當前位置:首頁 » 編程語言 » python的partial

python的partial

發布時間: 2023-01-06 08:32:54

python 有哪些好玩的語法糖

當然是函數式那一套黑魔法啦,且聽我細細道來。
lambda表達式
也就是匿名函數。
用法:lambda 參數列表 : 返回值
例:
+1函數
f=lambda x:x+1

max函數(條件語句的寫法如下)
f_max=lambda x,y:x if x>y else y

上述定義的函數與用def定義的函數沒有區別,而且左邊的f=在某些情況下並不是必要的。
filter,map,rece
filter函數接受兩個參數,第一個是過濾函數,第二個是可遍歷的對象,用於選擇出所有滿足過濾條件的元素,不同版本的filter的返回值稍有區別,我用的是python3.5,filter返回的是經過過濾的可遍歷對象。
例:
去除小寫字母
s=filter(lambda x:not str(x).islower(),"asdasfAsfBsdfC")
for ch in s:
print(ch)

map函數接受的參數類型與filter類似,它用於把函數作用於可遍歷對象的每一個元素。類似於數學中映射的概念。
例:
求y=2x+1(偷偷用了一下range函數生成定義域)
s=map(lambda x:2*x+1,range(6))
for x in s:
print(x)

rece函數對每個元素作累計操作,它接受的第一個參數必須是有兩個參數的函數。
例:
求和
from functools import rece
s=rece(lambda x,y:x+y,range(1,6))
print(s)

求乘積(第三個可選參數表示累計變數的初值)
from functools import rece
s=rece(lambda x,y:x*y,range(1,6),1)
print(s)

柯里化(curry)函數
如果一個函數需要2個參數,而你只傳入一個參數,那麼你就可以得到一個柯里化的函數,這是函數式編程語言的重要特性之一,遺憾的是,python並不能在語法層面支持柯里化調用,但它在庫中提供了介面。
例:
*3函數
f_mul=lambda x,y:x*y
from functools import partial
mul3=partial(f_mul,3)
print(mul3(1))
print(mul3(6))

打包與解包
有點類似於函數式中的模式匹配,略牽強。
t=(1,2,3)
x,y,z=t

列表生成式
這個也有點牽強,不知道嚴格意義上講屬不屬於函數式風格。
例:生成奇數序列
l=[2*x+1 for x in range(10)]
for i in l:
print(i)

最後來一個彩蛋(以前某答主提到的用調分函數來美顏的演算法,忘了出處了,侵刪)
from PIL import Image
from math import sqrt

im = Image.open("a.jpg")
ret= im.convert(mode="RGB")
ret = ret.point(lambda x:sqrt(x)*sqrt(255))
ret.save("b.jpg")

❷ 這個python題目怎麼寫

無意間,看到這么一道Python面試題:以下代碼將輸出什麼?

def testFun:
temp = [lambda x : i*x for i in range(4)]
return temp
for everyLambda in testFun:
print (everyLambda(2))

腦中默默一想,這還用說么,肯定是:

0
2
4
6

最後一看答案,竟然是:

6
6
6
6

於是帶著懷疑的心態(其實是不服輸,不認錯),打開編輯器,快速一敲,果然是:
懷疑了人生半天,本來還想黑,WTF Python…然後才想通是自己太生疏......
最後發現原因竟是:Python 的閉包的後期綁定導致的 late binding。
這意味著在閉包中的變數是在內部函數被調用的時候被查找,所以當任何testFun 返回的函數被調用,i 的值是在它被調用時的周圍作用域中查找。
也就是說無論哪個返回的函數被調用,for 循環都已經完成了,i 最後的值是 3,因此,每個返回的函數 testFun 的值都是 3。
因此一個等於 2 的值被傳遞進以上代碼,它們將返回一個值 6 (比如:3 x 2)。
究竟如何才能實現出這樣的結果呢?

0
2
4
6

想了想,若能立即綁定參數,或者直接不用閉包總該行吧,用另一種方式避免 i 的改寫。
回憶了之前所學知識,最後醞釀出了四種解決方案。
第一種:創建一個閉包,通過使用默認參數立即綁定它的參數

def testFun:
temp = [lambda x, i=i: i * x for i in range(4)]
return temp
for everyLambda in testFun:
print(everyLambda(2))

第二種:使用functools.partial 函數,把函數的某些參數(不管有沒有默認值)給固定住(也就是相當於設置默認值)

from functools import partial
from operator import mul
def testFun:
return [partial(mul, i) for i in range(4)]
for everyLambda in testFun:
print(everyLambda(2))

第三種:優雅的寫法,直接用生成器

def testFun:
return (lambda x, i=i: i * x for i in range(4))
for everyLambda in testFun:
print(everyLambda(2))

第四種:利用yield的惰性求值的思想

