python基礎教程：內建函式（一）

摘要： Python直譯器內建了很多函式和型別，可以隨時隨地在程式設計中使用。其實，我們在前面的學習中已經接觸過好多內建函式。 這裡把它們總結成下面的表格，方便我們學習它們的使用： 說明： 上面這個表格包含的有“內建函式”和“內建型別”，其中的...

Python直譯器內建了很多函式和型別，可以隨時隨地在程式設計中使用。其實，我們在前面的學習中已經接觸過好多內建函式。

這裡把它們總結成下面的表格，方便我們學習它們的使用：

說明：

上面這個表格包含的有“內建函式”和“內建型別”，其中的內建型別可以作為函式使用，把其它型別的物件轉變為該型別的物件。比如 int 是一個內建型別， int('123') 就是把字串轉換成整數。兩者在使用上沒有什麼區別，官方文件中也是把內建型別當做內建函式介紹的。

通過ipython，我們可以查看錶格中的是函式還是型別。比如：

In [14]: abs?
Signature: abs(x, /)
Docstring: Return the absolute value of the argument.
Type:builtin_function_or_method

In [15]: int?
Init signature: int(self, /, *args, **kwargs)
Docstring:
int(x=0) -> integer
int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments
are given.If x is a number, return x.__int__().For floating point
numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string,
bytes, or bytearray instance representing an integer literal in the
given base.The literal can be preceded by '+' or '-' and be surrounded
by whitespace.The base defaults to 10\.Valid bases are 0 and 2-36.
Base 0 means to interpret the base from the string as an integer literal.
>>> int('0b100', base=0)
4
Type:type
Subclasses:bool, IntEnum, IntFlag, _NamedIntConstant

在ipython裡面通過問號 ? 來檢視其對應的說明，其中的 Type 就是它的型別，可以看到 abs 是一個內建函式 builtin_function_or_method ，而 int 是一個型別 type 。

我們把這些內建函式（型別）分成幾類進行介紹。

數值型操作

abs(x)

求x的絕對值。x可以是整數或浮點數，如果是複數則返回它的模。

bin(x)

將一個整數轉變為一個字首為 0b 的二進位制字串。結果是一個合法的 Python 表示式。如果 x 不是 Python 的 int 物件，那它需要定義 index () 方法返回一個整數。比如：

In [26]: bin(5)
Out[26]: '0b101'

In [27]: bin(-5)
Out[27]: '-0b101'

x 不能是浮點數，否則會報錯。

還可以通過 format() 函式來進行轉換：

In [30]: format(5, '#b')
Out[30]: '0b101'

In [31]: format(5, 'b')
Out[31]: '101'

還可以用 f-string 格式化來轉換：

In [32]: f'{5:#b}'
Out[32]: '0b101'

In [33]: f'{5:b}'
Out[33]: '101'

chr(i)

返回 Unicode 碼位為整數 i 的字元的字串格式。例如，chr(97) 返回字串 ‘a’，chr(20013) 返回字串 ‘中’。這是 ord() 的逆函式。

實參的合法範圍是 0 到 1,114,111（16 進製表示是 0x10FFFF）。如果 i 超過這個範圍，會觸發 ValueError 異常。

divmod(a, b)

