2.内置函数

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 （ 可迭代 ）

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

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

any （ 可迭代 ）

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

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

ascii （ object  ）

如repr()，由返回的字符串中返回一个包含对象的可打印表示一个字符串，但逃避非ASCII字符 repr()使用\x，\u或\U逃逸。这会生成一个类似于repr()Python 2 中返回的字符串。

bin （ x  ）

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

>>>

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

如果需要前缀“0b”，则可以使用以下任一方式。

>>>

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

另见format()更多信息。

class  bool （ [  x  ]  ）

返回一个布尔值，即一个True或False。 x使用标准真相测试程序进行转换。如果x为假或省略，则返回False; 否则返回True。的 bool类是的子类int（参见数值类型-整数，浮点，复合）。它不能进一步分类。它唯一的例子是False和 True（参见布尔值）。

class  bytearray （ [  source  [ ， encoding  [ ， errors  ]  ]  ]  ）

返回一个新的字节数组。的bytearray类是整数的范围为0 <= X一个可变的序列<256它具有最的可变序列，在所描述的常规方法的可变序列类型，以及大多数方法，该bytes类型已见字节和ByteArray操作。

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

• 如果它是一个字符串，则还必须给出编码（以及可选的 错误）参数; bytearray()然后使用字符串转换为字节str.encode()。
• 如果它是一个整数，则数组将具有该大小，并将用空字节进行初始化。
• 如果它是符合缓冲区接口的对象，则将使用该对象的只读缓冲区来初始化字节数组。
• 如果它是可迭代的，它必须是范围内的整数的迭代 ，它们被用作数组的初始内容。0 <= x < 256

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

另请参见二进制序列类型 - 字节，bytearray，memoryview和Bytearray对象。

class  bytes （ [  source  [ ， encoding  [ ， errors  ]  ]  ]  ）

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

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

字节对象也可以使用文字创建，请参阅字符串和字节文字。

另请参见二进制序列类型 - 字节，字节阵列，内存视图，字节对象以及字节和字节阵列操作。

callable （ object  ）

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

3.2版本中的新功能：此功能在Python 3.0中首先被删除，然后在Python 3.2中被带回。

chr （ i  ）

返回表示Unicode代码点为整数i的字符的字符串。例如，chr(97)返回字符串'a'，同时 chr(8364)返回字符串'€'。这是与之相反的ord()。

参数的有效范围是从0到1,114,111（基于16的0x10FFFF）。 ValueError如果我在这个范围之外，会被提高。

@ classmethod

将方法转换为类方法。

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

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

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

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

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

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

compile （ source ， filename ， mode ， flags = 0 ， dont_inherit = False ， optimize = -1  ）

将源编译为代码或AST对象。代码对象可以由exec()或执行eval()。 源可以是普通字符串，字节字符串或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__

参数optimize指定编译器的优化级别; 默认值-1选择由-O选项给出的解释器的优化级别。显式级别是0（没有优化; __debug__是），1（断言被删除，__debug__是假的）或2（文档字符串也被删除）。

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

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

注意

 

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

警告

 

由于Python AST编译器中的堆栈深度限制，编译为AST对象时，可能会使Python解释器崩溃为足够大/复杂的字符串。

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

在版本3.5中更改：以前，TypeError在源中遇到空字节时引发。

class  complex （ [  real  [ ， imag  ]  ]  ）

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

注意

 

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

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

在版本3.6中更改：允许使用下划线对代码进行分组，如代码文字。

delattr （ object ， name  ）

这是一个相对的setattr()。参数是一个对象和一个字符串。该字符串必须是对象属性之一的名称。该函数删除指定的属性，只要该对象允许。例如，相当于。delattr(x, 'foobar')del x.foobar

班 dict （ ** kwarg  ） 类 dict （ 映射 ， ** kwarg  ） 类 dict （ 可迭代的 ， ** 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__', '__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  ）

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

enumerate （ iterable ， start = 0  ）