def testFun:
for i in range(4):
yield lambda x: i * x
for everyLambda in testFun:
print(everyLambda(2))

最終運行結果:
有了解決方案後,又陷入了懷疑自己,這個題目究竟是考察的是什麼?是在考面試者閉包相關知識以及Python 的閉包的後期綁定問題么?
若將題目改成:以下代碼輸出的結果是(0,2,4,6)么?如果不是,你將會怎麼做,讓它變成(0,2,4,6)?這樣會不會更有意思點呢?歡迎大家出妙招,看究竟有多少招?(哈哈哈!!!)

❸ python--並行計算

python能夠應用並行計算的模塊有多個multiprocessing、pathos等。其中multiprocessing模塊應用的較多,但對於數據挖掘場景來說,pathos模塊更實用,尤其允許輸入多個可變參數非常簡單實用。

本文總結整理了常見的並行計算場景,編寫parallel.py模塊,主要利用pathos模塊實現,可以實現單變數並行、多變數並行、並行嵌套等功能。通過tdqm模塊增加了進度條,可以顯示計算進度等信息,通過functools模塊中的partial函數將靜態參數凍結,以適應並行框架。
parallel.py

函數parallel的參數定義順序需要注意: 必選參數--任意位置參數--默認參數--任意關鍵字參數

定義另一個parallel_main.py模塊,用來展示各個場景下並行計算結果。
parallel_main.py

parallel函數使用注意點:

❹ python中兩個括弧怎麼做

#python3.3
defmake_adder(addend):
defadder(augend):
returnaugend+addend
returnadder

print(make_adder(10)(20))

參考:http://blog.csdn.net/wyabc1986/article/details/7399104

❺ 什麼是python的偏函數

偏函數是將所要承載的函數作為partial()函數的第一個參數,原函數的各個參數依次作為partial()函數後續的參數,除非使用關鍵字參數。
通過語言描述可能無法理解偏函數是怎麼使用的,那麼就舉一個常見的例子來說明。在這個例子里,我們實現了一個取余函數,對於整數100,取得對於不同數m的100%m的余數。

❻ python跨模塊調用函數的問題

有什麼辦法省略掉那些被調用函數的參數?

也就是func2隻想在調用是傳入一個c。

那麼func2在定義的時候必須喂飽func1,也就是func2在調用 func1時,當前作用域中要有a,b。

明顯圖中是沒有做到的,沒有實際ab


b可以試試在這個文件中直接定義 ab兩個變數,那麼在第三個文件中引入 func2,就可以直接傳c給func2了,因為ab已經在上一步被配置好。

❼ 風變編程的Python課程學完效果如何

一、Python簡介

Python是一種用來編寫應用程序的高級程序設計語言,TIOBE程序語言排行榜2015年12月的排名如下:

Python實現強勢逆襲,而且我相信,隨著時間的推移,國內Python語言未來前景也是一片向好。

Python的特點是優雅簡單,易學易用(雖然我感覺還是有一些概念不容易理解),Python的哲學是盡量用最少的,最簡單易懂的代碼實現需要的功能。Python適宜於開發網路應用,腳本寫作,日常簡單小工具等等。Python的缺點是效率較低,但是在大量的場合效率卻不是那麼重要或者說Python不是其性能瓶頸,所以不要太在意。其次是2.x-3.x的過渡使得許多3.x還缺少很多2.x下的模塊,不過也在完善中。其次就是源代碼無法加密,發布Python程序其實就是發布源代碼。

二、基礎語法要點

1.如果一個字元串中有許多需要轉義的字元,而又不想寫那麼多'',那麼可以用 r'...' 表示 '...'內的內容不轉義。

2.Python可用'''...'''來表示多行內容,如:

123456

>>>print('''line1line2line3''')line1line2line3

3.Python的邏輯運算and, or, not 分別對應C語言中的&&, ||, !.

4.Python的整數與浮點數大小都沒有范圍。

5.Python中除法有兩種: '/'除出來必是浮點數, '//'除出來是整數,即地板除。

6.Python中一切皆引用。每個對象都有一個引用計數器(內部跟蹤變數)進行跟蹤,引用計數值表示該對象有多少個引用,當初次產生賦給變數時,引用計數為1,其後沒進行下列行為中的任意一種都會增加引用計數:

123

賦值: a=b用作函數參數傳遞: func(a)成為容器對象的一個元素: lis=[1,2,a]

以下任意一種行為都會減少引用計數:

1234

del銷毀:dela變數另賦給其他對象:a=False對象從容器中刪除: lis.remove(a)身在的容器被銷毀:dellis

7.深拷貝與淺拷貝的概念與對比,有點復雜,看這篇文章

8.list,tuple和dict,set

list:為列表,是一個有序集合,類似於數組但又比數組功能強大,可以隨時append,pop元素,下標從0開始,且下標為加n模n制,即lis[-1] = lis[len-1],下標范圍[-len,len-1].

