一 三元表達式、列表推導式、生成器表達式
一 三元表達式
name=input('姓名>>: ') res='SB' if name == 'alex' else 'NB' print(res)
二 列表推導式
#一、示例 egg_list=[] for i in range(10): egg_list.append('雞蛋%s' %i) egg_list=['雞蛋%s' %i for i in range(10)] #二、語法 [expression for item1 in iterable1 if condition1 for item2 in iterable2 if condition2 ... for itemN in iterableN if conditionN ] 相似於 res=[] for item1 in iterable1: if condition1: for item2 in iterable2: if condition2 ... for itemN in iterableN: if conditionN: res.append(expression) #三、優勢：方便，改變了編程習慣，可稱之爲聲明式編程
三 生成器表達式
#一、把列表推導式的[]換成()就是生成器表達式 #二、示例：生一筐雞蛋變成給你一隻老母雞，用的時候就下蛋，這也是生成器的特性 >>> chicken=('雞蛋%s' %i for i in range(5)) >>> chicken <generator object <genexpr> at 0x10143f200> >>> next(chicken) '雞蛋0' >>> list(chicken) #因chicken可迭代，於是能夠轉成列表 ['雞蛋1', '雞蛋2', '雞蛋3', '雞蛋4',] #三、優勢：省內存，一次只產生一個值在內存中
四 聲明式編程練習題
一、將names=['egon','alex_sb','wupeiqi','yuanhao']中的名字所有變大寫javascript
二、將names=['egon','alex_sb','wupeiqi','yuanhao']中以sb結尾的名字過濾掉，而後保存剩下的名字長度html
三、求文件a.txt中最長的行的長度（長度按字符個數算，須要使用max函數）java
四、求文件a.txt中總共包含的字符個數？思考爲什麼在第一次以後的n次sum求和獲得的結果爲0？（須要使用sum函數）python
五、思考題算法
with open('a.txt') as f: g=(len(line) for line in f) print(sum(g)) #爲什麼報錯？
六、文件shopping.txt內容以下express
mac,20000,3 lenovo,3000,10 tesla,1000000,10 chicken,200,1
求總共花了多少錢？編程
打印出全部商品的信息，格式爲[{'name':'xxx','price':333,'count':3},...]api
求單價大於10000的商品信息,格式同上數據結構
#題目一 names=['egon','alex_sb','wupeiqi','yuanhao'] names=[name.upper() for name in names] #題目二 names=['egon','alex_sb','wupeiqi','yuanhao'] names=[len(name) for name in names if not name.endswith('sb')] #題目三 with open('a.txt',encoding='utf-8') as f: print(max(len(line) for line in f)) #題目四 with open('a.txt', encoding='utf-8') as f: print(sum(len(line) for line in f)) print(sum(len(line) for line in f)) #求包換換行符在內的文件全部的字符數，爲什麼獲得的值爲0? print(sum(len(line) for line in f)) #求包換換行符在內的文件全部的字符數，爲什麼獲得的值爲0? #題目五（略） #題目六：每次必須從新打開文件或seek到文件開頭，由於迭代完一次就結束了 with open('a.txt',encoding='utf-8') as f: info=[line.split() for line in f] cost=sum(float(unit_price)*int(count) for _,unit_price,count in info) print(cost) with open('a.txt',encoding='utf-8') as f: info=[{ 'name': line.split()[0], 'price': float(line.split()[1]), 'count': int(line.split()[2]), } for line in f] print(info) with open('a.txt',encoding='utf-8') as f: info=[{ 'name': line.split()[0], 'price': float(line.split()[1]), 'count': int(line.split()[2]), } for line in f if float(line.split()[1]) > 10000] print(info)
二 遞歸與二分法
一 遞歸調用的定義
#遞歸調用是函數嵌套調用的一種特殊形式，函數在調用時，直接或間接調用了自身，就是遞歸調用
#直接調用自己 def f1(): print('from f1') f1() f1() #間接調用自己 def f1(): print('from f1') f2() def f2(): print('from f2') f1() f1() # 調用函數會產生局部的名稱空間，佔用內存，由於上述這種調用會無需調用自己，python解釋器的內存管理機制爲了防止其無限制佔用內存，對函數的遞歸調用作了最大的層級限制 四 能夠修改遞歸最大深度 import sys sys.getrecursionlimit() sys.setrecursionlimit(2000) def f1(n): print('from f1',n) f1(n+1) f1(1) 雖然能夠設置，可是由於不是尾遞歸，仍然要保存棧，內存大小必定，不可能無限遞歸，並且無限制地遞歸調用自己是毫無心義的，遞歸應該分爲兩個明確的階段，回溯與遞推
二 遞歸調用應該分爲兩個明確的階段：遞推，回溯
#一、遞歸調用應該包含兩個明確的階段：回溯，遞推 回溯就是從外向裏一層一層遞歸調用下去， 回溯階段必需要有一個明確地結束條件，每進入下一次遞歸時，問題的規模都應該有所減小（不然，單純地重複調用自身是毫無心義的） 遞推就是從裏向外一層一層結束遞歸 #二、示例+圖解。。。 # salary(5)=salary(4)+300 # salary(4)=salary(3)+300 # salary(3)=salary(2)+300 # salary(2)=salary(1)+300 # salary(1)=100 # # salary(n)=salary(n-1)+300 n>1 # salary(1) =100 n=1 def salary(n): if n == 1: return 100 return salary(n-1)+300 print(salary(5))
三 python中的遞歸效率低且沒有尾遞歸優化
#python中的遞歸 python中的遞歸效率低，須要在進入下一次遞歸時保留當前的狀態，在其餘語言中能夠有解決方法：尾遞歸優化，即在函數的最後一步（而非最後一行)調用本身，尾遞歸優化：http://egon09.blog.51cto.com/9161406/1842475 可是python又沒有尾遞歸，且對遞歸層級作了限制 #總結遞歸的使用： 1. 必須有一個明確的結束條件 2. 每次進入更深一層遞歸時，問題規模相比上次遞歸都應有所減小 3. 遞歸效率不高，遞歸層次過多會致使棧溢出（在計算機中，函數調用是經過棧（stack）這種數據結構實現的，每當進入一個函數調用，棧就會加一層棧幀，每當函數返回，棧就會減一層棧幀。因爲棧的大小不是無限的，因此，遞歸調用的次數過多，會致使棧溢出）
四 二分法
想從一個按照從小到大排列的數字列表中找到指定的數字，遍歷的效率過低，用二分法（算法的一種，算法是解決問題的方法）能夠極大低縮小問題規模app
l=[1,2,10,30,33,99,101,200,301,311,402,403,500,900,1000] #從小到大排列的數字列表 def search(n,l): print(l) if len(l) == 0: print('not exists') return mid_index=len(l) // 2 if n > l[mid_index]: #in the right l=l[mid_index+1:] search(n,l) elif n < l[mid_index]: #in the left l=l[:mid_index] search(n,l) else: print('find it') search(3,l)
l=[1,2,10,30,33,99,101,200,301,402] def search(num,l,start=0,stop=len(l)-1): if start <= stop: mid=start+(stop-start)//2 print('start:[%s] stop:[%s] mid:[%s] mid_val:[%s]' %(start,stop,mid,l[mid])) if num > l[mid]: start=mid+1 elif num < l[mid]: stop=mid-1 else: print('find it',mid) return search(num,l,start,stop) else: #若是stop > start則意味着列表實際上已經所有切完，即切爲空 print('not exists') return search(301,l)
三 匿名函數
一 什麼是匿名函數？
匿名就是沒有名字 def func(x,y,z=1): return x+y+z 匿名 lambda x,y,z=1:x+y+z #與函數有相同的做用域，可是匿名意味着引用計數爲0，使用一次就釋放，除非讓其有名字 func=lambda x,y,z=1:x+y+z func(1,2,3) #讓其有名字就沒有意義
二 有名字的函數與匿名函數的對比
#有名函數與匿名函數的對比 有名函數：循環使用，保存了名字，經過名字就能夠重複引用函數功能 匿名函數：一次性使用，隨時隨時定義 應用：max，min，sorted,map,reduce,filter
四 內置函數
#注意：內置函數id()能夠返回一個對象的身份，返回值爲整數。這個整數一般對應與該對象在內存中的位置，但這與python的具體實現有關，不該該做爲對身份的定義，即不夠精準，最精準的仍是之內存地址爲準。is運算符用於比較兩個對象的身份，等號比較兩個對象的值，內置函數type()則返回一個對象的類型 #更多內置函數：https://docs.python.org/3/library/functions.html?highlight=built#ascii
#字符串能夠提供的參數 's' None >>> format('some string','s') 'some string' >>> format('some string') 'some string' #整形數值能夠提供的參數有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None >>> format(3,'b') #轉換成二進制 '11' >>> format(97,'c') #轉換unicode成字符 'a' >>> format(11,'d') #轉換成10進制 '11' >>> format(11,'o') #轉換成8進制 '13' >>> format(11,'x') #轉換成16進制 小寫字母表示 'b' >>> format(11,'X') #轉換成16進制 大寫字母表示 'B' >>> format(11,'n') #和d同樣 '11' >>> format(11) #默認和d同樣 '11' #浮點數能夠提供的參數有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None >>> format(314159267,'e') #科學計數法，默認保留6位小數 '3.141593e+08' >>> format(314159267,'0.2e') #科學計數法，指定保留2位小數 '3.14e+08' >>> format(314159267,'0.2E') #科學計數法，指定保留2位小數，採用大寫E表示 '3.14E+08' >>> format(314159267,'f') #小數點計數法，默認保留6位小數 '314159267.000000' >>> format(3.14159267000,'f') #小數點計數法，默認保留6位小數 '3.141593' >>> format(3.14159267000,'0.8f') #小數點計數法，指定保留8位小數 '3.14159267' >>> format(3.14159267000,'0.10f') #小數點計數法，指定保留10位小數 '3.1415926700' >>> format(3.14e+1000000,'F') #小數點計數法，無窮大轉換成大小字母 'INF' #g的格式化比較特殊，假設p爲格式中指定的保留小數位數，先嚐試採用科學計數法格式化，獲得冪指數exp，若是-4<=exp<p，則採用小數計數法，並保留p-1-exp位小數，不然按小數計數法計數，並按p-1保留小數位數 >>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留0位小數點 '3e-05' >>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留1位小數點 '3.1e-05' >>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留2位小數點 '3.14e-05' >>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留0位小數點，E使用大寫 '3.14E-05' >>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留0位小數點 '3' >>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留1位小數點 '3.1' >>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留2位小數點 '3.14' >>> format(0.00003141566,'.1n') #和g相同 '3e-05' >>> format(0.00003141566,'.3n') #和g相同 '3.14e-05' >>> format(0.00003141566) #和g相同 '3.141566e-05'
字典的運算：最小值，最大值，排序 salaries={ 'egon':3000, 'alex':100000000, 'wupeiqi':10000, 'yuanhao':2000 } 迭代字典，取得是key，於是比較的是key的最大和最小值 >>> max(salaries) 'yuanhao' >>> min(salaries) 'alex' 能夠取values，來比較 >>> max(salaries.values()) >>> min(salaries.values()) 但一般咱們都是想取出，工資最高的那我的名，即比較的是salaries的值，獲得的是鍵 >>> max(salaries,key=lambda k:salary[k]) 'alex' >>> min(salaries,key=lambda k:salary[k]) 'yuanhao' 也能夠經過zip的方式實現 salaries_and_names=zip(salaries.values(),salaries.keys()) 先比較值，值相同則比較鍵 >>> max(salaries_and_names) (100000000, 'alex') salaries_and_names是迭代器，於是只能訪問一次 >>> min(salaries_and_names) Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: min() arg is an empty sequence sorted(iterable，key=None,reverse=False)
#一、語法 # eval(str,[,globasl[,locals]]) # exec(str,[,globasl[,locals]]) #二、區別 #示例一： s='1+2+3' print(eval(s)) #eval用來執行表達式，並返回表達式執行的結果 print(exec(s)) #exec用來執行語句，不會返回任何值 ''' 6 None ''' #示例二： print(eval('1+2+x',{'x':3},{'x':30})) #返回33 print(exec('1+2+x',{'x':3},{'x':30})) #返回None # print(eval('for i in range(10):print(i)')) #語法錯誤，eval不能執行表達式 print(exec('for i in range(10):print(i)'))
compile(str,filename,kind) filename:用於追蹤str來自於哪一個文件，若是不想追蹤就能夠不定義 kind能夠是：single表明一條語句，exec表明一組語句，eval表明一個表達式 s='for i in range(10):print(i)' code=compile(s,'','exec') exec(code) s='1+2+3' code=compile(s,'','eval') eval(code)
五 階段性練習
一、文件內容以下,標題爲:姓名,性別,年紀,薪資
egon male 18 3000
alex male 38 30000
wupeiqi female 28 20000
yuanhao female 28 10000
要求:
從文件中取出每一條記錄放入列表中,
列表的每一個元素都是{'name':'egon','sex':'male','age':18,'salary':3000}的形式
2 根據1獲得的列表,取出薪資最高的人的信息
3 根據1獲得的列表,取出最年輕的人的信息
4 根據1獲得的列表,將每一個人的信息中的名字映射成首字母大寫的形式
5 根據1獲得的列表,過濾掉名字以a開頭的人的信息
6 使用遞歸打印斐波那契數列(前兩個數的和獲得第三個數，如：0 1 1 2 3 4 7...)
7 一個嵌套不少層的列表，如l=［1,2,[3,[4,5,6,[7,8,[9,10,[11,12,13,[14,15]]]]]]］，用遞歸取出全部的值
#1 with open('db.txt') as f: items=(line.split() for line in f) info=[{'name':name,'sex':sex,'age':age,'salary':salary} \ for name,sex,age,salary in items] print(info) #2 print(max(info,key=lambda dic:dic['salary'])) #3 print(min(info,key=lambda dic:dic['age'])) # 4 info_new=map(lambda item:{'name':item['name'].capitalize(), 'sex':item['sex'], 'age':item['age'], 'salary':item['salary']},info) print(list(info_new)) #5 g=filter(lambda item:item['name'].startswith('a'),info) print(list(g)) #6 #非遞歸 def fib(n): a,b=0,1 while a < n: print(a,end=' ') a,b=b,a+b print() fib(10) #遞歸 def fib(a,b,stop): if a > stop: return print(a,end=' ') fib(b,a+b,stop) fib(0,1,10) #7 l=[1,2,[3,[4,5,6,[7,8,[9,10,[11,12,13,[14,15]]]]]]] def get(seq): for item in seq: if type(item) is list: get(item) else: print(item) get(l)