Skip to main content

2. 内置函数

Python解释器有许多内置的函数和类型,它们总是可用的。它们按字母顺序列在这里。

内置函数

abs()

dict()

help()

min()

setattr()

all()

dir()

hex()

next()

slice()

any()

divmod()

id()

object()

sorted()

ascii()

enumerate()

input()

oct()

staticmethod()

bin()

eval()

int()

open()

str()

bool()

exec()

isinstance()

ord()

sum()

bytearray()

filter()

issubclass()

pow()

super()

bytes()

float()

iter()

print()

tuple()

callable()

format()

len()

property()

type()

chr()

frozenset()

list()

range()

vars()

classmethod()

getattr()

locals()

repr()

zip()

compile()

globals()

map()

reversed()

__import__()

complex()

hasattr()

max()

round()

 

delattr()

hash()

memoryview()

set()

 
abs(x)

返回数字的绝对值。参数可以是整数或浮点数。如果参数是复数,则返回其大小。

all(iterable)

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

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

如果 iterable 的任何元素为真,则返回 True。如果iterable为空,则返回 False。相当于:

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

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

bin(x)

将整数转换为二进制字符串。结果是一个有效的Python表达式。如果 x 不是Python int 对象,它必须定义一个返回整数的 __index__() 方法。

class bool([x])

返回布尔值,即 TrueFalse 之一。 x 使用标准 真实测试程序 转化。如果 x 为假或省略,则返回 False;否则返回 Truebool 类是 int 的子类(参见 数字类型— int,float,complex)。它不能进一步子类化。它的唯一实例是 FalseTrue (参见 布尔值)。

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

返回一个新的字节数组。 bytearray 类是在0 <= x <256范围内的整数的可变序列。它具有在 可变序列类型 中描述的大多数可变序列的常见方法以及 bytes 类型具有的大多数方法,参见 字节和Bytearray操作

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

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

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

  • 如果它是符合 buffer 接口的对象,则将使用该对象的只读缓冲区来初始化bytes数组。

  • 如果它是 iterable,它必须是在 0 <= x < 256 范围内的整数的可迭代,其被用作阵列的初始内容。

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

参见 二进制序列类型— bytes,bytearray,memoryviewBytearray对象

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

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

因此,构造函数参数被解释为 bytearray()

字节对象也可以用文字创建,请参阅 字符串和字节字面值

参见 二进制序列类型— bytes,bytearray,memoryview字节字节和Bytearray操作

callable(object)

如果 object 参数出现可调,则返回 True,否则返回 False。如果这返回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中的0x10 )。如果 i 在该范围之外,ValueError 将被提出。

classmethod(function)

返回 function 的类方法。

类方法接收类作为隐式第一个参数,就像实例方法接收实例一样。要声明一个类方法,使用这个成语:

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 参数指定必须编译什么样的代码;它可以是 'exec',如果 source 由语句序列组成,'eval' 如果它由单个表达式组成,或 'single' 由单个交互语句组成(在后一种情况下,评估为除 None 之外的其他语句的表达式语句将被打印)。

可选参数 flagsdont_inherit 控制哪些未来语句(见 PEP 236)影响 source 的编译。如果两者都不存在(或两者都为零),则使用在调用 compile() 的代码中有效的那些未来语句来编译代码。如果给出了 flags 自变量,并且 dont_inherit 不是(或为零),则除了将被使用的那些以外,还使用由 flags 自变量指定的未来语句。如果 dont_inherit 是一个非零整数,那么 flags 参数是它 - 忽略对调用编译的未来语句。

未来语句由位指定,它们可以按位或运算在一起以指定多个语句。指定给定特征所需的位字段可以作为 __future__ 模块中 _Feature 实例上的 compiler_flag 属性找到。

参数 optimize 指定编译器的优化级别; -1 的默认值选择由 -O 选项给定的解释器的优化级别。显式级别是 0 (无优化; __debug__ 为真),1 (声明被删除,__debug__ 为假)或 2 (docstrings也被删除)。

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

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

注解

'single''eval' 模式下编译具有多行代码的字符串时,输入必须至少以一个换行符结束。这是为了便于检测 code 模块中不完整和完整的语句。

在 3.2 版更改: 允许使用Windows和Mac换行符。在 'exec' 模式中输入也不必在换行符中结束。添加了 optimize 参数。

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

class complex([real[, imag]])

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

对于其他容器,请参阅内置的 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)

返回一个枚举对象。 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 可以是任何映射对象。

