Functions

Built-in Functions

Python解释器内置了许多可以使用的函数。它们按字母顺序排列在这里。

此外，还有一些不再被认为是必要的其他四个内置的功能：apply()，buffer()，coerce()，和intern()。它们记录在非必要的内置函数部分。

abs(x)

返回一个数字的绝对值。参数可能是一个普通或长整数或浮点数。如果参数是一个复数，则返回其大小。

all(iterable)

返回True如果的所有元素迭代是真实的（或者如果可迭代为空）。相当于：

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

2.5版本中的新功能。

any(iterable)

True如果迭代的任何元素为真，则返回。如果迭代器为空，则返回False。相当于：

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

2.5版本中的新功能。

basestring()

这个抽象类型是超str和unicode。它不能被调用或实例化，但它可以被用来测试对象是否是实例str或unicode。isinstance(obj, basestring)相当于isinstance(obj, (str, unicode))。

2.3版本的新功能。

bin(x)

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

2.6版本中的新功能。

class bool([x])

返回一个布尔值，即一个True或False。x使用标准真相测试程序进行转换。如果x为假或省略，则返回False; 否则返回True。bool也是一个类，它是一个子类int。类bool不能进一步子类化。它的唯一实例是False和True。

2.2.1版中的新功能。

版本2.3中更改：如果未给出参数，则此函数返回False。

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

返回一个新的字节数组。的bytearray类是整数的范围为0 <= X <256，具有大部分可变序列的常规方法，在可变的序列类型描述一个可变的序列，以及，最方法str类型有，参见字符串方法。

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

• 如果它是unicode，则还必须给出编码（以及可选的错误）参数; bytearray()然后将unicode转换为使用的字节unicode.encode()。

• 如果它是一个整数，则数组将具有该大小，并将用空字节进行初始化。

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

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

没有参数，就会创建一个大小为0的数组。

2.6版本中的新功能。

callable(object)

True如果对象参数显示为可调用，False则返回，如果不是。如果这返回true，那么调用失败仍然是可能的，但如果它是false，调用对象将永远不会成功。请注意，类是可调用的（调用一个类返回一个新的实例）; 类实例可以被调用，如果他们有一个__call__()方法。

chr(i)

返回ASCII码为整数i的一个字符串。例如，chr(97)返回字符串'a'。这是与之相反的ord()。参数必须在0..255的范围内（含）; ValueError如果我在这个范围之外，会被提高。另见unichr()。

classmethod(function)

为函数返回一个类方法。

类方法将类作为隐式第一个参数接收，就像实例方法接收实例一样。要声明一个类方法，使用这个习惯用法：

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

该@classmethod表单是一个函数装饰器 - 有关详细信息，请参阅函数定义中的函数定义说明。

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

类方法与C ++或Java静态方法不同。如果你想要这些，请参阅staticmethod()本节。

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

2.2版本中的新功能。

在版本2.4中更改：添加了函数装饰器语法。

cmp(x, y)

比较两个对象x和y，并根据结果返回一个整数。如果返回值为负，如果x < y为零，x == y并且严格为正，则返回值为负x > y。

compile(source, filename, mode[, flags[, dont_inherit]])

将源编译为代码或AST对象。代码对象可以由exec语句执行或通过调用来执行eval()。源可以是Unicode字符串，Latin-1编码的字符串或AST对象。ast有关如何使用AST对象的信息，请参阅模块文档。

该文件名参数应该给从代码读取的文件; 如果没有从文件中读取（'<string>'通常使用），则传递一些可识别的值。

该模式参数指定什么样的代码必须进行编译; 它可以是'exec'，如果源包含的语句序列的，'eval'如果它由一个单一的表达的，或者'single'如果它由单个交互式声明的（在后一种情况下，计算结果为比其他东西表达式语句None将被打印）。

可选参数flags和dont_inherit控制哪些未来语句（请参阅PEP 236）影响源编译。如果两者都不存在（或两者均为零），则代码将与正在调用的代码中生效的那些未来语句一起编译compile()。如果给出了flags参数，并且dont_inherit不是（或者是零），那么除了那些将被使用的参数之外，将使用flags参数指定的将来语句。如果dont_inherit是一个非零整数，那么flags参数就是它 - 将忽略围绕调用编译的未来声明。

将来的语句由可以按位或运算来指定多个语句的位指定。指定给定特征所需的位域可以作为模块中实例的compiler_flag属性找到。_Feature__future__

SyntaxError如果编译的源无效，并且TypeError源包含空字节，则此函数会引发。

如果您想将Python代码解析为其AST表示形式，请参阅ast.parse()。

注释

使用多行代码输入'single'或'eval'模式编译字符串时，输入必须至少由一个换行符终止。这是为了便于检测code模块中不完整和完整的语句。

版本2.3中更改：添加了标志和dont_inherit参数。

在版本2.6中更改：支持编译AST对象。

在版本2.7中更改：允许使用Windows和Mac换行符。在'exec'模式下输入也不必以换行符结束。

class complex([real[, imag]])

返回值为real + imag * 1j的复数或者将字符串或数字转换为复数。如果第一个参数是一个字符串，它将被解释为一个复数，并且该函数必须在没有第二个参数的情况下被调用。第二个参数不能是一个字符串。每个参数可以是任何数字类型（包括复数）。如果IMAG被省略，默认为零，并且该函数作为数字转换功能等int()，long()和float()。如果两个参数都被省略，则返回0j。

注释

