Python3 From Zero——{最初的意识：000～Initial consciousness『REVIEW』}

Posted 2020-08-05 纯原创，零转载

a、编码
默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串，也可以为源码文件指定不同的编码：# -*- coding: cp-1252 -*-

b、python保留字

保留字即关键字，我们不能把它们用作任何标识符名称。Python的标准库提供了一个keyword module，可以输出当前版本的所有关键字：

>>> import keyword 
>>> keyword.kwlist [‘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‘]

c、Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠(\)来实现多行语句，例如：

total = item_one + item_two + item_three

d、在 [], {}, 或 () 中的多行语句，不需要使用反斜杠(\)，例如： 

total = [‘item_one‘, ‘item_two‘, ‘item_three‘,
‘item_four‘, ‘item_five‘]

e、python中单引号和双引号使用完全相同

f、自然字符串，通过在字符串前加r或R，如 r"this is a line with \n" 则\n会显示，并不是换行
g、按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string
h、使用三引号(‘‘‘或""")可以指定一个多行字符串，空行也是程序代码的一部分，Python可以在同一行中使用多条语句，语句之间使用分号(;)分割
i、缩进相同的一组语句构成一个代码块，我们称之代码组，像if、while、def和class这样的复合语句，首行以关键字开始，以冒号 : 结束，该行之后的一行或多行代码构成代码组，首行及后面的代码组合称为一个子句(clause)
j、Python可以同时为多个变量赋值：　　a = b = c = 1k、Python3 中有六个标准的数据类型：Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典），Python3中支持的Number类型有int、float、bool、complex

l、内置的type()函数可以用来查询变量所指的对象类型或归属的类，Python3中，True和False的值是1和0，它们可以和数字相加，Python可以同时为多个变量赋值，如a, b = 1, 2，数值的除法（/）总是返回一个浮点数，要获取整数使用//操作符，即floor除法，在混合计算时，Python会把整型转换成为浮点数

m、索引值以 0 为开始值，-1 为从末尾的开始位置，加号 (+) 是字符串的连接符， 星号 (*) 表示复制当前字符串，紧跟的数字为复制的次数；Python 没有单独的字符类型，一个字符就是长度为1的字符串

n、列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（嵌套），元组、集合、字典等切可嵌套；与Python字符串不一样的是，列表中的元素是可以改变的：List写在方括号之间，元素用逗号隔开，和字符串一样，list可以被索引和切片，List可以使用+操作符进行拼接，List中的元素是可以改变的

o、元组（tuple）与列表类似，不同之处在于元组的元素不能修改，元组写在小括号　()　里，元素之间用逗号隔开，元组中的元素类型也可以不相同，构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：tup1 = () # 空元组；tup2 = (20,) # 一个元素，需要在元素后添加逗号；与字符串一样，元组的元素不能修改；元组也可以被索引和切片；元组tuple的标识符是“,”，不是“()”，如 test_tuple=1, 2, 4 可以声明一个tuple；元组也可以使用+操作符进行拼接，从而生成新的Tuple

p、集合（set）是一个无序不重复元素的序列，基本功能是进行成员关系测试和删除重复元素；可以使用大括号 {} 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 {}，因为 {} 是用来创建一个空字典，set可以进行集合运算:|并集 &交集 -差集 ^异或集

a = set(‘abracadabra‘)
b = set(‘alacazam‘)
print(a - b) # a和b的差集
print(a | b) # a和b的并集
print(a & b) # a和b的交集
print(a ^ b) # a和b中不同时存在的元素 

q、Dictionary（字典）是Python中另一个非常有用的内置数据类型，列表是有序的对象结合，字典是无序的对象集合，两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取；字典是一种映射类型，字典用"{}"标识，它是一个无序的键(key) : 值(value)对集合，键(key)必须使用不可变类型，因此列表不可用作dict的key，在同一个字典中，键(key)必须是唯一的；字典类型也有一些内置的函数，例如clear()、keys()、values()、items()等；注意：字典是一种映射类型，它的元素是键值对，字典的关键字必须为不可变类型，且不能重复，创建空字典使用 { }

r、Python数据类型转换，只需要将数据类型作为函数名即可，以下几个内置的函数可以执行数据类型之间的转换，这些函数返回一个新的对象，表示转换的值：int(x [,base])，将x转换为一个整数，若带有base部分，则x必须是‘x’字符串形式，base可以为2、8、10、16，表示将x按指定的进制对待，然后最终输出对应的十进制结果；float(x)，将x转换到一个浮点数；complex(real [,imag])创建一个复数，其中real代表实数部分，imag代表虚数部分；str(x)将对象 x 转换为字符串；repr(x)将对象 x 转换为表达式字符串，通常情况下x = eval(repr(x));tuple(s)将序列 s 转换为一个元组；list(s)将序列 s 转换为一个列表；set(s)转换为可变集合；dict(d)将子项符合key：value规则的嵌套队列类型转换为dict

s、要确保对模块, 函数, 方法和行内注释使用正确的风格，Python中的注释有单行注释和多行注释，Python中单行注释以#开头，例如：

# 这是一个注释
print("Hello, World!") 

多行注释用三个单引号（‘‘‘）或者三个双引号（"""）将注释括起来，例如:

#!/usr/bin/python3 
‘‘‘
这是多行注释，用三个单引号
这是多行注释，用三个单引号 
这是多行注释，用三个单引号
‘‘‘
print("Hello, World!")

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符，若要输出原始字符，可在‘‘‘之前添加r或R；在Python3中，所有的字符串都是Unicode字符串

t、Python位运算符：按位运算符是把数字看作二进制来进行计算的

&    按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
|    按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1
^    按位异或运算符：当两对应的二进位相异时，结果为1
~    按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1
<<    左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0
>>    右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数
注意：负整数的二进制表示法！因为整型数字占用4byte，即32位(此为C语言定义，不同的语言对int的定义会有差别，可能存在long int,long long int等)，能表示的最大数字即是32位1，若再加1，即再次回到起点0，由此可得出二进制整数取负的方法：即所有二进制位取反（此时称为“反码”），然后在末位加1（此时称为“补码”），原理上最终要保证两者之和为0，符合正负数运算法则

u、Python语言支持逻辑运算符 and, or, not；员运算符 in, not in；身份运算符 is, is not，用于判断两个标识符是不是引用自一个对象

Python 支持三种不同的数值类型：整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型；浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 10^2 = 250）;复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

v、math模块基本数学函数：

#import math
函数 返回值 ( 描述 )
abs(x) 返回数字的绝对值，如abs(-10) 返回 10
ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5
floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4
max(x1, x2,...) 返回给定参数的最大值，参数可以为序列。
min(x1, x2,...) 返回给定参数的最小值，参数可以为序列。
round(x [,n]) 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x) 返回数字x的平方根，不能为负数，取负数的平方根用cmath.sqrt()

