Python 解释器内置了许多始终可用的Function。它们按字母 Sequences 在此处列出。

此外，还有其他四个不再被视为必不可少的内置函数：apply()，buffer()，coerce()和intern()。它们记录在不必要的内置Function部分中。

• abs(* x *)

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

• all(* iterable *)

  • 如果* iterable *的所有元素都为 true(或者 iterable 为空)，则返回True。相当于：

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

2.5 版的新Function。

• any(* iterable *)
  • 如果* iterable *的任何元素为 true，则返回True。如果 iterable 为空，则返回False。相当于：

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

2.5 版的新Function。

• basestring ( )
  • 此抽象类型是str和unicode的超类。它不能被调用或实例化，但是可以用来测试一个对象是str还是unicode的实例。 isinstance(obj, basestring)等效于isinstance(obj, (str, unicode))。

2.3 版的新Function。

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

2.6 版的新Function。

• 类别 bool([* x *])
  • 返回布尔值，即True或False之一。 * x 是使用标准真值测试过程转换的。如果 x *为 false 或Ellipsis，则返回False；否则返回True。 bool也是一个类，是int的子类。类别bool无法再进一步子类别化。它唯一的实例是False和True。

2.2.1 版中的新Function。

在版本 2.3 中更改：如果未提供任何参数，则此函数返回False。

• • class * bytearray([源 [，编码 [，错误]]])
  • 返回一个新的字节数组。 bytearray类是一个可变的整数序列，范围为 0 <= x <256.它具有可变序列类型中描述的大多数可变序列的常用方法，以及str类型具有的大多数方法，请参见String Methods。

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

• 如果它是* unicode ，则还必须提供 encoding (和可选的 errors *)参数； bytearray()然后使用unicode.encode()将 unicode 转换为字节。

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

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

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

没有参数，将创建大小为 0 的数组。

2.6 版的新Function。

• callable(* object *)

  • 如果* object 参数可调用，则返回True，否则返回False。如果返回 true，则调用仍然有可能失败，但是如果为 false，则调用 object *将永远不会成功。注意，类是可调用的(调用一个类将返回一个新实例)。如果类实例具有call()方法，则它们是可调用的。

• chr(* i *)

  • 返回一个字符为 ASCII 码为整数* i 的字符串。例如，chr(97)返回字符串'a'。这是ord()的逆。参数必须在[0..255]范围内(包括 0 和 0.0255)。如果 i *不在该范围内，则ValueError将被引发。另请参见unichr()。

• classmethod(Function)

  • 返回* function *的类方法。

类方法将类作为隐式第一个参数接收，就像实例方法接收实例一样。要语句类方法，请使用以下惯用法：

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

@classmethod表单是函数decorator –有关详细信息，请参见Function definitions。

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

类方法不同于 C 或 Java 静态方法。如果需要这些，请参见staticmethod()。

有关类方法的更多信息，请参见标准类型层次结构。

2.2 版中的新Function。

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

• cmp(* x ， y *)

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

