目录
简介
Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。它上手简单，功能强大，坚持「极简主义」。
Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
缺点：
- 运行速度慢：运行速度慢是解释型语言的通病，Python 也不例外。
- 代码加密困难：不像编译型语言的源代码会被编译成可执行程序，Python 是直接运行源代码，因此对源代码加密比较困难。
应用：
- Youtube - 视频社交网站
- Reddit - 社交分享网站
- Dropbox - 文件分享服务
- 豆瓣网 - 图书、唱片、电影等文化产品的资料数据库网站
- 知乎 - 一个问答网站
- 果壳 - 一个泛科技主题网站
- Bottle - Python微Web框架
- EVE - 网络游戏EVE大量使用Python进行开发
- Blender - 使用Python作为建模工具与GUI语言的开源3D绘图软件
- Inkscape - 一个开源的SVG矢量图形编辑器。
- Web应用开发
- 自动化运维
- 网路爬虫
- 科学计算
- 游戏开发,国际上指明的游戏 Sid Meier's Civilization（文明，如图 2 所示）就是使用 Python 实现的。
- 等等
基础
关键字
if __name__ == '__main__': import keyword print(keyword.kwlist) ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', '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']数据类型
数字(Number)
- int (整数)
- bool (布尔), 如 True。
- float (浮点数), 如 1.23、3E-2
- complex (复数), 如 1 + 2j、 1.1 + 2.2j
数值运算
5 + 4 # 加法 9 4.3 - 2 # 减法 2.3 3 * 7 # 乘法 21 2 / 4 # 除法，得到一个浮点数 0.5 2 // 4 # 除法，得到一个整数 0 17 % 3 # 取余 2 2 ** 5 # 乘方 32字符串(String)
- python中单引号和双引号使用完全相同。使用三引号('''或""")可以指定一个多行字符串。
- 两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
- 截取的语法格式如下：变量[头下标:尾下标:步长]
- str = 'Runoob'
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符 Runoo
print(str[0]) # 输出字符串第一个字符 R
print(str[2:5]) # 输出从第三个开始到第五个的字符 noo
print(str[2:]) # 输出从第三个开始后的所有字符 noob
print(str[1:5:2]) # 输出从第二个开始到第五个且每隔一个的字符（步长为2）
print(str * 2) # 输出字符串两次
print(str + '你好') # 连接字符串
print('hello\nrunoob') # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob') # 在字符串前面添加一个 r，表示原始字符串，不会发生转义
List（列表）
- 列表截取的语法格式：变量[头下标:尾下标] 索引值以 0 为开始值，-1 为从末尾的开始位置。
- list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
print (list) # 输出完整列表
print (list[0]) # 输出列表第一个元素
print (list[1:3]) # 从第二个开始输出到第三个元素 [786, 2.23]
print (list[2:]) # 输出从第三个元素开始的所有元素 [2.23, 'runoob', 70.2]
print (tinylist * 2) # 输出两次列表
print (list + tinylist) # 连接列表
inputWords = input.split(" ") 通过空格将字符串分隔符，把各个单词分隔为列表
# 翻转字符串
# 假设列表 list = [1,2,3,4],
# inputWords[-1::-1] 有三个参数
# 第一个参数 -1 表示最后一个元素
# 第二个参数为空，表示移动到列表末尾
# 第三个参数为步长，-1 表示逆向
inputWords=inputWords[-1::-1]
# 重新组合字符串
output = ' '.join(inputWords)- list.append(x) 把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
list.extend(L) 通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
list.insert(i, x) 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
list.remove(x) 删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
list.pop([i]) 从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
list.clear() 移除列表中的所有项，等于del a[:]。
list.index(x) 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x) 返回 x 在列表中出现的次数。
list.sort() 对列表中的元素进行排序。
list.reverse() 倒排列表中的元素。
list.copy() 返回列表的浅复制，等于a[:]。将列表当做堆栈使用 列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。append() pop() stack = [3, 4, 5] stack.append(6) stack.append(7) # stack: [3, 4, 5, 6, 7] stack.pop() # 7 stack: [3, 4, 5, 6] 将列表当作队列使用 在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快 from collections import deque queue = deque(["Eric", "John", "Michael"]) queue.append("Terry") # Terry arrives queue.append("Graham") # Graham arrives queue.popleft() # The first to arrive now leaves 'Eric' queue.popleft() # The second to arrive now leaves 'John' queue # Remaining queue in order of arrival deque(['Michael', 'Terry', 'Graham']) del 语句 使用 del 语句可以从一个列表中依索引而不是值来删除一个元素 del a[0] del a[2:4] 删除下标3,4 del a[:] 删除所有Tuple（元组）
- 元组（tuple）与列表类似，但元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。元组中的元素类型可以不相同：
- tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
tinytuple = (123, 'runoob')
print (tuple) # 输出完整元组
print (tuple[0]) # 输出元组的第一个元素 abcd
print (tuple[1:3]) # 输出从第二个元素开始到第三个元素 (786, 2.23)
print (tuple[2:]) # 输出从第三个元素开始的所有元素 (2.23, 'runoob', 70.2)
print (tinytuple * 2) # 输出两次元组
print (tuple + tinytuple) # 连接元组Set（集合）
- 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
parame = {value01,value02,...} 或者 set(value)sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
print(sites) # 输出集合，重复的元素被自动去掉
'Runoob' in sites Runoob 是否在集合中
# 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 中不同时存在的元素Dictionary（字典）
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。键(key)必须使用不可变类型、必须是唯一的。
print (tinydict.keys()) # 输出所有键
print (tinydict.values()) # 输出所有值
print (tinydict.clear()) # 输出所有值
dict(Runoob=1, Google=2, Taobao=3) 构造函数构建字典遍历字典
for k, v in knights.items():
print(k, v)数据类型转换
- int(x [,base]) 将x转换为一个整数
- float(x) 将x转换到一个浮点数
- complex(real [,imag]) 创建一个复数
- str(x) 将对象 x 转换为字符串
- repr(x) 将对象 x 转换为表达式字符串
- eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
- tuple(s) 将序列 s 转换为一个元组
- list(s) 将序列 s 转换为一个列表
- set(s) 转换为可变集合
- dict(d) 创建一个字典。d 必须是一个 (key, value)元组序列。
- frozenset(s) 转换为不可变集合
- chr(x) 将一个整数转换为一个字符
- ord(x) 将一个字符转换为它的整数值
- hex(x) 将一个整数转换为一个十六进制字符串
- oct(x) 将一个整数转换为一个八进制字符串
条件控制
if condition_1: statement_block_1 elif condition_2: statement_block_2 else: statement_block_3循环语句
while 循环： while <expr>: <statement(s)> else: <additional_statement(s)> for循环： for <variable> in <sequence>: <statements> else: <statements> range()遍历数字 for i in range(5): print(i) pass 语句，是空语句，是为了保持程序结构的完整性。不做任何事情，一般用做占位语句迭代器
- list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
print (next(it)) # 输出迭代器的下一个元素 1
for x in it:
print (x, end=" ") # 1 2 3 4
while True:
print (next(it))使用了 yield 的函数被称为生成器（generator）。
生成器是一个返回迭代器的函数，只能用于迭代操作，在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
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()函数
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
def 函数名（参数列表）:
函数体参数
必需参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
def printme( str ):
print (str)
printme("hello")
关键字参数
使用关键字参数来确定传入的参数值,允许函数调用时参数的顺序与声明时不一致
def printme( str ):
print (str)
printme(str="hello")
默认参数
调用函数时，如果没有传递参数，则会使用默认参数。
def printme( str='word' ):
print (str)
printme(str="hello")
不定长参数
需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名
def printinfo( arg1, *vartuple ):
print (arg1)
for var in vartuple:
print (var)
printinfo( 70, 60, 50 )加了两个星号 ** 的参数会以字典的形式导入
def printinfo( arg1, **vartuple ):
print (arg1) # 1
for var in vartuple:
print (var) # {'a': 2, 'b': 3}
printinfo( 70, 60, 50 )
printinfo(1, a=2,b=3)声明函数时，参数中星号 * 可以单独出现,如果单独出现星号 * 后的参数必须用关键字传入。
def f(a,b,*,c):
return a+b+c
f(1,2,c=3)输入和输出
输出格式美化
Python两种输出值的方式: 表达式语句和 print() 函数。可以使用 str.format() 函数来格式化输出值。如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。
str()： 函数返回一个用户易读的表达形式。
repr()： 产生一个解释器易读的表达形式。
读取键盘输入
str = input("请输入：");
print ("你输入的内容是: ", str)
读和写文件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: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。
open() 将会返回一个 file 对象，基本语法格式: open(filename, mode)
filename：包含了你要访问的文件名称的字符串值。
mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。模式 描述
t 文本模式 (默认)。
x 写模式，新建一个文件，如果该文件已存在则会报错。
b 二进制模式。
+ 打开一个文件进行更新(可读可写)。
U 通用换行模式（Python 3 不支持）。
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
文件对象的方法
f.read()
# 打开一个文件
f = open("/tmp/foo.txt", "r")
str = f.read()
print(str)
# 关闭打开的文件
f.close()
f.readline()
f.readline() 会从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。
f.readlines()
f.readlines() 将返回该文件中包含的所有行。
如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。
f.write()
f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。
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()
处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源pickle 模块
python的pickle模块实现了基本的数据序列和反序列化。通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。
通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。
基本接口：
pickle.dump(obj, file, [,protocol])
有了 pickle 这个对象, 就能对 file 以读取的形式打开:
x = pickle.load(file)
注解：从 file 中读取一个字符串，并将它重构为原来的python对象。
file: 类文件对象，有read()和readline()接口。import pickle # 使用pickle模块将数据对象保存到文件 data = {'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.dump(data, output) pickle.dump(selfref_list, output, -1) output.close() ########################### #使用pickle模块从文件中重构python对象 pkl_file = open('data.pkl', 'rb') data = pickle.load(pkl_file) print(data) # {'a': [1, 2.0, 3, (4+6j)], 'b': ('string', 'Unicode string'), 'c': None} data2 = pickle.load(pkl_file) print(data2) # [1, 2, 3, [...]] pkl_file.close()OS 文件/目录方法
异常处理
try: f = open('myfile.txt') s = f.readline() i = int(s.strip()) except OSError as err: print("OS error: {0}".format(err)) except ValueError: print("Could not convert data to an integer.") except: print("Unexpected error:", sys.exc_info()[0]) raise else: print(arg, 'has', len(f.readlines()), 'lines') f.close() finally: print('这句话，无论异常是否发生都会执行。')抛出异常
raise Exception('x 不能大于 5。x 的值为: {}'.format(x))用户自定义异常
class MyError(Exception): def __init__(self, value): self.value = value def __str__(self): return repr(self.value) try: raise MyError(2*2) except MyError as e: print('My exception occurred, value:', e.value)定义清理行为
try: raise KeyboardInterrupt finally: print('Goodbye, world!') with open("myfile.txt") as f: for line in f: print(line, end="") 关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:面向对象
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
方法：类中定义的函数。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。class MyClass: """一个简单的类实例""" # 定义基本属性 name = '' age = 0 # 定义私有属性,私有属性在类外部无法直接进行访问 __weight = 0 # 定义构造方法 def __init__(self, n, a, w): self.name = n self.age = a self.__weight = w # 公共方法 def speak(self): print("%s 说: 我 %d 岁。" % (self.name, self.age)) # 单继承示例, 多继承,分分隔 class Student(MyClass): def __init__(self, a, b, n, w): super().__init__(n, a, w) self.a = a self.b = b # 方法重写 def speak(self): print("%s 说: 我 %d 岁。" % (self.name, self.age)) # 私有方法 def __foo(self): print('这是私有方法') # 运算符重载 def __str__(self): return 'Vector (%d, %d)' % (self.a, self.b) def __add__(self, other): return Student(self.age + other.a)类的专有方法：
__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__truediv__: 除运算
__mod__: 求余运算
__pow__: 乘方标准库
# 操作系统接口 import os os.getcwd() # 返回当前的工作目录 'C:\\Python34' os.chdir('/server/accesslogs') # 修改当前的工作目录 os.system('mkdir today') # 执行系统命令 mkdir # 文件复制和移动 import shutil shutil.copyfile('data.db', 'archive.db') shutil.move('/build/executables', 'installdir') # 文件通配符搜索中生成文件列表: import glob glob.glob('*.py') # ['primes.py', 'random.py', 'quote.py'] # 调用命令行 import sys print(sys.argv) # ['demo.py', 'one', 'two', 'three'] # 错误输出重定向和程序终止 # sys 还有 stdin，stdout 和 stderr 属性，即使在 stdout 被重定向时，后者也可以用于显示警告和错误信息。 sys.stderr.write('Warning, log file not found starting a new one\n') sys.exit() # 数学 import math math.cos(math.pi / 4) # 0.70710678118654757 math.log(1024, 2) # 10.0 # 性能度量 from timeit import Timer t = Timer('t=a; a=b; b=t', 'a=1; b=2').timeit() print(t) # 0.023624195000000014 t2 = Timer('a,b = b,a', 'a=1; b=2').timeit() print(t2) # 0.021122228999999992 # 相对于 timeit 的细粒度，:mod:profile 和 pstats 模块提供了针对更大代码块的时间度量工具。 # 访问互联网 from urllib.request import urlopen urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl') #处理get请求，不传data，则为get请求 import urllib from urllib.request import urlopen from urllib.parse import urlencode url='http://www.xxx.com/login' data={"username":"admin","password":123456} req_data=urlencode(data)#将字典类型的请求数据转变为url编码 res=urlopen(url+'?'+req_data)#通过urlopen方法访问拼接好的url res=res.read().decode()#read()方法是读取返回数据内容，decode是转换返回数据的bytes格式为str print(res) #处理post请求,如果传了data，则为post请求 from urllib.request import Request from urllib.parse import urlencode url='http://www.xxx.com/login' data={"username":"admin","password":123456} data=urlencode(data)#将字典类型的请求数据转变为url编码 data=data.encode('ascii')#将url编码类型的请求数据转变为bytes类型 req_data=Request(url,data)#将url和请求数据处理为一个Request对象，供urlopen调用 with urlopen(req_data) as res: res=res.read().decode()#read()方法是读取返回数据内容，decode是转换返回数据的bytes格式为str print(res) # 日期和时间 from datetime import date now = date.today() date.date(2003, 12, 2) now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.") # '12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.' # 支持日历算法 birthday = date(1964, 7, 31) age = now - birthday age.days today = datetime.date.today() # 今天 yesterday = today - datetime.timedelta(days=1) # 昨天 last_month = today.month - 1 if today.month - 1 else 12 # 上个月 time_stamp = time.time() # 当前时间戳 datetime.datetime.fromtimestamp(time_stamp) # 时间戳转datetime int(time.mktime(today.timetuple())) # datetime转时间戳 today_str = today.strftime("%Y-%m-%d") # datetime转字符串 today = datetime.datetime.strptime(today_str, "%Y-%m-%d") # 字符串转datetime today + datetime.timedelta(hours=8) # 补时差 # 数据压缩 # 支持通用的数据打包和压缩格式：zlib，gzip，bz2，zipfile，以及 tarfile。 import zlib s = b'witch which has which witches wrist watch' print(len(s)) # 41 t = zlib.compress(s) print(len(t)) # 37 print(zlib.decompress(t)) # b'witch which has which witches wrist watch' print(zlib.crc32(s)) # 226805979 # random随机数 import random random.choice(['apple', 'pear', 'banana']) # 'apple' random.sample(range(100), 10) # 随机十个 [30, 83, 16, 4, 8, 81, 41, 50, 18, 33] random.random() # 0.17970987693706186 random.randrange(6) # 从范围（6）中选择的随机整数 4测试模块
class Count: def __init__(self, a, b): self.a = int(a) self.b = int(b) def add(self): return self.a + self.b # test fixture:是初始化和清理测试数据及环境，通过覆盖TestCase的setUp（）和tearDown（）方法来实现 # test case:是测试用例 # test suite:是用例集合，即测试套件，通过addTest加载TestCase到TestSuite中，从而返回一个TestSuite实例。 # test runner:的作用是运行用例并返回结果，通过TextTestRunner类提供的run（）方法来执行test suite/test case。 import unittest class TestAdd(unittest.TestCase): def setUp(self): print('前置操作') def test_add(self): j = Count(2, 3) self.assertEqual(j.add(), 5, '计算错误！') def tearDown(self): print('test end') if __name__ == '__main__': # 构造测试集 suite = unittest.TestSuite() suite.addTest(TestAdd('test_add')) # 执行测试集合 runner = unittest.TextTestRunner() runner.run(suite) # 跳过测试和预期失败 # unittest.skip(reason):无条件跳过测试的装饰器，说明跳过的原因 # unittest.skipIf(condition, reason)：如果条件为真，跳过测试的装饰器 # unittest.skipUnless(condition, reason):跳过测试的装饰器，除非条件为真 # unittest.expectedFailure()：测试标记为失败。不管执行结果是否失败，统一标记失败。
62
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