w、随机数函数（示例：random模块）:用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性；random.choice(range(10))表示从0到9中随机挑选1项,random.sample(range(-10, 0), 2)表示从-10到-1之间随机挑选2项；另外，三角函数、数学常量（math.pi圆周率、math.e自然常数等）及其它数学函数等，Python擅长数学运算、数据分析等领域

x、Python转义字符：在需要在字符中使用特殊字符时，python用反斜杠(\)转义字符。如下表：

转义字符 描述
\(在行尾时) 续行符
\\ 反斜杠符号
\‘ 单引号
\" 双引号
\a 响铃
\b 退格(Backspace)
\000 空
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页

y、Python 的字符串内建函数（内建函数功能简单，但效率极高——C语言模块）

序号 方法及描述
1 
capitalize()
将字符串的第一个字符转换为大写
2 
center(width, fillchar)
返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
3 
count(str, beg= 0,end=len(string))
返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
8 
find(str, beg=0 end=len(string))
检测 str 是否包含在字符串中 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
9 
index(str, beg=0, end=len(string))
跟find()方法一样，只不过如果str不在字符串中会报一个异常.
10 
isalnum()
如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
11 
isalpha()
如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
12 
isdigit()
如果字符串只包含数字则返回 True 否则返回 False..
13 
islower()
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
14 
isnumeric()
如果字符串中只包含数字字符，则返回 True，否则返回 False
15 
isspace()
如果字符串中只包含空格，则返回 True，否则返回 False.
17 
isupper()
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
18 
join(seq)
以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
19 
len(string)
返回字符串长度
20 
ljust(width[, fillchar])
返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
21 
lower()
转换字符串中所有大写字符为小写.
24 
max(str)
返回字符串 str 中最大的字母。
25 
min(str)
返回字符串 str 中最小的字母。
26 
replace(old, new [, max])
把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。
27 
rfind(str, beg=0,end=len(string))
类似于 find()函数，不过是从右边开始查找.
28 
rindex( str, beg=0, end=len(string))
类似于 index()，不过是从右边开始.
29 
rjust(width,[, fillchar])
返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
31 
split(str="", num=string.count(str))
num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串
32 
splitlines( num=string.count(‘\n‘))
按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行.
33 
startswith(str, beg=0,end=len(string))
检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
35 
swapcase()
将字符串中大写转换为小写，小写转换为大写
38 
upper()
转换字符串中的小写字母为大写

