【总结】Python编程语言

（本文只是自己的学习总结，不一定正确，仅供参考）
（文档.md代码由.docx文档转码而成，会有部分乱码）

Python语言

代码示例：

#!/bin/python——解释器声明，只对unix/linux有效，win忽略

#coding=utf-8——执行时的字符编码声明，Python2以及shell需要

import module1——导入外部模块

from module1 import submodule1 as
md1——从外部某个大模块（包）里导入小模块，并重命名

#coment——注释

class Class1:——定义类

def func1(arg1,arg2):——定义函数，函数名后面要加括号和传入参数

code block——代码块，首行必须缩进4格

return result——函数的返回值

code——普通代码

a,b = c,d——多变量赋值

func:——定义结构

a + b——表达式连接

a=a+5——普通再赋值

a+=5——简便再赋值

语言特性

动态解释型语言

解释型：由解释器读取源代码解释执行。

编译型：先要经过编译过程生成可执行文件，然后执行可执行文件。

动态类型&强类型

动态类型：定义变量时不必指定类型，初次赋值后自动根据值确定类型。

静态类型：定义变量的时候就需要指定变量类型，否则无法通过编译检查。

强类型：变量赋值后就有了固定类型，除非有默认的隐式类型转换或者显式转换为指定类型，否则其类型不变。

弱类型：变量没有确定的类型，可被赋予任何类型的值。

允许面向过程编程（全局变量和函数）

对比其他面向对象语言

C/C++：元老编程语言，其编程模式值得效仿（python正是效仿了其编程模式），但其缺点非常明显：1.C++语法太过复杂，开发效率太低，早已不适合快速开发；2.指针是语法炸弹，若操作不慎会炸出一大堆bug；3.没有自动内存管理；4.头文件与源文件分离，增加了劳动量与编程的复杂性。

java：不允许任何全局变量或函数，全部都是类，但这样就会不够简明、不够灵活，属于过度设计。

js：没有层次封装，在本次执行的本文件内没有命名空间区分，在任何一个地方定义的任何一个变量都是全局变量，所以要通过奇葩的语法-闭包（回调函数链）来实现封闭变量，语言本身不够严谨才逼迫后人使用一些奇葩语法来保证严谨性。

Python：语法简单灵活又不失严谨，编程模式符合常理，优点十分明显。

Python语言的不同实现

CPython（官方C实现）

Jython（Java实现）

PyPy（Python实现，更快）

Cython（C实现，更快，py与c混合编程，可编译为机器码）

PyPI/pip官方源/包管理

PyPI是官方源，可通过官方包管理工具pip（随python安装为系统命令）安装第三方包。（包名称不区分大小写，包的命名规则有纯英文、英文+中括号后缀、英文+横杠后缀）

Python3新特性

2&3版本兼容

from __future__ import [新特性]

特性	可导入	强制要求	功能
nested_scopes	2.1.0b1	2.2	PEP 227: Statically Nested Scopes（静态内部类）
generators	2.2.0a1	2.3	PEP 255: Simple Generators（生成器）
with_statement	2.5.0a1	2.6	PEP 343: The “with” Statement（with语句）
absolute_import	2.5.0a1	3.0	PEP 328: Imports: Multi-Line and Absolute/Relative（绝对引用和相对引用，不常用）
division	2.2.0a2	3.0	PEP 238: Changing the Division Operator（2整除会截断小数位，3整除保留小数，若想截断请用//地板除）
print_function	2.6.0a2	3.0	PEP 3105: Make print a function（2print关键字，3print函数）
unicode_literals	2.6.0a2	3.0	PEP 3112: Bytes literals in Python 3000（字符串格式表示：2unicode需加u、二进制需加b，3不需要前缀）
generator_stop	3.5.0b1	3.7	PEP 479: StopIteration handling inside generators
annotations	3.7.0b1	4.0	PEP 563: Postponed evaluation of annotations

函数注释

语法：（形参加冒号，返回值加箭头）

def foo(a: expression, b: expression = 5) -> expression:

…

作用：只是注释，不会影响程序执行结果，但这个注释是动态可变、可赋值的，可在执行过程中动态查看和修改注释内容，用于标记运行状态。

查看所有的函数注释：print(foo.__annotations__)

变量与数据结构

基本数据类型变量

标准CPython实现：

Python中“变量”名是对实际数据的引用，数据自动占用内存，“变量”只是指向内存地址的指针。对某数据进行操作，任何指向该数据的“变量”均同步变化。

python建立的数据均自动统计引用计数，引用计数为0则会销毁此数据。

变量名不能以数字开头。

强制类型转换——int(variety)。

整数int

浮点数float

小数decimal

分数fraction

复数complex

——3+4j

进制表示（整数浮点数都可）

十进制——1234,3.1415

二进制——0b11001

八进制——0o754

十六进制——0xA89DE

字节与字符

字节（已编码utf-8/gbk、二进制）表示：\x0e\xaa\x12\x9c

字符：python3默认为Unicode字符，python2默认为ASCII字符

Unicode字符：\u5b66\u4e60\u603b\u7ed3-\u8ba1\u79d1

常用复合数据类型变量

【字符串str】（可索引、切片、连接）常量

定义时用双引号或单引号或三引号，索引时用[]

语法特性：

str = “string”——双引号形式

str = ‘string’——单引号形式

str = “””\

stringline1

stringline2

“””——多行字符串

str*5——重复输出5遍

“string1”“string2”——字符串连接（仅限于纯字符串）

“string1” + “string2”——字符串连接（通用）

“This is a string”[0]——字符串下标索引

“This is a string”.split()——直接调用字符串的类型方法

str[0]——字符串下标索引（正序）（=”s”）

str[-1]——字符串下标索引（逆序）（=”g”）

str[0:2]——字符串切片（正序）（=”str”）

str[:3]——字符串切片（默认起始，正序）（=”strn”）

str[:-2] + str[-2:]——字符串切片（默认起始结束，逆序）（=”string”）

