什麽是內置函數？

就是Python給你提供的，拿來直接用的函數，比如print，input等等。其實就是我們在創建.py的時候python解釋器所自動生成的內置的函數，就好比我們之前所學的作用空間

內置空間就是python文件在創建的時候python解釋器所自動創建的

重要的 內置函數：

***

eval：

eval：執行字符串類型的代碼，並返回最終結果。（其實就是對字符串內的類型進行操作 比如你字符串內事int類型的 相加相乘之類的 直接進行操作 如果字符串內事列表或者字典直接把列表字典給原樣返還）

print(eval(‘3+4‘))  #7
print(eval("{‘name‘:‘老南京‘, ‘age‘:17}
 
")) #{‘name‘:‘老南京‘, ‘age‘:17}
print(eval("[‘1+3‘]")) # [‘1+3‘]

exec:執行字符串類型的代碼,流程語句。 就是字符串內的該執行的內容給執行出來 （你字符串的只是在裏面是一種顯示沒有執行exec是把它給執行）

ret = ‘‘‘
li = [1, 2, 3]
for i in li :
    print(i)


‘‘‘
exec(ret)  #就是把字符串內的所有該執行的用這個方法在字符串外面給執行了

sum：對可叠代對象進行求和計算（可設置初始值）。 但是最多只能兩個元素相加

print(sum([1,2,3,4])) #
 
 10
print(sum((1,2,3,),100)) # 106
print(sum({1:2,3:4}))#字典只是把key值給相加

max：返回可叠代對象的最大值（可加key，key為函數名，通過函數的規則，返回最大值）

print(max([1,2,3,4])) #4
print(max([1, 2, 3, 4,-9], key=abs)) #-9  abs表示絕對值

min和max所有的使用都一樣只不過是返回最小值 兩個都是只能對可叠代對象進行使用

print(min((1,2,3,4,5)))
print(min({3:2,4:1}))  #對字典使用只能對字典的key進行比較
 

reversed：將一個序列翻轉，並返回此翻轉序列的叠代器。 就是你用reversed在對一個可叠代的隊形進行操作的就把它變成了叠代器

ret  =reversed([‘a‘, ‘b‘, 1, 2, 3])                                  
print(ret)                                                           
print(ret.__next__())  #因為reversed已經把可叠代的對象給轉化為叠代器了所以需要用__next__來取值  

repr:返回一個對象的string形式（原形畢露）。 就是字符串內是什麽形式就返還什麽形式

print(repr(‘{"name":"alex"}‘))  #字符串內含有的字典給返回出來  因為字典也是放在了字符串內 此時它就是字符串了    
print(repr(‘(1,2,3)‘))                                                      

sorted 對所有可叠代的對象進行排序操作。 可加key它和sort相比較就是多加了個key就是可以定義怎麽進行翻轉

li = [1, -2, -7, 8, 5, -4, 3]                                      
print(sorted(li))          #從小到大排序                                 
print(sorted(li , reverse = True)) #從大到小排序                         
print(sorted(li, reverse = True, key =abs))      #按照絕對值給排序         

enumerate 枚舉 就是返回一個枚舉對象 (0, seq[0]), (1, seq[1]), (2, seq[2]),

li = [‘老男孩‘,‘alex‘,‘wusir‘,‘嫂子‘,‘zhaoyun‘]  #返回一個枚舉對象你一一打印這個枚舉對象內的所有值就會出現對應的序列號                                              
for k, v in enumerate(li):  #0 老男孩                                                                                           
    print(k,v)               #1 alex                                                                                         
                             #2 wusir                                                                                        
                             #3 嫂子                                                                                           
                             #4 zhaoyun       

l1 = (‘laowang‘, ‘zhangsan‘,1, 2, 3,4)
for i in enumerate(l1):
    print(i)

zip 拉鏈方法 就是按照最短的可叠代對象來進行組合這個組合只能是從上到下 並且按照最短的那個叠代對象來組合

函數用於將可叠代的對象作為參數，將對象中對應的元素打包成一個個元組，然後返回由這些元組組成的列表。如果各個叠代器的元素個數不一致，則返回列表長度與最短的對象相同。

l1 = [1, 2, 3, 4, 5]                                         
l2 =(5, 6, 7,)                                               
l3 =[‘laowang‘, ‘sb‘, 5, 6]                                  
# print(zip(l1, l2, l3))                                     
for i in zip(l1, l2, l3) :       #     (1, 5, ‘laowang‘)     
    print(i)                     # (2, 6, ‘sb‘)              
                                 # (3, 7, 5)                 
                                                             

filter：過濾·。 其實就是提供一個場所讓你傳進倆條件和可叠代對象進行判斷

def func(x):return x%2 == 0             
ret = filter(func,[1, 2, 3, 4, 5, 6, 7])  #func是判斷條件 後面是需要判斷的內容
print(ret)                              
for i in ret :                          
    print(i)                            

map:會根據提供的函數對指定序列做映射。使用map的同時也是創建了一個裝飾器 需要用__next__來取值或者轉化為list之類的來取值

def s(x):                 
    return x**2           
ret =map(s, [1,2,3,4,5])  
print(ret.__next__())     
print(ret.__next__())     

匿名函數：

匿名函數：為了解決那些功能很簡單的需求而設計的一句話函數。

#這段代碼
def calc(n):
    return n**n
print(calc(10))
 
#換成匿名函數
calc = lambda n:n**n
print(calc(10))

res=map(lambda x,y:x+y,[1, 3, 5, 7, 9],[2,4,6,8])   #就是把兩個列表相加一起  但是是一一對應相加
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())        #但是 不能超過那個最少個映射

函數名 = lambda 參數 ：返回值

#參數可以有多個，用逗號隔開
#匿名函數不管邏輯多復雜，只能寫一行，且邏輯執行結束後的內容就是返回值
#返回值和正常的函數一樣可以是任意數據類型

我們可以看出，匿名函數並不是真的不能有名字。

匿名函數的調用和正常的調用也沒有什麽分別。 就是 函數名(參數) 就可以了～～～

匿名函數與內置函數舉例：

res = filter(lambda x: x>10,[5,8,9,11,13])    
# for i in res :                              
#     print(i)                                
print(res.__next__())                         
print(res.__next__())                         
                                              

python之內置函數，匿名函數