I am not a creator. I am just a porter.

簡介：對一些python的小知識進行總結

#### lambda匿名函數 #### {#lambda}

lambda函數也叫匿名函數，也就是函數沒有名稱。先看一個簡單的例子：

def add(x, y):    return x + y

對應的lambda函數則如下：

add = lambda x, y: x + y

我們在很多情況下都可以看到lambda表達式，它并不是python特有的，而且大多數情況下我們并不會使用它。那么，在什么情況下使用lambda函數呢？由于lambda沒有函數名這樣不會產生很多函數的引用，這樣對代碼的清晰是有好處的，個人認為，當一個功能簡單的函數，只在某個局部使用而且使用的次數不多，我們可以使用lambda函數，當然，不用lambda是完全可以的。

#### python生成器 #### {#generator}

什么是生成器？在談這個問題之前我們來看看python的迭代器。當我們可以逐項去讀取的對象的屬性時，我們就說這個對象是可迭代的：

>>> clist = [1, 2, 3, 4]>>> for item in clist:...     PRint item...     1234>>> for item in clist:...     print item...     1234>>> 

clist是一個可迭代的對象，可以使用for-in語法來訪問每個item。我們常見的迭代器：list，tuple，dict，file... for語句在容器對象中調用iter()，該函數調用對象的__iter__()函數返回一個定義了next()方法的迭代器對象：

class Array(object):    def __init__(self):        self._list = [i for i in range(10)]        self.ops = -1    def __iter__(self):        self.ops = -1        return self    def next(self):        self.ops += 1        if self.ops == len(self._list):            raise StopIteration()        return self._list[self.ops]

__iter__()和next()不必要在同一個類，我們只要明白，__iter__()是返回一個可迭代的對象，而可迭代的對象包含next()，記住越界raise StopIteration：

class Array(object):    def __init__(self):        self._list = [i for i in range(10)]    def __iter__(self):        return ArrayIterator(self)class ArrayIterator(object):    def __init__(self, array):        self._array = array        self._ops = -1    def next(self):        self._ops += 1        if self._ops == len(self._array._list):            raise StopIteration()        return self._array._list[self._ops]

說完迭代器，我們來看看生成器，首先生成器是可以迭代的，但是只可以讀取一次，因為它并不把所有的值放在內存中，而是實時生成數據：

>>> gen = (i for i in range(10))>>> for ite in gen:...     print ite...       0123456789>>> for ite in gen:...     print ite... >>> 

比較code-2.1和code-2.4，發現當我們把[]換成()后，for...in...只能使用一次，這就是因為生成器只能被迭代一次。

如何構造一個生成器？我們使用yield關鍵字。yield是一個類似return的關鍵字，只是這個函數返回的是一個生成器：

def generator(init_list):for i in init_list:    yield igen = generator([i for i in range(3)])for i in gen:    print i # out 0 1 2print gen.next() # raise StopIteration