r’string\n’——自然字符串，加上r或R前缀可忽略转义字符直接显示

u’string\n’——使用Unicode编码的字符串，加上u或U前缀（仅限py2，py3已默认是Unicode）

b’string\n’——把ASCII或Unicode字符串保存为经过编码的适用于传输和存储的字节串（py2/py3通用）

输入参数：

“{} can be {}”.format(“strings”, “interpolated”)

“{0} be nimble, {0} be quick, {0} jump over the {1}”.format(“Jack”,
“candle stick”)

“{name} wants to eat {food}”.format(name=“Bob”, food=“lasagna”)

“%s can be %s the %s way” % (“strings”, “interpolated”,
“old”)——老式输入参数方法，py3对py2的兼容

方法成员：

str.split(‘.’)/rsplit()——以.分割字符串，例如”192.168.1.1”分割成”192”,”168”,”1”,”1”

str.fomat()——格式化输出

str.capitalize()——返回首字母大写

str.lower()——返回全小写

str.upper()——返回全大写

str.swapcase()——转换大小写

str.count()——统计子串的次数

str.center()——获取指定长度的子串

str.encode()——指定字符编码

str.find()/rfind()——搜索是否存在子串，返回最低索引

str.expandtabs()——把tab替换为空格

str.isalpha/isdecimal/isdigital——判断是否为字母、数字，字符串格式判断

str.join()——串联迭代中的字符串

str.lstrip()/rstrip()——删除前导字符集（删除参数指定的字符集，而不是前缀）

str.strip()——同时删除前导和尾随字符集

str.replace()——替换指定位置的字符

str.title()——返回字符串的标题版本，每个单词首字母大写

str.translate()——根据转换表进行转换翻译

str.zfill()——用ASCII字符填充特定长度

元组tuple常量

定义时用()小括号，索引时用[]

结构同list但定义后不可更改

多个变量自动构建为元组，也可把元组拆解到多个变量

return a=1,b=2——ans=(1,2)

a, b, c = (1, 2, 3)

d, e, f = 4, 5, 6——多变量语句可视为省略了括号的元组

【列表list】（可索引、切片、连接、作为队列、作为栈）

定义时用[]中括号，索引时用[]

类似于数组，可存储多种类型

语法特性：

list = [1,4,9,16,25]——列表普通形式

list[0]——列表索引

list[:2]——列表切片

list1 + list2——列表连接

list = [1,4,9,[1,4],25]——列表嵌套

list[:2] = [“1”,”4”]——列表切片赋值

li[::-1]——倒排列表，利用了li[始:终:步伐]，步伐为-1即倒排

del li[2]——删除列表的某一项

li + other_li——列表相加拼接为一个列表，相当于append()方法

方法成员：

list.append(x)——在尾部添加单个原子元素或添加子数据结构，append(‘1’)添加单个元素，append([‘1’,’2’])添加子表

list.extend(L)——在尾部添加单个原子元素，append([‘1’,’2’])在尾部附加为平级元素不成为子表

list.insert(i,x)——在i处插入新成员x

list.remove(x)——移除值为x的成员，如果有多个，只移除第一个，如果没有则报错

list.pop()——移除最近存入的成员并返回此成员（作为栈）

list.popleft()——移除最左侧的成员并返回此成员（作为队列）

list.clear()——清空列表

list.index(x)——确认值为x的成员，如果有，则返回第一个

list.count(x)——累计值为x的个数

list.sort()——给列表正序排序

list.reverse()——给列表逆序排序

list.copy()——返回一个浅拷贝（浅拷贝是添加引用，深拷贝是复制所有内存内容）

列表推导式获取列表：

[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7]

【字典dict】（键值对，兼容json写法）

定义时用{}大括号，索引时用[]

键必须是字符串，值可选任意类型

类似于数据库中的表，json，结构为键：值(key:value)（与json格式上只有一个区别，即引号单双的不同，可json.dumps(dict1)直接输出为json串，以及json.loads(str)导入json串到dict对象）

语法特性：

dict1={“Tom”:76,”Bob”:89,”Mary”:87}——字典定义

dict1[“Bob”]——字典键索引，若不存在此键则出错

“one” in filled_dict——测试是否存在某个键

del filled_dict[“one”]——删除某个键

方法成员：

dict.len()——返回字典的项目数

dict.clear()——清空字典

dict.copy()——浅拷贝

dict.get(“key1”,None)——如果存在此键则返回其值，若不存在则返回默认值

dict.setdefault(“key1”,None)——如果存在此键则返回其值，否则创建此键设置默认值并返回

dict.items()——返回所有键值对

dict.keys()——返回所有键

dict.values()——返回所有值

dict.pop()——取出某个键对应的值并删除此项目

dict.popitem()——取出最后进入的项目

dict.update()——添加项目&通过参数中的键值对更新字典（键值对需要{}括起来），若键已存在则更新值，若键不存在则添加项目

集合set（非重复集合，不可索引，可集合运算）

定义时需要提前建立空集合empty_set = set()，然后添加元素some_set = {1,
1, 2, 2, 3, 4}=》{1, 2, 3, 4}

语法特性：

2 in filled_set——测试是否存在某个元素

filled_set & other_set——交（运算符是按位逻辑运算）

filled_set | other_set——并（运算符是按位逻辑运算）

{1, 2, 3, 4} - {2, 3, 5}——补

方法成员：

set1.add()——添加元素

set1.remove()——移除元素

set1.update()——添加多个元素

变量的特性

一切皆引用

所有的基本数据类型、字符串、数组、函数名、对象实例名，均为对内存中实际的变量实例的引用。

例：

a=10——在内存中新建一个数值对象，赋值10，并新建一个指向此对象的引用a

b=a——把a引用的地址传递给b，则b指向“10”这个对象

a=20——在内存中新建新对象“20”，a指向 “20”

b=?——b仍然指向“10”

此处b应当等于10

a=10——初次赋值

a=20或者a=’string’——重新赋值，无论是同类型还是不同类型，都是新开辟了一个实际的变量空间，a从指向原先的变量空间变为指向了新的变量空间；旧变量去哪了？通过引用计数垃圾回收机制处理

