Python 解釋器內置(內建)了很多函數，這篇博文對它們進行逐一介紹，博主覺得有必要給出示例代碼的會給出示例代碼。
聲明：博主(昊虹圖像算法)寫這篇博文時，用的Python的版本號為3.9.10。
官方文檔：https://docs.python.org/zh-cn/3.9/library/functions.html#built-in-functions
說明：官方文檔裏列出了14*5-1=59個內置函數，但博主認為classmethod、staticmethod、property這三個更像是定義類的三個關鍵字，故沒在這篇博文中進行介紹，如果要看這三個的介紹，可參考我的另一篇博文，鏈接 https://blog.csdn.net/wenhao_ir/article/details/125383895
這篇博文中反複提到了可迭代對象的概論，那麼什麼是可迭代對象呢？
列錶、元組、字典和集合就是典型的可迭代對象，這些對象都包含方法 __iter__() 或__next__()。可迭代對象的元素能夠通過其內部的方法 __iter__() 或 __next__()進行遍曆。
abs(x)
返回一個數的絕對值。 參數可以是整數、浮點數或任何實現了 __abs__() 的對象。 如果參數是一個複數，則返回它的模。
這個的示例代碼就不給了。
什麼叫可迭代對象？列錶、元組、字典和集合就是典型的可迭代對象，這些對象都包含方法 __iter__() 和 __next__()。可迭代對象的元素能夠通過其內部的方法 __iter__() 和 __next__()進行遍曆。
那麼元素對象滿足什麼條件為True呢？可參考我的另一篇博文 https://blog.csdn.net/wenhao_ir/article/details/125439660
注意：按道理，空元組、空列錶的布爾值為False，所以對於空元組、空列錶，函數all()應該返回False才對，但事實並不是這樣，對於空元組、空列錶函數all()的返回值也為True，這一點要特別注意。
示例代碼如下：
list1 = [1, 2, 3]
list2 = [-1, 2, 3]
list3 = [0, 2, 3]
list4 = []
bool1 = all(list1)
bool2 = all(list2)
bool3 = all(list3)
bool4 = all(list4)
運行結果如下：
什麼叫可迭代對象？列錶、元組、字典和集合就是典型的可迭代對象，這些對象都包含方法 __iter__() 和 __next__()。
any() 函數用於判斷可迭代對象是否有一個以上元素為True，如果有一個為 True，則返回 True；如果全部為False，則返回 False。
那麼元素對象滿足什麼條件為True呢？可參考我的另一篇博文 https://blog.csdn.net/wenhao_ir/article/details/125439660
注意：對於函數any()而言，空元組、空列錶返回值為False。
示例代碼如下：
list1 = [0, '', False, None]
list2 = [-1, 2, 3]
list3 = [0, 2, 3]
list4 = []
bool1 = any(list1)
bool2 = any(list2)
bool3 = any(list3)
bool4 = any(list4)
運行結果如下:
函數ascii()返回任何對象(字符串、元組、列錶等)的可讀版本，有點類似於把對象強制轉換為ASCII碼字符串，它會將非ASCII字符替換為轉義字符。
上面這句話不太好理解，看一個示例代碼就知道了。
示例代碼如下：
x1 = ascii('My name is Ståle')
print(x1)
x2 = ascii([77, 88, 'swh'])
print(x2)
運行結果如下：
這裏要注意x1中的“\xe5”是怎麼回事？那是因為在ASCII碼中沒有字符å ，所以將其替換成了 \xe5
另外， 我們看到字符串的前後的引號也被轉換成了字符。
示例代碼如下：
x1 = bin(10)
print(x1)
運行結果如下：
關於函數bool()，請參見我的另一篇博文 https://blog.csdn.net/wenhao_ir/article/details/125439660
這個函數是3.7 版之後才有的，使用頻率也不高，暫時不做過多介紹。
函數bytearray()的語法如下：
bytearray([source[, encoding[, errors]]])
參數介紹：
如果 source 為整數，則返回一個長度為 source 的初始化數組；
如果 source 為字符串，則按照指定的 encoding 將字符串轉換為字節序列；
如果 source 為可迭代類型，因為每個元素的存儲空間只有一個字節，則元素必須為[0 ,255] 中的整數；
如果沒有輸入任何參數，默認就是初始化數組為0個元素。
示例代碼如下：
bytearray0 = bytearray()
bytearray1 = bytearray(5)
bytearray2 = bytearray('suwenhao', 'utf-8')
bytearray3 = bytearray([65, 66, 67])
運行結果如下：
從上面的運行結果我們可以看出：
①長度為 source 的初始化數組的元素的默認值為\x00
②顯示是以ASCII碼來顯示其值的，所以bytearray3的三個數被顯示為了大寫的字母ABC。
如果指定的對象是可調用的，則返回 True，否則返回 False。
注意：如果函數callable()返回True，object 仍然可能調用失敗；但如果返回 False，調用對象 object 絕對不會成功。
對於函數、方法、lambda 匿名函數、 類以及實現了 __call__ 方法的類實例, 它都會返回 True。
示例代碼如下：
def add(a_p, b_p):
return a_p + b_p
class A:
def method(self):
return 0
class B:
def __call__(self):
return 0
bool1 = callable(0) # 對象0不可被調用,所以應該返回False
bool2 = callable(add) # 函數add返回True
bool3 = callable(A) # 類A返回True
a = A()
bool4 = callable(a) # 類A的實例化對象a沒有實現__call__，所以應該返回False
bool5 = callable(B) # 類B返回True
b = B()
bool6 = callable(b) # 類B的實例化對象b實現了__call__，所以應該返回True
運行結果如下：
函數chr( i )返回 Unicode 碼比特為整數 i 的字符的字符串格式。例如，chr(97) 返回字符串 ‘a’，chr(8364) 返回字符串 ‘€’。
i — 可以是 10 進制也可以是 16 進制的形式的數字，數字範圍為 0 到 1,114,111 (16 進制為0x10FFFF)。
示例代碼如下：
char1 = chr(97)
char2 = chr(8364)
運行結果如下：
另外，可用使用函數ord()返回字符的ASCII 數值或者Unicode數值，詳情見本文的第47個函數。
函數compile()的作用將字符串代碼編譯成可運行的代碼對象。
看了上面這句話通常還是不知道它幹了啥。沒關系，看一下示例代碼就知道了。
示例代碼如下：
a1 = 188
x = compile('print(a1)', 'jhoij', 'eval')
eval(x)
運行結果如下：
從上面的示例代碼我們可以看出，當對語句 print(a1) 執行了形式為eval的compile操作後，得到了對象x，此時用eval()函數調用對象x，就相當於執行了語句print(a1)。
那這樣的操作有什麼意義呢？
網上查到一個觀點如下：
當執行字符串形式的代碼時，每次都必須對這些代碼進行字節編譯處理。compile()函數提供了一次性字節代碼預編譯，以後每次調用的時候，都不用編譯了。
但是博主(昊虹君)覺得這個說法有點問題，從上面的例子來看，每次運行這個腳本的時候還是會去執行一次compile()函數，那還是每次都去編譯了啊，除非它的結果被緩存在某個地方。
compile()函數語法如下：
compile(source, filename, mode[, flags[, dont_inherit,[ optimize]]])
參數意義如下：
複數是Python中數值類型的一種。可以用函數complex()通過指定複數的實部和虛部來得到複數。
示例代碼如下：
z1 = complex(7, 8)
print(z1)
運行結果如下：
語法如下：
delattr(object, name)
object – 對象。
name – 必須是對象的屬性。
示例代碼如下：
class Coordinate:
x = 10
y = -5
z = 0
point1 = Coordinate()
print('x = ', point1.x)
print('y = ', point1.y)
print('z = ', point1.z)
delattr(Coordinate, 'z')
print('--刪除 z 屬性後--')
print('x = ', point1.x)
print('y = ', point1.y)
# 觸發錯誤
print('z = ', point1.z)
運行結果如下：
函數dict()的詳情請參見博文 https://blog.csdn.net/wenhao_ir/article/details/125412774 的“01-附2”
函數dir()的詳情請參見博文 https://blog.csdn.net/wenhao_ir/article/details/125421060
示例代碼如下：
result_1 = divmod(5, 2)
運行結果如下：
關於函數enumerate()的詳細介紹，請參見我的另一篇博文：https://blog.csdn.net/wenhao_ir/article/details/125443427
詳見對函數compile()的介紹，具體來說是這篇博文中的第11個。
filter() 函數用於過濾序列，過濾掉不符合條件的元素，返回一個迭代器對象，如果要轉換為列錶，可以使用 list() 來轉換。
該接收兩個參數，第一個為函數，第二個為序列，序列的每個元素作為參數傳遞給函數進行判斷，然後返回 True 或 False，最後將返回 True 的元素放到新列錶中。
示例代碼如下：
def is_odd(n):
return n % 2 == 1
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)
運行結果如下：
這個函數與列錶(list)的方法sort()的第一個參數key的使用挺類似的，詳情見博文https://blog.csdn.net/wenhao_ir/article/details/125406092
什麼?字符串也可以轉換成浮點數，是的，你沒看錯，看下面的示例你就知道了。
int1 = 112
str1 = '123'
float_1 = float(int1)
float_2 = float(str1)
運行結果如下：
從上面的運行結果我們可以看出，字符串’123’被轉換成了浮點數123.0，這就是Python的靈活之處，同樣的功能，在C++中則需要使用類stringstream來實現，詳情見我的另一篇博文 https://blog.csdn.net/wenhao_ir/article/details/124508457
關於函數format()，我已在博文https://blog.csdn.net/wenhao_ir/article/details/125390532中詳細介紹過，這裏就不再重複介紹了。
函數frozenset()用於由原可迭代對象返回一個被凍結的可迭代對象，處於凍結狀態的可迭代對象不能添加或刪除任何元素。
示例代碼如下：
list1 = ['Google', 'CSDN', 'tencent', 1997, 1999, 1998]
list2 = frozenset(list1)
list2[0] = 'facebook'
運行結果如下：
示例代碼如下：
class A(object):
bar = 1
a1 = A()
b1 = getattr(a1, 'bar')
運行結果如下：
如果您想設置對象的屬性值，可以用函數setattr()來設置哦！函數setattr()見本篇博文第56個函數
globals() 函數會以字典類型返回當前比特置的全部全局變量。
示例代碼如下：
str1 = 'suwenhao'
int1 = 1990
list1 = [1, 2, 3]
global_variable = globals()
運行結果如下：
函數hasattr()的示例代碼如下：
class Coordinate:
x = 10
y = -5
z = 0
point1 = Coordinate()
bool1 = hasattr(point1, 'x')
bool2 = hasattr(point1, 'y')
bool3 = hasattr(point1, 'z')
bool4 = hasattr(point1, 'no') # 沒有該屬性
運行結果如下：
示例代碼如下：
hash1 = hash('swh')
hash2 = hash(2487872782)
將上面的代碼運行兩次，結果分別如下：
第一次的運行結果：
第二次運行的結果：
從上面兩次的運行結果我們可以看出，一個字符串的hash值並不是唯一的，整數的hash值還是其本身。
示例代碼如下：
help('sys') # 查看sys模塊的幫助
help('str') # 查看str類的幫助
a = [1, 2, 3]
help(a) # 查看列錶list的幫助
help(a.append) # 查看list的append方法的幫助
下面兩行代碼
a = [1, 2, 3]
help(a.append) # 查看list的append方法的幫助
的運行結果如下：
示例代碼如下：
hex1 = hex(10)
運行結果如下：
注意：函數hex()返回的是一個字符串對象。
示例代碼如下：
str1 = 'CSDN'
id1 = id(str1)
運行結果如下：
示例代碼如下：
str1 = input("input:")
運行結果如下：
第一次運行(輸入字符串)：
第二次運行(輸入數字)
從第二次的運行結果我們可以看出，輸入的數字也被當成字符串處理了。不過不要緊，我們可以用函數float()或函數int()將字符串型數字轉化為float型和int型嘛。
語法如下：
int(x, base=10)
參數意義：
x – 字符串或數字。
base – 代錶x為哪種進制的數，注意不是錶示返回傎的進制
示例代碼如下：
int1 = int(3.6)
int2 = int('20')
int3 = int('12', 16) #16進制的12換算成10進制是18
int4 = int('0xa', 16)
運行結果如下：
從上面的運行結果可以看出，函數int()在將浮點數轉換為整數時，對於小數部分是直接捨棄處理的，而不是四捨五入。
示例代碼如下：
a = 2
bool1 = isinstance(a, int)
bool2 = isinstance(a, str)
bool3 = isinstance(a, (str, int, list)) # 只要是元組中的一個就返回True
運行結果如下：
語法如下：
issubclass(class1, class2)
如果 class1 是 class2 的子類返回 True，否則返回 False。
示例代碼如下：
class A:
pass
class B(A):
pass
class C:
pass
bool1 = issubclass(B, A)
bool2 = issubclass(B, C)
運行結果如下：
這個函數用於生成可迭代對象的迭代器對象。以list對象為例，如果我們想通過迭代器遍曆它，怎麼操作呢？方法之一就是先生成其迭代器對象，然後用內置函數next()進行遍曆操作。
內置函數next()的語法如下：
next(iterable[, default])
iterable – 可迭代對象
default – 可選，用於設置在沒有下一個元素時返回該默認值，如果不設置，又沒有下一個元素則會觸發 StopIteration 異常。
再看函數iter()的語法：
iter(object[, sentinel])
根據是否存在第二個實參，第一個實參的解釋是非常不同的。
如果沒有第二個實參，object 必須是支持迭代協議（有 __iter__() 方法）的集合對象（比如列錶、元組、集合都是有 __iter__() 方法的，博文https://blog.csdn.net/wenhao_ir/article/details/125421060的第一個示例代碼的運行結果便證明了這一點），或必須支持序列協議（有 __getitem__() 方法，且數字參數從 0 開始）。如果它不支持這些協議，會觸發 TypeError。
如果有第二個實參 sentinel，那麼 object 必須是可調用的對象。這種情況下生成的迭代器，每次迭代調用它的 __next__() 方法時都會不帶實參地調用 object；如果返回的結果是 sentinel 則觸發 StopIteration，從而停止迭代，否則返回調用結果.。
適合 iter() 的第二種形式的應用之一是構建塊讀取器。 例如，從二進制數據庫文件中讀取固定寬度的塊，直至到達文件的末尾，這種情況下的示例如下：
from functools import partial
with open('mydata.db', 'rb') as f:
for block in iter(partial(f.read, 64), 'b'):
process_block(block)
上面的函數partial()會被不帶參數的迭代下去，直到其返回值為’b’才停止迭代。
再回頭來說第一種情況，使用函數iter()和函數next()對列錶進行迭代的示例代碼如下：
x = iter(["apple", "banana", "cherry"])
print(next(x))
print(next(x))
print(next(x))
運行結果如下：
這個在前面關於字符串、列錶、元組、字典、集合的介紹時已經介紹過了，詳情見下面的鏈接：
https://blog.csdn.net/wenhao_ir/article/details/125396412(這篇博文中的第14-3點中用到了len()測量字符串長度)
https://blog.csdn.net/wenhao_ir/article/details/125400072
https://blog.csdn.net/wenhao_ir/article/details/125407815
https://blog.csdn.net/wenhao_ir/article/details/125412774
https://blog.csdn.net/wenhao_ir/article/details/125424671
所以這裏就不再舉例了。
示例代碼如下：
tup1 = ('Google', 'Taobao', 'CSDN', 555)
list1 = list(tup1)
str1 = "Hello World"
list2 = list(str1)
運行結果如下：
相關函數：
62-函數tuple():把可迭代對象轉換為元組
locals() 函數會以字典類型返回當前比特置的全部局部變量。
示例代碼如下：
def fun1(arg): # 兩個局部變量：arg、z
z = 1
print(locals())
fun1(6)
運行結果如下：
map() 函數會根據提供的函數對指定序列做映射。它的第一個參數和list的方法sort()、filter()函數的第一個參數使用類似。
sort()方法的詳細介紹見博文 https://blog.csdn.net/wenhao_ir/article/details/125406092
filter()函數上面已經介紹過了。
示例代碼一如下：
def square(x): # 計算平方數
return x ** 2
iter1 = map(square, [1, 2, 3, 4, 5])
list1 = list(iter1)
運行結果如下：
示例代碼二如下(匿名函數)：
iter1 = map(lambda x: x ** 3, [1, 2, 3, 4, 5])
list1 = list(iter1)
運行結果如下：
這個函數在之前對字符串、列錶、元組的介紹中均有提及，在字符串中它是作為字符類的方法出現的，不過它也可作用於字符串對象。
下面給一個綜合性的示例代碼。
str1 = 'abcdef'
max_str1 = max(str1)
list1 = [10, 11, 12, 13]
max_list1 = max(list1)
tup1 = (20, 21, 22, 25)
max_tupl1 = max(tup1)
set1 = {
50, 51, 52, 53}
max_set1 = max(set1)
運行結果如下：
所謂內存查看對象，是指對支持緩沖區協議的數據進行包裝，然後可以按字節進行查看。
示例代碼如下：
v = memoryview(bytearray("abcefg", 'utf-8'))
v_01 = v[1]
v_02 = v[2]
運行結果如下：
個人感覺在Pycharm-IDE中這個作用不是很大，因為我在IDE中可以很方便的查看對象的內存情況。
函數min()與第40個max()的使用一模一樣，只是它返回的是最小值，所以這裏就不再介紹，也不給示例代碼了。
函數next()在介紹35-函數iter()時已經介紹過了，這裏就不再介紹了。
object() 函數返回一個空對象。
您不能向這個對象添加新的屬性或方法，這個函數不接受任何實參。
這個對象是所有類的基礎，它擁有所有類默認的內置屬性和方法。
示例代碼如下：
x = object()
運行結果如下：
函數oct()將一個整數轉換成 8 進制字符串，8 進制以 0o 作為前綴錶示。
示例代碼如下：
str1 = oct(10)
運行果如下：
open()函數用於打開一個文件，並返回文件對象，在對文件進行處理過程都需要使用到這個函數，如果該文件無法被打開，會拋出 OSError。
注意：文件對象使用完後，一定要調用close()函數關閉文件。
open()函數常用的形式是接收兩個參數：文件名(file)和模式(mode)。
open(file, mode='r')
完整的語法格式如下：
pen(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
file—文件的路徑或名稱。
mode—文件打開模式，其具體內容如下：
補充說明：
mode 是一個可選字符串，用於指定打開文件的模式。
默認值是 ‘r’ ，與 ‘rt’ 同義，這意味著它以文本模式打開並讀取文件。
其他常見模式有：寫入 ‘w’ 、排它性創建 ‘x’ 、追加寫 ‘a’（在 一些 Unix 系統上，無論當前的文件指針在什麼比特置，所有 寫入都會追加到文件末尾）。
接下來繼續介紹函數open()的其它參數。
在文本模式，如果 encoding 沒有指定，則根據平臺來決定使用的編碼：使用 locale.getpreferredencoding(False) 來獲取本地編碼。
要讀取和寫入原始字節，請使用二進制模式並不要指定 encoding。
以二進制模式打開的文件（包括 mode 參數中的 ‘b’ ）返回的內容為 bytes 對象，不進行任何解碼。在文本模式下（默認情況下，或者在 mode 參數中包含 ‘t’ ）時，文件內容返回為 str ，首先使用指定的 encoding （如果給定）或者使用平臺默認的的字節編碼解碼。
模式 ‘w+’ 與 ‘w+b’ 將打開文件並清空內容。
模式 ‘r+’ 與 ‘r+b’ 將打開文件並不清空內容。
buffering—這個參數用於設置緩沖。
encoding— encoding 是用於解碼或編碼文件的編碼的名稱，一般使用utf8。這應該只在文本模式下使用。默認編碼是依賴於平臺的（而不管 locale.getpreferredencoding() 返回何值），但可以使用任何Python支持的 text encoding 。有關支持的編碼列錶，請參閱Pythoncodecs 模塊。
errors–是一個可選的字符串參數，用於指定如何處理編碼和解碼錯誤 - 這不能在二進制模式下使用。可以使用各種標准錯誤處理程序（列在 錯誤處理方案 ），但是使用 codecs.register_error() 注冊的任何錯誤處理名稱也是有效的。標准名稱包括:
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—如果 closefd 是 False 並且給出了文件描述符而不是文件名，那麼當文件關閉時，底層文件描述符將保持打開狀態。如果給出文件名則 closefd 必須為 True （默認值），否則將引發錯誤。
opener—可以通過傳遞可調用的 opener 來使用自定義開啟器。然後通過使用參數（ file，flags ）調用 opener 獲得文件對象的基礎文件描述符。 opener 必須返回一個打開的文件描述符（使用 os.open as opener 時與傳遞 None 的效果相同）。
ord() 函數是chr() 函數對於 8 比特的 ASCII 字符串）的配對函數[函數chr()見本文的第10個]，它以一個字符串（Unicode 字符）作為參數，返回對應的 ASCII 數值，或者 Unicode 數值。
示例代碼如下：
int1 = ord('a')
char1 = chr(int1)
運行結果如下：
語法如下：
pow(x, y[, z])
計算x的y次方，如果z在存在，則再對結果進行取模，其結果等效於pow(x,y) %z
示例代碼如下：
int1 = pow(2, 3)
int2 = pow(2, 3, 6)
運行結果如下：
函數print()的詳細介紹見我的另一篇博文：https://blog.csdn.net/wenhao_ir/article/details/125390532
函數property()通常用於獲取、設置、刪除類的某個屬性。
函數property()的語法如下：
class property([fget[, fset[, fdel[, doc]]]])
參數：
fget – -獲取屬性值的函數(函數的功能並不一定是真正的去獲取屬性值，看了示例代碼就容易理解這一點)
fset —設置屬性值的函數(函數的功能並不一定是真正的去設置屬性值，看了示例代碼就容易理解這一點)
fdel — 刪除屬性值函數(函數的功能並不一定是真正的去刪除屬性，看了示例代碼就容易理解這一點)
doc — 屬性描述信息。
示例代碼如下：
class C(object):
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 將調用getx(),
c.x = value 將調用setx()
del c.x 將調用delx()
如果給定 doc 參數，其將成為這個屬性值的 docstring，否則 property 函數就會複制 fget 函數的 docstring（如果有的話）。
繼續完善示例代碼如下：
# 博主微信/QQ 2487872782
# 有問題可以聯系博主交流
class C(object):
def __init__(self):
self._x = 100
self._y = 200
def getx(self):
print('called getx and x={}'.format(self._x))
def setx(self, value):
self._x = value
print('called setx and x={}'.format(self._x))
def delx(self):
del self._x
print('called delx')
def gety(self):
print('called gety and y={}'.format(self._y))
def sety(self, value):
self._y = value
print('called sety and y={}'.format(self._y))
def dely(self):
del self._y
print('called dely')
x = property(getx, setx, delx, "I'm the 'x' property.")
y = property(gety, sety, dely, "I'm the 'y' property.")
c = C()
c.x
c.x = 12
del c.x
c.y
help(c)
運行結果如下：
上面的代碼中我定義了兩個與函數property()有關的屬性名，分別為x和y，並且我還為x和y設置了三個函數，以x為例，這三個函數分別通過
c.x
c.x = 12
del c.x
來調用。
注意：
Python3 range() 函數返回的是一個可迭代對象，而不是列錶對象，可以用函數list()將其轉化為列錶。
Python2 range() 函數返回的則是列錶。
語法如下(有兩種形式)：
range(stop)
range(start, stop[, step])
start—計數從 start 開始。默認是從 0 開始。例如range（5）等價於range（0， 5）;
stop:—計數到 stop 結束，但不包括 stop。例如：range（0， 5是[0, 1, 2, 3, 4]，注意沒有包括5。
step—步長，默認為1。例如：range（0， 5） 等價於 range(0, 5, 1)
示例代碼如下：
rang1 = range(5)
list1 = list(rang1)
for i in range(1, 4, 1):
print(i)
運行結果如下：
示例代碼如下：
dict1 = {
'name': 'suwenhao', 'likes': 'reading', 123: 456}
str1 = repr(dict1)
print(str1)
list1 = ['Google', 'CSDN', 1997, 1999]
str2 = repr(list1)
print(str2)
運行結果如下：
示例代碼如下：
內置函數str()和這個函數的功能差不多，函數str()的介紹見本博文第59點。
示例代碼如下：
str1 = 'abcdefg'
str1_reverse = reversed(str1)
str1_reverse_list = list(str1_reverse)
list1 = [1, 2, 3, 4, 5]
list1_reverse = reversed(list1)
list1_reverse_list = list(list1_reverse)
tup1 = ('A', 'B', 'C', 'D')
tup1_reverse = reversed(tup1)
tup1_reverse_list = list(tup1_reverse)
運行結果如下圖所示：
語法如下：
round( x [, n] )
參數意義：
x — 待處理的浮點數。
n — 錶示需保留的小數比特數，默認值為0，即不保留小數部分。
注意：它做的是五捨六入的近似運算，而不是四捨五入，大家看下面的示例代碼就知道了。
示例代碼如下：
print("round(70.3) : ", round(70.3))
print("round(70.4) : ", round(70.4))
print("round(70.5) : ", round(70.5))
print("round(70.6) : ", round(70.6))
print("round(70.7) : ", round(70.7))
print("round(80.23, 1) : ", round(80.23, 1))
print("round(80.24, 1) : ", round(80.24, 1))
print("round(80.25, 1) : ", round(80.25, 1))
print("round(80.26, 1) : ", round(80.26, 1))
print("round(80.27, 1) : ", round(80.27, 1))
運行結果如下：
函數set()在博文 https://blog.csdn.net/wenhao_ir/article/details/125424671 中已經介紹過了，這裏就不再重複介紹了。
函數setattr()對應函數getattr()，用於設置屬性值，該屬性不一定是存在的哦。
語法如下：
setattr(object, name, value)
參數意義如下：
object – 對象。
name – 字符串，對象屬性。
value – 屬性值
示例代碼如下：
class A(object):
bar = 1
a = A()
bar1 = getattr(a, 'bar') # 獲取屬性bar的值
setattr(a, 'bar', 5) # 設置對象a的屬性bar的值
bar2 = getattr(a, 'bar') # 再次獲取屬性bar的值
運行結果如下：
slice() 函數實現切片對象，主要用在切片操作函數裏的參數傳遞。
語法如下：
有兩種形式：
slice(stop)
slice(start, stop[, step])
參數意義：
start – 起始索引值
stop – 結束索引值
step – 索引間距
示例代碼如下：
list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
slice1 = slice(5)
list_sub1 = list1[slice1]
slice2 = slice(1, 8, 2)
list_sub2 = list1[slice2]
運行結果如下：
這裏分析下list_sub2是怎麼得到的？
索引區間為[1, 8) 注意是左閉右開區間。
索引步長為2，則有效索引值為1、1+2=3、3+2=5、5+2=7
索引值1、3、5、7對應的元素值分別為：10、40、60、80
所以list_sub2為[20, 40, 60, 80]
當然，我們一般都不用這個切片對象，而直接寫出切片錶達式，
即我們通常把語句：
slice2 = slice(1, 8, 2)
list_sub2 = list1[slice2]
寫成：
list_sub2 = list1[1:8:2]
函數sorted()的用法和列錶中的方法sort()的使用方法和功能是基本一樣的。
不同之處在於函數sorted()可以對所有的可迭代對象元素進行排序，並且它會返回一個新的列錶。而列錶中的方法sort()它只能針對列錶，並且對原列錶對象進行操作。
所以這裏就不再對函數sorted()進行介紹了，大家可參考我的另一篇博文https://blog.csdn.net/wenhao_ir/article/details/125400072中第16點對方法sort()的介紹。
內置函數repr()和這個函數的功能差不多，函數repr()的介紹見本博文第52點。
示例代碼如下：
dict1 = {
'name': 'suwenhao', 'likes': 'reading', 123: 456}
str1 = str(dict1)
print(str1)
list1 = ['Google', 'CSDN', 1997, 1999]
str2 = str(list1)
print(str2)
運行結果如下：
內置函數repr()和這個函數的功能差不多，函數repr()的介紹見本博文第52點。
語法如下：
sum(iterable, start)
參數意義如下：
iterable—必需。需求和的可迭代對象(序列)。
start—可選。添加到返回值的值。
示例代碼如下：
resutl1 = sum([0, 1, 2])
result2 = sum((2, 3, 4), 1) # 元組對象計算總和後再加1
result3 = sum([0, 1, 2, 3, 4], 2) # 列錶計算總和後再加2
運行結果如下：
關於這個函數的詳細介紹，可以查看我的另一篇博文：https://blog.csdn.net/wenhao_ir/article/details/125472478
示例代碼如下：
list1 = ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple1 = tuple(list1)
運行結果如下：
相關函數：
37-函數list():用於將元組或字符串轉換為列錶
函數type()有兩種語法：
type(object)
type(name, bases, dict)
第一種語法返回對象的類型，第二種語法返回新的類型對象。
第一種語法是常用的，第二種語法很少用，所以下面的示例代碼只給第一種語法的示例代碼：
type1 = type(1)
type2 = type([1, 2, 'swh'])
type3 = type({
0: 'zero'})
x = 1
bool1 = type(x) == int # 判斷類型是否為int型
運行結果如下：
從上面的運行結果可以看出，函數type()返回的並不是字符串，而是type對象，type對象屬於“Special Variables”。
並通，還可以用關系運算符“==”對類型進行判斷哦。
示例代碼如下：
class Person:
name = "Bill"
age = 19
country = "USA"
x1 = dir(Person) # 返回類的所有屬性
x2 = vars(Person) # 返回類的__dic__屬性
運行結果如下：
資料上都說是返回對象的__dic__ 屬性，但是我實測卻返回不了，如下：
class Person:
name = "Bill"
age = 19
country = "USA"
object1 = Person()
x1 = vars(object1)
運行結果如下：
可能那些資料中的對象也把類認為是對象吧~在我的腦海裏，認為類的實例化才叫對象。
zip() 函數用於將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然後返回由這些元組組成的對象，這樣做的好處是節約了不少的內存。
我們可以使用 list() 轉換來輸出列錶。
如果各個迭代器的元素個數不一致，則返回列錶長度與最短的對象相同，利用 * 號操作符，可以將元組解壓為列錶。
示例代碼如下：
a = [1, 2, 3]
b = [4, 5, 6]
c = [11, 12, 13, 14, 15]
zip1 = zip(a, b)
list1 = list(zip1)
zip2 = zip(a, c)
list2 = list(zip2)
運行結果如下：
利用 * 號操作符，可以將元組解壓為列錶，示例代碼如下：
tup1 = ((1, 4), (2, 5), (3, 6))
a1, b1 = zip(*tup1)
運行結果如下：
雖然關鍵詞import可以實現同樣的功能，但是通常我們在程序的開頭使用關鍵詞import進入導入操作，如果我們想在程序中部，可以使用內置函數__import__()，這樣會使程序看來順眼。
其語法如下：
__import__(name[, globals[, locals[, fromlist[, level]]]])
可選參數意義暫時不作探究。
示例代碼如下：
my_script.py中的代碼如下：
print('Successfully imported my_ script!')
print('my_script execution completed!')
001-32-內置函數.py中的代碼如下：
list1 = [1, 2, 3]
__import__('my_script')
list2 = [7, 8, 9]
運行結果如下：
參考資料：https://blog.csdn.net/wenhao_ir/article/details/125100220