从字符串转换时，该字符串不得在中央+或-运算符周围包含空格。例如，complex('1+2j')很好，但complex('1 + 2j')引发ValueError。

复数类型用数字类型描述 - int，float，long，complex。

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
['__builtins__', '__doc__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module
['Struct', '__builtins__', '__doc__', '__file__', '__name__',
 '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape(object):
        def __dir__(self):
            return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'perimeter', 'location']

注意

由于dir()主要是为了便于在交互式提示下使用而提供，因此它会尝试提供一组有趣的名称，而不是试图提供严格或一致定义的名称集，并且其详细行为可能会在各版本之间发生变化。例如，当参数是一个类时，元类属性不在结果列表中。

divmod(a, b)

以两个（非复数）数字作为参数，并在使用长整数时返回一对由它们的商和余数组成的数字。使用混合操作数类型时，适用二元算术运算符的规则。对于普通和长整数，结果与之相同(a // b, a % b)。对于浮点数的结果是(q, a % b)，其中q通常是math.floor(a / b)但可能比1小1。在任何情况下q * b + a % b都非常接近a，如果a % b非零，则它与b具有相同的符号，并且0 <= abs(a % b) < abs(b)。

在版本2.3中更改：不建议使用divmod()复数。

enumerate(sequence, start=0)

返回一个枚举对象。序列必须是序列，迭代器或支持迭代的其他对象。next()返回的迭代器的方法enumerate()返回一个包含count的元组（从start开始，默认值为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

2.3版本的新功能。

在版本2.6中更改：添加了启动参数。

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

参数是Unicode或Latin-1编码的字符串以及可选的全局变量和本地变量。如果提供，全局变量必须是字典。如果提供，本地人可以是任何映射对象。

在版本2.4中改变：以前本地人被要求成为一本字典。

该表达参数分析，并作为一个Python表达式来使用（从技术上来说，一个条件列表）全局和当地人的字典作为全局和局部名字空间。如果globals字典存在并且缺少'__builtins__'，则在解析表达式之前将当前全局变量复制到全局变量中。这意味着表达式通常可以完全访问标准模块，并且传播受限制的环境。如果省略了本地字典，则默认为全局变量__builtin__字典。如果两个字典都被省略，表达式会在eval()调用的环境中执行。返回值是评估表达式的结果。语法错误被报告为例外。例：

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

这个函数也可以用来执行任意代码对象（比如那些创建的对象compile()）。在这种情况下，传递一个代码对象而不是一个字符串。如果代码对象已经被编译'exec'为模式参数，那么eval()返回值将是None。

提示：语句支持动态执行exec语句。execfile()函数支持从文件执行语句。的globals()和locals()功能返回当前全球和本地词典，分别，其可以是通过以绕过使用有用eval()或execfile()。

请参阅有关ast.literal_eval()可以安全地使用仅包含文字的表达式评估字符串的函数。

execfile(filename[, globals[, locals]])

该函数与该exec语句类似，但解析文件而不是字符串。它与import声明不同之处在于它不使用模块管理 - 它无条件地读取文件并且不创建新的模块。[1]

参数是一个文件名和两个可选字典。文件被解析并评估为一系列Python语句（类似于模块），使用全局和本地语言字典作为全局和本地命名空间。如果提供，本地人可以是任何映射对象。请记住，在模块级别，全局变量和本地变量是相同的字典。如果两个单独的对象作为全局变量和本地变量传递，那么代码将被嵌入类定义中执行。

在版本2.4中改变：以前本地人被要求成为一本字典。

如果省略了本地字典，则默认为全局字典。如果两个字典都被省略，表达式会在execfile()调用的环境中执行。返回值是None。

注释

默认本地人的行为如locals()下面的功能所述：不应尝试对默认本地人字典的修改。传递一个明确的当地人解释，如果你需要看到的代码的作用当地人后的功能execfile()恢复。execfile()不能可靠地用来修改一个函数的当地人。

file(name[, mode[, buffering]])

该file类型的构造函数，在文件对象部分进一步描述。构造函数的参数与open()下面描述的内置函数的参数相同。

打开文件时，最好使用open()而不是直接调用此构造函数。file更适合于类型测试（例如，写作isinstance(f, file)）。

2.2版本中的新功能。

filter(function, iterable)

构建从这些元素的列表迭代为此函数返回true。可迭代可以是序列，支持迭代的容器或迭代器。如果iterable是一个字符串或一个元组，结果也具有该类型; 否则它总是一个列表。如果函数是None，则假定标识函数，即删除所有可迭代的元素。

请注意，如果函数不是并且函数是filter(function, iterable)等价的。[item for item in iterable if function(item)]None[item for item in iterable if item]None

见itertools.ifilter()及itertools.ifilterfalse()此功能的迭代器版本，包括对于其中的元素筛选的变化函数返回false。

class float([x])

返回一个由数字或字符串x构造的浮点数。

如果参数是一个字符串，它必须包含一个可能带符号的十进制或浮点数，可能嵌入在空格中。参数也可以是+ | -nan或+ | -inf。否则，参数可能是一个普通或长整数或浮点数，并返回具有相同值（在Python的浮点精度内）的浮点数。如果没有提供参数，则返回0.0。

Note

传递字符串时，可能会返回NaN和Infinity的值，具体取决于底层的C库。对于NaN和正或负无限，Float接受字符串nan，inf和-inf。对于NaN，情况和领导+被忽略以及领先 - 被忽略。Float总是代表NaN和无穷大，如nan，inf或-inf。

浮点类型用数字类型描述 - int，float，long，complex。

format(value[, format_spec])

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

注释

format(value, format_spec) merely calls value.__format__(format_spec).

2.6版本中的新功能。

class frozenset([iterable])

返回一个新的frozenset对象，可选的元素来自iterable。frozenset是一个内置的类。请参阅frozenset和设置类型 - 设置，冻结关于此类的文档。

对于其他容器看到内置的set，list，tuple，和dict类，还有collections模块。

2.4版本中的新功能。

getattr(object, name[, default])

返回对象的指定属性的值。名称必须是字符串。如果字符串是对象属性之一的名称，则结果是该属性的值。例如，getattr(x, 'foobar')相当于x.foobar。如果指定的属性不存在，则返回默认值（如果提供），否则返回AttributeError。

globals()

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

hasattr(object, name)

参数是一个对象和一个字符串。结果是True如果字符串是对象属性之一的名称，False如果不是。（这是通过调用getattr(object, name)并查看它是否引发异常来实现的。）

hash(object)

返回对象的散列值（如果有）。哈希值是整数。它们用于在字典查找期间快速比较字典键。比较相等的数值具有相同的散列值（即使它们具有不同的类型，就像1和1.0一样）。

help([object])

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

该功能被模块添加到内置命名空间中site。

2.2版本中的新功能。

hex(x)

将整数（任意大小）转换为以“0x”为前缀的小写十六进制字符串，例如：

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(1L)
'0x1L'

如果x不是Python int或long对象，则必须定义一个返回字符串的__hex __（）方法。

注意

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

在版本2.4中更改：以前只返回一个无符号文字。

id(object)

返回一个对象的“身份”。这是一个整数（或长整数），在整个生命周期中保证这个对象是唯一的并且是常量。两个非重叠生命期的对象可能具有相同的id()值。

CPython实现细节：这是内存中对象的地址。

input([prompt])

相当于eval(raw_input(prompt))。

此功能不捕捉用户错误。如果输入不是语法有效的，SyntaxError则会提出。如果在评估过程中出现错误，可能会引发其他例外情况。

如果readline模块已加载，那么input()将使用它来提供精细的线条编辑和历史记录功能。

考虑使用该raw_input()函数来进行用户的一般输入。

class int(x=0)class int(x, base=10)

返回由数字或字符串x构造的整数对象，0如果没有给定参数，则返回。如果x是一个数字，它可以是一个纯整数，一个长整数或一个浮点数。如果x是浮点，则转换将截断为零。如果参数不在整数范围内，则该函数会返回一个长对象。

如果X不是数字或如果基给出，则X必须是字符串或Unicode对象表示面值整数在基数基。可选地，文字可以在+或之前-（没有间隔）并且被空白包围。base-n文字由数字0到n-1组成，其中ato z（或Ato Z）的值为10到35.默认基数为10.允许的值为0和2-36。base-2，-8和-16文字可以有选择地以0b/ 0B，0o/ 0O/ 0或0x/0X与代码中的整数文字一样。基数0表示将字符串完全解释为整数字面值，以便实际基数为2,8,10或16。

整数类型用数字类型 - int，float，long，complex来描述。

isinstance(object, classinfo)

如果对象参数是classinfo参数的实例或其（直接，间接或虚拟）子类的实例，则返回true 。如果classinfo是一个类型对象（new-style class），并且object是该类型的对象或其（直接，间接或虚拟）子类的对象，则也会返回true 。如果object不是给定类型的类实例或对象，则该函数始终返回false。如果classinfo是类或类型对象（或递归地，其他这样的元组）的元组，则如果object是任何类或类型的实例，则返回true 。如果classinfo不是类，类型和这些元组的类，类型或元组，TypeError会引发异常。

在版本2.2中更改：添加了对类型信息元组的支持。

issubclass(class, classinfo)

如果返回true 类是一个子类（直接，间接或虚拟）的CLASSINFO。一个类被认为是它自己的一个子类。classinfo可以是类对象的元组，在这种情况下，将检查classinfo中的每个条目。在其他情况下，TypeError会引发异常。

版本2.3中更改：添加了对类型信息元组的支持。

iter(o[, sentinel])

返回一个迭代器对象。根据第二个参数的存在，第一个参数被解释得非常不同。没有第二个参数，o必须是一个支持迭代协议（__iter__()方法）的集合对象，或者它必须支持序列协议（__getitem__()整数参数开始的方法0）。如果它不支持这些协议中的任何一个，TypeError则会引发。如果给出了第二个参数sentinel，那么o必须是可调用的对象。在这种情况下创建的迭代器将为每个对其方法的调用调用o而不带任何参数next( 如果返回的值等于哨兵，StopIteration 将被提出，否则该值将被退回。

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

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

New in version 2.2.

len(s)

返回对象的长度（项目数量）。参数可以是一个序列（如字符串，字节，元组，列表或范围）或集合（如字典，集合或冻结集合）。

class list([iterable])

返回一个列表，其项目与迭代项目的顺序相同并且顺序相同。可迭代可以是序列，支持迭代的容器或迭代器对象。如果可迭代已经是一个列表，则复制将被创建并返回，类似于iterable[:]。例如，list('abc')退货['a', 'b', 'c']和list( (1, 2, 3) )退货[1, 2, 3]。如果没有给出参数，则返回一个新的空列表[]。

list是一个可变序列类型，如序列类型 - str，unicode，list，tuple，bytearray，buffer，xrange中所记录。对于其他容器看到内置的dict，set以及tuple类和collections模块。

locals()

更新并返回表示当前本地符号表的字典。locals()在功能块中调用自由变量时会返回自由变量，但不会在类块中调用它们。

Note

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

class long(x=0)class long(x, base=10)

返回一个由字符串或数字x构造的长整数对象。如果参数是一个字符串，它必须包含一个可能有符号数的任意大小，可能嵌入在空格中。所述碱参数被解释以相同的方式作为用于int()，当仅可以给出X是一个字符串。否则，参数可能是一个普通或长整数或浮点数，并返回一个具有相同值的长整数。将浮点数转换为整数将截断（趋近于零）。如果没有给出参数，则返回0L。

长类型用数字类型描述 - int，float，long，complex。

map(function, iterable, ...)

将函数应用于每个可迭代项并返回结果列表。如果传递额外的迭代参数，函数必须采用多个参数并应用于并行所有迭代中的项目。如果一个迭代器比另一个迭代器短，则假定它被扩展为None项。如果函数是None，则假定身份函数; 如果有多个参数，则map()返回一个由包含所有可迭代对象项（一种转置操作）的元组构成的列表。所述迭代参数可以是序列或任何迭代的对象; 结果总是一个列表。

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

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

如果提供了一个位置参数，则iterable必须是非空的可迭代的（例如非空字符串，元组或列表）。迭代中最大的项目被返回。如果提供了两个或多个位置参数，则返回最大的位置参数。

可选的key参数指定一个与之相同的单参数排序函数list.sort()。的关键参数，如果提供的话，必须在关键字的形式（例如，max(a,b,c,key=func)）。

在版本2.5中进行了更改：添加了对可选键参数的支持。

memoryview(obj)

返回从给定参数创建的“内存视图”对象。有关更多信息，请参阅memoryview类型。

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

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

如果提供了一个位置参数，则iterable必须是非空的可迭代的（例如非空字符串，元组或列表）。迭代中的最小项返回。如果提供两个或多个位置参数，则返回最小的位置参数。

可选的key参数指定一个与之相同的单参数排序函数list.sort()。的关键参数，如果提供的话，必须在关键字的形式（例如，min(a,b,c,key=func)）。

在版本2.5中进行了更改：添加了对可选键参数的支持。

next(iterator[, default])

通过调用它的方法从迭代器中检索下一个项目next()。如果给出了默认值，则在迭代器用尽时返回，否则返回StopIteration。

2.6版本中的新功能。

class object

返回一个新的无特征的对象。object是所有新风格课程的基础。它具有所有新样式类的常见方法。

2.2版本中的新功能。

版本2.3中更改：此函数不接受任何参数。以前，它接受了论据，但忽略了它们。

oct(x)

将整数（任何大小）转换为八进制字符串。结果是一个有效的Python表达式。

在版本2.4中更改：以前只返回一个无符号文字。

open(name[, mode[, buffering]])

打开一个文件，返回file文件对象部分中描述的类型的对象。如果文件无法打开，IOError则引发。打开文件时，最好使用open()而不是file直接调用构造函数。

前两个参数与stdio's' 相同fopen()：name是要打开的文件名，mode是一个字符串，指示文件如何打开。

模式最常用的值是'r'读取，'w'写入（如果文件已存在，则截断文件）和'a'附加文件（在某些 Unix系统上，这意味着所有写入都附加到文件末尾，而不管当前的搜索位置）。如果省略模式，则默认为'r'。默认设置是使用文本模式，'\n'在写入时可以将字符转换为平台特定的表示，然后重新读取。因此，打开二进制文件时，你应该追加'b'到模式值以二进制方式打开该文件，这将提高便携性。（追加'b'即使在系统没有对二进制文本和文本文件进行不同的处理时，它也是有用的）。请参阅下面的模式的更多可能值。

可选的缓冲参数指定文件所需的缓冲区大小：0表示无缓冲，1表示缓冲行，任何其他正值意味着使用（大约）该缓冲区大小（以字节为单位）。负缓冲意味着使用系统默认值，通常为tty设备进行线路缓冲，并为其他文件进行完全缓冲。如果省略，则使用系统默认值。[2]

模式'r+'，'w+'并'a+'打开文件进行更新（读写）; 注意'w+'截断该文件。'b'在区分二进制和文本文件的系统上追加到以二进制模式打开文件的模式; 在没有这种区别的系统上，添加'b'无效。

除了标准fopen()值模式可能是'U'或'rU'。Python通常使用通用换行符支持来构建; 提供'U'将文件作为文本文件打开，但行可以通过以下任何一种方式终止：Unix行尾约定'\n'，Macintosh约定'\r'或Windows约定'\r\n'。所有这些外部表示都被'\n'Python程序看到。如果没有通用换行符支持Python的内置模式具有'U'相同普通的文本模式。需要注意的是文件对象，因此开了也有称为属性newlines，其具有的价值None（如果没有换行目前尚未看到）'\n'，'\r'，'\r\n'，或者包含所有可见的新行类型的元组。

Python的强制执行方式，剥离后'U'，开始'r'，'w'或'a'。

Python提供了很多文件处理模块，包括fileinput，os，os.path，tempfile，和shutil。

在版本2.5中更改：引入模式字符串的第一个字母的限制。

ord(c)

给定一个长度为1的字符串，当参数是一个unicode对象时返回一个表示字符的Unicode代码点的整数，或者当参数是一个8位字符串时返回字节的值。例如，ord('a')返回整数97，ord(u'\u2020')返回8224。这与chr()8位字符串和unichr()unicode对象相反。如果给出了一个unicode参数并且Python是使用UCS2 Unicode编译的，那么该字符的代码点必须在0到65535之间 否则字符串长度是两个，并且a TypeError会被提出。

pow(x, y[, z])

将x返回给y ; 如果z存在，则将x返回给y，模z（比其更有效地计算pow(x, y) % z）。双参数形式pow(x, y)相当于使用权力运算符：x**y。

参数必须有数字类型。对于混合操作数类型，适用于二元算术运算符的强制规则。对于int和长整型操作数，除非第二个参数为负数，否则结果与操作数（强制后）的类型相同; 在这种情况下，所有参数都将转换为浮点数并传递浮点结果。例如，10**2返回100，但10**-2返回0.01。（最后一个特性是在Python 2.2中添加的，在Python 2.1和之前的版本中，如果两个参数都是整数类型，而第二个参数是负数，则会引发异常。）如果第二个参数为负数，则必须省略第三个参数。如果z存在，x和y必须是整数类型，y必须是非负的。（这个限制是在Python 2.2中添加的，在Python 2.1和之前的版本中，pow()根据浮点舍入事故，浮动三个参数返回了依赖于平台的结果。）

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

将对象打印到流文件中，以sep分隔，然后以end结尾。sep，end和file（如果存在）必须作为关键字参数给出。

所有非关键字参数都会转换为字符串str()，并写入流中，然后由sep分隔并结尾。无论九月和年底必须是字符串; 他们也可以None，这意味着使用默认值。如果没有任何对象，print()只会写结束。

文件参数必须是与对象write(string)方法; 如果它不存在或None，sys.stdout将被使用。输出缓冲由文件决定。使用file.flush()保证，用于在屏幕上的实例，眼前的外观。

注释

由于名称print被识别为print语句，因此该函数通常不可用作为内置函数。要禁用语句并使用该print()函数，请在模块的顶部使用这个future语句：

from __future__ import print_function

2.6版本中的新功能。

class property([fget[, fset[, fdel[, doc]]]])

返回新样式类 es（从中派生的类object）的属性属性。

fget是获取属性值的函数。fset是用于设置属性值的函数。fdel是删除属性值的功能。然后doc为该属性创建一个文档字符串。

一个典型的用途是定义一个托管属性x：

class C(object):
    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.xdeleter。

如果给定，doc将是属性属性的文档字符串。否则，该属性将复制fget的文档字符串（如果存在）。这使得它能够很容易地创建只读属性使用property()作为装饰：

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

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

该@property装饰变成的voltage()方法变成“吸”为只读具有相同名称的属性，并将其设置的文档字符串的电压为“获取当前的电压。”

属性对象具有getter，setter和deleter可用作装饰器的方法，这些装饰器用相应的存取器函数设置为装饰函数来创建属性的副本。这可以用一个例子来解释：

class C(object):
    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相对应的构造函数的参数。

2.2版本中的新功能。

改变在2.5版本：使用fget的文档字符串，如果没有DOC给出。

改变在2.6版本：在getter，setter和deleter添加属性。

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

这是一个多功能的函数来创建包含算术级数的列表。它最常用于for循环中。参数必须是纯整数。如果省略step参数，则默认为1。如果省略start参数，则默认为0。完整的表单返回一个普通整数列表[start, start + step, start + 2 * step, ...]。如果步骤是肯定的，最后一个元素是最大的start + i * step小于停止 ; 如果step是负数，最后一个元素是start + i * step大于stop的最小元素。步骤不能为零（否则ValueError会引发）。例：

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(0, -10, -1)
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]

raw_input([prompt])

如果提示参数存在，则将其写入标准输出而没有尾随换行符。然后该函数从输入中读取一行，将其转换为一个字符串（剥离尾随的换行符），然后返回该行。当EOF被读取时，EOFError被提出。例：

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

如果readline模块已加载，那么raw_input()将使用它来提供精细的线条编辑和历史记录功能。

reduce(function, iterable[, initializer])

应用功能的两个参数来累计的项目迭代，由左到右，从而减少可迭代为单个值。例如，reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])计算((((1+2)+3)+4)+5)。左边的说法，X，是指累积值和正确的说法，ÿ，是从更新值迭代。如果可选初始值设定项存在，它将放置在计算中可迭代项的前面，并在迭代项为空时用作默认值。如果初始化程序没有给出并且迭代只包含一个项目，则返回第一个项目。大致相当于：

