介紹Python中的一些高級編程技巧
正文:
本文展示一些高級的Python設(shè)計結(jié)構(gòu)和它們的使用方法。在日常工作中,你可以根據(jù)需要選擇合適的數(shù)據(jù)結(jié)構(gòu),例如對快速查找性的要求、對數(shù)據(jù)一致性的要求或是對索引的要求等,同時也可以將各種數(shù)據(jù)結(jié)構(gòu)合適地結(jié)合在一起,從而生成具有邏輯性并易于理解的數(shù)據(jù)模型。Python的數(shù)據(jù)結(jié)構(gòu)從句法上來看非常直觀,并且提供了大量的可選操作。這篇指南嘗試將大部分常用的數(shù)據(jù)結(jié)構(gòu)知識放到一起,并且提供對其最佳用法的探討。
推導(dǎo)式(Comprehensions)
如果你已經(jīng)使用了很長時間的Python,那么你至少應(yīng)該聽說過列表推導(dǎo)(list comprehensions)。這是一種將for循環(huán)、if表達(dá)式以及賦值語句放到單一語句中的一種方法。換句話說,你能夠通過一個表達(dá)式對一個列表做映射或過濾操作。
一個列表推導(dǎo)式包含以下幾個部分:
- 一個輸入序列
- 一個表示輸入序列成員的變量
- 一個可選的斷言表達(dá)式
- 一個將輸入序列中滿足斷言表達(dá)式的成員變換成輸出列表成員的輸出表達(dá)式
舉個例子,我們需要從一個輸入列表中將所有大于0的整數(shù)平方生成一個新的序列,你也許會這么寫:
num = [1, 4, -5, 10, -7, 2, 3, -1] filtered_and_squared = [] for number in num: if number > 0: filtered_and_squared.append(number ** 2) print filtered_and_squared # [1, 16, 100, 4, 9]
很簡單是吧?但是這就會有4行代碼,兩層嵌套外加一個完全不必要的append操作。而如果使用filter、lambda和map函數(shù),則能夠?qū)⒋a大大簡化:
num = [1, 4, -5, 10, -7, 2, 3, -1] filtered_and_squared = map(lambda x: x ** 2, filter(lambda x: x > 0, num)) print filtered_and_squared # [1, 16, 100, 4, 9]
嗯,這么一來代碼就會在水平方向上展開。那么是否能夠繼續(xù)簡化代碼呢?列表推導(dǎo)能夠給我們答案:
num = [1, 4, -5, 10, -7, 2, 3, -1] filtered_and_squared = [ x**2 for x in num if x > 0] print filtered_and_squared # [1, 16, 100, 4, 9]
- 迭代器(iterator)遍歷輸入序列num的每個成員x
- 斷言式判斷每個成員是否大于零
- 如果成員大于零,則被交給輸出表達(dá)式,平方之后成為輸出列表的成員。
列表推導(dǎo)式被封裝在一個列表中,所以很明顯它能夠立即生成一個新列表。這里只有一個type函數(shù)調(diào)用而沒有隱式調(diào)用lambda函數(shù),列表推導(dǎo)式正是使用了一個常規(guī)的迭代器、一個表達(dá)式和一個if表達(dá)式來控制可選的參數(shù)。
另一方面,列表推導(dǎo)也可能會有一些負(fù)面效應(yīng),那就是整個列表必須一次性加載于內(nèi)存之中,這對上面舉的例子而言不是問題,甚至擴(kuò)大若干倍之后也都不是問題。但是總會達(dá)到極限,內(nèi)存總會被用完。
針對上面的問題,生成器(Generator)能夠很好的解決。生成器表達(dá)式不會一次將整個列表加載到內(nèi)存之中,而是生成一個生成器對象(Generator objector),所以一次只加載一個列表元素。
生成器表達(dá)式同列表推導(dǎo)式有著幾乎相同的語法結(jié)構(gòu),區(qū)別在于生成器表達(dá)式是被圓括號包圍,而不是方括號:
num = [1, 4, -5, 10, -7, 2, 3, -1] filtered_and_squared = ( x**2 for x in num if x > 0 ) print filtered_and_squared # <generator object <genexpr> at 0x00583E18> for item in filtered_and_squared: print item # 1, 16, 100 4,9
這比列表推導(dǎo)效率稍微提高一些,讓我們再一次改造一下代碼:
num = [1, 4, -5, 10, -7, 2, 3, -1] def square_generator(optional_parameter): return (x ** 2 for x in num if x > optional_parameter) print square_generator(0) # <generator object <genexpr> at 0x004E6418> # Option I for k in square_generator(0): print k # 1, 16, 100, 4, 9 # Option II g = list(square_generator(0)) print g # [1, 16, 100, 4, 9]
除非特殊的原因,應(yīng)該經(jīng)常在代碼中使用生成器表達(dá)式。但除非是面對非常大的列表,否則是不會看出明顯區(qū)別的。
下例使用zip()函數(shù)一次處理兩個或多個列表中的元素:
alist = ['a1', 'a2', 'a3'] blist = ['1', '2', '3'] for a, b in zip(alist, blist): print a, b # a1 1 # a2 2 # a3 3
再來看一個通過兩階列表推導(dǎo)式遍歷目錄的例子:
import os
def tree(top):
for path, names, fnames in os.walk(top):
for fname in fnames:
yield os.path.join(path, fname)
for name in tree('C:\Users\XXX\Downloads\Test'):
print name
裝飾器(Decorators)
裝飾器為我們提供了一個增加已有函數(shù)或類的功能的有效方法。聽起來是不是很像Java中的面向切面編程(Aspect-Oriented Programming)概念?兩者都很簡單,并且裝飾器有著更為強(qiáng)大的功能。舉個例子,假定你希望在一個函數(shù)的入口和退出點做一些特別的操作(比如一些安全、追蹤以及鎖定等操作)就可以使用裝飾器。
裝飾器是一個包裝了另一個函數(shù)的特殊函數(shù):主函數(shù)被調(diào)用,并且其返回值將會被傳給裝飾器,接下來裝飾器將返回一個包裝了主函數(shù)的替代函數(shù),程序的其他部分看到的將是這個包裝函數(shù)。
def timethis(func): ''' Decorator that reports the execution time. ''' pass @timethis def countdown(n): while n > 0: n -= 1
語法糖@標(biāo)識了裝飾器。
好了,讓我們回到剛才的例子。我們將用裝飾器做一些更典型的操作:
import time
from functools import wraps
def timethis(func):
'''
Decorator that reports the execution time.
'''
@wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(func.__name__, end-start)
return result
return wrapper
@timethis
def countdown(n):
while n > 0:
n -= 1
countdown(100000)
# ('countdown', 0.006999969482421875)
當(dāng)你寫下如下代碼時:
@timethis def countdown(n):
意味著你分開執(zhí)行了以下步驟:
def countdown(n): ... countdown = timethis(countdown)
裝飾器函數(shù)中的代碼創(chuàng)建了一個新的函數(shù)(正如此例中的wrapper函數(shù)),它用 *args 和 **kwargs 接收任意的輸入?yún)?shù),并且在此函數(shù)內(nèi)調(diào)用原函數(shù)并且返回其結(jié)果。你可以根據(jù)自己的需要放置任何額外的代碼(例如本例中的計時操作),新創(chuàng)建的包裝函數(shù)將作為結(jié)果返回并取代原函數(shù)。
@decorator
def function():
print("inside function")
當(dāng)編譯器查看以上代碼時,function()函數(shù)將會被編譯,并且函數(shù)返回對象將會被傳給裝飾器代碼,裝飾器將會在做完相關(guān)操作之后用一個新的函數(shù)對象代替原函數(shù)。
裝飾器代碼是什么樣的?大部分的例子都是將裝飾器定義為函數(shù),而我發(fā)覺將裝飾器定義成類更容易理解其功能,并且這樣更能發(fā)揮裝飾器機(jī)制的威力。
對裝飾器的類實現(xiàn)唯一要求是它必須能如函數(shù)一般使用,也就是說它必須是可調(diào)用的。所以,如果想這么做這個類必須實現(xiàn)__call__方法。
這樣的裝飾器應(yīng)該用來做些什么?它可以做任何事,但通常它用在當(dāng)你想在一些特殊的地方使用原函數(shù)時,但這不是必須的,例如:
class decorator(object):
def __init__(self, f):
print("inside decorator.__init__()")
f() # Prove that function definition has completed
def __call__(self):
print("inside decorator.__call__()")
@decorator
def function():
print("inside function()")
print("Finished decorating function()")
function()
# inside decorator.__init__()
# inside function()
# Finished decorating function()
# inside decorator.__call__()
譯者注:
1. 語法糖@decorator相當(dāng)于function=decorator(function),在此調(diào)用decorator的__init__打印“inside decorator.__init__()”
2. 隨后執(zhí)行f()打印“inside function()”
3. 隨后執(zhí)行“print(“Finished decorating function()”)”
4. 最后在調(diào)用function函數(shù)時,由于使用裝飾器包裝,因此執(zhí)行decorator的__call__打印 “inside decorator.__call__()”。
一個更實際的例子:
def decorator(func):
def modify(*args, **kwargs):
variable = kwargs.pop('variable', None)
print variable
x,y=func(*args, **kwargs)
return x,y
return modify
@decorator
def func(a,b):
print a**2,b**2
return a**2,b**2
func(a=4, b=5, variable="hi")
func(a=4, b=5)
# hi
# 16 25
# None
# 16 25
上下文管理庫(ContextLib)
contextlib模塊包含了與上下文管理器和with聲明相關(guān)的工具。通常如果你想寫一個上下文管理器,則你需要定義一個類包含__enter__方法以及__exit__方法,例如:
import time
class demo:
def __init__(self, label):
self.label = label
def __enter__(self):
self.start = time.time()
def __exit__(self, exc_ty, exc_val, exc_tb):
end = time.time()
print('{}: {}'.format(self.label, end - self.start))
完整的例子在此:
import time
class demo:
def __init__(self, label):
self.label = label
def __enter__(self):
self.start = time.time()
def __exit__(self, exc_ty, exc_val, exc_tb):
end = time.time()
print('{}: {}'.format(self.label, end - self.start))
with demo('counting'):
n = 10000000
while n > 0:
n -= 1
# counting: 1.36000013351
上下文管理器被with聲明所激活,這個API涉及到兩個方法。
1. __enter__方法,當(dāng)執(zhí)行流進(jìn)入with代碼塊時,__enter__方法將執(zhí)行。并且它將返回一個可供上下文使用的對象。
2. 當(dāng)執(zhí)行流離開with代碼塊時,__exit__方法被調(diào)用,它將清理被使用的資源。
利用@contextmanager裝飾器改寫上面那個例子:
from contextlib import contextmanager
import time
@contextmanager
def demo(label):
start = time.time()
try:
yield
finally:
end = time.time()
print('{}: {}'.format(label, end - start))
with demo('counting'):
n = 10000000
while n > 0:
n -= 1
# counting: 1.32399988174
看上面這個例子,函數(shù)中yield之前的所有代碼都類似于上下文管理器中__enter__方法的內(nèi)容。而yield之后的所有代碼都如__exit__方法的內(nèi)容。如果執(zhí)行過程中發(fā)生了異常,則會在yield語句觸發(fā)。
描述器(Descriptors)
描述器決定了對象屬性是如何被訪問的。描述器的作用是定制當(dāng)你想引用一個屬性時所發(fā)生的操作。
構(gòu)建描述器的方法是至少定義以下三個方法中的一個。需要注意,下文中的instance是包含被訪問屬性的對象實例,而owner則是被描述器修辭的類。
__get__(self, instance, owner) – 這個方法是當(dāng)屬性被通過(value = obj.attr)的方式獲取時調(diào)用,這個方法的返回值將被賦給請求此屬性值的代碼部分。
__set__(self, instance, value) – 這個方法是當(dāng)希望設(shè)置屬性的值(obj.attr = ‘value')時被調(diào)用,該方法不會返回任何值。
__delete__(self, instance) – 當(dāng)從一個對象中刪除一個屬性時(del obj.attr),調(diào)用此方法。
譯者注:對于instance和owner的理解,考慮以下代碼:
class Celsius(object): def __init__(self, value=0.0): self.value = float(value) def __get__(self, instance, owner): return self.value def __set__(self, instance, value): self.value = float(value) class Temperature(object): celsius = Celsius() temp=Temperature() temp.celsius #calls Celsius.__get__
上例中,instance指的是temp,而owner則是Temperature。
LazyLoading Properties例子:
import weakref class lazyattribute(object): def __init__(self, f): self.data = weakref.WeakKeyDictionary() self.f = f def __get__(self, obj, cls): if obj not in self.data: self.data[obj] = self.f(obj) return self.data[obj] class Foo(object): @lazyattribute def bar(self): print "Being lazy" return 42 f = Foo() print f.bar # Being lazy # 42 print f.bar # 42
描述器很好的總結(jié)了Python中的綁定方法(bound method)這個概念,綁定方法是經(jīng)典類(classic classes)的實現(xiàn)核心。在經(jīng)典類中,當(dāng)在一個對象實例的字典中沒有找到某個屬性時,會繼續(xù)到類的字典中查找,然后再到基類的字典中,就這么一直遞歸的查找下去。如果在類字典中找到這個屬性,解釋器會檢查找到的對象是不是一個Python函數(shù)對象。如果是,則返回的并不是這個對象本身,而是返回一個柯里化(currying function)的包裝器對象。當(dāng)調(diào)用這個包裝器時,它會首先在參數(shù)列表之前插入實例,然后再調(diào)用原函數(shù)。
譯者注:
1. 柯里化 – http://zh.wikipedia.org/wiki/%E6%9F%AF%E9%87%8C%E5%8C%96
2. function,method,bound method及unbound method的區(qū)別。首先,函數(shù)(function)是由def或lambda創(chuàng)建的。當(dāng)一個函數(shù)在class語句塊中定義或是由type來創(chuàng)建時,它會轉(zhuǎn)成一個非綁定方法(unbound method),而當(dāng)通過類實例(instance)來訪問此方法的時候,它將轉(zhuǎn)成綁定方法(bound method),綁定方法會自動將實例作為第一個參數(shù)傳入方法。綜上所述,方法是出現(xiàn)在類中的函數(shù),綁定方法是一個綁定了具體實例的方法,反之則是非綁定方法。
綜上,描述器被賦值給類,而這些特殊的方法就在屬性被訪問的時候根據(jù)具體的訪問類型自動地調(diào)用。
元類(MetaClasses)
元類提供了一個改變Python類行為的有效方式。
元類的定義是“一個類的類”。任何實例是它自己的類都是元類。
class demo(object):
pass
obj = demo()
print "Class of obj is {0}".format(obj.__class__)
print "Class of obj is {0}".format(demo.__class__)
# Class of obj is <class '__main__.demo'>
# Class of obj is <type 'type'>
在上例中,我們定義了一個類demo,并且生成了一個該類的對象obj。首先,可以看到obj的__class__是demo。有意思的來了,那么demo的class又是什么呢?可以看到demo的__class__是type。
所以說type是python類的類,換句話說,上例中的obj是一個demo的對象,而demo本身又是type的一個對象。
所以說type就是一個元類,而且是python中最常見的元類,因為它使python中所有類的默認(rèn)元類。
因為元類是類的類,所以它被用來創(chuàng)建類(正如類是被用來創(chuàng)建對象的一樣)。但是,難道我們不是通過一個標(biāo)準(zhǔn)的類定義來創(chuàng)建類的么?的確是這樣,但是python內(nèi)部的運作機(jī)制如下:
- 當(dāng)看見一個類定義,python會收集所有屬性到一個字典中。
- 當(dāng)類定義結(jié)束,python將決定類的元類,我們就稱它為Meta吧。
- 最后,python執(zhí)行Meta(name, bases, dct),其中:
a. Meta是元類,所以這個調(diào)用是實例化它。
b. name是新建類的類名。
c. bases是新建類的基類元組
d. dct將屬性名映射到對象,列出所有的類屬性。
那么如何確定一個類(A)的元類呢?簡單來說,如果一個類(A)自身或其基類(Base_A)之一有__metaclass__屬性存在,則這個類(A/Base_A)就是類(A)的元類。否則type就將是類(A)的元類。
模式(Patterns)
“請求寬恕比請求許可更容易(EFAP)”
這個Python設(shè)計原則是這么說的“請求寬恕比請求許可更容易(EFAP)”。不提倡深思熟慮的設(shè)計思路,這個原則是說應(yīng)該盡量去嘗試,如果遇到錯誤,則給予妥善的處理。Python有著強(qiáng)大的異常處理機(jī)制可以支持這種嘗試,這些機(jī)制幫助程序員開發(fā)出更為穩(wěn)定,容錯性更高的程序。
單例
單例是指只能同時存在一個的實例對象。Python提供了很多方法來實現(xiàn)單例。
Null對象
Null對象能夠用來代替None類型以避免對None的測試。
觀察者
觀察者模式允許多個對象訪問同一份數(shù)據(jù)。
構(gòu)造函數(shù)
構(gòu)造函數(shù)的參數(shù)經(jīng)常被賦值給實例的變量。這種模式能夠用一行代碼替代多個手動賦值語句。
總結(jié)
謝謝閱讀,如有疑問,請留言討論。
相關(guān)文章
Python實現(xiàn)的數(shù)據(jù)結(jié)構(gòu)與算法之雙端隊列詳解
這篇文章主要介紹了Python實現(xiàn)的數(shù)據(jù)結(jié)構(gòu)與算法之雙端隊列,詳細(xì)講述了雙端隊列的概念、功能、定義及Python實現(xiàn)與使用雙端隊列的相關(guān)技巧,非常具有實用價值,需要的朋友可以參考下2015-04-04
OpenCV3.0+Python3.6實現(xiàn)特定顏色的物體追蹤
這篇文章主要為大家詳細(xì)介紹了OpenCV3.0+Python3.6實現(xiàn)特定顏色的物體追蹤,具有一定的參考價值,感興趣的小伙伴們可以參考一下2019-07-07
分享Pandas庫中的一些寶藏函數(shù)transform()
Pandas具有很多強(qiáng)大的功能,transform就是其中之一,利用它可以高效地匯總數(shù)據(jù)且不改變數(shù)據(jù)行數(shù),transform是一種什么數(shù)據(jù)操作?如果熟悉SQL的窗口函數(shù),就非常容易理解了2021-09-09