• compile((* source ， filename ， mode * [，* flags * [，* dont_inherit *]])

  • 将* source *编译为代码或 AST 对象。代码对象可以passexec语句执行，也可以pass调用eval()进行评估。 * source 可以是 Unicode 字符串， Latin-1 *编码的字符串或 AST 对象。有关如何使用 AST 对象的信息，请参阅ast模块文档。

• filename *参数应提供从中读取代码的文件；如果未从文件中读取该值，则传递一些可识别的值(通常使用'<string>')。

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

可选参数* flags 和 dont_inherit 控制哪些将来的语句(请参见 PEP 236)影响 source 的编译。如果都不存在(或两个都不为零)，则使用调用compile()的代码中有效的将来语句来编译代码。如果给定了 flags 参数，而* dont_inherit 不为(或为零)，则除了将始终使用的那些语句外，还将使用 flags 参数指定的 Future 语句。如果* dont_inherit 是非零整数，则使用 flags *参数–忽略围绕编译调用有效的将来语句。

将来的语句由位指定，这些位可以按位或以指定多个语句。可以在future模块中_Feature实例上的compiler_flag属性中找到指定给定Function所需的位域。

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

如果要将 Python 代码解析为 AST 表示形式，请参见ast.parse()。

在版本 2.3 中进行了更改：添加了* flags 和* dont_inherit *参数。

在 2.6 版中进行了更改：支持编译 AST 对象。

在 2.7 版中进行了更改：允许使用 Windows 和 Mac 换行符。同样，以'exec'模式 Importing 的内容不必再以换行符结尾。

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

复杂类型在数值类型-整型，浮点型，长整型中描述。

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

• • class * dict(*** kwarg *)
• • class * dict(* mapping ，** kwarg *)
• • class * dict(* iterable ，** kwarg *)
  • 创建一个新的字典。 dict对象是字典类。有关此类的文档，请参见dict和Map 类型— dict。

对于其他容器，请参见内置的list，set和tuple类以及collections模块。

• dir([* object *])
  • 不带参数的情况下，返回当前本地范围内的名称列表。使用一个参数try返回该对象的有效属性列表。

如果对象具有名为__dir__()的方法，则将调用此方法，并且该方法必须返回属性列表。这允许实现自定义getattr()或getattribute()函数的对象自定义dir()报告其属性的方式。

如果对象不提供__dir__()，则该函数将尽最大努力从对象的dict属性(如果已定义)及其类型对象中收集信息。结果列表不一定是完整的，并且当对象具有自定义getattr()时可能是不准确的。

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

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

• 如果对象是类型或类对象，则列表包含其属性的名称以及递归其基础属性的名称。

• 否则，列表将包含对象的属性名称，其类的属性名称以及递归其类的 Base Class 的属性。

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

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

• divmod(* a ， b *)
  • 使用两个(非复数)数字作为参数，并在使用长除法时返回Pair包含其商和余数的数字。对于混合操作数类型，适用于二进制算术运算符的规则。对于纯整数和长整数，结果与(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)相同。

在版本 2.3 中进行了更改：不建议将divmod()与复数一起使用。

• enumerate(* sequence ， start = 0 *)
  • 返回一个枚举对象。 * sequence 必须是序列，iterator或其他支持迭代的对象。 enumerate()返回的迭代器的next()方法返回一个 Tuples，该 Tuples 包含一个计数(从 start 开始，默认为 0)和pass对 sequence *进行迭代而获得的值：

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

Equivalent to:

def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1

2.3 版的新Function。

在 2.6 版中进行了更改：添加了* start *参数。

• eval(* expression * [，* globals * [，* locals *]])
  • 参数是 Unicode 或* Latin-1 编码的字符串以及可选的 globals 和 locals。如果提供， globals 必须是字典。如果提供， locals *可以是任何 Map 对象。

在版本 2.4 中进行了更改：以前需要* locals *作为字典。

• expression 参数使用 globals 和 locals 字典作为全局和局部名称空间，被解析并评估为 Python 表达式(从技术上来说是条件列表)。如果存在 globals 词典并且缺少'builtins'，则在解析 expression 之前，将当前全局变量复制到 globals 中。这意味着 expression 通常具有对标准builtin模块的完全访问权限，并且可以传播受限的环境。如果Ellipsis locals 字典，则默认为 globals *字典。如果Ellipsis两个字典，则在调用eval()的环境中执行表达式。返回值是求值表达式的结果。语法错误被报告为异常。例：

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

此函数还可以用于执行任意代码对象(例如compile()创建的对象)。在这种情况下，传递代码对象而不是字符串。如果代码对象已使用'exec'作为* mode *参数进行编译，则eval()的返回值为None。

提示：exec语句支持动态执行语句。 execfile()函数支持从文件执行语句。 globals()和locals()函数分别返回当前的全局字典和局部字典，这对于传递给eval()或execfile()可能有用。

有关可以安全地使用仅包含 Literals 的表达式求值的字符串的函数，请参见ast.literal_eval()。

• execfile(* filename * [，* globals * [，* locals *]])
  • 此函数类似于exec语句，但是解析文件而不是字符串。它与import语句的不同之处在于它不使用模块 Management-它无条件地读取文件，并且不创建新模块。 [1]

参数是文件名和两个可选字典。使用* globals 和 locals 字典作为全局和本地命名空间，将文件解析为 Python 语句序列(类似于模块)并进行评估。如果提供， locals 可以是任何 Map 对象。请记住，在模块级别，全局变量和局部变量是相同的字典。如果两个单独的对象分别作为 globals 和 locals *传递，则代码将像嵌入在类定义中一样执行。

在版本 2.4 中进行了更改：以前需要* locals *作为字典。

如果Ellipsis* locals 字典，则默认为 globals *字典。如果Ellipsis两个字典，则在调用execfile()的环境中执行该表达式。返回值为None。

• file(* name * [，* mode * [，* buffering *]])
  • file类型的构造函数，将在File Objects部分中进一步描述。构造函数的参数与下面描述的open()内置函数的参数相同。

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

2.2 版中的新Function。

• filter((* function ， iterable *)
  • 从* iterable 的那些元素构造一个列表，对于这些元素， function *返回 true。 * iterable 可以是序列，支持迭代的容器或迭代器。如果 iterable 是字符串或 Tuples，则结果也具有该类型；否则，它始终是列表。如果 function 为None，则假定身份函数，即，删除 iterable *的所有错误元素。

请注意，如果 function 不是None，则filter(function, iterable)等效于[item for item in iterable if function(item)]；如果 function 是None，则_4 等效。

有关此函数的迭代器版本，请参见itertools.ifilter()和itertools.ifilterfalse()，包括用于过滤* function *返回 false 的元素的变体。

• 类别 float([* x *])
  • 返回由数字或字符串* x *构造的浮点数。

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

浮点类型在数值类型-整型，浮点型，长整型中描述。

• format(* value * [，* format_spec *])
  • 根据* format_spec 的控制，将 value *转换为“格式化”的表示形式。 * format_spec 的解释将取决于 value *参数的类型，但是大多数内置类型都使用一种标准格式语法：格式规格迷你语言。

2.6 版的新Function。

• 类别 frozenset([可迭代])

  • 返回一个新的frozenset对象，可以选择包含来自* iterable *的元素。 frozenset是内置类。有关此类的文档，请参见frozenset和集合类型-集合，frozenset。

对于其他容器，请参见内置的set，list，tuple和dict类，以及collections模块。

2.4 版的新Function。

• getattr(* object ， name * [，* default *])

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

• globals ( )

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

• hasattr(* object ， name *)

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

• hash(* object *)

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

• help([* object *])

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

site模块将此Function添加到内置名称空间中。

2.2 版中的新Function。

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

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

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

另请参见int()，以使用 16 为底的十六进制字符串转换为整数。

在版本 2.4 中更改：以前仅返回未签名的 Literals。

• id(* object *)
  • 返回对象的“身份”。这是一个整数(或长整数)，在该对象的生存期内，此整数保证是唯一且恒定的。具有不重叠生存期的两个对象可能具有相同的id()值。

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

• input([提示])
  • 等效于eval(raw_input(prompt))。

此Function不会捕获用户错误。如果 Importing 在语法上无效，则将引发SyntaxError。如果评估期间出现错误，可能会引发其他 exceptions。

如果加载了readline模块，则input()将使用它来提供详细的行编辑和历史记录Function。

考虑将raw_input()函数用于用户的一般 Importing。

• 类别 int(* x = 0 *)

• • class * int(* x ， base = 10 *)
  • 返回由数字或字符串* x 构造的整数对象，如果未提供任何参数，则返回0。如果 x 是数字，则可以是纯整数，长整数或浮点数。如果 x *是浮点数，则转换将截断为零。如果参数超出整数范围，则该函数将返回一个长对象。

如果* x 不是数字或给定 base ，则 x 必须是代表基数 base 中integer literal的字符串或 Unicode 对象。可选地，Literals 可以以+或-开头(之间没有空格)，并用空格包围。以 n 为基数的 Literals 包含数字 0 到 n-1，其中a到z(或A到Z)的值是 10 到 35.默认值 base *是 10.允许的值是 0 和 2–36.与代码中的整数 Literals 一样，Base-2，-8 和-16Literals 可以可选地以0b/0B，0o/0O/0或0x/0X作为前缀。底数 0 意味着将字符串完全解释为整数 Literals，因此实际底数是 2、8、10 或 16.

整数类型在数值类型-整型，浮点型，长整型中描述。

• isinstance(* object ， classinfo *)
  • 如果* object 参数是 classinfo 参数或其子类(直接，间接或virtual)的实例，则返回 true。如果 classinfo 是类型对象(新式类)并且 object 是该类型的对象或其(直接，间接或virtual)子类的对象，则也返回 true。如果 object 不是类实例或给定类型的对象，则该函数始终返回 false。如果 classinfo 是类或类型对象的 Tuples(或递归，其他类似的 Tuples)，则如果 object 是任何类或类型的实例，则返回 true。如果 classinfo *不是类，类型或类，类型以及此类 Tuples 的 Tuples，则会引发TypeError异常。

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

• issubclass(* class ， classinfo *)
  • 如果* class 是 classinfo *的子类(直接，间接或virtual)，则返回 true。类被认为是其自身的子类。 * classinfo 可能是一个类对象的 Tuples，在这种情况下，将检查 classinfo *中的每个条目。在任何其他情况下，都会引发TypeError异常。

在版本 2.3 中进行了更改：添加了对类型信息 Tuples 的支持。

• iter(* o * [，* sentinel *])
  • 返回一个iterator对象。根据第二个参数的存在，第一个参数的解释非常不同。如果没有第二个参数，* o 必须是支持迭代协议(iter()方法)的集合对象，或者它必须支持序列协议(以0开头的整数参数的getitem()方法)。如果它不支持这些协议中的任何一个，则引发TypeError。如果给定第二个参数 sentinel ，则 o 必须是可调用对象。在这种情况下创建的迭代器将在不调用next()方法的情况下调用 o ；如果返回的值等于 sentinel *，则将引发StopIteration，否则将返回该值。

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

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

2.2 版中的新Function。

• len(* s *)
  • 返回对象的长度(项目数)。参数可以是序列(例如字符串，字节，Tuples，列表或范围)或集合(例如字典，集合或冻结集合)。

• 类别 list([可迭代])

  • 返回一个列表，该列表的项与* iterable *的项相同且 Sequences 相同。 * iterable 可以是序列，支持迭代的容器或迭代器对象。如果 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 ( )
  • 更新并返回代表当前本地符号表的字典。当在Function块中调用locals()时，locals()返回自由变量，但在类块中则不。

• 类别 long(* x = 0 *)

• • class * long(* x ， base = 10 *)
  • 返回由字符串或数字* x *构造的长整数对象。如果参数是字符串，则它必须包含一个可能有符号的任意大小，并且可能嵌入在空格中。 * base 参数的解释方式与int()相同，并且仅当 x *是字符串时才可以给出。否则，参数可以是纯或长整数或浮点数，并返回具有相同值的长整数。浮点数到整数的转换将截断(向零)。如果没有给出参数，则返回0L。

long 类型在数值类型-整型，浮点型，长整型中描述。

• map((Function*，可迭代，* ... *)

  • 将* function 应用于 iterable 的每一项，并返回结果列表。如果传递了额外的 iterable 参数，则 function 必须接受那么多参数，并并行应用于所有可迭代对象的项。如果一个可迭代项比另一个可迭代项短，则假定它具有None个项。如果 function *为None，则假定身份函数；如果有多个参数，则map()返回一个包含 Tuples 的列表，该 Tuples 包含所有可迭代对象中的对应项(一种转置操作)。 * iterable *参数可以是一个序列或任何可迭代的对象；结果总是一个列表。

• max(* iterable * [，* key *])

• max(* arg1 ， arg2 ，* args * [，* key *])

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

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

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

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

• memoryview(* obj *)

  • 返回从给定参数创建的“memoryview”对象。有关更多信息，请参见memoryview type。

• min(* iterable * [，* key *])

• min(* arg1 ， arg2 ，* args * [，* key *])

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

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

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

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

• next(迭代器 [，默认])
  • pass调用next()方法从* iterator 中检索下一项。如果给定了 default *，则迭代器用尽了它，否则返回StopIteration。

2.6 版的新Function。

• 类 object
  • 返回一个新的无 Feature 对象。 object是所有新样式类的基础。它具有新样式类的所有实例通用的方法。

2.2 版中的新Function。

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

• oct(* x *)
  • 将整数(任意大小)转换为八进制字符串。结果是有效的 Python 表达式。

在版本 2.4 中更改：以前仅返回未签名的 Literals。

• open(* name * [，* mode * [，* buffering *]])
  • 打开文件，返回File Objects部分中所述的file类型的对象。如果无法打开文件，则引发IOError。打开文件时，最好使用open()而不是直接调用file构造函数。

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

• mode 的最常用值是_用于读取，_用于写入(如果文件已经存在，则将其截断)和'a'用于附加(在某些* Unix 系统上，这意味着* all 会将附加末尾写入)不论当前搜寻位置如何)。如果Ellipsis mode ，则默认为'r'。默认设置为使用文本模式，该模式可以在书写时将'\n'字符转换为特定于平台的表示形式，在阅读时又可以将其转换为特定于平台的表示形式。因此，在打开二进制文件时，应将'b'附加到 mode 值以二进制模式打开文件，这将提高可移植性。 (即使在没有区别对待二进制文件和文本文件的系统上，附加'b'也是有用的，它用作文档.)请参见下面的 mode *的更多可能值。

可选的* buffering 参数指定文件所需的缓冲区大小：0 表示未缓冲，1 表示行缓冲，任何其他正值表示使用(大约)该大小(以字节为单位)的缓冲区。负 buffering *表示使用系统默认值，通常对 tty 设备使用行缓冲，而对于其他文件则使用完全缓冲。如果Ellipsis，则使用系统默认值。 [2]

模式'r+'，'w+'和'a+'打开文件进行更新(读取和写入)；请注意'w+'会截断文件。在区分二进制文件和文本文件的系统上，将'b'附加到以二进制模式打开文件的模式；在没有此区别的系统上，添加'b'无效。

除标准fopen()值外，* mode 还可为'U'或'rU'。 Python 通常是passuniversal newlines支持构建的；提供'U'会以文本文件形式打开文件，但是行可能会被以下任一终止：Unix 换行符'\n'，Macintosh 约定'\r'或 Windows 约定'\r\n'。所有这些外部表示在 Python 程序中都被视为'\n'。如果 Python 是在没有通用换行符的情况下构建的，则'U'的 mode *与普通文本模式相同。请注意，如此打开的文件对象还具有一个名为newlines的属性，该属性的值是None(如果尚未看到换行符)，'\n'，'\r'，'\r\n'或包含所有看到的换行符类型的 Tuples。

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。对于 8 位字符串，这是chr()的反之；对于 unicode 对象，这是unichr()的反之。如果给出了 unicode 参数，并且 Python 是使用 UCS2 Unicode 构建的，则字符的代码点必须在[0..65535]范围内；否则，字符串长度为 2，并且将引发TypeError。

• pow(* x ， y * [，* z *])

  • 将* x 返回到幂 y ；如果存在 z ，则将 x 返回到幂 y ，以 z *为模(比pow(x, y) % z的计算效率更高)。两个参数的形式pow(x, y)等效于使用幂运算符x**y。

参数必须具有数字类型。对于混合操作数类型，适用于二进制算术运算符的强制规则。对于 int 和 long int 操作数，除非第二个参数为负，否则结果的类型与操作数相同(强制后)。在这种情况下，所有参数都将转换为 float 并传递 float 结果。例如，10**2返回100，但是10**-2返回0.01。 (这最后一个Function是在 Python 2.2 中添加的.在 Python 2.1 及之前的版本中，如果两个参数均为整数类型，并且第二个参数为负，则会引发异常.)如果第二个参数为负，则必须Ellipsis第三个参数。如果存在* z ，则 x 和 y 必须为整数类型，而 y *必须为非负数。 (此限制是在 Python 2.2 中添加的.在 Python 2.1 及以前的版本中，浮点 3 参数pow()返回取决于平台的结果，具体取决于浮点舍入事故.)

• print(** objects ， sep =''， end =' n'， file = sys.stdout *)
  • 将* object 打印到流 file 中，以 sep 分隔，然后以 end *分隔。 * sep ， end 和 file *(如果存在)必须作为关键字参数给出。

所有非关键字参数都将转换为类似于str()的字符串，并写入流中，以* sep 分隔，后跟 end *。 * sep 和 end 都必须是字符串；它们也可以是None，表示使用默认值。如果没有给出 object ，print()将只写 end *。

• file 参数必须是具有write(string)方法的对象；如果不存在或None，将使用sys.stdout。输出缓冲由 file *确定。使用file.flush()可以确保例如立即出现在屏幕上。

from __future__ import print_function

2.6 版的新Function。

• • class * property([* fget * [，* fset * [，* fdel * [，* doc *]]]])
  • 返回new-style class es(从object派生的类)的属性属性。

• fget *是用于获取属性值的函数。 * fset *是用于设置属性值的Function。 * 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.x是删除器。

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

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

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

@property装饰器将voltage()方法转换为具有相同名称的只读属性的“获取器”，并且将* 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

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

返回的属性对象还具有与构造函数参数相对应的属性fget，fset和fdel。

2.2 版中的新Function。

在版本 2.5 中进行了更改：如果未提供* doc ，请使用 fget *的 docstring。

在 2.6 版中进行了更改：添加了getter，setter和deleter属性。

• range(停止)

• range(开始，停止 [，步骤])

  • 这是创建包含算术级数的列表的通用Function。它最常用于for循环中。参数必须是纯整数。如果Ellipsis* step 参数，则默认为1。如果Ellipsis start 参数，则默认为0。完整形式返回一个纯整数[start, start + step, start + 2 * step, ...]的列表。如果 step 为正，则最后一个元素是小于 stop 的最大start + i * step；如果 step 为负，则最后一个元素是大于 stop *的最小start + i * step。 * step *不得为零(否则引发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 *参数，则将其写入标准输出而不会在末尾添加换行符。然后，该函数从 Importing 中读取一行，将其转换为字符串(带末尾的换行符)，然后将其返回。读取 EOF 时，将引发EOFError。例：

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

如果加载了readline模块，则raw_input()将使用它来提供详细的行编辑和历史记录Function。

• reduce(* function ， iterable * [，* initializer *])
  • 从左到右，将两个参数的* function 累计应用于 iterable 的项，以将 iterable 减小为单个值。例如，reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])计算((((1+2)+3)+4)+5)。左参数 x 是累加值，右参数 y 是 iterable 中的更新值。如果存在可选的 initializer ，则它将它放在计算中可迭代项的前面，并在可迭代项为空时用作默认值。如果未提供 initializer 且 iterable *仅包含一项，则返回第一项。大致相当于：

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 *)
  • 重新加载先前导入的* module 。参数必须是模块对象，因此它必须已经成功导入。如果您已使用外部编辑器编辑了模块源文件，并且想在不离开 Python 解释器的情况下try新版本，则这将非常有用。返回值是模块对象(与 module *参数相同)。