def reduce(function, iterable, initializer=None):
    it = iter(iterable)
    if initializer is None:
        try:
            initializer = next(it)
        except StopIteration:
            raise TypeError('reduce() of empty sequence with no initial value')
    accum_value = initializer
    for x in it:
        accum_value = function(accum_value, x)
    return accum_value

reload(module)

重新加载以前导入的模块。参数必须是模块对象，所以它必须在之前成功导入。如果您已经使用外部编辑器编辑了模块源文件，并且希望在不离开Python解释器的情况下尝试新版本，这将非常有用。返回值是模块对象（与模块参数相同）。

When reload(module) is executed:

• 重新编译Python模块的代码并重新执行模块级代码，定义一组绑定到模块字典中名称的新对象。init扩展模块的功能不是第二次调用。

• 与Python中的所有其他对象一样，旧对象只有在其引用计数降至零后才会回收。

• 模块名称空间中的名称将更新为指向任何新的或更改的对象。

• 对旧对象的其他引用（例如模块外部的名称）不会反弹以引用新对象，并且如果需要，则必须在它们出现的每个命名空间中进行更新。

还有一些其他警告：

当模块重新加载时，其字典（包含模块的全局变量）将被保留。名称的重新定义将覆盖旧的定义，所以这通常不是问题。如果新版本的模块未定义旧版本定义的名称，则旧定义将保留。如果该模块维护全局表或对象缓存，则该特性可用于模块的优势 - 如果需要try，可使用语句测试表的存在并跳过其初始化：

