本篇索引
（1）常用内置数据类型
（2）类型检查常用方法
（3）常用内置函数
（4）程序结构的数据类型
（1）常用内置数据类型
| 分类 | 类型名称 | 描述 |
|---|---|---|
| 数字 | int | 整数 |
| float | 浮点数 | |
| complex | 复数 | |
| bool | 布尔值 | |
| 序列 | str | 字符串（不可变序列） |
| list | 列表 | |
| tuple | 元组（不可变序列） | |
| range | 整数范围（不可变序列） | |
| bytes | 字节数组（不可变序列） | |
| bytearray | 可变字节数组 | |
| 映射 | dict | 字典 |
| 集合 | set | 可变集合 |
| frozenset | 不可变集合 | |
| None | NoneType | 空对象，它没有任何属性 |
（2）类型检查常用方法
| 用法 | 类型 | 描述 | 举例 |
|---|---|---|---|
| id(实例) | 内置函数 | 返回一个对象的身份（整数） |
id(a) |
| type(实例) | 内置函数 | 返回一个对象实例的类型 | type(a) |
| is | 运算符 | 比较2个对象是否同一身份 |
a is b type(a) is str type(a) is type(b) # a与b是否同一类型 |
| isinstance(实例, 类名) | 内置函数 | 入参对象是否是入参类的实例 |
isinstance(s, list) # s是否为列表 isinstance(f, Foo) # f是否为Foo类的实例 |
（3）常用内置函数
| 名称 | 简述 | 用法 | 举例或说明 |
|---|---|---|---|
| 数学运算 | |||
| abs() | 返回一个数的绝对值 | abs(x) | abs(a) |
| pow() | x的y次方运算，将结果对z取模 | pow(x, y[,z]) |
pow(2,3,3) # 结果为2 |
| round() | 将x按10的负n次取四舍五入 | round(x[, n=0]) | 舍入规则见下详述 |
| divmod() | 将a除以b的商和余数作为元组返回 | divmod(a, b) |
divmod(10,3) # 结果为(3,1) |
| 内置数据类型实例生成 | |||
| int() | 根据入参数字或字符串，生成整数实例 | int(x[, base=10]) | base默认为10， 详见下例 |
| float() | 根据入参数字或字符串，生成浮点数实例 | float(x) |
float(3) # 结果为3.0 |
| complex() | 生成复数实例 | complex(r[, i]) | 较少用到 |
| bool() | 生成布尔值实例 | bool([x]) | 不带入参时默认返回False |
| list() | 生成列表实例 | list([iter]) | iter须是可迭代对象 |
| dict() | 生成字典实例 | dict([m]) | 详见下述 |
| tuple() | 生成元组实例 | tuple([iter]) | iter须是可迭代对象 |
| str() | 生成字符串实例 | str([object]) | 入参object的__str__方法 |
| range() | 创建range实例 |
range(stop) range(start, stop [,step]) |
range对象可以用迭代、也可用切片访问 |
| set() | 生成集合实例 | set([iter]) | iter须是可迭代对象 |
| frozenset() | 生成不可变集合实例 | frozenset([iter]) | iter须是可迭代对象 |
| slice() | 生成切片对象 |
slice(stop) slice(start, stop [,step]) |
较少直接使用 |
| bytes() | 生成不可变字节数组实例 | bytes([source [,encoding [,errors]]]) | 详见下述 |
| bytearray() | 生成可变字节数组实例 | bytearray([source [,encoding [,errors]]]) | 用法同上，内容可变 |
| memoryview() | 生成memoryview实例 | memoryview(obj) | 较少用到 |
| object() | 生成一个基类实例 | object() | 较少用到 |
| 编码与解码 | |||
| hex() | 将数值x用16进制字符串表示 | hex(x) |
hex(16) # 结果为'0x10' |
| oct() | 将数值x用8进制字符串表示 | oct(x) |
oct(16) # 结果为'0o20' |
| bin() | 将数值x用2进制字符串表示 | bin(x) |
bin(8) # 结果为'0b1000' |
| ord() | 将单字符转换成utf-8数值 | ord(c) |
ord('a') # 结果为97 ord('数') # 结果为25968 |
| chr() | 将数值x转换成单字符字符串 | chr(x) |
chr(97) # 结果为'a' chr(25968) # 结果为'数' |
| ascii() | 像repr()那样显示对象，非ASCII字符显示为转义序列 | ascii(object) | 较少用到 |
| 序列操作 | |||
| len() | 返回s中包含的项数 | len(s) | s可以是：列表、元组、字符串、集合、字典 |
| min() | 如果只有1个参数s，返回s中各项的最小值。如果有多个参数，返回各个参数中的最小值。 | min(s[, args, ...]) |
s可以是可迭代对象 min([1,3,5]) # 结果为1 min(1,3,5,7) # 结果为1 |
| max() | 如果只有1个参数s，返回s中各项的最大值。如果有多个参数，返回各个参数中的最大值。 | max(s[, args, ...]) |
s可以是可迭代对象 min([1,3,5]) # 结果为5 min(1,3,5,7) # 结果为7 |
| sum() | 计算可迭代对象iter中所有项的和，initial为累加初始值，默认为0。只能用于数值计算。 | sum(iter[ ,initial]) |
sum([1,2,3]) # 结果为6 sum([1,2,3], 10) # 结果为16 |
| 迭代操作 | |||
| all() | 若可迭代对象iterable中的所有值都为True，则返回True。 | all(iter) |
all([0,1,2,3]) # 结果为False |
| any() | 若可迭代对象iterable中的任意值为True，则返回True。 | any(iter) |
any([0,1,2,3]) # 结果为True |
| enumerate() | 根据入参迭代器，产生一个新迭代器，其中每个元素为一个元组：内含一个计数值和原迭代出的值。 | enumerate(iter[ ,start=0]) |
for i,x in enumerate(['a','b']) pass # 结果迭代出(0,'a'), (1,'b') |
| zip() | 产生一个新迭代器，第n个元素为一个(s1[n], s2[n], ...)的元组，其长度为最短的一个迭代器长度。 | zip([s1 [, s2 [, ...]]]) |
a = [1,2,3] b = ['x','y'] for t in zip(a, b) pass # 迭代结果为(1,'x'), (2,'y') |
| sorted() | 根据入参迭代器的内容排序，创建有序列表 | sorted(iter, *, key=None, reverse=False) | 详见下述 |
| reversed() | 产生一个迭代器，将入参序列的所有元素位置颠倒（注意：跟sorted()完全不同） | reversed(seq) |
for x in reversed([1,2,'a']): pass # 迭代结果为 'a', 2, 1 |
| filter() | 产生一个迭代器，其内容是对入参iter中的每个元素使用func函数进行过滤，只有func返回True的才被加入新迭代器。 | filter(func, iter) |
a = [1,2,3,4,5,6,7,8] filter(lambda x:x%2==1, a) # 迭代器中内容为 1,3,5,7 |
| map() | 产生一个迭代器，其每一项是将函数func应用到iter中的每一项返回的结果。若入参有多个iter迭代器，则相应的函数func应有多个入参。 | map(func, iter, ...) |
map(lambda x:x*2, [1,3,5,7]) # 迭代器中内容为 2,6,10,14 |
| iter() | 返回一个可生成object中各项的迭代器。 | iter(object[ ,sentinel]) |
较少直接使用 |
| next() | 返回迭代器iter中的下一项。 | next(iter[ ,default]) |
较少直接使用 |
| 对象实例操作 | |||
| id() | 返回object的唯一整数标识符（这是一个内存位置）。 | id(object) |
结果为一个整数，较少直接使用 |
| type() | 当单参数调用时，返回入参object的类型。当三参数调用时，创建一个新type对象（一般用于元类）。 |
type(object) type(name, bases, dict) |
type(1) # 结果为<class 'int'> type('a') # 结果为<class 'str'> |
| isinstance() | 如果object是clsinfo类的一个实例，则返回True。clsinfo可以是一个含多个类的元组。 | isinstance(object, clsinfo) |
# 设有一个名为Foo的自定义类 f = Foo() isinstance(f, Foo) # True isinstance(f, (Foo,list)) # True isinstance([1,2], (Foo,list)) # True isinstance(f, (list,tuple) # False |
| repr() | 返回object的字符串表示形式。 | repr(object) | 一般在类内部的__repr__()方法会定义本对象的字符串表示形式。 |
| dir() | 返回object对象的属性名（含方法名）列表，若object是一个模块，则返回其内部定义的符号列表。 | dir(object) | 如果类内部定义了__dir__属性，则返回此值。 |
| hasattr() | 若name是object的属性名，则返回True | hasattr(object, name) |
入参name是一个字符串 |
| getattr() | 返回对象的name属性的值，若无此属性，则default是可选的返回值，否则引起AttributeError。 | getattr(object, name [,default]) |
a = getattr(obj, 'p1') # 效果同 a = obj.p1 |
| setattr() | 设置对象的属性 | setattr(object, name, value) |
setattr(obj, 'p1', a) # 效果同 obj.p1 = a |
| delattr() | 删除对象的属性 | delattr(object, name) |
delattr(obj, 'p1') # 效果同 del obj.p1 |
| hash() | 返回对象的整数散列值。一般可变对象不会定义散列值，除非类内部定义了__hash__()方法。 | hash() |
hash('abc') # 结果为526986374 hash(3.14) # 结果为1846836513 |
| callable() | 检查一个对象是否是可调用的。但有时即便返回 True，object 仍然可能调用失败。 | callable(object) | 对于函数、方法、lamdba表达式、类、实现了__call__()方法的类实例，它都返回True。 |
| 类操作 | |||
| staticmethod() | 创建在类中使用的静态方法。 | staticmethod(func) | 一般通过@staticmethod装饰器隐式调用该函数 |
| classmethod() | 创建在类方法。 | classmethod(func) | 一般通过@classmethod装饰器隐式调用该函数 |
| issubclass() | 如果class是clsinfo的子类，或class是基于抽象基类clsinfo注册的，则返回True。clsinfo可以是一个含多个类的元组。 | issubclass(class, clsinfo) |
issubclass(Foo, BaseFoo) # 结果为 True issubclass(Foo, (BaseFoo,list) # 结果为 True |
| super() |
返回一个代理对象，提供可以调用基类中的方法的手段。type是当前子类名，object一般是self。 在Python3中，在子类方法中可以省略type和object参数，直接简写成：super() |
super(type [,object]) |
class B(A): def foo(self): # 调用基类A的foo方法 super(B,self).foo() # 在Python3中可简写成： # super().foo() |
| property() | 创建一个虚拟属性。fget, fset, fdel分别为自定义的属性读取、设置、删除方法，doc为文档字符串。 | property(fget=None, fset=None, fdel=None, doc=None) |
class C: def __init__(self): self._x = 'c' def gx(self): return self._x x=property(fget=gx, doc='a') # 定义了一个只读的属性x |
| 域操作 | |||
| globals() | 返回代表当前全局作用域的所有符号的字典。 | globals() |
globals() |
| locals() | 返回代表当前局部作用域的所有符号的字典。 | locals() |
locals() |
| vars() | 返回object的所有属性和属性值的字典对象，如果没有入参，则相当于调用locals() | vars([object]) |
vars(obj) |
| 输入输出与文件操作 | |||
| input() | 显示prompt提示信息，并读取一行输入，将读入内容不作任何修改作为字符串返回。（Python3中取消了原raw_input()函数） | input([prompt]) |
>>> input('pls ipt:') pls ipt:123 # 返回结果为：'123' |
| print() | 打印一系列值到屏幕上。入参中可设置：多个显示对象之间的分隔符、换行符、输出设备、强制刷新等，一般不用修改。 | print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False) |
一般用于调试用 |
| open() | 打开文件并返回一个新文件对象。 | open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None) |
在文件操作章节详细描述 |
| 杂项 | |||
| eval() | 计算入参表达式的值并返回结果。expr是一个字符串或代码对象。globals和locals参数可指定操作时的全局和局部命名空间映射对象。 | eval(expr, globals=None, locals=None) |
x = 1 y = eval('x+1') # 结果为2 |
| exec() | 执行Python语句，入参code可以是字符串、文件或代码对象。globals和locals参数可指定操作时的全局和局部命名空间映射对象。 | exec(code[, globals[, locals]]) |
x = 1 code = """s = x + 1 print(s)""" exec(code) # 结果为2 exec(code, {'x':10}) # 结果为11 |
| format() | 按照format_spec中的格式将value转换为有格式的字符串，该操作调用value.__format__()方法。 | format(value[, format_spec]) |
一般在格式化字符串时被隐式调用 |
| help() | 调用内置的帮助系统。object可以是字符串（表示模块名、类名、函数名、方法名、关键字、文档主题名称），如果是其他类型的对象，则会出现与该对象有关的帮助界面。 | help([object]) |
help('math') |
| compile() | 将source对象编译为代码对象，结果可被用于eval()和exec()函数。 | compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1) |
若不是开发框架的话，一般用不到 |
| breakpoint() | Python3.7中新增的内置函数，用来设置程序运行时的断点，程序运行到该函数时自动进入调试器。这是个方便函数，可以让你很方便地进入Pdb调试器（不用再显式导入调试模块等）。 | breakpoint(*args, **kwargs) | 在需要设置断点的地方直接调用breakpoint()即可 |
● round(x[, n])
说明：
在Python3中，当被舍入数字为5且为第1位小数时，舍入规则如下：若被舍入数字的前一个数为偶数，则朝0方向进行四舍五入；否则远离0，正负数都遵循这个规则。其它位的四舍五入不适用此规则，依旧按照普通数学规则进行。
举例：
>>> round(2.5) # 结果为2
>>> round(-2.5) # 结果为2
>>> round(3.5) # 结果为4
>>> round(-3.5) # 结果为4
● int(x[, base])
说明：
x可以是数字或字符串，base是入参的转换进制基数，可以是2、8、16、16等，转换结果总是10进制整数。
举例：
>>> int('100') # 结果为100
>>> int('100', 10) # 结果为100
>>> int('100', 16) # 结果为256
>>> int('100', 2) # 结果为4
● dict([m])
说明：
入参m若是字典，则dict(m)就创建一个m浅复制。若m不是字典，则必须能够产生(key, value)形式的迭代值。也可用关键字创建字典，见下例。
举例：
>>> dict('a'=1, 'b'=2) # 结果为{'a':1, 'b':2}
>>> dict() # 结果为空字典{}
● bytes([source [,encoding [,errors]]])
说明：
生成不变字节数组，入参source为原始输入字符串，入参encoding指定要使用的字符编码方式。
举例：
>>> x = bytes() # 结果为空字节数组 b''
>>> x = b'' # 结果同上
>>> x = bytes('abc') # 结果为 b'abc'
>>> x = bytes('ab数字', 'utf-8') # 结果为 b'ab\xe6\x95\xb0\xe5\xad\x97'
● sorted(iter, *, key=None, reverse=False)
说明：
根据iter迭代器中的各项值的内容进行排序（从小到大），创建有序列表，一般只能对数字或字符串进行排序。key是个单参数函数，可以对元素在被排序前进行预处理，将一些常规来说不能排序的元素预处理成可排序的数字或字符串。reverse是个标志位，用以指出是否逆序（从大到小）排序。（注意：Python3最新版本中已废除了cmp参数）
举例：
>>> sorted([1,7,3,5]) # 结果为[1,3,5,7]
>>> sorted([1,7,3,5], reverse=True) # 结果为[7,5,3,1]
>>> sorted(['c','b','a']) # 结果为['a','b','c']
>>> sorted([('b',2),('a',1)], key=lambda x:x[1]) # 结果为[('a',1),('b',2)]
>>> # 上例说明：入参列表中的元素为元组，一般不能排序。但这里用lambda生成了一个匿名函数，对元素进行预处理，取出每个元素元组中的数字，然后用这个数字作为排序依据，给sorted()函数进行排序
● 旧版raw_input()用法
说明：
在Python3中的input()函数相当于Python2中的raw_input()函数。而在Python2中的input()函数中，用户在输入字符串内容时必须带上引号，否则会报错（非字符串类型则不需要引号）。所以在Python2中，一般尽量使用raw_input()函数。
举例：
x = input('x:') # 用户必须输入带引号的字符串：'abc'，否则会报错
x = raw_input('x:') # 用户可以直接输入：abc，系统会自动将其转换为字符串
● eval(expr, globals=None, locals=None)
说明：
eval()计算字符串形式的表达式或代码对象expr，并返回计算结果。其中globals和locals参数可指定操作时的全局和局部命名空间，如果省略，就使用当前实际的全局和局部命名空间中的值。
举例：
# 例1：
x = eval(input('Enter an expression:')) # 用户若输入：1+2*3，返回值为7 # 例2：
scope = {'x':2, 'y':3}
eval('x+y', scope) # 相当于在scope命名空间中运行eval()，结果为5
● exec(code[, globals[, locals]])
说明：
exec在Python2中是一个语句，exec()在Python3中是内置函数，exec()最有用的地方在于可以动态地创建代码字符串。其中globals和locals参数可指定操作时的全局和局部命名空间，如果省略，就使用当前实际的全局和局部命名空间中的值。
由于每次执行exec()或eval()时，Python都要编译一次入参字符串，这个比较耗资源。如果某个代码字符串要反复执行多次，最好是先编译代码，然后在后续的调用中使用编译过的code对象。详见后面的例子。
举例：
# 例1：
x = 1
scope = {}
exec('x=2', scope) # 在命名空间scope中运行赋值语句，所以x仅在scope范围为2，在实际的全局空间中仍为1 # 例2：
s = 'for i in range(100): print(i)'
code = compile(s, '', 'exec') # 将要执行的字符串代码先进行编译
exec(code) # 执行刚才已编译过的代码
● future_builtins
在Python2中，如果使用 future_builtins 模块，可以使用以下内置函数：
| 函数 | 说明 |
|---|---|
| ascii(object) | 产生的输出与 repr() 相同。 |
| hex(object) | 创建十六进制字符串，但使用__index__()特殊方法来得到整数值， 而不是调用__hex__() |
| otc(object) | 创建八进制字符串，但使用__index__()特殊方法来得到整数值， 而不是调用__oct__() |
| filter(function, iterable) | 创建迭代器而不是列表，等同于 itertools.ifilter()。 |
| map(function, iterable, ...) | 创建迭代器而不是列表，等同于itertools.imap()。 |
| zip(iter1, iter2, ...) | 创建迭代器而不是列表，等同于itertools.izip()。 |
（4）程序结构的数据类型
在Python中，函数、类、方法、模块等等都可以当作数据操作的对象，下表为表示程序本身各种元素的类型。
| 分类 | 类型名称 | 描述 |
|---|---|---|
| 可调用 | types.BuiltinFunctionType | 内置函数或方法 |
| types.FunctionType | 用于定义的函数（包括lambda匿名函数） | |
| types.MethodType | 类中定义的方法 | |
| type | 因为类本身也是可以被调用的，所以这里也列一下。 | |
| object | 因为类本身也是可以被调用的，所以这里也列一下。 | |
| 模块 | types.ModuleType | 模块 |
| 类型 | type | 内置数据类型和类的类型 |
| 根类 | object | 所有类型和类的祖先 |