python内置函数万字详解

python内置函数万字详解

内置函数

Python解释器内置了很多函数和类型，可以在任何时候使用它们。以下按照字母表顺序列出它们。

abs(x)

返回一个数的绝对值。参数可以是整数、浮点数或任何实现了__abs__()的对象。如果参数是一个复数，则返回它的模。

all(iterable)

如果iterable的所有元素均为真值(或可迭代对象为空),则返回True,等价于:
def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

any(iterable)

如果iterable的任一元素为真值则返回True。如果可迭代对象为空，则返回False。等价与:
def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

ascii(object)

就像函数repr(),返回一个对象可打印的字符串，但还repr()返回的字符串找那个非ASCII编码的字符，会使用\x、\u和\U来转义。生成的字符串 和python2的repr()返回的结果相似

bin(x)

将一个整数转变为一个前缀为"0b"的二进制字符串。结果是一个合法的python表达式。如果x不是python的int对象，那它需要定义__index__()方法返回一个整数，一些例子：
>>> bin(3)
'ob11'
>>> bin(-10)
'-0b1010'
如果不一定需要前缀"ob"，还可以使用一下方法：
>>> format(14,"#b"),format(14,"b")
("ob1110","1110")
>>> f'{14:#b}',f'{14:b}'
("ob1110","1110")

class boll([x])

返回一个布尔值，True或者False.x使用标准的真值测试过程来转换。如果x是假的或者被省略，返回False;其他情况返回True.bool类是int的子类。其他类不能继承自它。它只有False和True两个实例

breakpoint(*args,**kws)

此函数会在调用是将你陷入调试器中。具体来说，它调用sys.breakpointhook()，直接传递args和kws。默认情况下，sys.breakpointhook()调用pdb.set_trace()且没有参数。在这种情况下，它纯粹是一个便利函数，因此您不必显示导入pdb且键入尽可能少的代码即可进入调试器。但是，sys.breakpointhook()可以设置为其他一写函数并被breakpoint()自动调用，以允许进入你想调用的调试器。
引发一个审计事件builtins.breakpoint并附带参数breakpointhook。

class bytearry([source[,encoding[,errors]]])

返回一个新的bytes数组。bytearry类是一个可变序列，包含范围为0<=x<256的整数。它有可变序列大部分常见的用法，同时有butes类型的大部分方法；
可选形参source可以用不同的方式来初始化数组：
	• 如果是一个string，您必须提供encoding参数(errors参数是可选的)；bytearray()会使用str.encode()方法来将string转变为bytes。
    • 如果是一个intteger，会初始化大小为该数字的数组，并使用 null 字节填充。
	• 如果是一个遵循 缓冲区接口的对象，该对象的只读缓冲区将被用来初始化字节数组。
	• 如果是一个 iterable 可迭代对象，它的元素的范围必须是 0 <= x < 256 的整数，它会被用
作数组的初始内容。
如果没有实参，则创建大小为 0 的数组。

class bytes([source[, encoding[, errors]]])

返回一个新的“bytes”对象，是一个不可变序列，包含范围为 0 <= x < 256 的整数。bytes
是bytearray 的不可变版本 - 它有其中不改变序列的方法和相同的索引、切片操作。
因此，构造函数的实参和bytearray() 相同。

callable(object)

如果参数object是可调用的就返回True，否则返回False.如果返回True，调用仍可能失败，但如果你返回False，则调用object将肯定不会成功。请注意类是可调用的的（调用类将返回一个新的实例）；如果实例所属的类有 __call__() 则它就是可调用的。

chr(i)

返回 Unicode 码位为整数 i 的字符的字符串格式。例如，chr(97) 返回字符串 'a'，chr(8364)
返回字符串 '€'。这是ord() 的逆函数。
实参的合法范围是 0 到 1,114,111（16 进制表示是 0x10FFFF）。如果 i 超过这个范围，会触
发ValueError 异常。

@classmethod

把一个方法封装成类方法。
一个类方法把类自己作为第一个实参，就像一个实例方法把实例自己作为第一个实参。请用以下方式来声明类方法:
class C:
    @classmethod
    def f(cls,arg1,arg2,...):
        ...

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

将 source 编译成代码或 AST 对象。代码对象可以被exec() 或eval() 执行。source 可以是常规的
字符串、字节字符串，或者 AST 对象。参见ast 模块的文档了解如何使用 AST 对象。
filename 实参需要是代码读取的文件名；如果代码不需要从文件中读取，可以传入一些可辨识的值
（经常会使用 '<string>'）。
mode 实参指定了编译代码必须用的模式。如果 source 是语句序列，可以是 'exec'；如果是单一表
达式，可以是 'eval'；如果是单个交互式语句，可以是 'single'。（在最后一种情况下，如果
表达式执行结果不是 None 将会被打印出来。）
optimize 实参指定编译器的优化级别；默认值 -1 选择与解释器的 -O 选项相同的优化级别。显式级
别为 0 （没有优化；__debug__ 为真）、1 （断言被删除，__debug__ 为假）或 2 （文档字符串
也被删除）。
如果编译的源码不合法，此函数会触发SyntaxError 异常；如果源码包含 null 字节，则会触
发ValueError 异常。

