python 内置函数

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

内置函数
abs()	divmod()	input()	open()	staticmethod()
all()	enumerate()	int()	ord()	str()
any()	eval()	isinstance()	pow()	sum()
basestring()	execfile()	issubclass()	print()	super()
bin()	file()	iter()	property()	tuple()
bool()	filter()	len()	range()	type()
bytearray()	float()	list()	raw_input()	unichr()
callable()	format()	locals()	reduce()	unicode()
chr()	frozenset()	long()	reload()	vars()
classmethod()	getattr()	map()	repr()	xrange()
cmp()	globals()	max()	reversed()	zip()
compile()	hasattr()	memoryview()	round()	__import__()
complex()	hash()	min()	set()
delattr()	help()	next()	setattr()
dict()	hex()	object()	slice()
dir()	id()	oct()	sorted()

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

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

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

高清全（迭代器）：

    为 元素
的 迭代：

       如果没有 元素：

           返回假

    返回真

2.5版本中的新功能

any（可迭代）
True如果迭代的任何元素为真，则返回。如果迭代是空的，则返回False。相当于：

DEF  任何（迭代器）：

    为 元素
的 迭代：

       如果 元素：

           返回真正的

    回报假

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（功能）
为函数返回一个类方法。

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

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 < yx == yx > y

compile（source，filename，mode [，flags [，dont_inherit ] ] ）
将源代码编译成代码或AST对象。代码对象可以通过exec语句执行，也可以通过调用来执行eval()。 源可以是Unicode字符串，Latin-1编码的字符串或AST对象。ast有关如何使用AST对象的信息，请参阅模块文档。

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

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

可选的参数标志和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

类dict（** kwarg ）
类dict（映射，** kwarg ）
类dict（可迭代，** kwarg ）
创建一个新的字典。该dict对象是字典类。请参阅dict和映射类型
-有关此类文档的字典。

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

dir（[ object ] ）
没有参数，返回当前本地作用域中的名称列表。使用参数尝试返回该对象的有效属性列表。

如果该对象具有一个名为的方法__dir__()，则此方法将被调用，并且必须返回属性列表。这允许实现自定义__getattr__()或__getattribute__()功能的对象 定制dir()报告其属性的方式 。

如果对象没有提供__dir__()，那么函数尽量从对象的__dict__属性（如果已定义）以及从其类型对象收集信息。结果列表不一定完整，并且在对象具有自定义时可能不准确__getattr__()。

默认dir()机制的行为与不同类型的对象有所不同，因为它试图产生最相关的信息，而不是完整的信息：

·        如果对象是模块对象，则列表将包含模块属性的名称。

·        如果对象是类型或类对象，则列表包含其属性的名称，并递归地显示其基础的属性。

·        否则，该列表包含对象的属性名称，其类属性的名称以及其类的基类的属性的递归。

结果列表按字母顺序排序。例如：

>>> import
 struct


>>> dir
（）   ＃显示模块名称空间中的名称

['__builtins__'，'__doc__'，'__name__'，'struct']

>>> dir
（struct ）  ＃显示结构体中的名称module

