Python 官方文档解读(1)：66 个内置函数

python 解释器 （cpython 3.7）内置有 66 个函数，这些函数在任何时刻都是可用的。此文是为了对这 66 个函数进行简单的梳理，便于以后可能用到它们时能想到。

1. abs(x)

返回一个数的绝对值。参数x可以是int、float或complex。如果是complex，则返回这个复数的大小（模）。

2. all(iterable)

如果iterable的所有元素“是”true，才返回true，否则返回false。若iterable为空，也返回true。等价于：

def all(iterable):
    for element in iterable:
        if not element:
            return false
    return true

3. any(iterable)

只要iterable有一个元素“是”true，就返回true。若iterable为空，返回false。等价于：

def any(iterable):
    for element in iterable:
        if element:
            return true
    return false

4. ascii(object)

像repr()一样，但将非 ascii 字符使用\x, \u或\u来转义。

5. bin(x)

将整数x转换为二进制字符串（以“0b”开头）。如果x不是一个 python int对象，它需要定义一个__index__()方法来返回一个整数。示例：

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

也可以用format()和 f-string 来完成：

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

参考 format()。

6. class bool([x])

返回x的布尔值。如果x省略，也返回false。bool类是int类的子类，它仅有两个示例对象true和false。

7. breakpoint(args, **kws)

3.7 版新增。

8. class bytearray([source[, encoding[, errors]]])

返回一个字节数组。参考bytearray类和bytes类。

如果可选的source参数：

1. 是一个字符串，则必须提供一个encoding参数，bytearray()会使用str.encoding()来将字符串转换为字节序列。
2. 是一个整数，则字节数组的大小是这个整数，并且以空字节初始化。
3. 是一个符合buffer接口的对象，则字节数组以这个对象的一个只读 buffer 来初始化。
4. 是一个 iterable，那它的元素必须是[0, 256] 的整数。字节数组以它的元素来初始化。

若没有参数，则返回一个大小为 0 的字节数组。

9. callable(object)

如果对象是可调用的，则返回true，否则返回flase。注意：即使callable(object)返回true，object也有可能无法调用（为什么？）；但如果返回false，则一定无法调用。

如果一个对象有__call__()方法，则对象是可调用的。

10. chr(i)

返回一个字符（串），这个字符的 unicode 码点为整数i。比如chr(97)返回字符串'a'，chr(8364)返回'€'。它是ord()的逆反。

11. @classmethod

装饰器：将一个普通方法转换为类方法。

一个类方法的第一个参数为隐式参数：此类cls，而非此对象self。示例：

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

可以在类上调用（c.f()）也可以在对象上调用（c().f()）。

python 类方法不同于 java 和 c++ 中的静态方法。如果想使用静态方法，参考本文中的staticmethod()。

12. compile(source, filename, mode, flags=0, dont_inherit=false, optimize=-1)

将 source 编译为 code 或 ast 对象。code 对象可以被 exec() 或 eval() 执行。source 可以是普通字符串、字节字符串或一个 ast 对象。参考官方 ast 模块。

示例：

>>> codeinstring = 'a = 5\nb=6\nsum=a+b\nprint("sum =",sum)'
>>> codeobejct = compile(codeinstring, 'sumstring', 'exec')

>>> exec(codeobejct)
sum = 11

13. class complex([real[, imag]])

返回一个复数 real + imag*1j。或者将一个字符串（第一个参数）或数字转化为复数。

注意：complex('1+2j') 是正确的，但 complex('1 + 2j') 将抛出 valueerror.

14. delattr(object, name)

删除一个对象的属性，delattr(x, 'foobar') 等价于 del x.foobar。参考setattr()

15. class dict(**kwarg), dict(mapping, **kwarg), dict(iterable, **kwarg)

创建一个字典。

16. dir([object])

没有参数时，返回当前 local 的符号（标识符）。有参数时，返回object的有效属性。

如果object有__dir__()方法，则会调用它。示例：