首先當我們調用generator這個函數的時候，它并不是立馬就執行，這個函數返回一個生成器對象(包含next()方法）。函數內的代碼則是當我們使用for循環的時候執行。如果生成器內部沒有定義yield，那么這個生成器被認為成空，不滿足循環條件。

#### python裝飾器 #### {#decorator}

裝飾器，用于裝飾一個函數，所謂的裝飾就是在原有的基礎上增加功能(參數檢查，編碼解碼，添加日志...)

def help():    """        一個請求幫助的函數    """    print("Can you help me?")def decorator(func):    """        在請求幫助前，打招呼    """    print("Hi, Mike!")    return func #這里要返回原函數對象，否則外面無法調用def decorator_with_funcparams(args):    """        裝飾器和被裝飾的函數都是帶參數的，args是裝飾器的參數，func_param是被裝飾的函數的參數    """    def _deco(func):        def func_deco(func_param):            print("Hi, " + func_param)            return func()        return func_deco    return _deco

裝飾器測試：

hp = decorator(help)hp()hp()output:----------------Hi, Mike!Can you help me?Can you help me?

裝飾器只裝飾一次，所以Hi，Mike！輸出一次，

@decoratordef hp():    help()hp()hp()output:----------------Hi, Mike!Can you help me?Can you help me?

為了使得每次調用的時候，都能被裝飾，我們需要在裝飾器使用內嵌函數：

def decorator_with_inner(func):    def _deco():        print("Hi, Mike!")        return func() #這里調用函數，而不是返回原函數的對象    return _deco@decorator_with_innerdef hp():    help()hp() #實際上調用的是_deco()hp()output:----------------Hi, Mike!Can you help me?Hi, Mike!Can you help me?

有時候裝飾器是根據上下文來確定裝飾動作，這個是就需要帶參數了：

def decorator_with_params(args):    """        帶有參數的裝飾器，由于有參數，所以在函數調用時只會使用應用時的參數        而不是接收被裝飾的函數作為參數，所以必須在其內部再創建一個函數    """    print(args)    def _deco(func):        print("Hi, Mike")        return func #這里不能使用func()    return _deco@decorator_with_params(args = 'Please!')def hp():    help()hp() #調用的是func()，不是_deco()hp()output:----------------Please!Hi, Mike!Can you help me?Can you help me?

這里可以看出裝飾器(傳入被裝飾函數對象的函數以及外層的函數)只會執行一遍，對于這個例子來說，print(args)和_deco函數都只是執行了一遍。當我們調用hp()的時候實際上調用的是我們傳入func時的函數的返回值，所以在那一層不要調用函數，而是返回函數對象。所以為了保證每次都執行裝飾動作我們需要在傳入func的函數中內嵌一個函數：

def decorator_with_params2(args):    """        帶有參數的裝飾器，由于有參數，所以在函數調用時只會使用應用時的參數        而不是接收被裝飾的函數作為參數，所以必須在其內部再創建一個函數    """    print(args)    def _deco(func):        def f_deco():            print("Hi, Mike")            return func() #注意這里是調用函數，而不是返回原函數對象        return f_deco    return _deco@decorator_with_params(args = 'Please!')def hp():    help()hp() #調用的是f_deco()，不是_deco()hp()output:----------------Please!Hi, MikeCan you help me?Hi, MikeCan you help me?

當被裝飾的函數需要傳入參數，在內嵌函數中帶上參數就可以了：

def decorator_with_funcparams(args):"""    裝飾器和被裝飾的函數都是帶參數的，args是裝飾器的參數，func_param是被裝飾的函數的參數"""def _deco(func):    def func_deco(func_param):        print("Hi, " + func_param)        return func(func_param)    return func_decoreturn _deco@decorator_with_funcparams(args = 'Please!')def hp(func_param):    print("Can you help me, " + func_param + "?")hp("Mike1") hp("Mike2")output:-----------------------Hi, Mike1Can you help me, Mike1?Hi, Mike2Can you help me, Mike2?

調用hp("Mike1")實際上就是調用func_deco("Mike1")，所以在func_deco()函數體中是調用func()，而不是返回函數對象。如果我們返回的是函數對象會怎么樣：

def decorator_with_funcparams(args):    """        裝飾器和被裝飾的函數都是帶參數的，args是裝飾器的參數，func_param是被裝飾的函數的參數    """    def _deco(func):        def func_deco(func_param):            print("Hi, " + func_param)            return func        return func_deco    return _deco@decorator_with_funcparams(args = 'Please!')def hp(func_param):    print("Can you help me, " + func_param + "?")hp("Mike1")("test1")hp("Mike2")("test2") output:----------------------- Hi, Mike1Can you help me, test1?Hi, Mike2Can you help me, test2?

我們調用hp()也就是調用的func_deco()，所以返回的是真正的hp對象，hp()()這個時候就是對真正的hp進行調用。但是這樣就改變了hp的行為了，所以除了特殊情況下，一般不這么做！

Python裝飾器（decorator）在實現的時候，有一些細節需要被注意。例如，被裝飾后的函數其實已經是另外一個函數了（函數名等函數屬性會發生改變）。這樣有時候會對程序造成一些不便，例如筆者想對unittest框架中的一些函數添加自定義的decorator，添加后由于函數名和函數的doc發生了改變，對測試結果有一些影響。所以，Python的functools包中提供了一個叫wraps的decorator來消除這樣的副作用。寫一個decorator的時候，最好在實現之前加上functools的wrap，它能保留原有函數的名稱和docstring。

def authenticated(method):       @functools.wraps(method)    def wrapper(self, *args, **kwargs):        if not self.current_user:            if self.request.method in ("GET", "HEAD"):                url = self.get_login_url()                if "?" not in url:                    if urlparse.urlsplit(url).scheme:                        # if login url is absolute, make next absolute too                        next_url = self.request.full_url()                    else:                        next_url = self.request.uri                    url += "?" + urlencode(dict(next=next_url))                self.redirect(url)                return            raise HTTPError(403)        return method(self, *args, **kwargs)    return wrapper    

#### python列表，字典，集合推導 #### {#derive}

在python的使用過程中，我們經常需要構造一個列表。列表推導為我們提供了一個簡單的方法：

clist = [x for x in range(100) if x % 2 == 0]

使用一句話輕松生成一個100以內的偶數列表。

在python 3.1(反向移植到python 2.7)之后，集合(不是元組)和字典也支持推導式：

>>> { x for x in range(10) if x % 2 == 0}set([0, 8, 2, 4, 6])>>> { x: x * 2 for x in range(10) if x % 2 == 0}{0: 0, 8: 16, 2: 4, 4: 8, 6: 12}

注意：(x for x in range(10) if x % 2 == 0) 得到的是一個生成器

#### python字典的使用 #### {#dictionary}

判斷鍵的存在性

丑陋的：

dic.has_key(key)

python的做法：

key in dic

丑陋的：

not key in dic

難道這樣不是更好：

key not in dic

字典取值

丑陋的：

if key not in dic:    dic[key] = 0dic[key] = dic[key] + 1

這樣更簡潔：

dic[key] = dic.get(key, 0) + 1

統計計數

統計字典重復的次數：

>>> from collections import Counter>>> Counter([1,1,1,1,2,1,2,3,2,3])Counter({1: 5, 2: 3, 3: 2})

字典的初始化

有時你的字典里都是經常修改的對象，你需要初始化一些數據到這個字典，也需要修改其中的一些值。比如說，你在維護一個這樣的dict:它的值都是鏈表。

常見的：

dct = {}for (key, value) in data:    if key in dct:        dct[key].append(value)    else:        dct[key] = [value]

好一點：

dct = {}for (key, value) in data:    group = dct.setdefault(key, []) # key might exist already    group.append(value)

setdefault，如果存在，返回dct[key]，不存在就設為default，并返回。

使用defaultdict：

dct = defaultdict(list)for (key, value) in data:    dct[key].append(value) # all keys have a default already

defaultdict，對于每生成一對新的key-value，就會給value一個默認值，這個默認值就是defaultdict的參數。

#### Python的隱藏特性 ####

以下介紹來自PyZh

函數參數unpack

def foo(x, y):    print x, yalist = [1, 2]adict = {'x': 1, 'y': 2}foo(*alist)  # 1, 2foo(**adict)  # 1, 2

鏈式比較操作符

>>> x = 3>>> 1 < x < 5True>>> 4 > x >=3True

注意函數的默認參數

>>> def foo(x=[]):...     x.append(1)...     print x...>>> foo()[1]>>> foo()[1, 1]

更安全的做法:

>>> def foo(x=None):...     if x is None:...         x = []...     x.append(1)...     print x...>>> foo()[1]>>> foo()[1]>>>

字典有個get()方法

dct.get(key[, default_value]) , 當字典 dct 中找不到 key 時， get 就會返回 default_valuesum[value] = sum.get(value, 0) + 1

帶關鍵字的格式化

>>> print "Hello %(name)s !" % {'name': 'James'}Hello James !>>> print "I am years %(age)i years old" % {'age': 18}I am years 18 years old

更新些的格式化:

>>> print "Hello {name} !".format(name="James")Hello James !

快有些模板引擎的味道了:)