try:
    cache
except NameError:
    cache = {}

重新加载内置或动态加载的模块通常不是很有用。重装sys，__main__，builtins不建议和其他关键模块。在许多情况下，扩展模块并不是设计成多次初始化的，并且在重新加载时可能会以任意方式失败。

如果一个模块使用from... 从另一个模块导入对象import，调用reload()另一个模块不会重新定义从它导入的对象 - 解决这个问题的方法之一是重新执行from语句，另一个是使用import限定名称（模块。*名称*）来代替。

如果一个模块实例化一个类的实例，重新加载定义类的模块不会影响实例的方法定义 - 它们继续使用旧的类定义。派生类也是如此。

repr(object)

返回一个包含对象可打印表示的字符串。这与转换（反向引号）产生的价值相同。能够以普通功能访问此操作有时很有用。对于许多类型，此函数尝试返回一个字符串，该字符串在传递时会产生具有相同值的对象eval()，否则该表示是一个用尖括号括起来的字符串，其中包含对象类型的名称以及附加信息通常包括对象的名称和地址。一个类可以通过定义一个__repr__()方法来控制这个函数为其实例返回的内容。

reversed(seq)

返回一个反向迭代器。seq必须是一个具有__reversed__()方法或支持序列协议的对象（__len__()方法和__getitem__()整数参数始于的方法0）。