z、Python列表函数&方法（同理，内建函数效率较高）

序号 函数
1 len(list)
列表元素个数
2 max(list)
返回列表元素最大值
3 min(list)
返回列表元素最小值
4 list(seq)
将元组转换为列表
Python包含以下方法:
序号 方法
1 list.append(obj)
在列表末尾添加新的对象
2 list.count(obj)
统计某个元素在列表中出现的次数
3 list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4 list.index(obj)
从列表中找出某个值第一个匹配项的索引位置
5 list.insert(index, obj)
将对象插入列表
6 list.pop(obj=list[-1])
移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7 list.remove(obj)
移除列表中某个值的第一个匹配项
8 list.reverse()
反向列表中元素
9 list.sort([func])
对原列表进行排序
10 list.clear()
清空列表
11 list.copy()
复制列表

 

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

Python3 字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

访问字典里的值
把相应的键放入方括弧，不能用位置数字

修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对

删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令

字典键的特性
字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

← Python3 元组 Python3 编程第一步 →
Python3 字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例：
dict = {‘Alice‘: ‘2341‘, ‘Beth‘: ‘9102‘, ‘Cecil‘: ‘3258‘}
也可如此创建字典：
dict1 = { ‘abc‘: 456 };
dict2 = { ‘abc‘: 123, 98.6: 37 };
访问字典里的值
把相应的键放入熟悉的方括弧，如下实例:
#!/usr/bin/python3

dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}

print ("dict[‘Name‘]: ", dict[‘Name‘])
print ("dict[‘Age‘]: ", dict[‘Age‘])
以上实例输出结果：
dict[‘Name‘]: Runoob
dict[‘Age‘]: 7
如果用字典里没有的键访问数据，会输出错误如下：
#!/usr/bin/python3

dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘};

print ("dict[‘Alice‘]: ", dict[‘Alice‘])
以上实例输出结果：
Traceback (most recent call last):
File "test.py", line 5, in <module>
print ("dict[‘Alice‘]: ", dict[‘Alice‘])
KeyError: ‘Alice‘
修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
#!/usr/bin/python3

dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}

dict[‘Age‘] = 8; # 更新 Age
dict[‘School‘] = "菜鸟教程" # 添加信息

print ("dict[‘Age‘]: ", dict[‘Age‘])
print ("dict[‘School‘]: ", dict[‘School‘]) 以上实例输出结果：
dict[‘Age‘]: 8
dict[‘School‘]: 菜鸟教程
删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令，如下实例：
#!/usr/bin/python3

dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘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 "test.py", line 9, in <module>
print ("dict[‘Age‘]: ", dict[‘Age‘])
TypeError: ‘type‘ object is not subscriptable
注：del() 方法后面也会讨论。

字典键的特性
字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
#!/usr/bin/python3

dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Name‘: ‘小菜鸟‘}

print ("dict[‘Name‘]: ", dict[‘Name‘])
以上实例输出结果：
dict[‘Name‘]: 小菜鸟
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
#!/usr/bin/python3

dict = {[‘Name‘]: ‘Runoob‘, ‘Age‘: 7}

print ("dict[‘Name‘]: ", dict[‘Name‘])
以上实例输出结果：
Traceback (most recent call last):
File "test.py", line 3, in <module>
dict = {[‘Name‘]: ‘Runoob‘, ‘Age‘: 7}
TypeError: unhashable type: ‘list‘
字典内置函数&方法
Python字典包含了以下内置函数：
序号 函数及描述 实例
1 len(dict)
计算字典元素个数，即键的总数。 
>>> dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}
>>> len(dict)
3
2 str(dict)
输出字典以可打印的字符串表示。 
>>> dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}
>>> str(dict)
"{‘Name‘: ‘Runoob‘, ‘Class‘: ‘First‘, ‘Age‘: 7}"
3 type(variable)
返回输入的变量类型，如果变量是字典就返回字典类型。 
>>> dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}
>>> type(dict)
<class ‘dict‘>
Python字典包含了以下内置方法：
序号 函数及描述
1 radiansdict.clear()
删除字典内所有元素
2 radiansdict.copy()
返回一个字典的浅复制
4 radiansdict.get(key, default=None)
返回指定键的值，如果值不在字典中返回default值
5 key in dict
如果键在字典dict里返回true，否则返回false
6 radiansdict.items()
以列表返回可遍历的(键, 值) 元组数组
7 radiansdict.keys()
以列表返回一个字典所有的键
8 radiansdict.setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9 radiansdict.update(dict2)
把字典dict2的键/值对更新到dict里
10 radiansdict.values()
以列表返回字典中的所有值