class complex([real[, imag ]])

返回值为 real + imag*1j 的复数，或将字符串或数字转换为复数。如果第一个形参是字符串，则它被
解释为一个复数，并且函数调用时必须没有第二个形参。第二个形参不能是字符串。每个实参都可
以是任意的数值类型（包括复数）。如果省略了 imag，则默认值为零，构造函数会像int 和float
一样进行数值转换。如果两个实参都省略，则返回 0j。
对于一个普通 Python 对象 x，complex(x) 会委托给 x.__complex__()。如果 __complex__()
未定义则将回退至 __float__()。如果 __float__() 未定义则将回退至 __index__()。
注意：当从字符串转换时，字符串在 + 或 - 的周围必须不能有空格。例如 complex('1+2j') 是
合法的，但 complex('1 + 2j') 会触发ValueError 异常。

delattr(object, name)

setattr() 相关的函数。实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许，该函数将删除指定的属性。例如 delattr(x, 'foobar') 等价于 del x.foobar 。

class dict(**kwarg)

class dict(mapping,**kwarg)

class dict(iterable,**kwarg)

创建一个新的字典。dict 对象是一个字典类。

dir([object])

如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属
性列表。
如果对象有一个名为 __dir__() 的方法，那么该方法将被调用，并且必须返回一个属性列表。这
允许实现自定义 __getattr__() 或 __getattribute__() 函数的对象能够自定义dir() 来报
告它们的属性。
如果对象不提供 __dir__()，这个函数会尝试从对象已定义的__dict__ 属性和类型对象收集信
息。结果列表并不总是完整的，如果对象有自定义 __getattr__()，那结果可能不准确。
默认的dir() 机制对不同类型的对象行为不同，它会试图返回最相关而不是最全的信息：
    • 如果对象是模块对象，则列表包含模块的属性名称。
    • 如果对象是类型或类对象，则列表包含它们的属性名称，并且递归查找所有基类的属性。
    • 否则，列表包含对象的属性名称，它的类属性名称，并且递归查找它的类的所有基类的属性。
返回的列表按字母表排序。例如：
>>> import struct
>>> dir() # show the names in the module namespace
['__builtins__', '__name__', 'struct']
>>> dir(struct) # show the names in the struct module
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
'__initializing__', '__loader__', '__name__', '__package__',
'_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
'unpack', 'unpack_from']
>>> class Shape:
... def __dir__(self):
... return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

注解：因为dir() 主要是为了便于在交互式时使用，所以它会试图返回人们感兴趣的名字集合，
而不是试图保证结果的严格性或一致性，它具体的行为也可能在不同版本之间改变。例如，当实参
是一个类时，metaclass 的属性不包含在结果列表中。

divmod(a,b)

