Python基础学习笔记（3）Python内置函数一览

左手的ㄟ右手 2023-10-07 13:38 57阅读 0赞

# 一、定义 #

Python 解释器自带的函数叫做内置函数，这些函数可以直接使用，不需要导入某个模块，与Shell内置命令类似。

## 1.1.函数 ##

将使用频繁的代码段封装起来，并给它起一个名字，以后使用的时候只要知道名字就可以，这就是函数。函数就是一段封装好的、可以重复使用的代码，它使得我们的程序更加模块化，不需要编写大量重复的代码。

## 1.2.内置函数和标准库函数 ##

内置函数和标准库函数是不一样的。

###    1.2.1.内置函数 ###

Python 解释器也是一个程序，它给用户提供了一些常用功能，并给它们起了独一无二的名字，这些常用功能就是**内置函数**。Python 解释器启动以后，内置函数也生效了，可以直接拿来使用。

###    1.2.2.**标准库函数** ###

Python **标准库**相当于解释器的外部扩展，它并不会随着解释器的启动而启动，要想使用这些外部扩展，必须提前导入。Python 标准库非常庞大，包含了很多模块，要想使用某个函数，必须提前导入对应的模块，否则函数是无效的。

### 1.2.3.联系 ###

**内置函数**是解释器的一部分，它随着解释器的启动而生效；**标准库函数**是解释器的外部扩展，导入模块以后才能生效。

一般来说，内置函数的执行效率要高于标准库函数。  
  
Python 解释器一旦启动，所有的内置函数都生效了；而导入标准库的某个模块，只是该模块下的函数生效，并不是所有的标准库函数都生效。  
  
内置函数的数量必须被严格控制，否则 Python 解释器会变得庞大和臃肿。一般来说，只有那些使用频繁或者和语言本身绑定比较紧密的函数，才会被提升为内置函数。例如，在屏幕上输出文本就是使用最频繁的功能之一，所以 print() 是 Python 的内置函数。在 Python 2.x 中，print 是一个关键字；到了 Python 3.x 中，print 变成了内置函数。

## 1.3.内置函数表 ##

除了 print() 函数，Python 解释器还提供了更多内置函数，下表列出了 Python 3.x 中的所有内置函数。

<table>  &nbsp;  
 <tbody> 
  <tr> 
   <th colspan="5">内置函数</th> 
  </tr> 
  <tr> 
   <td>abs()</td> 
   <td>delattr()</td> 
   <td>hash()</td> 
   <td>memoryview()</td> 
   <td>set()</td> 
  </tr> 
  <tr> 
   <td>all()</td> 
   <td>dict()</td> 
   <td>help()</td> 
   <td>min()</td> 
   <td>setattr()</td> 
  </tr> 
  <tr> 
   <td>any()</td> 
   <td>dir()</td> 
   <td>hex()</td> 
   <td>next()</td> 
   <td>slicea()</td> 
  </tr> 
  <tr> 
   <td>ascii()</td> 
   <td>divmod()</td> 
   <td>id()</td> 
   <td>object()</td> 
   <td>sorted()</td> 
  </tr> 
  <tr> 
   <td>bin()</td> 
   <td>enumerate()</td> 
   <td>input()</td> 
   <td>oct()</td> 
   <td>staticmethod()</td> 
  </tr> 
  <tr> 
   <td>bool()</td> 
   <td>eval()</td> 
   <td>int()</td> 
   <td>open()</td> 
   <td>str()</td> 
  </tr> 
  <tr> 
   <td>breakpoint()</td> 
   <td>exec()</td> 
   <td>isinstance()</td> 
   <td>ord()</td> 
   <td>sum()</td> 
  </tr> 
  <tr> 
   <td>bytearray()</td> 
   <td>filter()</td> 
   <td>issubclass()</td> 
   <td>pow()</td> 
   <td>super()</td> 
  </tr> 
  <tr> 
   <td>bytes()</td> 
   <td>float()</td> 
   <td>iter()</td> 
   <td>print()</td> 
   <td>tuple()</td> 
  </tr> 
  <tr> 
   <td>callable()</td> 
   <td>format()</td> 
   <td>len()</td> 
   <td>property()</td> 
   <td>type()</td> 
  </tr> 
  <tr> 
   <td>chr()</td> 
   <td>frozenset()</td> 
   <td>list()</td> 
   <td>range()</td> 
   <td>vars()</td> 
  </tr> 
  <tr> 
   <td>classmethod()</td> 
   <td>getattr()</td> 
   <td>locals()</td> 
   <td>repr()</td> 
   <td>zip()</td> 
  </tr> 
  <tr> 
   <td>compile()</td> 
   <td>globals()</td> 
   <td>map()</td> 
   <td>reversed()</td> 
   <td>__import__()</td> 
  </tr> 
  <tr> 
   <td>complex()</td> 
   <td>hasattr()</td> 
   <td>max()</td> 
   <td>round()</td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

