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
b=6
sum=a+b
print("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
b=10
print("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
`)
-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])

返回一個 frozenset 物件。

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 中查詢要慢很多。參考 StackOverflow

特殊：-1 的雜湊值是 -2，因為 CPython 裡 -1 用來返回錯誤，所以 -1 的雜湊值被改成了 -2。所以hash(-1)==hash(-2)。參考 StackOverflow。

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 模式被啟用：輸入可以是 、 或 ，並且它們都被翻譯成 再被讀取出來。
` `	Universal newline 模式被啟用：輸入可以是 、 或 ，但它們被原封不動地讀取。
` `、` `或` `	僅僅適配一種換行符。

寫入檔案時：

newline	含義
None（預設）	任何 字元都被翻譯為系統預設換行符（os.linesep）。
` `	寫入 。
` `、` `或` `	寫入對應的換行符。

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=`
`, 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。

參看 guide to using super()。

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__賦值即可。但最好別這麼做。你若真想搞點自己的東西，可以看看importlib.import_module()。

from spam.ham import eggs, sausage as saus 實際上執行了

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

（本文完）