expression 参数作为Python表达式(技术上来说,条件列表)使用 globalslocals 字典作为全局和局部命名空间进行解析和计算。如果 globals 字典存在且缺少’__builtins__’,则在解析 expression 之前将当前全局变量复制到 globals 中。这意味着 expression 通常具有对标准 builtins 模块的完全访问,并且传播受限制的环境。如果省略 locals 字典,它将默认为 globals 字典。如果省略这两个字典,则在调用 eval() 的环境中执行表达式。返回值是计算表达式的结果。语法错误报告为异常。例:

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

此函数也可用于执行任意代码对象(例如由 compile() 创建的代码对象)。在这种情况下,传递一个代码对象而不是字符串。如果代码对象已经用 'exec' 作为 mode 参数编译,eval() 的返回值将是 None

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

有关可以安全地评估表达式只包含字面量的字符串的函数,请参阅 ast.literal_eval()

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

此函数支持动态执行Python代码。 object 必须是字符串或代码对象。如果它是一个字符串,该字符串被解析为一套Python语句,然后执行(除非语法错误发生)。 [1] 如果它是一个代码对象,它只是简单地执行。在所有情况下,执行的代码应该作为文件输入有效(参见“参考手册”中的“文件输入”部分)。请注意,即使在传递给 exec() 函数的代码上下文中,returnyield 语句也不能在函数定义之外使用。返回值为 None

在所有情况下,如果省略可选部分,则代码在当前作用域中执行。如果只提供 globals,它必须是一个字典,它将用于全局变量和局部变量。如果给出 globalslocals,它们分别用于全局变量和局部变量。如果提供,locals 可以是任何映射对象。记住,在模块级别,全局和本地是同一个字典。如果exec获取两个单独的对象作为 globalslocals,代码将被执行,就像它嵌入在类定义中。

如果 globals 字典不包含密钥 __builtins__ 的值,则在该密钥下插入对内置模块 builtins 的字典的引用。这样,您可以通过将自己的 __builtins__ 字典插入 globals,然后将其传递给 exec(),来控制内置程序可用于执行的代码。

注解

内置函数 globals()locals() 分别返回当前的全局和本地字典,这对于传递给 exec() 的第二个和第三个参数是有用的。

注解

默认 locals 的作用如下面的功能 locals() 所述:不应尝试修改默认的 locals 字典。传递一个明确的 locals 字典,如果你需要看到代码在 locals 函数 exec() 函数返回后的效果。

filter(function, iterable)

function 返回true的 iterable 的那些元素构造一个迭代器。 iterable 可以是序列,支持迭代的容器或迭代器。如果 functionNone,则假定身份函数,即,删除 iterable 的所有假的元素。

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

对于返回 function 返回false的 iterable 的元素的补充函数,请参阅 itertools.filterfalse()

class float([x])

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

如果参数是字符串,它应该包含一个十进制数,可选地前面加一个符号,并且可选地嵌入空格。可选符号可以是 '+''-''+' 符号对生成的值没有影响。参数还可以是表示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浮点的范围之外,则会引发 OverflowError

对于一般的Python对象 xfloat(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 版更改: 允许使用下划线对代码文字中的数字进行分组。

format(value[, format_spec])

value 转换为由 format_spec 控制的“格式化”表示。 format_spec 的解释将取决于 value 参数的类型,但是存在由大多数内置类型使用的标准格式化语法:格式规范Mini-Language

默认的 format_spec 是一个空字符串,通常给出与调用 str(value) 相同的效果。

format(value, format_spec) 的调用将被转换为 type(value).__format__(value, format_spec),在搜索值的 __format__() 方法时会绕过实例字典。如果方法搜索达到 objectformat_spec 非空,或者 format_spec 或返回值不是字符串,则会引发 TypeError 异常。

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

class frozenset([iterable])

返回一个新的 frozenset 对象,可选择包含从 iterable 中取得的元素。 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)

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

注解

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

help([object])

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

此函数由 site 模块添加到内置命名空间中。

在 3.4 版更改: pydocinspect 的变化意味着报告的可信标记的签名现在更全面和一致。

hex(x)

将整数转换为以“0x”为前缀的小写十六进制字符串,例如:

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

如果x不是一个Python int 对象,它必须定义一个__index__()方法返回一个整数。

另请参见 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=0)
class int(x, base=10)

返回一个从数字或字符串 x 构造的整数对象,如果没有给出参数,则返回 0。如果 x 是数字,返回 x.__int__()。对于浮点数,这将截断到零。