end 关键字
关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符

Python中while语句的一般形式：
while 判断条件：
语句
####同样需要注意冒号和缩进。另外，在Python中没有do..while循环

while 循环使用 else 语句
在 while … else 在条件语句为 false 时执行 else 的语句块

range()函数
如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列
还可以使用range()函数来创建一个列表：
>>> list(range(5))
[0, 1, 2, 3, 4]

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行

continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环

循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。

Python pass是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句

迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。
字符串，列表或元组对象都可用于创建迭代器：

迭代器对象可以使用常规for语句进行遍历

定义一个函数
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

语法
Python 定义函数使用 def 关键字，一般格式如下：
def 函数名（参数列表）:
函数体
默认情况下，参数值和参数名称是按函数声明中定义的的顺序匹配起来的

按值传递参数和按引用传递参数
在 Python 中，所有参数（变量）都是按引用传递。如果你在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了

参数
以下是调用函数时可使用的正式参数类型：
必需参数
关键字参数
默认参数
不定长参数

匿名函数
python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
lambda 只是一个表达式，函数体比 def 简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

列表推导式
每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。
如果希望表达式推导出一个元组，就必须使用括号。
如：
>>> [str(round(355/113, i)) for i in range(1, 6)]
[‘3.1‘, ‘3.14‘, ‘3.142‘, ‘3.1416‘, ‘3.14159‘]

以下实例展示了3X4的矩阵列表：
>>> matrix = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]
以下实例将3X4的矩阵列表转换为4X3列表：
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
以下实例也可以使用以下方法来实现：
>>> transposed = []
>>> for i in range(4):
... transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

del 语句
使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割，或清空整个列表
也可以用 del 删除实体变量：
>>> del a

集合
集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。
可以用大括号({})创建集合。可理解为不能得复的元组

字典
另一个非常有用的 Python 内建数据类型是字典。
序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。
理解字典的最佳方式是把它看做无序的键=>值对集合。在同一个字典之内，关键字必须是互不相同。
一对大括号创建一个空的字典：{}。

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。
一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。
>>> import sys
>>> sys.path
[‘‘, ‘/usr/lib/python3.4‘, ‘/usr/lib/python3.4/plat-x86_64-linux-gnu‘, ‘/usr/lib/python3.4/lib-dynload‘, 
‘/usr/local/lib/python3.4/dist-packages‘, ‘/usr/lib/python3/dist-packages‘]

路径开头的‘’代表当前目录，若在当前目录下存在与要引入模块同名的文件，就会把要引入的模块屏蔽掉。
了解了搜索路径的概念，就可以在脚本中修改sys.path来引入一些不在搜索路径中的模块。

from…import 语句
Python的from语句让你从模块中导入一个指定的部分到当前命名空间中

From…import* 语句
把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
from modname import *

每个模块有各自独立的符号表，在模块内部为所有的函数当作全局符号表来使用。
所以，模块的作者可以放心大胆的在模块内部使用这些全局变量，而不用担心把其他用户的全局变量搞花。

模块是可以导入其他模块的。
在一个模块（或者脚本，或者其他地方）的最前面使用 import 来导入一个模块。被导入的模块的名称将被放入当前操作的模块的符号表中。

__name__属性
一个模块被另一个程序第一次引入时，其主程序将运行。

标准模块
Python 本身带着一些标准的模块库，在 Python 库参考文档中将会介绍到（就是后面的"库参考文档"）。
有些模块直接被构建在解析器里，这些虽然不是一些语言内置的功能，但是他却能很高效的使用，甚至是系统级调用也没问题。
这些组件会根据不同的操作系统进行不同形式的配置，比如 winreg 这个模块就只会提供给 Windows 系统。
应该注意到这有一个特别的模块 sys ，它内置在每一个 Python 解析器中。变量 sys.ps1 和 sys.ps2 定义了主提示符和副提示符所对应的字符串

包
包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。
比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B

如果使用形如import item.subitem.subsubitem这种导入形式，除了最后一项，都必须是包，
而最后一项则可以是模块或者是包，但是不可以是类，函数或者变量的名字。

#!/usr/bin/python3

str = input("请输入：");
print ("你输入的内容是: ", str)