>>> import struct
>>> dir()   # show the names in the module namespace  # doctest: +skip
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module # doctest: +skip
['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()主要在交互式环境中使用，它的输出不稳定，不应在生产环境中使用。

17. divmod(a, b)

参数为整数时，返回(a // b, a % b)；参数为浮点数时，返回(math.floor(a / b), a % b)。而且0 <= abs(a % b) < abs(b)。

18. enumerate(iterable, start=0)

返回一个 enumerate 对象。示例：

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

19. eval(expression, globals=none, locals=none)

估值表达式。globals必须是一个字典，而locals可以是任何 mapping 对象。

如果 globals 和 locals 都省略，则使用当前环境的符号表。示例：

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

此函数也能用来执行任何 code 对象（比如使用 compile()创建的 code 对象）。但如果这个 code 对象在编译时的mode 是 'exec'，那么eval()将返回none。

提示：动态执行语句可以使用exec()。globals()和locals()函数分别返回当前的全局和局部符号表，可以用来传入eval()和exec()。

20. exec(object[, globals[, locals]])

动态执行 python 代码。其中 object 必须是字符串或 code 对象。示例：

>>> program = 'a = 5\nb=10\nprint("sum =", a+b)'
>>> exec(program)
sum = 15

也可以用于获取用户的输入程序：

program = input('enter a program:')
exec(program)

想要限制用户能访问的对象或函数，可以传入 globals，示例：

>>> from math import *
>>> exec('print(dir())', {'squareroot': sqrt, 'pow': pow})
['__builtins__', 'pow', 'squareroot']

# object can have squareroot() module
>>> exec('print(squareroot(9))', {'squareroot': sqrt, 'pow': pow})
3.0

21. filter(function, iterable)

filter()基于 function 过滤 iterable 的元素，如果 function(element) 返回 true，则通过过滤。

filter()等价于：

# when function is defined
(element for element in iterable if function(element))

# when function is none
(element for element in iterable if element)

itertools.filterflase()是这个函数的反函数。

22. class float([x])

构建浮点数。对于一个 python 对象x，float(x)会尝试调用x.__float__()。示例：

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1e6')
1000000.0
>>> float('-infinity')  # “inf”, “inf”, “infinity” 和 “infinity” 都行，不区分大小写
-inf

23. format(value[, format_spec])

将 value 转换为格式化后的表示，由 format_spec 控制。

format_spec 的格式为：

[[fill]align][sign][#][0][width][,][.precision][type]
where, the options are
fill        ::=  any character
align       ::=  "<" | ">" | "=" | "^"
sign        ::=  "+" | "-" | " "
width       ::=  integer
precision   ::=  integer
type        ::=  "b" | "c" | "d" | "e" | "e" | "f" | "f" | "g" | "g" | "n" | "o" | "s" | "x" | "x" | "%"

数字对齐 align 符号含义：

type	meaning
<	左对齐
^	居中对齐
>	右对齐
=	强制符号(+)(-)到最左边的位置

数字类型 type 符号函数

type	meaning
d	十进制整数
c	对应的 unicode 字符
b	二进制格式
o	八进制格式
x	十六进制格式
n	与d相同，只是它的数字分隔符因区域设置而不同
e	科学标识法 (e)
e	科学表示法 (e)
f	显示定点数 （默认为 6 位小数）
f	与f相同，只是它将inf显示为inf，nan显示为nan
g	通用格式，将数字四舍五入到 p 位有效数字（默认为 6 位）
g	与g相同，只是会显示e而不是e
%	将数字乘以100并且在后面增加一个%

示例 1：

# d, f and b are type

# integer
>>> print(format(123, "d"))
123

# float arguments
>>> print(format(123.4567898, "f"))
123.456790

# binary format
>>> print(format(12, "b"))
1100

示例 2：“对齐”和“填充”：

# integer 
>>> print(format(1234, "*>+7,d"))
*+1,234

# float number
>>> print(format(123.4567, "^-09.3f"))
0123.4570

上例相当于'{:^-09.3f}'.format(123.4567)。关于 python string format，参看 python string format()

示例 3：重写__format__()

# custom __format__() method
class person:
    def __format__(self, format):
        if(format == 'age'):
            return '23'
        return 'none'

print(format(person(), "age"))

输出为 23。

24. class frozenset([iterable])

返回一个 对象。

25. getattr(object, name[, default])

getattr(x, 'foobar') 等价于x.foobar。如果属性 name 不存在，则会尝试返回 default，若没有提供 default 则会引发 attributeerror。

26. globals()

返回当前全局符号表的字典。这个字典总是当前模块的符号表（在函数或方法中，会返回函数或方法被定义的模块的全局符号表，而非调用模块的全局符号表）。

27. hasattr(object, name)

如果 object 有属性 name，则返回 true，否则返回false。这个函数是由getattr()实现的（测试是否引发异常）。

28. hash(object)

返回一个对象的哈希值（如果有的话）。哈希值是整数。

这个函数主要用来快速比较两个对象。在 set 和 dict 的实现中也用到了，因为 set 和 dict 实际上就是可变大小的哈希表。而 list 不是，因此在 list 中查找元素比在 set 和 dict 中查找要慢很多。参考 *

特殊：-1 的哈希值是 -2，因为 cpython 里 -1 用来返回错误，所以 -1 的哈希值被改成了 -2。所以hash(-1)==hash(-2)。参考 *。

29. help([object])

显示帮助。用于交互式环境中使用。参数可以是字符串或对象。

30. hex(x)

将整数x转换为十六进制字符串（以“0x”开头）。如果x不是一个 python int对象，它需要定义一个__index__()方法来返回一个整数。示例：

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

也可以用format()和字符串格式字面量f"xxx"来完成：

>>> '%#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')

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

31. id(object)

返回对象的 id（一个整数）。

cpython 实现：这是对象在内存中的虚拟地址。

32. input([prompt])

显示 prompt，获取用户输入字符串，并去除结尾的回车。如果读到 eof，则会引发eoferror。

如果 引入了readline模块，input()会使用它来提供更多特性，如行编辑和历史记录。

33. class int([x]), int(x, base=10)

从一个数字或字符串构建一个整数。如果没有参数，则返回 0。

实际上能使用的 base 包括：0，2-36。

34. isinstance(object, classinfo)

如果 object 是 classinfo 的实例或子类的示例，则返回 true。如果 classinfo 是一个元组，那么只要 object 是其中一个 class 的实例或子类的实例，也返回 true。

33. issubclass(class, classinfo)

基本同上。注意：类是自己的子类。

34. iter(object[, sentinel])

返回一个 iterator 对象。第一个参数的类型取决于是否存在 sentinel。

若没有 sentinel，object 必须支持迭代协议（实现 __iter__()）或序列协议（实现从0开始的__getitem()__），否则将会引发typeerror。

若有 sentinel，那么 object 必须是可调用的对象。这种情况下，调用这个所返回的迭代器的__next__()会直接调用这个对象（没有参数）直到它返回的值等于 sentinel，此时stopiteration会被引发，其他情况下是直接返回值。

一个很有用的应用是使用iter()来构建一个“块读取器”，例如从一个二进制数据库中读取固定 block 大小的数据：

from functools import partial
with open('mydata.db', 'rb') as f:
    for block in iter(partial(f.read, 64), ''):
        process_block(block)

35. len(s)

返回对象的长度。对象可以是一个序列（string/bytes/tuple/list/range）或一个合集（dict/set/frozen set）。

36.class list([iterable])

返回一个列表。

37. locals()

参考 globals()。

38. map(function, iterable, ...)

返回一个 map 对象（迭代器），迭代结果为：将 function 施加于 iterable 的每个元素上所产生的返回值。实例：

def calculatesquare(n):
  return n*n

numbers = (1, 2, 3, 4)
result = map(calculatesquare, numbers)
print(result)

# converting map object to set
numberssquare = set(result)
print(numberssquare)

输出为：

<map object at 0x7f722da129e8>
{16, 1, 4, 9}

39. max(iterable, *[, key, default]), max(arg1, arg2, **args*[, key])

返回 iterable 最大的元素或两个以上参数中最大的。

如果 iterable 是空的，则尝试返回 default。

如果多个元素最大，则返回第一个遇到的。

40. memoryview(obj)

返回一个 memory view 对象。详见 memory view。

41. min(iterable, *[, key, default]), min(arg1, arg2, **args*[, key])

参见 max()。

42. next(iterator[, default])

调用 iterator 的__next__()来获得一个返回值。若 iterator 已经耗尽并且提供了 default，则会返回 default。否则会引发stopiteration。

43. class object()

返回一个空白的对象。object是所有类的基类。

注意：object没有__dict__，所以不能给object对象任意增加属性。

__dict__是一个存储对象可写属性的字典。

44. oct(x)

将整数x转换为八进制字符串（以“0o”开头）。如果x不是一个 python int对象，它需要定义一个__index__()方法来返回一个整数。示例：

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

也可以用format()和字符串格式字面量f"xxx"来完成：

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

45. open(file, mode='r', buffering=-1, encoding=none, errors=none, newline=none, closefd=true, opener=none)

打开一个文件，返回一个 file 对象。如果打不开，将会引发 oserror。

file 可以是一个字符串，或是一个文件描述符 (file descriptor)。

不同 mode 的含义表：

character	meaning
r	读（默认）
w	写，首先会截断（覆盖）之前的文件
x	排斥地(exclusively)创建文件，如果之前存在文件则会失败
a	写，在原文件后增添 (append)
b	二进制模式
t	文本模式（默认）
+	更新文件（读写）

python 区分二进制 i/o 和文本 i/o。二进制 i/o 将内容返回为 bytes 对象，而文本 i/o 将内容返回为 str对象。

buffering 参数是一个可选整数，用来设置缓冲策略。传入 0 将缓冲关闭（仅在二进制模式下允许）；传入 1 选择行缓冲（仅在文本模式下有效）；传入大于 1 的数字用来指定缓冲 trunk 的大小。若不指定 buffering，默认情况为：

• 二进制文件使用固定大小的 trunk 来缓冲，trunk 的大小取决于设备的 block 的大小，在大多数系统上是 4096 或 8192。
• “交互式”文本模式（isatty()返回true的文件）使用行缓冲。其他文本文件使用二进制文件的策略。

encoding 指定文件的编码方式，只能在文本模式下使用。默认的编码方式取决于系统（可以通过locale.getpreferredencoding()查看）。参看codec模块来查看支持的编码方式。

errors 用来指定发生编解码错误时如何处理，只能在文本模式下使用。参看 codec error handlers。

为了简化和标准化错误处理，python 中的 codecs 通常都会接受一个 errors 参数来指定错误处理策略。

newline 控制如何解释”新行“，仅在文本模式下有效。

读取文件时：

newline	含义
none（默认）	universal newline 模式被启用：输入可以是\r、\n或\r\n，并且它们都被翻译成\n再被读取出来。
' '	universal newline 模式被启用：输入可以是\r、\n或\r\n，但它们被原封不动地读取。
'\r'、'\n'或'\r\n'	仅仅适配一种换行符。

写入文件时：

newline	含义
none（默认）	任何\n字符都被翻译为系统默认换行符（os.linesep）。
' '	写入\n。
'\r'、'\n'或'\r\n'	写入对应的换行符。

closefd ：如果 file 是一个字符串，那么 closefd 只能是 false，否则将引发错误；如果 file 是一个文件描述符，那么 closefd 可以被设置为 true，此时这个文件描述符对应的文件即使被关闭了也仍然保持打开。

opener ：一个 callable，要被打开的文件会使用 opener(file, flags) 来打开，opener()需要返回一个打开的文件描述符（比如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

46. ord(c)

输入一个字符，返回这个字符的 unicode 码点。例如ord('a')返回97。

47. pow(x, y[, z])

返回 x 的 y 次幂（模 z）。

48. print(**objects, sep=' ', end='\n', file=sys.stdout, flush=false*)

所有的非关键词参数都通过str()被转换成字符串，以 sep 分隔，以 end 结尾，并将字符串输出到 file。flush 设为true能够强制冲洗缓冲区。

49. class property(fget=none, fset=none, fdel=none, doc=none)

参考我的。

50. range(stop), range(start, stop[, step])

返回一个 range 对象。参考 sequence types — list, tuple, range。

51.repr(object)

返回一个代表 object 的字符串。对于许多类型，比如内置类型，repr()返回的字符串放到eval()里能直接返回那个对象；对于其他类型，它一般返回一个字符串，两边是尖括号，里面包括对象的类型和额外信息（比如名字和内存地址）。一个类可以通过重写__repr__()方法来控制repr()的输出。

52. reversed(seq)

返回一个逆序的迭代器。seq 必须是一个拥有__reversed__()方法的对象，或者它支持序列协议（拥有__len__()方法和从 0 作为参数开始的__getitem__()方法）。

53. round(number[, ndigits])

返回 number 在小数点后舍入到 ndigits 精度的结果。如果省略 ndigits，则返回一个舍入后的整数。

注意：舍入方法不是四舍五入，而是靠近最近的偶数。举例：

>>> round(0.5)
0
>>> round(-0.5)
0
>>> round(1.5)
2

对于一个普通的对象，round()会尝试调用对象的__round__()方法。

round()对浮点数的行为有时会让人琢磨不透：round(2.675, 2)按理说应该返回2.68，但实际上它返回2.67。原因还是 python 的浮点精度问题。

54. class set([iterable])

返回一个 set 对象。参看 set types — set, frozenset。

55. setattr(object, name, value)

和 getattr() 搭配使用。setattr(x, 'foobar', 123) 相当于
x.foobar = 123。

56. class slice(stop), slice(start, stop[, step])

返回一个 slice 对象，用于对序列切片，代表一个在 range(start, stop, step)的下标。python 的扩展下标语法 (在 python 2.3 引入）也可以生成一个 slice 对象。示例：

>>> class c(object):
...     def __getitem__(self, val):
...         print val
... 
>>> c = c()
>>> c[1:2,3:4]
(slice(1, 2, none), slice(3, 4, none))
>>> c[5:6,7]
(slice(5, 6, none), 7)

57. sorted(iterable, *, key=none, reverse=false)

返回一个排序后的 iterable （升序）。key 是一个 callable，可以用来对复杂对象指定“按什么排序”。

这个函数保证是稳定的，即对于“相等”的两个元素，它们的相对位置不会改变。

58. @staticmethod

将一个方法转换为静态方法。

静态方法不接收第一个 implicit 参数（比如 self和cls）。使用方法为：

class c:
    # 使用装饰器
    @staticmethod
    def f(arg1, arg2, ...): ...
    
    # 不使用装饰器
    builtin_open = staticmethod(open)

注意它的 classmethod 的区别：classmethod 可以用来访问和更改这个类的内部状态和属性，但 staticmethod 不能；staticmethod 的主要作用是把一些和某个类相关的工具函数放到这个类的命名空间下。参看 class method vs static method in python。

59. class str(object=''), str(object=b'', encoding='utf-8', errors='strict')

返回一个字符串对象。

60. sum(iterable[, start])

将 iterable 的元素求和，再加上 start ，得到总和并返回。start 默认为 0。通常用于整数类型求和。

对于其他类型有更好的求和方法，比如串联字符串使用''.join(sequence)最快；用扩展精度求和浮点数，使用math.fsum()；将 iterable 串联起来可以使用itertools.chain()。

61. super([type[, object-or-type]])

返回一个代理对象，它能把对方法的调用传递给 type 的父类或兄弟类。

一个类的__mro__动态地记录了“方法解析搜索顺序” （method resuolution search order），像是一个继承链，getattr()和super()使用__mro__来解析对方法的访问。例如：

>>> class mylist(list):
...     x = 1

>>> mylist.__mro__
(<class '__main__.mylist'>, <class 'list'>, <class 'object'>)

super()主要有两个用途：

• 避免显式地使用基类
• 用于多重继承

单继承例子：

class mammal(object):
  def __init__(self, mammalname):
    print(mammalname, 'is a warm-blooded animal.')
    
class dog(mammal):
  def __init__(self):
    print('dog has four legs.')
    super().__init__('dog')
    
d1 = dog()

由于避免直接使用mammal.__init__(self, 'dog')，有一天改变了dog的基类后代码仍然是可用的。

多重继承例子：

class animal:
  def __init__(self, animalname):
    print(animalname, 'is an animal.');

class mammal(animal):
  def __init__(self, mammalname):
    print(mammalname, 'is a warm-blooded animal.')
    super().__init__(mammalname)
    
class nonwingedmammal(mammal):
  def __init__(self, nonwingedmammalname):
    print(nonwingedmammalname, "can't fly.")
    super().__init__(nonwingedmammalname)

class nonmarinemammal(mammal):
  def __init__(self, nonmarinemammalname):
    print(nonmarinemammalname, "can't swim.")
    super().__init__(nonmarinemammalname)

class dog(nonmarinemammal, nonwingedmammal):
  def __init__(self):
    print('dog has 4 legs.');
    super().__init__('dog')
    
d = dog()
print('')
bat = nonmarinemammal('bat') 

输出为：

dog has 4 legs.
dog can't swim.
dog can't fly.
dog is a warm-blooded animal.
dog is an animal.

bat can't swim.
bat is a warm-blooded animal.
bat is an animal.

注意到：一行super().__init__('dog')实际上把它两个基类的__init__()都依次调用了，先调用的是第一个基类，再调用第二个基类。

关于super()在 python 多重继承中的问题，参看 how does python's super() work with multiple inheritance?

关于 mro，可以参看 guido van rossum 的这一篇文章：method resolution order。

参看 。

62. tuple([iterable])

返回一个 tuple 对象。

63. class type(object), type(name, bases, dict)

返回 object 的类型（object.__class__）。

通过三个参数，可以动态构建 class。例如下面两种写法等价：

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

所有“类”的 type 都是 type，包括 type。

64. vars([object])

返回一个对象的__dict__属性。这个对象可以是模块、类、实例等任何对象。

没有参数时，vars()和locals()等价。

65. zip(**iterables*)

将不同 iterables 里的元素融合，返回一个新的 tuple 的迭代器，第 $i$ 个 tuple 是所有传入 iterable 里的第 $i$ 个元素。示例：

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]

zip()搭配*使用可以用来解压：

>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
true

66. __import__(name, globals=none, locals=none, fromlist=(), level=0)

这个函数被import语句调用。你可以通过重写这个函数来改变import语句的行为，只要引入builtins模块并对builtins.__import__赋值即可。但最好别这么做。你若真想搞点自己的东西，可以看看。

from spam.ham import eggs, sausage as saus 实际上执行了

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

（本文完）