⼀. 本節主要內容:
1. 內建函式
什麼是內建函式? 就是python給你提供的. 拿來直接⽤的函式, 比如print., input等等. 截⽌
到python版本3.6.2 python⼀共提供了68個內建函式. 他們就是python直接提供給我們的.

 

作用域相關：

　　locals（）返回當前作用域中的名字

　　globas（）返回全域性作用域中的名字

迭代器相關：

　　range（）生成資料

　　next（）迭代器向下執行一次，內部實際使用了__next__（）方法返回迭代器的下一個專案

　　iter（）獲取迭代器，內部實際使用的是__iter_（）方法來獲取迭代器

 

字串型別程式碼的執行

　　eval（）執行字串型別的程式碼。並返回最終結果

print(eval("2+2")) # 4
n = 8
print(eval("2+n")) # 10
def func():
     print(666)
eval("func()") # 666

　　exec（）執行字串型別的程式碼

exec("""
for i in range(10):
     print(i)
""")
exec("""
def func():
     print("我是周杰倫")
func()
""")

　　compile（）將字串型別的程式碼編譯。程式碼物件能夠通過exec語句來執行或者 eval（）進行

　　求值

　　引數說明：

　　　　1.resource 要執行的程式碼，動態程式碼片段

　　　　2.檔名，程式碼存放的檔名，當傳入了第一個引數的時候，這個引數給空就可以了

　　　　3.模式，取值有三個：

　　　　　　1.exec：一般放一些流程語句的時候使用

　　　　　　2.eval：resource之存放一個求值表示式。

　　　　　　3.single：resource存放的程式碼有互動的時候，使用

code1 = "for i in range(10): print(i)"
c1 = compile(code1, "", mode="exec")
exec(c1)

code2 = "1+2+3"
c2 = compile(code2, "", mode="eval")
a = eval(c2)
print(a)

code3 = "name = input('請輸⼊你的名字:')"
c3 = compile(code3, "", mode="single")
exec(c3)
print(name)

　　有返回值的字串形式的程式碼用eval（），沒有返回值的字串形式的程式碼用exec（），一般很少

　　用到compile（）

　　輸入和輸出相關：
　　　　input（）獲取使用者輸入的內容

　　　　print（）列印輸出

　　記憶體相關：

　　　　hash（）獲取物件的雜湊值（int，str，bool，tuple）

　　　　id（）獲取到物件的記憶體地址

　　檔案操作相關：
　　　　open（）用於開啟一個檔案，建立一個檔案控制代碼

　　模組相關：

　　　　__import__（）用於動態載入類和函式

　　幫助：

　　　　help（）函式用於檢視函式或模組用途的詳細說明

　　呼叫相關：

　　　　callable（）用於檢查一個物件是否是可呼叫。如果返回True，object有可能呼叫失敗，但如果

　　返回False，那呼叫絕對不會成功。

　　檢視內建屬性：
　　　　敵人（）檢視物件的內建屬性，方法。訪問的是物件中的__dir__（）方法

　　基礎資料型別相關：

　　　　數字相關：

　　　　　　bool（）將給定的資料轉換成bool值。如果不給值。返回False

　　　　　　int（）    將給定的資料轉換成int值，如果不給值，返回0

　　　　　　float（）  將給定的資料轉換成float值。也就是小數

　　　　　　complex（）建立一個複數，第一個引數為實部，第二個引數為虛部。或者第一個引數直

　　　　　　接用字串來描述複數

　　進位制轉換：

　　　　bin（）將給的引數轉換成二進位制

　　　　otc（）將給的引數轉換成八進位制

　　　　hex（）將給的引數轉換成十六進位制

　　數學運算：
　　　　abs（）返回絕對值

　　　　divmode（）返回商和餘數

　　　　round（）四捨五入

　　　　pow（a,b）求a的b次冪，如果有三個引數。則求完次冪後對第三個數取餘

　　　　sum（）求和

　　　　min（）求最小值

　　　　max（）求最大值

　　和資料結構相關：

　　　　列表和元組：

　　　　　　list（） 將一個可迭代物件轉換成列表

　　　　　　tuple（）將一個可迭代物件轉換成元組

　　　　　　reversed（） 將一個序列翻轉，返回翻轉序列的迭代器

　　　　　　slice（）列表的切片