['Struct'，'__builtins__'，

'__doc__'，'__file__'，'__name

__'，'__package__'，'_clearcache'，'calcsize'，'error'，'pack'，'pack_into'，'unpack'， 'unpack_from']

>>> class
 Shape
（object
）：

       def __dir __（self）：

           return ['区域'，'周长'，'位置']

>>> s 
=  Shape
（）

>>>dir
（s ）

['area'，'perimeter'，'location']

注意
 
由于dir()主要是为了方便在交互提示中使用，因此它试图提供一组有趣的名称，而不是试图提供严格或一致定义的名称集，而且其详细行为可能会在不同版本之间发生变化。例如，当参数是一个类时，元类属性不在结果列表中。
divmod（a，b ）
以两个（非复数）数字作为参数，并在使用长整数时返回由它们的商和余数组成的一对数字。混合操作数类型适用于二元算术运算符的规则。对于普通和长整数，结果是一样的。对于浮点数的结果是，其中q通常是 但可能比1小。在任何情况下，是非常接近的 一个，如果不为零，它具有相同的符号为b，和。(a // b,a % b)(q, a % b)math.floor(a / b)q * b + a % ba % b0 <= abs(a % b) < abs(b)

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

enumerate（sequence，start = 0 ）
返回一个枚举对象。序列必须是一个序列，一个 迭代器或其他支持迭代的对象。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'秋季'），（4，'冬'）]

相当于：

DEF  枚举（序列， 开始=
0 ）：

   ñ  =
 开始

    为ELEM 
在 序列：

       收率 Ñ
，ELEM

       Ñ  + =
 1

2.3版本中的新功能

在2.6版本中更改：将启动加入参数。

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

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

该表达参数分析，并作为一个Python表达式来使用（从技术上来说，一个条件列表）全局和当地人 的字典作为全局和局部名字空间。如果globals字典存在，并且缺少“__builtins__”，则 在解析表达式之前，将当前全局变量复制到全局变量中。这意味着表达式通常具有对标准模块的完全访问权，并且传播了受限制的环境。如果省略了locals字典，则默认为全局变量__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语句序列（类似于模块）使用globals和locals字典作为全局和本地名称空间进行评估。如果提供，本地人可以是任何映射对象。请记住，在模块级别，全局变量和本地变量是相同的字典。如果两个单独的对象作为全局变量和本地变量传递，那么代码将被嵌入类定义中执行。

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

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

注意
 
默认的locals按照locals()下面的函数描述：不应该尝试修改默认的locals字典。如果在函数返回后需要查看代码对本地代码的影响，则传递一个显式的本地字典 。 不能可靠地用来修改一个函数的本地。execfile()execfile()
file（name [，mode [，buffering ] ] ）
file类型的构造函数，在文件对象部分进一步描述 。构造函数的参数与open()下面描述的内置函数的参数相同。

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

2.2版本中的新功能

filter（函数，可迭代）
构建从这些元素的列表迭代为此函数返回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。

注意
 
传递字符串时，可能会返回NaN和Infinity的值，具体取决于底层的C库。对于NaN和正或负无限，Float接受字符串nan，inf和-inf。对于NaN，情况和领导+被忽略以及领先 - 被忽略。Float总是代表NaN，无穷大代表nan，inf或-inf。
浮点类型用数字类型描述-
int，float，long，complex。

将值转换为格式化的表示形式，由format_spec控制 。format_spec的解释将取决于value参数的类型，但有一种标准的格式化语法被大多数内置类型使用：FormatSpecification
Mini-Language。

注意
 
format(value, format_spec)只是打电话 value.__format__(format_spec)。
2.6版本中的新功能）

返回一个新的frozenset对象，可选的元素从 迭代中获取。 frozenset是一个内置的类。请参阅frozenset和 设置类型
- 设置，冻结关于此类的文档。

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

2.4版本中的新功能

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

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

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

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

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

这个函数被模块添加到内置的名字空间中site。

2.2版本中的新功能

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

>>> hex
（255
）

'0xff'

>>> hex
（- 42
）

'-0x2a'

>>> hex
（1 L
）

'0x1L'

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

另请参阅int()使用16的基数将十六进制字符串转换为整数。

注意
 
要获取浮点数的十六进制字符串表示形式，请使用该 float.hex()方法。
在版本2.4中更改：以前只返回一个无符号的文字。

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

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

相当于eval(raw_input(prompt))。

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

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

考虑使用raw_input()用户的一般输入功能。

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

如果X不是数字或如果基给出，则X必须是字符串或Unicode对象表示面值整数在基数 基。可选地，文字可以在前面+或之间-（没有空格）并且被空白包围。base-n文字由数字0到n-1组成，其中a to 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中描述。

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

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

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

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

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

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

与开放（'mydata.txt'
） 作为 FP
：

    用于 线
在ITER
（FP 。readline的，
'' ）：

       process_line （线）

2.2版本中的新功能

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

返回一个列表，其项目与迭代的项目相同，顺序相同。 可迭代可以是序列，支持迭代的容器或迭代器对象。如果可迭代已经是一个列表，则复制被创建并返回，类似于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()在函数块中调用自由变量时会返回自由变量，但不会在类块中调用变量。

注意
 
这本词典的内容不应该修改; 更改可能不会影响解释器使用的本地变量和自由变量的值。
返回一个由字符串或数字x构造的长整数对象。如果参数是一个字符串，它必须包含一个可能有符号数的任意大小，可能嵌入在空格中。所述碱参数被解释以相同的方式作为用于 int()，当仅可以给出X是一个字符串。否则，参数可能是一个普通或长整数或一个浮点数，并返回一个具有相同值的长整数。浮点数转换为整数截断（趋近于零）。如果没有参数，返回0L。

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

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

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

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

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

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

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

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

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

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

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

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

2.6版本中的新功能

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

2.2版本中的新功能

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

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

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

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

前两个参数与stdios 相同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版本更改：引入模式字符串的第一个字母的限制。

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

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

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

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

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

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

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

从__future__
 导入print_function

2.6版本中的新功能

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

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

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

 C
类（对象）：

    def
 __init__
（self
）：

       self
。_x  =
 无

 

    def
 getx
（self
）：

       返回自我。_X

 

    def
 setx
（self
， value ）：

       self
。_x  =
 值

 

    def
 delx
（self
）：

       del
 self
。_X

 

   x  =
 property（getx
， setx ， delx ， “我是'x'属性。”
）

如果c是C的一个实例，c.x将调用getter， 将调用setter和deleter。c.x = valuedel c.x

如果给定，doc将是属性属性的文档字符串。否则，该属性将复制fget的文档字符串（如果存在）。这使得可以使用property()作为装饰器轻松创建只读属性：

class  Parrot
（object
）：

    def
 __init__
（self
）：

       self
。_voltage 
=  100000

 

    @property


    def
 voltage
（self
）：

       “”“获取当前电压。”“”

       返回自我。_电压

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

一个属性对象具有getter，setter以及deleter可用作为创建属性的副本设置为装饰功能相应的存取功能的装饰方法。最好用一个例子来解释：

 C
类（对象）：

    def
 __init__
（self
）：

       self
。_x  =
 无

 

    @property


    def
 x
（self
）：

       “”“我是'x'属性。”“”

        return
 self。_X

 

    @x
。setter

    def
 x
（self
， value ）：

       自我。_x 
=  值

 

    @x
。deleter

    def
 x
（self
）：

       del
 self
。_X

这段代码和第一个例子完全相同。一定要赋予与原始属性相同名称的附加功能（x在这种情况下）。

返回的属性对象也有属性fget，fset以及 fdel相对应的构造函数的参数。

2.2版本中的新功能

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

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

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

>>> 范围（10
）

[0，1，2，3，4，5，6，7，8，9]

>>> 范围（1
， 11
）

[1，2，3，4，5，6， 7，8，9，10]

>>> 范围（0
， 30
， 5 ）

[0，5，10，15，20，25]

>>> 范围（0
， 10
， 3 ）

[0，3，6， 9]

>>> range
（0 ，
- 10
， - 1
）

[0，-1，-2，-3，-4，-5，-6，-7，-8，-9]

>>> range（0
）

[]

>>> 范围（1
， 0
）

[]

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

>>> s 
=  raw_input
（' ->'
）

- > Monty Python的飞行马戏团

>>> s

“Monty Python的飞行马戏团”

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

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

def  reduce
（function ， iterable ， initializer
= None ）：

   it  =
 iter（iterable
）

    如果 初始化器
是None
：

       try
：

           initializer  =
 next
（it ），

       除了StopIteration
：

           raise
 TypeError
（'没有初始值的空序列的reduce（）'
）

   accum_value  =
 初始化

    为X 
在 它：

       accum_value =
 函数（accum_value
，x ）

    返回accum_value

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

何时reload(module)执行：

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

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

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

·        对旧对象的其他引用（例如模块外部的名称）不会反弹到引用新对象，并且必须在每个需要的位置发生更新。

还有一些其他的警告：

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

尝试：

    缓存

除了NameError
：

    缓存 =
 {}

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

如果一个模块使用from... 从另一个模块导入对象import，则调用reload()另一个模块不会重新定义从其导入的对象
- 一种方法是重新执行from语句，另一种方法是使用import限定名称（module。*
name *）。

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

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

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

2.4版本中的新功能

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

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

注意
 
round()浮动的行为可能会令人惊讶：例如， 给出而不是预期的。这不是一个错误：这是大多数小数不能完全表示为浮点数的结果。有关更多信息，请参见浮点算术：问题和限制。round(2.675, 2)2.672.68
返回一个新的set对象，可选的元素从 迭代中获取。 set是一个内置的类。请参阅set和 设置类型
- 设置，冻结关于此类的文档。

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

2.4版本中的新功能

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

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

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

可选参数cmp，key和reverse与该list.sort()方法的含义相同（在Mutable SequenceTypes部分中描述 ）。

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

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

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

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

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

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

2.4版本中的新功能

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

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

 C
类（对象）：

    @staticmethod


    def
 f
（arg1 ， arg2 ，
... ）：

       ...

该@staticmethod形式是一个函数装饰 -见的功能定义描述函数定义的细节。

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

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

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

2.2版本中的新功能

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

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

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

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

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

2.3版本中的新功能

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

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

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

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

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

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

 C
类（B
）：

    def
 方法（self
， arg ）：

       super
（C ， self ）。方法（arg
）

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

另请注意，super()不限于使用里面的方法。这两个参数形式确切地指定了参数，并作出适当的参考。

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

2.2版本中的新功能

返回一个元组，其元素与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模块。

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

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

>>> class
 X
（object
）：

...     a 
=  1

...

>>> X 
=  type
（'X'
， （object ，），
dict （a
= 1 ））

2.2版本中的新功能

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

2.0版本中的新功能

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

如果给出了编码和/或错误，unicode()则使用编解码器对可以是8位字符串或字符缓冲器的对象进行解码以进行 编码。该编码参数是给出的编码的名称的字符串; 如果编码未知，LookupError则引发。错误处理是根据错误完成的; 这指定了对输入编码中无效字符的处理。如果错误是'strict'（默认）， ValueError错误'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__()添加。

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

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

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

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

>>> Ŷ 
=  [
4 ， 5
， 6
]

>>> 压缩
=  拉链（X， ÿ ）

>>> 压缩

[（1,4），（2,5 ），（3,6）]

>>> x2
，y2  =
 zip （*
zip ）

>>> x 
==  list
（x2 ） and
 y  ==
 list
（y2 ）

真正

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__()。

当名称变量的形式为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
。鸡蛋

香肠 =  _temp
。香肠

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

如果您只是想按名称导入一个模块（可能在一个包中），请使用importlib.import_module()。

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

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

3.非必需的内置功能

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

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

apply（函数，参数[，关键字] ）
的功能参数必须是可调用对象（用户定义的或内置的函数或方法，或一个类对象）和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（字符串）
在“interned”字符串的表格中输入字符串，并返回字符串本身或一个副本。实习字符串对于在字典查找中获得一些性能非常有用 - 如果字典中的密钥被实施，并且查找密钥被实施，那么可以通过指针比较而不是字符串比较来完成密钥比较（哈希后）。通常情况下，Python程序中使用的名称是自动实现的，用于保存模块，类或实例属性的字典都有实际的密钥。

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

脚注

[1]	它使用相对很少，所以不能作出声明。

 

[2]	指定缓冲区大小当前对没有的系统没有影响 setvbuf()。指定缓冲区大小的接口不是使用调用的方法完成的setvbuf()，因为在执行任何I / O操作之后调用核心，并且没有可靠的方法来确定是否是这种情况。

 

[3]	在当前的实现中，局部变量绑定通常不会受到这种影响，但是从其他作用域（如模块）中获取的变量可以是。这可能会改变。