Python內置函數
python內置函數，是隨着python解釋器運行而創建的函數，不需要重新定義，可以直接調用，那python的內置函數有哪些呢，接下來我們就了解一下python的內置函數，這些內置函數中，有一些是面相對象的內容，還有一些是某些模塊有關的，我們今天就先了解一些，那些涉及到某些模塊以及面向對象的內容我們以后學到之后可再加深了解。
abs()
這個函數的就是將傳入的數值取絕對值然后將絕對值。
i = abs(-50) print(i) k = abs(50) print(k) 輸出結果： 50 50
all()
給all()這個函數傳一個可迭代的數據，all()函數內部回去迭代，如果這里面所有被迭代的對象都是真值，all()函數就返回一個True，如果有一個不是真值就返回False。
li = [1,2,3,4,5] i = all(li) print(i) li1 = [1,2,3,0] #0為假值 k = all(li1) print(k) 輸出結果： True False
如何判斷哪些是真值哪些是假值，真值有很多但是假值僅有幾個我們通過拿到布爾值進行判斷，通過一些的示例我們可以知道0，None，以及空值都是假的。
print(bool(0)) #數字零為假 print(bool(None)) #None為假 print(bool("")) #空的字符串為假，這個空字符串不包含任何字符以及空格 print(bool(())) #空的元組為假 print(bool([]))#空的列表為假 print(bool({}))#空的字典為假 輸出結果： False False False False False False
any()
這個any()和all()有些相似，相似的地方就是判斷是否為真值，但是all()是所有為真輸出True，any()是只要有一個是真就輸出True。
li = [1,0] i = any(li) print(i) li1 = [0,0,""] k = any(li1) print(k) 輸出結果： True False
ascii()
我們使用ascii()這個函數的時候，去傳入對象的類（列表list，字典dict）中找__repr__這個方法，去執行這個方法，拿到這個方法的返回值。
我們在這里舉一個例子，這個例子涉及到類，沒了解過的可以在我以后的博客文章中了解以后再來深入學習。
class Nuo: def __repr__(self): return '123' obj = Nuo() print(ascii(obj)) #這個使我們自己寫的類，如果使用python中內部的__repr__方法 li = list() print(ascii(li)) #列表的類中的__repr__方法返回的就是[] 輸出結果： 123 []
bin()
這個是二進制，可以將其它進制轉換為二進制格式。
oct()
這個是八進制，可以將其它進制轉換為八進制格式。
int()
這個是十進制，可以將其它進制轉換為十進制格式。
hex()
這個是十六進制，可以將其它進制轉換為十六進制的格式。
以上四個的具體用法之前已經詳細介紹，文章連接在這里：https://www.cnblogs.com/liudi2017/p/9171267.html
bool()
這個函數的作用是判斷傳入對象的真假，其實就是將傳入的對象轉換為bool值。
print(bool(None)) print(bool(1)) print(bool("123")) 輸出結果： False True True
bytes()
這個表示字節
字節和字符轉的轉換
bytes("xxxx",encoding="utf-8")
bytearrary()
這個表示字節列表
這兩個我們僅僅知道這些即可，不需要太多的了解，很少會用到，我們以后用到會詳細介紹。
chr()
接收一個數字，找到這個數字對應ascii碼表中對應的元素。
print(chr(97)) #在ascii碼表中數值97對應的是小寫字母a 輸出結果： a
ord()
這個函數的方法正好和chr()相對，它是將一個字符轉換為ascii碼中的數值。
print(ord('p')) print(ord(' ')) print(ord('_')) 輸出結果： 112 32 95
callable()
判斷對象是否可以執行，可以執行返回一個True，不可以執行返回一個False。
def newfun(): return 123 newfun() r = callable(newfun) print(r) 輸出結果： True
compile()
接收一個字符串把這個字符串編譯成python可以執行的代碼，理解到這里就可以了。
str = 'name = "alexsel";print(name)' obj = compile(str,'string','exec') exec(obj) 輸出結果： alexsel
complex()
函數用於創建一個值為 real + imag * j 的復數或者轉化一個字符串或數為復數。
如果第一個參數為字符串，則不需要指定第二個參數。
這個在我們以后的學習中基本用不到。
>>>complex(1, 2) (1 + 2j) >>> complex(1) # 數字 (1 + 0j) >>> complex("1") # 當做字符串處理 (1 + 0j) # 注意：這個地方在"+"號兩邊不能有空格，也就是不能寫成"1 + 2j"，應該是"1+2j"，否則會報錯 >>> complex("1+2j") (1 + 2j)
dir()
查詢某個類提供了什么功能，下面示例就是查看列表這個類提供了什么功能。
li=[] print(dir(li)) 輸出結果： ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', ...........
divmod()
以元組的形式顯示商和余數。
>>> r=divmod(10,3) >>> print(r) (3, 1)
eval()
eval() 函數用來執行一個字符串表達式，並返回表達式的值。
>>> a="1+3" >>> print(a) 1+3 >>> ret=eval("1+3")#把字符串轉換為表達式 >>> print(ret) 4 >>>x = 7 >>> eval( '3 * x' ) 21 >>> eval('pow(2,2)') 4 >>> eval('2 + 2') 4 >>> eval("n + 4") 85
exec()
執行一個字符串內的代碼,無返回值(返回值為None)，這個函數在我們介紹compile()的時候也用到過，可以上去看看之前的代碼加深理解。
>>> exec("print(123)") 123
filter()
循環可迭代的對象，獲取每一個參數，在函數里執行參數
函數用於過濾序列，過濾掉不符合條件的元素，返回由符合條件元素組成的新列表。
該接收兩個參數，第一個為函數，第二個為序列，序列的每個元素作為參數傳遞給函數進行判，
然后返回 True 或 False，最后將返回 True 的元素放到新列表中。
格式：filter(函數，可迭代的對象)
示例1
def f1(x): if x>22: return True else: return False ret = filter(f1,[11,22,33,44]) #把返回為True的元素放到ret中 for i in ret: #用循環輸出ret print(i) 輸出結果： 33 44
示例2
def f1(x): return x>22 ret = filter(f1,[11,22,33,44]) #拿到傳入函數的參數得到返回值得到元素。 for i in ret: print(i) 輸出結果： 33 44
map()
map() 會根據提供的函數對指定序列做映射。
第一個參數 function 以參數序列中的每一個元素調用 function 函數，返回包含每次 function 函數返回值的新列表。
格式：map(函數，可迭代的對象)
def f1(x): return x+100 ret = map(f1, [1,2,3,4,5]) for i in ret: print(i) 輸出結果： 101 102 103 104 105
format()
字符串格式化，字符串格式化我們以后會常常用到，這里就先不講解，明天我們做一個詳細的介紹。
frozenset()
創建一個不能添加元素的set格式，保存在set()中的數據是不能重復的，所以這個就是一個不能重復的，不可修改的數據類型。
fset = frozenset([1,2,3,4,4]) print(fset) 輸出結果： frozenset({1, 2, 3, 4})
globals()
獲取當前代碼里的所有的全局變量，下面的示例中出現里一些我們沒有定義的全局變量，這些是python中需要用到的全局變量，自己生成的全局變量。
name = 'alexsel' age = '47' obj = globals() print(obj) 輸出結果： {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000000020AB1D0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/Administrator/PycharmProjects/untitled1/Alexsel/new_one.py', '__cached__': None, 'name': 'alexsel', 'age': '47', 'obj': {...}}
local()
獲取當前代碼里的所有的局部變量。
hash()
hash() 用於獲取取一個對象（字符串或者數值等）的哈希值,一般用於字典key的優化。
str = hash('alexsel') print(str) 輸出結果： 9030579981152233445
#在 hash() 對對象使用時，所得的結果不僅和對象的內容有關，還和對象的 id()，也就是內存地址有關。
id()
用於查詢某個對象的內存地址。
name = 'alexsel' print(id(name)) 輸出結果： 37728920
isinstance()
判斷某個對象是否由某一個類創建的。
li=[11,22,33] t=isinstance(li,list)#判斷li是否是由list類創建的 print(t) a=isinstance(li,dict)#判斷li是否是由dict類創建 print(a) #如果某個類是當前類的父類也是支持的 輸出結果： True False
issubclass()
判斷一個類是不是另一類的子類
格式：issubclass(a,B)，判斷a是不是B的子類
c = issubclass(list,object) print(c) 輸出結果： True
iter()
創建一個可以迭代的對象
li = [1,2,3,4,5,6] for i in iter(li): print(i) 輸出結果： 1 2 3 4 5 6
next()
將一個可迭代的對象運行一個next就去一個值，取下一個值。
a = iter([11, 22, 33, 44]) print(a) r1 = next(a) print(r1) r2 = next(a) print(r2) 輸出結果： <list_iterator object at 0x0000000002120978> 11 22
max()
找到多個值中的最大值
min()
找到多個值中的最小值
li = [11, 22, 33, 44] t = max(li) print(t) z = min(li) print(z) 輸出結果： 44 11
memoryview()
根據索引判斷某個對象的的地址是多少
函數返回給定參數的內存查看對象(Momory view)。
所謂內存查看對象，是指對支持緩沖區協議的數據進行包裝，在不需要復制對象基礎上允許Python代碼訪問。
open()
文件操作，操作文件的函數，這里做個簡單的示例，明天會詳細講解。
file1 = open('./text.txt',encoding='utf=-8') r1 = file1.read() print(r1)
pow()
返回x的y次方的值
格式:pow(x,y)
i=pow(2,10) print(i) 輸出結果： 1024
repr()
返回__repr__的值，每個類中都寫有__repr__方法，這個函數就是取到這個方法的返回值。
repr() 函數將對象轉化為供解釋器讀取的形式
range()
生成一個可以迭代的列表
for i in range(4): #從零開始生成，小於4 print(i) print('--------') for k in range(7,9): #大於等於7小於9 print(k) 輸出結果： 0 1 2 3 -------- 7 8
reversed()
講一個包含有多個元素的數據進行順序的反轉。
li = [1,2,3,4,5,6] print(list(reversed(li))) 輸出結果： [6, 5, 4, 3, 2, 1]
round()
將一個數字進行四舍五入
a = round(5.5) print(a) b = round(5.4) print(b) 輸出結果： 6 5
slice() 函數實現切片對象，主要用在切片操作函數里的參數傳遞
格式：slice(start,stop(step)
start起始位置
stop結束位置
step每次切片間距
li = [1,2,3,4,5,6,] slicetest = slice(3) print(li[slicetest]) slicetest1 = slice(3,6,2) print(li[slicetest1]) 輸出結果： [1, 2, 3] [4, 6]
sorted()
這個函數的功能是對含有多個元素的數據進行排序
示例1
li = [1, 22, 33, 222, 3, 1] print(li) le = sorted(li)# 生成新的值，不對原來的變量進行改變 print(le) #這個只能對同一個類型的數據進行排序 print(li) li.sort() # 不生成新的值，對原來的變量進行改變 print(li) 輸出結果： [1, 22, 33, 222, 3, 1] [1, 1, 3, 22, 33, 222] [1, 22, 33, 222, 3, 1] [1, 1, 3, 22, 33, 222]
示例2
li = ["123","1","張","a","99","c","you","鈾","---","_","A","b","0","你","王",] print(li) le = sorted(li)# 生成新的值，不對原來的變量進行改變 print(le) for i in le: print(bytes(i,encoding="utf-8")) 輸出結果： ['123', '1', '張', 'a', '99', 'c', 'you', '鈾', '---', '_', 'A', 'b', '0', '你', '王'] ['---', '0', '1', '123', '99', 'A', '_', 'a', 'b', 'c', 'you', '你', '張', '王', '鈾'] b'---' b'0' b'1' b'123'#數字是先比較第一個元素，誰小誰在前面，第一個樣就比第二個 b'99' b'A' b'_' #字母比較ascii碼，先比較第一個元素，誰小誰在前面，第一個 b'a' #一樣就比第二個 b'b' b'c' b'you' b'\xe4\xbd\xa0'#漢字比十六進制的大小 b'\xe5\xbc\xa0' b'\xe7\x8e\x8b' b'\xe9\x88\xbe'
staticmethod()
返回函數的靜態方法。
sum()
對一組數據求和。
t=sum([11,22,33]) print(t) 輸出結果： 66
super()
在類的繼承中，如果重定義某個方法，該方法會覆蓋父類的同名方法，但有時，我們希望能同時實現父類的功能，這時，我們就需要調用父類的方法了，可通過使用super 來實現。
tuple()
tuple 函數將列表轉換為元組。
li = [1,2,3] print(tuple(li)) 輸出結果： (1, 2, 3)
type()
查看所一個對象的類型
li = [1,2,3] dic = {'key':'v1'} str = 'alexsel' print(type(li)) print(type(dic)) print(type(str)) 輸出結果： <class 'list'> <class 'dict'> <class 'str'>
zip()
傳入多個可以迭代的對象，將可迭代的對象里的元素打包在一起，打包成一個元組，返回由這些元組組成的列表。
功能是從參數的多個迭代器中選取元素組合成一個新的迭代器。顧名思義，它就是一個將對象進行打包和解包的函數。
li=[11,22,33,44] li2=["a","VV","c","aa"] r=zip(li,li2) print(r) for i in r : print(i) 輸出結果： <zip object at 0x00000000027F77C8> (11, 'a') (22, 'VV') (33, 'c') (44, 'aa')
__import__
函數功能用於動態的導入模塊，主要用於反射或者延遲加載模塊
__import__(module) 相當於 import module