注意，不要使用内置函数的名字作为标识符使用（例如变量名、函数名、类名、模板名、对象名等），虽然这样做 Python 解释器不会报错，但这会导致同名的内置函数被覆盖，从而无法使用。例如：

print = "python"  #将print作为变量名
    print("Hello World!")  #print函数被覆盖，失效

>     报错：
>     Traceback (most recent call last):
>       File "<pyshell#1>", line 1, in <module>
>         print("Hello World!")
>     TypeError: 'str' object is not callable

# 二、部分内置函数的具体功能和用法 #

## `2.1. abs`(*x*) ##

功能：返回一个数的绝对值。

参数：可以是一个整数或浮点数。 如果参数是一个复数，则返回它的模。 如果 *x* 定义了\_\_abs\_\_()，则 `abs(x)` 将返回 `x.__abs__()`。

例子

abs(-1)

> 输出：1

## `2.2. all`(*iterable*) ##

如果 *iterable* 的所有元素为真（或迭代器为空），返回 `True` 。等价于:

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

## `2.3. any`(*iterable*) ##

如果 *iterable* 的任一元素为真则返回 `True`。 如果迭代器为空，返回 `False`。 等价于:

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

## `2.4. ascii`(*object*) ##

就像函数 repr()，返回一个对象可打印的字符串，但是 repr() 返回的字符串中非 ASCII 编码的字符，会使用 \\x、\\u 和 \\U 来转义。生成的字符串和 Python 2 的 repr() 返回的结果相似。

## `2.5. 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() 获取更多信息。

## *2.6. class* `bool`(\[*x*\]) ##

返回一个布尔值，True 或者 False。

x 使用标准的 真值测试过程 来转换。如果 x 是假的或者被省略，返回 False；其他情况返回 True。

bool 类是 int 的子类（参见 数字类型 --- int, float, complex）。其他类不能继承自它。它只有 False 和 True 两个实例（参见 布尔值）。在 3.7 版更改: *x* 现在只能作为位置参数。

## `2.7. breakpoint`(*\*args*, *\*\*kws*) ##

此函数会在调用时将你陷入调试器中。具体来说，它调用 sys.breakpointhook() ，直接传递 args 和 kws 。默认情况下， sys.breakpointhook() 调用 pdb.set\_trace() 且没有参数。在这种情况下，它纯粹是一个便利函数，因此您不必显式导入 pdb 且键入尽可能少的代码即可进入调试器。但是， sys.breakpointhook() 可以设置为其他一些函数并被 breakpoint() 自动调用，以允许进入你想用的调试器。

## *2.8. class* `bytearray`(\[*source*\[, *encoding*\[, *errors*\]\]\]) ##

返回一个新的 bytes 数组。 bytearray 类是一个可变序列，包含范围为 0 <= x < 256 的整数。它有可变序列大部分常见的方法，见 可变序列类型 的描述；同时有 bytes 类型的大部分方法，参见 bytes 和 bytearray 操作。

可选形参 *source* 可以用不同的方式来初始化数组：

*  如果是一个 string，您必须提供 encoding 参数（errors 参数仍是可选的）；bytearray() 会使用 str.encode() 方法来将 string 转变成 bytes。
 *  如果是一个 *integer*，会初始化大小为该数字的数组，并使用 null 字节填充。
 *  如果是一个符合 *buffer* 接口的对象，该对象的只读 buffer 会用来初始化字节数组。
 *  如果是一个 *iterable* 可迭代对象，它的元素的范围必须是 `0 <= x < 256` 的整数，它会被用作数组的初始内容。

如果没有实参，则创建大小为 0 的数组。

另见 二进制序列类型 --- bytes, bytearray, memoryview 和 bytearray 对象。

## *2.9.class* `bytes`(\[*source*\[, *encoding*\[, *errors*\]\]\]) ##

返回一个新的“bytes”对象， 是一个不可变序列，包含范围为 0 <= x < 256 的整数。bytes 是 bytearray 的不可变版本 - 它有其中不改变序列的方法和相同的索引、切片操作。

因此，构造函数的实参和 bytearray() 相同。

字节对象还可以用字面值创建，参见 字符串和字节串字面值。

