内置功能

Python解释器内置了许多函数和类型,这些函数和类型始终可用。它们按字母顺序列在这里。

内置功能

abs(x)

返回数字的绝对值。参数可以是整数、浮点数或实现 __abs__() . 如果参数是复数,则返回其大小。

all(iterable)

返回 True 如果所有元素 可迭代的 为真(或者如果iterable为空)。相当于:

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True
any(iterable)

返回 True 如果 可迭代的 是真的。如果iterable为空,则返回 False . 等同于:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False
ascii(object)

AS repr() ,返回一个包含对象可打印表示形式的字符串,但转义字符串中由返回的非ASCII字符 repr() 使用 \x\u\U 逃逸。这将生成一个类似于 repr() 在Python 2中。

bin(x)

将整数转换为前缀为“0b”的二进制字符串。结果是有效的python表达式。如果 x 不是 Python int 对象,它必须定义 __index__() 返回整数的方法。一些例子:

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

如果需要或不需要前缀“0b”,可以使用以下任一方法。

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

也见 format() 更多信息。

class bool([x])

返回一个布尔值,即 TrueFalse . x 使用标准转换 truth testing procedure . 如果 x 如果为false或省略,则返回 False 否则它会返回 True . 这个 bool 类是的子类 int (见 数字类型--- int , float , complex )它不能再分类。它的唯一实例是 FalseTrue (见 布尔值

在 3.7 版更改: x 现在是仅限位置的参数。

breakpoint(*args, **kws)

此函数将您放入调用站点的调试器中。具体来说,它需要 sys.breakpointhook() 通过 argskws 直接通过。默认情况下, sys.breakpointhook() 调用 pdb.set_trace() 不需要参数。在这种情况下,它纯粹是一个方便函数,因此您不必显式导入 pdb 或者键入足够多的代码以进入调试器。然而, sys.breakpointhook() 可设置为其他功能 breakpoint() 将自动调用它,允许您进入所选的调试器。

提出一个 auditing event builtins.breakpoint 带着论证 breakpointhook .

3.7 新版功能.

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

返回新的字节数组。这个 bytearray 类是范围0<=x<256的可变整数序列。它具有大多数常用的可变序列方法,如 可变序列类型 以及大多数方法 bytes 类型已见 字节和字节数组操作 .

可选的 source 参数可以用几种不同的方法初始化数组:

  • 如果是 string ,您还必须 encoding (可选, errors 参数; bytearray() 然后使用将字符串转换为字节 str.encode() .

  • 如果是 整数 ,数组将具有该大小,并将用空字节初始化。

  • 如果它是符合 缓冲区 接口,对象的只读缓冲区将用于初始化字节数组。

  • 如果是 可迭代的 ,它必须是范围内整数的可Itable 0 <= x < 256 ,用作数组的初始内容。

如果没有参数,将创建大小为0的数组。

也见 二进制序列类型--- bytes , bytearray , memoryviewBytearray对象 .

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

返回一个新的“bytes”对象,该对象是范围内不可变的整数序列 0 <= x < 256 . bytes 是的不可变版本 bytearray --它具有相同的非变异方法和相同的索引和切片行为。

相应地,构造函数参数被解释为 bytearray() .

字节对象也可以用文本创建,请参见 字符串与字节的字面值 .

也见 二进制序列类型--- bytes , bytearray , memoryview字节对象字节和字节数组操作 .

callable(object)

返回 True 如果 对象 参数似乎可以调用, False 如果没有。如果它回来了 True ,仍然有可能调用失败,但如果是 False 呼唤 对象 永远不会成功。请注意,类是可调用的(调用类返回新实例);如果实例的类具有 __call__() 方法。

3.2 新版功能: 这个函数首先在python 3.0中被删除,然后在python 3.2中被恢复。

chr(i)

返回表示其Unicode码位为整数的字符的字符串 i . 例如, chr(97) 返回字符串 'a' ,同时 chr(8364) 返回字符串 '€' . 这与 ord() .

参数的有效范围是从0到1114111(以16为基数为0x10ffff)。 ValueError 如果 i 在这个范围之外。

@classmethod

将方法转换为类方法。

类方法将类作为隐式第一个参数接收,就像实例方法接收实例一样。要声明类方法,请使用以下习惯用法:

class C:
    @classmethod
    def f(cls, arg1, arg2, ...): ...

这个 @classmethod 形式是一种功能 decorator --见 函数定义 有关详细信息。

类方法可以在类上调用(例如 C.f() )或在一个实例上(例如 C().f() )该实例被忽略,但其类除外。如果为派生类调用了类方法,则派生类对象将作为隐含的第一个参数传递。

类方法不同于C++或Java静态方法。如果你想要,看 staticmethod() 在本节中。有关类方法的详细信息,请参见 标准类型层次结构 .

在 3.9 版更改: 类方法现在可以包装其他 descriptorsproperty() .

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

编译 source 进入代码或AST对象。代码对象可以由 exec()eval() . source 可以是普通字符串、字节字符串或AST对象。参考 ast 有关如何使用AST对象的信息的模块文档。

这个 filename 参数应该给出从中读取代码的文件;如果不是从文件中读取代码,则传递一些可识别的值 ('<string>' 常用)。

这个 mode 参数指定必须编译的代码类型;它可以是 'exec' 如果 source 由一系列语句组成, 'eval' 如果它由单个表达式组成,或 'single' 如果它由单个交互语句组成(在后一种情况下,表达式语句的计算结果不是 None 将被打印)。

可选参数 flagsdont_inherit 控制哪个 future statements 影响的编译 source . 如果两者都不存在(或两者都为零),则使用在调用的代码中有效的未来语句编译代码。 compile() . 如果 flags 给出了参数,并且 dont_inherit 不是(或为零),则为 flags 除了那些无论如何都会用到的参数外,还使用了参数。如果 dont_inherit 是一个非零整数,然后 flags 参数是-compile调用周围有效的未来语句将被忽略。

未来的语句由位指定,这些位可以按位或一起指定多个语句。指定给定功能所需的位字段可以作为 compiler_flag 属性 _Feature 实例中 __future__ 模块。

可选参数 旗帜 还控制是否允许编译的源包含顶级 awaitasync forasync with . 当钻头 ast.PyCF_ALLOW_TOP_LEVEL_AWAIT 设置,返回代码对象具有 CO_COROUTINE 设置在 co_code ,并且可以通过 await eval(code_object) .

参数 optimize 指定编译器的优化级别;默认值为 -1 选择解释器的优化级别,如 -O 选项。显式级别是 0 (无优化; __debug__ 是真的) 1 (断言被删除, __debug__ 是假的) 2 (文档字符串也被删除)。

此函数引发 SyntaxError 如果编译的源无效,并且 ValueError 如果源包含空字节。

如果要将python代码解析为其ast表示形式,请参见 ast.parse() .

提出一个 auditing event compile 带着论据 sourcefilename .

注解

编译包含多行代码的字符串时 'single''eval' 模式,输入必须至少以一个换行符终止。这有助于检测 code 模块。

警告

由于python的ast编译器中的堆栈深度限制,在编译到ast对象时,可能会使用足够大/复杂的字符串使python解释器崩溃。

在 3.2 版更改: 允许使用Windows和Mac换行符。还输入 'exec' 模式不再以换行符结尾。添加了 optimize 参数。

在 3.5 版更改: 以前, TypeError 在中遇到空字节时引发 source .

3.8 新版功能: ast.PyCF_ALLOW_TOP_LEVEL_AWAIT 现在可以传入标志以启用对顶级的支持 awaitasync forasync with .

class complex([real[, imag]])

返回带值的复数 real + imag * 1j或将字符串或数字转换为复数。如果第一个参数是字符串,它将被解释为复数,并且必须在没有第二个参数的情况下调用函数。第二个参数不能是字符串。每个参数可以是任何数值类型(包括复数)。如果 imag 如果省略,则默认为零,构造函数用作类似 intfloat . 如果两个参数都被省略,则返回 0j .

对于一般的python对象 xcomplex(x) 代表参加 x.__complex__() . 如果 __complex__() 未定义,则返回到 __float__() . 如果 __float__() 未定义,则返回到 __index__() .

注解

从字符串转换时,该字符串不能在中心周围包含空格 +- 操作员。例如, complex('1+2j') 很好,但是 complex('1 + 2j') 引发 ValueError .

复杂类型在 数字类型--- int , float , complex .

在 3.6 版更改: 允许使用下划线对数字进行分组,如在代码文本中那样。

在 3.8 版更改: 回到 __index__() 如果 __complex__()__float__() 未定义。

delattr(object, name)

这是一个亲戚 setattr() . 参数是一个对象和一个字符串。字符串必须是对象属性之一的名称。如果对象允许,函数将删除命名属性。例如, delattr(x, 'foobar') 等于 del x.foobar .

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

创建新词典。这个 dict 对象是字典类。参见 dict映射类型--- dict 有关此类的文档。

对于其他容器,请参见内置的 listsettuple 类,以及 collections 模块。

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() 主要是为了方便在交互式提示下使用而提供的,它试图提供一组有趣的名称,而不是试图提供一组严格或一致定义的名称,并且它的详细行为可能会在不同版本之间发生变化。例如,当参数是类时,元类属性不在结果列表中。

divmod(a, b)

以两个(非复杂)数字作为参数,并在使用整数除法时返回一对由其商和余数组成的数字。对于混合操作数类型,应用二进制算术运算符的规则。对于整数,结果与 (a // b, a % b) . 对于浮点数,结果是 (q, a % b) 在哪里 q 通常是 math.floor(a / b) 但可能比这个少1。在任何情况下 q * b + a % b 非常接近 a 如果 a % b 是非零的,它的符号与 b0 <= abs(a % b) < abs(b) .

enumerate(iterable, start=0)

返回枚举对象。 可迭代的 必须是一个序列,一个 iterator 或者其他支持迭代的对象。这个 __next__() 迭代器返回的方法 enumerate() 返回包含计数的元组(从 开始 默认值为0)和通过迭代获得的值 可迭代的 .

>>> 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 可以是任何映射对象。

这个 表达 参数被解析为python表达式(从技术上讲,是一个条件列表),并使用 全局变量当地人 作为全局和本地命名空间的字典。如果 全局变量 字典存在且不包含键的值 __builtins__ ,对内置模块字典的引用 builtins 在那把钥匙下面插入 表达 被解析。这意味着 表达 通常可以完全访问标准 builtins 模块和受限环境被传播。如果 当地人 字典被省略,它默认为 全局变量 字典。如果省略了这两个字典,则使用 全局变量当地人 在环境中 eval() 被称为。注意, 评估() 无法访问 nested scopes (非本地)在封闭的环境中。

返回值是计算表达式的结果。语法错误报告为异常。例子:

>>> x = 1
>>> eval('x+1')
2

此函数还可用于执行任意代码对象(例如由 compile() )。在这种情况下,传递代码对象而不是字符串。如果代码对象是用 'exec' 作为 mode 论证, eval() 返回值为 None .

提示:支持动态执行语句 exec() 功能。这个 globals()locals() 函数分别返回当前的全局字典和本地字典,这对于传递给 eval()exec() .

ast.literal_eval() 对于可以使用只包含文本的表达式安全地计算字符串的函数。

提出一个 auditing event exec 带着论证 code_object .

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

此函数支持python代码的动态执行。 object 必须是字符串或代码对象。如果是字符串,则将该字符串解析为一组python语句,然后执行该语句(除非出现语法错误)。 1 如果它是一个代码对象,则只需执行即可。在所有情况下,执行的代码作为文件输入都是有效的(参见参考手册中的“文件输入”一节)。请注意 returnyield 语句不能在函数定义之外使用,即使在传递给 exec() 功能。返回值为 None .

在所有情况下,如果省略可选部分,代码将在当前范围内执行。只要 全局变量 如果提供,它必须是一个字典(而不是字典的子类),它将用于全局变量和局部变量。如果 全局变量当地人 给出了它们分别用于全局变量和局部变量。如果提供, 当地人 可以是任何映射对象。请记住,在模块级别,全局变量和局部变量是相同的字典。如果exec得到两个单独的对象 全局变量当地人 ,将执行代码,就像它嵌入到类定义中一样。

如果 globals 字典不包含键的值 __builtins__ ,对内置模块字典的引用 builtins 插入到该键下。这样,您就可以通过插入自己的代码来控制可用于执行代码的内置组件。 __builtins__ 词典导入 globals 在传递给 exec() .

提出一个 auditing event exec 带着论证 code_object .

注解

内置功能 globals()locals() 分别返回当前的全局和局部字典,这对于传递用作 exec() .

注解

默认值 locals 按功能描述行事 locals() 以下:对默认值的修改 locals 不应尝试使用字典。传递显式 locals 如果需要查看代码对 locals 后功能 exec() 返回。

filter(function, iterable)

从以下元素构造迭代器 可迭代的 为此 function 返回true。 可迭代的 可以是序列、支持迭代的容器或迭代器。如果 functionNone ,假设标识函数,即 可迭代的 这是错误的将被删除。

注意 filter(function, iterable) 等价于生成器表达式 (item for item in iterable if function(item)) 如果函数不是 None(item for item in iterable if item) 如果函数是 None .

itertools.filterfalse() 对于返回元素的互补函数 可迭代的 为此 function 返回false。

class float([x])

返回从数字或字符串构造的浮点数字 x .

如果参数是字符串,它应该包含一个十进制数字,可以选择在前面加一个符号,也可以选择嵌入空白。可选标志可以是 '+''-' A '+' 符号对产生的值没有影响。参数也可以是表示NaN(非数字)或正无穷大或负无穷大的字符串。更准确地说,删除前导和尾随空格字符后,输入必须符合以下语法:

sign           ::=  "+" | "-"
infinity       ::=  "Infinity" | "inf"
nan            ::=  "nan"
numeric_value  ::=  floatnumber | infinity | nan
numeric_string ::=  [sign] numeric_value

在这里 floatnumber 是python浮点文本的形式,如 浮点型的字面值 . 大小写不重要,因此,例如,“inf”、“inf”、“infinity”和“infinity”都是正无穷大的可接受拼写。

否则,如果参数是整数或浮点数,则返回具有相同值的浮点数(在Python的浮点数精度内)。如果参数超出了python float的范围,则 OverflowError 将被引发。

对于一般的python对象 xfloat(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

浮动类型在 数字类型--- int , float , complex .

在 3.6 版更改: 允许使用下划线对数字进行分组,如在代码文本中那样。

在 3.7 版更改: x 现在是仅限位置的参数。

在 3.8 版更改: 回到 __index__() 如果 __float__() 未定义。

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__() 方法。一 TypeError 如果方法搜索达到 object 以及 format_spec 不是空的,或者如果 format_spec 或者返回值不是字符串。

在 3.4 版更改: object().__format__(format_spec) 引发 TypeError 如果 format_spec 不是空字符串。

class frozenset([iterable])

返回一个新的 frozenset 对象,可以选择元素取自 可迭代的 . frozenset 是一个内置类。见 frozenset集合类型 set , frozenset 有关此类的文档。

对于其他容器,请参见内置的 setlisttupledict 类,以及 collections 模块。

getattr(object, name[, default])

返回的命名属性的值 object . name 必须是字符串。如果字符串是对象属性之一的名称,则结果是该属性的值。例如, getattr(x, 'foobar') 等于 x.foobar . 如果命名属性不存在, default 如果提供,则返回,否则 AttributeError 提高了。

globals()

返回表示当前全局符号表的字典。这始终是当前模块的字典(在函数或方法中,这是定义它的模块,而不是从中调用它的模块)。

hasattr(object, name)

参数是一个对象和一个字符串。结果是 True 如果字符串是对象属性之一的名称, False 如果没有。(这是通过调用 getattr(object, name) 看看它是否会引发 AttributeError 或者没有。

hash(object)

返回对象的hash值(如果有)。hash值是整数。它们用于在字典查找期间快速比较字典键。比较等于的数值具有相同的hash值(即使它们属于不同类型,1和1.0的情况也是如此)。

注解

对于具有自定义的对象 __hash__() 方法,注意 hash() 根据主机的位宽度截断返回值。见 __hash__() 有关详细信息。

help([object])

调用内置帮助系统。(此函数用于交互使用。)如果没有给出参数,则交互帮助系统将在解释器控制台上启动。如果参数是字符串,则该字符串将作为模块、函数、类、方法、关键字或文档主题的名称查找,并在控制台上打印帮助页。如果参数是任何其他类型的对象,则会生成该对象的帮助页。

请注意,如果调用时函数的参数列表中出现斜线(/) help() ,这意味着斜杠前面的参数仅为位置参数。有关详细信息,请参阅 the FAQ entry on positional-only parameters .

此函数通过 site 模块。

在 3.4 版更改: 改变到 pydocinspect 这意味着报告的可调用文件签名现在更加全面和一致。

hex(x)

将整数转换为前缀为“0x”的小写十六进制字符串。如果 x 不是 Python int 对象,它必须定义 __index__() 返回整数的方法。一些例子:

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

如果要将整数转换为带前缀或不带前缀的大写或小写十六进制字符串,可以使用以下任一方法:

>>> '%#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')

也见 format() 更多信息。

也见 int() 用于将十六进制字符串转换为以16为基数的整数。

注解

要获取浮点的十六进制字符串表示形式,请使用 float.hex() 方法。

id(object)

返回对象的“标识”。这是一个整数,它保证在这个对象的生存期内是唯一的和不变的。生命周期不重叠的两个对象可能具有相同的 id() 价值。

CPython implementation detail: This is the address of the object in memory.

input([prompt])

如果 促使 参数存在,它将写入标准输出,而不带尾随新行。然后,函数从输入中读取一行,将其转换为字符串(去掉尾随的换行符),并返回该字符串。当读取EOF时, EOFError 提高了。例子::

>>> s = input('--> ')  
--> Monty Python's Flying Circus
>>> s  
"Monty Python's Flying Circus"

如果 readline 模块已加载,然后 input() 将使用它来提供详细的行编辑和历史功能。

提出一个 auditing event builtins.input 带着论证 prompt .

提出一个 auditing event builtins.input/result 带着论证 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 必须是字符串, bytesbytearray 实例表示 integer literal 以基数为单位 base . 或者,文本前面可以有 + or - (with no space in between) and surrounded by whitespace. A base-n literal consists of the digits 0 to n-1, with a to z (or A to Z) having values 10 to 35. The default base is 10. The allowed values are 0 and 2--36. Base-2, -8, and -16 literals can be optionally prefixed with 0b/0B0o/0O0x/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 版更改: 回到 __index__() 如果 __int__() 未定义。

isinstance(object, classinfo)

返回 True 如果 对象 参数是 分类信息 论点,或(直接、间接或 virtual )其子类。如果 对象 不是给定类型的对象,函数总是返回 False .如果 分类信息 是对象类型的元组(或递归的,其他此类元组),返回 True 如果 对象 是任何类型的实例。如果 分类信息 不是类型或类型的元组和此类元组,而是 TypeError 引发异常。

issubclass(class, classinfo)

返回 True 如果 是一个子类(直接、间接或 virtual 的) 分类信息 . 类被认为是它自己的一个子类。 分类信息 可能是类对象的元组,在这种情况下, 分类信息 将被检查。在任何其他情况下,a TypeError 引发异常。

iter(object[, sentinel])

返回一 iterator 对象。根据第二个参数的存在,第一个参数的解释非常不同。没有第二个理由, object 必须是支持迭代协议的集合对象 __iter__() 方法),或者它必须支持序列协议 __getitem__() 方法的整数参数开始于 0 )如果它不支持这些协议中的任何一个, TypeError 提高了。如果第二个参数, 哨兵 ,则给出 object 必须是可调用对象。在这种情况下创建的迭代器将调用 object 对它的每个调用都没有参数 __next__() 方法;如果返回的值等于 哨兵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)

返回对象的长度(项目数)。参数可以是序列(如字符串、字节、元组、列表或范围)或集合(如字典、集合或冻结集合)。

CPython implementation detail: len 加薪 OverflowError 长度大于 sys.maxsize ,如 range(2 ** 100) .

class list([iterable])

而不是作为一个函数, list 实际上是可变序列类型,如 列表序列类型--- list , tuple , range .

locals()

更新并返回表示当前本地符号表的字典。自由变量由返回 locals() 当它在函数块中调用时,而不是在类块中调用时。注意,在模块级, locals()globals() 是同一本字典。

注解

不应修改本词典的内容;更改可能不会影响解释器使用的局部变量和自由变量的值。

map(function, iterable, ...)

返回应用的迭代器 function 到的每一项 可迭代的 产生结果。如果附加 可迭代的 传递参数, function 必须接受如此多的参数,并并行应用于所有iterables中的项。对于多个iterable,当最短的iterable用完时迭代器停止。对于函数输入已经排列成参数元组的情况,请参见 itertools.starmap()

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

返回iterable中的最大项或两个或多个参数中的最大项。

如果提供了一个位置参数,则它应该是 iterable . 返回iterable中最大的项。如果提供了两个或多个位置参数,则返回最大的位置参数。

有两个可选的仅关键字参数。这个 key 参数指定一个单参数排序函数,就像用于 list.sort() . 这个 default 参数指定在提供的ITerable为空时返回的对象。如果iterable为空且 default 未提供,a ValueError 提高了。

如果多个项最大,则函数返回遇到的第一个项。这与其他类型的稳定性保持工具(如 sorted(iterable, key=keyfunc, reverse=True)[0]heapq.nlargest(1, iterable, key=keyfunc) .

3.4 新版功能: 这个 default 仅关键字参数。

在 3.8 版更改: 这个 key 可以是 None .

class memoryview(obj)

返回从给定参数创建的“内存视图”对象。见 内存视图 更多信息。

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

返回iterable中的最小项或两个或多个参数中的最小项。

如果提供了一个位置参数,则它应该是 iterable . 返回iterable中最小的项。如果提供了两个或多个位置参数,则返回位置参数中最小的一个。

有两个可选的仅关键字参数。这个 key 参数指定一个单参数排序函数,就像用于 list.sort() . 这个 default 参数指定在提供的ITerable为空时返回的对象。如果iterable为空且 default 未提供,a ValueError 提高了。

如果多个项最小,则函数返回遇到的第一个项。这与其他类型的稳定性保持工具(如 sorted(iterable, key=keyfunc)[0]heapq.nsmallest(1, iterable, key=keyfunc) .

3.4 新版功能: 这个 default 仅关键字参数。

在 3.8 版更改: 这个 key 可以是 None .

next(iterator[, default])

从中检索下一项 迭代器 通过调用它的 __next__() 方法。如果 default 如果迭代器已用完,则返回,否则返回 StopIteration 提高了。

class object

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

注解

objectnot 有一个 __dict__ ,因此不能将任意属性分配给 object 类。

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

也见 format() 更多信息。

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

正常开放 file 并返回相应的 file object . 如果无法打开文件,则 OSError 提高了。看到了吗 读写文件 有关如何使用此函数的更多示例。

file 是一个 path-like object 提供要打开的文件的路径名(绝对或相对于当前工作目录)或要封装的文件的整数文件描述符。(如果给定了文件描述符,则当返回的I/O对象关闭时,它将关闭,除非 特洛夫德 设置为 False

mode 是指定打开文件的模式的可选字符串。它默认为 'r' 这意味着在文本模式下打开阅读。其他共同的价值观是 'w' 用于写入(如果文件已经存在,则截断文件), 'x' 专为创造和 'a' 用于附加(在 some Unix系统,意味着 all 写入附加到文件结尾,而不考虑当前的查找位置)。在文本模式下,如果 encoding 未指定使用的编码依赖于平台: locale.getpreferredencoding(False) 调用以获取当前区域设置编码。(对于读取和写入原始字节,使用二进制模式并离开 encoding 未指定。)可用模式为:

性格

意义

'r'

打开阅读(默认)

'w'

打开进行写入,首先截断文件

'x'

以独占创建方式打开,如果文件已存在则失败

'a'

打开进行写入,如果文件存在,则附加到文件结尾

'b'

二进制模式

't'

文本模式(默认)

'+'

开放更新(读写)

默认模式为 'r' (打开以阅读文本,同义词为 'rt' ). 模式 'w+''w+b' 打开并截断文件。模式 'r+''r+b' 打开文件时不进行截断。

如中所述 概述 ,python区分二进制和文本I/O。以二进制模式打开的文件(包括 'b'mode 参数)返回内容为 bytes 没有任何解码的对象。在文本模式下(默认,或 't' 包含在 mode 参数),文件的内容返回为 str ,第一次使用与平台相关的编码或使用指定的 encoding 如果给出的话。

允许附加模式字符, 'U' ,不再有任何效果,并被视为已弃用。它以前启用过 universal newlines 在文本模式下,这成为了Python3.0中的默认行为。请参阅 newline 用于进一步详细信息的参数。

注解

python不依赖底层操作系统的文本文件概念;所有的处理都是由python本身完成的,因此与平台无关。

缓冲 是用于设置缓冲策略的可选整数。传递0以关闭缓冲区(仅在二进制模式下允许),传递1以选择行缓冲区(仅在文本模式下可用),传递1以指示固定大小块缓冲区的字节大小。当没有 缓冲 参数为,默认缓冲策略的工作方式如下:

  • 二进制文件以固定大小的块进行缓冲;缓冲区的大小是通过尝试确定底层设备的“块大小”并返回 io.DEFAULT_BUFFER_SIZE . 在许多系统上,缓冲区通常是4096或8192字节长。

  • “交互式”文本文件(用于 isatty() 返回 True )使用线路缓冲。其他文本文件对二进制文件使用上述策略。

encoding 用于解码或编码文件的编码名称。这只能在文本模式中使用。默认编码依赖于平台(无论 locale.getpreferredencoding() 返回),但任何 text encoding 可以使用python支持的。见 codecs 用于支持的编码列表的模块。

errors 是指定如何处理编码和解码错误的可选字符串,不能在二进制模式下使用。提供各种标准错误处理程序(列在 错误处理程序 ,尽管已注册的任何错误处理名称 codecs.register_error() 也是有效的。标准名称包括:

  • 'strict' 养一个 ValueError 出现编码错误时出现异常。默认值为 None 有同样的效果。

  • 'ignore' 忽略错误。请注意,忽略编码错误会导致数据丢失。

  • 'replace' 导致替换标记(例如 '?' )在存在格式错误数据的地方插入。

  • 'surrogateescape' 将在U+DC80到U+DCFF的Unicode专用区域中表示任何不正确的字节作为代码点。当 surrogateescape 写入数据时使用错误处理程序。这对于以未知编码处理文件很有用。

  • 'xmlcharrefreplace' 只有在写入文件时才支持。编码不支持的字符将替换为适当的XML字符引用 &#nnn; .

  • 'backslashreplace' 用Python的反斜杠转义序列替换格式错误的数据。

  • 'namereplace' (也仅在写入时支持)将不支持的字符替换为 \N{{...}} 转义序列。

newline 控制如何 universal newlines 模式工作(仅适用于文本模式)。可能是 None'''\n''\r''\r\n' . 其工作原理如下:

  • 当从流中读取输入时,如果 newlineNone ,启用通用换行模式。输入中的行可以结束于 '\n''\r''\r\n' 它们被翻译成 '\n' 在被送回调用者之前。如果是 '' ,启用了通用换行模式,但行尾会返回给未翻译的调用方。如果它有任何其他合法值,则输入行仅由给定的字符串终止,行尾将返回给未翻译的调用方。

  • 将输出写入流时,如果 newlineNone 任何 '\n' 写入的字符将转换为系统默认行分隔符, os.linesep . 如果 newline'''\n' ,不进行翻译。如果 newline 是否有其他合法价值,任何 '\n' 写入的字符被转换为给定的字符串。

如果 特洛夫德False 并且给出了一个文件描述符而不是文件名,当文件关闭时,底层的文件描述符将保持打开状态。如果给定了文件名 特洛夫德 必须是 True (默认)否则将引发错误。

通过将可调用的 开瓶器 . 然后通过调用 开瓶器 用( fileflags开瓶器 必须返回打开的文件描述符(传递 os.open 作为 开瓶器 产生类似于传递的功能 None

新创建的文件是 non-inheritable .

以下示例使用 dir_fd 的参数 os.open() 函数打开相对于给定目录的文件:

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor

的类型 file object 返回的 open() 功能取决于模式。什么时候? open() 用于以文本模式打开文件 ('w''r''wt''rt' 等等),它返回 io.TextIOBase (具体地说) io.TextIOWrapper )当使用buffering以二进制模式打开文件时,返回的类是 io.BufferedIOBase . 确切的类是不同的:在读二进制模式中,它返回 io.BufferedReader ;在写入二进制和追加二进制模式中,它返回 io.BufferedWriter ,在读/写模式下,它返回 io.BufferedRandom . 当禁用缓冲时,原始流是 io.RawIOBaseio.FileIO ,返回。

另请参见文件处理模块,例如, fileinputio (何处) open() 已声明) osos.pathtempfileshutil .

提出一个 auditing event open 带着论据 filemodeflags .

这个 modeflags 参数可能已从原始调用中修改或推断。

在 3.3 版更改:
  • 这个 开瓶器 已添加参数。

  • 这个 'x' 增加了模式。

  • IOError 以前是被引发的,现在它是 OSError .

  • FileExistsError 如果文件以独占创建模式打开,则现在引发 ('x' )已经存在。

在 3.4 版更改:
  • 文件现在不可继承。

Deprecated since version 3.4, removed in version 3.10: 这个 'U' 模式。

在 3.5 版更改:
  • 如果系统调用被中断且信号处理程序没有引发异常,则函数现在将重试系统调用,而不是引发 InterruptedError 例外(见) PEP 475 理由)。

  • 这个 'namereplace' 添加了错误处理程序。

在 3.6 版更改:
ord(c)

给定一个表示一个Unicode字符的字符串,返回一个表示该字符的Unicode码位的整数。例如, ord('a') 返回整数 97ord('€') (欧元符号)返回 8364 . 这与 chr() .

pow(base, exp[, mod])

返回 base 权力 exp 如果 mod 存在,返回 base 权力 exp ,模 mod (计算效率比 pow(base, exp) % mod )两个论点的形式 pow(base, exp) 相当于使用电源操作器: base**exp .

参数必须具有数字类型。对于混合操作数类型,二进制算术运算符的强制规则适用。为了 int 操作数,除非第二个参数为负,否则结果与操作数具有相同的类型(强制之后);在这种情况下,所有参数都转换为float,并传递float结果。例如, 10**2 收益率 100 ,但是 10**-2 收益率 0.01 .

为了 int 操作数 baseexp 如果 mod 是存在的, mod 还必须是整数类型和 mod 必须为非零。如果 mod 存在和 exp 是否定的, base 必须是相对主要的 mod . 在那种情况下, pow(inv_base, -exp, mod) 返回,在哪里 inv_base 与…相反 basemod .

下面是计算 3897 ::

>>> pow(38, -1, mod=97)
23
>>> 23 * 38 % 97 == 1
True

在 3.8 版更改: 为了 int 操作数,三参数形式 pow 现在允许第二个参数为负,允许计算模逆。

在 3.8 版更改: 允许关键字参数。以前,只支持位置参数。

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

打印 物体 到文本流 file 分开 sep 紧随其后 end . sependfile脸红 如果存在,则必须作为关键字参数提供。

所有非关键字参数都转换为字符串,如 str() 做并写入流,由 sep 紧随其后 end . 两个 sepend 必须是字符串;它们也可以是 None ,表示使用默认值。如果没有 物体 被给予, print() 将只写 end .

这个 file 参数必须是具有 write(string) 方法;如果不存在或 Nonesys.stdout 将被使用。因为打印的参数被转换为文本字符串, print() 不能与二进制模式文件对象一起使用。对于这些,使用 file.write(...) 相反。

输出是否被缓冲通常取决于 file 但是,如果 脸红 关键字参数为true,强制刷新流。

在 3.3 版更改: 增加了 脸红 关键字参数。

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

返回属性属性。

fget 是用于获取属性值的函数。 fset 是用于设置属性值的函数。 fdel 是用于删除属性值的函数。和 doc 为属性创建docstring。

典型的用法是定义托管属性 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 是的实例 Cc.x 将调用getter, c.x = value 将调用setter和 del c.x 删除者。

如果给出的话, doc 将是属性属性的docstring。否则,该属性将复制 fget 的docstring(如果存在)。这使得使用 property() 作为一个 decorator ::

class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

这个 @property 装饰师把 voltage() 方法转换为具有相同名称的只读属性的“getter”,并将docString设置为 电压 得到电流电压。

属性对象具有 gettersetterdeleter 方法可用作修饰程序,该修饰程序创建属性的副本,并将相应的访问器函数设置为修饰函数。这最好用一个例子来解释:

class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

此代码与第一个示例完全等效。确保为附加函数赋予与原始属性相同的名称 (x 在这种情况下)

返回的属性对象还具有属性 fgetfsetfdel 对应于构造函数参数。

在 3.5 版更改: 属性对象的docStrings现在是可写的。

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

而不是作为一个函数, range 实际上是不可变的序列类型,如中所述 范围序列类型--- list , tuple , range .

repr(object)

返回包含对象的可打印表示形式的字符串。对于许多类型,此函数尝试返回一个字符串,当传递给 eval() 否则,表示是一个用尖括号括起来的字符串,其中包含对象类型的名称以及其他信息,通常包括对象的名称和地址。类可以通过定义 __repr__() 方法。

reversed(seq)

返回反向 iterator . seq 必须是具有 __reversed__() 方法或支持序列协议 __len__() 方法与 __getitem__() 方法的整数参数开始于 0

round(number[, ndigits])

返回 四舍五入 纳迪斯 小数点后的精度。如果 纳迪斯 省略或是 None ,返回其输入的最接近的整数。

对于内置类型支持 round() ,值四舍五入到最接近的幂减10的倍数。 纳迪斯 ;如果两个倍数相等,则四舍五入到偶数选项(例如,两者都是 round(0.5)round(-0.5)0round(1.5)2 )任何整数值对于 纳迪斯 (正、零或负)。返回值是一个整数,如果 纳迪斯 被省略或 None . 否则返回值的类型与 .

对于一般的python对象 numberround 代表参加 number.__round__ .

注解

行为 round() 对于浮点数来说,可能会令人惊讶:例如, round(2.675, 2) 给予 2.67 而不是预期的 2.68 . 这不是一个错误:这是大多数小数不能精确表示为浮点的结果。见 浮点运算:问题和限制 更多信息。

class set([iterable])

返回一个新的 set 对象,可以选择元素取自 可迭代的 . set 是一个内置类。见 set集合类型 set , frozenset 有关此类的文档。

对于其他容器,请参见内置的 frozensetlisttupledict 类,以及 collections 模块。

setattr(object, name, value)

这是 getattr() .参数是一个对象、一个字符串和一个任意值。该字符串可以命名现有属性或新属性。只要对象允许,函数就为属性赋值。例如, setattr(x, 'foobar', 123) 等于 x.foobar = 123 .

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

返回A slice 表示由指定的索引集的对象 range(start, stop, step) . 这个 开始step 参数默认为 None . 切片对象具有只读数据属性 startstopstep 只返回参数值(或其默认值)。它们没有其他明确的功能;但是它们被NumPy和其他第三方包使用。当使用扩展索引语法时,也会生成切片对象。例如: a[start:stop:step]a[start:stop, i] . 见 itertools.islice() 对于返回迭代器的备用版本。

sorted(iterable, *, key=None, reverse=False)

从中的项返回新的排序列表 可迭代的 .

有两个可选参数,必须指定为关键字参数。

key 指定一个参数的函数,该参数用于从中的每个元素提取比较键。 可迭代的 (例如, key=str.lower )默认值为 None (直接比较元素)。

reverse 是布尔值。如果设置为 True ,然后对列表元素进行排序,就好像每个比较都是相反的。

使用 functools.cmp_to_key() 转换旧样式 cmp 函数到 key 功能。

内置的 sorted() 保证功能稳定。如果一个排序保证不改变比较相等的元素的相对顺序,那么它是稳定的——这有助于在多个过程中排序(例如,按部门排序,然后按薪等)。

有关排序示例和简短的排序教程,请参见 如何排序 .

@staticmethod

将方法转换为静态方法。

静态方法不接收隐式第一个参数。要声明静态方法,请使用以下习惯用法:

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

这个 @staticmethod 形式是一种功能 decorator --见 函数定义 有关详细信息。

静态方法可以在类上调用(例如 C.f() )或在一个实例上(例如 C().f()

Python中的静态方法与Java或C++中的方法类似。也看到 classmethod() 对于用于创建备用类构造函数的变量。

像所有的装饰师一样,也可以调用给 staticmethod 作为一个正则函数,对它的结果做些什么。这在某些情况下是必需的,在这种情况下,您需要从类体引用一个函数,并且您希望避免自动转换为实例方法。对于这些情况,请使用以下成语:

class C:
    builtin_open = staticmethod(open)

有关静态方法的详细信息,请参见 标准类型层次结构 .

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

返回A str 版本 object . 见 str() 有关详细信息。

str 是内置字符串 class . 有关字符串的常规信息,请参见 文本序列类型--- str .

sum(iterable, /, start=0)

总额 开始 以及 可迭代的 从左到右并返回总数。这个 可迭代的 的项通常是数字,起始值不允许是字符串。

对于某些用例,有很好的替代方法 sum() . 连接字符串序列的首选快速方法是调用 ''.join(sequence) . 要添加具有扩展精度的浮点值,请参见 math.fsum() .要连接一系列iterables,请考虑使用 itertools.chain() .

在 3.8 版更改: 这个 开始 参数不能指定为关键字参数。

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

返回将方法调用委托给的父类或同级类的代理对象 type . 这对于访问类中重写的继承方法非常有用。

这个 object-or-type 确定 method resolution order 被搜查。搜索从 type .

例如,如果 __mro__ 属于 object-or-typeD -> B -> C -> A -> object 以及 typeB 然后 super() 搜索 C -> A -> object .

这个 __mro__ 的属性 object-or-type 列出两种方法使用的方法解析搜索顺序 getattr()super() . 属性是动态的,可以在继承层次结构更新时更改。

如果省略了第二个参数,则返回的超级对象是未绑定的。如果第二个参数是一个对象, isinstance(obj, type) 一定是真的。如果第二个参数是类型, issubclass(type2, type) 必须为true(这对ClassMethods很有用)。

有两个典型的用例用于 超级的 . 在具有单个继承的类层次结构中, 超级的 可以用来引用父类而不显式命名它们,从而使代码更易于维护。这种用法与 超级的 其他编程语言。

第二个用例是在动态执行环境中支持合作的多重继承。这个用例是Python独有的,在静态编译语言或只支持单一继承的语言中找不到。这使得在多个基类实现相同方法的情况下实现“菱形图”成为可能。良好的设计要求此方法在任何情况下都具有相同的调用签名(因为调用顺序是在运行时确定的,因为该顺序适应类层次结构中的更改,并且因为该顺序可以包括运行时之前未知的同级类)。

对于这两个用例,典型的超类调用如下所示:

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

除了方法查找之外, super() 也适用于属性查找。一个可能的用例是调用 descriptors 在父类或兄弟类中。

注意 super() 作为绑定过程的一部分实现,用于显式点式属性查找,例如 super().__getitem__(name) . 它通过实现自己的 __getattribute__() 方法以可预测的顺序搜索支持合作多重继承的类。因此, super() 对于使用语句或运算符(如 super()[name] .

还要注意,除了零参数形式, super() 不限于使用内部方法。双参数形式精确地指定参数并进行适当的引用。零参数表单只能在类定义内工作,因为编译器会填充必要的详细信息,以便正确检索正在定义的类,以及访问普通方法的当前实例。

对于如何使用 super()guide to using super() .

class tuple([iterable])

而不是作为一个函数, tuple 实际上是不可变的序列类型,如中所述 多元组序列类型--- list , tuple , range .

class type(object)
class type(name, bases, dict)

使用一个参数,返回 object . 返回值是一个类型对象,通常与返回的对象相同 object.__class__ .

这个 isinstance() 建议使用内置函数来测试对象的类型,因为它考虑了子类。

使用三个参数,返回一个新的类型对象。这本质上是 class 语句。这个 name 字符串是类名,并成为 __name__ 属性; tuple逐项化基类并成为 __bases__ 属性;以及 dict Dictionary是包含类主体定义的命名空间,它被复制到标准字典中,成为 __dict__ 属性。例如,以下两个语句创建相同的 type 物体:

>>> class X:
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))

也见 类型对象 .

在 3.6 版更改: 亚类 type 这不会覆盖 type.__new__ 不能再使用一个参数窗体获取对象的类型。

vars([object])

返回 __dict__ 模块、类、实例或具有 __dict__ 属性。

模块和实例等对象具有可更新的 __dict__ 属性;但是,其他对象可能对其 __dict__ 属性(例如,类使用 types.MappingProxyType 防止直接更新字典)。

没有参数, vars() 行为像 locals() . 注意,局部变量字典只对读取有用,因为对局部变量字典的更新被忽略。

A TypeError 如果指定了对象但它没有 __dict__ 属性(例如,如果其类定义 __slots__ 属性)。

zip(*iterables, strict=False)

并行迭代多个iterable,生成包含每个iterable项的元组。

例子::

>>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
...     print(item)
...
(1, 'sugar')
(2, 'spice')
(3, 'everything nice')

更正式地说: zip() 返回元组的迭代器,其中 i -该元组包含 i -每个论点中的第个元素都是可接受的。

另一种思考方式 zip() 它把行变成列,把列变成行。这与 transposing a matrix .

zip() 是惰性的:在迭代iterable之前不会处理元素,例如 for 循环或用 list .

要考虑的一件事是 zip() 可能有不同的长度;有时是根据设计,有时是因为准备这些iterable的代码中的错误。Python提供了三种不同的方法来处理此问题:

  • 默认情况下, zip() 当最短的iterable耗尽时停止。它将忽略较长iterable中的剩余项,将结果截断为最短iterable的长度:

    >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
    [(0, 'fee'), (1, 'fi'), (2, 'fo')]
    
  • zip() 通常用于假定iterable长度相等的情况。在这种情况下,建议使用 strict=True 选择。其输出与常规相同 zip() ::

    >>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
    [('a', 1), ('b', 2), ('c', 3)]
    

    与默认行为不同,它检查iterable的长度是否相同,从而提高 ValueError 如果不是:

    >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True))
    Traceback (most recent call last):
      ...
    ValueError: zip() argument 2 is longer than argument 1
    

    没有 strict=True 参数,任何导致不同长度的iterable的bug都将被关闭,可能在程序的另一部分显示为一个很难找到的bug。

  • 较短的iterable可以用一个常量填充,以使所有iterable具有相同的长度。这是由 itertools.zip_longest() .

边缘情况:只有一个可证论点, zip() 返回1元组的迭代器。如果没有参数,则返回一个空迭代器。

提示和技巧:

  • 保证了iTerables从左到右的评价顺序。这使得将数据序列聚类为n个长度组的成语成为可能,使用 zip(*[iter(s)]*n, strict=True) . 这重复了 same 迭代器 n 使每个输出元组的结果 n 调用迭代器。这有将输入划分为n个长度块的效果。

  • zip()* 操作员可用于解压缩列表:

    >>> x = [1, 2, 3]
    >>> y = [4, 5, 6]
    >>> list(zip(x, y))
    [(1, 4), (2, 5), (3, 6)]
    >>> x2, y2 = zip(*zip(x, y))
    >>> x == list(x2) and y == list(y2)
    True
    

在 3.10 版更改: 增加了 strict 争论。

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

注解

这是一个高级函数,在日常的Python编程中不需要它,不像 importlib.import_module() .

此函数由 import 语句。它可以被替换(通过导入 builtins 模块和分配给 builtins.__import__ )为了改变 import 声明,但这样做是 强烈地 不鼓励使用导入挂钩,因为使用导入挂钩通常比较简单(请参见 PEP 302 )为了实现相同的目标,并且不会导致假定使用默认导入实现的代码出现问题。直接使用 __import__() 也不赞成 importlib.import_module() .

函数导入模块 name ,可能使用给定的 globalslocals 确定如何解释包上下文中的名称。这个 来自列表 给出从模块导入的对象或子模块的名称 name . 标准实现不使用 locals 参数,并使用它 globals 仅用于确定 import 语句。

level 指定是使用绝对导入还是相对导入。 0 (默认)表示仅执行绝对导入。的正值 level 指示相对于模块调用的目录要搜索的父目录数 __import__() (见 PEP 328 详细信息)。

name 变量的形式为 package.module ,通常返回顶级包(名称直到第一个点)。 not 模块由命名 name . 但是,当一个非空的 来自列表 参数,模块名为 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() .

在 3.3 版更改: 的负值 level 不再支持(也将默认值更改为0)。

在 3.9 版更改: 当命令行选项 -E-I 正在使用,环境变量 PYTHONCASEOK 现在被忽略。

脚注

1

请注意,解析器只接受Unix风格的行尾约定。如果要从文件中读取代码,请确保使用换行转换模式来转换Windows或Mac样式的换行。