for...else 語法

>>> for i in (1, 3, 5):...     if i % 2 == 0:...         break... else:...     print "var i is always an odd"...var i is always an odd>>>

else 語句塊會在循環結束后執行，除非在循環塊中執行 break

**dict 的特殊方法__missing__**

Python 2.5之后引入的。當查找不到 key 的時候，會執行這個方法。

>>> class Dict(dict):...   def __missing__(self, key):...     self[key] = []...     return self[key]...>>> dct = Dict()>>> dct["foo"].append(1)>>> dct["foo"].append(2)>>> dct["foo"][1, 2]

這很像 collections.defaultdict 不是嗎?

>>> from collections import defaultdict>>> dct = defaultdict(list)>>> dct["foo"][]>>> dct["bar"].append("Hello")>>> dctdefaultdict(<type 'list'>, {'foo': [], 'bar': ['Hello']})

切片操作的步長參數

還能用步長 -1 來反轉鏈表:

>>> a = [1, 2, 3, 4, 5]>>> a[::2][1, 3, 5]>>> a[::-1][5, 4, 3, 2, 1]>>>9.9. 另一種字符串連接>>> Name = "Wang" "Hong">>> Name'WangHong'

連接多行:

>>> Name = "Wang" /...  "Hong">>> Name'WangHong'