另见 二进制序列类型 --- bytes, bytearray, memoryview，bytes 对象 和 bytes 和 bytearray 操作。

## `2.10.callable`(*object*) ##

如果参数 object 是可调用的就返回 True，否则返回 False。 如果返回 True，调用仍可能失败，但如果返回 False，则调用 object 将肯定不会成功。 请注意类是可调用的（调用类将返回一个新的实例）；如果实例所属的类有 \_\_call\_\_() 则它就是可调用的。

3.2 新版功能: 这个函数一开始在 Python 3.0 被移除了，但在 Python 3.2 被重新加入。

## `2.11.chr`(*i*) ##

返回 Unicode 码位为整数 i 的字符的字符串格式。例如，chr(97) 返回字符串 'a'，chr(8364) 返回字符串 '€'。这是 ord() 的逆函数。

实参的合法范围是 0 到 1,114,111（16 进制表示是 0x10FFFF）。如果 i 超过这个范围，会触发 ValueError 异常。

## `2.12.classmethod` ##

把一个方法封装成类方法。

一个类方法把类自己作为第一个实参，就像一个实例方法把实例自己作为第一个实参。请用以下习惯来声明类方法:

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

`@classmethod 这样的形式称为函数的 decorator -- 详情参阅 函数定义。`

`类方法的调用可以在类上进行 (例如 C.f()) 也可以在实例上进行 (例如 C().f())。 其所属类以外的类实例会被忽略。 如果类方法在其所属类的派生类上调用，则该派生类对象会被作为隐含的第一个参数被传入。`

`类方法与 C++ 或 Java 中的静态方法不同。 如果你需要后者，请参阅 staticmethod()。`

## `2.13. 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']

## `2.14. filter`(*function*, *iterable*) ##

用 *iterable* 中函数 *function* 返回真的那些元素，构建一个新的迭代器。*iterable* 可以是一个序列，一个支持迭代的容器，或一个迭代器。如果 *function* 是 `None` ，则会假设它是一个身份函数，即 *iterable* 中所有返回假的元素会被移除。

请注意， `filter(function, iterable)` 相当于一个生成器表达式，当 function 不是 `None` 的时候为 `(item for item in iterable if function(item))`；function 是 `None` 的时候为 `(item for item in iterable if item)` 。

## *2.15. class* `float`(\[*x*\]) ##

返回从数字或字符串 *x* 生成的浮点数。

如果实参是字符串，则它必须是包含十进制数字的字符串，字符串前面可以有符号，之前也可以有空格。可选的符号有 `'+'` 和 `'-'` ； `'+'` 对创建的值没有影响。实参也可以是 NaN（非数字）、正负无穷大的字符串。确切地说，除去首尾的空格后，输入必须遵循以下语法：

>     sign           ::=  "+" | "-"
>     infinity       ::=  "Infinity" | "inf"
>     nan            ::=  "nan"
>     numeric_value  ::= floatnumber|infinity|nan
>     
>     numeric_string ::=  [sign] numeric_value

这里， floatnumber 是 Python 浮点数的字符串形式，详见 浮点数字面值。字母大小写都可以，例如，“inf”、“Inf”、“INFINITY”、“iNfINity” 都可以表示正无穷大。

另一方面，如果实参是整数或浮点数，则返回具有相同值（在 Python 浮点精度范围内）的浮点数。如果实参在 Python 浮点精度范围外，则会触发 OverflowError。

对于一个普通 Python 对象 x，float(x) 会委托给 x.\_\_float\_\_()。 如果 \_\_float\_\_() 未定义则将回退至 \_\_index\_\_()。

如果没有实参，则返回 0.0 。

## `2.16. format`(*value*\[, *format\_spec*\]) ##

将 value 转换为 format\_spec 控制的“格式化”表示。format\_spec 的解释取决于 value 实参的类型，但是大多数内置类型使用标准格式化语法：格式规格迷你语言。

默认的 format\_spec 是一个空字符串，它通常和调用 str(value) 的结果相同。

调用 format(value, format\_spec) 会转换成 type(value).\_\_format\_\_(value, format\_spec) ，所以实例字典中的 \_\_format\_\_() 方法将不会调用。如果搜索到 object 有这个方法但 format\_spec 不为空，format\_spec 或返回值不是字符串，会触发 TypeError 异常。

## `2.17. hash`(*object*) ##

返回该对象的哈希值（如果它有的话）。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0）。

## `2.18. id`(*object*) ##

返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的 id() 值。

## `2.19. input`(\[*prompt*\]) ##

如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。当读取到 EOF 时，则触发 EOFError。例如:

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

