Python 解释器内置了不少函数和类型,您能够在任什么时候候使用它们。如下按字母表顺序列出它们。html
abs
(x)python
返回一个数的绝对值。实参能够是整数或浮点数。若是实参是一个复数,返回它的模。git
all
(iterable)数据库
若是 iterable 的全部元素为真(或迭代器为空),返回 True
。等价于:express
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
来转义。生成的字符串和 Python 2 的 repr()
返回的结果类似。安全
bin
(x)app
将一个整数转变为一个前缀为“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])
返回一个布尔值,True
或者 False
。 x 使用标准的 真值测试过程 来转换。若是 x 是假的或者被省略,返回 False
;其余状况返回 True
。bool
类是 int
的子类(参见 数字类型 --- int, float, complex)。其余类不能继承自它。它只有 False
和 True
两个实例(参见 Boolean Values)。
在 3.7 版更改: x 如今只能做为位置参数。
breakpoint
(*args, **kws)
此函数会在调用时将你陷入调试器中。具体来讲,它调用 sys.breakpointhook()
,直接传递 args
和 kws
。默认状况下, sys.breakpointhook()
调用 pdb.set_trace()
且没有参数。在这种状况下,它纯粹是一个便利函数,所以您没必要显式导入 pdb
且键入尽量少的代码便可进入调试器。可是, sys.breakpointhook()
能够设置为其余一些函数并被 breakpoint()
自动调用,以容许进入你想用的调试器。
3.7 新版功能.
class bytearray
([source[, encoding[, errors]]])
返回一个新的 bytes 数组。 bytearray
类是一个可变序列,包含范围为 0 <= x < 256 的整数。它有可变序列大部分常见的方法,见 可变序列类型 的描述;同时有 bytes
类型的大部分方法,参见 Bytes and Bytearray Operations。
可选形参 source 能够用不一样的方式来初始化数组:
bytearray()
会使用 str.encode()
方法来将 string 转变成 bytes。0 <= x < 256
的整数,它会被用做数组的初始内容。若是没有实参,则建立大小为 0 的数组。
另见 二进制序列类型 --- bytes, bytearray, memoryview 和 Bytearray Objects。
class bytes
([source[, encoding[, errors]]])
返回一个新的“bytes”对象, 是一个不可变序列,包含范围为 0 <= x < 256
的整数。bytes
是 bytearray
的不可变版本 - 它有其中不改变序列的方法和相同的索引、切片操做。
所以,构造函数的实参和 bytearray()
相同。
字节对象还能够用字面值建立,参见 字符串和字节串字面值。
另见 二进制序列类型 --- bytes, bytearray, memoryview,字节对象 和 Bytes and Bytearray Operations。
callable
(object)
若是实参 object 是可调用的,返回 True
,不然返回 False
。若是返回真,调用仍可能会失败;但若是返回假,则调用 object 确定会失败。注意类是可调用的(调用类会返回一个新的实例)。若是实例的类有 __call__()
方法,则它是可调用。
3.2 新版功能: 这个函数一开始在 Python 3.0 被移除了,但在 Python 3.2 被从新加入。
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, ...): ...
@classmethod
这样的形式称为函数的 decorator -- 详情参阅 函数定义。
类方法的调用能够在类上进行 (例如 C.f()
) 也能够在实际上进行 (例如 C().f()
)。 其所属类之外的类实例会被忽略。 若是类方法在其所属类的派生类上调用,则该派生类对象会被做为隐含的第一个参数被传入。
类方法与 C++ 或 Java 中的静态方法不一样。 若是你须要后者,请参阅 staticmethod()
。
想了解更多有关类方法的信息,请参阅 标准类型层级结构 。
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
将会被打印出来。)
可选参数 flags 和 dont_inherit 控制在编译 source 时要用到哪一个 future 语句。 若是二者都未提供(或都为零)则会使用调用 compile()
的代码中有效的 future 语句来编译代码。 若是给出了 flags 参数但没有 dont_inherit (或是为零) 则 flags 参数所指定的 以及那些不管如何都有效的 future 语句会被使用。 若是 dont_inherit 为一个非零整数,则只使用 flags 参数 -- 在调用外围有效的 future 语句将被忽略。
Future 语句使用比特位来指定,多个语句能够经过按位或来指定。具体特性的比特位能够经过 __future__
模块中的 _Feature
类的实例的 compiler_flag
属性来得到。
optimize 实参指定编译器的优化级别;默认值 -1
选择与解释器的 -O
选项相同的优化级别。显式级别为 0
(没有优化;__debug__
为真)、1
(断言被删除, __debug__
为假)或 2
(文档字符串也被删除)。
若是编译的源码不合法,此函数会触发 SyntaxError
异常;若是源码包含 null 字节,则会触发 ValueError
异常。
若是您想分析 Python 代码的 AST 表示,请参阅 ast.parse()
。
注解
在 'single'
或 'eval'
模式编译多行代码字符串时,输入必须以致少一个换行符结尾。 这使 code
模块更容易检测语句的完整性。
警告
若是编译足够大或者足够复杂的字符串成 AST 对象时,Python 解释器会由于 Python AST 编译器的栈深度限制而奔溃。
在 3.2 版更改: 容许使用 Windows 和 Mac 的换行符。在 'exec'
模式再也不须要以换行符结尾。增长了optimize 形参。
在 3.5 版更改: 以前 source 中包含 null 字节的话会触发 TypeError
异常。
class complex
([real[, imag]])
返回值为 real + imag*1j 的复数,或将字符串或数字转换为复数。若是第一个形参是字符串,则它被解释为一个复数,而且函数调用时必须没有第二个形参。第二个形参不能是字符串。每一个实参均可以是任意的数值类型(包括复数)。若是省略了 imag,则默认值为零,构造函数会像 int
和 float
同样进行数值转换。若是两个实参都省略,则返回 0j
。
注解
当从字符串转换时,字符串在 +
或 -
的周围必须不能有空格。例如 complex('1+2j')
是合法的,但complex('1 + 2j')
会触发 ValueError
异常。
数字类型 --- int, float, complex 描述了复数类型。
在 3.6 版更改: 您可使用下划线将代码文字中的数字进行分组。
delattr
(object, name)
setattr()
相关的函数。实参是一个对象和一个字符串。该字符串必须是对象的某个属性。若是对象容许,该函数将删除指定的属性。例如 delattr(x, 'foobar')
等价于 del x.foobar
。
class dict
(**kwarg)
class dict
(mapping, **kwarg)
class dict
(iterable, **kwarg)
建立一个新的字典。dict
对象是一个字典类。参见 dict
和 映射类型 --- dict 了解这个类。
其余容器类型,请参见内置的 list
、set
和 tuple
类,以及 collections
模块。
dir
([object])
若是没有实参,则返回当前本地做用域中的名称列表。若是有实参,它会尝试返回该对象的有效属性列表。
若是对象有一个名为 __dir__()
的方法,那么该方法将被调用,而且必须返回一个属性列表。这容许实现自定义 __getattr__()
或 __getattribute__()
函数的对象可以自定义 dir()
来报告它们的属性。
若是对象不提供 __dir__()
,这个函数会尝试从对象已定义的 __dict__
属性和类型对象收集信息。结果列表并不老是完整的,若是对象有自定义 __getattr__()
,那结果可能不许确。
默认的 dir()
机制对不一样类型的对象行为不一样,它会试图返回最相关而不是最全的信息:
返回的列表按字母表排序。例如:
>>> import struct >>> dir() # show the names in the module namespace # doctest: +SKIP ['__builtins__', '__name__', 'struct'] >>> dir(struct) # show the names in the struct module # doctest: +SKIP ['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=None, locals=None)
实参是一个字符串,以及可选的 globals 和 locals。globals 实参必须是一个字典。locals 能够是任何映射对象。
expression 参数会做为一个 Python 表达式(从技术上说是一个条件列表)被解析并求值,使用 globals 和 locals 字典做为全局和局部命名空间。 若是 globals 字典存在且不包含以 __builtins__
为键的值,则会在解析 expression 以前插入以此为键的对内置模块 builtins
的字典的引用。 这意味着 expression 一般具备对标准 builtins
模块的彻底访问权限且受限的环境会被传播。 若是省略 locals 字典则其默认值为 globals 字典。 若是两个字典同时省略,表达式会在 eval()
被调用的环境中执行。 返回值为表达式求值的结果。 语法错误将做为异常被报告。 例如:
>>> x = 1 >>> eval('x+1') 2
这个函数也能够用来执行任何代码对象(如 compile()
建立的)。这种状况下,参数是代码对象,而不是字符串。若是编译该对象时的 mode 实参是 'exec'
那么 eval()
返回值为 None
。
提示: exec()
函数支持动态执行语句。 globals()
和 locals()
函数各自返回当前的全局和本地字典,所以您能够将它们传递给 eval()
或 exec()
来使用。
另外能够参阅 ast.literal_eval()
,该函数能够安全执行仅包含文字的表达式字符串。
exec
(object[, globals[, locals]])
这个函数支持动态执行 Python 代码。object 必须是字符串或者代码对象。若是是字符串,那么该字符串将被解析为一系列 Python 语句并执行(除非发生语法错误)。[1] 若是是代码对象,它将被直接执行。在任何状况下,被执行的代码都须要和文件输入同样是有效的(见参考手册中关于文件输入的章节)。请注意即便在传递给 exec()
函数的代码的上下文中,return
和 yield
语句也不能在函数定义以外使用。该函数返回值是 None
。
不管哪一种状况,若是省略了可选参数,代码将在当前范围内执行。若是提供了 globals 参数,就必须是字典类型,并且会被用做全局和本地变量。若是同时提供了 globals 和 locals 参数,它们分别被用做全局和本地变量。若是提供了 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 foritem in iterable if function(item))
;function 是 None
的时候为 (item for item in iterable if item)
。
请参阅 itertools.filterfalse()
了解,只有 function 返回 false 时才选取 iterable 中元素的补充函数。
class float
([x])
返回从数字或字符串 x 生成的浮点数。
若是实参是字符串,则它必须是包含十进制数字的字符串,字符串前面能够有符号,以前也能够有空格。可选的符号有 '+'
和 '-'
; '+'
对建立的值没有影响。实参也能够是 NaN(非数字)、正负无穷大的字符串。确切地说,除去首尾的空格后,输入必须遵循如下语法:
sign ::= "+" | "-" infinity ::= "Infinity" | "inf" nan ::= "nan" numeric_value ::= | | numeric_string ::= [] floatnumberinfinitynansignnumeric_value
这里, floatnumber
是 Python 浮点数的字符串形式,详见 浮点数字面值。字母大小写均可以,例如,“inf”、“Inf”、“INFINITY”、“iNfINity” 均可以表示正无穷大。
另外一方面,若是实参是整数或浮点数,则返回具备相同值(在 Python 浮点精度范围内)的浮点数。若是实参在 Python 浮点精度范围外,则会触发 OverflowError
。
对于通常的 Python 对象 x
, float(x)
指派给 x.__float__()
。
若是没有实参,则返回 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 如今只能做为位置参数。
format
(value[, format_spec])
将 value 转换为 format_spec 控制的“格式化”表示。format_spec 的解释取决于 value 实参的类型,可是大多数内置类型使用标准格式化语法:Format Specification Mini-Language。
默认的 format_spec 是一个空字符串,它一般和调用 str(value)
的结果相同。
调用 format(value, format_spec)
会转换成 type(value).__format__(value, format_spec)
,因此实例字典中的 __format__()
方法将不会调用。若是搜索到 object
有这个方法但 format_spec 不为空,format_spec 或返回值不是字符串,会触发 TypeError
异常。
在 3.4 版更改: 当 format_spec 不是空字符串时, object().__format__(format_spec)
会触发 TypeError
。
class frozenset
([iterable])
返回一个新的 frozenset
对象,它包含可选参数 iterable 中的元素。 frozenset
是一个内置的类。有关此类的文档,请参阅 frozenset
和 集合类型 --- set, frozenset。
请参阅内建的 set
、list
、tuple
和 dict
类,以及 collections
模块来了解其它的容器。
getattr
(object, name[, default])
返回对象命名属性的值。name 必须是字符串。若是该字符串是对象的属性之一,则返回该属性的值。例如, getattr(x, 'foobar')
等同于 x.foobar
。若是指定的属性不存在,且提供了 default 值,则返回它,不然触发 AttributeError
。
globals
()
返回表示当前全局符号表的字典。这老是当前模块的字典(在函数或方法中,不是调用它的模块,而是定义它的模块)。
hasattr
(object, name)
该实参是一个对象和一个字符串。若是字符串是对象的属性之一的名称,则返回 True
,不然返回 False
。(此功能是经过调用 getattr(object, name)
看是否有 AttributeError
异常来实现的。)
hash
(object)
返回该对象的哈希值(若是它有的话)。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值(即便它们类型不一样,如 1 和 1.0)。
注解
若是对象实现了本身的 __hash__()
方法,请注意,hash()
根据机器的字长来截断返回值。另请参阅__hash__()
。
help
([object])
启动内置的帮助系统(此函数主要在交互式中使用)。若是没有实参,解释器控制台里会启动交互式帮助系统。若是实参是一个字符串,则在模块、函数、类、方法、关键字或文档主题中搜索该字符串,并在控制台上打印帮助信息。若是实参是其余任意对象,则会生成该对象的帮助页。
请注意若是在函数的形参列表中出现了斜杠 (/),则它在发起调用 help()
的时候意味着斜杠以前的均为仅限位置形参。 更多相关信息,请参阅 有关仅限位置形参的 FAQ 条目。
该函数经过 site
模块加入到内置命名空间。
在 3.4 版更改: pydoc
和 inspect
的变动使得可调用对象的签名信息更加全面和一致。
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')
另见 format()
获取更多信息。
另请参阅 int()
将十六进制字符串转换为以 16 为基数的整数。
注解
若是要获取浮点数的十六进制字符串形式,请使用 float.hex()
方法。
id
(object)
返回对象的“标识值”。该值是一个整数,在此对象的生命周期中保证是惟一且恒定的。两个生命期不重叠的对象可能具备相同的 id()
值。
CPython implementation detail: This is the address of the object in memory.
input
([prompt])
若是存在 prompt 实参,则将其写入标准输出,末尾不带换行符。接下来,该函数从输入中读取一行,将其转换为字符串(除了末尾的换行符)并返回。当读取到 EOF 时,则触发 EOFError
。例如:
>>>
>>> s = input('--> ') --> Monty Python's Flying Circus >>> s "Monty Python's Flying Circus"
若是加载了 readline
模块,input()
将使用它来提供复杂的行编辑和历史记录功能。
class int
([x])
class int
(x, base=10)
返回一个使用数字或字符串 x 生成的整数对象,或者没有实参的时候返回 0
。若是 x 定义了 __int__()
,int(x)
返回 x.__int__()
。若是 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。二、八、16 进制的数字能够在代码中用 0b
/0B
、 0o
/0O
、 0x
/0X
前缀来表示。进制为 0 将安照代码的字面量来精确解释,最后的结果会是 二、八、十、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 如今只能做为位置参数。
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)
返回对象的长度(元素个数)。实参能够是序列(如 string、bytes、tuple、list 或 range 等)或集合(如 dictionary、set 或 frozen set 等)。
class list
([iterable])
除了是函数,list
也是可变序列类型,详情请参阅 列表 和 序列类型 --- list, tuple, range。
locals
()
更新并返回表示当前本地符号表的字典。 在函数代码块但不是类代码块中调用 locals()
时将返回自由变量。 请注意在模块层级上,locals()
和 globals()
是同一个字典。
注解
不要更改此字典的内容;更改不会影响解释器使用的局部变量或自由变量的值。
map
(function, iterable, ...)
产生一个将 function 应用于迭代器中全部元素并返回结果的迭代器。若是传递了额外的 iterable 实参,function 必须接受相同个数的实参,并使用全部迭代器中并行获取的元素。当有多个迭代器时,最短的迭代器耗尽则整个迭代结束。若是函数的输入已是元组实参,请参阅 itertools.starmap()
。
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)
保持一致。
3.4 新版功能: keyword-only 实参 default 。
memoryview
(obj)
返回由给定实参建立的“内存视图”对象。有关详细信息,请参阅 Memory Views。
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)
保持一致。
3.4 新版功能: keyword-only 实参 default 。
next
(iterator[, default])
经过调用 iterator 的 __next__()
方法获取下一个元素。若是迭代器耗尽,则返回给定的 default,若是没有默认值则触发 StopIteration
。
class object
返回一个没有特征的新对象。object
是全部类的基类。它具备全部 Python 类实例的通用方法。这个函数不接受任何实参。
注解
因为 object
没有 __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 对象关闭而关闭,除非 closefd 被设为 False
。)
mode 是一个可选字符串,用于指定打开文件的模式。默认值是 'r'
,这意味着它以文本模式打开并读取。其余常见模式有:写入 'w'
(截断已经存在的文件);排它性建立 'x'
;追加写 'a'
(在 一些 Unix 系统上,不管当前的文件指针在什么位置,全部 写入都会追加到文件末尾)。在文本模式,若是 encoding 没有指定,则根据平台来决定使用的编码:使用 locale.getpreferredencoding(False)
来获取本地编码。(要读取和写入原始字节,请使用二进制模式并不要指定 encoding。)可用的模式有:
字符 | 意义 |
---|---|
'r' |
读取(默认) |
'w' |
写入,并先截断文件 |
'x' |
排它性建立,若是文件已存在则失败 |
'a' |
写入,若是文件存在则在末尾追加 |
'b' |
二进制模式 |
't' |
文本模式(默认) |
'+' |
更新磁盘文件(读取并写入) |
默认的模式是 'r'
(打开并读取文本,同 'rt'
)。对于二进制写入, 'w+b'
模式打开并把文件截断成 0 字节; 'r+b'
则不会截断。
正如在 概述 中提到的,Python区分二进制和文本I/O。以二进制模式打开的文件(包括 mode 参数中的 'b'
)返回的内容为 bytes`对象,不进行任何解码。在文本模式下(默认状况下,或者在 *mode* 参数中包含 `
't'` )时,文件内容返回为 str
,首先使用指定的 encoding (若是给定)或者使用平台默认的的字节编码解码。
此外还容许使用一个模式字符 'U'
,该字符已再也不具备任何效果,并被视为已弃用。 以前它会在文本模式中启用 universal newlines,这在 Python 3.0 中成为默认行为。 请参阅 newline 形参的文档了解更多细节。
注解
Python不依赖于底层操做系统的文本文件概念;全部处理都由Python自己完成,所以与平台无关。
buffering 是一个可选的整数,用于设置缓冲策略。传递0以切换缓冲关闭(仅容许在二进制模式下),1选择行缓冲(仅在文本模式下可用),而且>1的整数以指示固定大小的块缓冲区的大小(以字节为单位)。若是没有给出 buffering 参数,则默认缓冲策略的工做方式以下:
io.DEFAULT_BUFFER_SIZE
。在许多系统上,缓冲区的长度一般为4096或8192字节。isatty()
返回 True
的文件)使用行缓冲。其余文本文件使用上述策略用于二进制文件。encoding 是用于解码或编码文件的编码的名称。这应该只在文本模式下使用。默认编码是依赖于平台的(不 管 locale.getpreferredencoding()
返回何值),但可使用任何Python支持的 text encoding 。有关支持的编码列表,请参阅 codecs
模块。
errors 是一个可选的字符串参数,用于指定如何处理编码和解码错误 - 这不能在二进制模式下使用。可使用各类标准错误处理程序(列在 Error Handlers ),可是使用 codecs.register_error()
注册的任何错误处理名称也是有效的。标准名称包括:
'strict'
会引起 ValueError
异常。 默认值 None
具备相同的效果。'ignore'
忽略错误。请注意,忽略编码错误可能会致使数据丢失。'replace'
会将替换标记(例如 '?'
)插入有错误数据的地方。'surrogateescape'
将表示任何不正确的字节做为Unicode专用区中的代码点,范围从U+DC80到U+DCFF。当在写入数据时使用 surrogateescape
错误处理程序时,这些私有代码点将被转回到相同的字节中。这对于处理未知编码的文件颇有用。'xmlcharrefreplace'
。编码不支持的字符将替换为相应的XML字符引用 &#nnn;
。'backslashreplace'
用Python的反向转义序列替换格式错误的数据。'namereplace'
(也只在编写时支持)用 \N{...}
转义序列替换不支持的字符。newline 控制 universal newlines 模式如何生效(它仅适用于文本模式)。它能够是 None
,''
,'\n'
,'\r'
和 '\r\n'
。它的工做原理:
None
,则启用通用换行模式。输入中的行能够以 '\n'
,'\r'
或 '\r\n'
结尾,这些行被翻译成 '\n'
在返回呼叫者以前。若是它是 ''
,则启用通用换行模式,但行结尾将返回给调用者未翻译。若是它具备任何其余合法值,则输入行仅由给定字符串终止,而且行结尾将返回给未调用的调用者。None
,则写入的任何 '\n'
字符都将转换为系统默认行分隔符 os.linesep
。若是 newline 是 ''
或 '\n'
,则不进行翻译。若是 newline 是任何其余合法值,则写入的任何 '\n'
字符将被转换为给定的字符串。若是 closefd 是 False
而且给出了文件描述符而不是文件名,那么当文件关闭时,底层文件描述符将保持打开状态。若是给出文件名则 closefd 必须为 True
(默认值),不然将引起错误。
能够经过传递可调用的 opener 来使用自定义开启器。而后经过使用参数( file,flags )调用 opener 得到文件对象的基础文件描述符。 opener 必须返回一个打开的文件描述符(使用 os.open
as opener 时与传递 None
的效果相同)。
新建立的文件是 不可继承的。
下面的示例使用 os.open()
函数的 dir_fd 的形参,从给定的目录中用相对路径打开文件:
>>>
>>> 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
open()
函数所返回的 file object 类型取决于所用模式。 当使用 open()
以文本模式 ('w'
, 'r'
, 'wt'
, 'rt'
等) 打开文件时,它将返回 io.TextIOBase
(特别是 io.TextIOWrapper
) 的一个子类。 当使用缓冲以二进制模式打开文件时,返回的类是 io.BufferedIOBase
的一个子类。 具体的类会有多种:在只读的二进制模式下,它将返回 io.BufferedReader
;在写入二进制和追加二进制模式下,它将返回 io.BufferedWriter
,而在读/写模式下,它将返回 io.BufferedRandom
。 当禁用缓冲时,则会返回原始流,即 io.RawIOBase
的一个子类 io.FileIO
。
另请参阅文件操做模块,例如 fileinput
、io
(声明了 open()
)、os
、os.path
、tempfile
和 shutil
。
在 3.3 版更改:
- 增长了 opener 形参。
- 增长了
'x'
模式。- 过去触发的
IOError
,如今是OSError
的别名。- 若是文件已存在但使用了排它性建立模式(
'x'
),如今会触发FileExistsError
。
在 3.4 版更改:
- 文件如今禁止继承。
Deprecated since version 3.4, will be removed in version 4.0: 'U'
模式。
在 3.5 版更改:
- 若是系统调用被中断,但信号处理程序没有触发异常,此函数如今会重试系统调用,而不是触发
InterruptedError
异常(缘由详见 PEP 475)。- 增长了
'namereplace'
错误处理接口。
在 3.6 版更改:
- 增长对实现了
os.PathLike
对象的支持。- 在 Windows 上,打开一个控制台缓冲区将返回
io.RawIOBase
的子类,而不是io.FileIO
。
ord
(c)
对表示单个 Unicode 字符的字符串,返回表明它 Unicode 码点的整数。例如 ord('a')
返回整数 97
, ord('€')
(欧元符合)返回 8364
。这是 chr()
的逆函数。
pow
(x, y[, z])
返回 x 的 y 次幂;若是 z 存在,则对 z 取余(比直接 pow(x, y) % z
计算更高效)。两个参数形式的 pow(x,y)
等价于幂运算符: x**y
。
参数必须为数值类型。 对于混用的操做数类型,则适用二元算术运算符的类型强制转换规则。 对于 int
操做数,结果具备与操做数相同的类型(转换后),除非第二个参数为负值;在这种状况下,全部参数将被转换为浮点数并输出浮点数结果。 例如,10**2
返回 100
,但 10**-2
返回 0.01
。 若是第二个参数为负值,则第三个参数必须省略。 若是存在 z,则 x 和 y 必须为整数类型,且 y 必须为非负数。
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 关键字参数为真值,流会被强制刷新。
在 3.3 版更改: 增长了 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): """Get the current voltage.""" 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): """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
。)
返回的特征属性对象一样具备与构造器参数相对应的属性 fget
, fset
和 fdel
。
在 3.5 版更改: 特性属性对象的文档字符串如今是可写的。
range
(stop)
range
(start, stop[, step])
虽然被称为函数,但 range
其实是一个不可变的序列类型,参见在 range 对象 与 序列类型 --- list, tuple, 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
。 这不算是程序错误:这一结果是因为大多数十进制小数实际上都不能以浮点数精确地表示。 请参阅浮点算术:争议和限制 了解更多信息。
class set
([iterable])
返回一个新的 set
对象,能够选择带有从 iterable 获取的元素。 set
是一个内置类型。 请查看 set
和 集合类型 --- set, frozenset 获取关于这个类的文档。
有关其余容器请参看内置的 frozenset
, list
, tuple
和 dict
类,以及 collections
模块。
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]
。 请参阅 itertools.islice()
了解返回迭代器的一种替代版本。
sorted
(iterable, *, key=None, reverse=False)
根据 iterable 中的项返回一个新的已排序列表。
具备两个可选参数,它们都必须指定为关键字参数。
key 指定带有单个参数的函数,用于从 iterable 的每一个元素中提取用于比较的键 (例如 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')
返回一个 str
版本的 object 。有关详细信息,请参阅 str()
。
str
是内置字符串 class 。更多关于字符串的信息查看 文本序列类型 --- str。
sum
(iterable[, start])
从 start 开始自左向右对 iterable 中的项求和并返回总计值。 start 默认为 0
。 iterable 的项一般为数字,开始值则不容许为字符串。
对某些用例来讲,存在 sum()
的更好替代。 拼接字符串序列的更好更快方式是调用 ''.join(sequence)
。 要以扩展精度对浮点值求和,请参阅 math.fsum()
。 要拼接一系列可迭代对象,请考虑使用 itertools.chain()
。
super
([type[, object-or-type]])
返回一个代理对象,它会将方法调用委托给 type 指定的父类或兄弟类。 这对于访问已在类中被重载的继承方法颇有用。 搜索顺序与 getattr()
所使用的相同,只是 type 指定的类型自己会被跳过。
type 的 __mro__
属性列出了 getattr()
和 super()
所使用的方法解析顺序。 该属性是动态的,能够在继承层级结构更新的时候任意改变。
若是省略第二个参数,则返回的超类对象是未绑定的。 若是第二个参数为一个对象,则 isinstance(obj,type)
必须为真值。 若是第二个参数为一个类型,则 issubclass(type2, type)
必须为真值(这适用于类方法)。
super 有两个典型用例。 在具备单继承的类层级结构中,super 可用来引用父类而没必要显式地指定它们的名称,从而令代码更易维护。 这种用法与其余编程语言中 super 的用法很是类似。
第二个用例是在动态执行环境中支持协做多重继承。 此用例为 Python 所独有,在静态编译语言或仅支持单继承的语言中是不存在的。 这使得实现“菱形图”成为可能,在这时会有多个基类实现相同的方法。 好的设计强制要求这种方法在每一个状况下具备相同的调用签名(由于调用顺序是在运行时肯定的,也由于该顺序要适应类层级结构的更改,还由于该顺序可能包含在运行时以前未知的兄弟类)。
对于以上两个用例,典型的超类调用看起来是这样的:
class C(B): def method(self, arg): super().method(arg) # This does the same thing as: # super(C, self).method(arg)
请注意 super()
是做为显式加点属性查找的绑定过程的一部分来实现的,例如 super().__getitem__(name)
。 它作到这一点是经过实现本身的 __getattribute__()
方法,这样就能以可预测的顺序搜索类,而且支持协做多重继承。 对应地,super()
在像 super()[name]
这样使用语句或操做符进行隐式查找时则未被定义。
还要注意的是,除了零个参数的形式之外,super()
并不限于在方法内部傅和。 两个参数的形式明确指定参数并进行相应的引用。 零个参数的形式仅适用于类定义内部,由于编译器须要填入必要的细节以正确地检索到被定义的类,还须要为普通访问当前实例。
对于有关如何使用 super()
来如何设计协做类的实用建议,请参阅 使用 super() 的指南。
tuple
([iterable])
虽然被称为函数,但 tuple
其实是一个不可变的序列类型,参见在 元组 与 序列类型 --- list, tuple, range 中的文档说明。
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))
另请参阅 Type 对象。
在 3.6 版更改: type
的子类若是未重载 type.__new__
,将再也不能使用一个参数的形式来获取对象的类型。
vars
([object])
返回模块、类、实例或任何其它具备 __dict__
属性的对象的 __dict__
属性。
模块和实例这样的对象具备可更新的 __dict__
属性;可是,其它对象的 __dict__
属性可能会设为限制写入(例如,类会使用 types.MappingProxyType
来防止直接更新字典)。
不带参数时,vars()
的行为相似 locals()
。 请注意,locals 字典仅对于读取起做用,由于对 locals 字典的更新会被忽略。
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
语句的语义,可是 强烈 不建议这样作,由于使用导入钩子 (参见 PEP 302) 一般更容易实现一样的目标,而且不会致使代码问题,由于许多代码都会假定所用的是默认实现。 一样也不建议直接使用 __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()
在 3.3 版更改: Negative values for level are no longer supported (which also changes the default value to 0).
脚注
[1] | 解析器只接受 Unix 风格的行结束符。若是您从文件中读取代码,请确保用换行符转换模式转换 Windows 或 Mac 风格的换行符。 |