编者按：本文节选自方巍著《Python数据挖掘与机器学习实战》一书中的部分章节。

2.1　搭建Python开发环境

Python可应用于多平台，包括Linux和Mac OSX。本节主要介绍如何在Windows平台搭建Python开发环境，以及运行和保存相应的Python程序。

2.1.1　安装Anaconda

Anaconda是Python的一个开源发行版本，主要面向科学计算，内含有诸多机器学习算法框架、图像处理模块及经典算法集成模块。Anaconda的主要优点是预装了很多第三方库，而且增加了conda install命令，除了使得安装新的package非常方便外，还自带了Spyder IDE和Jupyter Notebook等编译环境。

单击下载链接https://www.anaconda.com/download/，选择Windows Python 3.6版本进行下载并安装，如图2-1所示。

图2-1　安装Anaconda

安装时，需要选择安装类型。这里选择管理员权限，并且将路径自动加入到环境变量中，如图2-2所示。

图2-2　添加环境变量

单击Install按钮即可安装。安装完成后，在Windows搜索栏中输入cmd进入命令行模式，输入python，检验环境是否创建成功，如图2-3所示。

图2-3　检查环境是否创建成功

2.1.2　安装Spyder

Spyder是Python的作者为Python开发的一个简单的集成开发环境。和其他的Python开发环境相比，Spyder的最大优点就是模仿MATLAB的“工作空间”的功能，可以很方便地观察和修改数组的值。

在“开始”菜单中打开Anaconda3(64-bit)，单击Anaconda Navigator，进入集成环境。首先选择Environments，然后选择All，最后输入spyder，勾选spyder复选框进行安装即可，如图2-4所示。

图2-4　安装Spyder

此时在“开始”菜单中打开Anaconda3(64-bit)，单击Spyder，即可进入编辑环境。Spyder界面如图2-5所示。

图2-5　Spyder界面

2.1.3　运行和保存Python程序

如果程序员每次想用Python程序时都需要重新输入则费时费力，非常影响效率。当然，如果只是几十行的小程序，重写也是可行的，但对于一些大型的程序，其中可能包含有数十万行甚至更多的代码，想象一下，要把这么多的代码进行重写是多么的困难。幸运地是，程序员可以把程序保存起来，随时随地就可以使用。要保存一个新程序，选择File→New file命令，然后会出现一个空白窗口，在菜单条上会有“Untitled0.py”字样。在新窗口中输入下面的代码：

print("Hello World")

然后选择file→save as命令。当提示输入文件名时，输入hello.py，并把文件保存到桌面即可。不出问题的话，在键盘上按F5键，保存的程序就可以运行了，如图2-6所示。

图2-6　运行和保存程序

2.2　Python计算与变量

Python开发环境已经搭建完成，也知道如何运行和保存程序了，现在就可以使用它来编写自己的程序了。本节首先从一些基本的数学运算开始讲解，然后再使用变量进行稍复杂一些的计算。变量是程序中用来保存东西（如数值和矩阵等内容）的一种方式，它们能使程序更加简单明了。

2.2.1　用Python做简单的计算

首先，使用Python做数值计算。例如，想要得到两个数字乘积的结果，一般可能会用计算器来得到答案，比如计算9×8.46。那么如何用Python程序来运行这个计算呢？

为了清晰地显示代码，在这里暂时不使用Spyder作为编译环境，直接使用命令行窗口。步骤如下：

（1）单击“开始”按钮，输入cmd，进入命令行窗口。

（2）再输入python，然后按Enter键，即进入Python编辑环境。

（3）显示当前的Python版本。

命令行窗口如图2-7所示。

图2-7　Python的命令行窗口

命令行中显示了3个大于号“>>>”，这3个大于号叫做“提示符”。

在提示符后面输入算式：

>>> 9*8.46
76.14

注意：在Python里输入乘法运算时要使用星号“*”而不是乘号“×”。

这是一个非常简单的程序。在本书中，读者将会学到如何扩展这些想法，写出更有用的程序来。

2.2.2　Python的运算符