它将两个（非复数）数字作为实参，并在执行整数除法时返回一对商和余数。对于混合操作数类型，适用双目算术运算符的规则。对于整数，结果和 (a // b, a % b) 一致。对于浮点数，结果是(q, a % b) ，q 通常是 math.floor(a / b) 但可能会比 1 小。在任何情况下，q * b + a % b 和 a 基本相等；如果 a % b 非零，它的符号和 b 一样，并且 0 <= abs(a % b) < abs(b) 。

enumerate(iterable,start=0)

返回一个枚举对象。iterable 必须是一个序列，或iterator，或其他支持迭代的对象。enumerate()返回的迭代器的__next__() 方法返回一个元组，里面包含一个计数值（从 start 开始，默认为 0）
和通过迭代 iterable 获得的值。
>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
等价于：
def enumerate(sequence, start=0):
	n = start
	for elem in sequence:
		yield n, elem
		n += 1

eval(expression[, globals[, locals]])

实参是一个字符串，以及可选的 globals 和 locals。globals 实参必须是一个字典。locals 可以是任何映
射对象。
expression 参数会作为一个 Python 表达式（从技术上说是一个条件列表）被解析并求值，并使用
globals 和 locals 字典作为全局和局部命名空间。如果 globals 字典存在且不包含以 __builtins__
为键的值，则会在解析 expression 之前插入以此为键的对内置模块builtins 的引用。这意味着
expression 通常具有对标准builtins 模块的完全访问权限且受限的环境会被传播。如果省略 locals
字典则其默认值为 globals 字典。如果两个字典同时省略，则表达式执行时会使用eval() 被调用的
环境中的 globals 和 locals。请注意，eval() 并没有对外围环境下的 (非局部) 嵌套作用域 的访问权限。
返回值就是表达式的求值结果。语法错误将作为异常被报告。例如：
>>> x = 1
>>> eval('x+1')
2
这个函数也可以用来执行任何代码对象（如compile() 创建的）。这种情况下，参数是代码对象，而不是字符串。如果编译该对象时的 mode 实参是 'exec' 那么eval() 返回值为 None 。
提示：exec() 函数支持动态执行语句。globals() 和locals() 函数各自返回当前的全局和本
地字典，因此您可以将它们传递给eval() 或exec() 来使用。

exec(object[, globals[, locals]])

这个函数支持动态执行 Python 代码。object 必须是字符串或者代码对象。如果是字符串，那么该字
符串将被解析为一系列 Python 语句并执行（除非发生语法错误）。1 如果是代码对象，它将被直接执
行。在任何情况下，被执行的代码都需要和文件输入一样是有效的（见参考手册中关于文件输入的
章节）。请注意即使在传递给exec() 函数的代码的上下文中，return 和 yield 语句也不能在函
数定义之外使用。该函数返回值是 None 。
无论哪种情况，如果省略了可选项，代码将在当前作用域内执行。如果只提供了 globals，则它必须
是一个字典（不能是字典的子类），该字典将同时被用于全局和局部变量。如果同时提供了 globals
和 locals，它们会分别被用于全局和局部变量。如果提供了 locals，则它可以是任何映射对象。请记
住在模块层级上，globals 和 locals 是同一个字典。如果 exec 得到两个单独对象作为 globals 和 locals，
则代码将如同嵌入类定义的情况一样执行。
如果 globals 字典不包含 __builtins__ 键值，则将为该键插入对内建builtins 模块字典的引
用。因此，在将执行的代码传递给exec() 之前，可以通过将自己的 __builtins__ 字典插入到
globals 中来控制可以使用哪些内置代码。
注解: 内置globals() 和locals() 函数各自返回当前的全局和本地字典，因此可以将它们传递
给exec() 的第二个和第三个实参。
默认情况下，locals 的行为如下面locals() 函数描述的一样：不要试图改变默认的 locals
字典。如果您想在exec() 函数返回时知道代码对 locals 的变动，请明确地传递 locals 字典。

filter(function, iterable)

用 iterable 中函数 function 返回真的那些元素，构建一个新的迭代器。iterable 可以是一个序列，一个
支持迭代的容器，或一个迭代器。如果 function 是 None ，则会假设它是一个身份函数，即 iterable
中所有返回假的元素会被移除。
请注意，filter(function, iterable) 相当于一个生成器表达式，当 function 不是 None 的
时候为 (item for item in iterable if function(item))；function 是 None 的时候为
(item for item in iterable if item) 。

class float([x])

返回从数字或字符串 x 生成的浮点数。
如果实参是字符串，则它必须是包含十进制数字的字符串，字符串前面可以有符号，之前也可以有
空格。可选的符号有 '+' 和 '-' ；'+' 对创建的值没有影响。实参也可以是 NaN（非数字）、正负
无穷大的字符串。确切地说，除去首尾的空格后，输入必须遵循以下语法：
sign ::= "+" | "-"
infinity ::= "Infinity" | "inf"
nan ::= "nan"
numeric_value ::= floatnumber | infinity | nan
numeric_string ::= [sign] numeric_value
这里，floatnumber 是 Python 浮点数的字符串形式，详见 floating。字母大小写都可以，例
如，“inf”、“Inf”、“INFINITY”、“iNfINity”都可以表示正无穷大。
另一方面，如果实参是整数或浮点数，则返回具有相同值（在 Python 浮点精度范围内）的浮点数。
如果实参在 Python 浮点精度范围外，则会触发OverflowError。
对于一个普通 Python 对象 x，float(x) 会委托给 x.__float__()。如果 __float__() 未定
义则将回退至 __index__()。
如果没有实参，则返回 0.0 。
例如:
>>> float('+1.23')
1.23
>>> float(' -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf   

format(value[, format_spec ])

将 value 转换为 format_spec 控制的“格式化”表示。format_spec 的解释取决于 value 实参的类型，但 是大多数内置类型使用标准格式化语法：格式规格迷你语言。 默认的 format_spec 是一个空字符串，它通常和调用str(value) 的结果相同。 调 用 format(value, format_spec) 会 转 换 成 type(value).__format__(value, format_spec) ，所以实例字典中的 __format__() 方法将不会调用。如果搜索到object 有这个方法但 format_spec 不为空，format_spec 或返回值不是字符串，会触发TypeError 异常。

class frozenset([iterable ])

返回一个新的frozenset 对象，它包含可选参数 iterable 中的元素。frozenset 是一个内置的类。

getatter(object, name[, default])

返回对象命名属性的值。name 必须是字符串。如果该字符串是对象的属性之一，则返回该属性的值。例如，getattr(x, 'foobar') 等同于 x.foobar。如果指定的属性不存在，且提供了default 值，则返回它，否则触发AttributeError。

globals()

返回表示当前全局符号表的字典。这总是当前模块的字典（在函数或方法中，不是调用它的模块，
而是定义它的模块）。

hasttr(object,name)

该实参是一个对象和一个字符串。如果字符串是对象的属性之一的名称，则返回 True，否则返回
False。（此功能是通过调用 getattr(object, name) 看是否有AttributeError 异常来实
现的。）

hash(object)

返回该对象的哈希值（如果它有的话）。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0）。
注解: 如果对象实现了自己的 __hash__() 方法，请注意，hash() 根据机器的字长来截断返回值。

help([object])

启动内置的帮助系统（此函数主要在交互式中使用）。如果没有实参，解释器控制台里会启动交互式帮助系统。如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。如果实参是其他任意对象，则会生成该对象的帮助页。

hex(x)

将整数转换为以“0x”为前缀的小写十六进制字符串。如果 x 不是 Python int 对象，则必须定义返回整数的 __index__() 方法。一些例子：
>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
如果要将整数转换为大写或小写的十六进制字符串，并可选择有无“0x”前缀，则可以使用如下方法：
>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')

id(object)

返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命周期不重叠的对象可能具有相同的id() 值。

input([prompt])

如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。当读取到 EOF 时，则触发EOFError。例如:
>>> s = input('--> ')
--> Monty Python's Flying Circus
>>> s
"Monty Python's Flying Circus"
如果加载了readline 模块，input() 将使用它来提供复杂的行编辑和历史记录功能。
引发一个审计事件 builtins.input 附带参数 prompt。
在成功读取输入之后引发一个审计事件 builtins.input/result 附带结果。

class int([x ])

class int(x, base=10)

返回一个基于数字或字符串 x 构造的整数对象，或者在未给出参数时返回 0。如果 x 定义
了 __int__()，int(x) 将返回 x.__int__()。如果 x 定义了 __index__()，它将返回 x.
__index__()。如果 x 定义了 __trunc__()，它将返回 x.__trunc__()。对于浮点数，它将
向零舍入。
如果 x 不是数字，或者有 base 参数，x 必须是字符串、bytes、表示进制为 base 的 整数字面值
的bytearray 实例。该文字前可以有 + 或 - （中间不能有空格），前后可以有空格。一个进制为 n
的数字包含 0 到 n-1 的数，其中 a 到 z（或 A 到 Z ）表示 10 到 35。默认的 base 为 10 ，允许的进制
有 0、2-36。2、8、16 进制的数字可以在代码中用 0b/0B 、0o/0O 、0x/0X 前缀来表示。进制为 0 将
安照代码的字面量来精确解释，最后的结果会是 2、8、10、16 进制中的一个。所以 int('010',
0) 是非法的，但 int('010') 和 int('010', 8) 是合法的。
整数类型定义请参阅数字类型 --- int, float, complex 。
在 3.4 版更改: 如果 base 不是int 的实例，但 base 对象有 base.__index__ 方法，则会调用该方
法来获取进制数。以前的版本使用 base.__int__ 而不是 base.__index__。
在 3.6 版更改: 您可以使用下划线将代码文字中的数字进行分组。
在 3.7 版更改: x 现在只能作为位置参数。
在 3.8 版更改: 如果 __int__() 未定义则回退至 __index__()。

isinstance(object,classinfo)

如果参数 object 是参数 classinfo 的实例或者是其 (直接、间接或虚拟) 子类则返回 True。如果 object
不是给定类型的对象，函数将总是返回 False。如果 classinfo 是类型对象元组（或由其他此类元组
递归组成的元组），那么如果 object 是其中任何一个类型的实例就返回 True。如果 classinfo 既不是
类型，也不是类型元组或类型元组的元组，则将引发TypeError 异常。

issubclass(class,classinfo())

如果 class 是 classinfo 的 (直接、间接或虚拟) 子类则返回 True。类会被视作其自身的子类。classinfo也以是类对象的元组，在此情况下 classinfo 中的每个条目都将被检查。在任何其他情况下，都将引
发TypeError 异常。

iter(object[,sentinel])

返回一个iterator 对象。根据是否存在第二个实参，第一个实参的解释是非常不同的。如果没有第二个实参，object 必须是支持迭代协议（有 __iter__() 方法）的集合对象，或必须支持序列协议（有 __getitem__() 方法，且数字参数从 0 开始）。如果它不支持这些协议，会触发TypeError。
如果有第二个实参 sentinel，那么 object 必须是可调用的对象。这种情况下生成的迭代器，每次
迭代调用它的__next__() 方法时都会不带实参地调用 object；如果返回的结果是 sentinel 则触
发StopIteration，否则返回调用结果。
适合iter() 的第二种形式的应用之一是构建块读取器。例如，从二进制数据库文件中读取固定宽
度的块，直至到达文件的末尾:
from functools import partial
with open('mydata.db', 'rb') as f:
	for block in iter(partial(f.read, 64), b''):
		process_block(block)

len(s)

虽然被称为函数，list 实际上是一种可变序列类型

locals()

更新并返回表示当前本地符号表的字典。在函数代码块但不是类代码块中调用locals() 时将返回自由变量。请注意在模块层级上，locals() 和globals() 是同一个字典。
注解: 不要更改此字典的内容；更改不会影响解释器使用的局部变量或自由变量的值。

map(function,iterable,…)

返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器。如果传入了额外的 iterable 参
数，function 必须接受相同个数的实参并被应用于从所有可迭代对象中并行获取的项。当有多个可迭代对象时，最短的可迭代对象耗尽则整个迭代就将结束。对于函数的输入已经是参数元组的情况

max(iterable,*[,key,default])

max(arg1,arg2,*args[,key])

返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。
如果只提供了一个位置参数，它必须是非空iterable，返回可迭代对象中最大的元素；如果提供了两
个及以上的位置参数，则返回最大的位置参数。
有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给list.sort() 的。
default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触
发ValueError。
如 果 有 多 个 最 大 元 素， 则 此 函 数 将 返 回 第 一 个 找 到 的。 这 和 其 他 稳 定 排 序 工
具 如 sorted(iterable, key=keyfunc, reverse=True)[0] 和 heapq.nlargest(1,
iterable, key=keyfunc) 保持一致。

class memoryview(obj)

返回由给定实参创建的“内存视图”对象。

min(iterable,*[,key,default])

min(arg1,arg2,*args[,key])

返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。
如果只提供了一个位置参数，它必须是iterable，返回可迭代对象中最小的元素；如果提供了两个及
以上的位置参数，则返回最小的位置参数。
有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给list.sort() 的。
default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触
发ValueError。
如 果 有 多 个 最 小 元 素， 则 此 函 数 将 返 回 第 一 个 找 到 的。 这 和 其 他 稳 定 排 序
工 具 如 sorted(iterable, key=keyfunc)[0] 和 heapq.nsmallest(1, iterable,
key=keyfunc) 保持一致。

next(iterator,[,default])

通过调用 iterator 的__next__() 方法获取下一个元素。如果迭代器耗尽，则返回给定的 default，
如果没有默认值则触发StopIteration。

class object

返回一个没有特征的新对象。object 是所有类的基类。它具有所有 Python 类实例的通用方法。这个函数不接受任何实参。

oct(x)

将一个整数转变为一个前缀为“0o”的八进制字符串。结果是一个合法的 Python 表达式。如果 x 不是 Python 的int 对象，那它需要定义 __index__() 方法返回一个整数。一些例子：
>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'
如果要将整数转换为八进制字符串，并可选择有无“0o”前缀，则可以使用如下方法：
>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

打开 file 并返回对应的file object。如果该文件不能被打开，则引发OSError。请参阅 tut-files 获取此
函数的更多用法示例。
file 是一个path-like object，表示将要打开的文件的路径（绝对路径或者当前工作目录的相对路径），
也可以是要被封装的整数类型文件描述符。（如果是文件描述符，它会随着返回的 I/O 对象关闭而
关闭，除非 closefd 被设为 False 。）
mode 是一个可选字符串，用于指定打开文件的模式。默认值是 'r' ，这意味着它以文本模式
打开并读取。其他常见模式有：写入 'w' （截断已经存在的文件）；排它性创建 'x' ；追加
写 'a' （在 一些 Unix 系统上，无论当前的文件指针在什么位置，所有写入都会追加到文件
末尾）。在文本模式，如果 encoding 没有指定，则根据平台来决定使用的编码：使用 locale.
getpreferredencoding(False) 来获取本地编码。（要读取和写入原始字节，请使用二进制模
式并不要指定 encoding.

可用的模式有:

字符	意义
‘r’	读取（默认）
‘w’	写入，并先截断文件
‘x’	排它性创建，如果文件已存在则失败
‘a’	写入，如果文件存在则在文件末尾追加
‘b’	二进制模式
‘t’	文本模式（默认）
‘+’	打开用于更新（读取与写入）

pow(base,exp[,mod])

返回 base 的 exp 次幂；如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp)
% mod 更高效）。两参数形式 pow(base, exp) 等价于乘方运算符: base**exp。
参数必须具有数值类型。对于混用的操作数类型，则将应用双目算术运算符的类型强制转换规则。
对于int 操作数，结果具有与操作数相同的类型（强制转换后），除非第二个参数为负值；在这种
情况下，所有参数将被转换为浮点数并输出浮点数结果。例如，10**2 返回 100，但 10**-2 返
回 0.01。
对于int 操作数 base 和 exp，如果给出 mod，则 mod 必须为整数类型并且 mod 必须不为零。如果给出
mod 并且 exp 为负值，则 base 必须相对于 mod 不可整除。在这种情况下，将会返回 pow(inv_base,
-exp, mod)，其中 inv_base 为 base 的倒数对 mod 取余。
下面的例子是 38 的倒数对 97 取余:
>>> pow(38, -1, mod=97)
23
>>> 23 * 38 % 97 == 1
True    

print(*objects, sep=’ ’, end=’\n’, file=sys.stdout, flush=False)

将 objects 打印到 file 指定的文本流，以 sep 分隔并在末尾加上 end。sep, end, file 和 flush 如果存在，
它们必须以关键字参数的形式给出。
所有非关键字参数都会被转换为字符串，就像是执行了str() 一样，并会被写入到流，以 sep 且在
末尾加上 end。sep 和 end 都必须为字符串；它们也可以为 None，这意味着使用默认值。如果没有
给出 objects，则print() 将只写入 end。
file 参数必须是一个具有 write(string) 方法的对象；如果参数不存在或为 None，则将使
用sys.stdout。由于要打印的参数会被转换为文本字符串，因此print() 不能用于二进制模式
的文件对象。对于这些对象，应改用 file.write(...)。
输出是否被缓存通常决定于 file，但如果 flush 关键字参数为真值，流会被强制刷新。

class property(fget=None, fset=None, fdel=None, doc=None)

返回 property 属性。
fget 是获取属性值的函数。fset 是用于设置属性值的函数。fdel 是用于删除属性值的函数。并且 doc
为属性对象创建文档字符串。
一个典型的用法是定义一个托管属性 x:
class C:
    def __init__(self):
    	self._x = None
    def getx(self):
    	return self._x
    def setx(self, value):
    	self._x = value
    def delx(self):
    	del self._x
	x = property(getx, setx, delx, "I'm the 'x' property.")  
如果 c 是 C 的实例，c.x 将调用 getter，c.x = value 将调用 setter，del c.x 将调用 deleter。
如果给出，doc 将成为该 property 属性的文档字符串。否则该 property 将拷贝 fget 的文档字符串（如
果存在）。这令使用property() 作为decorator 来创建只读的特征属性可以很容易地实现:
class Parrot:
	def __init__(self):
		self._voltage = 100000
	@property
	def voltage(self):
		return self._voltage
以上 @property 装饰器会将 voltage() 方法转化为一个具有相同名称的只读属性的”getter”，并
将 voltage 的文档字符串设置为”Get the current voltage.”
特征属性对象具有 getter, setter 以及 deleter 方法，它们可用作装饰器来创建该特征属性的
副本，并将相应的访问函数设为所装饰的函数。这最好是用一个例子来解释:
class C:
	def __init__(self):
		self._x = None
	@property
	def x(self):
		return self._x
	@x.setter
	def x(self, value):
		self._x = value
	@x.deleter
	def x(self):
		del self._x
上述代码与第一个例子完全等价。注意一定要给附加函数与原始的特征属性相同的名称 (在本例中为 x。)
返回的特征属性对象同样具有与构造器参数相对应的属性 fget, fset 和 fdel。      

class range(stop)

class range(start,stop[,step])

虽然被称为函数，但range 实际上是一个不可变的序列类型

repr(object)

返回包含一个对象的可打印表示形式的字符串。对于许多类型来说，该函数会尝试返回的字符串将会与该对象被传递给eval() 时所生成的对象具有相同的值，在其他情况下表示形式会是一个括在尖括号中的字符串，其中包含对象类型的名称与通常包括对象名称和地址的附加信息。类可以通过定义 __repr__() 方法来控制此函数为它的实例所返回的内容。

reversed(seq)

返回一个反向的iterator。seq 必须是一个具有 __reversed__() 方法的对象或者是支持该序列协议（具有从 0 开始的整数类型参数的 __len__() 方法和 __getitem__() 方法）。

round(number[,ndigits])

返回 number 舍入到小数点后 ndigits 位精度的值。如果 ndigits 被省略或为 None，则返回最接近输入
值的整数。
对于支持round() 的内置类型，值会被舍入到最接近的 10 的负 ndigits 次幂的倍数；如果与两个倍
数的距离相等，则选择偶数 (因此，round(0.5) 和 round(-0.5) 均为 0 而 round(1.5) 为 2)。
任何整数值都可作为有效的 ndigits (正数、零或负数)。如果 ndigits 被省略或为 None 则返回值将为
整数。否则返回值与 number 的类型相同。
对于一般的 Python 对象 number, round 将委托给 number.__round__。
注解: 对浮点数执行round() 的行为可能会令人惊讶：例如，round(2.675, 2) 将给出 2.67
而不是期望的 2.68。这不算是程序错误：这一结果是由于大多数十进制小数实际上都不能以浮点
数精确地表示。请参阅 tut-fp-issues 了解更多信息。

class set([iterable])

返回一个新的set 对象，可以选择带有从 iterable 获取的元素。set 是一个内置类型。

setattr(object,name,value)

此函数与getattr() 两相对应。其参数为一个对象、一个字符串和一个任意值。字符串指定一个现有属性或者新增属性。函数会将值赋给该属性，只要对象允许这种操作。例如，setattr(x,'foobar', 123) 等价于 x.foobar = 123。

class slice(stop)

class slice(start,stop,[,step])

返回一个表示由 range(start, stop, step) 所指定索引集的slice 对象。其中 start 和 step 参数
默认为 None。切片对象具有仅会返回对应参数值（或其默认值）的只读数据属性 start, stop 和
step。它们没有其他的显式功能；不过它们会被 NumPy 以及其他第三方扩展所使用。切片对象也
会在使用扩展索引语法时被生成。例如: a[start:stop:step] 或 a[start:stop, i]。

sorted(iterable,*,kkey-None,reverse=False)

根据 iterable 中的项返回一个新的已排序列表。
具有两个可选参数，它们都必须指定为关键字参数。
key 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.
lower)。默认值为 None (直接比较元素)。
reverse 为一个布尔值。如果设为 True，则每个列表元素将按反向顺序比较进行排序。
使用functools.cmp_to_key() 可将老式的 cmp 函数转换为 key 函数。
内置的sorted() 确保是稳定的。如果一个排序确保不会改变比较结果相等的元素的相对顺序就
称其为稳定的 --- 这有利于进行多重排序（例如先按部门、再按薪级排序）

