python 内置 -in功能

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如果的所有元素迭代是真实的（或者如果可迭代为空）。相当于：

高清 全（迭代器）：
    为 元素 的 迭代：
        如果 没有 元素：
            返回 假
    返回 真

any（可迭代）

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

DEF  任何（迭代器）：
    为 元素 的 迭代：
        如果 元素：
            返回 真正的
    回报 假

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”，则可以使用以下任一方法。

>>>

>>> 格式（14 ， '#b' ）， 格式（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

将方法转换为类方法。

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

 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模块中检测不完整和完整的语句。

在版本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有关此类的文档。

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

dir（[ object ] ）

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

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

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

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

• 如果对象是模块对象，则列表将包含模块属性的名称。
• 如果对象是类型或类对象，则列表包含其属性的名称，并递归地显示其基础的属性。
• 否则，该列表包含对象的属性名称，其类属性的名称以及其类的基类的属性的递归。

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

>>>

>>> import  struct 
>>> dir （）   ＃显示模块名称空间中的名称
['__ built ins __ '，'__ name __ '，'struct'] 
>>> dir （struct ）   ＃显示struct module中的名字
[ '结构'， '__all__'， '__ 建 ins__'， '__cached__'， '__doc__'， '__file__'，
'__initializing__'， '__loader__'， '__name__'， '__PACKAGE__'，
'_clearcache'， 'calcsize'， 'error'，'pack'，'pack_into'，
'unpack'，'unpack_from'] 
>>>类 形状：
...     def  __dir__ （self ）：
...        返回 [ 'area' ， 'perimeter' ， 'location' ] 
>>> s  =  Shape （）
>>> dir （s ）
['area'，'location'，'perimeter']

注意

 

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

divmod（a，b ）

以两个（非复数）数字作为参数，并在使用整数除法时返回由它们的商和余数组成的一对数字。使用混合操作数类型时，适用二元算术运算符的规则。对于整数，结果是一样的。对于浮点数的结果是，其中q通常是但可能比1小1。在任何情况下，是非常接近的一个，如果不为零，它具有相同的符号为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'秋季'），（4，'冬'）]

相当于：

DEF  枚举（序列， 开始= 0 ）：
    ñ  =  开始
    为 ELEM  在 序列：
        收率 Ñ ， ELEM 
        Ñ  + =  1

eval（表达式，globals = None，locals = None ）

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

该表达参数分析，并作为一个Python表达式来使用（从技术上来说，一个条件列表）全局和当地人 的字典作为全局和局部名字空间。如果globals字典存在并且缺少'__ built ins__'，则 在解析表达式之前将当前全局变量复制到全局变量中。这意味着表达式通常具有对标准模块的完全访问权，并且传播了受限制的环境。如果省略了locals字典，则默认为全局变量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()

注意

 

在建 -in功能globals()和locals()返回当前的全局和局部字典，分别，这可能是传递用作第二个和第三个参数有用exec()。

注意

 

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

filter（函数，可迭代）

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

注意，如果函数不是和函数是 相等的，则相当于生成器表达式。filter(function, iterable)(item for item in iterable iffunction(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对象，可选的元素从 迭代中获取。 frozenset是一个内置类。请参阅frozenset和 设置类型 - 设置，冻结关于此类的文档。

对于其他容器看到内置 -in 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 ' ）， 格式（255 ， 'x' ）， 格式（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   
“Monty Python的飞行马戏团”

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

class int（x = 0 ）

class int（x，base = 10 ）

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

如果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()方法返回空字符串：

与 开放（'mydata.txt' ） 作为 FP ：
    用于 线 在 ITER （FP 。readline的， '' ）：
        process_line （线）

len（s ）

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

类list（[ iterable ] ）

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

locals（）

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

注意

 

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

map（function，iterable，... ）

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

max（iterable，* [，key，default ] ）

max（arg1，arg2，* args [，key ] ）

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

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

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

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

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

memoryview（obj ）

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

min（iterable，* [，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 ）
'-Oo70'

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

>>>

>>> ' ％＃o '  ％ 10 ， ' ％o '  ％ 10 
（'0o12'，'12'）
>>> 格式（10 ， '#o​​' ）， 格式（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 。开放（'somedir' ， OS 。O_RDONLY ）
>>> 高清 开瓶器（路径， 旗）：
...     返回 操作系统。open （path ， flags ， dir_fd = dir_fd ）
... 
>>> with  open （'spamspam.txt' ， 'w' ， opener = opener ） as f ：
...     print （'这将被写入somedir / spamspam.txt' ， file = f ）
... 
>>> os 。关闭（dir_fd ）  ＃不要泄漏文件描述符

函数返回的文件对象的类型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分隔，然后是end。无论九月 和年底必须是字符串; 他们也可以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：

 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 ：
    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相对应的构造函数的参数。

在版本3.5中更改：属性对象的文档现在是可写的。

range（停止）

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

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

repr（object ）

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

reversed（seq ）

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

round（number [，ndigits ] ）

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

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

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

注意

 

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

类set（[ iterable ] ）

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

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

setattr（object，name，value ）

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

class slice（stop ）

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

返回表示由指定的索引集合的切片对象 。在启动和步参数默认为 。切片对象具有只读数据属性， 并且仅返回参数值（或其默认值）。他们没有其他明确的功能; 但是它们被数值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功能的 关键功能。

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

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

@staticmethod

将方法转换为静态方法。

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

 C 类：
    @staticmethod 
    def  f （arg1 ， arg2 ， ... ）： ...

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

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

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

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

 C 类：
    内置 in_open = staticmethod （打开）

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

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

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

 C 类（B ）：
    def  方法（self ， arg ）：
        super （）。方法（arg ）    ＃这和
                               ＃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'） - > Axis by 
    sentinel  =  object （）
    iterators  =  [ iter （it ） for  it  in  iterables ] 
    while  iterators ：
        result  =  [] 
        for  it  in  迭代器：
            elem  =  next （it ， sentinel ）
            如果 elem  是 sentinel ：
                返回
            结果。附加（elem ）
        产量 元组（result ）

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

zip()只有当你不关心后续的，不匹配的值的时候，才应该使用不等长度的输入。如果这些值很重要，请itertools.zip_longest()改用。

zip()结合*运算符可以用来解压一个列表：

>>>

>>> X  =  [ 1 ， 2 ， 3 ] 
>>> Ŷ  =  [ 4 ， 5 ， 6 ] 
>>> 压缩 =  拉链（X ， ÿ ）
>>> 列表（压缩）
[（1，4），（ 2，5），（3,6）] 
>>> x2 ， y2  =  zip （* zip （x ， y ））
>>> x  ==  list （x2 ） 和 y  ==  list （y2 ）
True

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

注意

 

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

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

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

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

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

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

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

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

脚注

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