在Python中，可以做加、减、乘、除运算，以及其他的一些数学运算。Python中用来做数学运算的基本符号叫做“运算符”，这里罗列了几种最常见的运算符，如表2-1所示。

Python中用斜杠“/”来表示除法，因为这与写分数的方式相似。例如，a=20，b=10，在Python程序中计算a除以b，只要输入20/10，输出结果为2。要记住“斜杠”是顶部靠右的那个（顶部靠左的是反斜杠“\”)。“%”表示取模，即返回除法的余数，如a%b的输出结果是0。“”表示幂，即返回x的y次幂，ab是10的20次方，输出是100000000000000000000。

表2-1　Python的基本运算符

符号	运算
+	加
-	减
*	乘
/	除
%	取模
//	向下取整
**	幂

在Python编程语言中，使用括号来控制运算的先后顺序。任何用到运算符的都是一个“运算”。乘法和除法运算比加法和减法优先，也就是说它们先运算。换句话讲，如果在Python中输入一个算式，乘法或者除法的运算会在加法或减法之前运算。

提示：请记住乘法和除法总是在加法和减法之前运算，除非用括号来控制运算的顺序。

2.2.3　Python的变量

变量存储的是在内存中的值，这就意味着在创建变量时会在内存中开辟一个空间。基于变量的数据类型，解释器会分配指定的内存，并决定什么数据可以被存储在内存中。因此，变量可以指定不同的数据类型，可以存储整数、小数或字符。

Python中的变量赋值不需要类型声明。在内存中创建每个变量时包括了变量的标识、名称和数据这些信息。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。等号“=”用来给变量赋值，其运算符左边是一个变量名，右边是存储在变量中的值。例如：

counter = 1000                                                     #赋值整型变量
miles = 1000.0                                                     #浮点型
str = "Python"                                                     #字符串
print (counter)
print (miles)
print (str)

上例中，1000、1000.0和Python分别赋值给了counter、miles和str变量。

执行以上程序会输出如下结果：

1000
1000.0
Python

Python允许同时为多个变量赋值。例如：

a = b = c = 1000

上例中创建了一个整型对象，值为1000，a、b、c这3个变量被分配到相同的内存空间上。

也可以为多个对象指定多个变量，例如：

a, b, c = 1, 2, "abc"

上例中，将两个整型对象1和2分别分配给变量a和b，字符串对象abc分配给变量c。

在内存中存储的数据可以有多种类型。Python有5个标准的数据类型，分别是Numbers（数字）、String（字符串）、List（列表）、Tuple（元组）和Dictionary（字典）。下面将重点介绍后4种数据类型。

2.3　Python的字符串

字符串是Python中最常用的数据类型。可以使用引号（单引号或双引号）来创建字符串。创建字符串很简单，只要为变量分配一个值即可。例如：

str1 = 'Hello World!'
str2 = "Python"
print(str1)
print(str2)

输出结果为：

Hello World!
Python

Python不支持单字符类型，单字符在Python中也是作为一个字符串使用的。在Python中访问子字符串时，可以使用方括号“[]”来截取字符串，例如：

str1 = 'Hello World!'
str2 = "Python"
print ("str1[0]: ", str1[0])
print ("str2[1:5]: ", str2[1:5])

输出结果为：

str1[0]: H
str2[1:5]: ytho

也可以对已存在的字符串进行修改，并赋值给另一个变量，例如：

str1 = 'Hello '
str2 = 'world!'
str1 = str1+str2
print(str1)

输出结果为：

Hello world!

上面例子中“+”是字符串运算符。还有很多字符串运算符，如表2-2所示。

表2-2　字符串运算符

运算符	说明
+	字符串连接
*	重复输出字符串
[]	通过索引获取字符串中的字符
[ : ]	截取字符串中的一部分
in	如果字符串中包含给定的字符则返回 True
not in	如果字符串中不包含给定的字符则返回 True
%	格式字符串

这里给出一个简单的例子来实现这些字符串运算符。

a = "Hello"
b = "Python"
print ("a + b 输出结果：", a + b)
print ("a * 2 输出结果：", a * 2)
print ("a[1] 输出结果：", a[1])
print ("a[1:4] 输出结果：", a[1:4])
if( "H" in a) :
    print ("H 在变量 a 中")