如果 x 不是数字或者如果给出 base,则 x 必须是表示基数 base 中的 整数文字 的字符串,bytesbytearray 实例。可选地,文字可以在 +- (之间没有空格)的前面,并且由空格包围。基本字面值由数字0到n-1组成,az (或 AZ)的值为10到35.默认 base 为10.允许的值为0和2-36。 Base-2,-8和-16字面值可以选择使用 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 版更改: 允许使用下划线对代码文字中的数字进行分组。

isinstance(object, classinfo)

如果 object 参数是 classinfo 参数的实例,或者其(直接,间接或 虚拟)子类的实例,则返回true。如果 object 不是给定类型的对象,则函数始终返回false。如果 classinfo 是类型对象的元组(或递归地,其他这样的元组),则返回true,如果 object 是任何类型的实例。如果 classinfo 不是类型或元组的类型和这样的元组,则引发 TypeError 异常。

issubclass(class, classinfo)

如果 classclassinfo 的子类(直接,间接或 虚拟),则返回true。类被认为是自身的子类。 classinfo 可以是类对象的元组,在这种情况下将检查 classinfo 中的每个条目。在任何其他情况下,引发 TypeError 异常。

iter(object[, sentinel])

返回 iterator 对象。根据第二个参数的存在,第一个参数的解释非常不同。没有第二个参数,object 必须是支持迭代协议(__iter__() 方法)的集合对象,或者必须支持序列协议(具有以 0 开始的整数参数的 __getitem__() 方法)。如果它不支持这些协议,则引发 TypeError。如果给出第二个参数 sentinel,则 object 必须是可调用对象。在这种情况下创建的迭代器将调用 object,每次调用它的 __next__() 方法时没有参数;如果返回的值等于 sentinel,则将引发 StopIteration,否则将返回该值。

参见 迭代器类型

iter() 的第二形式的一个有用的应用是读取文件的行,直到到达某一行。以下示例读取文件,直到 readline() 方法返回空字符串:

with open('mydata.txt') as fp:
    for line in iter(fp.readline, ''):
        process_line(line)
len(s)

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

class list([iterable])

list 实际上是一种可变序列类型,而不是作为一个函数,如 列表序列类型— list,tuple,range 中所述。

locals()

更新并返回表示当前局部符号表的字典。当在函数块中调用自由变量时,locals() 返回自由变量,但不在类块中。

注解

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

map(function, iterable, ...)

返回一个迭代器,它应用 functioniterable 的每个项目,产生结果。如果传递了附加的 iterable 参数,则 function 必须采用这么多参数,并且并行地应用于来自所有可迭代的项目。使用多个迭代,迭代器在最短迭代可用时停止。对于函数输入已经排列成参数元组的情况,请参见 itertools.starmap()

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

返回可迭代的最大项或两个或更多参数中最大的一个。

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

有两个可选的仅关键字参数。 key 参数指定一个用于 list.sort() 的单参数排序函数。如果提供的iterable为空,default 参数指定要返回的对象。如果可迭代为空并且不提供 default,则产生 ValueError

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

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

memoryview(obj)

返回从给定参数创建的“内存视图”对象。有关详细信息,请参阅 内存视图

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

返回可迭代中的最小项或两个或更多参数中的最小值。

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

有两个可选的仅关键字参数。 key 参数指定一个用于 list.sort() 的单参数排序函数。如果提供的iterable为空,default 参数指定要返回的对象。如果可迭代为空并且不提供 default,则产生 ValueError

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

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

next(iterator[, default])

通过调用其 __next__() 方法从 iterator 检索下一个项目。如果给出 default,则如果迭代器耗尽则返回,否则提高 StopIteration

class object

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

注解

object 确实 not 有一个 __dict__,所以你不能分配任意属性到 object 类的一个实例。

oct(x)

将整数转换为八进制字符串。结果是一个有效的Python表达式。如果 x 不是Python int 对象,它必须定义一个返回整数的 __index__() 方法。

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' 用于附加(在 some Unix系统上,意味着 all 写入追加到文件的末尾,而不管当前的寻找位置) 。在文本模式下,如果未指定 encoding,则使用的编码是平台相关的:调用 locale.getpreferredencoding(False) 以获取当前语言环境编码。 (用于读取和写入原始字节使用二进制模式,并保留 encoding 未指定。)可用的模式有:

字符

含义

'r'

打开阅读(默认)

'w'

打开写入,首先截断文件

'x'

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

'a'

打开以写入,如果存在,则附加到文件的末尾

'b'

二进制模式

't'

文本模式(默认)

'+'

打开磁盘文件进行更新(读写)

'U'

universal newlines 模式(已弃用)