返回一个枚举对象。iterable必须是一个序列，一个 迭代器或其他支持迭代的对象。__next__()通过enumerate()返回的迭代器的方法 返回一个包含count的元组（从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 （ 表达式 ， globals = None ， locals = None  ）

参数是一个字符串和可选的全局变量和局部变量。如果提供， 全局变量必须是字典。如果提供，本地人可以是任何映射对象。

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

>>>

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

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

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

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

exec （ object  [ ， globals  [ ， locals  ]  ]  ）

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

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

如果globals字典不包含该键的值，则 __builtins__将该内置模块的字典引用 builtins插入该键的下方。通过这种方式，您可以通过在将自己的__builtins__字典传递给全局变量之前，将其自己的字典插入到可执行代码中来控制可用的内置 变量exec()。

注意

 

内置的函数globals()并分别locals()返回当前的全局和本地字典，这可能对传递用作第二个和第三个参数非常有用exec()。

注意

 

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

filter （ 函数 ， 可迭代 ）

从构造的那些元件的迭代器可迭代为哪些函数 返回真。 可迭代可以是序列，支持迭代的容器或迭代器。如果函数是None，则假定标识函数，即删除所有可迭代的元素。

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

请参阅itertools.filterfalse()用于返回哪个函数返回false 的可迭代元素的补充函数。

class  float （ [  x  ]  ）

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

如果参数是一个字符串，它应该包含一个十进制数字，可选地以一个符号开头，并且可以嵌入空格。可选标志可以是'+'或'-'; 一个'+'标志对所产生的价值没有影响。该参数也可以是表示NaN（非数字）或正或负无穷大的字符串。更确切地说，在删除前后空白字符后，输入必须符合以下语法：

sign           :: =“+”| “ - ”
 infinity       :: =“Infinity”| “inf”
 nan            :: =“nan”
 numeric_value :: =   floatnumber| infinity| numeric_string :: = [ ]nan
signnumeric_value

这floatnumber是浮点文字中描述的Python浮点文字的形式。情况并不重要，因此，例如，“inf”，“Inf”，“INFINITY”和“iNfINity”对于正无穷大都是可接受的拼写。

否则，如果参数是整数或浮点数，则返回具有相同值（在Python的浮点精度内）的浮点数。如果参数超出了Python浮点的范围，OverflowError则会引发。

对于一般的Python对象x，float(x)委托给 x.__float__()。

如果没有提供参数，0.0则返回。

例子：

>>>

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

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

在版本3.6中更改：允许使用下划线对代码进行分组，如代码文字。

format （ value  [ ， format_spec  ]  ）

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

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

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

在版本3.4中更改： 如果format_spec不是空字符串，则object().__format__(format_spec)引发。TypeError

类 frozenset （ [  iterable  ]  ）

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

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

getattr （ object ， name  [ ， default  ]  ）

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

globals （ ）

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

hasattr （ object ， name  ）

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

hash （ object  ）

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

注意

 

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

help （ [  object  ]  ）

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

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

在版本3.4中进行了更改：更改pydoc并inspect意味着可报告的已报告签名现在更加全面和一致。

hex （ x  ）

将整数转换为以“0x”为前缀的小写十六进制字符串。如果x不是Python int对象，则必须定义一个__index__()返回整数的 方法。一些例子：

>>>

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

如果要将整数转换为带有前缀或不带前缀的大写或小写十六进制字符串，可以使用以下任一方式：

>>>

>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')

另见format()更多信息。

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

注意

 

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

id （ object  ）

返回一个对象的“身份”。这是一个整数，它在其生命周期中保证对这个对象唯一且恒定。两个非重叠生命期的对象可能具有相同的id() 值。

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

input （ [  提示 ]  ）

如果提示参数存在，则将其写入标准输出而没有尾随换行符。然后该函数从输入中读取一行，将其转换为一个字符串（剥离尾随的换行符），然后返回该行。当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定义__int__()，则 int(x)返回x.__int__()。如果x定义__trunc__()，它返回x.__trunc__()。对于浮点数，这将截断为零。

