基础学习 Python注释： 一、单行注释 Python 中单行注释以 # 开头 ，例如：
# 这是一个注释
print("Hello, World!")
二、多行注释
1、单引号（'''）：需要用3个单引号
#!/usr/bin/python3
'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号
这是多行注释，用三个单引号
'''
print("Hello, World!")
2、双引号（"""）：需要用3个双引号
#!/usr/bin/python3
"""
这是多行注释，用三个双引号
这是多行注释，用三个双引号
这是多行注释，用三个双引号
"""
print("Hello, World!")
Python3 运算符
一、Python算术运算符
以下假设变量 a=10，变量 b=21：
运算符描述实例+加 - 两个对象相加a + b 输出结果 31-减 - 得到负数或是一个数减去另一个数a - b 输出结果 -11*乘 - 两个数相乘或是返回一个被重复若干次的字符串a * b 输出结果 210/除 - x 除以 yb / a 输出结果 2.1%取模 - 返回除法的余数b % a 输出结果 1**幂 - 返回x的y次幂a**b 为10的21次方//取整除 - 往小的方向取整数>>> 9//2
4
>>> -9//2
-5
二、Python 比较运算符
以下假设变量 a 为 10，变量 b 为20：
运算符描述实例==等于 - 比较对象是否相等(a == b) 返回 False。
!=不等于 - 比较两个对象是否不相等(a != b) 返回 True。
>大于 - 返回x是否大于y(a > b) 返回 False。
<小于 - 返回x是否小于y。
所有比较运算符返回1表示真，返回0表示假。
这分别与特殊的变量True和False等价。
注意，这些变量名的大写。
(a < b) 返回 True。
>=大于等于 - 返回x是否大于等于y。
(a >= b) 返回 False。
<=小于等于 - 返回x是否小于等于y。
(a <= b) 返回 True。
三、Python赋值运算符 以下假设变量a为10，变量b为20： 运算符描述实例=简单的赋值运算符c = a + b 将 a + b 的运算结果赋值为 c+=加法赋值运算符c += a 等效于 c = c + a-=减法赋值运算符c -= a 等效于 c = c - a*=乘法赋值运算符c *= a 等效于 c = c * a/=除法赋值运算符c /= a 等效于 c = c / a%=取模赋值运算符c %= a 等效于 c = c % a**=幂赋值运算符c **= a 等效于 c = c ** a//=取整除赋值运算符c //= a 等效于 c = c // a:=海象运算符，可在表达式内部为变量赋值。
Python3.8 版本新增运算符。
在这个示例中，赋值表达式可以避免调用 len() 两次:if (n := len(a)) > 10:
print(f"List is too long ({n} elements, expected <= 10)")
四、Python位运算符
运算符描述实例&按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0(a & b) 输出结果 12 ，二进制解释： 0000 1100|按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
(a | b) 输出结果 61 ，二进制解释： 0011 1101^按位异或运算符：当两对应的二进位相异时，结果为1(a ^ b) 输出结果 49 ，二进制解释： 0011 0001~按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。
~x 类似于 -x-1(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。
a << 2 输出结果 240 ，二进制解释： 1111 0000>>右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数a >> 2 输出结果 15 ，二进制解释： 0000 1111 五、Python逻辑运算符 Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20: 运算符逻辑表达式描述实例andx and y布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。
(a and b) 返回 20。
orx or y布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。
(a or b) 返回 10。
notnot x布尔"非" - 如果 x 为 True，返回 False 。
如果 x 为 False，它返回 True。
not(a and b) 返回 False 六、Python成员运算符 除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
运算符描述实例in如果在指定的序列中找到值返回 True，否则返回 False。
x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in如果在指定的序列中没有找到值返回 True，否则返回 False。
x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
七、Python身份运算符 身份运算符用于比较两个对象的存储单元 运算符描述实例isis 是判断两个标识符是不是引用自一个对象x is y, 类似id(x) == id(y), 如果引用的是同一个对象则返回 True，否则返回 Falseis notis not 是判断两个标识符是不是引用自不同对象x is not y， 类似id(x) != id(y)。
如果引用的不是同一个对象则返回结果 True，否则返回 False。
八、Python运算符优先级 以下表格列出了从最高到最低优先级的所有运算符， 相同单元格内的运算符具有相同优先级。
运算符均指二元运算，除非特别指出。
相同单元格内的运算符从左至右分组（除了幂运算是从右至左分组）： 运算符描述
(expressions...),[expressions...],{key: value...},{expressions...}圆括号的表达式x[index],x[index:index],x(arguments...),x.attribute读取，切片，调用，属性引用await xawait 表达式**乘方(指数)+x,-x,~x正，负，按位非 NOT*,@,/,//,%乘，矩阵乘，除，整除，取余+,-加和减<<,>>移位&按位与 AND^按位异或 XOR|按位或 ORin,not in, is,is not, <, <=, >, >=, !=, ==比较运算，包括成员检测和标识号检测not x逻辑非 NOTand逻辑与 ANDor逻辑或 ORif -- else条件表达式lambdalambda 表达式:=赋值表达式
Python3 数字(Number) Python 数字数据类型用于存储数值。
数据类型是不允许改变的，这就意味着如果改变数字数据类型的值，将重新分配内存空间。
以下实例在变量赋值时 Number 对象将被创建：
var1 = 1
var2 = 10
您也可以使用del语句删除一些数字对象的引用。
del语句的语法是：
del var1[,var2[,var3[....,varN]]]
您可以通过使用del语句删除单个或多个对象的引用，例如：
del var
del var_a, var_b
Python 支持三种不同的数值类型： 整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
布尔(bool)是整型的子类型。
浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250） 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
Python支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
intfloatcomplex100.03.14j10015.2045.j-786-21.99.322e-36j08032.3e+18.876j-0490-90.-.6545+0J-0x260-32.54e1003e+26J0x6970.2E-124.53e-7j 一、Python 数字类型转换 有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
int(x) 将x转换为一个整数。
float(x) 将x转换到一个浮点数。
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。
x 和 y 是数字表达式。
二、Python 数字运算 Python 解释器可以作为一个简单的计算器，您可以在解释器里输入一个表达式，它将输出表达式的值。
表达式的语法很直白： +, -, * 和 /, 和其它语言（如Pascal或C）里一样。
例如：
>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5 # 总是返回一个浮点数
1.6
注意： 在不同的机器上浮点运算的结果可能会不一样。
在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 // ： 注意： // 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。
等号 = 用于给变量赋值。
赋值之后，除了下一个提示符，解释器不会显示任何结果。
Python 可以使用 ** 操作来进行幂运算： 变量在使用前必须先"定义"（即赋予变量一个值），否则会出现错误： 不同类型的数混合运算时会将整数转换为浮点数： 在交互模式中，最后被输出的表达式结果被赋值给变量 _ 。
例如： 三、数据函数 函数返回值 ( 描述 )abs(x)返回数字的绝对值，如abs(-10) 返回 10ceil(x)返回数字的上入整数，如math.ceil(4.1) 返回 5cmp(x, y)如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
Python 3 已废弃，使用 (x>y)-(x exp(x)返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045fabs(x)以浮点数形式返回数字的绝对值，如math.fabs(-10) 返回10.0floor(x)返回数字的下舍整数，如math.floor(4.9)返回 4log(x)如math.log(math.e)返回1.0,math.log(100,10)返回2.0log10(x)返回以10为基数的x的对数，如math.log10(100)返回 2.0max(x1, x2,...)返回给定参数的最大值，参数可以为序列。 min(x1, x2,...)返回给定参数的最小值，参数可以为序列。 modf(x)返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。 pow(x, y)x**y 运算后的值。 round(x [,n])返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。 其实准确的说是保留值将保留到离上一位更近的一端。 sqrt(x)返回数字x的平方根。
四、随机数函数
随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
Python包含以下常用随机数函数：
函数描述choice(seq)从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。 randrange ([start,] stop [,step])从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1random()随机生成下一个实数，它在[0,1)范围内。 seed([x])改变随机数生成器的种子seed。 如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。 shuffle(lst)将序列的所有元素随机排序uniform(x, y)随机生成下一个实数，它在[x,y]范围内。
五、三角函数
Python包括以下三角函数：
函数描述acos(x)返回x的反余弦弧度值。 asin(x)返回x的反正弦弧度值。 atan(x)返回x的反正切弧度值。 atan2(y, x)返回给定的 X 及 Y 坐标值的反正切值。 cos(x)返回x的弧度的余弦值。 hypot(x, y)返回欧几里德范数 sqrt(x*x + y*y)。 sin(x)返回的x弧度的正弦值。 tan(x)返回x弧度的正切值。 degrees(x)将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0radians(x)将角度转换为弧度
六、数学常量
常量描述pi数学常量 pi（圆周率，一般以π来表示）e数学常量 e，e即自然常数（自然常数）。
Python3 字符串
Python 访问字符串中的值
Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下：
索引值以
0
为开始值，
-1
为从末尾的开始位置。
一、Python 字符串更新
你可以截取字符串的一部分并与其他字段拼接，如下实例：
var1 = 'Hello World!'
print ("已更新字符串 : ", var1[:6] + 'Runoob!')变量[头下标:尾下标]
#!/usr/bin/python3
二、Python 转义字符
在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符。
如下表：
转义字符描述实例
\(在行尾时)续行符>>> print("line1 \
... line2 \
... line3")
line1 line2 line3
>>> \\反斜杠符号>>> print("\\")
\\'单引号>>> print('\'')
'\"双引号>>> print("\"")
"\a响铃>>> print("\a")执行后电脑有响声。
\b退格(Backspace)>>> print("Hello \b World!")
Hello World!\000空>>> print("\000")
>>> \n换行>>> print("\n")
>>>\v纵向制表符>>> print("Hello \v World!")
Hello
World!
>>>\t横向制表符>>> print("Hello \t World!")
Hello World!
>>>\r回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。
>>> print("Hello\rWorld!")
World!
>>> print('google runoob taobao\r123456')
123456 runoob taobao\f换页>>> print("Hello \f World!")
Hello
World!
>>> \yyy八进制数，y 代表 0~7 的字符，例如：\012 代表换行。
>>> print("\110\145\154\154\157\40\127\157\162\154\144\41")
Hello World!\xyy十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行>>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")
Hello World!\other其它的字符以普通格式输出
三、Python 字符串运算符
下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：
操作符描述实例+字符串连接a + b 输出结果： HelloPython*重复输出字符串a*2 输出结果：HelloHello[]通过索引获取字符串中字符a[1] 输出结果e[ : ]截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。
a[1:4] 输出结果ellin成员运算符 - 如果字符串中包含给定的字符返回 True'H' in a输出结果 Truenot in成员运算符 - 如果字符串中不包含给定的字符返回 True'M' not in a输出结果 Truer/R原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。
原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。
print( r'\n' )
print( R'\n' )%格式字符串请看下一节内容。
四、Python 字符串格式化 Python 支持格式化字符串的输出 。
尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
#!/usr/bin/python3
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
1、python字符串格式化符号:
符 号描述%c格式化字符及其ASCII码%s格式化字符串%d格式化整数%u格式化无符号整型%o格式化无符号八进制数%x格式化无符号十六进制数%X格式化无符号十六进制数（大写）%f格式化浮点数字，可指定小数点后的精度%e用科学计数法格式化浮点数%E作用同%e，用科学计数法格式化浮点数%g%f和%e的简写%G%f 和 %E 的简写%p用十六进制数格式化变量的地址
2、格式化操作符辅助指令:
符号功能*定义宽度或者小数点精度-用做左对齐+在正数前面显示加号( + )实例如下
#!/usr/bin/python3
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)
三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。
一个典型的用例是，当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。
六、f-string f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。
之前我们习惯用百分号 (%): f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：
>>> name = 'Runoob'
>>> f'Hello {name}' # 替换变量
'Hello Runoob'
>>> f'{1+2}' # 使用表达式
'3'
>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'
用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。
在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果： 七、Unicode 字符串 在Python3中，所有的字符串都是Unicode字符串。
八、Python 的字符串内建函数 Python 的字符串常用内建函数如下： 序号方法及描述1capitalize()将字符串的第一个字符转换为大写2center(width, fillchar)返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
3count(str, beg= 0,end=len(string))返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数4bytes.decode(encoding="utf-8", errors="strict")Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
5encode(encoding='UTF-8',errors='strict')以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'6endswith(suffix, beg=0, end=len(string))检查字符串是否以 suffix 结束，如果 beg 或者 end 指定则检查指定的范围内是否以 suffix 结束，如果是，返回 True,否则返回 False。
7expandtabs(tabsize=8)把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
8find(str, beg=0, end=len(string))检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-19index(str, beg=0, end=len(string))跟find()方法一样，只不过如果str不在字符串中会报一个异常。
10isalnum()如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False11isalpha()如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False12isdigit()如果字符串只包含数字则返回 True 否则返回 False..13islower()如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False14isnumeric()如果字符串中只包含数字字符，则返回 True，否则返回 False15isspace()如果字符串中只包含空白，则返回 True，否则返回 False.16istitle()如果字符串是标题化的(见 title())则返回 True，否则返回 False17isupper()如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False18join(seq)以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串19len(string)返回字符串长度20ljust(width[, fillchar])返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
21lower()转换字符串中所有大写字符为小写.22lstrip()截掉字符串左边的空格或指定字符。
23maketrans()创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
24max(str)返回字符串 str 中最大的字母。
25min(str)返回字符串 str 中最小的字母。
26replace(old, new [, max])把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。
27rfind(str, beg=0,end=len(string))类似于 find()函数，不过是从右边开始查找.28rindex( str, beg=0, end=len(string))类似于 index()，不过是从右边开始.29rjust(width,[, fillchar])返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串30rstrip()删除字符串末尾的空格或指定字符。
31split(str="", num=string.count(str))以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串32splitlines([keepends])按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
33startswith(substr, beg=0,end=len(string))检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。
如果beg 和 end 指定值，则在指定范围内检查。
34strip([chars])在字符串上执行 lstrip()和 rstrip()35swapcase()将字符串中大写转换为小写，小写转换为大写36title()返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())37translate(table, deletechars="")根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中38upper()转换字符串中的小写字母为大写39zfill (width)返回长度为 width 的字符串，原字符串右对齐，前面填充040isdecimal()检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。
Python3 列表 序列是 Python 中最基本的数据结构。
序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。
Python 有 6 个序列的内置类型，但最常见的是列表和元组。
列表都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
如下所示：
list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']
一、访问列表中的值
与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。
通过索引列表可以进行截取、组合等操作。
#!/usr/bin/python3
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )
索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。
#!/usr/bin/python3
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )
使用下标索引来访问列表中的值，同样你也可以使用方括号 [] 的形式截取字符，如下所示：
#!/usr/bin/python3
nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])
使用负数索引值截取：
#!/usr/bin/python3
list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]
# 读取第二位
print ("list[1]: ", list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print ("list[1:-2]: ", list[1:-2])
二、更新列表
你可以对列表的数据项进行修改或更新，你也可以使用 append() 方法来添加列表项，如下所示：
#!/usr/bin/python3
list = ['Google', 'Runoob', 1997, 2000]
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)
三、删除列表元素
可以使用 del 语句来删除列表的的元素，如下实例：
#!/usr/bin/python3
list = ['Google', 'Runoob', 1997, 2000]
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)
四、Python列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。
+ 号用于组合列表，* 号用于重复列表。
Python 表达式结果描述len([1, 2, 3])3长度[1, 2, 3] + [4, 5, 6][1, 2, 3, 4, 5, 6]组合['Hi!'] * 4['Hi!', 'Hi!', 'Hi!', 'Hi!']重复3 in [1, 2, 3]True元素是否存在于列表中for x in [1, 2, 3]: print(x, end=" ")1 2 3迭代 五、Python列表截取与拼接 Python的列表截取与字符串操作类型，如下所示： L=['Google', 'Runoob', 'Taobao'] Python 表达式结果描述L[2]'Taobao'读取第三个元素L[-2]'Runoob'从右侧开始读取倒数第二个元素: count from the rightL[1:]['Runoob', 'Taobao']输出从第二个元素开始后的所有元素
>>>L=['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao']
>>>
列表还支持拼接操作：
>>>squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>
六、嵌套列表
使用嵌套列表即在列表里创建其它列表，例如：
>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'
七、列表比较
列表比较需要引入 operator 模块的 eq 方法（详见：
Python operator 模块
）：
# 导入 operator 模块
import operator
a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))
以上代码输出结果为：
operator.eq(a,b): False
operator.eq(c,b): True
八、Python列表函数&方法
Python包含以下函数:
序号函数1len(list)列表元素个数2max(list)返回列表元素最大值3min(list)返回列表元素最小值4list(seq)将元组转换为列表
Python包含以下方法:
序号方法1list.append(obj)在列表末尾添加新的对象2list.count(obj)统计某个元素在列表中出现的次数3list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）4list.index(obj)从列表中找出某个值第一个匹配项的索引位置5list.insert(index, obj)将对象插入列表6list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值7list.remove(obj)移除列表中某个值的第一个匹配项8list.reverse()反向列表中元素9list.sort( key=None, reverse=False)对原列表进行排序10list.clear()清空列表11list.copy()复制列表
Python3 元组
一、元组的作用
1. 数据保护
由于元组是不可变的，一旦创建，元素的值就无法更改。
这种特性可以保护数据不被意外修改。
例如，如果你拥有一组固定的坐标点，在使用过程中不希望被修改，你可以将这些坐标点存储在元组中。
2. 元组在字典中的应用 字典是Python中常用的数据结构之一，它通过键-值对的形式存储数据。
而元组可以作为字典的键使用，因为字典的键必须是不可变的。
这是因为字典中的键是用来计算哈希值进行查找的，而哈希值只能计算不可变的数据类型。
例如，你可以使用元组作为字典的键来存储城市的经纬度信息，如下所示： city_coordinates = { ('北京', 39.9042, 116.4074): '中国北京', ('纽约', 40.7128, -74.0060): '美国纽约', ('巴黎', 48.8566, 2.3522): '法国巴黎' } 3. 函数的返回值 当一个函数需要返回多个值时，可以使用元组将这些值打包并返回。
这比返回多个独立的变量更加方便和清晰。
例如，下面的函数计算一个列表中的最小值和最大值，并将其作为一个元组返回
def get_min_max(numbers):
min_value = min(numbers)
max_value = max(numbers)
return min_value, max_value
result = get_min_max([1, 2, 3, 4, 5])
print(result) # 输出 (1, 5)
4. 多个变量的赋值 使用元组可以将多个变量的值同时赋给一个元组。
这种方式在交换两个变量的值时非常方便，不需要使用额外的变量。
例如：
a = 1
b = 2
a, b = b, a # 交换变量的值
print(a) # 输出 2
print(b) # 输出 1
5. 元组的解包 元组可以使用解包的方式将其元素赋给多个变量。
这在元组中包含固定数量的元素时非常有用。
例如，下面的代码将一个元组解包并将其值赋给三个变量：
person = ('John', 25, 'USA')
name, age, country = person
print(name) # 输出 'John'
print(age) # 输出 25
print(country) # 输出 'USA'
总结 元组是一种有序的、不可变的数据类型，常用于保护数据、作为字典的键、函数的返回值、多个变量赋值以及元组的解包等方面。
在实际的编程中，根据具体的需求，灵活运用元组可以提高代码的可读性和效率。
二、元组的用法 Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 ( )，列表使用方括号 [ ]。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
>>> tup1 = ('Google', 'Runoob', 1997, 2000) >>> tup2 = (1, 2, 3, 4, 5 ) >>> tup3 = "a", "b", "c", "d" # 不需要括号也可以 >>> type(tup3)
创建空元组 tup1 = () 元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用： >>> tup1 = (50) >>> type(tup1) # 不加逗号，类型为整型
>>> tup1 = (50,) >>> type(tup1) # 加上逗号，类型为元组
元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。
三、访问元组 元组可以使用下标索引来访问元组中的值，如下实例: #!/usr/bin/python3 tup1 = ('Google', 'Runoob', 1997, 2000) tup2 = (1, 2, 3, 4, 5, 6, 7 ) print ("tup1[0]: ", tup1[0]) print ("tup2[1:5]: ", tup2[1:5]) 以上实例输出结果： tup1[0]: Google tup2[1:5]: (2, 3, 4, 5) 四、修改元组 元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例: #!/usr/bin/python3 tup1 = (12, 34.56) tup2 = ('abc', 'xyz') # 以下修改元组元素操作是非法的。
# tup1[0] = 100 # 创建一个新的元组 tup3 = tup1 + tup2 print (tup3) 以上实例输出结果： (12, 34.56, 'abc', 'xyz') 五、删除元组 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例: #!/usr/bin/python3 tup = ('Google', 'Runoob', 1997, 2000) print (tup) del tup print ("删除后的元组 tup : ") print (tup) 六、元组运算符 与字符串一样，元组之间可以使用 +、+=和 * 号进行运算。
这就意味着他们可以组合和复制，运算后会生成一个新的元组。
len((1, 2, 3))3计算元素个数>>> a = (1, 2, 3)
>>> b = (4, 5, 6)
>>> c = a+b
>>> c
(1, 2, 3, 4, 5, 6)
(1, 2, 3, 4, 5, 6)连接，c 就是一个新的元组，它包含了 a 和 b 中的所有元素。
>>> a = (1, 2, 3)
>>> b = (4, 5, 6)
>>> a += b
>>> a
(1, 2, 3, 4, 5, 6)(1, 2, 3, 4, 5, 6)连接，a 就变成了一个新的元组，它包含了 a 和 b 中的所有元素。
('Hi!',) * 4('Hi!', 'Hi!', 'Hi!', 'Hi!')复制3 in (1, 2, 3)True元素是否存在for x in (1, 2, 3):
print (x, end=" ")1 2 3迭代
七、元组索引，截取
因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：
tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
Python 表达式结果描述tup[1]'Runoob'读取第二个元素tup[-2]'Weibo'反向读取，读取倒数第二个元素tup[1:]('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')截取元素，从第二个开始后的所有元素。
tup[1:4]('Runoob', 'Taobao', 'Wiki')截取元素，从第二个开始到第四个元素（索引为 3）。
运行实例如下： >>> tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin') >>> tup[1] 'Runoob' >>> tup[-2] 'Weibo' >>> tup[1:] ('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin') >>> tup[1:4] ('Runoob', 'Taobao', 'Wiki') >>> 八、元组内置函数 序号方法及描述实例1len(tuple)计算元组元素个数。
>>> tuple1 = ('Google', 'Runoob', 'Taobao')
>>> len(tuple1)
3
>>> 2max(tuple)返回元组中元素最大值。
>>> tuple2 = ('5', '4', '8')
>>> max(tuple2)
'8'
>>> 3min(tuple)返回元组中元素最小值。
>>> tuple2 = ('5', '4', '8')
>>> min(tuple2)
'4'
>>> 4tuple(iterable)将可迭代系列转换为元组。
>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
>>> tuple1=tuple(list1)
>>> tuple1
('Google', 'Taobao', 'Runoob', 'Baidu')
九、关于元组是不可变的
所谓元组的不可变指的是元组所指向的内存中的内容不可变。
>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g' # 不支持修改元素
Traceback (most recent call last):
File "
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号( , )分割，整个字典包括在花括号 {} 中 ,格式如下所示： d = {key1 : value1, key2 : value2, key3 : value3 } 注意： dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字。
一个简单的字典实例： tinydict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}
也可如此创建字典： tinydict1 = { 'abc': 456 } tinydict2 = { 'abc': 123, 98.6: 37 } 二、创建空字典 使用大括号 { } 创建空字典： # 使用大括号 {} 来创建空字典 emptyDict = {} # 打印字典 print(emptyDict) # 查看字典的数量 print("Length:", len(emptyDict)) # 查看类型 print(type(emptyDict)) 以上实例输出结果： {} Length: 0
三、使用内建函数 dict() 创建字典：
emptyDict = dict()
# 打印字典
print(emptyDict)
# 查看字典的数量
print("Length:",len(emptyDict))
# 查看类型
print(type(emptyDict))
四、访问字典里的值
把相应的键放入到方括号中，如下实例:
#!/usr/bin/python3
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])
以上实例输出结果：
tinydict['Name']: Runoob
tinydict['Age']: 7
如果用字典里没有的键访问数据，会输出错误如下：
#!/usr/bin/python3
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print ("tinydict['Alice']: ", tinydict['Alice'])
以上实例输出结果：
Traceback (most recent call last):
File "test.py", line 5, in
#!/usr/bin/python3
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 8 # 更新 Age
tinydict['School'] = "菜鸟教程" # 添加信息
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
以上实例输出结果：
tinydict['Age']: 8
tinydict['School']: 菜鸟教程
六、删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显式删除一个字典用del命令，如下实例：
#!/usr/bin/python3
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del tinydict['Name'] # 删除键 'Name'
tinydict.clear() # 清空字典
del tinydict # 删除字典
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
七、字典键的特性
字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住： 1）不允许同一个键出现两次。
创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
#!/usr/bin/python3
tinydict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
print ("tinydict['Name']: ", tinydict['Name'])
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
#!/usr/bin/python3
tinydict = {['Name']: 'Runoob', 'Age': 7}
print ("tinydict['Name']: ", tinydict['Name'])
八、字典内置函数&方法
Python字典包含了以下内置函数：
序号函数及描述实例1len(dict)计算字典元素个数，即键的总数。
>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> len(tinydict)
32str(dict)输出字典，可以打印的字符串表示。
>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> str(tinydict)
"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"3type(variable)返回输入的变量类型，如果变量是字典就返回字典类型。
>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> type(tinydict)
Python字典包含了以下内置方法： 序号函数及描述1dict.clear()删除字典内所有元素2dict.copy()返回一个字典的浅复制3dict.fromkeys()创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值4dict.get(key, default=None)返回指定键的值，如果键不在字典中返回 default 设置的默认值5key in dict如果键在字典dict里返回true，否则返回false6dict.items()以列表返回一个视图对象7dict.keys()返回一个视图对象8dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default9dict.update(dict2)把字典dict2的键/值对更新到dict里10dict.values()返回一个视图对象11pop(key[,default])删除字典 key（键）所对应的值，返回被删除的值。
12popitem()返回并删除字典中的最后一对键和值。
Python3集合 集合（set）是一个无序的不重复元素序列。
集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。
可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。
集合创建格式： parame = {value01,value02,...} 或者 set(value) 以下是一个简单实例： set1 = {1, 2, 3, 4} # 直接使用大括号创建集合 set2 = set([4, 5, 6, 7]) # 使用 set() 函数从列表创建集合 注意： 创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
更多实例演示： >>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'} >>> print(basket) # 这里演示的是去重功能 {'orange', 'banana', 'pear', 'apple'} >>> 'orange' in basket # 快速判断元素是否在集合内 True >>> 'crabgrass' in basket False >>> # 下面展示两个集合间的运算. ... >>> a = set('abracadabra') >>> b = set('alacazam') >>> a {'a', 'r', 'b', 'c', 'd'} >>> a - b # 集合a中包含而集合b中不包含的元素 {'r', 'd', 'b'} >>> a | b # 集合a或b中包含的所有元素 {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'} >>> a & b # 集合a和b中都包含了的元素 {'a', 'c'} >>> a ^ b # 不同时包含于a和b的元素 {'r', 'd', 'b', 'm', 'z', 'l'} 类似列表推导式，同样集合支持集合推导式(Set comprehension): >>> a = {x for x in 'abracadabra' if x not in 'abc'} >>> a {'r', 'd'} 集合的基本操作 1、添加元素 语法格式如下： s.add( x ) 将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作 >>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.add("Facebook") >>> print(thisset) {'Taobao', 'Facebook', 'Google', 'Runoob'} 还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下： s.update( x ) x 可以有多个，用逗号分开。
>>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.update({1,3}) >>> print(thisset) {1, 3, 'Google', 'Taobao', 'Runoob'} >>> thisset.update([1,4],[5,6]) >>> print(thisset) {1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'} >>> 2、移除元素 语法格式如下： s.remove( x ) 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook") # 不存在会发生错误
Traceback (most recent call last):
File "
格式如下所示： s.discard( x ) 实例 >>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.discard("Facebook") # 不存在不会发生错误 >>> print(thisset) {'Taobao', 'Google', 'Runoob'} 我们也可以设置随机删除集合中的一个元素，语法格式如下： s.pop()
thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()
print(x)
多次执行测试结果都不一样。
set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
3、计算集合元素个数 语法格式如下： len(s) 计算集合 s 元素个数。
>>> thisset = set(("Google", "Runoob", "Taobao")) >>> len(thisset) 3 4、清空集合 语法格式如下： s.clear() 清空集合 s。
>>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.clear() >>> print(thisset) set() 5、判断元素是否在集合中存在 语法格式如下： x in s 判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。
>>> thisset = set(("Google", "Runoob", "Taobao")) >>> "Runoob" in thisset True >>> "Facebook" in thisset False >>> 集合内置方法完整列表 方法描述add()为集合添加元素clear()移除集合中的所有元素copy()拷贝一个集合difference()返回多个集合的差集difference_update()移除集合中的元素，该元素在指定的集合也存在。
discard()删除集合中指定的元素intersection()返回集合的交集intersection_update()返回集合的交集。
isdisjoint()判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()判断指定集合是否为该方法参数集合的子集。
issuperset()判断该方法的参数集合是否为指定集合的子集pop()随机移除元素remove()移除指定元素symmetric_difference()返回两个集合中不重复的元素集合。
symmetric_difference_update()移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()返回两个集合的并集update()给集合添加元素 Python3条件控制 Python 条件语句是通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块。
可以通过下图来简单了解条件语句的执行过程:
代码执行过程：
if 语句 Python中if语句的一般形式如下所示：
if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3
如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句
如果 "condition_1" 为False，将判断 "condition_2"
如果"condition_2" 为 True 将执行 "statement_block_2" 块语句
如果 "condition_2" 为False，将执行"statement_block_3"块语句
Python 中用
elif
代替了
else if
，所以if语句的关键字为：
if – elif – else
。
注意： 1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
3、在 Python 中没有 switch...case 语句，但在 Python3.10 版本添加了 match...case，功能也类似，详见下文。
以下为if中常用的操作运算符:
操作符描述<小于<=小于或等于>大于>=大于或等于==等于，比较两个值是否相等!=不等于
if 嵌套
在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。
if 表达式1: 语句 if 表达式2: 语句 elif 表达式3: 语句 else: 语句 elif 表达式4: 语句 else: 语句 match...case Python 3.10 增加了 match...case 的条件判断，不需要再使用一连串的 if-else 来判断了。
match 后的对象会依次与 case 后的内容进行匹配，如果匹配成功，则执行匹配到的表达式，否则直接跳过，_ 可以匹配一切。
语法格式如下：
match subject:
case
case
case
case _:
case _: 类似于 C 和 Java 中的 default:，当其他 case 都无法匹配时，匹配这条，保证永远会匹配成功。
def http_error(status):
match status:
case 400:
return "Bad request"
case 404:
return "Not found"
case 418:
return "I'm a teapot"
case _:
return "Something's wrong with the internet"
mystatus=400
print(http_error(400))
一个 case 也可以设置多个匹配条件，条件使用 ｜ 隔开，例如：
...
case 401|403|404:
return "Not allowed"
Python3循环语句
Python 中的循环语句有 for 和 while。
Python 循环语句的控制结构图如下所示：
while 循环 Python 中 while 语句的一般形式： while 判断条件(condition)： 执行语句(statements)…… 执行流程图如下：
同样需要注意冒号和缩进。
另外，在 Python 中没有 do..while 循环。
无限循环 我们可以通过设置条件表达式永远不为 false 来实现无限循环，实例如下
#!/usr/bin/python3
var = 1
while var == 1 : # 表达式永远为 true
num = int(input("输入一个数字 :"))
print ("你输入的数字是: ", num)
print ("Good bye!")
执行以上脚本，输出结果如下：
输入一个数字 :5
你输入的数字是: 5
输入一个数字 :
可以使用
CTRL+C
来退出当前的无限循环。
无限循环在服务器上客户端的实时请求非常有用。
while 循环使用 else 语句 如果 while 后面的条件语句为 false 时，则执行 else 的语句块。
语法格式如下：
while
else:
expr 条件语句为 true 则执行 statement(s) 语句块，如果为 false，则执行 additional_statement(s)。
循环输出数字，并判断大小： #!/usr/bin/python3 count = 0 while count < 5: print (count, " 小于 5") count = count + 1 else: print (count, " 大于或等于 5") 简单语句组 类似 if 语句的语法，如果你的 while 循环体中只有一条语句，你可以将该语句与 while 写在同一行中， 如下所示：
#!/usr/bin/python
flag = 1
while (flag): print ('欢迎访问菜鸟教程!')
print ("Good bye!")
注意：
以上的无限循环你可以使用 CTRL+C 来中断循环。
for 语句 Python for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串。
for循环的一般格式如下：
for
else:
Python for 循环实例：
#!/usr/bin/python3
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
print(site)
for...else
在 Python 中，for...else 语句用于在循环结束后执行一段代码。
语法格式如下： for item in iterable: # 循环主体 else: # 循环结束后执行的代码 当循环执行完毕（即遍历完 iterable 中的所有元素）后，会执行 else 子句中的代码，如果在循环过程中遇到了 break 语句，则会中断循环，此时不会执行 else 子句。
for x in range(6):
print(x)
else:
print("Finally finished!")
执行脚本后，输出结果为：
0
1
2
3
4
5
Finally finished!
以下 for 实例中使用了 break 语句，break 语句用于跳出当前循环体，不会执行 else 子句：
#!/usr/bin/python3
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
if site == "Runoob":
print("菜鸟教程!")
break
print("循环数据 " + site)
else:
print("没有循环数据!")
print("完成循环!")
执行脚本后，在循环到 "Runoob"时会跳出循环体：
range() 函数
range(start, stop, step) 不包括终值
start初始值
stop终值
step步长
如果你需要遍历数字序列，可以使用内置 range() 函数。
它会生成数列，例如: >>>for i in range(5): ... print(i) ... 0 1 2 3 4 你也可以使用 range() 指定区间的值： >>>for i in range(5,9) : print(i) 5 6 7 8 >>> 也可以使 range() 以指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做'步长'): >>>for i in range(0, 10, 3) : print(i) 0 3 6 9 >>> 负数： >>>for i in range(-10, -100, -30) : print(i) -10 -40 -70 >>> 结合 range() 和 len() 函数以遍历一个序列的索引,如下所示: >>>a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ'] >>> for i in range(len(a)): ... print(i, a[i]) ... 0 Google 1 Baidu 2 Runoob 3 Taobao 4 QQ >>> 可以使用 range() 函数来创建一个列表： >>>list(range(5)) [0, 1, 2, 3, 4] >> break 和 continue 语句及循环中的 else 子句 break 执行流程图：
continue 执行流程图：
while 语句代码执行过程：
for 语句代码执行过程：
break 语句可以跳出 for 和 while 的循环体。
如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
while 中使用 break：
n = 5
while n > 0:
n -= 1
if n == 2:
break
print(n)
print('循环结束。
')
输出结果为：
4
3
循环结束。
while 中使用 continue：
n = 5
while n > 0:
n -= 1
if n == 2:
continue
print(n)
print('循环结束。
')
输出结果为：
4
3
1
0
循环结束。
循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行，但循环被 break 终止时不执行。
#!/usr/bin/python3
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(n, '等于', x, '*', n//x)
break
else:
# 循环中没有找到元素
print(n, ' 是质数')
执行以上脚本输出结果为：
2 是质数
3 是质数
4 等于 2 * 2
5 是质数
6 等于 2 * 3
7 是质数
8 等于 2 * 4
9 等于 3 * 3
pass 语句
Python pass是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句，如下实例 >>>while True: ... pass # 等待键盘中断 (Ctrl+C) 最小的类: >>>class MyEmptyClass: ... pass 以下实例在字母为 o 时 执行 pass 语句块: #!/usr/bin/python3 for letter in 'Runoob': if letter == 'o': pass print ('执行 pass 块') print ('当前字母 :', letter) print ("Good bye!") Python 推导式 Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。
Python 支持各种数据结构的推导式： 列表(list)推导式 字典(dict)推导式 集合(set)推导式 元组(tuple)推导式 列表推导式 列表推导式格式为： [表达式 for 变量 in 列表] [out_exp_res for out_exp in input_list] 或者 [表达式 for 变量 in 列表 if 条件] [out_exp_res for out_exp in input_list if condition] out_exp_res：列表生成元素表达式，可以是有返回值的函数。
for out_exp in input_list：迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。
if condition：条件语句，可以过滤列表中不符合条件的值。
过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母： >>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith'] >>> new_names = [name.upper()for name in names if len(name)>3] >>> print(new_names) ['ALICE', 'JERRY', 'WENDY', 'SMITH'] 计算 30 以内可以被 3 整除的整数： >>> multiples = [i for i in range(30) if i % 3 == 0] >>> print(multiples) [0, 3, 6, 9, 12, 15, 18, 21, 24, 27] 字典推导式 字典推导基本格式： { key_expr: value_expr for value in collection } 或 { key_expr: value_expr for value in collection if condition } 使用字符串及其长度创建字典： listdemo = ['Google','Runoob', 'Taobao'] # 将列表中各字符串值为键，各字符串的长度为值，组成键值对 >>> newdict = {key:len(key) for key in listdemo} >>> newdict {'Google': 6, 'Runoob': 6, 'Taobao': 6} 提供三个数字，以三个数字为键，三个数字的平方为值来创建字典： >>> dic = {x: x**2 for x in (2, 4, 6)} >>> dic {2: 4, 4: 16, 6: 36} >>> type(dic)
集合推导式 集合推导式基本格式： { expression for item in Sequence } 或 { expression for item in Sequence if conditional } 计算数字 1,2,3 的平方数： >>> setnew = {i**2 for i in (1,2,3)} >>> setnew {1, 4, 9} 判断不是 abc 的字母并输出： >>> a = {x for x in 'abracadabra' if x not in 'abc'} >>> a {'d', 'r'} >>> type(a)
元组推导式（生成器表达式） 元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。
元组推导式基本格式： (expression for item in Sequence ) 或 (expression for item in Sequence if conditional ) 元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象。
例如，我们可以使用下面的代码生成一个包含数字 1~9 的元组： >>> a = (x for x in range(1,10)) >>> a
>>> tuple(a) # 使用 tuple() 函数，可以直接将生成器对象转换成元组 (1, 2, 3, 4, 5, 6, 7, 8, 9) Python3 迭代器与生成器 迭代器 迭代是 Python 最强大的功能之一，是访问集合元素的一种方式。
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。
迭代器只能往前不会后退。
迭代器有两个基本的方法： iter() 和 next() 。
字符串，列表或元组对象都可用于创建迭代器： >>> list=[1,2,3,4] >>> it = iter(list) # 创建迭代器对象 >>> print (next(it)) # 输出迭代器的下一个元素 1 >>> print (next(it)) 2 >>> 迭代器对象可以使用常规for语句进行遍历： #!/usr/bin/python3 list=[1,2,3,4] it = iter(list) # 创建迭代器对象 for x in it: print (x, end=" ") 执行以上程序，输出结果如下：
1 2 3 4
也可以使用 next() 函数：
#!/usr/bin/python3
import sys # 引入 sys 模块
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
while True:
try:
print (next(it))
except StopIteration:
sys.exit()
创建一个迭代器
把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。
如果你已经了解的面向对象编程，就知道类都有一个构造函数，Python 的构造函数为 __init__(), 它会在对象初始化的时候执行。
更多内容查阅： Python3 面向对象 __iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。
__next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。
创建一个返回数字的迭代器，初始值为 1，逐步递增 1：
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
x = self.a
self.a += 1
return x
myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
执行输出结果为：
1
2
3
4
5
StopIteration
StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。
在 20 次迭代后停止执行：
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration
myclass = MyNumbers()
myiter = iter(myclass)
for x in myiter:
print(x)
执行输出结果为：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
生成器
在 Python 中，使用了
yield
的函数被称为生成器（generator）。
yield 是一个关键字，用于定义生成器函数，生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果。
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
当在生成器函数中使用 yield 语句时，函数的执行将会暂停，并将 yield 后面的表达式作为当前迭代的值返回。
然后，每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到 yield 语句。
这样，生成器函数可以逐步产生值，而不需要一次性计算并返回所有结果。
调用一个生成器函数，返回的是一个迭代器对象。
下面是一个简单的示例，展示了生成器函数的使用：
def countdown(n):
while n > 0:
yield n
n -= 1
# 创建生成器对象
generator = countdown(5)
# 通过迭代生成器获取值
print(next(generator)) # 输出: 5
print(next(generator)) # 输出: 4
print(next(generator)) # 输出: 3
# 使用 for 循环迭代生成器
for value in generator:
print(value) # 输出: 2 1
以上实例中，
countdown
函数是一个生成器函数。
它使用 yield 语句逐步产生从 n 到 1 的倒数数字。
在每次调用 yield 语句时，函数会返回当前的倒数值，并在下一次调用时从上次暂停的地方继续执行。
通过创建生成器对象并使用 next() 函数或 for 循环迭代生成器，我们可以逐步获取生成器函数产生的值。
在这个例子中，我们首先使用 next() 函数获取前三个倒数值，然后通过 for 循环获取剩下的两个倒数值。
生成器函数的优势是它们可以按需生成值，避免一次性生成大量数据并占用大量内存。
此外，生成器还可以与其他迭代工具（如for循环）无缝配合使用，提供简洁和高效的迭代方式。
执行以上程序，输出结果如下： 5 4 3 2 1 以下实例使用 yield 实现斐波那契数列：
#!/usr/bin/python3
import sys
def fibonacci(n): # 生成器函数 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()
执行以上程序，输出结果如下：
0 1 1 2 3 5 8 13 21 34 55
常见模块
os模块:
引用菜鸟论坛标准库概览：
Python3 标准库概览 | 菜鸟教程Python3 标准库概览 Python 标准库非常庞大，所提供的组件涉及范围十分广泛，使用标准库我们可以让您轻松地完成各种任务。
以下是一些 Python3 标准库中的模块： os 模块：os 模块提供了许多与操作系统交互的函数，例如创建、移动和删除文件和目录，以及访问环境变量等。
sys 模块：sys 模块提供了与 Python 解释器和系统相关的功能，例如解释器的版本和路径，以及与 stdin、stdout 和 stderr 相关的..https://www.runoob.com/python3/python3-stdlib.html os.remove() 删除文 os.unlink() 删除文件 os.rename() 重命名文件 os.listdir() 列出指定目录下所有文件 os.chdir() 改变当前工作目录 os.getcwd() 获取当前文件路径 os.mkdir() 新建目录 os.rmdir() 删除空目录(删除非空目录, 使用shutil.rmtree()) os.makedirs() 创建多级目录 os.removedirs() 删除多级目录 os.stat(file) 获取文件属性 os.chmod(file) 修改文件权限 os.utime(file) 修改文件时间戳 os.name(file) 获取操作系统标识 os.system() 执行操作系统命令 os.execvp() 启动一个新进程 os.fork() 获取父进程ID，在子进程返回中返回0 os.execvp() 执行外部程序脚本（Uinx） os.spawn() 执行外部程序脚本（Windows） os.access(path, mode) 判断文件权限(详细参考cnblogs) os.wait() 暂时未知 os.path模块： os.path.split(filename) 将文件路径和文件名分割(会将最后一个目录作为文件名而分离) os.path.splitext(filename) 将文件路径和文件扩展名分割成一个元组 os.path.dirname(filename) 返回文件路径的目录部分 os.path.basename(filename) 返回文件路径的文件名部分 os.path.join(dirname,basename) 将文件路径和文件名凑成完整文件路径 os.path.abspath(name) 获得绝对路径 os.path.splitunc(path) 把路径分割为挂载点和文件名 os.path.normpath(path) 规范path字符串形式 os.path.exists() 判断文件或目录是否存在 os.path.isabs() 如果path是绝对路径，返回True os.path.realpath(path) #返回path的真实路径 os.path.relpath(path[, start]) #从start开始计算相对路径 os.path.normcase(path) #转换path的大小写和斜杠 os.path.isdir() 判断name是不是一个目录，name不是目录就返回false os.path.isfile() 判断name是不是一个文件，不存在返回false os.path.islink() 判断文件是否连接文件,返回boolean os.path.ismount() 指定路径是否存在且为一个挂载点，返回boolean os.path.samefile() 是否相同路径的文件，返回boolean os.path.getatime() 返回最近访问时间 浮点型 os.path.getmtime() 返回上一次修改时间 浮点型 os.path.getctime() 返回文件创建时间 浮点型 os.path.getsize() 返回文件大小 字节单位 os.path.commonprefix(list) #返回list(多个路径)中，所有path共有的最长的路径 os.path.lexists #路径存在则返回True,路径损坏也返回True os.path.expanduser(path) #把path中包含的”~”和”~user”转换成用户目录 os.path.expandvars(path) #根据环境变量的值替换path中包含的”$name”和”${name}” os.path.sameopenfile(fp1, fp2) #判断fp1和fp2是否指向同一文件 os.path.samestat(stat1, stat2) #判断stat tuple stat1和stat2是否指向同一个文件 os.path.splitdrive(path) #一般用在windows下，返回驱动器名和路径组成的元组 os.path.walk(path, visit, arg) #遍历path，给每个path执行一个函数详细见手册 os.path.supports_unicode_filenames() 设置是否支持unicode路径名 序号方法及描述1os.access(path, mode)检验权限模式2os.chdir(path)改变当前工作目录3os.chflags(path, flags)设置路径的标记为数字标记。
4os.chmod(path, mode)更改权限5os.chown(path, uid, gid)更改文件所有者6os.chroot(path)改变当前进程的根目录7os.close(fd)关闭文件描述符 fd8os.closerange(fd_low, fd_high)关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略9os.dup(fd)复制文件描述符 fd10os.dup2(fd, fd2)将一个文件描述符 fd 复制到另一个 fd211os.fchdir(fd)通过文件描述符改变当前工作目录12os.fchmod(fd, mode)改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。
13os.fchown(fd, uid, gid)修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
14os.fdatasync(fd)强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。
15os.fdopen(fd[, mode[, bufsize]])通过文件描述符 fd 创建一个文件对象，并返回这个文件对象16os.fpathconf(fd, name)返回一个打开的文件的系统配置信息。
name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
17os.fstat(fd)返回文件描述符fd的状态，像stat()。
18os.fstatvfs(fd)返回包含文件描述符fd的文件的文件系统的信息，Python 3.3 相等于 statvfs()。
19os.fsync(fd)强制将文件描述符为fd的文件写入硬盘。
20os.ftruncate(fd, length)裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。
21os.getcwd()返回当前工作目录22os.getcwdb()返回一个当前工作目录的Unicode对象23os.isatty(fd)如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。
24os.lchflags(path, flags)设置路径的标记为数字标记，类似 chflags()，但是没有软链接25os.lchmod(path, mode)修改连接文件权限26os.lchown(path, uid, gid)更改文件所有者，类似 chown，但是不追踪链接。
27os.link(src, dst)创建硬链接，名为参数 dst，指向参数 src28os.listdir(path)返回path指定的文件夹包含的文件或文件夹的名字的列表。
29os.lseek(fd, pos, how)设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效30os.lstat(path)像stat(),但是没有软链接31os.major(device)从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。
32os.makedev(major, minor)以major和minor设备号组成一个原始设备号33os.makedirs(path[, mode])递归文件夹创建函数。
像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。
34os.minor(device)从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。
35os.mkdir(path[, mode])以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。
36os.mkfifo(path[, mode])创建命名管道，mode 为数字，默认为 0666 (八进制)37os.mknod(filename[, mode=0600, device])创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。
38os.open(file, flags[, mode])打开一个文件，并且设置需要的打开选项，mode参数是可选的39os.openpty()打开一个新的伪终端对。
返回 pty 和 tty的文件描述符。
40os.pathconf(path, name)返回相关文件的系统配置信息。
41os.pipe()创建一个管道. 返回一对文件描述符(r, w) 分别为读和写42os.popen(command[, mode[, bufsize]])从一个 command 打开一个管道43os.read(fd, n)从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
44os.readlink(path)返回软链接所指向的文件45os.remove(path)删除路径为path的文件。
如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。
46os.removedirs(path)递归删除目录。
47os.rename(src, dst)重命名文件或目录，从 src 到 dst48os.renames(old, new)递归地对目录进行更名，也可以对文件进行更名。
49os.rmdir(path)删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
50os.stat(path)获取path指定的路径的信息，功能等同于C API中的stat()系统调用。
51os.stat_float_times([newvalue])决定stat_result是否以float对象显示时间戳52os.statvfs(path)获取指定路径的文件系统统计信息53os.symlink(src, dst)创建一个软链接54os.tcgetpgrp(fd)返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组55os.tcsetpgrp(fd, pg)设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。
56os.tempnam([dir[, prefix]])Python3 中已删除。
返回唯一的路径名用于创建临时文件。
57os.tmpfile()Python3 中已删除。
返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。
58os.tmpnam()Python3 中已删除。
为创建一个临时文件返回一个唯一的路径59os.ttyname(fd)返回一个字符串，它表示与文件描述符fd 关联的终端设备。
如果fd 没有与终端设备关联，则引发一个异常。
60os.unlink(path)删除文件路径61os.utime(path, times)返回指定的path文件的访问和修改的时间。
62os.walk(top[, topdown=True[, οnerrοr=None[, followlinks=False]]])输出在文件夹中的文件名通过在树中游走，向上或者向下。
63os.write(fd, str)写入字符串到文件描述符 fd中. 返回实际写入的字符串长度64os.path 模块获取文件的属性信息。
65os.pardir()获取当前目录的父目录，以字符串形式显示目录名。
66os.replace()重命名文件或目录。
Python3 File(文件) 方法 open() 方法 Python open() 方法用于打开一个文件，并返回文件对象。
在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
注意： 使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。
open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。
open(file, mode='r') 完整的语法格式为： open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None) 参数说明: file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式 buffering: 设置缓冲 encoding: 一般使用utf8 errors: 报错级别 newline: 区分换行符 closefd: 传入的file参数类型 opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。
mode 参数有： 模式描述t文本模式 (默认)。
x写模式，新建一个文件，如果该文件已存在则会报错。
b二进制模式。
+打开一个文件进行更新(可读可写)。
U通用换行模式（Python 3 不支持）。
r以只读方式打开文件。
文件的指针将会放在文件的开头。
这是默认模式。
rb以二进制格式打开一个文件用于只读。
文件指针将会放在文件的开头。
这是默认模式。
一般用于非文本文件如图片等。
r+打开一个文件用于读写。
文件指针将会放在文件的开头。
rb+以二进制格式打开一个文件用于读写。
文件指针将会放在文件的开头。
一般用于非文本文件如图片等。
w打开一个文件只用于写入。
如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。
如果该文件不存在，创建新文件。
wb以二进制格式打开一个文件只用于写入。
如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。
如果该文件不存在，创建新文件。
一般用于非文本文件如图片等。
w+打开一个文件用于读写。
如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。
如果该文件不存在，创建新文件。
wb+以二进制格式打开一个文件用于读写。
如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。
如果该文件不存在，创建新文件。
一般用于非文本文件如图片等。
a打开一个文件用于追加。
如果该文件已存在，文件指针将会放在文件的结尾。
也就是说，新的内容将会被写入到已有内容之后。
如果该文件不存在，创建新文件进行写入。
ab以二进制格式打开一个文件用于追加。
如果该文件已存在，文件指针将会放在文件的结尾。
也就是说，新的内容将会被写入到已有内容之后。
如果该文件不存在，创建新文件进行写入。
a+打开一个文件用于读写。
如果该文件已存在，文件指针将会放在文件的结尾。
文件打开时会是追加模式。
如果该文件不存在，创建新文件用于读写。
ab+以二进制格式打开一个文件用于追加。
如果该文件已存在，文件指针将会放在文件的结尾。
如果该文件不存在，创建新文件用于读写。
默认为文本模式，如果要以二进制模式打开，加上 b 。
file 对象 file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数： 序号方法及描述1file.close()关闭文件。
关闭后文件不能再进行读写操作。
2file.flush()刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3file.fileno()返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
4file.isatty()如果文件连接到一个终端设备返回 True，否则返回 False。
5file.next()Python 3 中的 File 对象不支持 next() 方法。
返回文件下一行。
6file.read([size])从文件读取指定的字节数，如果未给定或为负则读取所有。
7file.readline([size])读取整行，包括 "\n" 字符。
8file.readlines([sizeint])读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
9file.seek(offset[, whence])移动文件读取指针到指定位置10file.tell()返回文件当前位置。
11file.truncate([size])从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。
12file.write(str)将字符串写入文件，返回的是写入的字符长度。
13file.writelines(sequence)向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。
Python3 输入和输出 输出格式美化 Python两种输出值的方式: 表达式语句和 print() 函数。
第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。
如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。
如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。
str()： 函数返回一个用户易读的表达形式。
repr()： 产生一个解释器易读的表达形式。
>>> s = 'Hello, Runoob' >>> str(s) 'Hello, Runoob' >>> repr(s) "'Hello, Runoob'" >>> str(1/7) '0.14285714285714285' >>> x = 10 * 3.25 >>> y = 200 * 200 >>> s = 'x 的值为： ' + repr(x) + ', y 的值为：' + repr(y) + '...' >>> print(s) x 的值为： 32.5, y 的值为：40000... >>> # repr() 函数可以转义字符串中的特殊字符 ... hello = 'hello, runoob\n' >>> hellos = repr(hello) >>> print(hellos) 'hello, runoob\n' >>> # repr() 的参数可以是 Python 的任何对象 ... repr((x, y, ('Google', 'Runoob'))) "(32.5, 40000, ('Google', 'Runoob'))" 这里有两种方式输出一个平方与立方的表:
>>> for x in range(1, 11):
... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
... # 注意前一行 'end' 的使用
... print(repr(x*x*x).rjust(4))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
>>> for x in range(1, 11):
... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
注意：
在第一个例子中, 每列间的空格由 print() 添加。
这个例子展示了字符串对象的 rjust() 方法, 它可以将字符串靠右, 并在左边填充空格。
还有类似的方法, 如 ljust() 和 center()。
这些方法并不会写任何东西, 它们仅仅返回新的字符串。
另一个方法 zfill(), 它会在数字的左边填充 0，如下所示：
>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'
str.format() 的基本使用如下:
>>> print('{}网址： "{}!"'.format('菜鸟教程', 'www.runoob.com'))
菜鸟教程网址： "www.runoob.com!"
括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。
在括号中的数字用于指向传入对象在 format() 中的位置，如下所示：
>>> print('{0} 和 {1}'.format('Google', 'Runoob'))
Google 和 Runoob
>>> print('{1} 和 {0}'.format('Google', 'Runoob'))
Runoob 和 Google
如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。
>>> print('{name}网址： {site}'.format(name='菜鸟教程', site='www.runoob.com'))
菜鸟教程网址： www.runoob.com
位置及关键字参数可以任意的结合:
>>> print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'Runoob', other='Taobao'))
站点列表 Google, Runoob, 和 Taobao。
!a (使用
ascii()
), !s (使用
str()
) 和 !r (使用
repr()
) 可以用于在格式化某个值之前对其进行转化:
>>> import math
>>> print('常量 PI 的值近似为： {}。
'.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。
>>> print('常量 PI 的值近似为： {!r}。
'.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。
可选项 : 和格式标识符可以跟着字段名。
这就允许对值进行更好的格式化。
下面的例子将 Pi 保留到小数点后三位：
>>> import math
>>> print('常量 PI 的值近似为 {0:.3f}。
'.format(math.pi))
常量 PI 的值近似为 3.142。
在 : 后传入一个整数, 可以保证该域至少有这么多的宽度。
用于美化表格时很有用。
>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> for name, number in table.items():
... print('{0:10} ==> {1:10d}'.format(name, number))
...
Google ==> 1
Runoob ==> 2
Taobao ==> 3
如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。
最简单的就是传入一个字典, 然后使用方括号 [] 来访问键值 :
>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> print('Runoob: {0[Runoob]:d}; Google: {0[Google]:d}; Taobao: {0[Taobao]:d}'.format(table))
Runoob: 2; Google: 1; Taobao: 3
也可以通过在 table 变量前使用 ** 来实现相同的功能：
>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> print('Runoob: {Runoob:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
Runoob: 2; Google: 1; Taobao: 3
旧式字符串格式化
% 操作符也可以实现字符串格式化。
它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的代入, 然后返回格式化后的字符串. 例如:
>>> import math
>>> print('常量 PI 的值近似为：%5.3f。
' % math.pi)
常量 PI 的值近似为：3.142。
因为 str.format() 是比较新的函数， 大多数的 Python 代码仍然使用 % 操作符。
但是因为这种旧式的格式化最终会从该语言中移除, 应该更多的使用 str.format(). 读取键盘输入 Python 提供了 input() 内置函数 从标准输入读入一行文本，默认的标准输入是键盘。
函数语法
input([prompt])
参数说明： prompt: 提示信息
#!/usr/bin/python3
str = input("请输入：");
print ("你输入的内容是: ", str)
读和写文件
open() 将会返回一个 file 对象，基本语法格式如下:
open(filename, mode)
filename：包含了你要访问的文件名称的字符串值。
mode：决定了打开文件的模式：只读，写入，追加等。
所有可取值见如下的完全列表。
这个参数是非强制的，默认文件访问模式为只读(r)。
不同模式打开文件的完全列表： 模式描述r以只读方式打开文件。
文件的指针将会放在文件的开头。
这是默认模式。
rb以二进制格式打开一个文件用于只读。
文件指针将会放在文件的开头。
r+打开一个文件用于读写。
文件指针将会放在文件的开头。
rb+以二进制格式打开一个文件用于读写。
文件指针将会放在文件的开头。
w打开一个文件只用于写入。
如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。
如果该文件不存在，创建新文件。
wb以二进制格式打开一个文件只用于写入。
如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。
如果该文件不存在，创建新文件。
w+打开一个文件用于读写。
如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。
如果该文件不存在，创建新文件。
wb+以二进制格式打开一个文件用于读写。
如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。
如果该文件不存在，创建新文件。
a打开一个文件用于追加。
如果该文件已存在，文件指针将会放在文件的结尾。
也就是说，新的内容将会被写入到已有内容之后。
如果该文件不存在，创建新文件进行写入。
ab以二进制格式打开一个文件用于追加。
如果该文件已存在，文件指针将会放在文件的结尾。
也就是说，新的内容将会被写入到已有内容之后。
如果该文件不存在，创建新文件进行写入。
a+打开一个文件用于读写。
如果该文件已存在，文件指针将会放在文件的结尾。
文件打开时会是追加模式。
如果该文件不存在，创建新文件用于读写。
ab+以二进制格式打开一个文件用于追加。
如果该文件已存在，文件指针将会放在文件的结尾。
如果该文件不存在，创建新文件用于读写。
以下实例将字符串写入到文件 foo.txt 中：
实例
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo.txt", "w")
f.write( "Python 是一个非常好的语言。
\n是的，的确非常好!!\n" )
# 关闭打开的文件
f.close()
第一个参数为要打开的文件名。
第二个参数描述文件如何使用的字符。
mode 可以是 'r' 如果文件只读, 'w' 只用于写 (如果存在同名文件则将被删除), 和 'a' 用于追加文件内容; 所写的任何数据都会被自动增加到末尾. 'r+' 同时用于读写。
mode 参数是可选的; 'r' 将是默认值。
此时打开文件 foo.txt,显示如下：
$ cat /tmp/foo.txt
Python 是一个非常好的语言。
是的，的确非常好!!
文件对象的方法
本节中剩下的例子假设已经创建了一个称为 f 的文件对象。
f.read() 为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。
size 是一个可选的数字类型的参数。
当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。
以下实例假定文件 foo.txt 已存在（上面实例中已创建）：
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo.txt", "r")
str = f.read()
print(str)
# 关闭打开的文件
f.close()
执行以上程序，输出结果为：
Python 是一个非常好的语言。
是的，的确非常好!!
f.readline()
f.readline() 会从文件中读取单独的一行。
换行符为 '\n'。
f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo.txt", "r")
str = f.readline()
print(str)
# 关闭打开的文件
f.close()
执行以上程序，输出结果为：
Python 是一个非常好的语言。
f.readlines()
f.readlines() 将返回该文件中包含的所有行。
如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo.txt", "r")
str = f.readlines()
print(str)
# 关闭打开的文件
f.close()
执行以上程序，输出结果为：
['Python 是一个非常好的语言。
\n', '是的，的确非常好!!\n']
f.write()
f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo.txt", "w")
num = f.write( "Python 是一个非常好的语言。
\n是的，的确非常好!!\n" )
print(num)
# 关闭打开的文件
f.close()
执行以上程序，输出结果为：
29
如果要写入一些不是字符串的东西, 那么将需要先进行转换:
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo1.txt", "w")
value = ('www.runoob.com', 14)
s = str(value)
f.write(s)
# 关闭打开的文件
f.close()
执行以上程序，打开 foo1.txt 文件：
$ cat /tmp/foo1.txt
('www.runoob.com', 14)
f.tell()
f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。
f.seek() 如果要改变文件指针当前的位置, 可以使用 f.seek(offset, from_what) 函数。
from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如： seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符 seek(x,1) ： 表示从当前位置往后移动x个字符 seek(-x,2)：表示从文件的结尾往前移动x个字符 from_what 值为默认为0，即文件开头。
下面给出一个完整的例子：
>>> f = open('/tmp/foo.txt', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5) # 移动到文件的第六个字节
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # 移动到文件的倒数第三字节
13
>>> f.read(1)
b'd'
f.close()
在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。
当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。
>>> f.close()
>>> f.read()
Traceback (most recent call last):
File "", line 1, in ?
ValueError: I/O operation on closed file
当处理一个文件对象时, 使用 with 关键字是非常好的方式。
在结束后, 它会帮你正确的关闭文件。
而且写起来也比 try - finally 语句块要简短:
>>> with open('/tmp/foo.txt', 'r') as f:
... read_data = f.read()
>>> f.closed
True
文件对象还有其他方法, 如 isatty() 和 trucate(), 但这些通常比较少用。
pickle 模块 python的pickle模块实现了基本的数据序列和反序列化。
通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。
通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。
基本接口： pickle.dump(obj, file, [,protocol]) 有了 pickle 这个对象, 就能对 file 以读取的形式打开: x = pickle.load(file) 注解： 从 file 中读取一个字符串，并将它重构为原来的python对象。
file: 类文件对象，有read()和readline()接口。
2个实例
#!/usr/bin/python3
import pickle
# 使用pickle模块将数据对象保存到文件
data1 = {'a': [1, 2.0, 3, 4+6j],
'b': ('string', u'Unicode string'),
'c': None}
selfref_list = [1, 2, 3]
selfref_list.append(selfref_list)
output = open('data.pkl', 'wb')
# Pickle dictionary using protocol 0.
pickle.dump(data1, output)
# Pickle the list using the highest protocol available.
pickle.dump(selfref_list, output, -1)
output.close()
#!/usr/bin/python3
import pprint, pickle
#使用pickle模块从文件中重构python对象
pkl_file = open('data.pkl', 'rb')
data1 = pickle.load(pkl_file)
pprint.pprint(data1)
data2 = pickle.load(pkl_file)
pprint.pprint(data2)
pkl_file.close()
stat模块：
描述os.stat()返回的文件属性列表中各值的意义
fileStats = os.stat(path) 获取到的文件属性列表
fileStats[stat.ST_MODE] 获取文件的模式
fileStats[stat.ST_SIZE] 文件大小
fileStats[stat.ST_MTIME] 文件最后修改时间
fileStats[stat.ST_ATIME] 文件最后访问时间
fileStats[stat.ST_CTIME] 文件创建时间
stat.S_ISDIR(fileStats[stat.ST_MODE]) 是否目录
stat.S_ISREG(fileStats[stat.ST_MODE]) 是否一般文件
stat.S_ISLNK(fileStats[stat.ST_MODE]) 是否连接文件
stat.S_ISSOCK(fileStats[stat.ST_MODE]) 是否COCK文件
stat.S_ISFIFO(fileStats[stat.ST_MODE]) 是否命名管道
stat.S_ISBLK(fileStats[stat.ST_MODE]) 是否块设备
stat.S_ISCHR(fileStats[stat.ST_MODE]) 是否字符设置
sys模块：
sys.argv 命令行参数List，第一个元素是程序本身路径
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.modules.keys() 返回所有已经导入的模块列表
sys.modules 返回系统导入的模块字段，key是模块名，value是模块
sys.exc_info() 获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息
sys.exit(n) 退出程序，正常退出时exit(0)
sys.hexversion 获取Python解释程序的版本值，16进制格式如：0x020403F0
sys.version 获取Python解释程序的版本信息
sys.platform 返回操作系统平台名称
sys.stdout 标准输出
sys.stdout.write(‘aaa‘) 标准输出内容
sys.stdout.writelines() 无换行输出
sys.stdin 标准输入
sys.stdin.read() 输入一行
sys.stderr 错误输出
sys.exc_clear() 用来清除当前线程所出现的当前的或最近的错误信息
sys.exec_prefix 返回平台独立的python文件安装的位置
sys.byteorder 本地字节规则的指示器，big-endian平台的值是‘big‘,little-endian平台的值是‘little‘
sys.copyright 记录python版权相关的东西
sys.api_version 解释器的C的API版本
sys.version_info ‘final‘表示最终,也有‘candidate‘表示候选，表示版本级别，是否有后继的发行
sys.getdefaultencoding() 返回当前你所用的默认的字符编码格式
sys.getfilesystemencoding() 返回将Unicode文件名转换成系统文件名的编码的名字
sys.builtin_module_names Python解释器导入的内建模块列表
sys.executable Python解释程序路径
sys.getwindowsversion() 获取Windows的版本
sys.stdin.readline() 从标准输入读一行，sys.stdout.write(“a”) 屏幕输出a
sys.setdefaultencoding(name) 用来设置当前默认的字符编码(详细使用参考文档)
sys.displayhook(value) 如果value非空，这个函数会把他输出到sys.stdout(详细使用参考文档)
datetime,date,time模块：
datetime.date.today() 本地日期对象,(用str函数可得到它的字面表示(2014-03-24))
datetime.date.isoformat(obj) 当前[年-月-日]字符串表示(2014-03-24)
datetime.date.fromtimestamp() 返回一个日期对象，参数是时间戳,返回 [年-月-日]
datetime.date.weekday(obj) 返回一个日期对象的星期数,周一是0
datetime.date.isoweekday(obj) 返回一个日期对象的星期数,周一是1
datetime.date.isocalendar(obj) 把日期对象返回一个带有年月日的元组
datetime对象：
datetime.datetime.today() 返回一个包含本地时间(含微秒数)的datetime对象 2014-03-24 23:31:50.419000
datetime.datetime.now([tz]) 返回指定时区的datetime对象 2014-03-24 23:31:50.419000
datetime.datetime.utcnow() 返回一个零时区的datetime对象
datetime.fromtimestamp(timestamp[,tz]) 按时间戳返回一个datetime对象，可指定时区,可用于strftime转换为日期表示
datetime.utcfromtimestamp(timestamp) 按时间戳返回一个UTC-datetime对象
datetime.datetime.strptime(‘2014-03-16 12:21:21‘,”%Y-%m-%d %H:%M:%S”) 将字符串转为datetime对象
datetime.datetime.strftime(datetime.datetime.now(), ‘%Y%m%d %H%M%S‘) 将datetime对象转换为str表示形式
datetime.date.today().timetuple() 转换为时间戳datetime元组对象，可用于转换时间戳
datetime.datetime.now().timetuple()
time.mktime(timetupleobj) 将datetime元组对象转为时间戳
time.time() 当前时间戳
time.localtime
time.gmtime
hashlib,md5模块：
hashlib.md5(‘md5_str‘).hexdigest() 对指定字符串md5加密
md5.md5(‘md5_str‘).hexdigest() 对指定字符串md5加密
random模块：
random.random() 产生0-1的随机浮点数
random.uniform(a, b) 产生指定范围内的随机浮点数
random.randint(a, b) 产生指定范围内的随机整数
random.randrange([start], stop[, step]) 从一个指定步长的集合中产生随机数
random.choice(sequence) 从序列中产生一个随机数
random.shuffle(x[, random]) 将一个列表中的元素打乱
random.sample(sequence, k) 从序列中随机获取指定长度的片断
方法描述seed()初始化随机数生成器getstate()返回捕获生成器当前内部状态的对象。
setstate()state 应该是从之前调用 getstate() 获得的，并且 setstate() 将生成器的内部状态恢复到 getstate() 被调用时的状态。
getrandbits(k)返回具有 k 个随机比特位的非负 Python 整数。
此方法随 MersenneTwister 生成器一起提供，其他一些生成器也可能将其作为 API 的可选部分提供。
在可能的情况下，getrandbits() 会启用 randrange() 来处理任意大的区间。
randrange()从 range(start, stop, step) 返回一个随机选择的元素。
randint(a, b)返回随机整数 N 满足 a <= N <= b。
choice(seq)从非空序列 seq 返回一个随机元素。
如果 seq 为空，则引发 IndexError。
choices(population, weights=None, *, cum_weights=None, k=1)从 population 中选择替换，返回大小为 k 的元素列表。
如果 population 为空，则引发 IndexError。
shuffle(x[, random])将序列 x 随机打乱位置。
sample(population, k, *, counts=None)返回从总体序列或集合中选择的唯一元素的 k 长度列表。
用于无重复的随机抽样。
random()返回 [0.0, 1.0) 范围内的下一个随机浮点数。
uniform()返回一个随机浮点数 N ，当 a <= b 时 a <= N <= b ，当 b < a 时 b <= N <= a 。
triangular(low, high, mode)返回一个随机浮点数 N ，使得 low <= N <= high 并在这些边界之间使用指定的 mode 。
low 和 high 边界默认为零和一。
mode 参数默认为边界之间的中点，给出对称分布。
betavariate(alpha, beta)Beta 分布。
参数的条件是 alpha > 0 和 beta > 0。
返回值的范围介于 0 和 1 之间。
expovariate(lambd)指数分布。
lambd 是 1.0 除以所需的平均值，它应该是非零的。
gammavariate()Gamma 分布（ 不是伽马函数） 参数的条件是 alpha > 0 和 beta > 0。
gauss(mu, sigma)正态分布，也称高斯分布。
mu 为平均值，而 sigma 为标准差。
此函数要稍快于下面所定义的 normalvariate() 函数。
lognormvariate(mu, sigma)对数正态分布。
如果你采用这个分布的自然对数，你将得到一个正态分布，平均值为 mu 和标准差为 sigma 。
mu 可以是任何值，sigma 必须大于零。
normalvariate(mu, sigma)正态分布。
mu 是平均值，sigma 是标准差。
vonmisesvariate(mu, kappa)冯·米塞斯分布。
mu 是平均角度，以弧度表示，介于0和 2*pi 之间，kappa 是浓度参数，必须大于或等于零。
如果 kappa 等于零，则该分布在 0 到 2*pi 的范围内减小到均匀的随机角度。
paretovariate(alpha)帕累托分布。
alpha 是形状参数。
weibullvariate(alpha, beta)威布尔分布。
alpha 是比例参数，beta 是形状参数。
Python3 日期和时间 Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。
Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。
时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从 1970 年 1 月 1 日午夜（历元）经过了多长时间来表示。
Python 的 time 模块下有很多函数可以转换常见日期格式。
如函数 time.time() 用于获取当前时间戳, 如下实例:
#!/usr/bin/python3
import time # 引入time模块
ticks = time.time()
print ("当前时间戳为:", ticks)
以上实例输出结果：
当前时间戳为: 1459996086.7115328
时间戳单位最适于做日期运算。
但是1970年之前的日期就无法以此表示了。
太遥远的日期也不行，UNIX和Windows只支持到2038年。
什么是时间元组？
很多Python函数用一个元组装起来的9组数字处理时间: 序号字段值04位数年20081月1 到 122日1到313小时0到234分钟0到595秒0到61 (60或61 是闰秒)6一周的第几日0到6 (0是周一)7一年的第几日1到366 (儒略历)8夏令时-1, 0, 1, -1是决定是否为夏令时的标识 上述也就是 struct_time 元组。
这种结构具有如下属性： 序号属性值0tm_year20081tm_mon1 到 122tm_mday1 到 313tm_hour0 到 234tm_min0 到 595tm_sec0 到 61 (60或61 是闰秒)6tm_wday0 到 6 (0是周一)7tm_yday一年中的第几天，1 到 3668tm_isdst是否为夏令时，值有：1(夏令时)、0(不是夏令时)、-1(未知)，默认 -1 获取当前时间 从返回浮点数的时间戳方式向时间元组转换，只要将浮点数传递给如localtime之类的函数。
#!/usr/bin/python3
import time
localtime = time.localtime(time.time())
print ("本地时间为 :", localtime)
以上实例输出结果：
本地时间为 : time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=28, tm_sec=49, tm_wday=3, tm_yday=98, tm_isdst=0)
获取格式化的时间 你可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime():
#!/usr/bin/python3
import time
localtime = time.asctime( time.localtime(time.time()) )
print ("本地时间为 :", localtime)
格式化日期 我们可以使用 time 模块的 strftime 方法来格式化日期： time.strftime(format[, t])
#!/usr/bin/python3
import time
# 格式化成2016-03-20 11:45:39形式
print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
# 格式化成Sat Mar 28 22:24:24 2016形式
print (time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))
# 将格式字符串转换为时间戳
a = "Sat Mar 28 22:24:24 2016"
print (time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y")))
以上实例输出结果：
2016-04-07 10:29:46
Thu Apr 07 10:29:46 2016
1459175064.0
python中时间日期格式化符号： %y 两位数的年份表示（00-99） %Y 四位数的年份表示（000-9999） %m 月份（01-12） %d 月内中的一天（0-31） %H 24小时制小时数（0-23） %I 12小时制小时数（01-12） %M 分钟数（00=59） %S 秒（00-59） %a 本地简化星期名称 %A 本地完整星期名称 %b 本地简化的月份名称 %B 本地完整的月份名称 %c 本地相应的日期表示和时间表示 %j 年内的一天（001-366） %p 本地A.M.或P.M.的等价符 %U 一年中的星期数（00-53）星期天为星期的开始 %w 星期（0-6），星期天为星期的开始 %W 一年中的星期数（00-53）星期一为星期的开始 %x 本地相应的日期表示 %X 本地相应的时间表示 %Z 当前时区的名称 %% %号本身 获取某月日历 Calendar 模块有很广泛的方法用来处理年历和月历，例如打印某月的月历：
#!/usr/bin/python3
import calendar
cal = calendar.month(2016, 1)
print ("以下输出2016年1月份的日历:")
print (cal)
以上实例输出结果：
以下输出2016年1月份的日历:
January 2016
Mo Tu We Th Fr Sa Su
1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31
Time 模块 Time 模块包含了以下内置函数，既有时间处理的，也有转换时间格式的： 序号函数及描述实例1time.altzone返回格林威治西部的夏令时地区的偏移秒数。
如果该地区在格林威治东部会返回负值（如西欧，包括英国）。
对夏令时启用地区才能使用。
以下实例展示了 altzone()函数的使用方法：>>> import time
>>> print ("time.altzone %d " % time.altzone)
time.altzone -28800 2time.asctime([tupletime])接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。
以下实例展示了 asctime()函数的使用方法：>>> import time
>>> t = time.localtime()
>>> print ("time.asctime(t): %s " % time.asctime(t))
time.asctime(t): Thu Apr 7 10:36:20 2016 3time.clock()用以浮点数计算的秒数返回当前的CPU时间。
用来衡量不同程序的耗时，比time.time()更有用。
实例由于该方法依赖操作系统，在 Python 3.3 以后不被推荐，而在 3.8 版本中被移除，需使用下列两个函数替代。
time.perf_counter() # 返回系统运行时间
time.process_time() # 返回进程运行时间4time.ctime([secs])作用相当于asctime(localtime(secs))，未给参数相当于asctime()以下实例展示了 ctime()函数的使用方法：>>> import time
>>> print ("time.ctime() : %s" % time.ctime())
time.ctime() : Thu Apr 7 10:51:58 20165time.gmtime([secs])接收时间戳（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。
注：t.tm_isdst始终为0以下实例展示了 gmtime()函数的使用方法：>>> import time
>>> print ("gmtime :", time.gmtime(1455508609.34375))
gmtime : time.struct_time(tm_year=2016, tm_mon=2, tm_mday=15, tm_hour=3, tm_min=56, tm_sec=49, tm_wday=0, tm_yday=46, tm_isdst=0)6time.localtime([secs]接收时间戳（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。
以下实例展示了 localtime()函数的使用方法：>>> import time
>>> print ("localtime(): ", time.localtime(1455508609.34375))
localtime(): time.struct_time(tm_year=2016, tm_mon=2, tm_mday=15, tm_hour=11, tm_min=56, tm_sec=49, tm_wday=0, tm_yday=46, tm_isdst=0)7time.mktime(tupletime)接受时间元组并返回时间戳（1970纪元后经过的浮点秒数）。
实例8time.sleep(secs)推迟调用线程的运行，secs指秒数。
以下实例展示了 sleep()函数的使用方法：#!/usr/bin/python3
import time
print ("Start : %s" % time.ctime()) time.sleep( 5 ) print ("End : %s" % time.ctime())9time.strftime(fmt[,tupletime])接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。
以下实例展示了 strftime()函数的使用方法：>>> import time
>>> print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
2016-04-07 11:18:0510time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')根据fmt的格式把一个时间字符串解析为时间元组。
以下实例展示了 strptime()函数的使用方法：>>> import time
>>> struct_time = time.strptime("30 Nov 00", "%d %b %y")
>>> print ("返回元组: ", struct_time)
返回元组: time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)11time.time( )返回当前时间的时间戳（1970纪元后经过的浮点秒数）。
以下实例展示了 time()函数的使用方法：>>> import time
>>> print(time.time())
1459999336.196357712time.tzset()根据环境变量TZ重新初始化时间相关设置。
实例13time.perf_counter()返回计时器的精准时间（系统的运行时间），包含整个系统的睡眠时间。
由于返回值的基准点是未定义的，所以，只有连续调用的结果之间的差才是有效的。
实例14time.process_time()返回当前进程执行 CPU 的时间总和，不包含睡眠时间。
由于返回值的基准点是未定义的，所以，只有连续调用的结果之间的差才是有效的。
Time模块包含了以下2个非常重要的属性： 序号属性及描述1time.timezone属性time.timezone是当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲;<=0大部分欧洲，亚洲，非洲）。
2time.tzname属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。
日历（Calendar）模块 此模块的函数都是日历相关的，例如打印某月的字符月历。
星期一是默认的每周第一天，星期天是默认的最后一天。
更改设置需调用calendar.setfirstweekday()函数。
模块包含了以下内置函数： 序号函数及描述1calendar.calendar(year,w=2,l=1,c=6)返回一个多行字符串格式的 year 年年历，3 个月一行，间隔距离为 c。
每日宽度间隔为w字符。
每行长度为 21* W+18+2* C。
l是每星期行数。
2calendar.firstweekday( )返回当前每周起始日期的设置。
默认情况下，首次载入 calendar 模块时返回 0，即星期一。
3calendar.isleap(year)是闰年返回 True，否则为 False。
>>> import calendar
>>> print(calendar.isleap(2000))
True
>>> print(calendar.isleap(1900))
False4calendar.leapdays(y1,y2)返回在Y1，Y2两年之间的闰年总数。
5calendar.month(year,month,w=2,l=1)返回一个多行字符串格式的year年month月日历，两行标题，一周一行。
每日宽度间隔为w字符。
每行的长度为7* w+6。
l是每星期的行数。
6calendar.monthcalendar(year,month)返回一个整数的单层嵌套列表。
每个子列表装载代表一个星期的整数。
Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。
7calendar.monthrange(year,month)返回两个整数。
第一个是该月的星期几，第二个是该月有几天。
星期几是从0（星期一）到 6（星期日）。
>>> import calendar
>>> calendar.monthrange(2014, 11)
(5, 30)(5, 30)解释：5 表示 2014 年 11 月份的第一天是周六，30 表示 2014 年 11 月份总共有 30 天。
8calendar.prcal(year, w=0, l=0, c=6, m=3)相当于 print (calendar.calendar(year, w=0, l=0, c=6, m=3))。
9calendar.prmonth(theyear, themonth, w=0, l=0)相当于 print(calendar.month(theyear, themonth, w=0, l=0))。
10calendar.setfirstweekday(weekday)设置每周的起始日期码。
0（星期一）到6（星期日）。
11calendar.timegm(tupletime)和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间戳（1970纪元后经过的浮点秒数）。
12calendar.weekday(year,month,day)返回给定日期的日期码。
0（星期一）到6（星期日）。
月份为 1（一月） 到 12（12月）。
types模块： 保存了所有数据类型名称。
if type(‘1111‘) == types.StringType: MySQLdb模块： MySQLdb.get_client_info() 获取API版本 MySQLdb.Binary(‘string‘) 转为二进制数据形式 MySQLdb.escape_string(‘str‘) 针对mysql的字符转义函数 MySQLdb.DateFromTicks(1395842548) 把时间戳转为datetime.date对象实例 MySQLdb.TimestampFromTicks(1395842548) 把时间戳转为datetime.datetime对象实例 MySQLdb.string_literal(‘str‘) 字符转义 MySQLdb.cursor()游标对象上的方法：《python核心编程》P624 atexit模块： atexit.register(fun,args,args2..) 注册函数func，在解析器退出前调用该函数 string模块 str.capitalize() 把字符串的第一个字符大写 str.center(width) 返回一个原字符串居中，并使用空格填充到width长度的新字符串 str.ljust(width) 返回一个原字符串左对齐，用空格填充到指定长度的新字符串 str.rjust(width) 返回一个原字符串右对齐，用空格填充到指定长度的新字符串 str.zfill(width) 返回字符串右对齐，前面用0填充到指定长度的新字符串 str.count(str,[beg,len]) 返回子字符串在原字符串出现次数，beg,len是范围 str.decode(encodeing[,replace]) 解码string,出错引发ValueError异常 str.encode(encodeing[,replace]) 解码string str.endswith(substr[,beg,end]) 字符串是否以substr结束，beg,end是范围 str.startswith(substr[,beg,end]) 字符串是否以substr开头，beg,end是范围 str.expandtabs(tabsize = 8) 把字符串的tab转为空格，默认为8个 str.find(str,[stat,end]) 查找子字符串在字符串第一次出现的位置，否则返回-1 str.index(str,[beg,end]) 查找子字符串在指定字符中的位置，不存在报异常 str.isalnum() 检查字符串是否以字母和数字组成，是返回true否则False str.isalpha() 检查字符串是否以纯字母组成，是返回true,否则false str.isdecimal() 检查字符串是否以纯十进制数字组成，返回布尔值 str.isdigit() 检查字符串是否以纯数字组成，返回布尔值 str.islower() 检查字符串是否全是小写，返回布尔值 str.isupper() 检查字符串是否全是大写，返回布尔值 str.isnumeric() 检查字符串是否只包含数字字符，返回布尔值 str.isspace() 如果str中只包含空格，则返回true,否则FALSE str.title() 返回标题化的字符串（所有单词首字母大写，其余小写） str.istitle() 如果字符串是标题化的(参见title())则返回true,否则false str.join(seq) 以str作为连接符，将一个序列中的元素连接成字符串 str.split(str=‘‘,num) 以str作为分隔符，将一个字符串分隔成一个序列，num是被分隔的字符串 str.splitlines(num) 以行分隔，返回各行内容作为元素的列表 str.lower() 将大写转为小写 str.upper() 转换字符串的小写为大写 str.swapcase() 翻换字符串的大小写 str.lstrip() 去掉字符左边的空格和回车换行符 str.rstrip() 去掉字符右边的空格和回车换行符 str.strip() 去掉字符两边的空格和回车换行符 str.partition(substr) 从substr出现的第一个位置起，将str分割成一个3元组。
str.replace(str1,str2,num) 查找str1替换成str2，num是替换次数 str.rfind(str[,beg,end]) 从右边开始查询子字符串 str.rindex(str,[beg,end]) 从右边开始查找子字符串位置 str.rpartition(str) 类似partition函数，不过从右边开始查找 str.translate(str,del=‘‘) 按str给出的表转换string的字符，del是要过虑的字符 urllib模块： urllib.quote(string[,safe]) 对字符串进行编码。
参数safe指定了不需要编码的字符 urllib.unquote(string) 对字符串进行解码 urllib.quote_plus(string[,safe]) 与urllib.quote类似，但这个方法用‘+‘来替换‘ ‘，而quote用‘%20‘来代替‘ ‘ urllib.unquote_plus(string ) 对字符串进行解码 urllib.urlencode(query[,doseq]) 将dict或者包含两个元素的元组列表转换成url参数。
例如 字典{‘name‘:‘wklken‘,‘pwd‘:‘123‘}将被转换为”name=wklken&pwd=123″ urllib.pathname2url(path) 将本地路径转换成url路径 urllib.url2pathname(path) 将url路径转换成本地路径 urllib.urlretrieve(url[,filename[,reporthook[,data]]]) 下载远程数据到本地 filename：指定保存到本地的路径（若未指定该，urllib生成一个临时文件保存数据） reporthook：回调函数，当连接上服务器、以及相应的数据块传输完毕的时候会触发该回调 data：指post到服务器的数据 rulrs = urllib.urlopen(url[,data[,proxies]]) 抓取网页信息，[data]post数据到Url,proxies设置的代理 urlrs.readline() 跟文件对象使用一样 urlrs.readlines() 跟文件对象使用一样 urlrs.fileno() 跟文件对象使用一样 urlrs.close() 跟文件对象使用一样 urlrs.info() 返回一个httplib.HTTPMessage对象，表示远程服务器返回的头信息 urlrs.getcode() 获取请求返回状态HTTP状态码 urlrs.geturl() 返回请求的URL re模块： 一.常用正则表达式符号和语法： '.' 匹配所有字符串，除\n以外 ‘-’ 表示范围[0-9] '*' 匹配前面的子表达式零次或多次。
要匹配 * 字符，请使用 \*。
'+' 匹配前面的子表达式一次或多次。
要匹配 + 字符，请使用 \+
'^' 匹配字符串开头
‘$’ 匹配字符串结尾 re
'\' 转义字符， 使后一个字符改变原来的意思，如果字符串中有字符*需要匹配，可以\*或者字符集[*] re.findall(r'3\*','3*ds')结['3*']
'*' 匹配前面的字符0次或多次 re.findall("ab*","cabc3abcbbac")结果：['ab', 'ab', 'a']
‘?’ 匹配前一个字符串0次或1次 re.findall('ab?','abcabcabcadf')结果['ab', 'ab', 'ab', 'a']
'{m}' 匹配前一个字符m次 re.findall('cb{1}','bchbchcbfbcbb')结果['cb', 'cb']
'{n,m}' 匹配前一个字符n到m次 re.findall('cb{2,3}','bchbchcbfbcbb')结果['cbb']
'\d' 匹配数字，等于[0-9] re.findall('\d','电话:10086')结果['1', '0', '0', '8', '6']
'\D' 匹配非数字，等于[^0-9] re.findall('\D','电话:10086')结果['电', '话', ':']
'\w' 匹配字母和数字，等于[A-Za-z0-9] re.findall('\w','alex123,./;;;')结果['a', 'l', 'e', 'x', '1', '2', '3']
'\W' 匹配非英文字母和数字,等于[^A-Za-z0-9] re.findall('\W','alex123,./;;;')结果[',', '.', '/', ';', ';', ';']
'\s' 匹配空白字符 re.findall('\s','3*ds \t\n')结果[' ', '\t', '\n']
'\S' 匹配非空白字符 re.findall('\s','3*ds \t\n')结果['3', '*', 'd', 's']
'\A' 匹配字符串开头
'\Z' 匹配字符串结尾
'\b' 匹配单词的词首和词尾，单词被定义为一个字母数字序列，因此词尾是用空白符或非字母数字符来表示的
'\B' 与\b相反，只在当前位置不在单词边界时匹配
'(?P
比如 [a-zA-Z0-9] 表示相应位置的字符要匹配英文字符和数字。
[\s*]表示空格或者*号。
二.常用的re函数： 方法/属性 作用 re.match(pattern, string, flags=0) 从字符串的起始位置匹配，如果起始位置匹配不成功的话，match()就返回none re.search(pattern, string, flags=0) 扫描整个字符串并返回第一个成功的匹配 re.findall(pattern, string, flags=0) 找到RE匹配的所有字符串，并把他们作为一个列表返回 re.finditer(pattern, string, flags=0) 找到RE匹配的所有字符串，并把他们作为一个迭代器返回 re.sub(pattern, repl, string, count=0, flags=0) 替换匹配到的字符串 math模块 ceil:取大于等于x的最小的整数值，如果x是一个整数，则返回x copysign:把y的正负号加到x前面，可以使用0 cos:求x的余弦，x必须是弧度 degrees:把x从弧度转换成角度 e:表示一个常量 exp:返回math.e,也就是2.71828的x次方 expm1:返回math.e的x(其值为2.71828)次方的值减１ fabs:返回x的绝对值 factorial:取x的阶乘的值 floor:取小于等于x的最大的整数值，如果x是一个整数，则返回自身 fmod:得到x/y的余数，其值是一个浮点数 frexp:返回一个元组(m,e),其计算方式为：x分别除0.5和1,得到一个值的范围 fsum:对迭代器里的每个元素进行求和操作 gcd:返回x和y的最大公约数 hypot:如果x是不是无穷大的数字,则返回True,否则返回False isfinite:如果x是正无穷大或负无穷大，则返回True,否则返回False isinf:如果x是正无穷大或负无穷大，则返回True,否则返回False isnan:如果x不是数字True,否则返回False ldexp:返回x*(2**i)的值 log:返回x的自然对数，默认以e为基数，base参数给定时，将x的对数返回给定的base,计算式为：log(x)/log(base) log10:返回x的以10为底的对数 log1p:返回x+1的自然对数(基数为e)的值 log2:返回x的基2对数 modf:返回由x的小数部分和整数部分组成的元组 pi:数字常量，圆周率 pow:返回x的y次方，即x**y radians:把角度x转换成弧度 sin:求x(x为弧度)的正弦值 sqrt:求x的平方根 tan:返回x(x为弧度)的正切值 trunc:返回x的整数部分 math 模块常量 常量描述math.e返回欧拉数 (2.7182...)math.inf返回正无穷大浮点数math.nan返回一个浮点值 NaN (not a number)math.piπ 一般指圆周率。
圆周率 PI (3.1415...)math.tau数学常数 τ = 6.283185...，精确到可用精度。
Tau 是一个圆周常数，等于 2π，圆的周长与半径之比。
math 模块方法 方法描述math.acos(x)返回 x 的反余弦，结果范围在 0 到 pi 之间。
math.acosh(x)返回 x 的反双曲余弦值。
math.asin(x)返回 x 的反正弦值，结果范围在 -pi/2 到 pi/2 之间。
math.asinh(x)返回 x 的反双曲正弦值。
math.atan(x)返回 x 的反正切值，结果范围在 -pi/2 到 pi/2 之间。
math.atan2(y, x)返回给定的 X 及 Y 坐标值的反正切值，结果是在 -pi 和 pi 之间。
math.atanh(x)返回 x 的反双曲正切值。
math.ceil(x)将 x 向上舍入到最接近的整数math.comb(n, k)返回不重复且无顺序地从 n 项中选择 k 项的方式总数。
math.copysign(x, y)返回一个基于 x 的绝对值和 y 的符号的浮点数。
math.cos()返回 x 弧度的余弦值。
math.cosh(x)返回 x 的双曲余弦值。
math.degrees(x)将角度 x 从弧度转换为度数。
math.dist(p, q)返回 p 与 q 两点之间的欧几里得距离，以一个坐标序列（或可迭代对象）的形式给出。
两个点必须具有相同的维度。
math.erf(x)返回一个数的误差函数math.erfc(x)返回 x 处的互补误差函数math.exp(x)返回 e 的 x 次幂，Ex， 其中 e = 2.718281... 是自然对数的基数。
math.expm1()返回 Ex - 1， e 的 x 次幂，Ex，其中 e = 2.718281... 是自然对数的基数。
这通常比 math.e ** x 或 pow(math.e, x) 更精确。
math.fabs(x)返回 x 的绝对值。
math.factorial(x)返回 x 的阶乘。
如果 x 不是整数或为负数时则将引发 ValueError。
math.floor()将数字向下舍入到最接近的整数math.fmod(x, y)返回 x/y 的余数math.frexp(x)以 (m, e) 对的形式返回 x 的尾数和指数。
m 是一个浮点数， e 是一个整数，正好是 x == m * 2**e 。
如果 x 为零，则返回 (0.0, 0) ，否则返回 0.5 <= abs(m) < 1 。
math.fsum(iterable)返回可迭代对象 (元组, 数组, 列表, 等)中的元素总和，是浮点值。
math.gamma(x)返回 x 处的伽马函数值。
math.gcd()返回给定的整数参数的最大公约数。
math.hypot()返回欧几里得范数，sqrt(sum(x**2 for x in coordinates))。
这是从原点到坐标给定点的向量长度。
math.isclose(a,b)检查两个值是否彼此接近，若 a 和 b 的值比较接近则返回 True，否则返回 False。
。
math.isfinite(x)判断 x 是否有限，如果 x 既不是无穷大也不是 NaN，则返回 True ，否则返回 False 。
math.isinf(x)判断 x 是否是无穷大，如果 x 是正或负无穷大，则返回 True ，否则返回 False 。
math.isnan()判断数字是否为 NaN，如果 x 是 NaN（不是数字），则返回 True ，否则返回 False 。
math.isqrt()将平方根数向下舍入到最接近的整数math.ldexp(x, i)返回 x * (2**i) 。
这基本上是函数math.frexp() 的反函数。
math.lgamma()返回伽玛函数在 x 绝对值的自然对数。
math.log(x[, base])使用一个参数，返回 x 的自然对数（底为 e ）。
math.log10(x)返回 x 底为 10 的对数。
math.log1p(x)返回 1+x 的自然对数（以 e 为底）。
math.log2(x)返回 x 以 2 为底的对数math.perm(n, k=None)返回不重复且有顺序地从 n 项中选择 k 项的方式总数。
math.pow(x, y)将返回 x 的 y 次幂。
math.prod(iterable)计算可迭代对象中所有元素的积。
math.radians(x)将角度 x 从度数转换为弧度。
math.remainder(x, y)返回 IEEE 754 风格的 x 除于 y 的余数。
math.sin(x)返回 x 弧度的正弦值。
math.sinh(x)返回 x 的双曲正弦值。
math.sqrt(x)返回 x 的平方根。
math.tan(x)返回 x 弧度的正切值。
math.tanh(x)返回 x 的双曲正切值。
math.trunc(x)返回 x 截断整数的部分，即返回整数部分，删除小数部分 Python PIP命令 pip --version 查看是否已经安装 pip pip install some-package-name 下载安装包： 例如我们安装 numpy 包：pip install numpy pip uninstall some-package-name 移除软件包： pip list 查看我们已经安装的软件包 requests 模块 requests 方法 delete(url, args) 发送 DELETE 请求到指定 url get(url, params, args) 发送 GET 请求到指定 url head(url, args) 发送 HEAD 请求到指定 url patch(url, data, args) 发送 PATCH 请求到指定 url post(url, data, json, args) 发送 POST 请求到指定 url put(url, data, args) 发送 PUT 请求到指定 url request(method, url, args) 向指定的 url 发送指定的请求方法 request响应信息 引用1：博客园requests教程 https://www.cnblogs.com/caijunchao/p/12643895.htmlhttps://www.cnblogs.com/caijunchao/p/12643895.html apparent_encoding 编码方式 close() 关闭与服务器的连接 content 返回响应的内容，以字节为单位 cookies 返回一个 CookieJar 对象，包含了从服务器发回的 cookie elapsed 返回一个 timedelta 对象，包含了从发送请求到响应到达之间经过的时间量，可以用于测试响应速度。
比如 r.elapsed.microseconds 表示响应到达需要多少微秒。
encoding 解码 r.text 的编码方式 headers 返回响应头，字典格式 history 返回包含请求历史的响应对象列表（url） is_permanent_redirect 如果响应是永久重定向的 url，则返回 True，否则返回 False is_redirect 如果响应被重定向，则返回 True，否则返回 False iter_content() 迭代响应 iter_lines() 迭代响应的行 json() 返回结果的 JSON 对象 (结果需要以 JSON 格式编写的，否则会引发错误) links 返回响应的解析头链接 next 返回重定向链中下一个请求的 PreparedRequest 对象 ok 检查 "status_code" 的值，如果小于400，则返回 True，如果不小于 400，则返回 False raise_for_status() 如果发生错误，方法返回一个 HTTPError 对象 reason 响应状态的描述，比如 "Not Found" 或 "OK" request 返回请求此响应的请求对象 status_code 返回 http 的状态码，比如 404 和 200（200 是 OK，404 是 Not Found） text 返回响应的内容，unicode 类型数据 url 返回响应的 URL Python3 operator 模块 operator 模块包含的方法 operator.lt(a, b) 与 a < b 相同 operator.le(a, b) a <= b 相同 operator.eq(a, b) 与 a == b 相同 operator.ne(a, b) 与 a != b 相同 operator.ge(a, b) 与 a > b 相同 operator.gt(a, b) 与 a >= b 相同 operator.__lt__(a, b) operator.__le__(a, b) operator.__eq__(a, b) operator.__ne__(a, b) operator.__ge__(a, b) operator.__gt__(a, b) 运算符函数 operator 模块提供了一套与 Python 的内置运算符对应的高效率函数。
例如， operator.add(x, y) 与表达式 x+y 相同。
函数包含的种类有：对象的比较运算、逻辑运算、数学运算以及序列运算。
对象比较函数适用于所有的对象，函数名根据它们对应的比较运算符命名。
许多函数名与特殊方法名相同，只是没有双下划线。
为了向后兼容性，也保留了许多包含双下划线的函数，为了表述清楚，建议使用没有双下划线的函数。
运算语法函数
加法a + badd(a, b)字符串拼接seq1 + seq2concat(seq1, seq2)包含测试obj in seqcontains(seq, obj)除法a / btruediv(a, b)除法a // bfloordiv(a, b)按位与a & band_(a, b)按位异或a ^ bxor(a, b)按位取反~ ainvert(a)按位或a | bor_(a, b)取幂a ** bpow(a, b)标识a is bis_(a, b)标识a is not bis_not(a, b)索引赋值obj[k] = vsetitem(obj, k, v)索引删除del obj[k]delitem(obj, k)索引取值obj[k]getitem(obj, k)左移a << blshift(a, b)取模a % bmod(a, b)乘法a * bmul(a, b)矩阵乘法a @ bmatmul(a, b)取反（算术）- aneg(a)取反（逻辑）not anot_(a)正数+ apos(a)右移a >> brshift(a, b)切片赋值seq[i:j] = valuessetitem(seq, slice(i, j), values)切片删除del seq[i:j]delitem(seq, slice(i, j))切片取值seq[i:j]getitem(seq, slice(i, j))字符串格式化s % objmod(s, obj)减法a - bsub(a, b)真值测试objtruth(obj)比较a < blt(a, b)比较a <= ble(a, b)相等a == beq(a, b)不等a != bne(a, b)比较a >= bge(a, b)比较a > bgt(a, b)
内置函数
截至 Python 3.11.2 版本，Python 中有71个内置函数。
下面是内置函数的列表 − 序号功能和描述 1abs()返回一个数字的绝对值2aiter()返回一个异步可迭代对象的异步迭代器3all()当可迭代对象中的所有元素都为真时返回true4anext()从给定的异步迭代器中返回下一个项5any()检查可迭代对象中是否有任何元素为真6ascii()返回包含可打印表示的字符串7bin()将整数转换为二进制字符串8bool()将值转换为布尔值9breakpoint()此函数将您放入调试器，并调用sys.breakpointhook()10bytearray()返回指定字节大小的数组11bytes()返回不可变的字节对象12callable()检查对象是否可调用13chr()从整数中返回一个字符（字符串）14classmethod()返回给定函数的类方法15compile()返回一个代码对象16complex()创建一个复数17delattr()从对象中删除属性18dict()创建一个字典19dir()尝试返回对象的属性20divmod()返回商和余数的元组21enumerate()返回一个枚举对象22eval()在程序内部运行代码。
23exec()执行动态创建的程序24filter()从真值构造迭代器25float()从数字、字符串返回浮点数26format()返回值的格式化表示27frozenset()返回不可变的frozenset对象28getattr()返回对象的命名属性的值29globals()返回当前全局符号表的字典30hasattr()返回对象是否具有指定名称的属性31hash()返回对象的哈希值32help()调用内置的帮助系统33hex()将整数转换为十六进制34id()返回对象的标识35input()读取并返回一行字符串36int()将数字或字符串转换为整数37isinstance()检查一个对象是否是某个类的实例38issubclass()检查一个类是否是另一个类的子类39iter()返回一个迭代器40len()返回对象的长度41list()在Python中创建一个列表42locals()返回当前局部符号表的字典43map()应用函数并返回一个列表44max()返回最大的项45memoryview()返回参数的内存视图46min()返回最小值47next()从迭代器中获取下一个项目48object()创建一个无特征的对象49oct()返回整数的八进制表示50open()返回文件对象51ord()返回Unicode字符的整数值52pow()返回一个数的幂53print()打印给定对象54property()返回属性55range()返回整数序列56repr()返回对象的可打印表示57reversed()返回序列的反转迭代器58round()将数字四舍五入到指定的小数位数59set()构造并返回一个集合60setattr()设置对象的属性值61slice()返回一个切片对象62sorted()从给定的可迭代对象中返回一个排序后的列表63staticmethod()将一个方法转换为静态方法64str()返回对象的字符串版本65sum()添加可迭代对象的项目66super()返回基类的代理对象67tuple()返回一个元组68type()返回对象的类型69vars()返回dict属性70zip()返回一个元组的迭代器71import() 由import语句调用的函数 来源菜鸟论坛 内置函数 abs()dict()help()min()setattr()all()dir()hex()next()slice()any()divmod()id()object()sorted()ascii()enumerate()input()oct()staticmethod()bin()eval()int()open()str()bool()exec()isinstance()ord()sum()bytearray()filter()issubclass()pow()super()bytes()float()iter()print()tuple()callable()format()len()property()type()chr()frozenset()list()range()vars()classmethod()getattr()locals()repr()zip()compile()globals()map()reversed()__import__()complex()hasattr()max()round()reload()delattr()hash()memoryview()set() Pandas模块 官方文档： DataFrame — pandas 2.1.1 documentationhttps://pandas.pydata.org/pandas-docs/stable/reference/frame.html# Pandas中文官网: 强大的 Python 数据分析支持库 | PandasPandas中文网、Pandas官方中文文档。
https://www.pypandas.cn/docs/ 引用： Pyhton - 数据分析之pandas模块一览总表_pandas有哪些模块-CSDN博客Pandas包含以下三个数据结构：系列(Series)，数据帧(DataFrame)，面板(Panel)。
_pandas有哪些模块https://blog.csdn.net/weixin_41176932/article/details/130584992 Numpy模块 引用1： Pyhton - 数据分析之pandas模块一览总表_pandas有哪些模块-CSDN博客Pandas包含以下三个数据结构：系列(Series)，数据帧(DataFrame)，面板(Panel)。
_pandas有哪些模块https://blog.csdn.net/weixin_41176932/article/details/130584992 引用2： Python之Numpy详细教程_python numpy-CSDN博客NumPy - 简介NumPy 是一个 Python 包。
它代表 “Numeric Python”。
它是一个由多维数组对象和用于处理数组的例程集合组成的库。
Numeric，即 NumPy 的前身，是由 Jim Hugunin 开发的。
也开发了另一个包 Numarray ，它拥有一些额外的功能。
2005年，Travis Oliphant 通过将 Numarray 的功能集成到 Num..._python numpyhttps://blog.csdn.net/a373595475/article/details/79580734?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522169683123816800227496777%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=169683123816800227496777&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-79580734-null-null.142%5Ev95%5Einsert_down28v1&utm_term=numpy&spm=1018.2226.3001.4187 STMP模块 引用： Python之smtpd及smtplib（邮件服务器及客户端）_python smtpd-CSDN博客python的asyncore：https://docs.python.org/2/library/asyncore.html?发送带附件的邮件，首先要创建MIMEMultipart()实例，然后构造附件，如果有多个附件，可依次构造，最后利用smtplib.smtp发送。
实例二：如果我们本机没有 sendmail 访问，也可以使用其他邮件服务商的 SMTP 访问（QQ、网易、Google等）。
以下实例你需要修改：发件人邮箱（你的QQ邮箱），密码，收件人邮箱（可发给自己）。
来连接到 SMTP 访问，并使用。
_python smtpdhttps://blog.csdn.net/u012206617/article/details/104476613 SMTP（Simple Mail Transfer Protocol）即简单邮件传输协议,它是一组用于由源地址到目的地址传送邮件的规则，由它来控制信件的中转方式。
python的smtplib提供了一种很方便的途径发送电子邮件。
它对smtp协议进行了简单的封装。
Python创建 SMTP 对象语法如下：
import smtplib
smtpObj = smtplib.SMTP( [host [, port [, local_hostname]]] )
参数说明：
host: SMTP 服务器主机。
你可以指定主机的ip地址或者域名如:runoob.com，这个是可选参数。
port: 如果你提供了 host 参数, 你需要指定 SMTP 服务使用的端口号，一般情况下SMTP端口号为25。
local_hostname: 如果SMTP在你的本机上，你只需要指定服务器地址为 localhost 即可。
Python SMTP对象使用sendmail方法发送邮件，语法如下：
SMTP.sendmail(from_addr, to_addrs, msg[, mail_options, rcpt_options]
参数说明： from_addr: 邮件发送者地址。
to_addrs: 字符串列表，邮件发送地址。
msg: 发送消息 这里要注意一下第三个参数，msg是字符串，表示邮件。
我们知道邮件一般由标题，发信人，收件人，邮件内容，附件等构成，发送邮件的时候，要注意msg的格式。
这个格式就是smtp协议中定义的格式。
以下是一个使用Python发送邮件简单的实例：
#!/usr/bin/python3
import smtplib
from email.mime.text import MIMEText
from email.header import Header
sender = 'from@runoob.com'
receivers = ['429240967@qq.com'] # 接收邮件，可设置为你的QQ邮箱或者其他邮箱
# 三个参数：第一个为文本内容，第二个 plain 设置文本格式，第三个 utf-8 设置编码
message = MIMEText('Python 邮件发送测试...', 'plain', 'utf-8')
message['From'] = Header("菜鸟教程", 'utf-8') # 发送者
message['To'] = Header("测试", 'utf-8') # 接收者
subject = 'Python SMTP 邮件测试'
message['Subject'] = Header(subject, 'utf-8')
try:
smtpObj = smtplib.SMTP('localhost')
smtpObj.sendmail(sender, receivers, message.as_string())
print ("邮件发送成功")
except smtplib.SMTPException:
print ("Error: 无法发送邮件")
我们使用三个引号来设置邮件信息，标准邮件需要三个头部信息：
From
,
To
, 和
Subject
，每个信息直接使用空行分割。
我们通过实例化 smtplib 模块的 SMTP 对象 smtpObj 来连接到 SMTP 访问，并使用 sendmail 方法来发送信息。
执行以上程序，如果你本机安装sendmail，就会输出：
$ python3 test.py
邮件发送成功
如果我们本机没有 sendmail 访问，也可以使用其他服务商的 SMTP 访问（QQ、网易、Google等）。
#!/usr/bin/python3
import smtplib
from email.mime.text import MIMEText
from email.header import Header
# 第三方 SMTP 服务
mail_host="smtp.XXX.com" #设置服务器
mail_user="XXXX" #用户名
mail_pass="XXXXXX" #口令
sender = 'from@runoob.com'
receivers = ['429240967@qq.com'] # 接收邮件，可设置为你的QQ邮箱或者其他邮箱
message = MIMEText('Python 邮件发送测试...', 'plain', 'utf-8')
message['From'] = Header("菜鸟教程", 'utf-8')
message['To'] = Header("测试", 'utf-8')
subject = 'Python SMTP 邮件测试'
message['Subject'] = Header(subject, 'utf-8')
try:
smtpObj = smtplib.SMTP()
smtpObj.connect(mail_host, 25) # 25 为 SMTP 端口号
smtpObj.login(mail_user,mail_pass)
smtpObj.sendmail(sender, receivers, message.as_string())
print ("邮件发送成功")
except smtplib.SMTPException:
print ("Error: 无法发送邮件")
使用Python发送HTML格式的邮件
Python发送HTML格式的邮件与发送纯文本消息的邮件不同之处就是将MIMEText中_subtype设置为html。
具体代码如下：
#!/usr/bin/python3
import smtplib
from email.mime.text import MIMEText
from email.header import Header
sender = 'from@runoob.com'
receivers = ['429240967@qq.com'] # 接收邮件，可设置为你的QQ邮箱或者其他邮箱
mail_msg = """
Python 邮件发送测试...
"""
message = MIMEText(mail_msg, 'html', 'utf-8')
message['From'] = Header("菜鸟教程", 'utf-8')
message['To'] = Header("测试", 'utf-8')
subject = 'Python SMTP 邮件测试'
message['Subject'] = Header(subject, 'utf-8')
try:
smtpObj = smtplib.SMTP('localhost')
smtpObj.sendmail(sender, receivers, message.as_string())
print ("邮件发送成功")
except smtplib.SMTPException:
print ("Error: 无法发送邮件")
执行以上程序，如果你本机安装sendmail，就会输出：
$ python3 test.py
邮件发送成功
查看我们的收件箱(一般在垃圾箱)，就可以查看到邮件信息：
Python 发送带附件的邮件 发送带附件的邮件，首先要创建MIMEMultipart()实例，然后构造附件，如果有多个附件，可依次构造，最后利用smtplib.smtp发送。
#!/usr/bin/python3
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.header import Header
sender = 'from@runoob.com'
receivers = ['429240967@qq.com'] # 接收邮件，可设置为你的QQ邮箱或者其他邮箱
#创建一个带附件的实例
message = MIMEMultipart()
message['From'] = Header("菜鸟教程", 'utf-8')
message['To'] = Header("测试", 'utf-8')
subject = 'Python SMTP 邮件测试'
message['Subject'] = Header(subject, 'utf-8')
#邮件正文内容
message.attach(MIMEText('这是菜鸟教程Python 邮件发送测试……', 'plain', 'utf-8'))
# 构造附件1，传送当前目录下的 test.txt 文件
att1 = MIMEText(open('test.txt', 'rb').read(), 'base64', 'utf-8')
att1["Content-Type"] = 'application/octet-stream'
# 这里的filename可以任意写，写什么名字，邮件中显示什么名字
att1["Content-Disposition"] = 'attachment; filename="test.txt"'
message.attach(att1)
# 构造附件2，传送当前目录下的 runoob.txt 文件
att2 = MIMEText(open('runoob.txt', 'rb').read(), 'base64', 'utf-8')
att2["Content-Type"] = 'application/octet-stream'
att2["Content-Disposition"] = 'attachment; filename="runoob.txt"'
message.attach(att2)
try:
smtpObj = smtplib.SMTP('localhost')
smtpObj.sendmail(sender, receivers, message.as_string())
print ("邮件发送成功")
except smtplib.SMTPException:
print ("Error: 无法发送邮件")
查看我们的收件箱(一般在垃圾箱)，就可以查看到邮件信息：
在 HTML 文本中添加图片 邮件的 HTML 文本中一般邮件服务商添加外链是无效的，正确添加图片的实例如下所示：
#!/usr/bin/python3
import smtplib
from email.mime.image import MIMEImage
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.header import Header
sender = 'from@runoob.com'
receivers = ['429240967@qq.com'] # 接收邮件，可设置为你的QQ邮箱或者其他邮箱
msgRoot = MIMEMultipart('related')
msgRoot['From'] = Header("菜鸟教程", 'utf-8')
msgRoot['To'] = Header("测试", 'utf-8')
subject = 'Python SMTP 邮件测试'
msgRoot['Subject'] = Header(subject, 'utf-8')
msgAlternative = MIMEMultipart('alternative')
msgRoot.attach(msgAlternative)
mail_msg = """
Python 邮件发送测试...
图片演示：
"""
msgAlternative.attach(MIMEText(mail_msg, 'html', 'utf-8'))
# 指定图片为当前目录
fp = open('test.png', 'rb')
msgImage = MIMEImage(fp.read())
fp.close()
# 定义图片 ID，在 HTML 文本中引用
msgImage.add_header('Content-ID', '')
msgRoot.attach(msgImage)
try:
smtpObj = smtplib.SMTP('localhost')
smtpObj.sendmail(sender, receivers, msgRoot.as_string())
print ("邮件发送成功")
except smtplib.SMTPException:
print ("Error: 无法发送邮件")
查看我们的收件箱(如果在垃圾箱可能需要移动到收件箱才可正常显示)，就可以查看到邮件信息：
使用第三方 SMTP 服务发送 这里使用了 QQ 邮箱(你也可以使用 163，Gmail等)的 SMTP 服务，需要做以下配置：
QQ 邮箱通过生成授权码来设置密码：
QQ 邮箱 SMTP 服务器地址：smtp.qq.com，ssl 端口：465。
以下实例你需要修改：发件人邮箱（你的QQ邮箱），密码，收件人邮箱（可发给自己）。
#!/usr/bin/python3
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
my_sender='429240967@qq.com' # 发件人邮箱账号
my_pass = 'xxxxxxxxxx' # 发件人邮箱密码
my_user='429240967@qq.com' # 收件人邮箱账号，我这边发送给自己
def mail():
ret=True
try:
msg=MIMEText('填写邮件内容','plain','utf-8')
msg['From']=formataddr(["FromRunoob",my_sender]) # 括号里的对应发件人邮箱昵称、发件人邮箱账号
msg['To']=formataddr(["FK",my_user]) # 括号里的对应收件人邮箱昵称、收件人邮箱账号
msg['Subject']="菜鸟教程发送邮件测试" # 邮件的主题，也可以说是标题
server=smtplib.SMTP_SSL("smtp.qq.com", 465) # 发件人邮箱中的SMTP服务器，端口是25
server.login(my_sender, my_pass) # 括号中对应的是发件人邮箱账号、邮箱密码
server.sendmail(my_sender,[my_user,],msg.as_string()) # 括号中对应的是发件人邮箱账号、收件人邮箱账号、发送邮件
server.quit() # 关闭连接
except Exception: # 如果 try 中的语句没有执行，则会执行下面的 ret=False
ret=False
return ret
ret=mail()
if ret:
print("邮件发送成功")
else:
print("邮件发送失败")
Selenium模块
Python3 多线程
多线程的优点：
多线程类似于同时执行多个不同程序，多线程运行有如下优点：
使用线程可以把占据长时间的程序中的任务放到后台去处理。
用户界面可以更加吸引人，比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度。
程序的运行速度可能加快。
在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。
在这种情况下我们可以释放一些珍贵的资源如内存占用等等。
每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。
但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
每个线程都有他自己的一组CPU寄存器，称为线程的上下文，该上下文反映了线程上次运行该线程的CPU寄存器的状态。
指令指针和堆栈指针寄存器是线程上下文中两个最重要的寄存器，线程总是在进程得到上下文中运行的，这些地址都用于标志拥有线程的进程地址空间中的内存。
线程可以被抢占（中断）。
在其他线程正在运行时，线程可以暂时搁置（也称为睡眠） -- 这就是线程的退让。
线程可以分为: 内核线程： 由操作系统内核创建和撤销。
用户线程： 不需要内核支持而在用户程序中实现的线程。
Python3 线程中常用的两个模块为： _thread threading(推荐使用) thread 模块已被废弃。
用户可以使用 threading 模块代替。
所以，在 Python3 中不能再使用"thread" 模块。
为了兼容性，Python3 将 thread 重命名为 "_thread"。
多线程的使用 Python中使用线程有两种方式：函数或者用类来包装线程对象。
函数式：调用 _thread 模块中的start_new_thread()函数来产生新线程。
语法如下: _thread.start_new_thread ( function, args[, kwargs] ) 参数说明: function - 线程函数。
args - 传递给线程函数的参数,他必须是个tuple类型。
kwargs - 可选参数。
#!/usr/bin/python3
import _thread
import time
# 为线程定义一个函数
def print_time( threadName, delay):
count = 0
while count < 5:
time.sleep(delay)
count += 1
print ("%s: %s" % ( threadName, time.ctime(time.time()) ))
# 创建两个线程
try:
_thread.start_new_thread( print_time, ("Thread-1", 2, ) )
_thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
print ("Error: 无法启动线程")
while 1:
pass
执行以上程序输出结果如下：
Thread-1: Wed Jan 5 17:38:08 2022
Thread-2: Wed Jan 5 17:38:10 2022
Thread-1: Wed Jan 5 17:38:10 2022
Thread-1: Wed Jan 5 17:38:12 2022
Thread-2: Wed Jan 5 17:38:14 2022
Thread-1: Wed Jan 5 17:38:14 2022
Thread-1: Wed Jan 5 17:38:16 2022
Thread-2: Wed Jan 5 17:38:18 2022
Thread-2: Wed Jan 5 17:38:22 2022
Thread-2: Wed Jan 5 17:38:26 2022
线程模块 Python3 通过两个标准库 _thread 和 threading 提供对线程的支持。
_thread 提供了低级别的、原始的线程以及一个简单的锁，它相比于 threading 模块的功能还是比较有限的。
threading 模块除了包含 _thread 模块中的所有方法外，还提供的其他方法： threading.currentThread(): 返回当前的线程变量。
threading.enumerate(): 返回一个包含正在运行的线程的list。
正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法: run(): 用以表示线程活动的方法。
start(): 启动线程活动。
join([time]): 等待至线程中止。
这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
isAlive(): 返回线程是否活动的。
getName(): 返回线程名。
setName(): 设置线程名。
使用 threading 模块创建线程 我们可以通过直接从 threading.Thread 继承创建一个新的子类，并实例化后调用 start() 方法启动新线程，即它调用了线程的 run() 方法：
#!/usr/bin/python3
import threading
import time
exitFlag = 0
class myThread (threading.Thread):
def __init__(self, threadID, name, delay):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.delay = delay
def run(self):
print ("开始线程：" + self.name)
print_time(self.name, self.delay, 5)
print ("退出线程：" + self.name)
def print_time(threadName, delay, counter):
while counter:
if exitFlag:
threadName.exit()
time.sleep(delay)
print ("%s: %s" % (threadName, time.ctime(time.time())))
counter -= 1
# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
# 开启新线程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("退出主线程")
以上程序执行结果如下；
开始线程：Thread-1
开始线程：Thread-2
Thread-1: Wed Jan 5 17:34:54 2022
Thread-2: Wed Jan 5 17:34:55 2022
Thread-1: Wed Jan 5 17:34:55 2022
Thread-1: Wed Jan 5 17:34:56 2022
Thread-2: Wed Jan 5 17:34:57 2022
Thread-1: Wed Jan 5 17:34:57 2022
Thread-1: Wed Jan 5 17:34:58 2022
退出线程：Thread-1
Thread-2: Wed Jan 5 17:34:59 2022
Thread-2: Wed Jan 5 17:35:01 2022
Thread-2: Wed Jan 5 17:35:03 2022
退出线程：Thread-2
退出主线程
线程同步
如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。
使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。
如下： 多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。
但是当线程需要共享数据时，可能存在数据不同步的问题。
考虑这样一种情况：一个列表里所有元素都是0，线程"set"从后向前把所有元素改成1，而线程"print"负责从前往后读取列表并打印。
那么，可能线程"set"开始改的时候，线程"print"便来打印列表了，输出就成了一半0一半1，这就是数据的不同步。
为了避免这种情况，引入了锁的概念。
锁有两种状态——锁定和未锁定。
每当一个线程比如"set"要访问共享数据时，必须先获得锁定；如果已经有别的线程比如"print"获得锁定了，那么就让线程"set"暂停，也就是同步阻塞；等到线程"print"访问完毕，释放锁以后，再让线程"set"继续。
经过这样的处理，打印列表时要么全部输出0，要么全部输出1，不会再出现一半0一半1的尴尬场面。
#!/usr/bin/python3
import threading
import time
class myThread (threading.Thread):
def __init__(self, threadID, name, delay):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.delay = delay
def run(self):
print ("开启线程： " + self.name)
# 获取锁，用于线程同步
threadLock.acquire()
print_time(self.name, self.delay, 3)
# 释放锁，开启下一个线程
threadLock.release()
def print_time(threadName, delay, counter):
while counter:
time.sleep(delay)
print ("%s: %s" % (threadName, time.ctime(time.time())))
counter -= 1
threadLock = threading.Lock()
threads = []
# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
# 开启新线程
thread1.start()
thread2.start()
# 添加线程到线程列表
threads.append(thread1)
threads.append(thread2)
# 等待所有线程完成
for t in threads:
t.join()
print ("退出主线程")
执行以上程序，输出结果为：
开启线程： Thread-1
开启线程： Thread-2
Thread-1: Wed Jan 5 17:36:50 2022
Thread-1: Wed Jan 5 17:36:51 2022
Thread-1: Wed Jan 5 17:36:52 2022
Thread-2: Wed Jan 5 17:36:54 2022
Thread-2: Wed Jan 5 17:36:56 2022
Thread-2: Wed Jan 5 17:36:58 2022
退出主线程
线程优先级队列（ Queue）
Python 的 Queue 模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列 PriorityQueue。
这些队列都实现了锁原语，能够在多线程中直接使用，可以使用队列来实现线程间的同步。
Queue 模块中的常用方法: Queue.qsize() 返回队列的大小 Queue.empty() 如果队列为空，返回True,反之False Queue.full() 如果队列满了，返回True,反之False Queue.full 与 maxsize 大小对应 Queue.get([block[, timeout]])获取队列，timeout等待时间 Queue.get_nowait() 相当Queue.get(False) Queue.put(item) 写入队列，timeout等待时间 Queue.put_nowait(item) 相当Queue.put(item, False) Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号 Queue.join() 实际上意味着等到队列为空，再执行别的操作
#!/usr/bin/python3
import queue
import threading
import time
exitFlag = 0
class myThread (threading.Thread):
def __init__(self, threadID, name, q):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.q = q
def run(self):
print ("开启线程：" + self.name)
process_data(self.name, self.q)
print ("退出线程：" + self.name)
def process_data(threadName, q):
while not exitFlag:
queueLock.acquire()
if not workQueue.empty():
data = q.get()
queueLock.release()
print ("%s processing %s" % (threadName, data))
else:
queueLock.release()
time.sleep(1)
threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = queue.Queue(10)
threads = []
threadID = 1
# 创建新线程
for tName in threadList:
thread = myThread(threadID, tName, workQueue)
thread.start()
threads.append(thread)
threadID += 1
# 填充队列
queueLock.acquire()
for word in nameList:
workQueue.put(word)
queueLock.release()
# 等待队列清空
while not workQueue.empty():
pass
# 通知线程是时候退出
exitFlag = 1
# 等待所有线程完成
for t in threads:
t.join()
print ("退出主线程")
以上程序执行结果：
开启线程：Thread-1
开启线程：Thread-2
开启线程：Thread-3
Thread-3 processing One
Thread-1 processing Two
Thread-2 processing Three
Thread-3 processing Four
Thread-1 processing Five
退出线程：Thread-3
退出线程：Thread-2
退出线程：Thread-1
退出主线程
说明： 本文为个人学习笔记，只是为了方便后期学习查阅，将会记录个人的学习Python时的过程，部分为其他博客复制内容，主要来源于菜鸟教程，CSDN以及其他一些个人教程，如有侵权，联系删除，不定期更新，将学习到的内容会同步在此。