Python 常用內置函數如下：
1. abs()函數返回數字的絕對值。
print( abs(-45) ) # 返回 45
print("abs(0.2):",abs(0.2)) # 返回 abs(0.2): 0.2
2. all() 函數用於判斷給定的參數中的所有元素是否都為 TRUE，如果是返回 True，否則返回 False。元素除了是 0、空、None、False 外都算 True；空元組、空列表返回值為True。
print( all( [0.1,1,-1] ) ) # 返回 True print( all( (None,1) ) ) # 返回 False（其中一個元素為None） print( all( [0,1,-1] ) ) # 返回 False（其中一個元素為0） print( all( [" ","a",""] ) ) # 返回 False(第三個元素為空)
3. any() 函數用於判斷給定的參數是否全部為False，是則返回False，如果有一個為True，則返回True。 元素除了是 0、空、False外都算 TRUE。
# 參數全部不為 0、空、FALSE print(any("-45")) # True print(any(["-45"])) # True print( any( ("0","ab","") ) ) # True（注意：第一個參數0加了雙引號，表示為一個字符串） # 參數全部為 0、空、False print( any( (0,"") ) ) # False print( any( (0,"",False) ) ) # False
4. bin()函數返回一個整數int或者長整數long int的二進制表示。
print( bin(10) ) # 0b1010
print( bin(133) ) # 0b10000101
5. bool() 函數用於將給定參數轉換為布爾類型，如果參數不為空或不為0，返回True；參數為0或沒有參數，返回False。
print( bool(10) ) # True print( bool([0]) ) # True print( bool(["123","s",0]) ) # True print( bool(0) ) # False print( bool() ) # False
6. bytearray()方法返回一個新字節數組。這個數組里的元素是可變的，並且每個元素的值范圍: 0 <= x < 256（即0-255）。即bytearray()是可修改的二進制字節格式。
1 b = bytearray("abcd",encoding="utf-8") 2 print(b[0]) # 返回數字97，即把“abcd”的“a"對應的ascii碼打印出來了 3 b[0] = 99 # 把字符串第一個字節修改為99（即對應字母為“c”） 4 print(b) # 返回：bytearray(b'cbcd')---第一個字節a已被修改為c
7. callable()函數用於檢查一個對象是否可調用的。對於函數、方法、lambda函式、類以及實現了 __call__ 方法的類實例, 它都返回 True。（可以加括號的都可以調用）
1 def sayhi():pass # 先定義一個函數sayhi() 2 print( callable( sayhi ) ) # True
1 a = 1 2 print( callable( a ) ) # False
8. chr()函數用一個范圍在range(256)內（即0～255）的整數作參數，返回一個對應的ASCII數值。
# 把數字98在ascii碼中對應的字符打印出來 print( chr(98) ) # 返回：b
9. dict()函數用來將元組/列表轉換為字典格式。
print(dict(a='a', b='b', t='t')) # 返回：{'b': 'b', 'a': 'a', 't': 't'} print(dict( [ ('one',1),('two',2),('three',3) ] ) ) # 可迭代對象方式來構造字典 # 返回：{'two': 2, 'one': 1, 'three': 3} print(dict(zip(["1","2","3"],["a","b","c"]))) # 映射函數方式來構造字典 # 返回：{'2': 'b', '3': 'c', '1': 'a'}
10. dir()函數不帶參數時，返回當前范圍內的變量、方法和定義的類型列表；帶參數時，返回參數的屬性、方法列表。
print( dir() ) # 獲得當前模塊的屬性列表 # 返回：['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
print( dir([]) ) # 查看列表的方法 # 返回：['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__',
'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__',
'__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse',
'sort']
11. divmod() 函數把除數和余數運算結果結合起來，返回一個包含商和余數的元組（商x，余數y）。
print( divmod(5,2) ) # 返回：(2, 1) print( divmod(5,1) ) # 返回：(5, 0) print( divmod(5,3) ) # 返回：(1, 2)
12. enumerate() 函數用於將一個可遍歷的數據對象(如列表、元組或字符串)組合為一個索引序列，同時列出數據和數據下標，一般用在 for 循環當中。Python 2.3. 以上版本可用，2.6 添加 start 參數。
1 seasons = ['Spring', 'Summer', 'Fall', 'Winter'] 2 print(list(enumerate(seasons)))
# 返回：[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
1 print(list(enumerate(seasons, start=1)) ) # 下標從 1 開始
# 返回：[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
13. eval() 函數用來執行一個字符串表達式，並返回表達式的值。
print(eval('3 * 2')) # 6
1 x = 7 2 print(eval('3 + x')) # 10
14. exec() 執行儲存在字符串或文件中的Python語句，相比於eval，exec可以執行更復雜的Python代碼。
exec("print('Hello World')") # 執行簡單的字符串 # Hello World
exec("for i in range(5): print('iter time is %d'%i)") # 執行復雜的for循環 # iter time is 0 # iter time is 1 # iter time is 2 # iter time is 3 # iter time is 4
15. filter()用於過濾序列，過濾掉不符合條件的元素，返回一個迭代器對象，可用list()來轉換為列表。
注意： filter()接收兩個參數，第一個為函數，第二個為序列，序列的每個元素作為參數傳遞給函數進行判斷，然后返回True或 False，最后將返回 True 的元素放到新列表中。
res = filter(lambda n:n>5,range(10)) # 過濾掉0-9中不符合n>5的數據 for i in res: # 循環打印符合n>5的數據 print(i) # 5 # 6 # 7 # 8 # 9
16. format()是一種格式化字符串的函數 ，基本語法是通過 {} 和 : 來代替以前的 % 。format 函數可以接受不限個參數，位置可以不按順序。
# 位置映射 print( "{}{}".format('a','1') ) # a1 print('name:{n},url:{u}'.format(n='alex',u='www.xxxxx.com')) # name:alex,url:www.xxxxx.com
# 元素訪問 print( "{0[0]},{0[1]}".format(('baidu','com')) ) # 按順序 # baidu,com print( "{0[2]},{0[0]},{0[1]}".format(('baidu','com','www')) ) # 不按順序 # www,baidu,com
17. float() 函數用於將整數和字符串轉換成浮點數。
print(float(1)) # 1.0 print(float(0.1)) # 0.1 print(float('123')) # 123.0
18. frozenset() 返回一個凍結的集合（一個無序的不重復元素序列），凍結后集合不能再添加或刪除任何元素。
1 a = frozenset(range(10)) # 先創建一個凍結集合 2 print(a) 3 # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) 4 5 del a[0] # 試圖刪除凍結集合a中的元素，報錯 6 # TypeError: 'frozenset' object doesn't support item deletion
1 b = frozenset("happy") # 將字符串轉換成一個集合 2 print(b) 3 # frozenset({'a', 'h', 'p', 'y'}) # 無序不重復
1 c = frozenset() # 創建一個空集合 2 print(c) 3 # frozenset() # 如果不提供任何參數，默認會生成空集合
19. globals() 函數會以字典格式返回當前位置的全部全局變量。
print(globals()) # globals 函數返回一個全局變量的字典，包括所有導入的變量。 # {'__file__': 'C:/Users/Administrator/PycharmProjects/test/day4/內置函數-globals().py', '__spec__': None, '__doc__': None, '__package__': None,
'a': 'append', '__cached__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000000666B00>,
'__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__'}
20. hasattr() 函數用於判斷對象是否包含對應的屬性。如果對象有該屬性返回 True，否則返回 False。
1 class t: 2 a = 1 3 b = 2 4 c = 3 5 6 p = t() 7 print(hasattr(p,'a')) # True 8 print(hasattr(p,'b')) # True 9 print(hasattr(p,'x')) # False
21. hash() 用於獲取一個對象（數字或者字符串等）的哈希值。不能直接應用於 list、set、dictionary。
注意：在 hash() 對對象使用時，所得的結果不僅和對象的內容有關，還和對象的 id()，也就是內存地址有關。
print(hash(1)) # 1 print(hash(20000)) # 20000 print(hash('123')) # -6436280630278763230 print(hash('ab12')) # 5468785079765213470 print(hash('ab12')) # 5468785079765213470
22. help() 函數用於查看函數或模塊用途的詳細說明。
help('sys') # 查看 sys 模塊的幫助 help('str') # 查看 str 數據類型的幫助
a = [1,2,3] help(a) # 查看列表 list 幫助信息 help(a.append) # 顯示list的append方法的幫助
23. hex() 函數用於將一個整數轉換為十六進制數。返回一個字符串，以0x開頭。
print(hex(1)) # 0x1 print(hex(-256)) # -0x100 print(type(hex(-256))) #<class 'str'>
24. id()函數用於獲取對象的內存地址。
a = "123" # 字符串 print(id(a)) # 13870392 b = [1,2,3] # 列表 print(id(b)) # 7184328 c = {'num1':1,'num2':2,'num3':3} # 字典 print(id(c)) # 6923656
25. input() 函數接受一個標准輸入數據，返回為 string 類型。這個函數是最最常用的了。在Python3.x中 raw_input() 和 input() 進行了整合，僅保留了input( )函數。
a = '123456' b = input("username:") if b == a : # 如果b的輸入數據等於a存儲的數據，打印”right“ print("right") else: # 否則打印”wrong“ print("wrong")
26. int() 函數用於將一個字符串或數字轉換為整型。
print(int()) # 不傳入參數時，得到結果0 print(int(0.5)) # 去掉小數部分，得到結果0 print(int(3)) # 得到結果3 print(int('0xa',16)) # 十六進制數“0xa”轉換成十進制整數，得到結果10 print(int('00010',2)) # 二進制數“00010”轉換成十進制整數，得到結果2
27. isinstance() 函數來判斷一個對象是否是一個已知的類型，返回布爾值。類似 type()。
a = 2 print(isinstance(a,int)) # True print(isinstance(a,str)) # False print(isinstance(a,(str,tuple,dict))) # False print(isinstance(a,(str,tuple,int))) # 是元組其中的一個則返回True
-
isinstance() 與 type() 區別：
type() 不會認為子類是一種父類類型，不考慮繼承關系。
isinstance() 會認為子類是一種父類類型，考慮繼承關系。
如果要判斷兩個類型是否相同推薦使用 isinstance()。
示例：
1 class A: 2 pass 3 4 class B(A): 5 pass 6 7 print(isinstance(A(),A)) # True 8 print( type(A()) == A ) # True 9 10 print(isinstance(B(),A)) # True 11 print( type(B()) == A ) # False --type()不考慮繼承關系
28. issubclass()用於判斷參數class是否是類型參數classinfo的子類，是則返回True，否則返回False。
語法：issubclass(class,classinfo)。
1 class a: 2 pass 3 class b(a): # b繼承了a，即b是a的子類 4 pass 5 6 print(issubclass(a,b)) # 判斷 a 是 b 的子類？ 7 # False 8 print(issubclass(b,a)) # 判斷 b 是 a 的子類？ 9 # True
29. iter() 函數用來生成迭代器。list、tuple等都是可迭代對象，我們可以通過iter()函數獲取這些可迭代對象的迭代器，然后可以對獲取到的迭代器不斷用next()函數來獲取下條數據。iter()函數實際上就是調了可迭代對象的 __iter__ 方法。
# 注意：當已經迭代完最后一個數據之后，再次調用next()函數會拋出 StopIteration的異常，來告訴我們所有數據都已迭代完成。
1 it = [1,2,3] 2 it_list = iter(it) 3 4 print(next(it_list)) 5 # 1 6 print(next(it_list)) 7 # 2 8 print(next(it_list)) 9 # 3 10 print(next(it_list)) 11 # StopIteration
30. len() 方法返回對象（字符、列表、元組等）長度或元素個數。
# len()方法返回對象（字符、列表、元組等）長度或元素個數。 print(len('1234')) # 字符串，返回字符長度4 print(len(['1234','asd',1])) # 列表，返回元素個數3 print(len((1,2,3,4,50))) # 元組，返回元素個數5 print(len(12)) # 注意：整數類型不適用，否則報錯 # TypeError: object of type 'int' has no len()
31. list() 方法用於將元組轉換為列表。
注：元組與列表是非常類似的，區別在於元組的元素值不能修改，元組是放在括號中，列表是放於方括號中。
print( list((1,2,3))) # [1, 2, 3]
32. map()接收函數f和list，並通過把函數f依次作用在list的每個元素上，得到一個新的list並返回。
1 res = map(lambda n: n*2,[0,1,2,3,4,5]) # 使用 lambda 匿名函數 2 for i in res: 3 print(i) 4 5 # 返回以下數據： 6 # 0 7 # 2 8 # 4 9 # 6 10 # 8 11 # 10
1 # 提供了兩個列表，對相同位置的列表數據進行相加 2 3 a = map(lambda x,y : x+y,[1,2,3,4,5],[2,4,6,8,10]) 4 for i in a: 5 print(i) 6 7 # 返回以下數據： 8 # 3 9 # 6 10 # 9 11 # 12 12 # 15
33. max()函數返回給定參數的最大值，參數可以為序列。
print("max(10,20,30):" , max(10,20,30) ) # max(10,20,30): 30 print("max(10,-2,3.4):" , max(10,-2,3.4) ) # max(10,-2,3.4): 10 print("max({'b':2,'a':1,'c':0}):" , max({'b':2,'a':1,'c':0}) ) # 字典，默認按key排序 # max({'b':2,'a':1,'c':0}): c
34. min()函數返回給定參數的最小值，參數可以為序列。
print("min(10,20,30):" , min(10,20,30) ) # min(10,20,30): 10 print("min(10,-2,3.4):" , min(10,-2,3.4) ) # min(10,-2,3.4): -2 print("min({'b':2,'a':1,'c':0}):" , min({'b':2,'a':1,'c':0}) ) # 字典，默認按key排序 # min({'b':2,'a':1,'c':0}): a
35. next() 返回迭代器的下一個項目。
1 # 首先獲得Iterator對象: 2 it = iter([1,2,3,4,5]) 3 4 # 循環: 5 while True: 6 try: 7 # 獲得下一個值: 8 x = next(it) 9 print(x) 10 except StopIteration: 11 break 12 # 遇到StopIteration就退出循環
36. oct() 函數將一個整數轉換成八進制字符串。
print( oct(10) ) # 0o12 print( oct(255) ) # 0o377 print( oct(-6655) ) # -0o14777
37. open() 函數用於打開一個文件，創建一個 file 對象，相關的方法才可以調用它進行讀寫。
f = open("test1.txt","w",encoding="utf-8") # 創建一個file print(f.write("abc")) f = open("test1.txt","r",encoding="utf-8") # 讀取文件數據 print(f.read())
38. ord()函數是chr()的配對函數，它以一個字符（長度為1的字符串）作為參數，返回對應的ASCII數值，或者Unicode數值，如果所給的 Unicode 字符超出了定義范圍，則會引發一個 TypeError 的異常。
# 把字符 b（長度為1的字符串）作為參數在ascii碼中對應的字符打印出來 print( ord('b') ) # 返回：98 print( ord('%') ) # 返回：37
39. pow()函數返回x的y次方的值。
注意：pow()通過內置的方法直接調用，內置方法會把參數作為整型，而 math 模塊則會把參數轉換為 float。
# 通過內置的方法直接調用 print( pow(2,2) ) # 2的二次方 # 4 print( pow(2,-2) ) # 2的負二次方 # 0.5
1 # 導入math模塊 2 3 import math 4 5 print(math.pow(3,2)) # 3的負二次方 6 # 9.0
40. print()用於打印輸出，最常見的一個函數。print 在Python3.x是一個函數，但在Python2.x版本只是一個關鍵字。
print( abs(-45) ) # 45 print("Hello World!") # Hello World! print([1,2,3]) # [1, 2, 3]
41. range() 函數可創建一個整數列表，一般用在 for 循環中。語法：range(start, stop[, step])
for i in range(10): print(i) # 依次打印數字0-9 for a in range(0,10,2): # 步長為2 print(a) # 打印0,2,4,6,8 for b in range(10, 0, -2): # 步長為-2 print(b) # 打印10,8,6,4,2
42. reduce() 函數會對參數序列中元素進行累積。在Python3 ，reduce()被放置在functools模塊里，如果想要使用它，需要先引入functools模塊。
import functools a = functools.reduce(lambda x,y:x+y,[1,2,3]) print(a) # 6 ， 即從1加到3 b = functools.reduce(lambda x,y:x+y,range(10)) print(b) # 45 ， 即從0加到9
43. repr() 函數將對象轉化為供解釋器讀取的形式。返回一個對象的 string 格式。
r = repr((1,2,3)) print( r ) # (1, 2, 3) print( type(r) ) # <class 'str'> dict = repr({'a':1,'b':2,'c':3}) print( dict ) # {'c': 3, 'a': 1, 'b': 2} print( type(dict) ) # <class 'str'>
44. reversed() 函數返回一個反轉的迭代器。 reversed(seq)要轉換的序列，可以是 tuple, string, list 或 range。
rev = reversed( [1,2,3,4,5] ) # 列表 print(list(rev)) # [5, 4, 3, 2, 1] rev1 = reversed( "school" ) # 元組 print(tuple(rev1)) # ('l', 'o', 'o', 'h', 'c', 's') rev2 = reversed(range(10)) # range print(list(rev2)) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
45. round() 方法返回浮點數x的四舍五入值。（除非對精確度沒什么要求，否則盡量避開用round()函數）
print( round(4.3)) # 只有一個參數時，默認保留到整數 # 4 print( round(2.678,2)) # 保留2位小數 # 2.68 print( round(5/3,3)) # 運算表達式並保留3位小數 # 1.667
46. set() 函數創建一個無序不重復元素集，可進行關系測試，刪除重復數據，還可以計算交集、差集、並集等。
1 a = set('school') 2 print(a) # 重復的被刪除，得到結果：{'o', 'c', 's', 'l', 'h'}
1 b = set([1,2,3,4,5]) 2 c = set([2,4,6,8,10]) 3 4 print(b & c) # 交集，得到結果為{2, 4} 5 print(b | c) # 並集，得到結果為{1, 2, 3, 4, 5, 6, 8, 10} 6 print(b - c) # 差集，得到結果為{1, 3, 5}
47. slice() 函數實現切片對象，主要用在切片操作函數里的參數傳遞。
a = slice("school") print(a) # slice(None, 'school', None)
48. sorted() 函數對所有可迭代的對象進行排序（默認升序）操作。
# 對列表進行排序 print(sorted([1,2,5,30,4,22])) # [1, 2, 4, 5, 22, 30] # 對字典進行排序 dict = {23:42,1:0,98:46,47:-28} print( sorted(dict) ) # 只對key排序 # [1, 23, 47, 98] print( sorted(dict.items()) ) # 默認按key進行排序 # [(1, 0), (23, 42), (47, -28), (98, 46)] print( sorted(dict.items(),key=lambda x:x[1]) ) # 用匿名函數實現按value進行排序 # [(47, -28), (1, 0), (23, 42), (98, 46)]
# 利用key進行倒序排序 test1 = [1,2,5,30,4,22] r_list = sorted(test1,key=lambda x:x*-1) print(r_list) # [30, 22, 5, 4, 2, 1] # 要進行反向排序，也可以通過傳入第三個參數 reverse=True： test2 = [1,2,5,30,4,22] print(sorted(test2,reverse=True)) # [30, 22, 5, 4, 2, 1]
49. str() 函數將對象轉化為string格式。
1 a = str((1,2,3)) 2 print(a) # 打印a，得到結果(1, 2, 3) 3 print(type(a)) # 打印a的類型，得到結果 <class 'str'>
50. sum()函數對參數進行求和計算。
print( sum([1,2,3]) ) # 6 print( sum([1,2,3],4) ) # 列表計算總和后再加4，得到結果10 print( sum( (1,2,3),4 ) ) # 元組計算總和后再加4，得到結果10
51. tuple()函數將列表轉換為元組。
# 注：元組與列表是非常類似的，區別在於元組的元素值不能修改，元組是放在括號中，列表是放於方括號中。
print( tuple([1, 2, 3])) # (1,2,3)
52. type() 函數如果你只有第一個參數則返回對象的類型，三個參數返回新的類型對象。
print(type(1)) # <class 'int'> print(type("123")) # <class 'str'> print(type([123,456])) # <class 'list'> print(type( (123,456) ) ) # <class 'tuple'> print(type({'a':1,'b':2}) ) # <class 'dict'>
53. zip() 函數用於將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的對象，這樣做的好處是節約了不少的內存。可以使用 list() 轉換來輸出列表。如果各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同。利用 * 號操作符，可以將元組解壓為列表。
1 a = [1,2,3] 2 b = [4,5,6] 3 c = [7,8,9,10] 4 5 for i in zip(a,b): 6 print(i) 7 8 # 返回結果： 9 # (1, 4) 10 # (2, 5) 11 # (3, 6) 12 13 print(list(zip(a,b))) # list() 轉換為列表 14 # [(1, 4), (2, 5), (3, 6)] 15 16 print(list(zip(b,c))) # 元素個數與最短的列表一致 17 # [(4, 7), (5, 8), (6, 9)] 18 19 a1,a2 = zip(*zip(a,b)) # 用zip(*)解壓 20 print(list(a1)) # [1, 2, 3] 21 print(list(a2)) # [4, 5, 6]
54. __import__() 函數用於動態加載類和函數。如果一個模塊經常變化就可以使用 __import__() 來動態載入。
__import__('decorator') # 返回結果如下： # in the bar # the func run time is 3.000171661376953
# 首先獲得Iterator對象:
it = iter([1,2,3,4,5])
# 循環:
while True:
try:
# 獲得下一個值:
x = next(it)
print(x)
except StopIteration:
break
# 遇到StopIteration就退出循環