tuple:為元組,類似於list,但list為可變類型,而tuple不可變,即沒有append,pop等函數。一個建議是為了安全起見,能用tuple代替list盡量用tuple。如果tuple只有一個元素,要寫成如(1,)以避免歧義。

dict:字典類型,存放key-value鍵值對,可以根據key迅速地找出value,當然,key必須是不可變類型,如下是錯誤的:

12345

>>> dic={[1,2]:'value'}Traceback (most recent call last):File"<pyshell#10>", line1,in<mole>dic={[1,2]:'value'}TypeError: unhashabletype:'list'

list與dict的優劣對比:

1234567

dict:1.插入,查找速度快,跟key的數目無關2.需佔用大量內存,內存浪費嚴重list:1.插入,查找速度慢,O(n)的復雜度,隨元素個數增加而增加2.佔用內存小

dict內部存放的順序和key放入的順序是沒有關系的

set:set與dict類似,相當於只有key沒有value的dict,每個key不同,set間有 &, | 等操作對應集合的交,並操作。

三、函數

1.函數是對象,函數名即是指向對應函數對象的引用,所以可以將函數名賦給一個變數,相當於給函數起一個『別名』。

123

>>> mmm=max>>> mmm(1,2,3)3

2.Python函數可以返回」多個值「,之所以打引號,是因為實際上返回的多個值拼成了一個元組,返回這個元組。

3.定義默認參數需要牢記:默認參數必須指向不變對象。否則第一次調用和第二次調用結果會不一樣,因為可變的默認參數調用後改變了。

4.可變參數:傳入的參數個數是可變的,可以是0個或多個。可變參數會將你傳入的參數自動組裝為一個tuple。在你傳入的list或tuple名字前加一個 * 即說明傳入的是可變參數。習慣寫法為*args。

5.關鍵字參數:傳入0個或多個含參數名的參數,這些參數被自動組裝成一個dict。習慣寫法**kw,如**a表示把a中所有的鍵值對以關鍵字參數的形式傳入kw,獲得一個dict,這個dict是a的一份拷貝,對kw改動不會傳遞到a

6.命名關鍵字在函數定義中跟在一個*分割符後,如

12

deffunc(a,b,*,c,d):pass

c,d為命名關鍵字參數,可以限制調用者可以傳入的參數名,同時可以提供默認值。

7.參數定義順序:必選參數,默認參數,可變參數/命名關鍵字參數,關鍵字參數。

8.切片操作格式為lis[首下標:尾下標:間隔],如果都不填,即lis[::]則代表整個容器lis

9.用圓括弧()括起來一個列表生成式創建一個生成器generator,generator保存生成演算法,我們可以用next(g)取得生成器g的下一個返回值。生成器的好處就是我們不需要提前生成所有列表元素,而是需要時再生成,這在某些情況下可以節省許多內存。演算法也可以不是列表生成式而是自定義函數,只需在函數定義中包含yield關鍵字。

10.map()和rece(): 二者都是高階函數。map()接收兩個參數,一個是函數,一個是Iterable序列,map將傳入的函數依次作用在序列每一個元素上,並把結果作為新的Iterator返回。rece()類似累積計算版的map(),把一個函數作用在一個序列上,每次接收兩個參數,將結果繼續與序列的下一個元素做累積計算。

利用map和rece編寫一個str2float函數,如把字元串'123.456'轉換成浮點數123.456:

123456789101112131415

