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

舉例：

num = 126
print(oct(num))
num = 100
print(oct(num))
num = 64
print(oct(num))

0o176
0o144
0o100

48.open()

說明：open() 函數用於打開一個文件，創建一個 file 對象，相關的方法纔可以調用它進行讀寫。

關於open函數，後期會專本出該函數的專題，全面講解open函數對文件操作的使用方法。

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

打開 file 並返回對應的 file object。如果該文件不能打開，則觸發 OSError。

file 是一個 path-like object，表示將要打開的文件的路徑（絕對路徑或者當前工作目錄的相對路徑），也可以是要被封裝的整數類型文件描述符。（如果是文件描述符，它會隨着返回的 I/O 對象關閉而關閉，除非 closefd 被設爲 False 。）

mode 是一個可選字符串，用於指定打開文件的模式。默認值是 'r' ，這意味着它以文本模式打開並讀取。其他常見模式有：寫入 'w' （截斷已經存在的文件）；排它性創建 'x' ；追加寫 'a' （在一些 Unix 系統上，無論當前的文件指針在什麼位置，所有寫入都會追加到文件末尾）。在文本模式，如果 encoding 沒有指定，則根據平臺來決定使用的編碼：使用 locale.getpreferredencoding(False) 來獲取本地編碼。（要讀取和寫入原始字節，請使用二進制模式並不要指定 encoding。）可用的模式有：

字符

含義

'r'

讀取（默認）

'w'

寫入，並先截斷文件

'x'

排它性創建，如果文件已存在則失敗

'a'

寫入，如果文件存在則在末尾追加

'b'

二進制模式

't'

文本模式（默認）

'+'

更新磁盤文件（讀取並寫入）

默認的模式是 'r' （打開並讀取文本，同 'rt' ）。對於二進制寫入， 'w+b' 模式打開並把文件截斷成 0 字節； 'r+b' 則不會截斷。