2.4版本中的新功能。

在版本2.6中更改：增加了编写自定义__reversed__()方法的可能性。

round(number[, ndigits])

返回浮点值数四舍五入到ndigits小数点后的数字。如果ndigits被忽略，它默认为零。结果是一个浮点数。数值四舍五入为功率减去ndigits的10的最接近倍数; 如果两个倍数同样接近，则四舍五入从0开始（例如，round(0.5)is 1.0和round(-0.5)is -1.0）。

注释

round()对于浮动的行为可能会令人惊讶：例如，round(2.675, 2)给出2.67而不是预期的2.68。这不是一个错误：这是由于大多数小数不能完全表示为浮点数的结果。有关更多信息，请参见浮点算术：问题和限制。

class set([iterable])

返回一个新的set对象，可选的元素来自iterable。set是一个内置的类。请参阅set和设置类型 - 设置，冻结关于此类的文档。

对于其他容器看到内置的frozenset，list，tuple，和dict类，还有collections模块。

2.4版本中的新功能。

setattr(object, name, value)

这是与之相对的getattr()。参数是一个对象，一个字符串和一个任意值。该字符串可以命名现有的属性或新的属性。如果该对象允许，该函数将该值分配给该属性。例如，setattr(x, 'foobar', 123)相当于x.foobar = 123。

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