st = "⼤家好, 我是麻花藤"
s = slice(1, 5, 2)
print(st[s])

　　字串相關：

　　　　str（） 將資料轉化成字串

　　　　format（）與具體資料有關，用於計算各種小數，精算等。

# 字串
print(format('test', '<20')) # 左對⻬
print(format('test', '>20')) # 右對⻬
print(format('test', '^20')) # 居中
# 數值
print(format(3, 'b')) # ⼆進位制
print(format(97, 'c')) # 轉換成unicode字元
print(format(11, 'd')) # ⼗進位制
print(format(11, 'o')) # ⼋進位制
print(format(11, 'x')) # ⼗六進位制(⼩寫字⺟)
print(format(11, 'X')) # ⼗六進位制(⼤寫字字⺟)
print(format(11, 'n')) # 和d⼀樣
print(format(11)) # 和d⼀樣
# 浮點數
print(format(123456789, 'e')) # 科學計數法. 預設保留6位⼩數
print(format(123456789, '0.2e')) # 科學計數法. 保留2位⼩數(⼩寫)
print(format(123456789, '0.2E')) # 科學計數法. 保留2位⼩數(⼤寫)
print(format(1.23456789, 'f')) # ⼩數點計數法. 保留6位⼩數
print(format(1.23456789, '0.2f')) # ⼩數點計數法. 保留2位⼩數
print(format(1.23456789, '0.10f')) # ⼩數點計數法. 保留10位⼩數
print(format(1.23456789e+10000, 'F')) # ⼩數點計數法.

　　

　　bytes（）把字串轉化成bytes型別

s = "你好"
bs = s.encode("UTF-8")
print(bs)
s1 = bs.decode("UTF-8")
print(s1)
bs = bytes(s, encoding="utf-8") # 把字串編碼成UTF-8
print(bs)

　　

　　bytearray（）返回一個新位元組陣列。這個數字裡的元素是可變的，並且每個元素的值的範圍

　　是 [0,256)

ret = bytearray('alex',encoding='utf-8')
print(ret[0])
print(ret)

　　

　　memoryview（）檢視bytes在記憶體中的情況

# 檢視bytes位元組在記憶體中的情況
s = memoryview("麻花藤".encode("utf-8"))
print(s)

　　

　　ord（）輸入字元找帶字元編碼的位置

　　chr（）輸入位置數字找出對應的字元

　　ascii（）是ascii碼中的返回值，不是就返回\u..

# 找到對應字元的編碼位置
print(ord('a'))
print(ord('中'))

# 找到對應編碼位置的字元
print(chr(97))
print(chr(20013))

# 在ascii中就返回這個值. 如果不在就返回\u...
print(ascii('a'))
print(ascii('好'))

　　

　　rep（）返回一個物件的string的形式

# repr 就是原封不動的輸出, 引號和轉義字元都不起作⽤
print(repr('⼤家好,\n \t我叫周杰倫'))
print('⼤家好我叫周杰倫')
# %r 原封不動的寫出來
name = 'taibai'
print('我叫%r' % name)

 

　　資料集合：
　　　　dict（）建立一個字典

　　　　set（）建立一個集合

　　　　frozenset（）建立一個凍結的集合，凍結的集合不能進行新增和刪除操作

　　其他相關：

　　　　len（） 返回一個物件中的元素的個數

　　　　sorted（） 對可迭代物件進行排序操作，可以配合lamda（）

　　　　enumerate（）獲取集合的列舉物件

lst = ["alex", "wusir", "taibai"]
for index, el in enumerate(lst):
     print(str(index)+"==>"+el)

　　all（） 可迭代物件中全部是True，結果才是True

　　any（）可迭代物件中有一個是True，結果是True

print(all([1,2,True,0]))
print(any([1,'',0]))

　　zip（）函式用於將可迭代的物件作為引數，將物件中對應的元素打包成一個個元組，然後返回由這些元祖組成的列表。如果各個迭代器的元素個數不一致，則返回列表長度與最短的物件相同。

l1 = [1,2,3,]
l2 = ['a','b','c',5]
l3 = ('*','**',(1,2,3))
for i in zip(l1,l2,l3):
     print(i)

　　filter（） 過濾，也可以配合lamda使用

　　map（）會根據提供的函式對指定序列做對映，也可以配合lamda使用

 