如果X不是数字或如果基给出，则X必须是一个字符串， bytes或bytearray代表一个实例字面整数在基数基。可选地，文字可以在+或之前-（没有间隔）并且被空白包围。base-n文字由数字0到n-1组成，其中a to z（或Ato Z）的值为10到35.默认基数为10.允许的值为0和2-36。base-2，-8和-16文字可以有选择地以0b/ 0B， 0o/ 0O或0x/0X与代码中的整数文字一样。基0意味着精确地解释为文字代码，使得实际碱是2，8，10，或16，并且使得不合法，而 是，以及。int('010', 0)int('010')int('010', 8)

整数类型在数值类型 - int，float，complex中描述。

在版本3.4中进行了更改：如果base不是实例，int并且基础对象具有 base.__index__方法，则会调用该方法以获取基础的整数。以前的版本用来 base.__int__代替base.__index__。

在版本3.6中更改：允许使用下划线对代码进行分组，如代码文字。

isinstance （ object ， classinfo  ）

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

issubclass （ class ， classinfo  ）

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

iter （ object  [ ， sentinel  ]  ）

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

另请参阅迭代器类型。

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

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

len （ s  ）

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

类 list （ [  iterable  ]  ）

而不是一个函数，list实际上是一个可变的序列类型，如列表和序列类型 - 列表，元组，范围所记录。

locals （ ）

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

注意

 

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

map （ function ， iterable ， ...  ）

返回一个将函数应用于每个迭代项的迭代器，从而产生结果。如果传递额外的迭代参数， 函数必须采用多个参数并应用于并行所有迭代中的项目。使用多个迭代器时，当最短迭代器耗尽时，迭代器停止。对于函数输入已经安排到参数元组中的情况，请参见itertools.starmap()。

max （ 可迭代 ， *  [ ， key ， default  ]  ） max （ arg1 ， arg2 ， * args  [ ， key  ]  ）

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

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

有两个可选的仅关键字参数。该关键参数指定一个参数的排序功能，类似于用于list.sort()。该 默认参数指定的对象返回如果提供的迭代是空的。如果迭代器为空并且未提供缺省值， ValueError则会引发a。

如果多个项目最大，则该函数返回遇到的第一个项目。这与其他类型稳定保存工具（如and）一致 。sorted(iterable, key=keyfunc, reverse=True)[0]heapq.nlargest(1, iterable, key=keyfunc)

在新版本3.4：在默认情况下只有关键字的说法。

memoryview （ obj  ）

返回从给定参数创建的“内存视图”对象。请参阅 内存视图了解更多信息。

min （ 可迭代 ， *  [ ， key ， default  ]  ） min （ arg1 ， arg2 ， * args  [ ， key  ]  ）

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

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

有两个可选的仅关键字参数。该关键参数指定一个参数的排序功能，类似于用于list.sort()。该 默认参数指定的对象返回如果提供的迭代是空的。如果迭代器为空并且未提供缺省值， ValueError则会引发a。

如果多个项目最小，则该函数返回遇到的第一个项目。这与其他类型稳定保存工具（如and）一致。sorted(iterable, key=keyfunc)[0]heapq.nsmallest(1, iterable, key=keyfunc)

在新版本3.4：在默认情况下只有关键字的说法。

next （ iterator  [ ， default  ]  ）

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

类 object

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

注意

 

object没有不有__dict__，所以你不能指定任意属性的实例object类。

oct （ x  ）

将整数转换为以“0o”为前缀的八进制字符串。结果是一个有效的Python表达式。如果x不是Python int对象，则必须定义一个__index__()返回整数的方法。例如：

>>>

>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'

如果要将整数转换为八进制字符串，前缀为“0o”，则可以使用以下任一方式。

>>>

>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

另见format()更多信息。

open （ file ， mode ='r' ， buffering = -1 ， encoding = None ， errors = None ， newline = None ， closefd = True ， opener = None  ）

打开文件并返回相应的文件对象。如果文件无法打开，OSError则会提出。