返回表示由指定的索引集的切片对象range(start, stop, step)。在启动和步参数默认为None。切片对象具有只读数据属性start，stop并且step仅返回参数值（或其默认值）。他们没有其他明确的功能; 然而，它们被Numerical Python和其他第三方扩展使用。当使用扩展索引语法时，也会生成切片对象。例如：a[start:stop:step]或a[start:stop, i]。查看itertools.islice()返回迭代器的备用版本。

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

从迭代中的项目中返回一个新的排序列表。

可选参数cmp，key和reverse与该list.sort()方法的含义相同（在Mutable Sequence Types部分中进行了介绍）。

cmp指定两个参数（可迭代元素）的自定义比较函数，根据第一个参数是否小于，等于或大于第二个参数，它应返回负数，零或正数：cmp=lambda x,y: cmp(x.lower(), y.lower())。默认值是None。

key指定一个用于从每个列表元素中提取比较键的参数的函数：key=str.lower。默认值是None（直接比较元素）。

reverse是一个布尔值。如果设置为True，则列表元素按照每个比较被颠倒的顺序进行排序。

通常，关键和反向转换过程比指定等效的cmp函数要快得多。这是因为对于每个列表元素，cmp被多次调用，而按键和反向触摸每个元素只有一次。用functools.cmp_to_key()一个老式的转换CMP功能的关键功能。

内置sorted()功能保证稳定。如果确保不会更改比较相等的元素的相对顺序，则排序是稳定的 - 这对于多次排序（例如，按部门排序，然后按薪级）进行排序很有帮助。

有关排序示例和简要的排序教程，请参阅对如何排序。

2.4版本中的新功能。

staticmethod(function)

为函数返回一个静态方法。

静态方法不会收到隐式的第一个参数。要声明一个静态方法，使用这个习惯用法：

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

该@staticmethod表单是一个函数装饰器 - 有关详细信息，请参阅函数定义中的函数定义说明。

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

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

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

2.2版本中的新功能。

在版本2.4中更改：添加了函数装饰器语法。

class str(object='')

