python內置函數及匿名函數

locals  本地做用域/局部做用域 會隨着位置的改變而改變
globals 全局做用域           永遠不變 永遠是全局

 1 a = 1
 2 b = 2  3 print(locals())  4 print(globals())  5 def func():  6 c = 3  7 d = 4  8 print(locals())  9 def func2(): 10 l1 = [] 11 d1 = {} 12 print(locals()) #不管在哪裏打印 獲得的都是全局做用域中的名字 13 func() 14 func2() 15 結果 16 {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001CE3C83A470>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/PyPractise/day11.py', '__cached__': None, 'a': 1, 'b': 2} 17 {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001CE3C83A470>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/PyPractise/day11.py', '__cached__': None, 'a': 1, 'b': 2} 18 {'d': 4, 'c': 3} 19 {'d1': {}, 'l1': []}

range(起始位置,終止位置,步長)
range(終止位置)
range(起始,終止位置)

1 range(5)        #0,1,2,3,4 2 range(5,0,-1) #5,4,3,2,1 3 range(1,10,2) #1,3,5,7,9

iter  建立迭代器和__iter__同樣

1 迭代器 = 可迭代的.__iter__() 2 迭代器 = iter(可迭代的)

next    執行迭代器和__next__同樣

1 print(net(迭代器)) 2 帶雙下劃線的魔術方法通常狀況下不直接用 3 帶雙下劃線的全部的方法均可能和內置的函數有千絲萬縷的聯繫

print(要打印的內容1,要打印的內容2,sep = '分隔符',end = '結束符',file=file.txt, flush=False)
file:  默認是輸出到屏幕,若是設置爲文件句柄,輸出到文件
sep:   打印多個值之間的分隔符,默認爲空格
end:   每一次打印的結尾,默認爲換行符
flush: 當即把內容輸出到流文件,不做緩存(默認緩存)
#print的本質,就是寫文件,這個文件是pycharm的屏幕

 1 print(123,'abc',sep='|',end='@')  2 print('www')  3 結果：  4 123|abc@www  5  6 事例二  7 f = open('file','w')  8 print(123,'abc',file=f,flush=True)  9 f.close() 10 11 案例:打印進度條 12 import time #導入別人寫好的代碼 13 def func(): 14 for i in range(0,101,2): 15 time.sleep(0.1) #每一次在這個地方阻塞0.1s 16 char_num = i//2 #控制輸出長度 17 if i == 100: 18 per_str = '\r%s%% : %s\n' % (i, '*' * char_num) # %% 轉義%，\n換行符 19 else: 20 per_str = '\r%s%% : %s' % (i, '*' * char_num) 21 print(per_str,end = '') #per_str,end = ''格式化輸出去除print末尾的默認換行符\n,不換行打印 22 func() 23 print('下載完成')

input('字符串數據類型的參數,提醒用戶你要輸入的內容')

1 python2 2  input() 還原你輸入的值的數據類型 3 raw_input = py3.input 4 python3 5  input() 輸入的全部內容都是字符串類型 6  阻塞: 等待某件事情發生,若是不發生一直等着 7 input的返回值就是用戶輸入的內容 8 輸入的內容 = input('提示')

hash函數

 1 哈希: 可哈希(不可變數據類型),不可哈希(可變數據類型)  2 哈希是一個算法,致使了字典的快速尋址  3 全部的數據要想獲得不變的hash值,必須是一個不可變的數據類型  4 字符串經過hash複雜的算法,獲得一個數字  5 數字算出來就是數字自己  6 print(id('呵呵'))  7 print(hash(12345))  8 結果：  9 2655670439144 10 12345

id函數
獲取到的是內存地址

1 print(id('呵呵')) 2 結果 3 2076687142120

open('文件名')打開一個文件,返回一個文件操做符(文件句柄)