## 2.20. `int`(\[*x*\]) ##

*class* `int`(\[*x*\])

*class* `int`(*x*, *base=10*)

返回一个基于数字或字符串 x 构造的整数对象，或者在未给出参数时返回 0。 如果 x 定义了 \_\_int\_\_()，int(x) 将返回 x.\_\_int\_\_()。 如果 x 定义了 \_\_index\_\_()，它将返回 x.\_\_index\_\_()。 如果 x 定义了 \_\_trunc\_\_()，它将返回 x.\_\_trunc\_\_()。 对于浮点数，它将向零舍入。

如果 x 不是数字，或者有 base 参数，x 必须是字符串、bytes、表示进制为 base 的 整数字面值 的 bytearray 实例。该文字前可以有 + 或 - （中间不能有空格），前后可以有空格。一个进制为 n 的数字包含 0 到 n-1 的数，其中 a 到 z （或 A 到 Z ）表示 10 到 35。默认的 base 为 10 ，允许的进制有 0、2-36。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 。

## `2.21. len`(*s*) ##

返回对象的长度（元素个数）。实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）。

## *2.22. class* `list`(\[*iterable*\]) ##

虽然被称为函数，list 实际上是一种可变序列类型，详情请参阅 列表 和 序列类型 --- list, tuple, range。

## `2.23. map`(*function*, *iterable*, *...*) ##

返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器。 如果传入了额外的 iterable 参数，function 必须接受相同个数的实参并被应用于从所有可迭代对象中并行获取的项。 当有多个可迭代对象时，最短的可迭代对象耗尽则整个迭代就将结束。 对于函数的输入已经是参数元组的情况，请参阅 itertools.starmap()。

## `2.24. pow`(*base*, *exp*\[, *mod*\]) ##

返回 *base* 的 *exp* 次幂；如果 *mod* 存在，则返回 *base* 的 *exp* 次幂对 *mod* 取余（比 `pow(base, exp) % mod` 更高效）。 两参数形式 `pow(base, exp)` 等价于乘方运算符: `base**exp`。

参数必须具有数值类型。 对于混用的操作数类型，则将应用双目算术运算符的类型强制转换规则。 对于 int 操作数，结果具有与操作数相同的类型（强制转换后），除非第二个参数为负值；在这种情况下，所有参数将被转换为浮点数并输出浮点数结果。 例如，10\*\*2 返回 100，但 10\*\*-2 返回 0.01。

对于 int 操作数 base 和 exp，如果给出 mod，则 mod 必须为整数类型并且 mod 必须不为零。 如果给出 mod 并且 exp 为负值，则 base 必须相对于 mod 不可整除。 在这种情况下，将会返回 pow(inv\_base, -exp, mod)，其中 inv\_base 为 base 的倒数对 mod 取余。

下面的例子是 `38` 的倒数对 `97` 取余:

>     >>> pow(38, -1, mod=97)
>     23
>     >>> 23 * 38 % 97 == 1
>     True

## `2.25. print`(*\*objects*, *sep=' '*, *end='\\n'*, *file=sys.stdout*, *flush=False*) ##

将 objects 打印到 file 指定的文本流，以 sep 分隔并在末尾加上 end。 sep, end, file 和 flush 如果存在，它们必须以关键字参数的形式给出。

所有非关键字参数都会被转换为字符串，就像是执行了 str() 一样，并会被写入到流，以 sep 且在末尾加上 end。 sep 和 end 都必须为字符串；它们也可以为 None，这意味着使用默认值。 如果没有给出 objects，则 print() 将只写入 end。

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

输出是否被缓存通常决定于 file，但如果 flush 关键字参数为真值，流会被强制刷新。

在 3.3 版更改: 增加了 flush 关键字参数。

## *2.26. class* `str`(*object=''*) ##

> *class* `str`(*object='b'*, *encoding='utf-8'*, *errors='strict'*)

返回一个 str 版本的 object 。有关详细信息，请参阅 str() 。

str 是内置字符串 class 。更多关于字符串的信息查看 文本序列类型 --- str。

## `2.27. sum`(*iterable*, */*, *start=0*) ##

从 start 开始自左向右对 iterable 的项求和并返回总计值。 iterable 的项通常为数字，而 start 值则不允许为字符串。

对某些用例来说，存在 sum() 的更好替代。 拼接字符串序列的更好更快方式是调用 ''.join(sequence)。 要以扩展精度对浮点值求和，请参阅 math.fsum()。 要拼接一系列可迭代对象，请考虑使用 itertools.chain()。