返回一个包含对象的可打印表示的字符串。对于字符串，这会返回字符串本身。不同之处repr(object)在于，str(object)并不总是尝试返回可接受的字符串eval( 其目标是返回一个可打印的字符串。如果没有给出参数，则返回空字符串''。

有关字符串的更多信息，请参阅序列类型 - str，unicode，list，tuple，bytearray，buffer，描述序列功能的xrange（字符串是序列）以及字符串方法部分中描述的字符串特定方法。要输出格式化的字符串，请使用%字符串格式操作部分中描述的模板字符串或运算符。另外请参阅字符串服务部分。另见unicode()。

sum(iterable[, start])

资金开始和的项目迭代由左到右，并返回总。开始默认为0。该迭代的项目通常是数字，起始值不允许是一个字符串。

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

2.3版本的新功能。

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

返回一个代理对象，委托方法调用到父母或兄弟姐妹类的类型。这对于访问在类中被覆盖的继承方法很有用。getattr()除了类型本身被跳过之外，搜索顺序与使用的顺序相同。

该类型的__mro__属性列出了两者和使用的方法解析搜索顺序。该属性是动态的，只要继承层次更新就可以更改。getattr()super()

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

注释

super()只适用于新式类。

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

第二个用例是在动态执行环境中支持协作式多重继承。这个用例是Python独有的，在静态编译的语言或仅支持单一继承的语言中找不到。这使得在多个基类实现相同方法的情况下实现“菱形图”成为可能。良好的设计规定，这种方法在每种情况下都具有相同的调用签名（因为调用顺序是在运行时确定的，因为该顺序适用于类层次结构中的更改，并且因为该顺序可以包含运行时未知的同级类）。

对于这两种用例，典型的超类调用如下所示：

class C(B):
    def method(self, arg):
        super(C, self).method(arg)

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

另请注意，super()并不限于使用内部方法。这两个参数形式完全指定了参数，并提供了适当的参考。

有关如何使用设计协作类的实用建议super()，请参阅使用super（）的指南。

2.2版本中的新功能。

tuple([iterable])

返回一个元组，其元素与iterable的元素相同并且顺序相同。可迭代可以是序列，支持迭代的容器或迭代器对象。如果可迭代已经是一个元组，它将不会被返回。例如，tuple('abc')返回('a', 'b', 'c')和tuple([1, 2, 3])返回(1, 2, 3)。如果没有给出任何参数，则返回一个新的空元组，()。

tuple是一个不可变的序列类型，如序列类型 - str，unicode，list，tuple，bytearray，buffer，xrange中所记录。对于其他容器看到内置的dict，list以及set类和collections模块。

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

使用一个参数，返回一个对象的类型。返回值是一个类型对象。isinstance()建议使用内置函数来测试对象的类型。

有三个参数，返回一个新的类型对象。这实质上是class声明的一种动态形式。该名字符串类名，并成为__name__属性; 所述碱元组逐条列出的基类和成为__bases__属性; 和字典的字典是包含用于类定义体的命名空间，成为__dict__属性。例如，以下两条语句创建相同的type对象：

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

2.2版本中的新功能。

unichr(i)

返回Unicode代码为整数i的一个字符的Unicode字符串。例如，unichr(97)返回字符串u'a'。这是ord()Unicode字符串的反例。参数的有效范围取决于Python的配置方式 - 它可以是UCS2 0..0xFFFF或UCS4 0..0x10FFFF。ValueError否则会被提出。对于ASCII和8位字符串请参见chr()。

2.0版本中的新功能。

unicode(object='')unicode(object[, encoding[, errors]])

使用以下某种模式返回Unicode字符串版本的对象：

如果给出了编码和/或错误，unicode()则将使用用于编码的编解码器对可以是8位字符串或字符缓冲区的对象进行解码。该编码参数是给出的编码的名称的字符串; 如果编码未知，LookupError则引发。错误处理根据错误完成; 这指定了对输入编码中无效字符的处理。如果错误是'strict'（默认），ValueError则错误引发a ，而错误的值'ignore'会被默默忽略，并且值'replace'会导致官方的Unicode替换字符，U+FFFD，用于替换无法解码的输入字符。另请参阅codecs模块。

如果没有给出可选参数，unicode()将模仿str()除了返回Unicode字符串而不是8位字符串之外的行为。更确切地说，如果object是一个Unicode字符串或子类，它将返回该Unicode字符串，而不需要应用任何额外的解码。

对于提供__unicode__()方法的对象，它会调用这个没有参数的方法来创建一个Unicode字符串。对于所有其他对象，请求8位字符串版本或表示，然后使用编解码器将'strict'模式中的默认编码转换为Unicode字符串。

有关Unicode字符串的更多信息，请参阅序列类型 - str，unicode，list，tuple，bytearray，buffer，描述序列功能的xrange（Unicode字符串是序列）以及字符串方法部分中描述的字符串特定的方法。要输出格式化的字符串，请使用%字符串格式操作部分中描述的模板字符串或运算符。另外请参阅字符串服务部分。另见str()。

2.0版本中的新功能。

在版本2.2中更改：支持__unicode__()添加。

vars([object])

使用__dict__属性返回模块，类，实例或任何其他对象的__dict__属性。

诸如模块和实例之类的对象具有可更新__dict__属性; 然而，其他对象可能会对其__dict__属性进行写入限制（例如，新式类使用dictproxy来防止直接更新字典）。

没有争论，vars()就像locals()。请注意，本地字典仅用于读取，因为本地字典的更新被忽略。

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

这个函数非常类似range()，但返回一个xrange对象而不是一个列表。这是一种不透明的序列类型，与相应的列表产生相同的值，而不是实际同时存储它们。的优势xrange()比range()是最小的（因为xrange()仍然有创造价值的时候问他们）当一个非常大范围使用的内存饥渴机上或当所有范围的元素都从来没有使用过（如当环路除通常以终止break）。有关xrange对象的更多信息，请参阅XRange类型和序列类型 - str，unicode，列表，元组，bytearray，缓冲区，xrange。

CPython实现细节： xrange()旨在简单快速。为了实现这一点，实现可能会施加限制。Python的C实现将所有参数限制为本地C long（“short”Python整数），并且还要求元素的数量适合本地C long。如果需要更大的范围，可以使用itertools模块制作替代版本：islice(count(start, step), (stop-start+step-1+2*(step<0))//step)。

zip([iterable, ...])

这个函数返回一个元组列表，其中第i个元组包含来自每个参数序列或迭代的第i个元素。返回的列表的长度被截断为最短参数序列的长度。当有多个长度相同的参数时，与初始参数zip()类似。使用单个序列参数，它将返回1元组列表。没有参数，它返回一个空列表。map()None

可保证迭代的从左到右的评估顺序。这使得使用一个将数据序列聚类为n长度组的成语成为可能zip(*[iter(s)]*n)。

zip()与*运营商一起可以用来解压一个列表：

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

2.0版本中的新功能。

在版本2.4中更改：以前，zip()至少需要一个参数，并zip()提出一个TypeError而不是返回一个空列表。

__import__(name[, globals[, locals[, fromlist[, level]]]])

注释

与日常Python编程不同，这是一种高级功能importlib.import_module()。

该函数由import语句调用。它可以被替换（通过导入__builtin__模块并赋值__builtin__.__import__）以改变import语句的语义，但现在通常使用导入钩子更简单（参见PEP 302）。直接使用__import__()是很少见的，除非您想要导入名称仅在运行时已知的模块。

该函数导入模块名称，可能使用给定的全局变量和局部变量来确定如何解释包上下文中的名称。在fromlist里给出了应该从给出的模块导入的对象或子的名字命名。标准实现完全不使用它的本地参数，并且仅使用它的全局变量来确定import语句的包上下文。

级别指定是使用绝对导入还是相对导入。默认值是-1指示绝对和相对导入都将被尝试。0意味着只执行绝对导入。级别的正值表示要搜索的父目录相对于模块调用目录的数量__import__()。

当name变量具有这种形式时package.module，通常会返回顶层包（名称直到第一个点），而不是按名称命名的模块。但是，如果给出非空的fromlist参数，则会返回按名称命名的模块。

例如，该语句import spam导致类似于以下代码的字节码：

spam = __import__('spam', globals(), locals(), [], -1)

声明import spam.ham结果在这个调用中：

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

请注意，__import__()这里返回顶层模块是因为这是通过import语句绑定到名称的对象。

另一方面，声明from spam.ham import eggs, sausage as saus结果

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], -1)
eggs = _temp.eggs
saus = _temp.sausage