文件是一个类似路径的对象，它提供要打开的文件的路径名（绝对或相对于当前工作目录）或要打包的文件的整数文件描述符。（如果给出文件描述符，则在返回的I / O对象关闭时关闭，除非closefd 设置为False。）

mode是一个可选字符串，用于指定打开文件的模式。它默认'r'打开文本模式下的阅读方式。其他常见的值是'w'写入（如果文件已经存在，则截断文件），'x'独占创建和'a'附加（在某些 Unix系统上，这意味着所有写入追加到文件末尾，而不管当前搜索位置如何）。在文本模式下，如果 编码未指定使用的编码是与平台相关的： locale.getpreferredencoding(False)被称为获取当前的本地编码。（用于读取和写入原始字节使用二进制模式并且 未指定编码。）可用的模式有：

字符	含义
'r'	打开阅读（默认）
'w'	打开写入，首先截断文件
'x'	打开独占创建，如果文件已经存在则失败
'a'	打开写入，追加到文件末尾（如果存在）
'b'	二进制模式
't'	文本模式（默认）
'+'	打开磁盘文件进行更新（读取和写入）
'U'	通用换行符模式（已弃用）

默认模式是'r'（打开阅读文本，同义词'rt'）。对于二进制读写访问，该模式'w+b'打开并将文件截断为0字节。 'r+b'不截断打开文件。

如概述中所述，Python区分二进制和文本I / O。以二进制模式打开的文件（包括'b'在模式 参数中）以bytes没有任何解码的对象的形式返回内容。在文本模式下（默认情况下，或者't'包含在mode参数中时），文件的内容将返回为str：字节首先使用平台相关编码进行解码，或者使用指定的 编码（如果给出）。

注意

 

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

缓冲是用于设置缓冲策略的可选整数。通过0切换缓冲关闭（仅在二进制模式下允许），1选择行缓冲（仅在文本模式下可用）以及> 1的整数，以指示固定大小的块缓冲区的大小（以字节为单位）。如果未给出缓冲参数，则默认缓冲策略的工作方式如下所示：

• 二进制文件以固定大小的块进行缓冲; 缓冲区的大小是通过试图确定底层设备的“块大小”并重新开始的启发式来选择的io.DEFAULT_BUFFER_SIZE。在很多系统上，缓冲区的长度通常为4096或8192字节。
• “交互式”文本文件（isatty() 返回的文件True）使用行缓冲。其他文本文件使用上述的二进制文件策略。

编码是用于解码或编码文件的编码的名称。这只能用于文本模式。默认编码是平台相关的（无论locale.getpreferredencoding()返回），但可以使用Python支持的任何 文本编码。请参阅codecs模块以获取支持的编码列表。

错误是一个可选字符串，指定如何处理编码和解码错误 - 这不能用于二进制模式。有多种标准错误处理程序可用（列在“ 错误处理程序”下），但已注册的任何错误处理名称 codecs.register_error()也是有效的。标准名称包括：

• 'strict'ValueError如果存在编码错误，则引发异常。默认值None具有相同的效果。
• 'ignore'忽略错误。请注意，忽略编码错误可能会导致数据丢失。
• 'replace'导致替换标记（例如'?'）被插入有错误数据的地方。
• 'surrogateescape'会将任何不正确的字节表示为Unicode专用区域中的代码点，范围从U + DC80到U + DCFF。surrogateescape当写入数据时使用错误处理程序时，这些私有代码点将被转回相同的字节。这对处理未知编码中的文件很有用。
• 'xmlcharrefreplace'仅在写入文件时才受支持。编码不支持的字符将替换为适当的XML字符引用&#nnn;。
• 'backslashreplace' 用Python的反斜杠转义序列替换畸形数据。
• 'namereplace'（也仅在写入时才支持）用换\N{...}码序列替换不支持的字符。

换行符控制通用换行符模式的工作方式（仅适用于文本模式）。它可以是None，''，'\n'，'\r'，和'\r\n'。它的工作原理如下：