else :
    print ("H 不在变量 a 中")
if( "N" not in a) :
    print ("N 不在变量 a 中")
else :
print ("N 在变量 a 中")

输出结果为：

a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
N 不在变量 a 中

Python支持格式化字符串的输出。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符“%s”的字符串中。在Python中，字符串格式化使用与C语言中printf，函数的语法一样。例如：

print ("My name is %s and age is %d!" % ('xiaoming', 20))

输出结果为：

My name is xiaoming and age is 20!

2.4　Python的列表

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字来表示它的位置（或叫做索引），第一个索引是0，第二个索引是1，依此类推。Python有6个序列的内置类型，但最常见的是列表和元组。

序列可以进行的操作包括索引、切片、加、乘和检查成员等。此外，Python已经内置了确定序列的长度及确定最大和最小的元素的方法。列表是最常用的Python数据类型，表现形式为一个方括号内包含若干数据项，各数据项之间以逗号分隔。

创建一个列表，列表的各数据项不需要具有相同的类型，只要把用逗号分隔的不同数据项使用方括号括起来即可。例如：

list1 = ['a', 'b', 10, 20]
list2 = [1, 2, 3, 4]
list3 = ["a", "b", "c"]

与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。可以使用下标索引来访问列表中的值，同样也可以使用方括号的形式截取字符，示例如下：

list1 = ['a', 'b', 10, 20]
list2 = [1, 2, 3, 4]
print ("list1[0]: ", list1[0])
print ("list2[1:4]: ", list2[1:4])

输出结果为：

list1[0]:  a
list2[1:4]:  [2, 3, 4]

可以对列表的数据项进行修改或更新，也可以使用append()方法添加列表项，示例如下：

list = []                                        #空列表
list.append('Hello')                             #使用append()添加元素
list.append('World!')
print (list)

输出结果为：

['Hello', 'World!']

可以使用del语句删除列表的元素，例如：

list1 = ['a', 'b', 10, 20]
print (list1)
del list1[2]
print ("删除后的输出为 : ")
print (list1)

输出结果为：

['a', 'b', 10, 20]
删除后的输出为 :
['a', 'b', 20]

Python列表操作符和字符串操作符有些是相似的，如“+”号用于组合列表，“*”号用于重复列表。如表2-3所示为常见的列表操作符。

表2-3　常见的列表操作符

操作符	说明
len 列表长度
+	组合
*	重复
in	元素是否存在于列表中
for	迭代

下面给出一个简单的例子来实现这些列表运算符。

list1 = [1,2,3]
list2 = [4,5,6]
print(len(list1))
print(list1+list2)
print(list1*3)
print(3 in list1)
for x in list1:
    print (x)

输出结果为：

3
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 1, 2, 3, 1, 2, 3]
True
1
2
3

2.5　Python的元组

Python的元组与列表类似，不同之处在于元组的元素不能修改；元组使用小括号，列表使用方括号。元组的创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。例如：

tup1 = ('a', 'b', 10, 20)
tup2 = (1, 2, 3, 4, 5 )
tup3 =("a", "b", "c", "d")
tup1 = ()                                                       #创建空元组

元组中只包含一个元素时，需要在元素后面添加逗号，例如：

tup1 = (50,)

元组与字符串类似，下标索引从0开始，可以进行截取、组合等。元组可以使用下标索引来访问元组中的值，例如：

tup1 = ('a', 'b', 10, 20)
tup2 = (1, 2, 3, 4, 5 )
print ("tup1[0]: ", tup1[0])
print ("tup2[1:4]: ", tup2[1:4])

输出结果为：

tup1[0]:  a
tup2[1:4]:  (2, 3, 4)

元组中的元素值是不允许修改的，但可以对元组进行连接组合，例如：

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

输出结果为：

(12, 34.56, 'abc', 'xyz')

元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组，例如：

tup1 = ('a', 'b', 10, 20)
print (tup)
del tup
print ("删除后的结果: ")
print (tup)