二、lamda函式

　　lamda匿名函式

　　為了解決一些簡單的需求而設計的一句話函式

# 計算n的n次⽅
def func(n):
     return n**n
print(func(10))

f = lambda n: n**n
print(f(10))

　　lambda表⽰的是匿名函式. 不需要⽤def來宣告, ⼀句話就可以宣告出⼀個函式

語法：

　　函式名 = lambda 引數: 返回值

注意：

　　1. 函式的引數可以有多個. 多個引數之間⽤逗號隔開
　　2. 匿名函式不管多複雜. 只能寫⼀⾏, 且邏輯結束後直接返回資料
　　3. 返回值和正常的函式⼀樣, 可以是任意資料型別

　　匿名函式並不是說⼀定沒有名字. 這⾥前⾯的變數就是⼀個函式名. 說他是匿名原因是我們通
　　過__name__檢視的時候是沒有名字的. 統⼀都叫lambda. 在調⽤的時候沒有什麼特別之處.
　　像正常的函式調⽤即可

詳細講解sorted（）

　　排序函式：

　　語法: sorted(Iterable, key=None, reverse=False)

　　　　  Iterable: 可迭代物件

　　　　  key: 排序規則(排序函式), 在sorted內部會將可迭代物件中的每⼀個元素傳遞給這個函
　　　　  數的引數. 根據函式運算的結果進⾏排序

　　　　  reverse: 是否是倒敘. True: 倒敘, False: 正序

lst = [1,5,3,4,6]
lst2 = sorted(lst)
print(lst) # 原列表不會改變
print(lst2) # 返回的新列表是經過排序的
dic = {1:'A', 3:'C', 2:'B'}
print(sorted(dic)) # 如果是字典. 則返回排序過後的key

　　和函式組合使用

# 根據字串⻓度進⾏排序
lst = ["麻花藤", "岡本次郎", "中央情報局", "狐仙"]
# 計算字串⻓度
def func(s):
     return len(s)
print(sorted(lst, key=func))

　　和lambda組合使用

# 根據字串⻓度進⾏排序
lst = ["麻花藤", "岡本次郎", "中央情報局", "狐仙"]
# 計算字串⻓度
def func(s):
     return len(s)
print(sorted(lst, key=lambda s: len(s)))
lst = [{"id":1, "name":'alex', "age":18},
         {"id":2, "name":'wusir', "age":16},
         {"id":3, "name":'taibai', "age":17}]
# 按照年齡對學⽣資訊進⾏排序
print(sorted(lst, key=lambda e: e['age']))    

 

三、filter（）詳解

　　篩選函式

　　語法: filter(function. Iterable)

　　　　function: ⽤來篩選的函式. 在filter中會⾃動的把iterable中的元素傳遞給function. 然後
　　　　　　　　根據function返回的True或者False來判斷是否保留此項資料

　　　　Iterable: 可迭代物件

lst = [1,2,3,4,5,6,7]
ll = filter(lambda x: x%2==0, lst) # 篩選所有的偶數
print(ll)
print(list(ll))
lst = [{"id":1, "name":'alex', "age":18},
         {"id":2, "name":'wusir', "age":16},
         {"id":3, "name":'taibai', "age":17}]
fl = filter(lambda e: e['age'] > 16, lst) # 篩選年齡⼤於16的資料
print(list(fl))

　　

四、map（）詳解

　　對映函式　

　　語法: map(function, iterable) 可以對可迭代物件中的每⼀個元素進⾏對映. 分別取執⾏
　　function
　　計算列表中每個元素的平⽅ ,返回新列表

def func(e):
     return e*e
mp = map(func, [1, 2, 3, 4, 5])
print(mp)
print(list(mp))

　　改寫lambda

print(list(map(lambda x: x * x, [1, 2, 3, 4, 5])))

　　計算兩個列表中相同位置的資料的和

# 計算兩個列表相同位置的資料的和
lst1 = [1, 2, 3, 4, 5]
lst2 = [2, 4, 6, 8, 10]
print(list(map(lambda x, y: x+y, lst1, lst2)))

　　最後

　　附上一個內建函式的思維導圖：

　　https://www.processon.com/view/link/5c10d5fde4b0fd4819959b0d

　　密碼：

　　5bI2