1 操做文件的模式有r,w,a,r+,w+,a+ 共6種 2 每一種方式均可以用二進制的形式操做(rb,wb,ab,rb+,wb+,ab+) 3 encoding指定編碼：默認是操做系統的默認編碼

dir函數: 特殊的需求/研究或者瞭解一個新的數據類型/面向對象以後會介紹新的數據類型

1 print(dir(list)) #查看列表內置方法 2 print(dir(123))

help() 幫助你瞭解python的

1 方式一 2 輸入help() 進入幫助頁面,輸入數據類型,幫助咱們打印具體的幫助信息 3 輸入q退出幫助 4 5 方式二 6 print(help(str)) 7 print(help('abc'))

callable() 判斷某一個變量是否可調用(True/False)

 1 def call(arg):  2 if callable(arg):  3  arg()  4 else:  5 print('參數不符合規定')  6 def func():  7 print('in func')  8 return 1  9 func2 = 1234 10 call(func) 11 call(func2) 12 print(callable(func)) 13 print(callable(func2)) 14 結果 15 in func 16 參數不符合規定 17 True 18 False

bool
int
float
complex 複數

 1 實數 (有理數和無理數) :世界上存在的數  2 虛數 : j  3 某一個數的平方是-1 ,那麼這個數就是一個虛數的基礎單位 j  4 複數 = 實數+虛數 = a+bj  5 選擇題 :(對你的數學有要求的公司都會考)  6  複數不能比較大小  7 共軛複數 : a+bj 和 a-bj是一對共軛複數  8 a+bj 和 a+bJ都是複數  9 c = 1+2J 10 print(type(c)) 11 結果 12 <class 'complex'>

bin二進制沒有2, oct八進制沒8, hex十六進制沒有16

1 逢二進一是二進制 2 逢八進一是十進制 3 逢十六進一是十六進制 4 0 1 2 3 4 5 6 7 8 9 A B C D E F 5 6 a=256 7 print(bin(a)) # 0b100000000 0b表明二進制,100000000 = 256 8 print(oct(a)) # 0o400 0o表明八進制,400 = 256 9 print(hex(a)) # 0x100 十六進制

abs 求絕對值,正數的絕對值是正數,負數的絕對值也是正數

1 print(abs(5)) 2 print(abs(-5))

sum(可迭代的數字集,start),start從哪一個數開始加

 1 print(sum(range(10))) #1+2+3+……9+10  2 print(sum((i**2 for i in range(5)))) #1+4+9+16  3 print(sum((1,2,3,4))) #1+2+3+4  4 print(sum([1,2,3,4]))  5 print(sum((1,2,3,4)))  6 print(sum((1,2,3,4),10)) #1+2+3+4+10  7 print(sum((1,2,3,4),30))  8 結果  9 45 10 30 11 10 12 10 13 10 14 20 15 40