@staticemethod

将方法转换为静态方法。
静态方法不会接收隐式的第一个参数。要声明一个静态方法，请使用此语法
class C:
@staticmethod
def f(arg1, arg2, ...): 
    ...

class str(object="")

class str(object=b”, encoding=’utf-8’, errors=’strict’)

返回一个str 版本的 object 。

sum(iterable,/,start=0)

从 start 开始自左向右对 iterable 的项求和并返回总计值。iterable 的项通常为数字，而 start 值则不允许为字符串。对某些用例来说，存在sum() 的更好替代。拼接字符串序列的更好更快方式是调用 ''.join(sequence)。要以扩展精度对浮点值求和，请参阅math.fsum()。要拼接一系列可迭代对象，请考虑使用itertools.chain()。

super([type[, object-or-type ]])

返回一个代理对象，它会将方法调用委托给 type 的父类或兄弟类。这对于访问已在类中被重载的继
承方法很有用。
object-or-type 确定用于搜索的method resolution order。搜索会从 type 之后的类开始。
举例来说，如果 object-or-type 的__mro__ 为 D -> B -> C -> A -> object 并且 type 的值为
B，则super() 将会搜索 C -> A -> object。
object-or-type 的__mro__ 属性列出了getattr() 和super() 所共同使用的方法解析搜索顺序。该
属性是动态的，可以在任何继承层级结构发生更新的时候被改变。
如果省略第二个参数，则返回的超类对象是未绑定的。如果第二个参数为一个对象，则
isinstance(obj, type) 必须为真值。如果第二个参数为一个类型，则 issubclass(type2,
type) 必须为真值（这适用于类方法）。
super 有两个典型用例。在具有单继承的类层级结构中，super 可用来引用父类而不必显式地指定它
们的名称，从而令代码更易维护。这种用法与其他编程语言中 super 的用法非常相似。
第二个用例是在动态执行环境中支持协作多重继承。此用例为 Python 所独有，在静态编译语言或
仅支持单继承的语言中是不存在的。这使得实现“菱形图”成为可能，在这时会有多个基类实现相
同的方法。好的设计强制要求这种方法在每个情况下具有相同的调用签名（因为调用顺序是在运行
时确定的，也因为该顺序要适应类层级结构的更改，还因为该顺序可能包含在运行时之前未知的兄
弟类）。
对于以上两个用例，典型的超类调用看起来是这样的:
class C(B):
	def method(self, arg):
		super().method(arg) 