• 当从流中读取输入时，如果换行符是None，则启用通用换行符模式。输入中的行可以以'\n'，， '\r'或结束'\r\n'，并且'\n'在返回给调用者之前将这些行翻译成。如果是''，则启用通用换行符模式，但行结束符将返回给调用方未翻译。如果它具有任何其他合法值，则输入行仅由给定字符串终止，并且行尾以未翻译形式返回给调用者。
• 将输出写入流时，如果换行符是None，则'\n' 写入的任何字符都将转换为系统默认行分隔符os.linesep。如果换行符是''或'\n'，则不会进行翻译。如果换行符是任何其他合法值，则'\n' 写入的任何字符都将转换为给定的字符串。

如果closefd是False文件描述符而不是文件名，那么文件关闭时底层文件描述符将保持打开状态。如果给定文件名，closefd必须是True（默认），否则会引发错误。

可以通过传递可调用的开罐器来使用自定义开罐器。然后通过调用opener（file，flags）来获得文件对象的底层文件描述符。开os.open叫器必须返回一个打开的文件描述符（ 作为开叫者的结果传递类似于传递的功能None）。

新创建的文件是不可继承的。

以下示例使用该函数的dir_fd参数 os.open()来打开相对于给定目录的文件：

>>>

>>> 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()取决于模式。当open()使用在文本模式（打开一个文件'w'，'r'，'wt'，'rt'，等等），它返回的一个子类 io.TextIOBase（具体而言io.TextIOWrapper）。当用缓冲区以二进制模式打开文件时，返回的类是其子类io.BufferedIOBase。确切的类有所不同：在读取二进制模式下，它返回一个io.BufferedReader; 在写二进制和附加二进制模式下，它返回一个io.BufferedWriter，并在读/写模式下，它返回一个io.BufferedRandom。当缓冲被禁用，原始流，的一个子类io.RawIOBase，io.FileIO，则返回。

参见文件处理模块，如，fileinput，io （其中open()被声明）， ，os，os.path，tempfile和shutil。

在版本3.3中更改：

• 在揭幕战中添加参数。
• 该'x'模式已添加。
• IOError曾经被提出，它现在是一个别名OSError。
• FileExistsError如果在独占创建模式（'x'）中打开的文件已经存在，现在会产生。

在版本3.4中更改：

• 该文件现在是不可继承的。

自版本3.4起弃用，将在版本4.0中删除：该'U'模式。

在版本3.5中更改：

• 如果系统调用中断并且信号处理程序不引发异常，则此函数现在重试系统调用而不是引发InterruptedError异常（请参阅PEP 475为理由）。
• 在'namereplace'加入错误处理程序。

在版本3.6中更改：

• 添加支持以接受实现的对象os.PathLike。
• 在Windows上，打开控制台缓冲区可能会返回io.RawIOBase除以外的子类 io.FileIO。

ord （ c  ）

给定一个表示一个Unicode字符的字符串，返回一个表示该字符的Unicode代码点的整数。例如， ord('a')返回整数97和ord('€')（欧元符号）返回8364。这是与之相反的chr()。

pow （ x ， y  [ ， z  ]  ）

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

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

print （ * objects ， sep ='' ， end ='\ n' ， file = sys.stdout ， flush = False  ）

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

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

的文件参数必须是与对象write(string)方法; 如果它不存在或None，sys.stdout将被使用。由于打印参数转换为文本字符串，print()因此不能与二进制模式文件对象一起使用。对于这些，请file.write(...)改用。

输出是否缓冲通常由文件决定，但如果 flush关键字参数为true，则强制刷新流。

版本3.3中更改：添加了flush关键字参数。

class  property （ fget = None ， fset = None ， fdel = None ， doc = None  ）

返回一个属性属性。

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

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

class C:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")

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

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

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

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

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

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

class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

此代码与第一个示例完全等效。一定要赋予与原始属性同名的附加功能（x在这种情况下）。

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

版本3.5中已更改：属性对象的文档字符串现在可写入。

range （ 停止 ） range （ 开始 ， 停止 [ ， 步骤 ]  ）

而不是一个函数，range实际上是一个不可变的序列类型，如范围和序列类型 - 列表，元组，范围所记录。