当执行reload(module)时：

• 重新编译 Python 模块的代码并重新执行模块级代码，从而定义了一组新对象，这些对象绑定到模块字典中的名称。扩展模块的initFunction不再被调用。

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

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

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

还有其他一些警告：

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

try:
    cache
except NameError:
    cache = {}

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

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

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

• repr(* object *)

  • 返回包含对象的可打印表示形式的字符串。这与转化产生的值相同(反引号)。能够以常规Function访问此操作有时很有用。对于许多类型，此函数会try返回一个字符串，该字符串在传递给eval()时将产生具有相同值的对象，否则表示形式是一个用尖括号括起来的字符串，其中包含对象类型的名称以及其他内容。信息通常包括对象的名称和地址。一个类可以pass定义repr()方法来控制此函数为其实例返回的内容。

• reversed(* seq *)

  • 返回反向iterator。 * seq *必须是具有reversed()方法或支持序列协议(len()方法和getitem()方法的整数参数以0开头)的对象。

2.4 版的新Function。

在 2.6 版中进行了更改：添加了编写自定义reversed()方法的可能性。

• round(* number * [，* ndigits *])
  • 返回浮点数* number 小数点后四舍五入为 ndigits 位。如果Ellipsis ndigits ，则默认为零。结果是一个浮点数。值四舍五入为乘幂减去 ndigits *的最接近的 10 的倍数；如果两个倍数相等地接近，则四舍五入时应远离 0(例如round(0.5)是1.0，而round(-0.5)是-1.0)。