以上实例中，元组被删除后，输出变量会有异常信息，输出如下：

 ('a', 'b', 10, 20)
删除后的结果:
Traceback (most recent call last):
  File "F:/program/2.5.py", line 26, in <module>
    print (tup)
NameError: name 'tup' is not defined

与字符串一样，元组之间可以使用“+”号和“*”号进行运算。这就意味着它们可以组合和复制，运算后会生成一个新的元组。常见的元组运算符如表2-4所示。

表2-4　常见的元组运算符

运算符	说明
len	计算元素个数
+	连接
*	复制
in	元素是否存在
for	迭代

下面给出一个简单的例子来实现这些元组运算符。

tup1 = (1,2,3)
tup2 = (4,5,6)
print(len(tup1))
print(tup1+tup2)
print(tup1*3)
print(3 in tup1)　
for x in tup1:
    print (x)

输出结果为：

3
(1, 2, 3, 4, 5, 6)
(1, 2, 3, 1, 2, 3, 1, 2, 3)
True
1
2
3

2.6　Python的字典

字典是另一种可变容器模型，并且可存储任意类型的对象。

字典的每个键值对（key-value）用冒号分隔，每个键值对之间用逗号分隔，整个字典包括在花括号中，格式如下：

dict = {key1 : value1, key2 : value2 }

键一般是唯一的，如果重复，最后一个键值对就会替换前面的，值不需要唯一。例如：

dict = {'a': 1, 'b': 2, 'b': '3'}
print(dict['b'])
print(dict)

输出结果为：

3
{'a': 1, 'b': '3'}

值可以取任何数据类型，但键必须是不可变的，如字符串、数字或元组。这里给出一个简单的字典实例：

dict = {'Alice': '20', 'Beth': '21', 'Cecil': '22'}

也可如此创建字典：

dict1 = { 'abc':123}
dict2 = { 'abc': 123, 98: 37 }

如果要访问字典里的值，只要把相应的键放入熟悉的方括号中即可，例如：

dict = {'Name': 'xioaming', 'Age': 20, 'Class': 'First'}
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])

输出结果为：

dict['Name']:  xioaming
dict['Age']:  20

如果用字典里没有的键访问数据，则会输出错误，例如：

dict = {'Name': 'xioaming', 'Age': 20, 'Class': 'First'}
print ("dict[xiaowang']: ", dict['xiaowang'])

输出结果为：

Traceback (most recent call last):
  File "F:/program/2.6.py", line 19, in <module>
    print ("dict[xiaowang']: ", dict['xiaowang'])
KeyError: 'xiaowang'

向字典添加新内容的方法是增加新的键/值对，示例如下：

dict = {'Name': 'xioaming', 'Age': 20, 'Class': 'First'}
dict['Age'] = 22                        #修改年龄
dict['School'] = "NUIST"                 #添加新的键/值对
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

输出结果为：

dict['Age']:  22
dict['School']:  NUIST

在字典操作中，能删除单一的元素也能清空字典，删除一项只需要删除其键的内容。删除一个字典用del命令，示例如下：

dict = {'Name': 'xioaming', 'Age': 20, 'Class': 'First'}
del dict['Name']                     #删除键是'Name'的条目
dict.clear()                         #清空词典所有条目
del dict                            #删除词典
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

但这会引发一个异常，因为用del后字典不再存在：

Traceback (most recent call last):
  File "F:/program/DCGAN-tensorflow-master/2.6.py", line 34, in <module>
    print ("dict['Age']: ", dict['Age'])
TypeError: 'type' object is not subscriptable

图书简介：https://item.jd.com/12623592.html?dist=jd

相关阅读

Python数据挖掘与机器学习实战（一）：Python语言优势及开发工具

Python数据挖掘与机器学习实战（二）：Python语言简介

Python数据挖掘与机器学习实战（三）：网络爬虫原理与设计实现

Python数据挖掘与机器学习实战（四）：用 Python 实现多元线性回归

Python数据挖掘与机器学习实战（五）：基于线性回归的股票预测

创作场景

Python 数据挖掘与机器学习实战（二）：Python 语言简介