Python 3

#对于任意可迭代对象可使用序列拆分操作符*进行拆分

#可用iterable对分片进行赋值等操作(相当于del分片并把iterable插入其中,所以二者长度可以不同)

#del取消对象引用与数据项之间的绑定并删除对象引用

数据类型

Integral(包括int bool等)

n.bin(i) #返回'0b'前缀的i的二进制字符串

n.hex(i) #返回'0x'前缀的i的十六进制字符串

n.oct(i) #返回'0o'前缀的i的八进制字符串

n.int(x) #将对象x转换为整数,失败产生ValueError或类型不支持转换产生TypeError,若为浮点截取整数部分

n.int(s, base) #将字符串s转换为base进制数,与xx进制转换为xx进制不同

Float(包括float complex decimal.Decimal等)

#float

f.as_integer_ratio() #返回代表f的整数除法表示的二元组

f.hex() #返回f的十六进制形式字符串

f.fromhex() #将十六进制形式字符串转换为浮点数

f.is_integer() #当f小数部分为0是返回True

#complex(用字母j代表sqrt(-1),有对应cmath模块提供类似math模块的功能)

f.real #获取f的实部

f.imag #获取f的虚部

f.conjugate() #改变f虚部符号

#math模块

math.copysign(x, y) #将x的符号设置为y的符号

#角度弧度转换

math.degrees(r) #将浮点数r从弧度转为角度

math.radians(d) #将d从角度转为弧度

math.factorial(x)

math.hypot(x, y) #计算点(x, y)与原点距离

#数字判断

math.isnan(x)

math.isinf(x)

math.modf(x) #以floatS的形式返回x的小数与整数部分

math.trunc(x) #等同于int(x)

#常量

math.pi

math.e

String

#分片[]操作

#返回首字母大写的s副本

s.title() #其他字母转为小写

s.capitalize()

#返回t在s中的最左位置

s.index(t, start, end) #没找到返回ValueError

s.rindex(t, start, end)

s.find(t, start, end) #没找到返回-1

s.rfind(t, start, end)

#字符判断

s.isalnum()

s.isalpha()

s.isdecimal()

s.isdigit()

s.isidentifier()

s.isnumeric() #s非空且每个字符都是Unicode数值型字符(例如数字或小数)返回True

s.isprintable()

s.isspace()

s.istitle() #s非空且首字母大写返回True

s.isupper()

s.islower()

#替换

s.replace(t, u, n)

#字符串判断

s.startswith(x, start, end)

s.endswith(x, start, end)

#大小写转换

s.lower()

s.upper()

s.swapcase()

s.join(seq)

#去除chars 默认为空格

s.strip(chars)  #去除开头结尾

s.lstrip(chars)  #去除开头

s.rstrip(chars)  #去除结尾

s.count(t, start, end)

#分割

s.split(t, n)

s.rsplit(t, n)

s.splitlines(f)

#按照table翻译

s.translate(table)

s.maketrans(table)

s.encode(encoding, err)

s.format(...)  #神烦的规则.......但是方便...........

组合数据类型

序列类型

#序列拆分 *

Tuple(包含在()中)

#固定对象

#支持+、*、+=、*=、[]操作

#in \ not in 判断成员是否存在元组中

#可使用标准比较操作符(逐项比较)

t.count(x) #x出现次数

t.index(x) #x的index,不存在返回ValueError

#collections模块提供namedtuple()函数用于创建自定义元组数据类型(为每一项命名,操作方法类似于C++枚举类型)

#也可使用私有方法如namedtuple._asdict()返回映射

List(包含在[]中)

#可使用内涵

#插入

l.append(x) #将数据项x追加到l末尾

l.extend(m) #将可迭代对象m的项追加到l末尾

l += m

l.insert(i, x) #在索引i处插入数据项x

#删除

l.pop() #返回并移除l最右边的数据项

l.pop(i) #返回并移除l中索引i处的数据项

l.remove(x) #返回并移除l中最左边的x, 不存在x产生ValueError

l.index(x, start, end) #(l中或l[start:end]中)查找x的索引

l.count(x) #返回数据项x在l中的出现次数

l.reverse()