在 3.8 版更改: start 形参可用关键字参数形式来指定。

## `2.28. super`(\[*type*\[, *object-or-type*\]\]) ##

返回一个代理对象，它会将方法调用委托给 type 的父类或兄弟类。 这对于访问已在类中被重载的继承方法很有用。

object-or-type 确定用于搜索的 method resolution order。 搜索会从 type 之后的类开始。

举例来说，如果 object-or-type 的 \_\_mro\_\_ 为 D -> B -> C -> A -> object 并且 type 的值为 B，则 super() 将会搜索 C -> A -> object。

object-or-type 的 \_\_mro\_\_ 属性列出了 getattr() 和 super() 所共同使用的方法解析搜索顺序。 该属性是动态的，可以在任何继承层级结构发生更新的时候被改变。

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

super 有两个典型用例。 在具有单继承的类层级结构中，super 可用来引用父类而不必显式地指定它们的名称，从而令代码更易维护。 这种用法与其他编程语言中 super 的用法非常相似。

第二个用例是在动态执行环境中支持协作多重继承。 此用例为 Python 所独有，在静态编译语言或仅支持单继承的语言中是不存在的。 这使得实现“菱形图”成为可能，在这时会有多个基类实现相同的方法。 好的设计强制要求这种方法在每个情况下具有相同的调用签名（因为调用顺序是在运行时确定的，也因为该顺序要适应类层级结构的更改，还因为该顺序可能包含在运行时之前未知的兄弟类）。

对于以上两个用例，典型的超类调用看起来是这样的:

>     class C(B):
>         def method(self, arg):
>             super().method(arg)    # This does the same thing as:
>                                    # super(C, self).method(arg)

## *2.29. class* `tuple`(\[*iterable*\]) ##

虽然被称为函数，但 tuple 实际上是一个不可变的序列类型，参见在 元组 与 序列类型 --- list, tuple, range 中的文档说明。

## *2.30. class* `type`(*object*) ##

## *class* `type`(*name*, *bases*, *dict*) ##

传入一个参数时，返回 object 的类型。 返回值是一个 type 对象，通常与 object.\_\_class\_\_ 所返回的对象相同。

推荐使用 isinstance() 内置函数来检测对象的类型，因为它会考虑子类的情况。

传入三个参数时，返回一个新的 type 对象。 这在本质上是 class 语句的一种动态形式。 name 字符串即类名并且会成为 \_\_name\_\_ 属性；bases 元组列出基类并且会成为 \_\_bases\_\_ 属性；而 dict 字典为包含类主体定义的命名空间并且会被复制到一个标准字典成为 \_\_dict\_\_ 属性。 例如，下面两条语句会创建相同的 type 对象:

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

## `2.31.zip`(*\*iterables*) ##

创建一个聚合了来自每个可迭代对象中的元素的迭代器。

返回一个元组的迭代器，其中的第 *i* 个元组包含来自每个参数序列或可迭代对象的第 *i* 个元素。 当所输入可迭代对象中最短的一个被耗尽时，迭代器将停止迭代。 当只有一个可迭代对象参数时，它将返回一个单元组的迭代器。 不带参数时，它将返回一个空迭代器。 相当于:

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)

函数会保证可迭代对象按从左至右的顺序被求值。 使得可以通过 `zip(*[iter(s)]*n)` 这样的惯用形式将一系列数据聚类为长度为 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

## `2.32. __import__`(*name*, *globals=None*, *locals=None*, *fromlist=()*, *level=0*) ##

##  ##

注:与 importlib.import\_module() 不同，这是一个日常 Python 编程中不需要用到的高级函数。

此函数会由 import 语句发起调用。 它可以被替换 (通过导入 builtins 模块并赋值给 builtins.\_\_import\_\_) 以便修改 import 语句的语义，但是 强烈 不建议这样做，因为使用导入钩子 (参见 PEP 302) 通常更容易实现同样的目标，并且不会导致代码问题，因为许多代码都会假定所用的是默认实现。 同样也不建议直接使用 \_\_import\_\_() 而应该用 importlib.import\_module()。

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

level 指定是使用绝对还是相对导入。 0 (默认值) 意味着仅执行绝对导入。 level 为正数值表示相对于模块调用 \_\_import\_\_() 的目录，将要搜索的父目录层数 (详情参见 PEP 328)。

当 name 变量的形式为 package.module 时，通常将会返回最高层级的包（第一个点号之前的名称），而 不是 以 name 命名的模块。 但是，当给出了非空的 fromlist 参数时，则将返回以 name 命名的模块。

例如，语句 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()