在这里，spam.ham模块从中返回__import__()。从这个对象中，要导入的名称被检索并分配给它们各自的名称。

如果您只是想按名称导入模块（可能位于软件包内），请使用importlib.import_module()。

在版本2.5中更改：添加了级别参数。

在版本2.5中更改：添加了对参数的关键字支持。

非必要的内置功能

有几种内置函数不再是学习，了解或在现代Python编程中使用的基本功能。他们一直在这里保持与为旧版Python编写的程序的向后兼容性。

Python程序员，培训师，学生和图书作者应该随时绕过这些功能，而不必担心丢失重要的东西。

apply(function, args[, keywords])

的功能参数必须是可调用对象（用户定义的或内置的函数或方法，或一个类对象）和ARGS参数必须是一个序列。用args作为参数列表调用该函数 ; 参数的数量是元组的长度。如果可选关键字参数存在，则它必须是键字符串的字典。它指定要添加到参数列表末尾的关键字参数。调用与调用不同，因为在那种情况下总是只有一个参数。使用相当于。apply()function(args)apply()function(*args, **keywords)

自2.3版弃用：请使用，function(*args, **keywords)而不是apply(function, args, keywords)（请参阅解包参数列表）。

buffer(object[, offset[, size]])

的对象参数必须是支持呼叫缓冲器接口（如字符串，数组和缓冲液）的对象。将创建一个引用对象参数的新缓冲区对象。缓冲区对象将是从对象的开头（或从指定的偏移量）开始的一个切片。切片将延伸到对象的末尾（或者将具有由大小参数给定的长度）。

coerce(x, y)

使用与算术运算相同的规则，返回一个由两个数字参数组成的元组。如果胁迫不可行，请提高TypeError。

intern(string)

在“interned”字符串的表格中输入字符串并返回字符串 - 字符串本身或副本。实习字符串对于在字典查找中获得一些性能很有用 - 如果字典中的密钥被实施并且查找密钥被实施，则可以通过指针比较而不是字符串比较来完成关键比较（哈希后）。通常情况下，Python程序中使用的名称会自动实现，并且用于保存模块，类或实例属性的字典具有实际的密钥。

版本2.3中更改：字符串不是不朽的（就像他们以前在Python 2.2和之前）; 你必须保持对intern()周围回报价值的参考才能从中受益。

注