repr （ object  ）

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

reversed （ seq  ）

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

round （ number  [ ， ndigits  ]  ）

返回数字在小数点后舍入到精度ndigits。如果ndigits被忽略或是None，它返回最接近的整数到它的输入。

对于内置类型支持round()，值将四舍五入为功率减去ndigits的10 倍数 ; 如果两个倍数同样接近，舍入朝向甚至选择完成（因此，例如，这两个round(0.5)和round(-0.5)是0，和round(1.5)是 2）。任何整数值对ndigits有效（正数，零或负数）。如果ndigits被省略或者 返回值是一个整数None。否则，返回值与数字的类型相同。

对于一般的Python对象number，round委托给 number.__round__。

注意

 

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

类 set （ [  iterable  ]  ）

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

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

setattr （ 对象 ， 名称 ， 值 ）

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

class  slice （ stop  ） 类 slice （ 开始 ， 停止 [ ， 步骤 ]  ）

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

sorted （ iterable ， * ， key = None ， reverse = False  ）

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

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

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

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

用functools.cmp_to_key()一个老式的转换CMP功能的 关键功能。

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

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

@ staticmethod

将方法转换为静态方法。

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

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

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

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

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

像所有的装饰器一样，它也可以staticmethod作为一个常规函数调用，并对其结果进行处理。在需要从类体中引用函数的某些情况下，需要这样做，并且您希望避免自动转换为实例方法。对于这些情况，请使用以下习惯用法：

class C:
    builtin_open = staticmethod(open)

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

class  str （ object =''  ） class  str （ object = b'' ， encoding ='utf-8' ， errors ='strict'  ）

返回一个对象的str版本。详情请参阅。str()

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

sum （ iterable  [ ， start  ]  ）

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

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

super （ [  type  [ ， object-or-type  ]  ]  ）

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

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

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

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 （ [  可迭代 ]  ）

而不是一个函数，tuple实际上是一个不可变的序列类型，如元组和序列类型 - 列表，元组，范围中记载的那样。

class  type （ object  ） 类 type （ 名称 ， 基地 ， 字典 ）

使用一个参数，返回一个对象的类型。返回值是一个类型对象，通常与返回的对象相同 object.__class__。

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

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

>>>

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

另请参见键入对象。

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

vars （ [  object  ]  ）

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

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

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

zip （ * iterables  ）

制作一个迭代器，用于聚合来自每个迭代器的元素。

返回元组的迭代器，其中第i个元组包含来自每个参数序列或迭代的第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)

可保证迭代的从左到右的评估顺序。这使得使用一个将数据序列聚类为n长度组的成语成为可能zip(*[iter(s)]*n)。这将重复相同的迭代器n时间，以便每个输出元组都有n调用迭代器的结果。这具有将输入划分为n长度块的效果。

zip()只有当您不关心较长迭代中的尾随，不匹配值时才应使用不等长输入。如果这些值很重要，请itertools.zip_longest()改用它。

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

>>>

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

__import__ （ 名称 ， globals = None ， locals = None ， fromlist =（） ， level = 0  ）

注意

 

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

该函数由import语句调用。它可以被替换（通过导入builtins模块并分配给 builtins.__import__）以改变import语句的语义 ，但是强烈建议不要这样做，因为使用导入钩子通常更简单（请参阅PEP 302）来实现相同的目标，并且不会导致假定默认导入实施正在使用的代码出现问题。直接使用__import__()也是不鼓励的importlib.import_module()。

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

级别指定是使用绝对导入还是相对导入。0（默认）意味着只执行绝对导入。级别的正值 表示要相对于模块调用目录搜索的父目录的数量__import__()（请参阅PEP 328的细节）。

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

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

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

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

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

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

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

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

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

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

在版本3.3中更改：不再支持级别的负值（它也将默认值更改为0）。

脚注

[1]	请注意，解析器只接受Unix风格的行结束约定。如果您正在阅读文件中的代码，请确保使用换行转换模式转换Windows或Mac样式的换行符。