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()调用基类

比较操作符的特殊方法

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

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

repr()/eval()

修饰器

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

基本的特殊方法：

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

组合类型的特殊方法：

文件处理

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

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

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

pickle.PicklingError/pickle.UnpicklingError

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

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

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

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

bytes与bytearray数据类型：

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

高级程序设计技术

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

生成器表达式

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

动态导入模块

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

局部函数和递归函数

函数与方法修饰器

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

@functools.wraps(function)

带参修饰器

函数注释

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

suit

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

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