**Python解釋器中的”_”**

>>> range(4)[0, 1, 2, 3]>>> _[0, 1, 2, 3]

_ 即Python解釋器上一次返回的值

嵌套列表推導式

>>> [(i, j) for i in range(3) for j in range(i)][(1, 0), (2, 0), (2, 1)]

try/except/else

try:  put_4000000000_volts_through_it(parrot)except Voom:  print "'E's pining!"else:  print "This parrot is no more!"finally:  end_sketch()

print 重定向輸出到文件

>>> print >> open("somefile", "w+"), "Hello World"

注意打開的模式: "w+" 而不能 "w" , 當然 "a" 是可以的

省略號

在 Python 3 中你可以直接使用省略號這個文法:

Python 3.2 (r32:88445, Oct 20 2012, 14:09:50)[GCC 4.5.2] on linux2Type "help", "copyright", "credits" or "license" for more information.>>> ...EllipsisPython2 中呢?>>> class C(object):...  def __getitem__(self, item):...   return item...>>> C()[1:2, ..., 3](slice(1, 2, None), Ellipsis, 3)>>>

Python3中的元組unpack

>>> a, b, *rest = range(10)>>> a0>>> b1>>> rest[2, 3, 4, 5, 6, 7, 8, 9]>>>

當然也可以取出最后一個:

>>> first, second, *rest, last = range(10)>>> first0>>> second1>>> last9>>> rest[2, 3, 4, 5, 6, 7, 8]

pow()還有第三個參數

我們都知道內置函數 pow, pow(x, y) 即 x ** y

但是它還可以有第三個參數:

>>> pow(4, 2, 2)0>>> pow(4, 2, 3)1

其實第三個參數是來求模的: pow(x, y, z) == (x ** y) % z

注意，內置的 pow 和 math.pow 并不是一個函數，后者只接受2個參數

enumerate還有第二個參數

enumerate 很贊，可以給我們索引和序列值的對, 但是它還有第二個參數:

>>> lst = ["a", "b", "c"]>>> list(enumerate(lst, 1))[(1, 'a'), (2, 'b'), (3, 'c')]

這個參數用來: 指明索引的起始值

顯式的聲明一個集合

新建一個集合，我們會:

>>> set([1,2,3])

在Python 2.7 之后可以這么寫了:

>>> {1,2,3}set([1, 2, 3])

用切片來刪除序列的某一段

>>> a = [1, 2, 3, 4, 5, 6, 7]>>> a[1:4] = []>>> a[1, 5, 6, 7]

當然用 del a[1:4] 也是可以的

去除偶數項(偶數索引的):

>>> a = [0, 1, 2, 3, 4, 5, 6, 7]>>> del a[::2]>>> a[1, 3, 5, 7]

isinstance可以接收一個元組

這個真的鮮為人知, 我們可以用 isinstance(x, (float, int)) 來判斷 x 是不是數:

>>> isinstance(1, (float, int))True>>> isinstance(1.3, (float, int))True>>> isinstance("1.3", (float, int))False

那么對于第三個測試，你把 str 加入元組就可以看到這是怎么回事了:

>>> isinstance("1.3", (float, int, str))True

也就是那個元組里面是 或 的關系，只要是其中一個的實例就返回 True

字典里的無限遞歸

>>> a, b = {}, {}>>> a['b'] = b>>> b['a'] = a>>> a{'b': {'a': {...}}}

當然你可以制作一個鏈表中的無限循環:

>>> a, b =  [], []>>> a.append(b)>>> b.append(a)>>> a[[[...]]]

真心不知道有什么用，不過蠻好玩的不是嗎

Python可以認識Unicode中的數字

所以說，Python很贊:

>>> int(u'1234')1234

不只是ASCII字符串的可以認出來，連Unicode的也可以。

不能訪問到的屬性

>>> class O(object):pass...>>> o = O()>>> setattr(o, "can't touch this", 123)>>> o.can't touch this  File "<stdin>", line 1    o.can't touch this                     ^SyntaxError: EOL while scanning string literal>>>

不過，能用 setattr 設置屬性，就可以用 getattr 取出