除了方法查找之外，super() 也可用于属性查找。一个可能的应用场合是在上级或同级类中调
用描述器。
请注意super() 是作为显式加点属性查找的绑定过程的一部分来实现的，例如 super().
__getitem__(name)。它做到这一点是通过实现自己的 __getattribute__() 方法，这样
就能以可预测的顺序搜索类，并且支持协作多重继承。对应地，super() 在像 super()[name]
这样使用语句或操作符进行隐式查找时则未被定义。
还要注意的是，除了零个参数的形式以外，super() 并不限于在方法内部使用。两个参数的形式
明确指定参数并进行相应的引用。零个参数的形式仅适用于类定义内部，因为编译器需要填入必要
的细节以正确地检索到被定义的类，还需要让普通方法访问当前实例。    

class tuple([iterable])

虽然被称为函数，但tuple 实际上是一个不可变的序列类型

class type(object)

class type(name,bases,dict)

传入一个参数时，返回 object 的类型。返回值是一个 type 对象，通常与object.__class__ 所返
回的对象相同。
推荐使用isinstance() 内置函数来检测对象的类型，因为它会考虑子类的情况。
传入三个参数时，返回一个新的 type 对象。这在本质上是 class 语句的一种动态形式。name 字符
串即类名并且会成为__name__ 属性；bases 元组列出基类并且会成为__bases__ 属性；而 dict 字
典为包含类主体定义的命名空间并且会被复制到一个标准字典成为__dict__ 属性。例如，下面两
条语句会创建相同的type 对象:
>>> class X:
... a = 1
...
>>> X = type('X', (object,), dict(a=1))    