l.sort(...) #排序, 与内置sorted()函数一样可以接受key(制定函数, 用于每一个数据项, 结果用于比较)可以和reverse参数

#列表内涵

[expression for item in iterable]

[expression for item in iterable if condition]

集合类型

#set  frozenset

Set(包含在{}中)

#可使用内涵

#内置可变的set和不可变的frozenset类型

#只有可哈希运算的对象可以添加到集合中，可哈希运算对象包含__hash__()用于计算和__eq__()用于相等性比较

#所有内置固定类型都是可哈希运算对象(可添加到集合中), 所有内置可变对象都不是可哈希运算对象(不可加入集合中)

#集合中的项是无序的，没有索引的定义，也不支持分片操作

#集合中的项不重复

#加*的方法/操作符可用于frozenset

s.add(x)

s.clear()

s.copy() #返回s的浅拷贝 *

s.isdisjoint(t) #若没有x in s and x in t返回True *

#移除项

s.discard(x) #若x in s则移除x

s.remove(x) #移除x，若x not in s产生KeyError异常

s.pop() #返回并移除s中的一个随机项，若s为空集产生KeyError异常

#集合操作(方法接受任意iterable做参数)

s.difference(t)  (s - t) #返回包含在s中但不在t中的数据项的集合 *

s.difference_update(t)  (s -= t) #移除每个在t中但不在s中的数据项

s.intersection(t)  (s & t) *

s.intersection_update(t)  (s &= t)

s.issubset(t)  (s <= t) *

s.issuperset(t)  (s >= t) *

s.symetric_difference(t)  (s ^ t)  #返回包含x in s 和 x in t 但 not(x in s and x in t) 的集合 *

s.symetric_difference_update(t)  (s ^= t)

s.union(t)  (s | t) *

s.update(t)  (s |= t)

映射类型

#映射拆分 **

#dict  collections.defaultdict  collections.OrderedDict

#键-值数据项组合  只有可哈希运算对象能用作键

#可通过标准比较操作符逐项比较

Dict(包含在{}中)

#无序、可变    不能使用索引和分片操作

#无效键值产生KeyError异常

#空{}代表空字典

#字典内涵

#默认字典 collections.defaultdict

#有序字典 collections.OrderedDict

d.clear()

d.copy()　　#返回d的浅拷贝

d.fromkeys(s, v)　　#返回一个dict，该字典的键为序列s中的项，值为None或v(如果给定了参数v)

d.get(k)　　#若k无效返回None

d.get(k, v)　　#若k无效返回v

d.items()　　#返回d中所有的(key, value)对的视图

d.keys()　　#返回d中所有键的视图

d.values()　　#返回d中所有值的视图

d.pop(k)　　#移除键为k的项并返回该项的值，若k无效产生KeyError异常

d.pop(k, v)　　#若k无效返回v

d.popitem()　　#返回并移除d中一个(key, value)对，如果d为空产生KeyError异常

d.setdefault(k, v)　　#若k已经存在d中，返回对应该项的值；否则插入一个键为k值为None或v(如果给定了参数v)的新项

d.update(a)　　　#用a更新d，a可以是dict，也可以是(key, value)对的一个iterable，或一个关键字参数

#组合类型的迭代

iter(object[, sentinel])

all(iterable)

any(iterable)

len(s)

enumerate(iterable[, start = 0])

max(i, key)

min(i, key)

range(start, stop, step)

reversed(iterable)

sorted(iterable, key, reversed)

sum(iterable, start)

zip()

#组合类型的拷贝

import copy

copy.deepcopy()

控制结构和函数

条件分支if

if boolean_expression1:

　　suite1

elif boolean_expression2:

　　suite2

else:

　　suite3

expression1 if boolean_expression else expression2

循环

while循环

while boolean_expression:

　　suite

else:

　　suite

else分支是可选的，只有在while循环正常执行完才会执行else分支，不正常如break、return、异常等

for循环

for expression in iterable:

　　suite

else:

　　suite

异常处理

try:

　　suite

except exception_group as variable:

　　suite

else:

　　suite

finally:

　　suite

至少包含一个except块，else和finally块是可选的

每个exception_group可以是单独一个异常，也可以是包含在括号内的异常元组，as variable是可选的