(s):deff1(x,y):returnx*10+ydefchar2num(s):return{'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}[s]deff2(x,y):returnx*0.1+ya,b=s.split('.')print('a=',a)print('b=',b)returnrece(f1,map(char2num,a))+0.1*rece(f2,map(char2num,b[::-1]))print('str2float('123.456') =', str2float('123.456'))

11.fliter()函數過濾序列,類似於map()作用於每一元素,根據返回值是True或者False決定舍棄還是保留該元素。函數返回一個Iterator。

12.sorted()函數可實現排序,類似於C++庫中的sort()函數,但是比其更加簡潔,語法為sorted(lis,key=func,reverse=T/F)

key函數可實現自定義的排序規則,reverse表示升序還是降序。

13.一個函數可以返回一個函數,但是返回時該函數並未執行,所以返回函數中不要引用任何可能發生變化的變數,否則會出現邏輯錯誤。

14.裝飾器(decorator): 當需要增強函數的功能卻不希望修改函數本身,那麼可以採用裝飾器這種運行時動態增加功能的方式,增加的功能卸載裝飾器函數中。如在執行前後列印'begin call'和'end call',可以這樣做:

12345678910111213141516

importfunctoolsdeflog(func):@functools.wraps(func)#為了校正函數簽名,最好寫上defwrapper(*args,**kw):print('begin call')f=func(*args,**kw)print('end call')returnfreturnwrapper@logdefhah():print('hahahaha')hah()

123

begin callhahahahaend call

15.偏函數: functools.partial(),作用是將一個函數的某些參數固定住,作為新函數的參數,即固定住該參數,返回一個新函數,使調用更簡單。

四、面向對象編程

1.Python實例變數可以自由地綁定任何屬性

2.為了不讓內部屬性不被外部訪問,在屬性的名稱前加上兩個下劃線__,這樣就變成了一個私有變數(private),注意,不能直接訪問不代表一定不能訪問,事實上,加雙下劃線後Python就會將其改名為『_class名__name』,所以還是可以這樣來訪問這個『私有』變數。

3.對於靜態語言,如果要求傳入一個class類型的對象,那麼傳入的對象必須是class類型或者其子類,否則將無法調用class中的方法,而Python這樣的動態語言有『鴨子類型』一說,即不一定要傳入class類型或其子類,而只要保證傳入的對象中有要使用的方法即可。

4.如果想要限制實例可以綁定的屬性,那麼在定義class時定義一個__slots__變數即可,例如:

12

classStudent(object):__slots__=(『name』,』age』)

注意,__slots__限制的屬性對當前類實例起完全限製作用,且與子類共同定義其__slots__,也就是說子類可以定義自己的__slots__,子類實例允許定義的屬性就是自身的__slots__加上父類的__slots__,即並集。

5.@ property裝飾器可以使一個getter方法變成屬性,如果方法名為me,那麼@me.setter裝飾器則可使一個setter方法變成屬性。這樣可以使代碼更簡短,同時可對參數進行必要的檢查。

6.通過多重繼承,可使子類擁有多個父類的所有功能。

7.在類中__call__方法可使實例對象像函數那樣直接調用,作用即是該方法定義的過程。

8.ORM(Object Relational Mapping 對象關系映射),就是把關系資料庫的一行映射為一個對象,也就是一個類對應一個表。ORM的實現需要通過metaclass元類修改類的定義。元類可以改變類創建時的行為。

五、調試

1.Python調試方法:

(1)直接列印

(2)斷言

(3)pdb

(4)IDE

六、IO編程

1.序列化: 把變數從內存中變成可存儲或傳輸的過程稱之為序列化。Python用pickle模塊實現序列化。序列化之後,就可以把序列化後的內容存儲到磁碟上或者通過網路進行傳輸。pickle.mps()將對象序列化成一個bytes,而pickle.loads()可以根據bytes反序列化出對象。

2.pickle雖好,但是它專為Python而生,所以要在不同語言間傳遞對象,最好還是xml或者json,而json表示格式是一個字元串,更易讀取,且比xml快,所以更加適宜於對象序列化。Python內置了json模塊,相應方法仍然是mps()和loads()。

3.但是在默認情況下,有些對象是無法序列化的,所以我們有時還需要定製轉換方法,告訴json該如何將某類對象轉換成可序列為json格式的{}對象。如下即是一個轉換方法:

123456

defmantodict(std):return{'name': std.name,'age': std.age,'id': std.id}

七、進程與線程

1.Python用mutiprocessing模塊來實現多進程。

2.如果要大量創建子進程,可以使用進程池:

1

frommultiprocessingimportPool

示例如下:

12345678

....p=Pool(4)foriinrange(5):p.apply_async(long_time_task, args=(i,))print('Waiting for all subprocesses done...')p.close()p.join()print('All subprocesses done.')

要使用進程池需新建Pool對象,對Pool對象調用join()使等待池中所有子進程運行完畢,調用join()方法之前必須調用close(),且此後無法再新加子進程。

3.使用subprocess模塊可以方便的啟動並管理一個子進程,控制其輸入輸出。

4.進程間通信使用Queue,Pipes實現。

5.threading模塊管理線程。threading.lock()創建線程鎖,防止同時訪問互斥資源造成的錯誤,示例如下:

1234567

lock=threading.Lock()...lock.acquire()...change(mutex)...lock.release()

6.ThreadLocal可以解決參數在一個線程中各個函數之間互相傳遞的問題。

7.managers模塊實現分布式進程。

八、正則表達式與常用內建模塊

1.re模塊進行正則表達式編譯和匹配,如果該表達式需要匹配很多次,那麼最好進行編譯從而大大節省時間。

正則表達式匹配郵箱例子:

12345678910

importrehah=re.compile('[0-9a-zA-Z]+[.[0-9a-zA-Z]+]*@[0-9a-zA-Z]+.[a-z]{2,3}')print(hah.match('[email protected]').group())print(hah.match('[email protected]').group())i=1whilei <10:r=input('請輸入郵箱:')print(hah.match(r).group())i=i+1

2.datetime模塊進行日期和時間的處理,每一個時間對應一個timestamp,我們把1970年1月1日 00:00:00 UTC+00:00時區的時刻稱為epoch time,記為0(1970年以前的時間timestamp為負數),當前時間就是相對於epoch time的秒數,稱為timestamp。字元串和datetime也可以相互轉換,採用strptime()方法,字元串轉換為datetime時需要設定一個識別格式,其中

1

%Y-%m-%d%H:%M:%S

分別表示年-月-日 時-分-秒。

從datetime得出月份,星期等字元串用strftime()方法,其中:

1

%a,%b%d%H:%M

分別表示星期, 月份 日期 時:分。

示例:

12345678910

fromdatetimeimportdatetimer='2015-11-23 12:01'dt=datetime.strptime(r,'%Y-%m-%d %H:%M')print(dt)week=dt.strftime('%a %b %d, %H:%M')print(week)2015-11-2312:01:00Mon Nov23,12:01

3.collections是Python內建的一個集合模塊,提供了許多有用的集合類。

4.Base64是一種任意二進制到文本字元串的編碼方法,常用於在URL、Cookie、網頁中傳輸少量二進制數據。

5.struct模塊用來解決bytes和其他二進制數據類型的轉換。

6.Python的hashlib提供了常見的哈希演算法,如MD5,SHA1等等。hashlib實現簡單登錄:

importhashlibdb={'michael':'','bob':'','alice':''}defget_md5(ostr):md5=hashlib.md5()md5.update(ostr.encode())returnmd5.hexdigest()deflogin(user, password):r=get_md5(password)fornameindb:ifdb[name]==r:returnTruereturnFalseprint(login('bob','abc999'))True

7.Python的內建模塊itertools提供了非常有用的用於操作迭代對象的函數。

8.urllib提供了一系列用於操作URL的功能。如GET,POST...

9.PIL(Python Imaging Library Python圖像庫)是一個強大的圖像處理標准庫,功能強大卻又簡單易用。現在的名字叫做Pillow。可以如下安裝Pillow:

1

pip3 install pillow

從下面生成數字驗證碼的程序可以窺其一斑:

九、網路編程和電子郵件

1.網路編程主要是TCP和UDP的編程,示例見【Python網路編程】利用Python進行TCP、UDP套接字編程

2.SMTP是發送郵件的協議,Python內置對SMTP的支持,可以發送純文本郵件、HTML郵件以及帶附件的郵件。Python對SMTP支持有smtplib和email兩個模塊,email負責構造郵件,smtplib負責發送郵件。Python內置一個poplib模塊,實現了POP3協議,可以直接用來收郵件。由於現在絕大多數大型郵件服務商都採取了反垃圾郵件措施,所以這部分的簡單實驗並沒有成功,還需進一步研究,等遇到具體情況再說。

3.Python內嵌了sqlite資料庫,還可以自行安裝連接mysql,MySQL是當前最流行的開源資料庫,在行業內有著廣泛的應用。

十、Web開發和非同步IO

1.WSGI(Web Server Gateway Interface) 伺服器網關介面。

2.Python web 開發框架:

-Flask:流行的Web框架

-Django:全能型Web框架

-web.py:一個小巧的Web框架

-Bottle:和Flask類似的Web框架

-Tornado:Facebook的開源非同步Web框架

3.協程

❽ Python-嵌套函數中的局部變數

嵌套函數在執行時(而不是在定義時)從父范圍中查找變數。
編譯函數主體,然後驗證「自由」變數(未在函數本身中通過賦值定義),然後將其作為閉包單元綁定到函數,並且代碼使用索引引用每個單元格。pet_function因此具有一個自由變數(cage),然後將其通過一個閉合單元引用,索引為0的閉合本身指向局部變數cage在get_petters功能。
當你實際調用該函數時,該閉包將用於在你調用該函數時查看cage周圍作用域中的值。問題就在這里。在你調用函數時,該函數已經完成了對其結果的計算。將在在執行過程中的一些點局部變數分配各的,和字元串,但在功能的結束,包含了最後一個值。因此,當你調用每個動態返回的函數時,就會得到列印的值。get_petterscage'cow''dog''cat'cage'cat''cat'
解決方法是不依賴閉包。你可以改用部分函數,創建新的函數作用域或將變數綁定為關鍵字parameter的默認值。
部分函數示例,使用functools.partial():
from functools import partialdef pet_function(cage=None):
print "Mary pets the " + cage.animal + "."yield (animal, partial(gotimes, partial(pet_function, cage=cage)))

創建一個新的范圍示例:
def scoped_cage(cage=None):
def pet_function():
print "Mary pets the " + cage.animal + "."
return pet_functionyield (animal, partial(gotimes, scoped_cage(cage)))

將變數綁定為關鍵字參數的默認值:
def pet_function(cage=cage):
print "Mary pets the " + cage.animal + "."yield (animal, partial(gotimes, pet_function))

無需scoped_cage在循環中定義函數,編譯僅進行一次,而不是在循環的每次迭代中進行。

❾ 一文讀懂Python 高階函數

將函數作為參數傳入,這樣的函數稱為高階函數。 函數式編程就是指這種高度抽象的編程範式。
變數可以指向函數,函數的參數能接收變數,那麼一個函數就可以接收另一個函數作為參數,這種函數就稱之為高階函數。如下所示:


map(fun, lst),將傳入的函數變數func作用到lst變數的每個元素中,並將結果組成新的列表返回。


定義一個匿名函數並調用,定義格式如-->lambda arg1,arg2…:表達式


rece把一個函數作用在一個序列[x1, x2, x3, …]上,這個函數必須接收兩個參數,rece把結果繼續和序列的下一個元素做累積計算。


filter() 函數用於過濾序列,過濾掉不符合條件的元素,返回由符合條件元素組成的新列表。





閉包的定義?閉包本質上就是一個函數
如何創建閉包?

如何使用閉包?典型的使用場景是裝飾器的使用。
global與nonlocal的區別:

簡單的使用如下:


偏函數主要輔助原函數,作用其實和原函數差不多,不同的是,我們要多次調用原函數的時候,有些參數,我們需要多次手動的去提供值。
而偏函數便可簡化這些操作,減少函數調用,主要是將一個或多個參數預先賦值,以便函數能用更少的參數進行調用。

我們再來看一下偏函數的定義:
類func = functools.partial(func, *args, **keywords)
我們可以看到,partial 一定接受三個參數,從之前的例子,我們也能大概知道這三個參數的作用。簡單介紹下:


總結
本文是對Python 高階函數相關知識的分享,主題內容總結如下:

❿ Python 有什麼奇技淫巧

Python奇技淫巧
當發布python第三方package時, 並不希望代碼中所有的函數或者class可以被外部import, 在 __init__.py 中添加 __all__ 屬性,

該list中填寫可以import的類或者函數名, 可以起到限制的import的作用, 防止外部import其他函數或者類

#!/usr/bin/env python
# -*- coding: utf-8 -*-

frombaseimportAPIBase
fromclientimportClient
fromdecoratorimportinterface, export, stream
fromserverimportServer
fromstorageimportStorage
fromutilimport(LogFormatter, disable_logging_to_stderr,
enable_logging_to_kids, info)

__all__ = ['APIBase','Client','LogFormatter','Server',
'Storage','disable_logging_to_stderr','enable_logging_to_kids',
'export','info','interface','stream']

with的魔力

with語句需要支持 上下文管理協議的對象 , 上下文管理協議包含 __enter__ 和 __exit__ 兩個方法. with語句建立運行時上下文需要通過這兩個方法執行 進入和退出 操作.

其中 上下文表達式 是跟在with之後的表達式, 該表示大返回一個上下文管理對象
# 常見with使用場景
withopen("test.txt","r")asmy_file:# 注意, 是__enter__()方法的返回值賦值給了my_file,
forlineinmy_file:
print line

詳細原理可以查看這篇文章, 淺談 Python 的 with 語句

知道具體原理, 我們可以自定義支持上下文管理協議的類, 類中實現 __enter__ 和 __exit__ 方法
#!/usr/bin/env python
# -*- coding: utf-8 -*-

classMyWith(object):

def__init__(self):
print"__init__ method"

def__enter__(self):
print"__enter__ method"
returnself# 返回對象給as後的變數

def__exit__(self, exc_type, exc_value, exc_traceback):
print"__exit__ method"
ifexc_tracebackisNone:
print"Exited without Exception"
returnTrue
else:
print"Exited with Exception"
returnFalse

deftest_with():
withMyWith()asmy_with:
print"running my_with"
print"------分割線-----"
withMyWith()asmy_with:
print"running before Exception"
raiseException
print"running after Exception"

if__name__ =='__main__':
test_with()

執行結果如下:
__init__ method
__enter__ method
running my_with
__exit__ method
ExitedwithoutException
------分割線-----
__init__ method
__enter__ method
running before Exception
__exit__ method
ExitedwithException
Traceback(most recent call last):
File"bin/python", line34,in<mole>
exec(compile(__file__f.read(), __file__, "exec"))
File"test_with.py", line33,in<mole>
test_with()
File"test_with.py", line28,intest_with
raiseException
Exception

證明了會先執行 __enter__ 方法, 然後調用with內的邏輯, 最後執行 __exit__ 做退出處理, 並且, 即使出現異常也能正常退出

filter的用法

相對 filter 而言, map和rece使用的會更頻繁一些, filter 正如其名字, 按照某種規則 過濾 掉一些元素
#!/usr/bin/env python
# -*- coding: utf-8 -*-

lst = [1,2,3,4,5,6]
# 所有奇數都會返回True, 偶數會返回False被過濾掉
print filter(lambda x: x % 2!=0, lst)

#輸出結果
[1,3,5]

一行作判斷

當條件滿足時, 返回的為等號後面的變數, 否則返回else後語句
lst = [1,2,3]
new_lst = lst[0]iflstisnotNoneelseNone
printnew_lst

# 列印結果
1

裝飾器之單例

使用裝飾器實現簡單的單例模式

# 單例裝飾器
defsingleton(cls):
instances = dict() # 初始為空
def_singleton(*args, **kwargs):
ifclsnotininstances:#如果不存在, 則創建並放入字典
instances[cls] = cls(*args, **kwargs)
returninstances[cls]
return_singleton

@singleton
classTest(object):
pass

if__name__ =='__main__':
t1 = Test()
t2 = Test()
# 兩者具有相同的地址
printt1, t2

staticmethod裝飾器

類中兩種常用的裝飾, 首先區分一下他們

普通成員函數, 其中第一個隱式參數為 對象
classmethod裝飾器 , 類方法(給人感覺非常類似於OC中的類方法), 其中第一個隱式參數為 類
staticmethod裝飾器 , 沒有任何隱式參數. python中的靜態方法類似與C++中的靜態方法
#!/usr/bin/env python
# -*- coding: utf-8 -*-

classA(object):

# 普通成員函數
deffoo(self, x):
print "executing foo(%s, %s)"% (self, x)

@classmethod# 使用classmethod進行裝飾
defclass_foo(cls, x):
print "executing class_foo(%s, %s)"% (cls, x)

@staticmethod# 使用staticmethod進行裝飾
defstatic_foo(x):
print "executing static_foo(%s)"% x

deftest_three_method():
obj = A()
# 直接調用噗通的成員方法
obj.foo("para")# 此處obj對象作為成員函數的隱式參數, 就是self
obj.class_foo("para")# 此處類作為隱式參數被傳入, 就是cls
A.class_foo("para")#更直接的類方法調用
obj.static_foo("para")# 靜態方法並沒有任何隱式參數, 但是要通過對象或者類進行調用
A.static_foo("para")

if__name__=='__main__':
test_three_method()

# 函數輸出
executing foo(<__main__.Aobject at0x100ba4e10>, para)
executing class_foo(<class'__main__.A'>,para)
executing class_foo(<class'__main__.A'>,para)
executing static_foo(para)
executing static_foo(para)

property裝飾器

定義私有類屬性

將 property 與裝飾器結合實現屬性私有化( 更簡單安全的實現get和set方法 )
#python內建函數
property(fget=None, fset=None, fdel=None, doc=None)

fget 是獲取屬性的值的函數, fset 是設置屬性值的函數, fdel 是刪除屬性的函數, doc 是一個字元串(like a comment).從實現來看,這些參數都是可選的

property有三個方法 getter() , setter() 和 delete() 來指定fget, fset和fdel。 這表示以下這行
classStudent(object):

@property #相當於property.getter(score) 或者property(score)
defscore(self):
returnself._score

@score.setter #相當於score = property.setter(score)
defscore(self, value):
ifnotisinstance(value, int):
raiseValueError('score must be an integer!')
ifvalue <0orvalue >100:
raiseValueError('score must between 0 ~ 100!')
self._score = value

iter魔法

通過yield和 __iter__ 的結合, 我們可以把一個對象變成可迭代的
通過 __str__ 的重寫, 可以直接通過想要的形式列印對象
#!/usr/bin/env python
# -*- coding: utf-8 -*-

classTestIter(object):

def__init__(self):
self.lst = [1,2,3,4,5]

defread(self):
foreleinxrange(len(self.lst)):
yieldele

def__iter__(self):
returnself.read()

def__str__(self):
return','.join(map(str, self.lst))

__repr__ = __str__

deftest_iter():
obj = TestIter()
fornuminobj:
printnum
printobj

if__name__ =='__main__':
test_iter()

神奇partial

partial使用上很像C++中仿函數(函數對象).

在stackoverflow給出了類似與partial的運行方式
defpartial(func, *part_args):
defwrapper(*extra_args):
args = list(part_args)
args.extend(extra_args)
returnfunc(*args)

returnwrapper

利用用閉包的特性綁定預先綁定一些函數參數, 返回一個可調用的變數, 直到真正的調用執行
#!/usr/bin/env python
# -*- coding: utf-8 -*-

fromfunctoolsimportpartial

defsum(a, b):
returna + b

deftest_partial():
fun = partial(sum, 2)# 事先綁定一個參數, fun成為一個只需要一個參數的可調用變數
printfun(3)# 實現執行的即是sum(2, 3)

if__name__ =='__main__':
test_partial()

# 執行結果
5

神秘eval

eval我理解為一種內嵌的python解釋器(這種解釋可能會有偏差), 會解釋字元串為對應的代碼並執行, 並且將執行結果返回

看一下下面這個例子
#!/usr/bin/env python
# -*- coding: utf-8 -*-

deftest_first():
return3

deftest_second(num):
returnnum

action = { # 可以看做是一個sandbox
"para":5,
"test_first": test_first,
"test_second": test_second
}

deftest_eavl():
condition = "para == 5 and test_second(test_first) > 5"
res = eval(condition, action) # 解釋condition並根據action對應的動作執行
printres

if__name__ =='_

exec

exec在Python中會忽略返回值, 總是返回None, eval會返回執行代碼或語句的返回值
exec 和 eval 在執行代碼時, 除了返回值其他行為都相同
在傳入字元串時, 會使用 compile(source, '<string>', mode) 編譯位元組碼. mode的取值為 exec 和 eval
#!/usr/bin/env python
# -*- coding: utf-8 -*-

deftest_first():
print"hello"

deftest_second():
test_first()
print"second"

deftest_third():
print"third"

action = {
"test_second": test_second,
"test_third": test_third
}

deftest_exec():
exec"test_second"inaction

if__name__ =='__main__':
test_exec() # 無法看到執行結果

getattr

getattr(object, name[, default]) Return the value of
the named attribute of object. name must be a string. If the string is
the name of one of the object』s attributes, the result is the value of
that attribute. For example, getattr(x, 『foobar』) is equivalent to
x.foobar. If the named attribute does not exist, default is returned if
provided, otherwise AttributeError is raised.

通過string類型的name, 返回對象的name屬性(方法)對應的值, 如果屬性不存在, 則返回默認值, 相當於object.name
# 使用範例
classTestGetAttr(object):

test = "test attribute"

defsay(self):
print"test method"

deftest_getattr():
my_test = TestGetAttr()
try:
printgetattr(my_test,"test")
exceptAttributeError:
print"Attribute Error!"
try:
getattr(my_test, "say")()
exceptAttributeError:# 沒有該屬性, 且沒有指定返回值的情況下
print"Method Error!"

if__name__ =='__main__':
test_getattr()

# 輸出結果
test attribute
test method

命令行處理
defprocess_command_line(argv):
"""
Return a 2-tuple: (settings object, args list).
`argv` is a list of arguments, or `None` for ``sys.argv[1:]``.
"""
ifargvisNone:
argv = sys.argv[1:]

# initialize the parser object:
parser = optparse.OptionParser(
formatter=optparse.TitledHelpFormatter(width=78),
add_help_option=None)

# define options here:
parser.add_option( # customized description; put --help last
'-h','--help', action='help',
help='Show this help message and exit.')

settings, args = parser.parse_args(argv)

# check number of arguments, verify values, etc.:
ifargs:
parser.error('program takes no command-line arguments; '
'"%s" ignored.'% (args,))

# further process settings & args if necessary

returnsettings, args

defmain(argv=None):
settings, args = process_command_line(argv)
# application code here, like:
# run(settings, args)
return0# success

if__name__ =='__main__':
status = main()
sys.exit(status)

讀寫csv文件
# 從csv中讀取文件, 基本和傳統文件讀取類似
importcsv
withopen('data.csv','rb')asf:
reader = csv.reader(f)
forrowinreader:
printrow
# 向csv文件寫入
importcsv
withopen('data.csv','wb')asf:
writer = csv.writer(f)
writer.writerow(['name','address','age'])# 單行寫入
data = [
( 'xiaoming ','china','10'),
( 'Lily','USA','12')]
writer.writerows(data) # 多行寫入

各種時間形式轉換

只發一張網上的圖, 然後差文檔就好了, 這個是記不住的

字元串格式化

一個非常好用, 很多人又不知道的功能
>>>name ="andrew"
>>>"my name is {name}".format(name=name)
'my name is andrew'

熱點內容
隨機啟動腳本 發布:2025-07-05 16:10:30 瀏覽:532
微博資料庫設計 發布:2025-07-05 15:30:55 瀏覽:30
linux485 發布:2025-07-05 14:38:28 瀏覽:310
php用的軟體 發布:2025-07-05 14:06:22 瀏覽:760
沒有許可權訪問計算機 發布:2025-07-05 13:29:11 瀏覽:436
javaweb開發教程視頻教程 發布:2025-07-05 13:24:41 瀏覽:717
康師傅控流腳本破解 發布:2025-07-05 13:17:27 瀏覽:246
java的開發流程 發布:2025-07-05 12:45:11 瀏覽:692
怎麼看內存卡配置 發布:2025-07-05 12:29:19 瀏覽:288
訪問學者英文個人簡歷 發布:2025-07-05 12:29:17 瀏覽:837