默认模式为 'r' (打开阅读文本,'rt' 的同义词)。对于二进制读写访问,模式 'w+b' 打开并将文件截断为0字节。 'r+b' 打开文件而不截断。

概述 中所提到的,Python区分二进制和文本I/O。以二进制模式打开的文件(包括 mode 参数中的 'b')将内容作为 bytes 对象返回,而不进行任何解码。在文本模式(默认情况下,或当 't' 包括在 mode 参数中)时,文件的内容作为 str 返回,字节首先使用平台相关编码解码,或者如果给定,则使用指定的 encoding

注解

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

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

  • 二进制文件以固定大小的块缓冲;使用试探确定底层设备的“块大小”并回退到 io.DEFAULT_BUFFER_SIZE 的试探法来选择缓冲器的大小。在许多系统上,缓冲区通常为4096或8192字节长。

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

encoding 是用于解码或编码文件的编码的名称。这应该只在文本模式下使用。默认编码是平台相关的(无论 locale.getpreferredencoding() 返回),但是可以使用Python支持的任何 text encoding。有关支持的编码列表,请参见 codecs 模块。

errors 是一个可选字符串,指定如何处理编码和解码错误 - 这不能在二进制模式下使用。可以使用各种标准错误处理程序(在 错误处理程序 下列出),但是已经使用 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'。它的工作原理如下:

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

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

如果 closefdFalse 并且给出了文件描述符而不是文件名,则当文件关闭时,底层文件描述符将保持打开。如果给定文件名,closefd 必须是 True (默认值),否则会引发错误。

可以通过将可调用项传递为 opener 来使用自定义打开程序。然后通过使用(fileflags)调用 opener 来获取文件对象的基础文件描述符。 opener 必须返回一个打开的文件描述符(传递 os.open 作为 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

另请参阅文件处理模块,例如 fileinputio (其中声明了 open()),osos.pathtempfileshutil

在 3.3 版更改:
  • 添加了 opener 参数。

  • 添加了 'x' 模式。

  • IOError 以前被提出,它现在是 OSError 的别名。

  • FileExistsError 现在升高,如果文件在专属开放

  • 创建模式('x')已存在。

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

从版本3.4开始弃用,将在版本4.0中删除:“U”模式。

在 3.5 版更改:
  • 如果系统调用中断并且信号处理程序不引发异常,则此函数现在重试系统调用,而不是引发 InterruptedError 异常(请参阅 PEP 475 的原理)。

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

在 3.6 版更改:
ord(c)

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

pow(x, y[, z])

x 返回电源 y;如果存在 z,则将 x 返回到功率 y,模 z (比 pow(x, y) % z 更有效地计算)。双参数形式 pow(x, y) 等价于使用幂运算符:x**y

参数必须有数字类型。对于混合操作数类型,二进制算术运算符的强制规则适用。对于 int 操作数,结果具有与操作数相同的类型(强制后),除非第二个参数为负;在这种情况下,所有参数都转换为float,并传递float结果。例如,10**2 返回 100,但 10**-2 返回 0.01。如果第二个参数为负,则必须省略第三个参数。如果存在 z,则 xy 必须是整数类型,并且 y 必须是非负数。

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

objects 打印到文本流 file,由 sep 分隔,然后由 end 分隔。 sependfile (如果存在)必须作为关键字参数给出。

所有非关键字参数都转换为字符串,如 str(),并写入流,由 sep 分隔,后跟 endsepend 都必须是字符串;它们也可以是 None,这意味着使用默认值。如果没有给出 objectsprint() 将只写入 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)

返回属性属性。

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.")

如果 cC 的实例,c.x 将调用getter,c.x = value 将调用设置器,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”,并将 voltage 的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现在是可写的。

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

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

repr(object)

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

reversed(seq)

返回反向 iteratorseq 必须是具有 __reversed__() 方法或支持序列协议(__len__() 方法和具有以 0 开始的整数参数的 __getitem__() 方法)的对象。

round(number[, ndigits])

将浮点值 number 舍入为小数点后的 ndigits 数字。如果 ndigits 被省略或是 None,它返回最接近的整数到其输入。代表 number.__round__(ndigits)

对于支持 round() 的内置类型,值被四舍五入到功率减去 ndigits 的最接近的倍数10;如果两个倍数相等接近,则对偶数选择进行舍入(因此,例如,round(0.5)round(-0.5) 都是 0round(1.5)2)。如果使用一个参数调用,返回值是一个整数,否则与 number 类型相同。

注解

round() 对浮标的行为可能是令人惊讶的:例如,round(2.675, 2) 给出 2.67 而不是预期的 2.68。这不是一个错误:这是一个事实的结果,大多数小数不能准确地表示为一个浮点。有关详细信息,请参阅 浮点算术:问题和限制