vars([object])

返回模块、类、实例或任何其它具有__dict__ 属性的对象的__dict__ 属性。
模块和实例这样的对象具有可更新的__dict__ 属性；但是，其它对象的__dict__ 属性可能会
设为限制写入（例如，类会使用types.MappingProxyType 来防止直接更新字典）。
不带参数时，vars() 的行为类似locals()。请注意，locals 字典仅对于读取起作用，因为对 locals
字典的更新会被忽略。
如果指定了一个对象但它没有__dict__ 属性（例如，当它所属的类定义了 __slots__ 属性时）
则会引发TypeError 异常。

zip(*iterables)

创建一个聚合了来自每个可迭代对象中的元素的迭代器。
返回一个元组的迭代器，其中的第 i 个元组包含来自每个参数序列或可迭代对象的第 i 个元素。当
所输入可迭代对象中最短的一个被耗尽时，迭代器将停止迭代。当只有一个可迭代对象参数时，它
将返回一个单元组的迭代器。不带参数时，它将返回一个空迭代器。相当于:
def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
    	result = []
    	for it in iterators:
    	elem = next(it, sentinel)
    	if elem is sentinel:
   			 return
    	result.append(elem)
    yield tuple(result)
函数会保证可迭代对象按从左至右的顺序被求值。使得可以通过 zip(*[iter(s)]*n) 这样的惯
用形式将一系列数据聚类为长度为 n 的分组。这将重复 同样的迭代器 n 次，以便每个输出的元组
具有第 n 次调用该迭代器的结果。它的作用效果就是将输入拆分为长度为 n 的数据块。
当你不用关心较长可迭代对象末尾不匹配的值时，则zip() 只须使用长度不相等的输入即可。如
果那些值很重要，则应改用itertools.zip_longest()。
zip() 与 * 运算符相结合可以用来拆解一个列表:
>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True

