I am not a creator. I am just a porter.
簡介：對一些python的小知識進行總結
lambda函數也叫匿名函數，也就是函數沒有名稱。先看一個簡單的例子：
def add(x, y): return x + y對應的lambda函數則如下：
add = lambda x, y: x + y我們在很多情況下都可以看到lambda表達式，它并不是python特有的，而且大多數情況下我們并不會使用它。那么，在什么情況下使用lambda函數呢？由于lambda沒有函數名這樣不會產生很多函數的引用，這樣對代碼的清晰是有好處的，個人認為，當一個功能簡單的函數，只在某個局部使用而且使用的次數不多，我們可以使用lambda函數，當然，不用lambda是完全可以的。
什么是生成器？在談這個問題之前我們來看看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，那么這個生成器被認為成空，不滿足循環條件。
裝飾器，用于裝飾一個函數，所謂的裝飾就是在原有的基礎上增加功能(參數檢查，編碼解碼，添加日志...)
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的使用過程中，我們經常需要構造一個列表。列表推導為我們提供了一個簡單的方法：
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) 得到的是一個生成器
判斷鍵的存在性
丑陋的：
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 alreadydefaultdict，對于每生成一對新的key-value，就會給value一個默認值，這個默認值就是defaultdict的參數。
以下介紹來自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 取出
新聞熱點
疑難解答