• 类别 set([可迭代])

  • 返回一个新的set对象，可以选择包含来自* iterable *的元素。 set是内置类。有关此类的文档，请参见set和集合类型-集合，frozenset。

对于其他容器，请参见内置的frozenset，list，tuple和dict类，以及collections模块。

2.4 版的新Function。

• setattr((* object ， name ， value *)

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

• 类别 slice(停止)

• • class * slice(* start ， stop * [，* step *])
  • 返回表示由range(start, stop, step)指定的索引集的slice对象。 * start 和 step *参数默认为None。切片对象具有只读数据属性start，stop和step，它们仅返回参数值(或其默认值)。它们没有其他显式Function。但是，它们被数值 Python 和其他第三方扩展使用。使用扩展索引语法时，也会生成切片对象。例如：a[start:stop:step]或a[start:stop, i]。有关返回迭代器的替代版本，请参见itertools.islice()。

• sorted(* iterable * [，* cmp * [，* key * [，* reverse *]]])
  • 从* iterable *中的项目返回一个新的排序列表。

可选参数* cmp ， key 和 reverse *与list.sort()方法(在可变序列类型部分中介绍)的含义相同。

• cmp *指定两个参数(可迭代元素)的自定义比较函数，该函数应返回负数，零数或正数，具体取决于第一个参数是否小于，等于或大于第二个参数cmp=lambda x,y: cmp(x.lower(), y.lower())。默认值为None。

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

• reverse *是一个布尔值。如果设置为True，则对列表元素进行排序，就好像每个比较都被反转一样。

通常，* key 和 reverse 转换过程比指定等效的 cmp 函数要快得多。这是因为 cmp 被每个列表元素多次调用，而 key 和 reverse 仅触摸每个元素一次。使用functools.cmp_to_key()将旧式 cmp 函数转换为 key *函数。

内置的sorted()Function保证稳定。如果排序保证不改变比较相等的元素的相对 Sequences，则该排序是稳定的-这有助于多次pass排序(例如，按部门排序，然后按薪级排序)。

有关排序示例和简短的排序教程，请参见排序方式。

2.4 版的新Function。

• staticmethod(Function)
  • 返回* function *的静态方法。

静态方法不会收到隐式的第一个参数。要语句静态方法，请使用以下惯用法：

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

@staticmethod表单是函数decorator –有关详细信息，请参见Function definitions。

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

Python 中的静态方法类似于 Java 或 C 中的静态方法。另请参见classmethod()，该变量对于创建备用类构造函数很有用。

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

2.2 版中的新Function。

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

• • class * str(* object =''*)
  • 返回一个字符串，其中包含对象的漂亮可打印表示形式。对于字符串，这将返回字符串本身。与repr(object)的区别在于str(object)并不总是try返回eval()可接受的字符串；它的目标是返回可打印的字符串。如果未提供任何参数，则返回空字符串''。

有关字符串的更多信息，请参见序列类型— str，unicode，list，tuple，bytearray，buffer，xrange，它描述了序列Function(字符串是序列)，以及String Methods部分中描述的特定于字符串的方法。要输出格式化的字符串，请使用模板字符串或字符串格式化操作部分中所述的%运算符。此外，请参见String Services部分。另请参见unicode()。

• sum(* iterable * [，* start *])
  • 从左到右对* start 和 iterable *的项求和，并返回总数。 开始默认为0。 * iterable *的项目通常是数字，并且起始值不允许为字符串。

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

2.3 版的新Function。

• super(* type * [，* object-or-type *])
  • 返回将方法调用委托给* type 的父级或同级类的代理对象。这对于访问已在类中重写的继承方法很有用。搜索 Sequences 与getattr()使用的搜索 Sequences 相同，只是 type *本身被跳过。

• type *的mro属性列出了getattr()和super()所使用的方法分辨率搜索 Sequences。该属性是动态的，并且在继承层次结构更新时可以更改。

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

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

第二个用例是在动态执行环境中支持协作式多重继承。该用例是 Python 特有的，在静态编译语言或仅支持单继承的语言中找不到。这样就可以在多个 Base Class 实现相同方法的情况下实现“菱形图”。良好的设计表明，此方法在每种情况下都具有相同的调用签名(因为调用的 Sequences 是在运行时确定的，因为该 Sequences 可以适应类层次结构中的更改，并且因为该 Sequences 可以包含在运行时之前未知的同级类)。

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

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

请注意，super()是作为诸如super().__getitem__(name)之类的显式点分属性查找的绑定过程的一部分而实现的。它pass实现自己的getattribute()方法以支持可协作多重继承的可预测 Sequences 搜索类来实现。因此，对于使用语句或super()[name]之类的隐式查找，未定义super()。

另请注意，super()不限于在内部方法中使用。两个参数形式准确地指定了参数并进行了适当的引用。

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

2.2 版中的新Function。

• tuple([可迭代])
  • 返回一个与* iterable *的项目相同且 Sequences 相同的 Tuples。 * iterable 可以是序列，支持迭代的容器或迭代器对象。如果 iterable *已经是一个 Tuples，则将其保持不变。例如，tuple('abc')返回('a', 'b', 'c')，tuple([1, 2, 3])返回(1, 2, 3)。如果未提供任何参数，则返回一个新的空 Tuples()。

tuple是不可变的序列类型，如序列类型— str，unicode，list，tuple，bytearray，buffer，xrange中所述。对于其他容器，请参见内置的dict，list和set类以及collections模块。

• 类别 type(对象)

• • class * type(* name ， base ， dict *)
  • 使用一个参数，返回* object *的类型。返回值是一个类型对象。建议使用isinstance()内置函数来测试对象的类型。

具有三个参数，返回一个新的类型对象。这本质上是class语句的动态形式。 * name *字符串是类名称，并成为name属性； * base *Tuples 逐项列出 Base Class 并成为bases属性； * dict *字典是包含类主体定义的名称空间，并成为dict属性。例如，以下两个语句创建相同的type对象：

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

2.2 版中的新Function。

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

2.0 版中的新Function。

• unicode(* object =''*)

• unicode(* object * [，* encoding * [，* errors *]])

  • 使用以下方式之一返回* object *的 Unicode 字符串版本：

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

如果未提供任何可选参数，则unicode()将模仿str()的行为，除了它返回 Unicode 字符串而不是 8 位字符串。更准确地说，如果* object *是 Unicode 字符串或子类，它将返回该 Unicode 字符串，而无需应用任何其他解码。

对于提供unicode()方法的对象，它将在不带参数的情况下调用此方法以创建 Unicode 字符串。对于所有其他对象，要求使用 8 位字符串版本或表示形式，然后使用编解码器将其转换为 Unicode 字符串，以实现'strict'模式下的默认编码。

有关 Unicode 字符串的更多信息，请参见序列类型— str，unicode，list，tuple，bytearray，buffer，xrange，它描述了序列Function(Unicode 字符串是序列)，以及String Methods部分中描述的特定于字符串的方法。要输出格式化的字符串，请使用模板字符串或字符串格式化操作部分中所述的%运算符。此外，请参见String Services部分。另请参见str()。

2.0 版中的新Function。

在版本 2.2 中更改：添加了对unicode()的支持。

• vars([* object *])
  • 返回模块，类，实例或具有dict属性的任何其他对象的dict属性。

对象(例如模块和实例)具有可更新的dict属性；但是，其他对象可能对其dict属性具有写限制(例如，新式类使用 dictproxy 来防止直接字典更新)。

没有参数，vars()的行为就像locals()。请注意，由于忽略了本地字典的更新，因此本地字典仅对读取有用。

• xrange(停止)

• xrange(开始，停止 [，步骤])

  • 此函数非常类似于range()，但是返回xrange object而不是列表。这是一种不透明的序列类型，其产生的值与对应的列表相同，而实际上并没有同时存储它们。 xrange()优于range()的优势很小(因为xrange()仍然需要在创建值时创建值)，除非在内存不足的计算机上使用了非常大的范围，或者从未使用过范围的所有元素时(例如当循环通常以break终止。有关 xrange 对象的更多信息，请参见XRange Type和序列类型— str，unicode，list，tuple，bytearray，buffer，xrange。

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

• zip([[* iterable ， ... *])
  • 此函数返回一个 Tuples 列表，其中第* i 个 Tuples 包含每个参数序列或可迭代对象中的第 i *个元素。返回的列表的长度被截断为最短参数序列的长度。当存在多个具有相同长度的参数时，zip()类似于map()，其初始参数为None。使用单个序列参数，它将返回一个 1Tuples 的列表。没有参数，它将返回一个空列表。

保证了可迭代对象的从左到右的评估 Sequences。这使使用zip(*[iter(s)]*n)将数据系列聚类为 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 版中的新Function。

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

__import__(* name * [，* globals * [，* locals * [，* fromlist * [，* level *]]]])

与importlib.import_module()不同，这是日常 Python 编程中不需要的高级Function。

import语句调用此函数。可以替换它(pass导入builtin模块并分配给__builtin__.__import__)以更改import语句的语义，但是如今，使用导入钩子通常更简单(请参见 PEP 302)。很少使用import()，除非要导入仅在运行时知道其名称的模块。

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

• level *指定使用绝对导入还是相对导入。默认值为-1，表示将同时try绝对导入和相对导入。 0表示仅执行绝对导入。 * level *的正值表示相对于调用import()的模块目录，要搜索的父目录数。

当* name 变量的格式为package.module时，通常返回顶级包(直到第一个点的名称)，而不是 name 命名的模块。但是，当给出非空的 fromlist 参数时，将返回以 name *命名的模块。

例如，语句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 中更改：添加了 level 参数。

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

3.不必要的内置函数

在现代 Python 编程中，不再需要学习，了解或使用一些内置函数。将它们保留在此处以保持与为旧版本 Python 编写的程序向后兼容。

Python 程序员，培训师，学生和图书作者应随时绕过这些Function，而不必担心会丢失重要的内容。

• apply((* function ， args * [，* keywords *])
  • • function 参数必须是可调用的对象(用户定义或内置的函数或方法，或类对象)，而 args 参数必须是一个序列。以 args 为参数列表调用 function ；参数的数量是 Tuples 的长度。如果存在可选的 keywords *参数，则它必须是键为字符串的字典。它指定要添加到参数列表末尾的关键字参数。调用apply()与仅调用function(args)有所不同，因为在这种情况下，始终只有一个参数。 apply()的使用等效于function(*args, **keywords)。

从 2.3 版开始不推荐使用：使用function(*args, **keywords)而不是apply(function, args, keywords)(请参见解包参数列表)。

• buffer(* object * [，* offset * [，* size *]])

  • • object 参数必须是支持缓冲区调用接口的对象(例如字符串，数组和缓冲区)。将创建一个引用 object 参数的新缓冲区对象。缓冲区对象将从 object 的开头(或从指定的 offset )开始是一个切片。切片将延伸到 object 的末尾(或具有 size *参数指定的长度)。

• coerce(* x ， y *)

  • 使用与算术运算相同的规则，返回由转换为通用类型的两个数字参数组成的 Tuples。如果无法强制，请提高TypeError。

• intern(* string *)

  • 在“ interned”字符串表中 Importing* string 并返回该 interned 字符串–它本身就是 string *或副本。插入字符串对于提高字典查找的性能很有用–如果字典中的键被插入，并且查找键被插入，则键比较(散列后)可以pass指针比较而不是字符串比较来完成。通常，Python 程序中使用的名称会被自动插入，而用于保存模块，类或实例属性的字典则具有插入键。

在版本 2.3 中进行了更改：内联字符串不是不朽的(就像它们曾经在 Python 2.2 及之前的版本中一样)；您必须保留对返回值intern()的引用才能从中受益。

Footnotes

• [1]

  • 它很少使用，因此不保证被语句。

• [2]

  • 当前指定缓冲区大小对没有setvbuf()的系统无效。指定缓冲区大小的接口不是使用调用setvbuf()的方法来完成的，因为在执行任何 I/O 之后调用该方法时，它可能会转储核心，并且没有可靠的方法来确定是否是这种情况。

• 3

  • 在当前的实现中，通常无法以这种方式影响局部变量绑定，但是从其他作用域(例如模块)检索的变量可能会受到影响。这可能会改变。