try中产生异常后按顺序匹配except块(类型一致或类型与exception_group中某个的子类一致即匹配)

应对except块进行从最具针对性到最通常的排序

没有异常产生执行else

在最后，不管有没有异常产生，finally块总是执行

raise产生异常

raise exceprion(args)

raise exception(args) from original_exception

raise

自定义异常

class exceptionName(baseException): pass

自定义函数

全局函数、局部函数、lambda函数、方法

全局函数、局部函数创建语法：

def functionName(parameters):

　　suite

parameters是可选的，如果有多于一个的参数，用逗号隔开，可对参数指定默认值

使用return语句返回，不带参数或没有return语句则返回None

有默认值的参数应放在所有没有默认值参数的后面

参数默认值陷阱　　(类似于：对于有默认值的参数，每次调用时创建同名参数，如果没有传入则指向默认值，否则指向传入值？？(未知但能解释))

命名规范和Docstrings

参数拆分：序列拆分操作符(*)、映射拆分操作符(*)

"*"作为参数，表明后面不在允许位置参数

对全局变量进行操作时需加上一句global paramenters

lambda函数：

　　lambda parameters: expression

　　parameters 是可选的，参数语法格式可以与def语句相同

　　expression 不能包含分支或循环，但可以有条件表达式，也不能有return或yield

　　lambda表达式结果是一个匿名函数

　　如果expression是一个元组，应该使用圆括号包含起来

断言assert：

　　assert boolean_expression, optional_expression

　　如果boolean_expression为False，则raise AssertionError(optional_expression)

　　使用Python的-O参数或将PYTHONOPTIMIZE设置为O使Python忽略assert(-OO为忽略assert和Docstrings)，也可创建注释掉assert的副本

模块和包

模块是一个 .py 文件，与程序的区别是：程序用于运行，模块用于其他程序导入使用

import importable

import importable1, importable2, ...

import importable as preferred_name

from importable import object

from importable import object as preferred_name

from importable import object1, object2, ...

from importable import (object1, object2, ...)

from importable import *

import语句在shebang行和模块文档之后

.pyo　　最优化的字节码编译版本

.pyc　　非最优化的字节码编译版本

包是一个目录，包含一组模块和一个__init__.py文件

__init__.py中只有一句是必须的： __all__ = [moduleName1, moduleName2, ... ]

面向对象程序设计

自定义类

class className:

　　suite

class className(base_classes):

　　suite

pass语句

方法第一个参数为self，是对对象自身的对象引用，调用时Python自动提供

创建对象时，先创建[__new__()]、再初始化[__init__()]

属性或方法不能在类树中找到产生AttributeError异常

super()调用基类

比较操作符的特殊方法

 #比较操作符的特殊方法
 __lt__(self, other)    x < y
 __le__(self, other)    x <= y
 __eq__(self, other)    x == y
 __ne__(self, other)    x != y
 __ge__(self, other)    x >= y
 __gt__(self, other)    x > y

......

默认情况下自定义类的所有实例都支持==，但总是返回False，可以通过重新实现__eq__()改变这一行为

如果实现了__eq__()但没有实现__ne__()，Python会自动提供__ne__()以及!=

repr()/eval()

修饰器

　　@property、@xxx.setter、@xxx.deleter

基本的特殊方法：

 __bool__(self)    bool(x)
 __format__(self, format_spac)    "{0}".format(x)
 __hash__(self)    hash(x)
 __init__(self, args)    x = X(args)
 __new__(cls, args)    x = X(args)
 __repr__(self)    repr(x)/ascii(x)
 __str__(self)    str(x)

......