min/max(iterable/*args,key)
key是一個函數的內存地址,key作的事情就是根據你對每一項數據大小的需求來排序

 1 print(min(1,2,3))  2 print(min((1,2,3)))  3 print(min((1,2,3),(4,5,6)))  4 print(min((7,2,3),(7,5,6)))  5 結果  6 1  7 1  8 (1, 2, 3)  9 (7, 2, 3) 10 11 事例1 12 def func(n): # n = 2,3,4,7 13 return n%6 # 2,3,4,1 14 ret = min(2,3,4,7,key = func) 15 print(ret) 16 結果 17 7 18 19 事例2 20 根據每個元組的和來計算max或者min 21 l = [(7,2,3),(4,5,6),(-1,20,5)] 22 print(max(l,key = sum)) # sum((7,2,3)) 23 結果： 24 (-1, 20, 5) 25 26 案例 27 max函數 找到股價最高的那個字典 28 l中的每一項都會做爲參數傳給func 29 max和min的求值會根據func的返回值來排序 30 l = [{'name1':10},{'name2':500}] 31 def max(iter,key = None): # 內置的max iter = [{'name1':10},{'name2':500}] , key = func 32 ret = 0 # ret = 0 33 max_value = 0 # max_value = 0 34 if key: # key = func 35 for i in iter: # iter = [{'name1':10},{'name2':500}] 36 print(key(i),max_value) # i = {'name1':500} key(i) = func({'name1':500}) = 500,max_value = 10 37 if key(i) > max_value: # 500>10 38 max_value = key(i) # max_value = 500 39 ret = i # ret ={'name1':500} 40 return ret 41 42 def func(dic): # {'name1':10} 43 for k in dic: 44 return dic[k] # 10 45 print(max(l,key = func)) 46 print(min(l,key = func)) 47 結果： 48 10 0 49 500 10 50 {'name2': 500} 51 {'name1': 10}

divmod 商餘函數(計算商和餘數)

1 主要應用: 翻頁功能 2 print(divmod(10,3)) 3 print(divmod(7,4)) 4 print(divmod(8,3)) 5 結果 6 (3, 1) 7 (1, 3) 8 (2, 2)

round(小數,保留幾位小數)  小數精確
整數是奇數 -> 正常四捨五入
整數是偶數 -> 五舍六入

 1 2.x(徹底的四捨五入)和3.x(更精準的計算方式)不一樣  2 print(round(2.3258358))  3 print(round(2.3253358,2))  4 print(round(2.3254358,3))  5 print(round(1.5))  6 print(round(2.5))  7 print(round(2.6))  8 結果  9 2 10 2.33 11 2.325 12 2 13 2 14 3

pow(x,y,z=1) 冪運算/冪餘運算 x的y次方%z

 1 print(pow(2,3))  2 print(pow(3,2))  3 print(pow(5,3,2))  4 print(pow(4,2,2))  5 print(pow(4,3,2))  6 結果  7 8  8 9  9 1 10 0 11 0

list
tuple

reversed  返回一個迭代器,節省內存
reversed 不修改原基礎: 不直接返回列表而返回迭代器,爲了避免佔用更多的內存
reverse 是在原基礎上修改: 2000項的列表,不會產生額外的內存佔用

 1 l = [1,2]  2 l.reverse()  3 print(l)  4 結果：  5 [2, 1]  6  7 ret = reversed([1,2,3]) # iterator可迭代的  8 print(ret)  9 print(list(ret)) 10 結果： 11 <list_reverseiterator object at 0x0000024B9ECEEC88> 12 [3, 2, 1] 13 14 lst = ["河南", "四川", "東北", "山東", "上海"] 15 r = reversed(lst) 16 print(list(r)) 17 結果 18 ['上海', '山東', '東北', '四川', '河南'] 19 20 s= "不是上海自來水來自海上" 21 print(s[::-1]) 22 it = reversed(s) 23 s2 = '' 24 for i in it: 25 s2 += i 26 print(s2) 27 結果： 28 上海自來水來自海上是不 29 上海自來水來自海上是不

slice  切片

1 l = [1,2,3,4,5,] 2 ret = slice(1,4) # [1:4] 3 print(l[ret]) 4 等於 5 print(l[1:4]) 6 結果： 7 [2, 3, 4] 8 [2, 3, 4]

format(填充)

 1 print(format('test', '<20'),'alex')  2 print(format('test', '>20'),'alex')  3 print(format('test', '^20'),'alex')  4 結果：  5 test alex  6  test alex  7  test alex  8  9 進制轉換 10 print(format(3, 'b')) # 轉換成二進制 binary 0b11 11 print(format(65, 'c')) # 轉換成unicode字符 ascii 12 print(format(11, 'o')) # 轉換成八進制 0o 13 13 print(format(11, 'x')) # 轉換成十六進制(小寫字母) 14 print(format(11, 'X')) # 轉換成十六進制(大寫字母) 15 print(format(11, 'd')) # 轉換成十進制 16 print(format(11, 'n')) # 和d同樣 17 print(format(11)) # 和d同樣 18 結果 19 11 20 A 21 13 22 b 23 B 24 11 25 11 26 11 27 28 科學計數法 29 print(format(123456789, 'e')) # 科學計數法,默認保留6位小數,表示大的數據 30 print(format(123456789, '.2e')) # 科學計數法,保留2位小數(小寫) 31 print(format(123456789, '0.2E'))# 科學計數法,保留2位小數(大寫) 32 結果 33 1.234568e+08 34 1.23e+08 35 1.23E+08 36 37 浮點計數法 38 print(format(1.23456789, 'f')) # 浮點數計數法,保留6位小數 39 print(format(1.23456789, '0.2f')) # 小浮點數計數法,保留2位小數 40 print(format(1, '0.10f')) # 小浮點數計數法,保留10位小數 41 print(format(1.23456789e+10000, 'F')) # 小浮點數計數法 42 結果 43 1.234568 44 1.23 45 1.0000000000 46 INF #無窮大

bytes 字節
網絡上傳輸的數據: bytes
文件的存儲: wb 寫字節 rb 讀字節 圖片視頻都是字節
網絡 + 文件: wb / rb

 1 str --> bytes  2 print('abc'.encode('utf-8'))  3 print('你好'.encode('utf-8'))  4 bytes --> str  5 b = b'\xe4\xbd\xa0\xe5\xa5\xbd'  6 print(b.decode('utf-8'))  7 結果：  8 b'abc'  9 b'\xe4\xbd\xa0\xe5\xa5\xbd' 10 你好

bytearray
把一個字符串編程一個字節數組,較長的字符串的修改節省內存,修改行爲必須依靠編碼

1 ret = bytearray('abc'*30,encoding='utf-8') # 字節數組 2 print(ret) 3 ret[0] = 102 # assice碼 65A 97a bcdef 你好 您好 4 print(ret)

memoryview 忘記吧

1 print(memoryview(bytes('hello,eva',encoding='utf-8'))) 2 結果： 3 <memory at 0x0000026B858B8048>

ord/chr  字符和編碼之間的轉換

1 print(ord('中')) 2 print(chr(20013)) 3 結果 4 20013 5 中 6 7 查看計算機中全部的字符 8 for i in range(65536): 9 print(chr(i), end= " ")

repr() 還原字符串最官方的效果

 1 轉義字符  2 \n 換行  3 \t tab 製表符  4 \r 回車  5 \" 雙引號  6 \' 單引號  7 \\ \  8 print('hello\\n world')  9 結果 10 hello\n world 11 12 還原字符串最官方的效果 13 print(repr('hello\\n world')) 14 結果 15 'hello\\n world' 16 17 原封不動的顯示字符串 18 print(r'hello\\n wo\trld') 19 結果 20 hello\\n wo\trld

len 計算長度

1 print(len('abc')) 2 結果 3 3

enumerate 枚舉函數

 1 lst = ['姓名','年齡','職業']  2 for i in range(len(lst)):  3 print(i,lst[i])  4 等於  5 for k,v in enumerate(lst):  6 print(k,v)  7 結果  8 0 姓名  9 1 年齡 10 2 職業 11 12 for i in enumerate(['a','b','c'],9): #能夠指定索引發始位置 13 print(i) 14 結果： 15 (9, 'a') 16 (10, 'b') 17 (11, 'c') 18 19 案例 20 goods_lst= [ 21 {'name':'電腦','price':1999}, 22 {'name':'鼠標','price':20}, 23 {'name':'美女','price':20}, 24 ] 25 26 for good in goods_lst: 27 print(goods_lst.index(good)+1,good['name'],good['price']) 28 同等 29 for good in enumerate(goods_lst,1): 30 # print(good) 31 index = good[0] 32 dic = good[1] 33 name = dic['name'] 34 price = dic['price'] 35 print(index,name,price) 36 同等 37 #index,dic = (1, {'name': '電腦', 'price': 1999}) # 解構 38 for index,dic in enumerate(goods_lst,1): 39 print(index,dic['name'],dic['price']) 40 結果： 41 1 電腦 1999 42 2 鼠標 20 43 3 美女 20

all就是bool值(and),參數iterable,只要有一個爲假返回False

1 print(all((1,2,3,True))) 2 print(all((1,2,3,0,True))) 3 print(all((1,2,3,True,[]))) 4 print(all((1,2,3,True,''))) 5 結果 6 True 7 False 8 False 9 False

any就是bool值(or),參數iterable,只要有一個爲真返回True

1 print(any((1,2,3,True))) 2 print(any((1,2,3,0,True))) 3 print(any((1,2,3,True,[]))) 4 print(any(({},False,0,[],''))) 5 結果 6 True 7 True 8 True 9 False

zip 拉鍊函數,返回迭代器-節省內存,水桶效應

 1 a = (1,2,3,4)  2 b = ('a','b','c')  3 c = ['111','222']  4 d = {'k1':'v1','k2':'v2'}  5 ret = zip(a,b,c,d)  6 print(ret)  7  8 for i in ret:  9 print(i) 10 結果： 11 <zip object at 0x0000023ECB077108> 12 (1, 'a', '111', 'k1') 13 (2, 'b', '222', 'k2')

匿名函數
定義
匿名函數的內存地址 = lambda 參數1,參數2 : 返回值/返回值的表達式
調用
接收返回值 = 匿名函數的內存地址(參數)

 1 def定義的函數: 都是有名字的,def後面寫的就是函數名  2 def qqxing():  3 print('qqxing')  4 func = qqxing  5 func2 = qqxing  6 print(qqxing.__name__)  7 print(func.__name__) #內置屬性,經過執行的函數名返回定義的函數名  8 print(func2.__name__)  9 結果 10 qqxing 11 qqxing 12 qqxing 13 14 事例2 15 def exe(func): 16  func() 17 print('執行%s函數了'%func.__name__) 18 def qqxing(): 19 print('qqxing') 20 def wahaha(): 21 print('wahaha') 22 exe(wahaha) 23 exe(qqxing) 24 結果 25 wahaha 26 執行wahaha函數了 27 qqxing 28 執行qqxing函數了 29 30 31 匿名函數沒有名字,統一的名字是:<lambda>,別稱: lambda表達式 32 定義一個很簡單的函數,複雜的函數不要用lambda 33 def func(a,b): 34 return a + b 35 ret = func(1,2) 36 print(ret) 37 38 fn = lambda a,b:a + b 39 ret = fn(5,6) 40 print(ret) 41 print(fn) 42 結果 43 3 44 11 45 <function <lambda> at 0x0000027766AD98C8> 46 使用場景: 配合着sorted,map,filter一塊兒使用 47 48 事例2 49 qqxing = lambda n:n**2 50 print(qqxing.__name__) 51 ret = qqxing(8) 52 print(ret) 53 結果 54 <lambda> 55 64 56 57 事例3 58 f = lambda *args:sum(args) 59 ret = f(1,2,3) 60 print(ret) 61 執行結果 62 6 63 64 事例4 65 dic = {'k1':10,'k2':100,'k3':30} 66 m = max(dic,key=lambda k:dic[k]) 67 print(m) 68 同等 69 def func(k): 70 return dic[k] 71 m = max(dic,key=func) 72 print(m) 73 結果 74 k2 75 76 接收兩個參數,返回較大值(不用max內置函數) 77 f1 = lambda a,b : max(a,b) 78 f2 = lambda a,b : a if a>b else b

sorted() 排序,根據key對應的函數的返回值的大小來排序的
因爲必需要知道後面的值是誰,才能排出順序,因此結果就是排序後的結果而不是可迭代的
按照字符串長度排序
執行流程: 把可迭代對象中的每一項拿出來, 做爲參數傳遞給後面key函數,函數返回數字,根據數字進行排序

 1 lst = ['關穀神奇','呂小布','諾蘭','山口美惠子','易']  2 def func(s):  3 return len(s)  4 ret = sorted(lst,key=func)  5 print(ret)  6 同等  7 print(sorted(lst,key=lambda s:len(s)))  8 結果：  9 ['易', '諾蘭', '呂小布', '關穀神奇', '山口美惠子'] 10 11 事例2 12 lst = [ 13 {"name":"bob", "shengao":150, "tizhong":250}, 14 {"name":"jary", "shengao":158, "tizhong":150}, 15 {"name":"jack", "shengao":177, "tizhong":130}, 16 {"name":"pique", "shengao":165, "tizhong":130}, 17 {"name":"alice", "shengao":160, "tizhong":120}, 18 {"name":"athena", "shengao":183, "tizhong":190} 19 ] 20 按照體重進行排序 21 按照身高進行排序 22 print(sorted(lst,key=lambda dic:dic['tizhong'])) 23 print(sorted(lst,key=lambda dic:dic['shengao'])) 24 25 26 事例3 27 l = [-3,1,2] 28 l.sort() 29 print(l) 30 def func(n): 31 return abs(n) 32 l.sort(key = func) 33 print(l) 34 結果 35 [-3, 1, 2] 36 [1, 2, -3] 37 38 事例4 39 l = [1,-3,2] 40 new_l = sorted(l) #在不改變原列表的狀況下 生成一個新列表 41 print(l) 42 print(new_l) 43 def func(n): 44 return abs(n) 45 ret = sorted(l,key = func) 46 print(ret) 47 結果 48 [1, -3, 2] 49 [-3, 1, 2] 50 [1, 2, -3] 51 52 事例5 53 按照每個字典中商品的價格從高到低排列 54 l = [{'name':'電腦','price':1999},{'name':'鼠標','price':2000}] 55 def func(dic): 56 return dic['price'] 57 l.sort(key=func,reverse=True) 58 print(l) 59 同等 60 new_l = sorted(l,key = func,reverse= True) 61 print(new_l) 62 結果: 63 [{'name': '鼠標', 'price': 2000}, {'name': '電腦', 'price': 1999}]

filter 篩選

 1 過濾掉名字結尾帶剛字的人  2 把可迭代對象打開,把內部元素一個一個的傳遞給前面的函數,由這個函數決定此項是否保留  3 lst = ['旭日陽剛','金毛獅王','李剛','張傑']  4 f = filter(lambda name:not name.endswith('剛'),lst)  5 print(f)  6 print(list(f))  7 結果：  8 <filter object at 0x00000206FCB37208> #可迭代對象  9 ['金毛獅王', '張傑'] 10 11 事例2 12 lst = [ 13 {"name":"bob", "shengao":150, "tizhong":250}, 14 {"name":"jary", "shengao":158, "tizhong":150}, 15 {"name":"jack", "shengao":177, "tizhong":130}, 16 {"name":"pique", "shengao":165, "tizhong":130}, 17 {"name":"alice", "shengao":160, "tizhong":120}, 18 {"name":"athena", "shengao":183, "tizhong":190} 19 ] 20 ret = filter(lambda a:a['tizhong'] < 180,lst) 21 print(list(ret)) 22 結果： 23 [{'name': 'jary', 'shengao': 158, 'tizhong': 150}, {'name': 'jack', 'shengao': 177, 'tizhong': 130}, {'name': 'pique', 'shengao': 165, 'tizhong': 130}, {'name': 'alice', 'shengao': 160, 'tizhong': 120}] 24 25 事例3 26 ret = filter(None,[1,2,3,0,False]) #只保留真的 27 print(ret) 28 for i in ret: 29 print(i) 30 結果： 31 <filter object at 0x000002BD91BCEBA8> 32 1 33 2 34 3 35 36 事例4 37 def func(i): 38 if i % 2 != 0: 39 return True 40 l = [1, 4, 6, 7, 9, 12, 17] 41 for i in filter(func,l): # 迭代l,每個元素做爲參數傳給func,若是func的返回值爲True,那麼l中的這個元素就保留 42 print(i) 43 結果： 44 1 45 7 46 9 47 17 48 49 事例5 50 def func(i): 51 if type(i) is not dict: #判斷i類型不是dict的就返回True 52 return True 53 同等 54 def func(i): 55 return type(i) is not dict 56 57 l = ['sjkdhf',[1,2,3],{},()] #去掉列表中的字典,用filter 58 ret = filter(func,l) 59 print(list(ret)) 60 結果： 61 ['sjkdhf', [1, 2, 3], ()] 62 63 # filter 就像 帶着if條件的列表推導式 64 l = ['sjkdhf',[1,2,3],{},()] 65 print([i for i in l if type(i) is not dict])

map 映射函數
一個迭代器中的每個元素都須要去作同一個操做並返回一個結果組成一個新列表的時候map來處理

 1 lst = ['關穀神奇','呂小布','諾蘭','山口美惠子','易']  2 m = map(lambda s:'姓名:'+s,lst)  3 print(m)  4 for i in m:  5 print(i)  6 結果：  7 <map object at 0x000001B76BAA7208>  8 姓名:關穀神奇  9 姓名:呂小布 10 姓名:諾蘭 11 姓名:山口美惠子 12 姓名:易 13 14 事例2 15 列表中的每個值的平方組成的新列表 16 lst = [1,5,78,12,16] 17 m = map(lambda i:i**2,lst) 18 print(list(m)) 19 同等 20 print([i**2 for i in lst]) 21 同等 22 lst = [1,5,78,12,16] 23 def func(num): 24 return num**2 25 ret = map(func,lst) 26 print(list(ret)) 27 結果： 28 [1, 25, 6084, 144, 256] 29 30 事例3 31 def func(i): 32 return i*'*' 33 ret = map(func,[1,2,3]) 34 print(ret) 35 for i in ret: 36 print(i) 37 結果： 38 <map object at 0x0000024AEBB4ECC0> 39 * 40 ** 41 ***

eval() 有返回值,能夠將字符串數據類型的python代碼執行,經過拼接字符串的方式來執行不一樣的代碼--簡化代碼
eval\exec這個函數,不能直接操做文件當中讀進來的,從網絡上傳進來,用戶輸入的

 1 eval('print(1+2+3+4)') #返回10  2 ret = eval('1+2/3*4')  3 print(ret) #有返回值  4 結果：  5 10  6 3.6666666666666665  7  8 事例2  9 code = input("請輸入你要執行的代碼:") 10 ret = eval(code) 11 print(ret) 12 13 事例3 14 把字符串類型的代碼還原回字典, 列表, 元組 15 s = "{'name':'bob', 'age':18, 'isMan':False}" #字符串 16 ret = eval(s) #側重的有返回值 17 print(ret) 18 print(type(ret)) 19 結果： 20 {'name': 'bob', 'age': 18, 'isMan': False} 21 <class 'dict'> 22 23 事例4 24 with open('測試文件.txt','r',encoding='utf=8')as f: 25 content=f.read() 26 print(content,type(content)) 27 print(eval(content),type(eval(content))) 28 print(eval(content)[0]) 29 結果： 30 [{'id':1},{'name':'alex'}] <class 'str'> 31 [{'id': 1}, {'name': 'alex'}] <class 'list'> 32 {'id': 1} 33 34 將普通字符串'<'轉換成<小於 35 def func(f): 36 if eval('33 %s 20'%f): 37 print('符合條件') 38 else: 39 print('不符合條件') 40 if '>': 41 func('>') 42 if '<': 43 func('<')

exec() 沒有返回值,執行字符串類型的代碼,不能太長,不能太亂

 1 code = input("請輸入你要執行的代碼")  2 exec(code) # 沒有返回值. 想要返回值用eval  3 print(a) # pycharm報錯不必定準  4 結果：  5 請輸入你要執行的代碼a=3+4+9  6 16  7  8 事例2  9 exec('print(1+2+3+4)') # 沒有返回值,想要返回值用eval 10 ret = exec('1+2/3*4') 11 print(ret) #沒有返回值None 12 exec('for i in range(3):print(i)') 13 執行結果 14 10 15 None 16 0 17 1 18 2

compile編譯  
把要執行的代碼先預編譯,可以節省時間工具,經過exec和eval能夠執行咱們的代碼
參數說明:
resource 要執行的代碼,動態代碼⽚片斷
文件名,代碼存放的文件名,當傳入了第一個參數的時候,這個參數給空就能夠了
模式,取值有3個
    exec: 通常放一些流程語句句的時候
    eval: resource只存放一個求值表達式.
    single: resource存放的代碼有交互的時候,mode應爲single

 1 先編譯 python -編譯-> 字節碼(bytes) -解釋-> 機器碼 0101010100101
 2 先總體編譯  3 code1 = 'for i in range(0,3): print (i)' #這是一個字符串代碼  4  5 事例1  6 流程語句使用exec  7 compile1 = compile(code1,'','exec') #預編譯 python-> 字節碼  8 exec (compile1) #解釋  9 exec (compile1) 10 exec(code1) #編譯+解釋 11 結果： 12 0 13 1 14 2 15 0 16 1 17 2 18 0 19 1 20 2 21 22 事例2 23 簡單求值表達式用eval 24 code2 = '1 + 2 + 3 + 4' 25 compile2 = compile(code2,'','eval') 26 print(eval(compile2)) 27 結果： 28 10 29 30 事例3 31 交互語句用single 32 code3 = 'name = input("please input your name:")' 33 compile3 = compile(code3,'','single') 34 exec(compile3) 35 print(name) 36 結果： 37 please input your name:linux 38 linux

 練習題

 1 l3 = [{'name':'alex','age':83},{'name':'wusir','age':38}]  2 # 1.找到年齡大於40的值 filter  3 def func(dic):  4 return dic['age']>40  5 ret = filter(lambda dic:dic['age']>40,l3)  6 print(list(ret))  7 結果：  8 [{'name': 'alex', 'age': 83}]  9 10 2.將列表中的項按照年齡從小到大排序 sorted 11 def func(dic): 12 return dic['age'] 13 ret = sorted(l3,key=lambda dic:dic['age']) 14 print(ret) 15 結果 16 [{'name': 'wusir', 'age': 38}, {'name': 'alex', 'age': 83}] 17 18 3.給列表中的每個人的年齡+1 #lambda 並不能取代函數 19 def func(dic): 20 dic['age'] += 1 21 return dic 22 ret = map(lambda dic:{'name':dic['name'],'age':dic['age']+1},l3) 23 print(list(ret)) 24 結果： 25 [{'name': 'alex', 'age': 84}, {'name': 'wusir', 'age': 39}] 26 27 # 4.給列表中名叫alex的人的年齡+1 三元運算符+字典拼接 28 29 現有兩個元組(('a'),('b')),(('c'),('d'))， 30 請使用python中匿名函數生成列表[{'a':'c'},{'b':'d'}] 31 t1 = (('a'),('b')) 32 t2 = (('c'),('d')) 33 print(t1,t2) 34 ret = zip(t1,t2) 35 def func(tup): 36 return {tup[0]:tup[1]} 37 map(func,ret) 38 iterator1 = map(lambda tup:{tup[0]:tup[1]} ,ret) 39 print(list(iterator1)) 40 執行結果： 41 ('a', 'b') ('c', 'd') 42 [{'a': 'c'}, {'b': 'd'}]