class set([iterable])

返回一个新的 set 对象,可选择包含从 iterable 中取得的元素。 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])

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

sorted(iterable[, key][, reverse])

iterable 中的项目返回新的排序列表。

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

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

reverse 是一个布尔值。如果设置为 True,那么列表元素将按照每个比较反转进行排序。

使用 functools.cmp_to_key() 将旧式 cmp 函数转换为 key 函数。

内置的 sorted() 功能保证稳定。如果保证不改变比较相等的元素的相对顺序,则排序是稳定的 - 这有助于在多个通过中排序(例如,按部门排序,然后按工资级排序)。

有关排序示例和简要排序教程,请参阅 排序如何

staticmethod(function)

返回 function 的静态方法。

静态方法不接收隐式第一个参数。要声明静态方法,请使用此成语:

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

@staticmethod 表单是一个函数 decorator - 有关详细信息,请参阅 函数定义 中函数定义的描述。

它可以在类(如 C.f())或实例(如 C().f())上调用。实例被忽略,除了它的类。

Python中的静态方法类似于Java或C++中的方法。另请参阅 classmethod() 一个变量,它有助于创建备用类构造函数。

有关静态方法的更多信息,请参阅 标准类型层次结构 中标准类型层次结构的文档。

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

返回 str 版本的 object。有关详细信息,请参阅 str()

str 是内置字符串 class。有关字符串的一般信息,请参阅 文本序列类型— str

sum(iterable[, start])

startiterable 的项从左到右求和,并返回总和。 start 默认为 0iterable 的项目通常是数字,并且起始值不允许为字符串。

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

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

返回一个代理对象,它将方法调用委派给 type 的父级或同级类。这对于访问在类中被覆盖的继承方法很有用。搜索顺序与 getattr() 使用的顺序相同,只是跳过了 type 本身。

type__mro__ 属性列出了 getattr()super() 使用的方法解析搜索顺序。该属性是动态的,并且可以在更新继承层次结构时更改。

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

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 的类型。返回值是一个类型对象,通常与 object.__class__ 返回的对象相同。

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

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

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

参见 类型对象

在 3.6 版更改: 不覆盖 type.__new__type 的子类可能不再使用单参数形式来获取对象的类型。

vars([object])

返回模块,类,实例或任何其他具有 __dict__ 属性的对象的 __dict__ 属性。

诸如模块和实例的对象具有可更新的 __dict__ 属性;然而,其他对象可能对其 __dict__ 属性具有写入限制(例如,类使用 types.MappingProxyType 来防止直接的字典更新)。

没有论据,vars() 就像 locals()。注意,本地字典只对读取有用,因为忽略了对本地字典的更新。

zip(*iterables)

创建一个迭代器,聚合来自每个迭代器的元素。

返回元组的迭代器,其中 i-th元组包含来自每个参数序列或迭代的第 i 个元素。当最短输入可迭代被耗尽时,迭代器停止。使用单个可迭代参数,它返回1元组的迭代器。没有参数,它返回一个空的迭代器。相当于:

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长度组的习语成为可能。这重复了 same 迭代器 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)

注解

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

此函数由 import 语句调用。它可以被替换(通过导入 builtins 模块并分配给 builtins.__import__)以改变 import 语句的语义,但是这样做是 强烈 不鼓励的,因为使用导入钩子(见 PEP 302)通常更容易达到相同的目标,不会导致假设默认导入实现正在使用的代码问题。也不赞成 importlib.import_module() 的直接使用 __import__()

该函数导入模块 name,可能使用给定的 globalslocals 来确定如何解释包上下文中的名称。 fromlist 给出了应该从 name 给出的模块中导入的对象或子模块的名称。标准实现根本不使用其 locals 参数,并且使用其 globals 仅确定 import 语句的包上下文。

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

name 变量的格式为 package.module 时,通常返回顶级包(直到第一个点的名称),notname 命名的模块。然而,当给出非空的 fromlist 参数时,返回由 name 命名的模块。

例如,语句 import spam 导致类似以下代码的字节码:

spam = __import__('spam', globals(), locals(), [], 0)

语句 import spam.ham 导致此调用:

spam = __import__('spam.ham', globals(), locals(), [], 0)

注意 __import__() 如何在这里返回toplevel模块,因为这是由 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)。

脚注

[1]

注意,解析器只接受Unix风格的行结束约定。如果您正在从文件中读取代码,请务必使用换行转换模式转换Windows或Mac样式的换行符。