读和写文件
open() 将会返回一个 file 对象，基本语法格式如下:
open(filename, mode)
filename：filename 变量是一个包含了你要访问的文件名称的字符串值。
mode：mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

如果要写入一些不是字符串的东西, 那么将需要先进行转换:
#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo1.txt", "w")

value = (‘www.runoob.com‘, 14)
s = str(value)
f.write(s)

# 关闭打开的文件
f.close()

读写二进制文件
>>> f = open(‘/tmp/foo.txt‘, ‘rb+‘)
>>> f.write(b‘0123456789abcdef‘)
16

f.read([size]) 为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。
f.readline()
f.readlines([sizehint]) 如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。
f.read

如果要写入一些不是字符串的东西, 那么将需要先进行转换:
#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo1.txt", "w")

value = (‘www.runoob.com‘, 14)
s = str(value)
f.write(s)

pickle 模块
python的pickle模块实现了基本的数据序列和反序列化。
通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。
通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。
基本接口：
pickle.dump(obj, file, [,protocol])
有了 pickle 这个对象, 就能对 file 以读取的形式打开:
x = pickle.load(file)
注解：从 file 中读取一个字符串，并将它重构为原来的python对象

Python3 OS 文件/目录方法
os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示：
序号 方法及描述
os.chdir(path)
改变当前工作目录
os.open(file, flags[, mode])
打开一个文件，并且设置需要的打开选项，mode参数是可选的
...

关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:
with open("myfile.txt") as f:
for line in f:
print(line, end="")

try:
except xxx:
else:
finally:

建议使用 "import os" 风格而非 "from os import *"。这样可以保证随操作系统不同而有所变化的 os.open() 不会覆盖内置函数 open()。
在使用 os 这样的大型模块时内置的 dir() 和 help() 函数非常有用:
>>> import os
>>> dir(os)
<returns a list of all module functions>
>>> help(os)
<returns an extensive manual page created from the module‘s docstrings>

针对日常的文件和目录管理任务，:mod:shutil 模块提供了一个易于使用的高级接口:
>>> import shutil
>>> shutil.copyfile(‘data.db‘, ‘archive.db‘)
>>> shutil.move(‘/build/executables‘, ‘installdir‘)

文件通配符
glob模块提供了一个函数用于从目录通配符搜索中生成文件列表:
>>> import glob
>>> glob.glob(‘*.py‘)
[‘primes.py‘, ‘random.py‘, ‘quote.py‘]

字符串正则匹配
re模块为高级字符串处理提供了正则表达式工具。对于复杂的匹配和处理，正则表达式提供了简洁、优化的解决方案:
>>> import re
>>> re.findall(r‘\bf[a-z]*‘, ‘which foot or hand fell fastest‘)
[‘foot‘, ‘fell‘, ‘fastest‘]
>>> re.sub(r‘(\b[a-z]+) \1‘, r‘\1‘, ‘cat in the the hat‘)
‘cat in the hat‘
如果只需要简单的功能，应该首先考虑字符串方法，因为它们非常简单，易于阅读和调试:
>>> ‘tea for too‘.replace(‘too‘, ‘two‘)
‘tea for two‘

访问 互联网
有几个模块用于访问互联网以及处理网络通信协议。其中最简单的两个是用于处理从 urls 接收的数据的 urllib.request 以及用于发送电子邮件的 smtplib:

_______________________________
2016-08-01
-------------------------------
例如, 假设我们创建一个 squares 列表, 可以像下面方式:

>>> squares = []
>>> for x in range(10):
... squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
注意这个 for 循环中的被创建(或被重写)的名为 x 的变量在循环完毕后依然存在。使用如下方法，我们可以计算squares的值而不会产生任何的副作用:

squares = [x**2 for x in range(10)]

如果想要得到一个元组（例如，上面例子中的 (x, y)），必须要加上括号:
>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]

>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

dict() 构造函数可以直接从 key-value 对中创建字典:

>>> dict([(‘sape‘, 4139), (‘guido‘, 4127), (‘jack‘, 4098)])
{‘sape‘: 4139, ‘jack‘: 4098, ‘guido‘: 4127}
此外，字典推导式可以从任意的键值表达式中创建字典:

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
如果关键字都是简单的字符串，有时通过关键字参数指定 key-value 对更为方便:

>>> dict(sape=4139, guido=4127, jack=4098)
{‘sape‘: 4139, ‘jack‘: 4098, ‘guido‘: 4127}

需要逆向循环序列的话，先正向定位序列，然后调用 reversed() 函数:

>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1