一切皆对象

所有的基本数据类型、字符串、数组、函数名、对象实例名，均可视为对象。

例：

1——一个数字也是对象，是int()类的一个实例，可调用int()类即int整数类型的各种方法

‘string’——一个字符串也是对象，是str()类的一个实例，可使用str()字符串类型的各种方法，比如‘string’.split()

classObj——自定义类的实例

可变对象与不可变对象

不可变（immutable）常量对象：数字、字符串（str）、元组（tuple)

可变（mutable）：字典型(dictionary)、列表型(list)、集合型（set）

生命周期

有引用则一直存在，无引用则稍后通过自动垃圾收集机制回收。

作用域

只有两种作用域：全局和局部。

全局变量：在代码文件中定义，想作用于函数内，需加 global。

局部变量：在同一个函数内全体共享局部变量，不区分子代码块。

强制类型转换

与C形式相同，在变量外添加强制转换函数。

直接赋值、浅拷贝和深拷贝

建立一个列表变量a:

a=[a,b,c,[1,2,3]]

直接赋值给b:

b=a——a和b指向同一个数据地址，数据同步变化

浅拷贝给c:

import copy

c=copy.copy(a)——c复制a建立了一个列表变量副本（两个变量本身已不相干），但变量内部通过引用的元素仍然是同一份，可变类型的元素仍然同步变化

深拷贝给d:

import copy

d=copy.deepcopy(a)——d复制a和a的元素建立了副本，包括变量本身和变量内部引用的所有元素都互不相干

操作符

数学运算

+——加

-——减

*——乘

/——除（浮点）

//——除（整除，向下取整，别名地板除）

%——除（取余，别名模）

**——幂

逻辑运算

&&或and——与

||或or——或

!或not——非

&——按位与

|——按位或

～——按位非

^——按位异或

关系运算

>——大于

>=——大于等于

<——小于

<=——小于等于

==——等于

!=——不等于

可连续比较，如：

1 < 2 < 3 # => True

2 < 3 < 2 # => False

‘ABC’ < ‘C’ < ‘Pascal’ <
‘Python’——每个字符依次按照unicode编码顺序比较

操作符重载

例：

class Vector:

def __init__(self, a, b):

self.a = a

self.b = b

def __str__(self):

return ‘Vector (%d, %d)’ % (self.a, self.b)

def __add__(self,other):

return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)

v2 = Vector(5,-2)

print v1 + v2

运行结果：Vector(7,8)

常用操作

逻辑真假

逻辑真：逻辑True，0以外的任意数字，任意非空数据结构

逻辑假：逻辑False，空数据None，数字0，空数据结构’’,[],(),{}

比较大小

==等于或!=不等于：数字的数值相等或不等，字符串内容相等或不等，前两者不必为同一对象；其他数据类型必须为同一对象

><大于小于：必须同一类型比较，数字比较数值大小（不同的数值类型可以比较，如整数和浮点数），字符串比较长度；其他数据类型不能直接比较

虽然整数可以与浮点数比较大小或者比对是否相等，但几乎不可能会相等，比较大小也不是完全可靠，因为浮点数不是精确值

测试长度

len()——数字返回字节数，字符串返回字符数，序列类型返回元素数

测试类型

type(obj)——返回类型字符串

测试是否为某类的实例

isinstance(obj,cls)——返回True或False

关键字

True——逻辑真

False——逻辑假

None——空

in——判断是否是序列中的值

is——判断是否为同一个对象

import/from…import——导入外部模块

package是文件夹，由__init__.py管理，向python引擎表示这是一个py包；module是.py文件，可定义多个class/function/varity，建议一个类对应一个文件，尽量把代码写成类、独立变量与过程这两种形式，一个提供基础代码，一个作为脚本执行。

import package/module——程序中使用须加前缀