import(name, globals=None, locals=None, fromlist=(), level=0)

注解: 与importlib.import_module() 不同，这是一个日常 Python 编程中不需要用到的高级 函数。

此函数会由 import 语句发起调用。它可以被替换 (通过导入builtins 模块并赋值给builtins.__import__) 以便修改 import 语句的语义，但是 强烈不建议这样做，因为使用导入钩子通常更容易实现同样的目标，并且不会导致代码问题，因为许多代码都会假定所用的是默认实现。同样也不建议直接使用__import__() 而应该用importlib.import_module()。
该函数会导入 name 模块，有可能使用给定的 globals 和 locals 来确定如何在包的上下文中解读名称。
fromlist 给出了应该从由 name 指定的模块导入对象或子模块的名称。标准实现完全不使用其 locals
参数，而仅使用 globals 参数来确定 import 语句的包上下文。
level 指定是使用绝对还是相对导入。0 (默认值) 意味着仅执行绝对导入。level 为正数值表示相对于
模块调用__import__() 的目录，将要搜索的父目录层数 (详情参见 PEP 328)。
当 name 变量的形式为 package.module 时，通常将会返回最高层级的包（第一个点号之前的名
称），而 不是以 name 命名的模块。但是，当给出了非空的 fromlist 参数时，则将返回以 name 命名
的模块。
例如，语句 import spam 的结果将为与以下代码作用相同的字节码:
spam = __import__('spam', globals(), locals(), [], 0)
语句 import spam.ham 的结果将为以下调用:
spam = __import__('spam.ham', globals(), locals(), [], 0)
请注意在这里__import__() 是如何返回顶层模块的，因为这是通过 import 语句被绑定到特定
名称的对象。
另一方面，语句 from spam.ham import eggs, sausage as saus 的结果将为
_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage
在这里，spam.ham 模块会由__import__() 返回。要导入的对象将从此对象中提取并赋值给它
们对应的名称。
如果您只想按名称导入模块（可能在包中），请使用importlib.import_module()