目录
写在前面
本节主要介绍固定语法，包括：声明、注释、缩进、多行语句、保留字符和赋值等。
声明与注释
声明
要为源文件指定特定的字符编码格式，需要在文件的首行或第2行插入一行注释，称为编码声明。这一声明必须放在首行或第2行的原因是：注释行都是以#号开头的，不会被机器编译。编码声明虽然不属于注释行，但同样以#号开头，可能会被机器误识别为注释，只有放在首行或第2行的位置，才能被机器正常识别并编译。编码声明的格式如下。
通过这一声明，源文件中的所有字符都被当作coding指代的UTF-8编码对待。
# -*- coding: utf-8 -*-编写Python脚本时，除声明编码格式外，常常也会加上一个路径声明。路径声明的格式如下。
# !/usr/bin/Pytho路径声明指出了系统执行py文件时，调用的是/usr/bin下的Python解释器。路径声明一般放在脚本首行。
注释
单行注释以#号开头，#号后到换行前之间的所有字符都是注释部分；
多行注释同样可以使用#号，在每一行前都需要加上#号。使用#号进行多行注释；
通过3个单引号（′′′）或3个双引号（″″″）将注释对象括起来。使用引号进行多行注释时，需要保证前后使用的引号类型一致。
缩进与多行语句
缩进
代码行首的空白称为缩进，可用4个空格或制表符创建。Python的一大特色就是用缩进的方式标识代码结构，而Java和C++等语言则使用大括号{}。Python使用缩进标识代码结构的方式使得代码更加简洁优雅。
使用缩进方式标识代码结构时，同一代码块内的语句必须有相同的缩进空格数，否则就会出错。
缩进的长度没有硬性要求，保持同层次结构一致即可，推荐使用4个空格进行缩进。
正确的缩进方式：
In[1]: # 比较两个数字对于π的精度, 保持缩进一致
pie = 3.1415
pie 1 = 3.14
同一代码块内各行缩进空格数目相同, 观察输出结果
if pie > pie1:
print('π取pie更精确')
elif pie == pie1:
print('π取pie或pie1一样精确')
else:
print('π取pie1更精确')
Out[1]: π取pie更精确 缩进空格数不一致，会导致代码运行出错，
In[2]: # 比较两个数字对于π的精度, 使用不一致的缩进
pie = 3.1415
pie 1 = 3.14
# 内容与代码清单2-1相同, 缩进不对齐, 观察输出结果
if pie > pie1:
print('π取pie更精确')
elif Pie == pie:
print('π取pie或pie1一样精确')
else:
print('π取pie1更精确')
Out[2]: File "<ipython-input-33-1620b8ac3a51>", line 10
print('π取pie1更精确')
^
IndentationError: expected an indented block多行语句
编写代码时，通常应在一行内完成一条语句，但太长的语句显得冗长，可读性差。用反斜杠（\）可以实现长语句的换行，且不会被机器识别成多个语句
长语句换行：
In[3]: # 给出3种水果的价格, 计算总价
apple_price, banana_price, pear_price = 1, 1.5, 0.5
用反斜杠实现长语句换行
total_price = apple_price + \
banana_price + \
pear_price
print('total_price =', total_price)
Out[3]: total_price = 3.0 需要注意，在[]、{}、()等不同括号内，多行语句换行时不需要使用反斜杠（\），直接换行即可，
逗号换行：
In[4]: # 方括号内, 在逗号后直接换行
total_price = sum([apple_price,
banana_price,
pear_price])
print('total_price =', total_price)
Out[4]: total_price = 3.0 除了将一个语句拆分为多行外，Python也支持在一行中实现多个语句，这通常只用于多个短语句。在一行中实现多个语句需要使用分号（;）将短语句隔离，
分号隔离：
In[5]: # 给出3种水果的价格, 计算总价
apple_price = 1; banana_price = 1.5; pear_price = 0.5
total_price = apple_price + banana_price + pear_price
print('total_price =', total_price)
Out[5]: total_price = 3.0 保留字符与赋值
保留字符
Python中的标识符是指变量、函数、类、模块及其他对象的名字，可以包含字母、数字和下划线（_），但必须以非数字字符开始。特殊符号，如$、%、@等，不能用在标识符中。标识符对大小写敏感，比如“UFO”和“ufo”就是两 个不同的对象。
保留字符清单：
'False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'
In[6]: import keyword
print('Python中所有的保留字符为：\n', keyword.kwlist)
Out[6]: Python中所有的保留字符为：
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
In[7]: # class作为保留字符, 不能被当作普通标识符使用
class = 1
print(class)
Out[7]: File "<ipython-input-10-6950dab4b4c2>", line 1
class = 1
^
yntaxError: invalid syntax 赋值
Python中的赋值方式有4种，除最基本的赋值形式外，还有序列赋值、链接赋值和增量赋值等方式。
基本的赋值
赋值的最基本形式是以等号（=）为连接，将要赋值的变量放在等号左侧，将要赋给的值放在等号右侧
赋值的基本形式：
In[8]: # 使用等号直接给num_int赋一个整数值
num_int = 1
print('使用等号创建的整数为：', num_int)
Out[8]: 使用等号创建的整数为： 1
In[9]: # 使用等号直接给num_float赋一个浮点数值
num_float = 9.9
print('使用等号创建的浮点数为：', num_float)
Out[9]: 使用等号创建的浮点数为： 9.9
In[10]: # 使用等号直接给string赋一个字符串
string = 'python'
print('使用等号创建的字符串为：', string)
Out[10]: 使用等号创建的字符串为： python 序列赋值
序列赋值的基本形式是将多个变量排列成变量序列，变量之间使用逗号相连，使用等号作为赋值符号，后接值序列，值之间用逗号相连。序列赋值在变量序列与值序列之间建立了依次映射的关系。
序列赋值：
In[11]: # 序列赋值可给变量赋值多种数据类型
num_int, string, list1 = 123, 'str', [4,6]
print('赋值创建的多种数据类型为：', num_int, string, list1)
Out[11]: 赋值创建的多种数据类型为： 123 str [4,6]
In[12]: # 序列赋值可给变量赋值已赋值的变量
um1, num2, num3 = 7, 8, 9
num_int1, num_int2, num_int3 = num1, num2, num3
print('变量赋值为已赋值变量结果为：', num_int1, num_int2, num_int3)
Out[12]: 变量赋值为已赋值变量结果为： 7 8 9 链接赋值
链接赋值的基本形式是将多个变量用等号相连，在末个变量后用等号连接一个赋值。链接赋值只适用于给多个变量赋予同一值的情况，又称为多目标赋值
链接赋值：
In[13]: str1 = str2 = str3 = 'STR'
print('str1, str2, str3分别为：', str1, str2, str3)
Out[13]: str1, str2, str3分别为： STR STR STR
In[14]: print('str1, str2, str3的内存地址分别为：', id(str1), id(str2), id(str3))
Out[14]: str1, str2, str3的内存地址分别为： 151371368 151371368 151371368
In[15]: print('str1, str2, str3是否等价：', str1 is str2 is str3)
Out[15]: str1, str2, str3是否等价： True增量赋值
又称为增强赋值，其基本形式是将原始赋值语句改写，去掉赋值符号右侧变量，将赋值符号右侧运算符挪至赋值符号左侧，形成新的运算式。增量赋值需要通过赋值运算符实现，Python的赋值运算符将在2.2.2节介绍。增量赋值是赋值运算式的“增量写法”，通过声明变量、增量方式和增量数值完成赋值（如运算式“x*=100”，其变量是x，增量方式是*，增量数值是100）。
增量赋值的优势在于可以减少输入代码的工作量，
增量赋值：
In[16]: x=100
x+=10
print('x+=10等价于x=x+10,其值为：',x)
Out[16]: x+=10等价于x=x+10,其值为：110运算符
Python提供了算术运算符、赋值运算符、比较运算符、逻辑运算符、位运算符、身份运算符和成员运算符7类运算符
算数运算符
算术运算结果的数字类型与运算数的类型有关。进行除法（/）运算时，不管商为整数还是浮点数，运算结果始终为浮点数。要得到整型的商，需要用双斜杠（//）做整除，且除数必须是整型的。对于其他的运算，只要任一运算数为浮点数，运算结果就是浮点数。
算术运算：
In[1]: num_int = 4
num_float = 4.0
print('整数与浮点数的和为：', num_int + num_float)
Out[1]: 整数与浮点数的和为： 8.0
In[2]: print('整数与浮点数的差为：', num_int - num_float)
Out[2]: 整数与浮点数的差为： 0.0
In[3]: print('整数与浮点数的积为：', num_int * num_float)
Out[3]: 整数与浮点数的积为： 16.0
In[4]: print('浮点数与整数的商为：', num_float / num_int)
Out[4]: 浮点数与整数的商为： 1.0
In[5]: print('浮点数对整数取模结果为：', num_float % num_int)
Out[5]: 浮点数对整数取模结果为： 0.0
In[6]: print('浮点数的整数次幂为：', num_float ** num_int)
Out[6]: 浮点数的整数次幂为： 256.0 赋值运算符
赋值运算符用于变量的赋值和更新。Python的赋值运算符除基础赋值运算符（=）外，还包括加法赋值运算符、减法赋值运算符等。严格地说，除基础赋值运算符外，其他都属于特殊的赋值运算符。
赋值运算
In[7]: num_int1 = 4
print('赋值后num_int1为：', num_int1)
Out[7]: 赋值后num_int1为： 4
In[8]: num_int1 = 4 + 6
print('赋值后num_int1为：', num_int1)
Out[8]: 赋值后num_int1为： 10
In[9]: num_int1 = 4 * 2
print('赋值后num_int1为：', num_int1)
Out[9]: 赋值后num_int1为： 8
In[10]: num_int1 = 4 / 2
print('赋值后num_int1为：', num_int1)
Out[10]: 赋值后num_int1为： 2.0
In[11]: num_int1 = 4 % 2
print('赋值后num_int1为：', num_int1)
Out[11]: 赋值后num_int1为： 0
In[12]: num_int1 = 4 ** 2
print('赋值后num_int1为：', num_int1)
Out[12]: 赋值后num_int1为： 16 比较运算符
比较运算符也可用于字符之间的比较。Python中的字符使用ASCII编码，每个字符都有属于自己的ASCII码，字符比较的本质是字符ASCII码的比较。
比较运算
In[13]: num_int = 4
num_float = 4.0
print('num_int与num_float是否相等：', num_int == num_float)
Out[13]: num_int与num_float是否相等： True
In[14]: print('num_int与num_float是否不相等：', num_int != num_float)
Out[14]: num_int与num_float是否不等： False
In[15]: print('num_int是否大于num_float：', num_int > num_float)
Out[15]: num_int是否大于num_float： False
In[16]: print('num_int是否小于num_float：', num_int < num_float)
Out[16]: num_int是否小于num_float： False
In[17]: print('num_int是否大于等于numfloat：', num_int >= num_float)
Out[17]: num_int是否大于等于numfloat： True
In[18]: print('num_int是否小于等于num_float：', num_int <= num_float)
Out[18]: num_int是否小于等于num_float： True 逻辑运算符
逻辑运算即判断事物之间的“与”“或”“非”关系，Python中的逻辑运算符包含and、or、not，
逻辑运算
In[19]: num_bool1 = False
num_bool2 = True
print('num_bool1 and num_bool2返回值为：', num_bool1 and num_bool2)
Out[19]: num_bool1 and num_bool2返回值为： False
In[20]: print('num_bool1 or num_bool2返回值为：', num_bool1 or num_bool2)
Out[20]: num_bool1 or num_bool2返回值为： True
In[21]: print('not num_bool2的返回值为：', not (num_bool2))
Out[21]: not num_bool2的返回值为： False 按位运算符
十进制数被人们广泛使用，但对于计算机而言，二进制数反而是更重要的，计算机的一切计算都建立在二进制数计算的基础上。按位运算是一种将十进制数转为二进制数再进行运算的过程。
按位运算
In[22]: num_int1 = 15 # 15 = 00001111
num_int2 = 23 # 23 = 00010111
按位与, num_int1 & num_int2 = 00000111
print('num_int1按位与num_int2结果为：', num_int1 & num_int2)
Out[22]: num_int1按位与num_int2结果为： 7
In[23]: # 按位或, num_int1 | num_int2 = 00011111
print('num_int1按位或num_int2结果为：', num_int1 | num_int2)
Out[23]: num_int1按位或num_int2结果为： 31
In[24]: # 按位异或, num_int1 ^ num_int2 = 00011000
print('num_int1按位异或num_int2结果为：', num_int1 ^ num_int2)
Out[24]: num_int1按位异或num_int2结果为： 24
In[25]: # 按位取反, ~ num_int1 = 11110000
print('num_int1按位取反结果为：', ~ num_int1)
Out[25]: num_int1按位取反结果为： -16
In[26]: # 左移动两位, num_int1 << 2 = 00111100
print('num_int1左移动两位结果为：', num_int1 << 2)
Out[26]: num_int1左移动两位结果为： 60
In[27]: # 右移动两位, num_int1 >> 2 = 00000011
print('num_int1右移动两位结果为：', num_int1 >> 2)
Out[27]: num_int1右移动两位结果为： 3身份运算符
身份运算符用于比较两个对象的储存单位
身份运算符
In[28]: num_int1 = 15
num_int3 = 15
print('num_int1与num_int3储存单位是否相同：', num_int1 is num_int3)
Out[28]: num_int1与num_int3储存单位是否相同： True
In[29]: num_int2 = 15.0
print('num_int1与num_int2储存单位是否相同：', num_int1 is num_int2)
Out[29]: num_int1与num_int2储存单位是否相同： False
In[30]: # 如果储存单位相同就返回True, 否则返回False
print('num_int1与num_int3储存单位是否不同：', num_int1 is not num_int3)
Out[30]: num_int1与num_int3储存单位是否不同： False
In[31]: print('num_int1与num_int2储存单位是否不同：', num_int1 is not num_int2)
Out[31]: num_int1与num_int2储存单位是否不同： True 在身份运算中，内存地址相同的两个变量进行is运算时，返回True；内存地址不同的两个变量进行is not运算时，返回True。当a、b获取到一样的值时，两个变量就获取同样的内存地址
成员运算符
成员运算符的作用是判断某个指定值是否存在某一序列中，包括字符串、列表和元组，
成员运算符
In[32]: num_int1 = 15
ist2 = [1, 'apple', 15]
print('num_int1是否在list2中：', num_int1 in list2)
Out[32]: num_int1是否在list2中： True
In[33]: array = ('orange', 6, 15)
print('num_int1是否不在array中：', num_int1 not in array)
Out[33]: num_int1是否不在array中： False运算符优先级
In[34]: # 先执行乘除法运算, 再执行加减法运算
print('num_float + num_int1 / num_int3 =', num_float + num_int1 / num_int3)
Out[34]: num_float + num_int1 / num_int3 = 5.0
In[35]: # 先执行加减法运算, 再执行比较运算
print('num_int1 - num_int2 > num_int1 - num_int3：',
num_int1 - num_int2 > num_int1 - num_int3)
Out[35]: num_int1 - num_int2 > num_int1 - num_int3： False
In[36]: # 先执行加减法运算, 再做身份判断
print('num_int1 - num_int3 + num_int1 is num_int1：',
num_int1 - num_int3 + num_int1 is num_int1)
Out[36]: num_int1 - num_int3 + num_int1 is num_int1： True
In[37]: # 先执行指数运算, 再执行减法运算, 最后做身份判断
print('num_float ** 2 - 1 is not num_int2：',
num_float ** 2 - 1 is not num_int2)
Out[37]: num_float ** 2 - 1 is not num_int2： True数据类型
Python中的常用数据量类型有6种：number、str、list、tuple、dict和set。其中，number和str属于基础数据类型，而list、tuple、dict和sets属于复合数据类型。
基础数据类型
1.number
number又称数字，是专门用于储存数值的数据类型，具有不可改变性。数据的不可改变性意味着：每改变一个数据的类型，计算机就分配内存空间以创建新的对象，解释器则基于数据的类型分配指定的内存，决定什么样的数据可以被储存在内存中。要“改变”不可改变的数据类型，只能通过创造新变量的间接方式。number既是复合型数据中的基本元素，也是数学计算的基本元素，计算机的一切数学计算工作都离不开它。
int只有整数部分，即整型数。int仅表示广为使用的十进制整数，如果需要用到二进制数、八进制数和十六进制数，需要分别通过bin函数、oct函数和hex函数进行创建或转换。在Python 2中，用long表示长整型数，其特征是以L为后缀。长整型数和短整型数同属于整数，区别在于：短整型数的范围是[-2417483648，2417483647]，长整型数的范围是[-2^{63}，2^{63}-1]。Python 3不再保留长整型数，以int统一表示整数。
float是既有整数部分也有小数部分的数值类型，即浮点型数字。
complex是由实部（real）和虚部（imag）组成的数值类型，即复数。复数的实部和虚部都是浮点数。
bool表示布尔值，只有True（1）和False（0）两种取值。因为bool继承了int类型，所以True可以等价于数值1，False可以等价于数值0，bool值可以直接用于数学运算。
给变量指定一个数值时，number对象就被创建，并在内存中分配储存空间。通过type函数可以判断number对象的类型。
In[1]: num_int = 2
num_float = 4.5
num_bool = True
num_complex = 3j
print('数据类型分别为：\n', type(num_int),
dtype(num_float), type(num_bool), type(num_complex))
Out[1]: 数据类型分别为：
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>不同number类型通过函数可以互相转换，使用代表number类型的函数即可。也可以进行混合运算，运算时先自动转换成同一类型，然后再进行运算。转换遵守一定的方向：int向float转换，非complex向complex转换，
In[2]: # number类型转换
# 将float转换为int(直接去掉小数部分)
print('int(4.5)的结果为：', int(4.5))
Out[2]: int(4.5)的结果为： 4
In[3]: # 将int转换为float(直接增加小数部分)
print('float(4)的结果为：', float(4))
Out[3]: float(4)的结果为： 4.0
In[4]: # 将int和float转换为complex(直接增加虚部)
print('complex(4)和complex(4.5)的结果分别为：', complex(4), complex(4.5))
Out[4]: complex(4)和complex(4.5)的结果分别为： (4+0j) (4.5+0j)
In[5]: # 不同number类型混合运算
# int + float = float
print('整数和浮点数和的类型为：', type(124 + 4.0))
Out[5]: 整数和浮点数和的类型为： <class 'float'>
In[6]: # int + complex = complex
print('整数和复数和的类型为：', type(124 + 5.3j))
Out[6]: 整数和复数和的类型为： <class 'complex'>
In[7]: # float + complex = complex
print('浮点数和复数和的类型为：', type(4.0 + 5.3j))
Out[7]: 浮点数和复数和的类型为： <class 'complex'> 2.str
str又称为字符串，是存放着Unicode字符序列，用于表示文本的数据类型。str可以由任何字符构成，包括字母、数值、符号或标点符号以及它们的任意组合，如“Hello,word!”“1+1”等。与number相同的是，Python中的str也是不可变的，无法直接修改str中的某一位字符。
创建一个str，除字符外，还要在字符序列的首尾加上引号。使用单引号（'）、双引号（''）是等效的，但需要保证str两端的引号类型相同。如果要指定一个多行的str，则需要使用三引号（'''）。
str支持索引，索引一般按照“变量[下标]”和“变量[头下标:尾下标]”两种格式处理，其中的“变量[下标]”格式能够索引单个数值，“变量[头下标:尾下标]”格式能够进行切片（索引连续一片元素）。索引的具体规则如下：
1）下标为正数时，最小为0，表示第1位。下标最大为总字符数减1，表示最后一位。
2）下标为负数时，下标最小为总字符数的相反数，表示第1位。尾下标最大为-1，表示最后一位。
3）当进行切片时，索引从头下标位置字符开始，到尾下标位置前一位字符终止。
4）在一个索引式中，头下标与尾下标可以异号，但必须保证头下标字符位置在尾下标字符之前。
5）头下标留空，表示索引从第1个字符开始；尾下标留空，表示索引到最后一个字符结束。
除一般的索引格式外，str还支持按步长索引，即指定步长后，每隔固定的步数索引一次字符，其格式为“变量[头下标：尾下标：步长]”。此外，通过“变量[::-1]”这一索引式可以将整个str反向排序。
In[8]: string = "ilovePython"
# 下标为正数, 从第2个字符开始索引, 到第6个字符
print('ilovePython[1:5] =', string[1:5])
Out[8]: ilovePython[1:5] = love
In[9]: # 下标为负数, 从倒数第10个字符开始索引, 到倒数第6个字符
print('ilovePython[-10:-6] =', string[-10:-6])
Out[9]: ilovePython[-10:-6] = love
In[10]: # 头下标留空, 从第1个字符开始索引, 到第6个字符
print('ilovePython[:5] =', string[:5])
Out[10]: ilovePython[:5] = ilove
In[11]: # 尾下标留空, 从第2个字符开始索引, 到最后一个字符截止
print('ilovePython[1:] =', string[1:])
Out[11]: ilovePython[1:] = lovePython
In[12]: # 按步索引, 从第2个元素开始索引, 到第11个元素, 步距为3
print('ilovePython[1:10:3] =', string[1:10:3])
Out[12]: ilovePython[1:10:3] = let
In[13]: # 反向索引
print('ilovePython[::-1] =', string[::-1])
Out[13]: ilovePython[::-1] = nohtyPevoli str的索引方式对Python中其他支持索引的数据类型都具有参考价值。
尽管str不可变，但它其实有很好的可操作性。Python为str提供了极为丰富的内置方法，从而能实现多样化的操作。
str中的所有方法中部分是用于查询的，这些方法包括检查str中是否包含某个对象，是否只包含某个对象，某个对象是否在特定的位置，以及包含某个对象的个数。
str查询方法
In[14]: print('string中n的位置和总数分别为：', string.index('n'), string.count('n'))
Out[14]: string中n的位置和总数分别为： 10 1
In[15]: print('string中是否只包含字母：', string.isalpha())
Out[15]: string中是否只包含字母： True
In[16]: print('string中是否只包含数字：', string.isdigit())
Out[16]: string中是否只包含数字： False
In[17]: print('string是否以P开头：', string.startswith('P'))
Out[17]: string是否以P开头： False
In[18]: print('string是否是标题化的：', string.istitle())
Out[18]: string是否是标题化的： False str方法除查询外，还有对str进行改写等操作的方法。
改写主要有两种形式：
对str中的制表符、空格等符号进行增删，且改变str的总长度；
针对str中的字母，进行大小写调整或替换。
改写方法
In[19]: print('string左对齐填充至20个字符结果为：', string.ljust(20))
Out[19]: string左对齐填充至20个字符结果为： ilovePython
In[20]: print('string右对齐填充至20个字符结果为：', string.rjust(20))
Out[20]: string右对齐填充至20个字符结果为：ilovePython
In[21]: print('string大写化结果为：', string.upper())
Out[21]: string大写化结果为： ILOVEPYTHON
In[22]: print('string大小写置换结果为：', string.swapcase())
Out[22]: string大小写置换结果为： ILOVEpYTHON
In[23]: print('string中h替换为H结果为：', string.replace('h','H'))
Out[23]: string中h替换为H结果为： ilovePytHon 一些其他功能：
转义字符
除转义输出外，还可以使用+号与*号分别实现str的连接和重复操作。
In[28]: print ('\note\mybook') # str中包含\n, 识别为换行符并转义
Out[28]:
te\mybook
In[29]: print ('\title\mybook') # str中包含\t, 识别为制表符并转义
Out[29]: itle\mybook
In[30]: print (r'\note\mybook ') # 使用r制止转义
Out[30]: \note\mybook
In[31]: print (string + "TEST") # 输出连接的str
Out[31]: ilovePythonTEST
In[32]: print (string * 2) # 输出str两次
Out[32]: ilovePythonilovePython 复合数据类型
Python中的容器包含序列、映射和集合
序列，是数据对象的有序排列，数据对象作为序列中的元素被分配了一个位置编号（索引），序列相当于数学中数列的概念。Python中的序列包括str、list、tuple、Unicode字符串、buffer对象等，其中的str、list、tuple最为常用。
映射，是包含一组键（key）和值（value）以及映射关系的容器，字典（dictionary）是Python中唯一的映射类型，字典中的每个元素都存在相应的名称（称为键）与之一一对应。字典相当于由带有各自名称的元素组成的集合，与序列不同的是，字典中的元素并没有排列顺序。
集合，在集合类型数据中，集合中的元素不能重复出现，当中的元素是唯一的，元素间不存在排列顺序，Python中的集合相当于数学中的集合概念。集合类型包括可变集合（set）与不可变集合（frozenset）。
1.list
list又称为列表，属于序列类数据，是包含0或多个对象引用的有序序列。由于list中所有的数据项都是对象引用，因此list可以存放任意数据类型的数据项，既可以是int、float、str等这种基础数据类型，也可以是list、tuple、dict等这一类的复合数据类型。list是Python中最通用的复合数据类型。
list可以用方括号“[]”创建：空的方括号创建空的list；包含多个项的list可以在方括号中使用逗号分隔的项序列创建。也可以通过list函数创建，list函数最多接收一个参数；不带参数调用函数时返回空list；带参数时返回参数的浅拷贝（在有指针的情况下，浅拷贝只是增加了一个指针，指向已经存在的内存）；对复杂参数（非基本元素，如复合数据类型）则尝试将给出的对象转换为list。
In[33]: # 使用方括号创建一个非空list
sist1 = ['runoob', 786, 2.23, 'john']
print('方括号建立的列表为：', list1)
Out[33]: 方括号建立的列表为： ['runoob', 786, 2.23, 'john']
In[34]: #建立元组
tuple1 = (123, 'xyz', 'zara', 'abc')
list2 = list(tuple1)
print('元组转换成列表结果为：', list2)
Out[34]: 元组转换成列表结果为： [123, 'xyz', 'zara', 'abc']
In[35]: # list函数将str拆开, 作为新list中的元素
list3 = list('china')
print('字符串转换成列表结果为：', list3)
Out[35]: 字符串转换成列表结果为： ['c', 'h', 'i', 'n', 'a'] list基本操作
In[36]: print('列表按指定长度索引结果为：', list3[-4:-2])
Out[36]: 列表按指定长度索引结果为： ['h', 'i']
In[37]: print('列表按步长索引结果为：', list3[0::2])
Out[37]: 列表按步长索引结果为： ['c', 'i', 'a']
In[38]: list1[2] = 666
print('列表替换结果为：', list1)
Out[38]: 列表替换结果为： ['runoob', 786, 666, 'john']
In[39]: print('list1和list2用+连接结果为：', list1 + list2)
Out[39]: list1和list2用+连接结果为： ['runoob', 786, 666, 'john', 123, 'xyz', 'zara', 'abc']
In[40]: print('列表通过*重复结果为：', list1 * 2)
Out[40]: 列表通过*重复结果为： ['runoob', 786, 666, 'john', 'runoob', 786, 666, 'john']Python为list提供了一些内置方法，可以实现list的查询、增删和排序等功能
In[41]: print('list3中a出现的次数：', list3.count('a'), '\n',
'list3中a首次出现的位置：', list3.index('a'))
Out[41]: list3中a出现的次数： 1
list3中a首次出现的位置： 4
In[42]: list3.insert(0,'g')
list1.append('新增')
list2.extend(list3)
print('在列表指定位置插入元素：', list3, '\n',
'在列表末尾新增元素：', list1, '\n',
'将list3扩展至list2：', list2)
Out[42]: 在列表指定位置插入元素： ['g', 'c', 'h', 'i', 'n', 'a']
列表末尾新增元素： ['runoob', 786, 666, 'john', '新增']
将list3扩展至list2： [123, 'xyz', 'zara', 'abc', 'g', 'c', 'h', 'i', 'n', 'a']
In[43]: list3.pop(0)
list1.remove('新增')
print('使用pop删除指定位置的元素：', list3, '\n',
'使用remove删除指定元素：', list1)
Out[43]: 使用pop删除指定位置的元素： ['c', 'h', 'i', 'n', 'a']
使用remove删除指定元素： ['runoob', 786, 666, 'john']
In[44]: list2.pop(0)
list2.sort()
list3.reverse()
print('列表排序：', list2, '\n',
'列表反向排序：', list3)
Out[44]: 列表排序： ['a', 'abc', 'c', 'g', 'h', 'i', 'n', 'xyz', 'zara']
列表反向排序： ['a', 'n', 'i', 'h', 'c'] 2.tuple
tuple又称元组，与list同属于序列类数据，是包含0个或多个对象引用的有序序列。与list不同的是，tuple是不可更改的数据类型。
tuple可以用圆括号()创建：空的圆括号创建空的tuple；包含一个或多个项的tuple可以使用逗号分隔开元素；如果tuple内只包含一个元素，需要在元素后加上逗号予以区分。有时，tuple必须被包含在圆括号中以避免语义二义性。例如，要将tuple(1,2,3)传递给一个函数，应该写成function((1,2,3))的形式，以免被识别成“1,2,3”这3个数字变量。
创建tuple
In[45]: # 使用圆括号创建tuple
tup1 = ('Google', 'Runoob')
print('查看tup1类型：', type(tup1), '\n',
'查看tup1：', tup1)
Out[45]: 查看tup1类型： <class 'tuple'>
查看tup1： ('Google', 'Runoob')
In[46]: # 不加括号创建tuple
tup2 = "a", "b", "c", "d"
print('查看tup2：', tup2, '\n',
'查看tup2类型：', type(tup2))
Out[46]: 查看tup2： ('a', 'b', 'c', 'd')
查看tup2类型： <class 'tuple'>
In[47]: # 将['a','b','c']转换成tuple
tup3 = tuple(['x','y','z'])
print('查看tup3：', tup3, '\n',
'查看tup3类型：', type(tup3))
Out[47]: 查看tup3： ('x', 'y', 'z')
查看tup3类型： <class 'tuple'>
In[48]: # 单个数字元素加逗号, 变量是tuple
tup4 = (50,)
# 单个数字元素无逗号, 变量是int
tup5 = (50)
print('tup4和tup5的类型分别为：', type(tup4), type(tup5))
Out[48]: tup4和tup5的类型分别为： <class 'tuple'> <class 'int'> tuple支持索引，其索引方式与str、list类似。与list相同的是，tuple也可以进行连接、重复操作；与list不同的是，tuple中的元素无法做增删操作，只能使用del函数删除整个tuple。
In[49]: print('tup2中第3元素为：', tup2[2])
print('tup2中第1个到倒数第2个元素为：', tup2[:-1])
Out[49]: tup2中第3元素为： c
tup2中第1个到倒数第2个元素为： ('a', 'b', 'c')
In[50]: print('连接两个元组结果为：', tup1 + tup2)
Out[50]: 连接两个元组结果为： ('Google', 'Runoob', 'a', 'b', 'c', 'd')
In[51]: print('元组重复输出结果为：', tup3 * 2)
Out[51]: 元组重复输出结果为： ('x', 'y', 'z', 'x', 'y', 'z')Python为tuple提供的内置方法较少，主要用于查询
3.dict
dict又称字典，属于映射类数据。dict通过键而不是位置来索引。键是不可变对象（如number、str、tuple）的对象引用，值是可以指向任意类型对象的对象引用。dict是Python中唯一一种映射数据类型，具有可变性，dict的长度可以增大或减小，如同list一样。dict的值可以无限制地取任何Python对象，既可以是Python内置的标准数据，也可以是用户定义的。同一个键不允许出现两次，创建dict时如果同一个键被赋值两次，只有后一个值会被记住。键固定不变，所以只能用number、str或tuple充当。注意，可变的数据类型不能充当dict中的键。
dict可以用花括号{}创建：使用空的花括号创建空的dict；非空的花括号包含一个或多个逗号分隔的项，每个项包含一个键、一个冒号以及一个值。通过dict函数也可以创建dict：不带参数时返回一个空的dict；带一个映射类型参数时返回以该参数为基础的dict，当参数本身为dict时返回该参数的浅拷贝；也可以使用序列型参数，前提是序列中的每个项是包含两个对象的序列，第1个作为键，第2个作为值。创建dict
创建dict
In[54]: # 使用花括号创建空dict, 更新键值对
dict1 = {}
dict1['one'] = "This is 1"
dict1['two'] = "This is 2"
print('查看字典：', dict1)
Out[54]: 查看字典： {'one': 'This is 1', 'two': 'This is 2'}
In[55]: # 使用dict函数创建dict, 指定键值对
dict2 = dict(name='小明', height=187)
print('查看字典：', dict2)
Out[55]: 查看字典： {'name': '小明', 'height': 187} dict的主要索引方式是通过键索引值，这与str等变量截然不同。通过dict的索引功能，可以实现dict的查改增删，且不需要用到Python提供的内置方法，
基本操作
In[56]: print('通过键索引字典元素：', dict1['one'])
Out[56]: 通过键索引字典元素： This is 1
In[57]: dict1['one'] = 'this is 1'
print('以键改字典元素值：', dict1)
Out[57]: 以键改字典元素值： {'one': 'this is 1', 'two': 'This is 2'}
In[58]: dict1[3] = 'This is 3'
print('更新后的字典为：', dict1)
Out[58]: 更新后的字典为： {'one': 'this is 1', 'two': 'This is 2', 3: 'This is 3'}
In[59]: del dict1[3]
print('删除键3后的字典为：', dict1)
Out[59]: 删除键3后的字典为： {'one': 'this is 1', 'two': 'This is 2'} 
常用操作
In[60]: print('输出dict1中所有的键值对：', dict1.items(), '\n',
'输出dict1中所有的键：', dict1.keys(), '\n',
'输出dict1中所有的值：', dict1.values())
Out[60]: 输出dict1中所有的键值对： dict_items([('one', 'this is 1'), ('two', 'This is 2')])
输出dict1中所有的键： dict_keys(['one', 'two'])
输出dict1中所有的值： dict_values(['this is 1', 'This is 2'])
In[61]: print('与one对应的元素为：', dict1.get('one'), dict1.setdefault ('one'))
Out[61]: 与one对应的元素为： this is 1 this is 1
In[62]: dict1.update(dict2)
dict3 = dict2.copy()
print('将dict2中键值对更新到dict1中：', dict1, '\n',
'将dict2中内容复制到新的字典中：', dict3)
Out[62]: 将dict2中键值对更新到dict1中： {'one': 'this is 1', 'two': 'This is 2', 'name': '小明', 'height': 187}
将dict2中内容复制到新的字典中： {'name': '小明', 'height': 187}
In[63]: dict1.pop('name')
dict2.popitem()
dict3.clear()
print('删除dict1中name键对应的内容：', dict1, '\n',
'随机删除dict2中的一个键值对为：', dict2.popitem(), '\n',
'清空dict3中的内容：', dict3)
Out[63]: 删除dict1中name键对应的内容： {'one': 'this is 1', 'two': 'This is 2', 'height': 187}
随机删除dict2中的一个键值对为： ('name', '小明')
清空dict3中的内容： {} 4.set
Python中有两种内置集合类型：set（可变集合）和frozenset（不可变集合）。set是引用零个或多个对象的无序组合，所引用的对象都是不可变的，所有内置的固定数据类型（如float、frozenset、int、str、tuple）都是不可变的。以下所指的集合都是set。
set可以使用花括号{}或set函数创建。使用花括号{}创建集合时使用{}包裹一个或多个项，项与项间用“,”分割；空的set无法用{}创建。使用set函数创建set时，不带参数时返回空set；带一个参数时返回参数的浅拷贝；带多个参数时，则尝试将给定的对象转换为set，
创建set
In[64]: # 使用非空的{}创建set
set1 = {1, 2, 3}
print('set1的类型为：', type(set1))
Out[64]: set1的类型为： <class 'set'>
In[65]: # 创建一个空的set只能使用set函数
set2 = set()
print('查看set2：', set2, '\n',
'set2的类型为：', type(set2))
Out[65]: 查看set2： set()
set2的类型为： <class 'set'>
In[66]: # 将list、tuple转换为set
set3 = set([1,2,3])
set4 = set((1,2,3))
print('查看set3和set4：', set3, set4, '\n',
'set3和set4的类型分别为：', type(set3), type(set4))
Out[66]: 查看set3和set4： {1, 2, 3} {1, 2, 3}
set3和set4的类型分别为： <class 'set'> <class 'set'> set是可变的，但由于其中的项是无序的，因此没有索引的概念。set可变而无法索引，这使得它无法进行查询和修改元素的操作，但仍支持元素的增删，并可以清空和拷贝。set的常用操作基本都需要通过内置方法，
常用方法
In[67]: set1.add('a')
print('add方法向set1中添加元素结果为：', set1)
Out[67]: add方法向set1中添加元素结果为： {1, 2, 3, 'a'}
In[68]: set1.pop()
print('pop方法删除set1中任意一个元素结果为：', set1)
Out[68]: pop方法删除set1中任意一个元素结果为： {2, 3, 'a'}
In[69]: set2.clear()
print('清除set2中内容结果为：', set2)
Out[69]: 清除set2中内容结果为： set() 
集合运算：
In[70]: print('set4是否为set1的子集：', set4 < set1)
Out[70]: set4是否为set1的子集： False
In[71]: print('set4和set1的并集为：', set4 | set1)
Out[71]: set4和set1的并集为： {1, 2, 3, 'a'}
In[72]: print('set4和set1的交集为：', set4 & set1)
Out[72]: set4和set1的交集为： {2, 3}
In[73]: print('set4和set1的差集为：', set4 - set1)
Out[73]: set4和set1的差集为： {1} Python I/O
I/O并不仅仅指信息键入和打印信息，还包括文件的输入输出。
input与print
1.input
input函数在用于交互式的信息键入时，相当于一个容器，用户从键盘输入的信息先存放在容器中，再被变量引用。
input函数可以接纳多种数据类型，包括number、str等基础类型，及list、tuple、dict、set等复合类型。使用input函数时，可以在括号内添加str以提示输入。需要注意的是，Python 3.x中的input函数将所有接收的数据都默认为str
输入不同数据类型
In[1]: # 输入一个数字, 由Python默认类型
number1 = input('请输入一个数字：')
Out[1]: 请输入一个数字：1
In[2]: # 输入一个str, 由Python默认类型
tr1 = input('请输入一个字符串：')
Out[2]: 请输入一个字符串：1
In[3]: # 输入一个数字, 并将其转换为int类型
number2 = int(input('请输入一个数字：'))
Out[3]: 请输入一个数字：123
In[4]: # 查看以上输入的输出结果类型
print('number1、str1和number2的类型分别为：\n',
type(number1), type(str1), type(number2))
Out[4]: number1、str1和number2的类型分别为：
<class 'str'> <class 'str'> <class 'int'> 在str1变量中，尽管输入的不是str，也被默认为str。要得到需要的数据类型，必须做类型转换。
2.print
In[5]: # print函数接收多个str
print('我', '爱', '中华')
Out5]: 我 爱 中华
In[6]: # print函数在打印前计算结果
print('100+200 =', 100 + 200)
Out[6]: 100+200 = 300 格式化输出是计算机输出中的一个重要概念，主要针对str。其运行机制为：使用占位符在str中进行占位，再用数值或字符替换占位符，重组str后输出。这种输出方法主要是为了方便修改语句，减少编写代码的工作量，并且包含自动取位、转换进制等功能。Python中的格式化输出方法有两种，即“%+格式符”的方法和format函数方法。
“%+格式符”的方法是一种较早的格式化输出方法，使用方式是在百分号（%）后加上相应的格式符以占位，再进行替换和输出。Python中的格式符
“%+格式符”格式化输出
In[7]: # 用%s、%d分别格式化字符串'Zara'和整数20
print("我的名字叫作%s, 已经%d岁了!"%('Zara',20))
Out[7]: 我的名字叫作Zara, 已经20岁了!
In[8]: # 用%d格式化16, 用%o将十进制整数16用八进制数表示
print("%d 的八进制是 %o"%(16,16))
Out[8]: 16 的八进制是 20
In[9]: # 用%.3f将整数转化为保留小数点后3位的float
print("23 转化为保留3位小数的浮点数%.3f"%(23))
Out[9]: 23转化为保留3位小数的浮点数23.000 文件I/O
1.open
内置函数open的作用是打开一个文件，创建一个file对象以进行调用。在打开文件的基础上，后续的文件读写操作才可以实现。open函数的基本语法格式如下：
open(filename, mode)filename表示包含要访问的文件名称。mode决定打开文件的模式，这个参数是非强制的，默认的文件访问模式为只读（r），其可取值如表2-22所示。
2.read
在Python中，读取文件的内容需要以只读的模式先打开一个文件，可以用open函数传入文件名和模式标识符，再用read函数读取文件中的内容。
read函数可以从打开的文件中一次性读取全部内容，内容被读取到内存并用一个str对象表示。read函数的基本语法格式如下：
f = open(filename, mode)
f.read(size)
size表示要从文件中读取的字节数，该方法从文件的开头开始读入，每调用一次就读取size个字节的内容。如果没有传入size，程序会尝试尽可能多地读取内容，一直到文件的末尾。
使用read函数读取test.txt文件，并打印
read函数读取test.txt文件
In[14]: # 以只读模式打开test.txt文件
data = open('../data/test.txt', 'r')
# 读取文件中的内容, 存到content变量中
content = data.read()
# 打印出content变量中包含的文本内容
print('该文本中的内容是：', content)
Out[14]: 该文本中的内容是： Hello World! 3.write
在Python中，写入文件和读出文件的操作方式是相似的：先调用open函数并传入标识符‘w’或‘wb’，再使用write函数进行写入。write函数的基本语法格式如下：
f = open(filename, mode)
f.write(str)
write函数写入文件
In[15]: # 打开一个文件
web = open('../tmp/web.txt', 'w')
# 转换内容, 写入文件
value = ('http://www.tipdm.org', 14)
str_value = str(value)
web.write(str_value)
web.close()
# 打开文本, 读取出写入的内容
web = open('../tmp/web.txt', 'r')
content = web.read()
print('该文本中的内容是：', content)
Out[15]: 该文本中的内容是： ('http://www.tipdm.org', 14) 4.close
close函数可以刷新缓存里任何还没写入的信息并关闭文件，关闭之后的文件便不能再进行写入。使用完文件后应该关闭，关闭文件的本质是使文件指针与文件脱离，关闭后不再能通过该指针对原来与其联系的文件进行操作。如果文件使用完后不关闭，文件对象会一直占用操作系统的资源，并且，操作系统同一时间能打开的文件数量是有限的。写入文件时，数据会占用操作系统的内存，待计算机空闲时再慢慢写入，不调用close函数的后果是数据可能只写一部分到磁盘中，其他的信息则丢失了。
fileObject.close()本节的各代码清单中，都需要在末尾使用close函数关闭文件，以保证信息的完整。
小结
Python可以实现快速开发，是最适合于机器学习的工具。本章介绍了利用Python进行编程的入门知识，主要内容如下：
1）固定语法主要介绍了Python的基本操作，包括声明、注释、缩进、多行语句、保留字符与赋值等。
2）运算符部分主要介绍了算术运算符、比较运算符、赋值运算符、按位运算符、逻辑运算符、成员运算符和身份运算符7类运算符的使用方法，并介绍了多个运算符时的优先级。
3）基础数据类型主要介绍了number和str两种数据类型，其中number包括int、float、bool、complex；str由引号标识，操作方式多样且灵活。
4）复合数据类型主要介绍了list、tuple、dict和set，需要注意各种数据类型之间的异同点，以及每种类型的基础操作。
5）交互式的输入操作主要介绍了基础I/O和文件读写。基础I/O部分说明了input函数的用法、输入数据类型和print函数的输出格式化。文件读写则说明了open、read、write、close四个函数分别实现打开、读取、写入、关闭操作。
1380
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