from module import class/function/variety/*——程序中直接使用名称

del——删除对象或对象中的元素

set——使

pass——空语句，占位符

yield——协程生成器

流程控制

if-elif-else（条件）

if x<0:

code1

elif x==0:

code2

else:

code3

for-in（遍历）

1.按照容器内顺序遍历，可切片遍历：

lists = [1,4,9,16]

for list in lists[0:2]:

code

2.按照等差数列遍历（与c系列类似）：

for i in range(5):

code

3.使用enumrate()函数进行遍历（index输出序号，item输出迭代项值）：

for index, item in enumerate(sequence):

print(index, item)

while/do-while（循环）

while x<5:

code

break（跳出循环体，也可在for语句中使用）

continue（跳出本次循环，进入下一次循环，也可在for语句中使用）

pass（空操作）

内存管理

引用计数垃圾回收

当对象被创建时，就创建了一个引用计数，当这个对象不再需要时，也就是说，这个对象的引用计数变为0
时， 它被垃圾回收。但是回收不是"立即"的，
由解释器在适当的时机，将垃圾对象占用的内存空间回收。

异常处理

try-except-else-finally（异常处理）

try:有可能出现异常的代码

except:捕获上面代码可能会出现的异常类型，执行相应操作，例：except
IOError,msg:pass

else:没有任何异常时才会执行的代码

finally:不管有没有异常，最后都要执行的代码

raise（直接抛出异常）

assert（断言测试异常）

后面跟表达式，若表达式为真则继续执行，若为假则抛出异常

Python内置异常类型

BaseException

±- SystemExit

±- KeyboardInterrupt

±- GeneratorExit

±- Exception

±- StopIteration

±- StopAsyncIteration

±- ArithmeticError

| ±- FloatingPointError

| ±- OverflowError

| ±- ZeroDivisionError

±- AssertionError

±- AttributeError

±- BufferError

±- EOFError

±- ImportError

| ±- ModuleNotFoundError

±- LookupError

| ±- IndexError

| ±- KeyError

±- MemoryError

±- NameError

| ±- UnboundLocalError

±- OSError

| ±- BlockingIOError

| ±- ChildProcessError

| ±- ConnectionError

| | ±- BrokenPipeError

| | ±- ConnectionAbortedError

| | ±- ConnectionRefusedError

| | ±- ConnectionResetError

| ±- FileExistsError

| ±- FileNotFoundError

| ±- InterruptedError

| ±- IsADirectoryError

| ±- NotADirectoryError

| ±- PermissionError

| ±- ProcessLookupError

| ±- TimeoutError

±- ReferenceError

±- RuntimeError

| ±- NotImplementedError

| ±- RecursionError

±- SyntaxError

| ±- IndentationError

| ±- TabError

±- SystemError

±- TypeError

±- ValueError

| ±- UnicodeError

| ±- UnicodeDecodeError

| ±- UnicodeEncodeError

| ±- UnicodeTranslateError

±- Warning

±- DeprecationWarning

±- PendingDeprecationWarning

±- RuntimeWarning

±- SyntaxWarning

±- UserWarning

±- FutureWarning

±- ImportWarning

±- UnicodeWarning

±- BytesWarning

±- ResourceWarning

函数

不需要声明直接定义

定义、调用、调用时赋予实参、定义时在函数内定义形参

局部变量（函数内定义）、全局变量（文件内函数外定义）

固定参数、可变列表参数list、可变关键字参数dict

传入固定参数（传统方式）——

无默认值必选：

def func(arg1):

code

有默认值可选：

def func(arg1=True):

code

多个参数必选在前可选在后否则出错：

def func(arg1,arg2=True,arg3=True):

code

调用时乱序传参必须指定参数名称：

func(value1,arg3=value2)

传入列表参数(参数前加*号)——

def func(*x):

code

func(a,b,c)

传入关键字参数（参数前加**号）——

def func(**x):

code

func(a=1,b=2)

混用：

def func(*x,**y):

code

func(1, 2, 3, 4, a=3, b=4)

匿名函数lambda

快速定义单行小函数

def f(x,y): ——定义

return x*y

ans=f(2,3) ——调用。ans=6

等价于

ans=(lambda x,y:x*y)(2,3)——直接产生结果。ans=6

——冒号前面写输入参数，冒号后面写函数体直接返回

两种调用

函数对象：func——一般作为回调函数的参数，函数对象就是这个函数的所有代码

函数执行，获取返回值：func()

默认返回None

可定义内部函数（闭包）

类

基础定义

定义：

class Test(SuperClass):

var=123

def __init__(self, arg):

super(Test,self).__init__()

initcode

def obj_func(self):

print(“hello”)

@classmethod

def class_func(cls):

code

@staticmethod

def static_func():

code

@property

def Property(cls):

code

实例化：

newObj=Test(arg)——实例化并执行初始化函数

调用：

Test.var——调用类变量

Test.static_func()——调用静态方法

newObj.obj_func()——调用实例方法

newObj.class_func()——调用类方法

newObj.Property——调用类属性

三种调用

返回类定义代码对象MyClass

调用类MyClass()

调用实例classobj = MyClass();classobj

初始化函数（构造函数）

def __init__():

code

引用父类super引用本实例self引用本类cls

子类默认不执行父类的__init__，若需要执行则写：super(子类,self).__init__()

写代码，若使用的是类变量或函数则使用cls.name，若使用的是实例变量或函数则使用self.name

可定义内部类（闭包）

类属性

函数前用@property修饰。被所有此类的实例共用，可被任意实例更改

类变量

所有实例共享的类的变量

实例变量

每个具体实例各自独有的变量

静态方法

函数前用@staticmethod修饰。不需要实例化，与类或实例均没有关联，是可独立执行的代码，直接通过类名访问执行

类方法

函数前用@classmethod修饰。被所有此类的实例共用，可被任意实例更改

实例方法

一般的函数，每一个实例都有其私有的函数，不同的实例间没有联系

实例属性方法

getattr()获取实例属性

——getattr(obj,obj_input)——通过obj_input变量的输入值得到obj与输入值同名的属性（根据输入生成同名属性）

setattr()设置实例属性

特殊的类属性

对于所有的类，都有一组特殊的属性：

类属性	含义
__name__	类或者模块文件的名字（字符串）
__init__	实例创建后执行的第一个函数（类似构造函数）
__del__	类似析构函数
__doc__	类的文档字符串
__bases__	类的所有父类组成的元组
__dict__	类的属性组成的字典
__module__	类所属的模块
__class__	类对象的类型
__str__	返回用户看到的字符串
__repr__	返回程序员看到的字符串（调试）
__all__	指定对外公开的成员（只针对from import *）

对象的动态操作

setattr()——添加对象的成员

hasattr()——测试对象的成员

getattr()——获取对象的成员

delattr()——删除对象的成员

工程管理

包

模块的集合，通过文件夹组织，以文件路径解析，包是一个完整的工程。

.py源代码文件/模块

被import到其他代码中的.py文件就是模块，一个.py源代码文件就是一个模块。

直接import
module1会导入所有module1.py中的代码，如果有可执行代码会直接执行，使用module1.py中的函数应当这样写：module1.func1()

from module1 import func1只导入func1函数的定义，使用时直接写：func1()

如果直接执行，代码文件顶层的__name__默认值为__main__，如果被其他代码导入，__name__为文件名。可通过判断__name__判断是否为直接执行，从而决定是否执行相关代码

有很多个文件，可以创建包，在里面创建__init__.py包管理文件（一个空文件）

import package1.module1

Class类与全局变量、全局函数

命名规范

双下划线封边（特殊的方法）

双下划线开头（类的私有成员private，非强制）

单下划线开头（类的保护类型protected，非强制）

高级用法

迭代器（iterator）iter()

在迭代子满足条件的情况下，可迭代对象会不断重复执行，可以视为一个可执行序列（列表）。调用下一个迭代对象：iter.next()

可迭代对象：列表、字符串。

不可迭代对象：字典、元组、集合等。

要想把不可迭代对象转化为可迭代对象，就要使用迭代器。显式使用迭代器为iter()，python语法中已经提供了很多隐含的迭代器，如range()/enumrate()函数。

for item in range(1,10):——

dict1[‘key’+item]

for num,item in enumrate(dict1.keys()):——

dict1[item]=num

生成器（generator）yield协程

通过关键字yield实现，每一次循环执行到yield会返回后面的值，并在下一次循环时直接跳到yield下一行执行。yield本身相当于迭代器，使用了yield关键字的函数是一个生成器。生成器yield实现了协程功能。

通常用于异步编程避免阻塞。

传统的生产者-消费者模型是一个线程写消息，一个线程取消息，通过锁机制控制队列和等待，但一不小心就可能死锁。

如果改用协程，生产者生产消息后，直接通过yield跳转到消费者开始执行，待消费者执行完毕后，切换回生产者继续生产，效率极高。

例：

def MyGenerator():

value=yield 1

yield value

return done

gen=MyGenerator()——实例化一个生成器

print(next(gen))——初次调用（可使用next(gen)或gen.send(None)），执行第一句value=yield
1中的右侧，则yield返回1

print(gen.send(“I am
Value”))——生成器继续在上一次yield处向后执行，执行到value=，接收到send()传递的值，即value=“I
am Value”，依次执行，执行到yeild value，返回"I am Value"

装饰器（decorator）@wrapper

一个函数被另一个函数装饰——即另一个函数调用一个函数并赋予额外的功能，然后返回包装好的函数。如果一个函数被装饰器装饰，直接执行此函数的效果就相当于在装饰器内调用此函数。

装饰器函数可用@装饰器函数名，来修饰其他被装饰的函数。

例：

def beg(target_function):——装饰器函数

@wraps(target_function)

def wrapper(*args, **kwargs):——使用python库里的装饰器函数

msg, say_please = target_function(*args, **kwargs)——调用被装饰函数

if say_please:

return “{} {}”.format(msg, “Please! I am poor ?”)

return msg

return wrapper

@beg

def say():

code

return msg, say_please

并发

协程（详见生成器）

多线程

多进程

性能优化

尽量少使用try-except，或者except一定要指定有限的类型，因为会搜索所有的出错类型，比较耗时

Python库

Python内置函数（~=70个）

Built-in Functions

abs()

delattr()

hash()

memoryview()

set()

all()

dict()

help()

min()

setattr()

any()

dir()

hex()

next()

slice()

ascii()

divmod()

id()

object()

sorted()

bin()

enumerate()

input()

oct()

staticmethod()

bool()

eval()

int()

open()

str()

breakpoint()

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()

定义简单变量对象

bool()——定义布尔变量对象

int()——定义整型变量对象

float()——定义浮点数变量对象

complex()——定义复数变量对象

定义数据结构容器

str()——定义字符串对象

dict()——定义字典对象

list()——定义列表对象

tuple()——定义元组对象

set()——定义可变集合对象

集合对象，可进行集合交并补运算、成员测试、删除重复项

frozenset()——定义不可变集合对象

bytearray()——定义可变字节对象

是一连串单字节组成的数组，而字符串是一整个对象。

简单定义（添加前缀b）：

b’still allows embedded “double” quotes’

方法成员与字符串类似。

bytes()——定义不可变字节对象

是由字符串编码后组成的字节串，python3中以b为前缀的就是bytes()类型。str()是未经过编码的Unicode字符串，bytes()是经过编码的字节串（需指定ascii或utf-8或gbk等编码）。

memoryview()——建立内存视图对象（对缓冲区的引用）

访问在内存缓冲区的变量内容而无需复制。

数值算法类

abs()——取绝对值

bin()——数值二进制显示

oct()——数值八进制显示

hex()——数值十六进制显示

max()——取最大值

min()——取最小值

round()——小数点精确度

divmod()——除法取商取余

返回div+mod

pow()——幂

迭代算法类

len()——取结构长度

sum()——统计迭代个数

all()——迭代器全真返回真

any()——迭代器任意真返回真

range()——返回计数

enumerate()——返回枚举对象

>>> seasons = [‘Spring’, ‘Summer’, ‘Fall’, ‘Winter’]

>>> (enumerate(seasons)

(0, ‘Spring’), (1, ‘Summer’), (2, ‘Fall’), (3, ‘Winter’)

iter()——返回迭代器

reversed()——返回反向迭代器

next()——进入下一次迭代（类似continue）

filter(func,list)——筛选

利用筛选函数func把序列中返回值为True的值保留下来，为False的值删掉

zip(list1,list2)——并行遍历

（把多个序列交叉合并）

map(func,list1,list2)——并行遍历

（把多个序列交叉合并）然后传递给函数操作

reduce(func,list)——递归计算

sorted(list)——广义排序

IO处理类

chr()——编码数字转化为Unicode字符

For example, chr(97) returns the string ‘a’, while chr(8364) returns the
string ‘€’

ord()——Unicode字符转化为编码数字

是chr()的反过程

print()——输出

可格式化打印（%s,%d）类比于c语言的printf

py3设置结尾不换行——print(str, end=””)

%d——整数输出

%f——浮点数输出

%s——字符串输出

format()——文本格式化输出

input()——读取键盘输入

open()——打开文件

file object = open(file_name [, access_mode][, buffering])

Character	Meaning
'r'	open for reading (default)
'w'	open for writing, truncating the file first
'x'	open for exclusive creation, failing if the file already exists
'a'	open for writing, appending to the end of the file if it exists
'b'	binary mode
't'	text mode (default)
'+'	open a disk file for updating (reading and writing)
'U'	universal newlines mode (deprecated)

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

slice()——对序列切片

面向对象类

object()——返回最基本的对象

ascii()——返回对象的ASCII字符串

repr()——返回对象的字符串

super()——取父类

dir()——展示对象成员列表

setattr()——添加对象的成员

hasattr()——测试对象的成员

getattr()——获取对象的成员

delattr()——删除对象的成员

isinstance()——测试是否为某对象的实例

issubclass()——测试是否为某对象的子对象

str()——返回对象的str文本

语言类

callable()——测试是否可访问

compile()——编译到目标代码

Compile the source into a code or AST object. Code objects can be
executed by exec() or eval(). source can either be a normal string, a
byte string, or an AST object. Refer to the ast module documentation for
information on how to work with AST objects.

eval()——动态执行表达式

exec()——动态执行代码对象

globals()——获取全局变量

locals()——读取本地变量域

vars()——更新并读取本地变量域

hash()——获取对象的哈希值

id()——获取对象的数值ID

help()——调用系统帮助文档

__import__()——反射机制导入模块

装饰器类

装饰器本身也是一个函数，利用装饰器模式设计，把被装饰的对象包含在内，添加修饰语句。

@classmethod——类方法

@staticmethod——静态方法

@property——类属性

Python标准库

文本与数据

re——正则表达式

string——字符串的各种方法

datetime——日期时间

calendar——日历

collections——集合容器

heapq——堆（优先队列二叉树）

bitset——有序存储的列表

array——性能优化的列表

weakref——弱引用（不阻止销毁）

types——动态创建类对象

pprint——针对复杂数据结构的优化打印

pprint.PrettyPrinter()

enum——枚举

enum.Enum

copy——对象的浅拷贝和深拷贝

数值与数学

numbers——数字对象

decimal——小数对象

fractions——有理数对象

math——数学函数

包含常用数学常量、数学计算、指数对数、三角函数等

cmath——可操作复数的数学函数

比math增加的内容：极坐标转换

random——随机数函数

statistics——统计函数

平均数、中位数、众数、方差等

文件与路径

io——输入输出流

glob——文件搜索

linecache——文件行缓存

linecache.getline()

shutil——高级文件系统操作

csv——csv解析

json——json解析

xml——xml解析

html——html简单操作

configparser——ini配置文件解析

hashlib——加密算法

base64——二进制编码（常用于网络图片）

压缩打包类

pickle——python对象存储（二进制）

shelve——python对象存储（键值对）

网络与异步IO

asyncio——异步IO编程

引入消息机制事件循环（与GUI和前端的事件循环类似），实现异步，增强交互

socket——底层网络socket编程

与asyncio结合使用，可实现异步网络编程

ssl——安全层

socketserver——对socket库的封装

urllib类

http类

webbrowser——使用浏览器引擎

操作系统与编程语言

os——系统相关

time——计时与暂停

argparse——命令行参数解析

命令行执行python程序时，对后面的参数进行解析

logging——日志输出

sys——python语言系统相关

并发

threading——多线程

继承Thread类，重写run()方法

threading.Lock()——线程锁

multiprocessing——多进程

封装了管道和队列，提供了同步锁，进程池

queue——线程安全的队列

数据库

sqlite3——sqlite数据库

GUI

tkinter类

Python扩展库

官方库扩展以及编程工具类

python-memcached——分布式缓存

click——命令行软件开发

psutil——获取系统信息

数据库

psycopg2——postgresql

MySQLdb——mysql

redis——redis

pymongo——mongodb

SQLAlchemy——数据对象模型编程

文件类

openpyxl——excel数据表读写

mammoth——word格式转换

pandoc——主流文本文档格式转换

网络类

requests——网络模拟访问（目前最高可用性）

selenium——模拟浏览器

bs4(beautifulsoup)——网页渲染与解析

lxml——xpath寻址的网页解析器

html5lib——网页解析器

pyquery——仿jquery的网页解析器

网络框架类

aiohttp——基于标准asyncio的异步http协议

gevent——对协程的完善支持

Python通过yield提供了对协程的基本支持，但是不完全。而第三方的gevent为Python提供了比较完善的协程支持。

当一个greenlet遇到IO操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO。

twisted——事件驱动异步IO网络框架

支持多种协议。UDP,TCP,TLS（SSL）和其他应用层协议

autobahn[twisted]——适用于twistred的websocket协议

scrapy——基于twisted的爬虫服务框架

Django——大型网站服务框架

Flask——中型网站服务框架

web(web.py)——小型网站服务框架

图形编程类

qrcode——二维码

PyGame——游戏

OpenCV——计算机视觉

pillow(PIL)——图像处理

moviepy——视频处理

计算与数据类

numpy——主要是线性代数矩阵运算

pandas——数据处理与分析，excel格式转换

matplotlib——数据图表

tensorflow——机器学习

GUI框架类

PyQt——qtGUI框架的py版本

Python开发

正则表达式与字符转义——re

re.compile()——生成正则表达式规则对应的对象

re.search()——在字符串内搜索，匹配一个就返回

（易误导，不常用）re.match()——从串的开头匹配，失败立即返回

（易误导，不常用）re.fullmatch()——匹配整个串

re.split(pattren,string)——利用正则表达式分割字符串，例如re.split(’[_#|]’,‘this_is#a|test’)

re.findall()——搜索并匹配所有能够匹配的子字符串

re.sub()——把匹配的子字符串替换掉

re.escape()——将ASCII字符、数字、下划线之外的字符进行转义

日期时间——datetime

datetime.datetime——表示日期时间的对象

datetime.datetime(year,month,day,hour,minute,second)——日期时间对象

datetime.today()——当前时间

datetime.strftime()——输出指定格式的字符串

datetime.strptime()——将格式字符串转化为datetime对象

datetime.timedelta——日期时间的计算

timedelta=datetime1-datetime2

深浅拷贝——copy

copy.copy()

（1）对于shallow
copy而言，它创建一个新的混合对象，并且将原对象中其他对象的引用插入新对象。

copy.deepcopy()

（2）对于deep
copy而言，它创建一个新的对象，并且递归地复制源对象中的其他对象并插入新的对象中。

数据文档——json,xml,configparser,html,pickle

ini/cfg语法配置文件

cfg=configparser.ConfigParser()——建立配置文件实例

cfg.read(‘配置文件路径’)——读取配置文件

cfg.get(‘sectionname’,’keyname’)——获取section下面的某个键的字符串值

cfg.getboolean(‘sectionname’,’keyname’)
——获取section下面的某个键的布尔值（True or False）

cfg.getfloat(‘sectionname’,’keyname’) ——获取section下面的某个键的浮点值

cfg.getint(‘sectionname’,’keyname’) ——获取section下面的某个键的整数值

json文档数据

json.dumps()——obj或dict对象输出到json字符串

json.loads()——json字符串转化为obj

html文档数据

html.escape()——转义字符串到html-safe串

html.unescape()——反操作

html.parser——简单的html解析

pickle对象存储

pickle.dumps(obj,file)——输出到二进制文件

pickle.loads(file)——从二进制文件加载对象

数值与数学——random,math,numpy,pandas

random随机

random.seed()——随机数种子

random.randint(1,10)——返回1-10之间的随机整数

random.random()——返回0-1之间的浮点数

random.choice([1,2,3])——返回列表中的随机值

random.choice(“abcdefg”)——返回字符串中的随机字符

random.shuffle([1,2,3,4,5])——搅乱顺序

另外还有按照随机分布规律的分布函数

操作系统——os,psutil

os系统操作

os.name——操作系统名称

os.environ——环境变量

os.getenv()——获取环境变量键对应的值

os.getegid()——当前进程的groupid

os.geteuid()——当前进程的userid

os.abort()——发出中止信号

os.exec*()——各种执行新进程的函数

os.fork()——fork子进程

os.kill(pid,sig)——kill某个进程

os.system(command)——执行系统命令

psutil系统信息

psutil.cpu_count() # CPU逻辑数量

psutil.cpu_count(logical=False) # CPU物理核心

psutil.cpu_times() #CPU时间占用就是CPU的使用量

psutil.virtual_memory() #物理内存

psutil.swap_memory() #交换空间（虚拟内存）

psutil.disk_partitions() # 磁盘分区信息

psutil.disk_usage(’/’) # 磁盘使用情况

psutil.net_if_addrs() # 获取网络接口信息

{

‘lo0’: [snic(family=<AddressFamily.AF_INET: 2>, address=‘127.0.0.1’,
netmask=‘255.0.0.0’), …],

‘en1’: [snic(family=<AddressFamily.AF_INET: 2>, address=‘10.0.1.80’,
netmask=‘255.255.255.0’), …],

‘en0’: […],

‘en2’: […],

‘bridge0’: […]

}

psutil.net_if_stats() # 获取网络接口状态

{

‘lo0’: snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_UNKNOWN:
0>, speed=0, mtu=16384),

‘en0’: snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_UNKNOWN:
0>, speed=0, mtu=1500),

‘en1’: snicstats(…),

‘en2’: snicstats(…),

‘bridge0’: snicstats(…)

}

文件与路径——os,glob,shutil

os系统文件操作

文件系统操作

os.access(path,mode)——测试文件读写权限

mode=

os.F_OK: 作为access()的mode参数，测试path是否存在。

os.R_OK: 包含在access()的mode参数中 ， 测试path是否可读。

os.W_OK 包含在access()的mode参数中 ， 测试path是否可写。

os.X_OK 包含在access()的mode参数中 ，测试path是否可执行。

返回值为True/False，True表示测试通过

os.chmod(path,mode)——对应命令chmod

mode=

stat.S_IXOTH: 其他用户有执行权0o001

stat.S_IWOTH: 其他用户有写权限0o002

stat.S_IROTH: 其他用户有读权限0o004

stat.S_IRWXO: 其他用户有全部权限(权限掩码)0o007

stat.S_IXGRP: 组用户有执行权限0o010

stat.S_IWGRP: 组用户有写权限0o020

stat.S_IRGRP: 组用户有读权限0o040

stat.S_IRWXG: 组用户有全部权限(权限掩码)0o070

stat.S_IXUSR: 拥有者具有执行权限0o100

stat.S_IWUSR: 拥有者具有写权限0o200

stat.S_IRUSR: 拥有者具有读权限0o400

stat.S_IRWXU: 拥有者有全部权限(权限掩码)0o700

stat.S_ISVTX: 目录里文件目录只有拥有者才可删除更改0o1000

stat.S_ISGID: 执行此文件其进程有效组为文件所在组0o2000

stat.S_ISUID: 执行此文件其进程有效用户为文件所有者0o4000

stat.S_IREAD: windows下设为只读

stat.S_IWRITE: windows下取消只读

os.chdir(path)——改变当前进程的工作目录

os.chroot(path)——改变当前进程的根目录（默认根为系统的/）

os.getcwd()——返回当前工作目录

（受限）os.mkdir(path)——创建单层目录（若已存在则报错）

（受限）os.makedirs(path)——创建多层目录（若已存在则报错）

（受限）os.remove(path)——删除文件（但不能删除目录，必须与os.rmdir()组合使用）

（受限）os.rmdir(path)——删除空文件夹

（受限）os.removedirs(path)——递归删除空目录树（但只能删除空目录，快捷删除目录请用shutil.rmtree()）

os.rename(old,new)——重命名文件或目录

os.listdir(path)——对应命令ls

os.link(srcpath,dstpath)——创建硬链接文件

os.symlink(srcpath,dstpath)——创建软链接文件

路径查询

os.path.dirname(path)——返回文件路径（不一定是绝对路径）

os.path.abspath(path)——返回绝对路径

os.path.basename(path)——返回文件名

os.path.realpath(path) ——返回path的真实路径

os.path.getatime(path)——返回最近访问时间（浮点型秒数）

os.path.getmtime(path)——返回最近文件修改时间

os.path.getctime(path)——返回文件 path 创建时间

os.path.getsize(path)——返回文件大小，如果文件不存在就返回错误

路径判断

os.path.exists(path)——判断是否存在

os.path.isabs(path)——判断是否为绝对路径

os.path.isfile(path)——判断路径是否为文件

os.path.isdir(path)——判断路径是否为目录

os.path.islink(path)——判断路径是否为链接

os.path.ismount(path) ——判断路径是否为挂载点

os.path.samefile(path1, path2) ——判断目录或文件是否相同

路径字符串操作

os.path.join(path1[, path2[, …]])——把目录和文件名合成一个路径

os.path.normcase(path)——转换path的大小写和斜杠

os.path.normpath(path)——规范path字符串形式

os.path.relpath(path[, start])——从start开始计算相对路径

os.path.split(path)——把路径分割成
dirname（文件路径）和basename（文件名），返回一个元组

常量属性

os.curdir——当前路径（全部为.）

os.pardir——父路径（全部为…）

os.sep——路径分隔符（unix为/，windows为\\）

os.pathsep——PATH分隔符（unix为:，windows为;）

os.extsep——文件名与扩展名分隔符（全部为.）

os.linesep——文本行尾（unix为LF即\n，windows为CRLF即\r\n）

glob文件搜索工具

glob.glob(‘通配符’)——使用通配符搜索，整个路径path都可使用通配符，只能搜索文件，不能搜索文件夹

glob.glob(’./[0-9].*’) #[’./1.gif’, ‘./2.txt’]

glob.glob(’*.gif’) #[‘1.gif’, ‘card.gif’]

glob.glob(’?.gif’) #[‘1.gif’]

shutil壳工具

shutil.copyfileobj(fsrc, fdst)——复制打开的文件内容

shutil.copyfile(src,dst)——复制文件内容

shutil.copymode(src, dst)——复制文件权限

shutil.copystat(src,
dst)——复制文件的所有元数据（包括权限、用户、创建修改时间）

shutil.copy()——复制文件内容和权限

shutil.copy2(src,
dst)——复制文件内容和所有元数据（包括权限、用户、创建修改时间），是copy()
和copystat() 的组合

shutil.copytree(src,
dst)——递归复制文件夹树，目标文件夹不能已存在，调用时会自动创建

shutil.rmtree(path)——递归删除文件夹树

【shutil.move(src, dst)】——移动单个文件或者递归移动文件夹树；

1.若是文件夹且目标也是文件夹（无论存在还是不存在）则直接移动到目标文件夹内；

2.若是文件且目标是文件夹（无论存在还是不存在）则移动（若存在同名文件则覆盖）；

3.若是文件且目标也是文件（无论是否同名）则不确定（可能覆盖也可能另存为新文件，取决于系统rename命令的语义）；

shutil.disk_usage()——返回磁盘使用情况

shutil.chown()——更改文件所有者

shutil.which()——返回对象所在的文件路径

还有文档压缩解压函数

压缩打包——zlib,gzip,bz2,zipfile,tarfile

gzip——.gz

bz2——.bz2

zipfile——.zip

tarfile——.tar

编程语言——sys,pickle,time

sys语言环境

sys.path——解释器的代码搜索path列表，可通过append()方法添加新路径

reload(sys)
sys.setdefaultencoding(‘utf8’)——python2中指定默认编解码方式，否则需要显式声明编解码的编码方式

time计时与暂停

time.time()——返回秒计时

time.sleep()——暂停程序

time.process_time()——返回系统和CPU计时不包括sleep

【IO与网络】

io, asyncio, socket, socketserver, http, ssl, urllib, webbrowser,
requests, selenium, phantomjs

网络协议

tcp/udp协议

服务端：

s=socket.socket()——建立实例

s.bind(port)——绑定端口

s.listen(port)——监听端口

conn,addr=s.accept()——接受连接请求

conn.recv(1024)——读取客户端发送的1024位以内的数据

s.close()——关闭服务、端口

客户端：

c=socket.socket()——建立实例

conn=c.connect()——请求服务器建立连接

conn.sendall()——可把数据拆分为多段完全发送

http协议

http.client——实现客户端http/https协议

http.server——实现服务端http/https协议

http.cookies——自定义http状态管理机制

http.cookiejar——自动管理cookies

urllib网络请求与简易解析

urllib.request——请求，维护session&cookie&proxy

urllib.request.urlopen()——请求网址

urllib.response——响应处理

urllib.parse——URL解析

requests常用第三方网络包

r =
requests.get(url,timeout=2.5,params={},headers={},cookies={})——GET请求

r =
requests.post(url,timeout=2.5,params={},headers={},cookies={},data={},files={
‘file1’: open(‘report.xls’, ‘rb’)})——POST请求

r.status_code——响应码

r.encoding——返回内容的编码

r.content——返回的二进制内容

r.text——返回的文本内容

selenium+phantomjs浏览器自动网络测试

日志——logging

日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET

logging.debug(‘debug message’) #不显示

logging.info(‘info message’) #不显示

logging.warning(‘warning message’) #显示

logging.error(‘error message’) #显示

logging.critical(‘critical message’) #显示

配置日志：

logging.basicConfig(level=logging.DEBUG, format=’%(asctime)s
%(filename)s[line:%(lineno)d] %(levelname)s %(message)s’,

datefmt=’%a, %d %b %Y %H:%M:%S’, filename=’/tmp/test.log’, filemode=‘w’)

线程进程——threading,multiprocess,queue

加密——hashlib,base64

hash-md5摘要算法

m=hashlib.md5()

m.update(b”nobody inspects”)

m.hexdigest()

base64二进制编码算法

>>> import base64

>>> base64.b64encode(b’binary\x00string’)

b’YmluYXJ5AHN0cmluZw==’

>>> base64.b64decode(b’YmluYXJ5AHN0cmluZw==’)

b’binary\x00string’

数据库——sqlite3,redis,psycopg2

sqlite小型文件数据库

conn=sqlite3.connect(dbfilepath)——连接数据库

conn.cursor()——为本连接建立游标

cursor.execute()——执行SQL语句

cursor.fetchall()——返回执行结果集

conn.commit()——提交前面未提交的SQL操作事务

redis小型内存数据库

redis.connect(host,port,user,pass…)

postgresql关系数据库

mongodb非关系数据库

SQLAlchemy数据对象模型

GUI——tkinter