数值型与位逻辑的特殊方法：

 __abs__(self)    abs(x)
 __complex__(self)    complex(x)
 __float__(self)    float(x)
 __int__(self)    int(x)
 __index__(self)    bin(x)/oct(x)/hex(x)
 __round__(self, digits)    round(x, digits)
 __pos__(self)    +x
 __neg__(self)    -x
 __add__(self, other)    x + y
 __iadd__(self, other)    x += y
 __radd__(self, other)    y + x
 __sub__(self, other)    x - y
 __isub__(self, other)    x -= y
 __rsub__(self, other)    y - x
 __mul__(self, other)    x * y
 __imul__(self, other)    x *= y
 __rmul__(self, other)    y * x
 __mod__(self, other)    x % y
 __imod__(self, other)    x %= y
 __rmod__(self, other)    y % x
 __floordiv__(self, other)    x // y
 __ifloordiv__(self, other)    x //= y
 __rfloordiv__(self, other)    y // x
 __truediv__(self, other)    x / y
 __itruediv__(self, other)    x /= y
 __rtruediv__(self, other)    y / x
 __divmod__(self, other)    divmod(x, y)
 __rdivmod__(self, other)    divmod(y, x)
 __pow__(self, other)    x ** y
 __ipow__(self, other)    x **= y
 __rpow__(self, other)    y ** x
 __and__(self, other)    x & y
 __iand__(self, other)    x &= y
 __rand__(self, other)    y & x
 __xor__(self, other)    x ^ y
 __ixor__(self, other)    x ^= y
 __rxor__(self, other)    y ^ x
 __or__(self, other)    x | y
 __ior__(self, other)    x |= y
 __ror__(self, other)    y | x
 __lshift__(self, other)    x << y
 __ilshift__(self, other)    x <<= y
 __rlshift__(self, other)    y << x
 __rshift__(self, other)    x >> y
 __irshift__(self, other)    x >>= y
 __rrshift__(self, other)    y >> x
 __invert__(self)    ~x

......

组合类型的特殊方法：

 __contain__(self, x)    x in y
 __delitem__(self, k)    del y[k]
 __getitem__(self, k)    y[k]
 __iter__(self)    for x in y: pass
 __len__(self)    len(y)
 __reversed__(self)    reversed(y)
 __setitem__(self, k, v)    y[k] = v

......

文件处理

二进制格式通常占用空间最小， 保存和加载速度最快，最简单是使用pickles

pickle(序列化)，不安全(没有加密，没有数字签名)

pickle.dump()/pickle.load()　　格式Protocol，pickle.dump()需在第三个参数指定格式，pickle.load()能自行推断出格式

pickle.PicklingError/pickle.UnpicklingError

pickle.HIGHEST_PROTOCOL/protocol 3　　Python3特有的一种紧凑的二进制pickle格式

布尔型、数值型、字符串、任意内置组合类型、私有的__dict__是picklable的类实例都可以pickled

如果要求进行压缩，可以使用gzip模块的gzip.open()函数打开，否则使用内置open()函数即可，打开模式应为'rb'/'wb'

使用gzip压缩的文件都以一个特定的魔数引导　　GZIP_MAGIC = b'\x1F\x8B'