它將兩個（非複數）數字作為實參，並在執行整數除法時返回一對商和餘數。對於混合運算元型別，適用雙目算術運算子的規則。對於整數，結果和 (a // b, a % b) 一致。對於浮點數，結果是 (q, a % b) ，q 通常是 math.floor(a / b) 但可能會比 1 小。在任何情況下， q * b + a % b 和 a 基本相等；如果 a % b 非零，它的符號和 b 一樣，並且 0 <= abs(a % b) < abs(b) 。

format(value[, format_spec])

將 value 轉換為 format_spec 控制的“格式化”表示。

hex(x)

將整數轉換為以“0x”為字首的小寫十六進位制字串。如果 x 不是 Python int 物件，則必須定義返回整數的 index () 方法。

oct(x)

將一個整數轉變為一個字首為“0o”的八進位制字串。結果是一個合法的 Python 表示式。如果 x 不是 Python 的 int 物件，那它需要定義 index () 方法返回一個整數。

ord(c)

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

pow(x, y[, z])

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

round(number[, ndigits])

返回精確到小數點後ndigits精度的數。 如果省略ndigits或者為None，則返回其輸入的最接近的整數。

對於支援round()的內建型別，值被舍入離前一位更近的一端（四捨六入）; 如果距離兩端相等（5）則保留到偶數一邊。（例如，round(0.5)和round(-0.5)均為0，round(1.5)為2）。 任何整數值對ndigits（正數，零或負數）有效。如果省略ndigits或None，則返回值為整數。 否則返回值與number的型別相同。

對於一般的Python物件number，將代理舍入為 number.__round__ 。

註釋：round()對於浮點數的行為可能令人驚訝，比如， round(2.675, 2) 得出 2.67 ，而不是期望的 2.68 。這不是bug，這是因為大多數十進位制小數不能準確表示為二進位制的浮點數。

sum(iterable[, start])

從 start 開始由左到右累加可迭代的元素並返回總數。start預設為0. iterable的項通常是數字，起始值不允許是字串。

對於某些用例，sum()有很好的替代方法。 連線字串序列的首選快速方法是呼叫 ''.join(sequence) 。 要以擴充套件精度累加浮點值，就用 math.fsum() 。要拼接一系列可迭代物件就考慮使用 itertools.chain() 。

可迭代操作

all(iterable), any(iterable)

這兩個函式，我們在前面學習list、dict等資料結構時已經多次學習。

all()： 如果iterable的所有元素都為真（或iterable為空）返回 True ；等價於：

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

any()：如果iterable的任一個元素為真則返回 True 。如果iterable為空，則返回 False 。等價於：

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

enumerate(iterable, start=0)

返回一個列舉物件。iterable 必須是一個序列，或 iterator，或其他支援迭代的物件。 enumerate() 返回的迭代器的 next () 方法返回一個元組，裡面包含一個計數值（從 start 開始，預設為 0）和通過迭代 iterable 獲得的值。

In [4]: ll = ['a', 'b', 'c', 'd']

In [5]: list(enumerate(ll))
Out[5]: [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]

In [6]: list(enumerate(ll, start=1))
Out[6]: [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

等價於:

def enumerate(sequence, start=0):
n = start
for elem in sequence:
yield n, elem
n += 1

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

只有 function 返回 false 時才選取 iterable 中元素的補充函式。

map(function, iterable, …)

產生一個將 function 應用於迭代器中所有元素並返回結果的迭代器。如果傳遞了額外的 iterable 實參，function 必須接受相同個數的實參，並使用所有迭代器中並行獲取的元素。當有多個迭代器時，最短的迭代器耗盡則整個迭代結束。如果函式的輸入已經是元組實參，請參閱 itertools.starmap()。

zip(*iterables)

建立一個聚合來自每個可迭代的元素的迭代器。

返回元組的迭代器，其中第i個元組包含來自每個引數序列或迭代的第i個元素。當最短輸入可迭代用盡時，迭代器停止。使用單個iterable引數，它返回一個1元組的迭代器。沒有引數，它返回一個空迭代器。相當於：

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()與 * 運算子一起用於解壓縮列表：

In [80]: a = [1, 2, 3]

In [81]: b = ['a', 'b', 'c']

In [82]: zipped = zip(a, b)

In [83]: list(zipped)
Out[83]: [(1, 'a'), (2, 'b'), (3, 'c')]

In [84]: a2, b2 = zip(*zip(a, b))

In [85]: a == list(a2) and b == list(b2)
Out[86]: True

max(iterable, *[, key, default])

* max(arg1, arg2, args[, key])

返回可迭代物件中最大的元素，或者返回兩個及以上實參中最大的。

如果只提供了一個位置引數，它必須是非空 iterable，返回可迭代物件中最大的元素；如果提供了兩個及以上的位置引數，則返回最大的位置引數。

有兩個可選只能用關鍵字的實參。key 實參指定排序函式用的引數，如傳給 list.sort() 的。default 實參是當可迭代物件為空時返回的值。如果可迭代物件為空，並且沒有給 default ，則會觸發 ValueError。

如果有多個最大元素，則此函式將返回第一個找到的。這和其他穩定排序工具如 sorted(iterable, key=keyfunc, reverse=True)[0] 和 heapq.nlargest(1, iterable, key=keyfunc) 保持一致。

min(iterable, *[, key, default])

min(arg1, arg2, *args[, key])

返回可迭代物件中最小的元素，或者返回兩個及以上實參中最小的。

如果只提供了一個位置引數，它必須是 iterable，返回可迭代物件中最小的元素；如果提供了兩個及以上的位置引數，則返回最小的位置引數。

有兩個可選只能用關鍵字的實參。key 實參指定排序函式用的引數，如傳給 list.sort() 的。default 實參是當可迭代物件為空時返回的值。如果可迭代物件為空，並且沒有給 default ，則會觸發 ValueError。

如果有多個最小元素，則此函式將返回第一個找到的。這和其他穩定排序工具如 sorted(iterable, key=keyfunc)[0] 和 heapq.nsmallest(1, iterable, key=keyfunc) 保持一致。

reversed(seq)

返回反向迭代器。seq必須是一個具有 reversed ()方法的物件，或者支援序列協議（ len ()方法和 getitem ()方法，整數引數從0開始）。

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

從iterable中的項返回一個新的排序列表。

有兩個可選引數，必須指定為關鍵字引數。

key指定一個引數的函式，該函式用於從iterable中的每個元素中提取比較鍵（例如，key = str.lower）。預設值為None（直接比較元素）。

reverse是一個布林值。 如果設定為True，則列表元素將按照每個比較相反的方式進行排序。

使用functools.cmp_to_key（）將舊式cmp函式轉換為鍵函式。

內建的sorted()函式保證穩定。 如果排序保證不改變比較相等的元素的相對順序，則排序是穩定的 – 這有助於多次傳遞排序（例如，按部門排序，然後按工資等級排序）。

iter(object[, sentinel])

返回一個 iterator 物件。根據是否存在第二個實參，第一個實參的解釋是非常不同的。如果沒有第二個實參，object 必須是支援迭代協議（有 iter () 方法）的集合物件，或必須支援序列協議（有 getitem () 方法，且數字引數從 0 開始）。如果它不支援這些協議，會觸發 TypeError。如果有第二個實參 sentinel，那麼 object 必須是可呼叫的物件。這種情況下生成的迭代器，每次迭代呼叫它的 next () 方法時都會不帶實參地呼叫 object；如果返回的結果是 sentinel 則觸發 StopIteration，否則返回呼叫結果。

next(iterator[, default])

通過呼叫 iterator 的 next () 方法獲取下一個元素。如果迭代器耗盡，則返回給定的 default，如果沒有預設值則觸發 StopIteration。

內建型別

class bool([x])

說明：在文件中，函式的引數用方括號 [] 括起來表示這個引數可有可無（在引數列表中）。

內建型別，返回一個布林值： True 或者 False 。 x 使用標註的真值測試過程來轉換，關於真值測試的知識可以再回顧一下前面我們關於布林值的章節。

bool 類是 int 的子類，這個bool類很特別，它不能被繼承，且只有 True 和 False 兩個例項。

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

返回一個新的 bytes 陣列。 bytearray 類是一個可變序列，包含範圍為 0 <= x < 256 的整數。它有可變序列大部分常見的方法，同時有 bytes 型別的大部分方法。

可選形參 source 可以用不同的方式來初始化陣列：

如果是一個 string，您必須提供 encoding 引數（errors 引數仍是可選的）；bytearray() 會使用 str.encode() 方法來將 string 轉變成 bytes。

• 如果是一個 integer，會初始化大小為該數字的陣列，並使用 null 位元組填充。
• 如果是一個符合 buffer 介面的物件，該物件的只讀 buffer 會用來初始化位元組陣列。
• 如果是一個 iterable 可迭代物件，它的元素的範圍必須是 0 <= x < 256 的整數，它會被用作陣列的初始內容。

如果沒有實參，則建立大小為 0 的陣列。

class bytes([source[, encoding[, errors]]])

返回一個新的“bytes”物件， 是一個不可變序列，包含範圍為 0 <= x < 256 的整數。bytes 是 bytearray 的不可變版本 – 它有其中不改變序列的方法和相同的索引、切片操作。

因此，建構函式的實參和 bytearray() 相同。

class complex([real[, imag]])

返回值為 real + imag*1j 的複數，或將字串或數字轉換為複數。如果第一個形參是字串，則它被解釋為一個複數，並且函式呼叫時必須沒有第二個形參。第二個形參不能是字串。每個實參都可以是任意的數值型別（包括複數）。如果省略了 imag，則預設值為零，建構函式會像 int 和 float 一樣進行數值轉換。如果兩個實參都省略，則返回 0j。

註解 當從字串轉換時，字串在 + 或 – 的周圍必須不能有空格。例如 complex(‘1+2j’) 是合法的，但 complex(‘1 + 2j’) 會觸發 ValueError 異常。

在 3.6 版更改: 您可以使用下劃線將程式碼文字中的數字進行分組。

class float([x])

返回從數字或字串 x 生成的浮點數。

如果實參是字串，則它必須是包含十進位制數字的字串，字串前面可以有符號，之前也可以有空格。可選的符號有 ‘+’ 和 ‘-‘ ； ‘+’ 對建立的值沒有影響。實參也可以是 NaN（非數字）、正負無窮大的字串。

class int([x])

class int(x, base=10)

返回一個使用數字或字串 x 生成的整數物件，或者沒有實參的時候返回 0 。如果 x 定義了 int ()，int(x) 返回 x. int () 。如果 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) 是合法的。

class str(object=”)

class str(object=b”, encoding=’utf-8′, errors=’strict’)

返回一個str型別的物件。 str 是內建字串類

class list([iterable])

除了是函式，list 也是可變序列型別，詳情請參閱 列表 和 Sequence Types — list, tuple, range。

tuple([iterable])

元組是內建的不可變序列型別。 tuple() 生成一個元組物件，可選引數iterable的元素將被加入到新元組。

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

建立一個新的字典。dict 物件是一個字典類

其他容器型別，請參見內建的 list、set 和 tuple 類，以及 collections 模組。

class set([iterable])

返回一個set物件。可選引數iterable的元素將被加入新set物件裡面。

class frozenset([iterable])

返回一個新的 frozenset 物件，它包含可選引數 iterable 中的元素。 frozenset 是一個內建的類。

class object

返回一個沒有特徵的新物件。object 是所有類的基類。它具有所有 Python 類例項的通用方法。這個函式不接受任何實參。

註解 由於 object 沒有 dict ，因此無法將任意屬性賦給 object 的例項。

class range(stop)

class range(start, stop[, step])

range 其實是個不可變數字序列型別而不是一個函式，通常用於在for迴圈中迴圈特定次數。

傳給range的實參必須是整數（或是內建型別int，或是實現了 index 這個特殊方法的物件）。如果 step 引數省略了，則它預設為1.如果 start 省略了則預設為0。如果 step 為0，則報錯： ValueError 。

如果 step 為整數，range 的內容決定於公式： r[i] = start + step*i ，其中 i >= 0, r[i] < stop 。

如果 step 是負數，range 的內容仍決定於公式： r[i] = start + step*i ，其中 i >= 0, r[i] > stop 。

如果r[0]不滿足值約束，則range物件將為空。 range確實支援負索引，但這些索引被解釋為從正索引確定的序列末尾開始的索引。

range被允許包含絕對值大於 sys.maxsize 的值，但是某些特性（如len()）可能會報錯： OverflowError 。

參看下面range的例子：

In [32]: list(range(9))
Out[32]: [0, 1, 2, 3, 4, 5, 6, 7, 8]

In [33]: list(range(3,9))
Out[33]: [3, 4, 5, 6, 7, 8]

In [34]: list(range(0, 20, 3))
Out[34]: [0, 3, 6, 9, 12, 15, 18]

In [35]: list(range(0, -10, -1))
Out[35]: [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

In [36]: list(range(0))
Out[36]: []

In [37]: list(range(10, 0))
Out[37]: []

range型別比通常的list或tuple的優點是，range對線下總是佔用相同（小的）數量的記憶體，不管它表示的範圍有多大。因為它只儲存 start ， stop 和 step 的值，在需要的時候才計算單獨的元素或子範圍。

range物件實現了類似list或tuple序列的特性，比如包含測試，元素索引查詢，切片和對負索引的支援。參見下面的例子：

In [43]: r = range(0, 10, 2)

In [44]: r
Out[44]: range(0, 10, 2)

In [45]: 5 in r
Out[45]: False

In [46]: 6 in r
Out[46]: True

In [47]: r.index(8)
Out[47]: 4

In [48]: r[3]
Out[48]: 6

In [49]: r[:3]
Out[49]: range(0, 6, 2)

In [50]: r[-1]
Out[50]: 8

通過 == 和 != 測試兩個range物件的相等性是把它們當做序列進行比較。也就是說，如果兩個range物件表示相同的值的序列就認為它們實時相等的。

注意：兩個range物件相等但可能含有不同的 start ， stop 和 step 屬性，比如 range(0) == range(2, 1, 1) 或者 range(0, 3, 2) == range(0, 4, 2) 。

class slice(stop)

class slice(start, stop[, step])

返回一個切片物件，表示由range(start,stop,step)指定的索引集。start和step引數預設為None。Slice物件具有隻讀資料屬性start，stop和step，它們只返回引數值（或它們的預設值）。他們沒有其他明確的功能；但是它們被Numerical Python和其他第三方擴充套件使用。使用擴充套件索引語法時也會生成切片物件。例如：a[start:stop:step]或a[start:stop,i]。

class type(object)

class type(name, bases, dict)

傳入一個引數object，則返回該物件的型別。返回值是一個type物件，通常和 object.__class__ 返回的一樣。

建議使用isinstance（）內建函式來測試物件的型別，因為它需要考慮子類。

使用三個引數，返回一個新型別物件。 這實際上是類語句的動態形式。 名稱字串是類名，併成為 name 屬性; 基元元組列出基類併成為 bases 屬性; 並且dict字典是包含類主體定義的名稱空間，並被複制到標準字典以成為 dict 屬性。 例如，以下兩個語句建立相同的型別物件：

大家在學python的時候肯定會遇到很多難題，以及對於新技術的追求，這裡推薦一下我們的Python學習扣qun：784758214，這裡是python學習者聚集地！！同時，自己是一名高階python開發工程師，從基礎的python指令碼到web開發、爬蟲、django、資料探勘等，零基礎到專案實戰的資料都有整理。送給每一位python的小夥伴！每日分享一些學習的方法和需要注意的小細節