正如在概述中提到的，Python區分二進制和文本I/O。以二進制模式打開的文件（包括 mode 參數中的 'b' ）返回的內容爲 bytes`對象，不進行任何解碼。在文本模式下（默認情況下，或者在 *mode* 參數中包含 `'t'` ）時，文件內容返回爲 str ，首先使用指定的 encoding （如果給定）或者使用平臺默認的的字節編碼解碼。

此外還允許使用一個模式字符 'U'，該字符已不再具有任何效果，並被視爲已棄用。之前它會在文本模式中啓用 universal newlines，這在 Python 3.0 中成爲默認行爲。請參閱 newline 形參的文檔瞭解更多細節。

註解

Python不依賴於底層操作系統的文本文件概念;所有處理都由Python本身完成，因此與平臺無關。

buffering 是一個可選的整數，用於設置緩衝策略。傳遞0以切換緩衝關閉（僅允許在二進制模式下），1選擇行緩衝（僅在文本模式下可用），並且>1的整數以指示固定大小的塊緩衝區的大小（以字節爲單位）。如果沒有給出 buffering 參數，則默認緩衝策略的工作方式如下:

二進制文件以固定大小的塊進行緩衝；使用啓發式方法選擇緩衝區的大小，嘗試確定底層設備的“塊大小”或使用 io.DEFAULT_BUFFER_SIZE。在許多系統上，緩衝區的長度通常爲4096或8192字節。

“交互式”文本文件（ isatty() 返回 True 的文件）使用行緩衝。其他文本文件使用上述策略用於二進制文件。

encoding 是用於解碼或編碼文件的編碼的名稱。這應該只在文本模式下使用。默認編碼是依賴於平臺的（不管 locale.getpreferredencoding() 返回何值），但可以使用任何Python支持的 text encoding 。有關支持的編碼列表，請參閱 codecs 模塊。

errors 是一個可選的字符串參數，用於指定如何處理編碼和解碼錯誤 - 這不能在二進制模式下使用。可以使用各種標準錯誤處理程序（列在錯誤處理方案），但是使用 codecs.register_error() 註冊的任何錯誤處理名稱也是有效的。標準名稱包括:

如果存在編碼錯誤，'strict' 會引發 ValueError 異常。默認值 None 具有相同的效果。

'ignore' 忽略錯誤。請注意，忽略編碼錯誤可能會導致數據丟失。

'replace' 會將替換標記（例如 '?' ）插入有錯誤數據的地方。

'surrogateescape' 將表示任何不正確的字節作爲Unicode專用區中的代碼點，範圍從U+DC80到U+DCFF。當在寫入數據時使用 surrogateescape 錯誤處理程序時，這些私有代碼點將被轉回到相同的字節中。這對於處理未知編碼的文件很有用。

只有在寫入文件時才支持 'xmlcharrefreplace'。編碼不支持的字符將替換爲相應的XML字符引用 &#nnn;。

'backslashreplace' 用Python的反向轉義序列替換格式錯誤的數據。

'namereplace' （也只在編寫時支持）用 \N{...} 轉義序列替換不支持的字符。

newline 控制 universal newlines 模式如何生效（它僅適用於文本模式）。它可以是 None，''，'\n'，'\r' 和 '\r\n'。它的工作原理:

從流中讀取輸入時，如果 newline 爲 None，則啓用通用換行模式。輸入中的行可以以 '\n'，'\r' 或 '\r\n' 結尾，這些行被翻譯成 '\n' 在返回呼叫者之前。如果它是 ''，則啓用通用換行模式，但行結尾將返回給調用者未翻譯。如果它具有任何其他合法值，則輸入行僅由給定字符串終止，並且行結尾將返回給未調用的調用者。

將輸出寫入流時，如果 newline 爲 None，則寫入的任何 '\n' 字符都將轉換爲系統默認行分隔符 os.linesep。如果 newline 是 '' 或 '\n'，則不進行翻譯。如果 newline 是任何其他合法值，則寫入的任何 '\n' 字符將被轉換爲給定的字符串。

如果 closefd 是 False 並且給出了文件描述符而不是文件名，那麼當文件關閉時，底層文件描述符將保持打開狀態。如果給出文件名則 closefd 必須爲 True （默認值），否則將引發錯誤。

可以通過傳遞可調用的 opener 來使用自定義開啓器。然後通過使用參數（ file，flags ）調用 opener 獲得文件對象的基礎文件描述符。 opener 必須返回一個打開的文件描述符（使用 os.open as opener 時與傳遞 None 的效果相同）。

新創建的文件是不可繼承的。

下面的示例使用 os.open() 函數的 dir_fd 的形參，從給定的目錄中用相對路徑打開文件:

>>>
>>> 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() 函數所返回的 file object 類型取決於所用模式。當使用 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 版更改:

增加了 opener 形參。

增加了 'x' 模式。

過去觸發的 IOError，現在是 OSError 的別名。

如果文件已存在但使用了排它性創建模式（ 'x' ），現在會觸發 FileExistsError。

在 3.4 版更改:

文件現在禁止繼承。

Deprecated since version 3.4, will be removed in version 3.9: 'U' 模式。

在 3.5 版更改:

如果系統調用被中斷，但信號處理程序沒有觸發異常，此函數現在會重試系統調用，而不是觸發 InterruptedError 異常 (原因詳見 PEP 475)。

增加了 'namereplace' 錯誤處理接口。

在 3.6 版更改:

增加對實現了 os.PathLike 對象的支持。

在 Windows 上，打開一個控制檯緩衝區將返回 io.RawIOBase 的子類，而不是 io.FileIO。

字符	含義
`'r'`	讀取（默認）
`'w'`	寫入，並先截斷文件
`'x'`	排它性創建，如果文件已存在則失敗
`'a'`	寫入，如果文件存在則在末尾追加
`'b'`	二進制模式
`'t'`	文本模式（默認）
`'+'`	更新磁盤文件（讀取並寫入）

備註：open函數會在後面章節中單獨講解，這裏僅做了解。

49.`ord`()

說明：ord() 函數是 chr() 函數（對於8位的ASCII字符串）或 unichr() 函數（對於Unicode對象）的配對函數，它以一個字符（長度爲1的字符串）作爲參數，返回對應的 ASCII 數值，或者 Unicode 數值，如果所給的 Unicode 字符超出了你的 Python 定義範圍，則會引發一個 TypeError 的異常。

ord(c)

對錶示單個 Unicode 字符的字符串，返回代表它 Unicode 碼點的整數。例如 ord('a') 返回整數 97， ord('€') （歐元符號）返回 8364 。這是 chr() 的逆函數。

正確使用舉例：

print(ord('a'))

錯誤示範：

print(ord('aa'))

    print(ord('aa'))
TypeError: ord() expected a character, but string of length 2 found

50.`pow`()

說明：pow() 方法返回 xy（x的y次方）的值。

pow(x, y[, z])

返回 x 的 y 次冪；如果 z 存在，則對 z 取餘（比直接 pow(x, y) % z 計算更高效）。兩個參數形式的 pow(x, y) 等價於冪運算符： x**y。

參數必須爲數值類型。對於混用的操作數類型，則適用二元算術運算符的類型強制轉換規則。對於 int 操作數，結果具有與操作數相同的類型（轉換後），除非第二個參數爲負值；在這種情況下，所有參數將被轉換爲浮點數並輸出浮點數結果。例如，10**2 返回 100，但 10**-2 返回 0.01。如果第二個參數爲負值，則第三個參數必須省略。如果存在 z，則 x 和 y 必須爲整數類型，且 y 必須爲非負數。

舉例：

print(pow(2,4))

print(pow(5,3))

51.`print`()

說明：打印，python中最爲常見最爲易懂的內置函數，沒有之一。唯一要注意的是print函數的參數用法：

def print(self, *args, sep=' ', end='\n', file=None):

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 關鍵字參數。

舉例：

print('hello world')

hello world

52. `property`()

說明：property() 函數的作用是在新式類中返回屬性值。

說明：

class property(fget=None, fset=None, fdel=None, doc=None)

返回 property 屬性。

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，c.x = value 將調用setter， del c.x 將調用deleter。

如果給出，doc 將成爲該 property 屬性的文檔字符串。否則該 property 將拷貝 fget 的文檔字符串（如果存在）。這令使用 property() 作爲 decorator 來創建只讀的特徵屬性可以很容易地實現:
class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage
以上 @property 裝飾器會將 voltage() 方法轉化爲一個具有相同名稱的只讀屬性的 "getter"，並將 voltage 的文檔字符串設置爲 "Get the current 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 版更改: 特徵屬性對象的文檔字符串現在是可寫的。

備註：類和對象的內置函數會放到後面再統一學習，這裏僅瞭解即可。

53.`range`()

說明：range函數用來表示一個範圍,range() 函數可創建一個整數列表，一般用在 for 循環中。和分片概念一樣，取左不去右，range(1,10)表示1——9這9個數字，不包含10。

class range(stop)

class range(start, stop[, step])

雖然被稱爲函數，但 range 實際上是一個不可變的序列類型，參見在 range 對象與序列類型 --- list, tuple, range 中的文檔說明。

print(range(1,10))
print(type(range(1,10)))
for i in range(1,10):
    print(i)

range(1, 10)
<class 'range'>
1
2
3
4
5
6
7
8
9

54.repr()

說明：repr() 函數將對象轉化爲供解釋器讀取的形式。也就是repr函數會將對象轉換爲字符串類型。

repr(object)

返回包含一個對象的可打印表示形式的字符串。對於許多類型來說，該函數會嘗試返回的字符串將會與該對象被傳遞給 eval() 時所生成的對象具有相同的值，在其他情況下表示形式會是一個括在尖括號中的字符串，其中包含對象類型的名稱與通常包括對象名稱和地址的附加信息。類可以通過定義 __repr__() 方法來控制此函數爲它的實例所返回的內容。

舉例：

lst = ['a','b','c']
print(repr(lst))
print(type(repr(lst)))

['a', 'b', 'c']
<class 'str'>

55.`reversed`()

說明：reversed 函數返回一個反轉的迭代器。顧名思義，該函數用於反轉。

reversed(seq)

返回一個反向的 iterator。 seq 必須是一個具有 __reversed__() 方法的對象或者是支持該序列協議（具有從 0 開始的整數類型參數的 __len__() 方法和 __getitem__() 方法）。

舉例：

lst = ['a','b','c']
print(reversed(lst))
print(type(reversed(lst)))
print(list(reversed(lst)))

<list_reverseiterator object at 0x0000012C14B8E048>
<class 'list_reverseiterator'>
['c', 'b', 'a']

56.`round`()

說明：round() 方法返回浮點數x的四捨五入值。該函數用於四捨五入。

round(number[, ndigits])

返回 number 舍入到小數點後 ndigits 位精度的值。如果 ndigits 被省略或爲 None，則返回最接近輸入值的整數。

對於支持 round() 的內置類型，值會被舍入到最接近的 10 的負 ndigits 次冪的倍數；如果與兩個倍數的距離相等，則選擇偶數 (因此，round(0.5) 和 round(-0.5) 均爲 0 而 round(1.5) 爲 2)。任何整數值都可作爲有效的 ndigits (正數、零或負數)。如果 ndigits 被省略或爲 None 則返回值將爲整數。否則返回值與 number 的類型相同。

對於一般的 Python 對象 number, round 將委託給 number.__round__。

註解

對浮點數執行 round() 的行爲可能會令人驚訝：例如，round(2.675, 2) 將給出 2.67 而不是期望的 2.68。這不算是程序錯誤：這一結果是由於大多數十進制小數實際上都不能以浮點數精確地表示。請參閱浮點算術：爭議和限制瞭解更多信息。

舉例：

print(round(1.5))
print(round(-1.5))
print(round(25.9))

2
-2
26

57.`set`()

說明：set類型轉換，也就是集合。集合在之前的學習中有講到，最主要的作用就是排序。

class set([iterable])

返回一個新的 set 對象，可以選擇帶有從 iterable 獲取的元素。 set 是一個內置類型。請查看 set 和集合類型 --- set, frozenset 獲取關於這個類的文檔。

有關其他容器請參看內置的 frozenset, list, tuple 和 dict 類，以及 collections 模塊。

舉例：

list = [1,2,3,4,5]
print(set(list))
print(type(set(list)))

{1, 2, 3, 4, 5}
<class 'set'>

排序作用：

list = [1,2,3,4,5,9,8,7,6]
print(set(list))
print(type(set(list)))

{1, 2, 3, 4, 5, 6, 7, 8, 9}
<class 'set'>

58.`setattr`()

說明：setattr() 函數對應函數 getattr()，用於設置屬性值，該屬性不一定是存在的。

setattr(object, name, value)

此函數與 getattr() 兩相對應。其參數爲一個對象、一個字符串和一個任意值。字符串指定一個現有屬性或者新增屬性。函數會將值賦給該屬性，只要對象允許這種操作。例如，setattr(x, 'foobar', 123) 等價於 x.foobar = 123。

舉例：類和對象的內置函數會放到後面再統一學習，這裏僅瞭解即可。

59.`slice`()

說明：slice()函數實際上是切片類的一個構造函數，返回一個切片對象，千萬不能把其當作函數使用。

slice() 函數實現切片對象，主要用在切片操作函數裏的參數傳遞。

class slice(stop)

class slice(start, stop[, step])

返回一個表示由 range(start, stop, step) 所指定索引集的 slice 對象。其中 start 和 step 參數默認爲 None。切片對象具有僅會返回對應參數值（或其默認值）的只讀數據屬性 start, stop 和 step。它們沒有其他的顯式功能；不過它們會被 NumPy 以及其他第三方擴展所使用。切片對象也會在使用擴展索引語法時被生成。例如: a[start:stop:step] 或 a[start:stop, i]。請參閱 itertools.islice() 瞭解返回迭代器的一種替代版本。

舉例：

rang = range(1,10)
print(rang)
slice = slice(1,6,2)
print(slice)
print(rang[slice])
for i in rang:
    print(i)

range(1, 10)
slice(1, 6, 2)
range(2, 7, 2)
1
2
3
4
5
6
7
8
9

備註：通過舉例可以看出，slice得到的就是一個分片對象，這個分片對象可以直接拿來使用。所以最好不要把slice當作一個函數去使用，會產生誤解。

60.`sorted`()

說明：sorted() 函數對所有可迭代的對象進行排序操作。

sort 與 sorted 區別：

sort 是應用在 list 上的方法，sorted 可以對所有可迭代的對象進行排序操作。

list 的 sort 方法返回的是對已經存在的列表進行操作，無返回值，而內建函數 sorted 方法返回的是一個新的 list，而不是在原來的基礎上進行的操作。

sorted(iterable, *, key=None, reverse=False)

根據 iterable 中的項返回一個新的已排序列表。

具有兩個可選參數，它們都必須指定爲關鍵字參數。

key 指定帶有單個參數的函數，用於從 iterable 的每個元素中提取用於比較的鍵 (例如 key=str.lower)。默認值爲 None (直接比較元素)。

reverse 爲一個布爾值。如果設爲 True，則每個列表元素將按反向順序比較進行排序。

使用 functools.cmp_to_key() 可將老式的 cmp 函數轉換爲 key 函數。

內置的 sorted() 確保是穩定的。如果一個排序確保不會改變比較結果相等的元素的相對順序就稱其爲穩定的 --- 這有利於進行多重排序（例如先按部門、再按薪級排序）。

有關排序示例和簡要排序教程，請參閱排序指南。

舉例：

lst = [5,8,2,4,9,1,3]
print(sorted(lst))
print(lst)
lst.sort()
print(lst)

[1, 2, 3, 4, 5, 8, 9]

[1, 2, 3, 4, 5, 8, 9]
[5, 8, 2, 4, 9, 1, 3]
[1, 2, 3, 4, 5, 8, 9]

備註：簡單來說sort()方法會改變原先的內容，而sorted函數會重新返回一個新的排序後的內容。

61.`staticmethod`

說明：@staticmethod將方法轉換爲靜態方法。

@staticmethod

將方法轉換爲靜態方法。

靜態方法不會接收隱式的第一個參數。要聲明一個靜態方法，請使用此語法
class C:
    @staticmethod
    def f(arg1, arg2, ...): ...
@staticmethod 這樣的形式稱爲函數的 decorator -- 詳情參閱函數定義。

靜態方法的調用可以在類上進行 (例如 C.f()) 也可以在實例上進行 (例如 C().f())。

Python中的靜態方法與Java或C ++中的靜態方法類似。另請參閱 classmethod() ，用於創建備用類構造函數的變體。

像所有裝飾器一樣，也可以像常規函數一樣調用 staticmethod ，並對其結果執行某些操作。比如某些情況下需要從類主體引用函數並且您希望避免自動轉換爲實例方法。對於這些情況，請使用此語法:
class C:
    builtin_open = staticmethod(open)
想了解更多有關靜態方法的信息，請參閱標準類型層級結構。

舉例：類和對象相關的內置函數會放到後面再統一學習，這裏僅瞭解即可。

62. `str`()

說明：字符串數據類型轉換函數。

class str(object='')

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

返回一個 str 版本的 object 。有關詳細信息，請參閱 str() 。

str 是內置字符串 class 。更多關於字符串的信息查看文本序列類型 --- str。

舉例：

lst = [5,8,2,4,9,1,3]
print(type(lst))
print(str(lst))
print(type(str(lst)))

<class 'list'>
[5, 8, 2, 4, 9, 1, 3]
<class 'str'>

63.sum()

說明：求和函數。sum() 方法對系列進行求和計算。

sum(iterable[, start])

從 start 開始自左向右對 iterable 中的項求和並返回總計值。 start 默認爲 0。 iterable 的項通常爲數字，開始值則不允許爲字符串。

對某些用例來說，存在 sum() 的更好替代。拼接字符串序列的更好更快方式是調用 ''.join(sequence)。要以擴展精度對浮點值求和，請參閱 math.fsum()。要拼接一系列可迭代對象，請考慮使用 itertools.chain()。

舉例：

lst = [5,8,2,4,9,1,3]
print(sum(lst))

64.`super`()

說明：super() 函數是用於調用父類(超類)的一個方法。

super 是用來解決多重繼承問題的，直接用類名調用父類方法在使用單繼承的時候沒問題，但是如果使用多繼承，會涉及到查找順序（MRO）、重複調用（鑽石繼承）等種種問題。

MRO 就是類的方法解析順序表, 其實也就是繼承父類方法時的順序表。

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

返回一個代理對象，它會將方法調用委託給 type 指定的父類或兄弟類。這對於訪問已在類中被重載的繼承方法很有用。搜索順序與 getattr() 所使用的相同，只是 type 指定的類型本身會被跳過。

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)
除了方法查找之外，super() 也可用於屬性查找。一個可能的此種用例是在上級或同級類中調用 descriptor。

請注意 super() 是作爲顯式加點屬性查找的綁定過程的一部分來實現的，例如 super().__getitem__(name)。它做到這一點是通過實現自己的 __getattribute__() 方法，這樣就能以可預測的順序搜索類，並且支持協作多重繼承。對應地，super() 在像 super()[name] 這樣使用語句或操作符進行隱式查找時則未被定義。

還要注意的是，除了零個參數的形式以外，super() 並不限於在方法內部使用。兩個參數的形式明確指定參數並進行相應的引用。零個參數的形式僅適用於類定義內部，因爲編譯器需要填入必要的細節以正確地檢索到被定義的類，還需要讓普通方法訪問當前實例。

對於有關如何使用 super() 來如何設計協作類的實用建議，請參閱使用 super() 的指南。

備註：類和對象相關的內置函數會放到後面再統一學習，這裏僅瞭解即可。

65.`tuple`()

說明：元組類型轉換函數。

class tuple([iterable])

雖然被稱爲函數，但 tuple 實際上是一個不可變的序列類型，參見在元組與序列類型 --- list, tuple, range 中的文檔說明。

舉例：

lst = [1,2,3,4,5]
tpule = (tuple(lst))
print(tpule)
print(type(tpule))

(1, 2, 3, 4, 5)
<class 'tuple'>

66.`type`()

說明：返回數據類型。可以利用該函數去查看值的數據類型。

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))
另請參閱類型對象。

在 3.6 版更改: type 的子類如果未重載 type.__new__，將不再能使用一個參數的形式來獲取對象的類型。

舉例：

lst = [1,2,3,4,5]
str = 'Jack'
num = 3.1415926
dict = {'class':'python'}
print(lst,str,num,dict)
print(type(lst),type(str),type(num),type(dict))

[1, 2, 3, 4, 5] Jack 3.1415926 {'class': 'python'}
<class 'list'> <class 'str'> <class 'float'> <class 'dict'>

67.`vars`()

說明：vars() 函數返回對象object的屬性和屬性值的字典對象。

vars([object])

返回模塊、類、實例或任何其它具有 __dict__ 屬性的對象的 __dict__ 屬性。

模塊和實例這樣的對象具有可更新的 __dict__ 屬性；但是，其它對象的 __dict__ 屬性可能會設爲限制寫入（例如，類會使用 types.MappingProxyType 來防止直接更新字典）。

不帶參數時，vars() 的行爲類似 locals()。請注意，locals 字典僅對於讀取起作用，因爲對 locals 字典的更新會被忽略。

舉例：類和對象的內置函數會放到後面再統一學習，這裏僅瞭解即可。

68.`zip`()

說明：zip() 函數用於將可迭代的對象作爲參數，將對象中對應的元素打包成一個個元組，然後返回由這些元組組成的列表。

如果各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同，利用 * 號操作符，可以將元組解壓爲列表。

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

舉例：

各個迭代器的元素個數一致的情況下：

lst = [1,2,3,4]
str = 'Jack'
a = list(zip(lst,str))
print(a)
b = dict(zip(lst,str))
print(b)
print(zip(lst,str))
print(type(zip(lst,str)))

[(1, 'J'), (2, 'a'), (3, 'c'), (4, 'k')]
{1: 'J', 2: 'a', 3: 'c', 4: 'k'}
<zip object at 0x00000214C894E248>
<class 'zip'>

各個迭代器的元素個數不一致的情況下：

lst = [1,2,3,4,5]
str = 'Jack'
a = list(zip(lst,str))
print(a)
b = dict(zip(lst,str))
print(b)

[(1, 'J'), (2, 'a'), (3, 'c'), (4, 'k')]
{1: 'J', 2: 'a', 3: 'c', 4: 'k'}

69.`import`

說明：__import__() 函數用於動態加載類和函數。

如果一個模塊經常變化就可以使用 __import__() 來動態載入。

__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()

在 3.3 版更改: Negative values for level are no longer supported (which also changes the default value to 0).

備註：同樣的，類和對象相關的內置函數會放到後面再統一學習，這裏僅瞭解即可。

以上便是《Python學習14：內置函數（二）》所有內容，作爲內置函數三部曲的最後一篇，69個內置函數已經全部介紹完畢。

而python中經常使用並相對有難度的內置函數會在之後的逐一講解。類和對象的學習內容會在內置函數的學習中穿插進行。

目前《Python學習》專題正在不斷更新，原創不易，如果喜歡請點贊和關注，謝謝大家的支持！

獲得更多免費的學習資料請添加微信公衆號——風起怨江南，有任何問題可以隨時和我交流溝通。

Python學習15：內置函數（三）

Python常用的內置函數

47.`oct`()

48.open()

49.`ord`()

50.`pow`()

51.`print`()

52. `property`()

53.`range`()

54.repr()

55.`reversed`()

56.`round`()

57.`set`()

58.`setattr`()

59.`slice`()

60.`sorted`()

61.`staticmethod`

62. `str`()

63.sum()

64.`super`()

65.`tuple`()

66.`type`()

67.`vars`()

68.`zip`()

69.`import`

教你用Perl實現Smgp協議

如何通過前端表格控件在10分鐘內完成一張分組報表？

win11關閉自動檢測病毒刪文件

千兆寬帶實際網速能到達多少？

Python學習00：不同操作系統的安裝和"Hello World!"

軟件研發模型和軟件測試模型

Jenkins學習01：Jenkins的介紹、下載和安裝

忘記Jenkins登陸密碼怎麼辦？學會這招就夠了

Python學習17：模塊和包的導入

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結