bytes与bytearray数据类型：

 用于处理原始字节
 bytes是固定的数据类型，bytearray是可变的数据类型
 用于存放0个到多个8位无符号整数(字节)(0 - 255)
 使用分片返回的是同样类型的对象
 使用项存取操作符[]存取单独字节时返回的是该字节所代表的值
 方法：
 ba.append(i)    将整数i(0 - 255)附加到bytearray ba中
 b.capitalize()    返回bytes/bytearray的副本，若第一个字符是ASCII变为大写
 b.center(width, byte)    返回b的副本，b在长度为width区域中间，其他用空格或byte填充
 b.count(x, start, end)    返回x在b或b[start:end]中的出现次数
 b.decode(encoding, error)    返回str对象，代表使用encoding或UTF-8编码表示的字节
 b.endswith(x, start, end)    判断b或b[start:end]是否以x或元组x中任一项结尾，对应有startswith()
 b.expandtabs(size)    返回b的副本，将其中制表符用空格(个数为size或8的倍数)代替
 ba.extend(seq)    使用序列seq中所有ints对ba进行拓展，ints必须在0 - 255之间
 b.find(x, start, end)    返回x在b或b[start:end]中最左边的位置，没找到返回-1，对应有rfind()
 b.fromhex(h)    返回一个bytes对象，其字节对应是字符串h中的十六进制整数
 b.index(x, start, end)    返回x在b或b[start:end]中最左边的位置，没找到产生ValueError，对应有rindex()
 ba.insert(p, i)    将整数i(0 - 255)插入到ba中的p位置
 b.isalnum()    若b非空，且每个字符都是ASCII字母数字字符，返回True
 b.isalpha()    若b非空，且每个字符都是ASCII字母字符，返回True
 b.isdigit()    若b非空，且每个字符都是ASCII数字，返回True
 b.islower()    若b包含至少一个可小写ASCII字符且都是小写，返回True
 b.isspace()    若b非空，且都是ASCII空格字符,，返回True
 b.istitle()    若b非空且首字母大写，返回True
 b.isupper()    若b包含至少一个可大写ASCII字符且都是大写，返回True
 b.join(seq)    返回序列seq中每项用b连接后所得结果
 b.ljust(width, byte)    返回b的左对齐副本，宽度为width，使用空格或byte进行填充剩余位置，对应有rjust()
 b.lower()    返回b的副本，其中的ASCII字符都变成小写
 b.upper()    返回b的副本，其中的ASCII字符都变成大写
 b.partition(seq)    用seq在最左边分割b后返回一个三个bytes对象的元组，对应有rpartition()
 ba.pop(p)    移除并返回ba中索引位置p处的整数
 ba.remove(i)    从ba中移除整数i的首次出现
 b.replace(x, y, n)    返回一个副本，将所有(或最多n个)x替换成y
 ba.reverse()    反转ba的字节
 b.split(x, n)    返回字节列表，在x或空字符处进行分割(或分割n次)，对应有rsplit()
 b.splitlines(f)    返回对b行终结符处分割后产生的行列表，若f为False，剥离行终结符
 s.strip(x)    返回b的副本，剥离开始和结尾处的x或空字符，lstrip()只剥离开始处，rstrip()只剥离结尾处
 b.swapcse()    返回b的副本，大小写倒置
 b.title()    返回b的副本，将每个字第一个ASCII字符变大写，其余变小写
 b.translate(bt, d)    返回b的副本，不包括d的字节，且每个字节都被bt相应字节替换
 b.zfill(w)    返回b的副本，如果长度小于w就用引导字符(0x30)填充

......

看不下去了.....跳过先......259

高级程序设计技术

使用字典和函数引用进行分支

生成器表达式

动态执行代码 eval()\exec()

动态导入模块

动态程序设计与内省函数：

 __import__(...)    #根据模块名导入模块
 compile(source, file, mode)    #返回编译source文本生成的代码对象，file为文件名||"<string>"，mode为"sigli"||"eval"||"exec"
 delattr(obj, name)    #从obj中删除名为name的属性
 dir(obj)    #返回本地或obj的名称列表
 eval(source, globals, locals)    #返回对source中单一表达式的评估结果，globals:全局上下文 locals:本地上下文
 exec(obj, globals, locals)    #对obj(字符串||来自compile()的对象)进行评估，globals:全局上下文 locals:本地上下文
 getattr(obj, name, val)    #返回obj中名为name的属性，若不存在且给定了val则返回val
 globals()    #返回当前全局上下文的字典
 locals()    #返回当前本地上下文的字典
 hasattr(obj, name)    #如果obj中有name属性则为True
 setattr(obj, name, val)    #将obj中name属性的值设为val，必要时创建属性
 type(obj)    #返回obj的类型对象
 vars(obj)    #以字典形式返回本地字典或obj的上下文

 动态程序设计与内省函数

......

局部函数和递归函数

函数与方法修饰器

　　预定义修饰器@property @classmethod @staticmethod

　　@functools.wraps(function)

　　带参修饰器

函数注释

　　def functionName(par1: exp1, par2: exp2, ..., parN: expN) -> rexp:

　　　　suit

类的__slots__属性，其值为一个属性名元组，使用了__slots__的类实例不存在__dict__，因此不能通过对象添加属性，但可以通过类添加属性(read-only)

用于属性存取的特殊方法:

 __delattr__(self, name)    del x.n
 __dir__(self)    dir(x)
 __getattr__(self, name)    v = x.n    #最后调用, 会在没有查找到相应实例属性时被调用
 __getattribute__(self, name)    v = x.n  #最先调用
 __setattr__(self, name, value)    x.n = v

......