python“不為人知的”特性

本文整理自SO上的熱門問答 hidden features of python ，早期有人做過類似的整理，但是內容比較舊而且比較粗糙，因此筆者在原文基礎上加入自己的一些理解，另外那些高質量的評論也引入進來了。總之，這是一篇用心之作，希望你可以喜歡。

鏈式比較操作

>>> x = 5
>>> 1 < x < 10
True
>>> 10 < x < 20 
False
>>> x < 10 < x*10 < 100
True
>>> 10 > x <= 9
True
>>> 5 == x > 4
True

你可能認為它執行的過程先是： 1 < x ，返回 True ，然後再比較 True < 10 ,當然這麼做也是返回 True ,比較表示式 True < 10 ,因為直譯器會把 True 轉換成1 ， False 轉換成 0 。但這裡的鏈式比較直譯器在內部並不是這樣乾的，它會把這種鏈式的比較操作轉換成： 1 < x and x < 10 ，不信你可以看看最後一個例子。這樣的鏈式操作本可以值得所有程式語言擁有，但是很遺憾

列舉

>>> a = ['a', 'b', 'c', 'd', 'e']
>>> for index, item in enumerate(a): print index, item
...
0 a
1 b
2 c
3 d
4 e
>>>

用enumerate包裝一個可迭代物件,可以同時使用迭代項和索引，如果你不這麼幹的話，下面有一種比較麻煩的方法：

for i in range(len(a)):
    print i, a[i]

enumerate 還可以接收一個可選引數start，預設start等於0。 enumerate(list, start=1) ，這樣index的起始值就是1

生成器物件

x=(n for n in foo if bar(n))  #foo是可迭代物件
>>> type(x)
<type 'generator'>

你可以把生成器物件賦值給x，意味著可以對x進行迭代操作：

for n in x:
    pass

它的好處就是不需要儲存中間結果，也許你會使用（列表推倒式）：

x = [n for n in foo if bar(n)]
>>> type(x)
<type 'list'>

它比生成器物件能帶來更快的速度。相對地，生成器更能節省記憶體開銷，它的值是按需生成，不需要像列表推倒式一樣把整個結果儲存在記憶體中，同時它不能重新迭代，列表推倒式則不然。

iter()可接收callable引數

iter()內建函式接收的引數分為兩種，第一種是：

iter(collection)---> iterator

引數collection必須是可迭代物件或者是序列 ，第二種是：

iter（callable， sentinel) --> iterator

callable函式會一直被呼叫，直到它的返回結果等於sentinel，例如：

def seek_next_line(f):
    #每次讀一個字元，直到出現換行符就返回
    for c in iter(lambda: f.read(1),'\n'):  
        pass

小心可變的預設引數

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

取而代之的是你應該使用一個標記值表示“沒有指定”來替換可變值,如：

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

傳送值到生成器函式在中

def mygen():
    """Yield 5 until something else is passed back via send()"""
    a = 5
    while True:
        f = (yield a) #yield a and possibly get f in return
        if f is not None: 
            a = f  #store the new value

你可以：

>>> g = mygen()
>>> g.next()
5
>>> g.next()
5
>>> g.send(7)  #we send this back to the generator
7
>>> g.next() #now it will yield 7 until we send something else
7

如果你不喜歡使用空格縮排，那麼可以使用C語言花括號{}定義函式：

>>> from __future__ import braces   #這裡的braces 指的是：curly braces（花括號）
  File "<stdin>", line 1
SyntaxError: not a chance

當然這僅僅是一個玩笑，想用花括號定義函式？沒門。感興趣的還可以瞭解下：

from __future__ import barry_as_FLUFL

不過這是python3裡面的特性， http://www.python.org/dev/peps/pep-0401/

切片操作中的步長引數

a = [1,2,3,4,5]
>>> a[::2]  # iterate over the whole list in 2-increments
[1,3,5]

還有一個特例： x[::-1] ，反轉列表：

>>> a[::-1]
[5,4,3,2,1]

有關反轉，還有兩個函式reverse、reversed，reverse是list物件的方法，沒有返回值，而reversed是內建方法，可接收的引數包括tuple、string、list、unicode，以及使用者自定義的型別，返回一個迭代器。

>>> l = range(5)
>>> l
[0, 1, 2, 3, 4]
>>> l.reverse()
>>> l
[4, 3, 2, 1, 0]
>>> l2 = reversed(l)
>>> l2
<listreverseiterator object at 0x99faeec>

裝飾器

裝飾器使一個函式或方法包裝在另一個函式裡頭，可以在被包裝的函式新增一些額外的功能，比如@是語法糖，它等價於：，還可以對引數、返回結果進行修改。裝飾器有點類似Java中的AOP。下面這個例子是列印被裝飾的函式裡面的引數的裝飾器，

>>> def print_args(function):
>>>     def wrapper(*args, **kwargs):
>>>         print 'Arguments:', args, kwargs
>>>         return function(*args, **kwargs)
>>>     return wrapper

>>> @print_args
>>> def write(text):
>>>     print text

>>> write('foo')
Arguments: ('foo',) {}
foo

@是語法糖，它等價於：

>>> write = print_args(write)
>>> write('foo')
arguments: ('foo',) {}
foo

for ... else語法

for i in foo:
    if i == 0:
        break
else:
    print("i was never 0")

else程式碼塊只有在for迴圈正常結束後執行如果遇到break語句那麼不會執行else語句塊，等價於下面：

found = False
for i in foo:
    if i == 0:
        found = True
        break
if not found: 
    print("i was never 0")

不過這種語法看起來怪怪地，讓人感覺是else塊是在for語句塊沒有執行的時候執行的，很容易讓人去類比 if else 的語法，如果是把else換成finally或許更容易理解

python2.5有個 __missing__ 方法

dict的子類如果定義了方法 __missing__(self, key) ，如果key不再dict中，那麼d[key]就會呼叫 __missing__ 方法，而且d[key]的返回值就是 __missing__ 的返回值。

>>> class MyDict(dict):
...  def __missing__(self, key):
...   self[key] = rv = []
...   return rv
... 
>>> m = MyDict()
>>> m["foo"].append(1)
>>> m["foo"].append(2)
>>> dict(m)
{'foo': [1, 2]}

在collections模組下有一個叫defaultdict的dict子類，它與missing非常類似，但是對於不存在的項不需要傳遞引數。

>>> from collections import defaultdict
>>> m = defaultdict(list)
>>> m["foo"].append(1)
>>> m["foo"].append(2)
>>> dict(m)
{'foo': [1, 2]}

變數值交換

>>> a = 10
>>> b = 5
>>> a, b
(10, 5)

>>> a, b = b, a
>>> a, b
(5, 10)

等號右邊是一個建立元組的表示式，等號左邊解壓（沒有引用的）元組分別賦給名稱（變數）a和b。賦完值後因為沒有被其他名字引用，因此被標記之後被垃圾收集器回收，而繫結到a和b的值已經被交換了。注意：多值賦值其實僅僅就是元組打包和序列解包的組合的過程

可讀的正規表示式

在Python中你可以把正規表示式分割成多行寫，還可以寫註釋

>>> pattern = """
... ^                   # beginning of string
... M{0,4}              # thousands - 0 to 4 M's
... (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
...                     #            or 500-800 (D, followed by 0 to 3 C's)
... (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
...                     #        or 50-80 (L, followed by 0 to 3 X's)
... (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
...                     #        or 5-8 (V, followed by 0 to 3 I's)
... $                   # end of string
... """
>>> re.search(pattern, 'M', re.VERBOSE)

函式引數解包(unpacking)

分別使用 * 和 ** 解包列表和字典,這是一種非常實用的快捷方式,因為list,tuple,dict作為容器被廣泛使用

def draw_point(x, y):
    # do some magic

point_foo = (3, 4)
point_bar = {'y': 3, 'x': 2}

draw_point(*point_foo)
draw_point(**point_bar)

動態地建立新型別

動態建立新型別雖不是實用功能,但瞭解一下也是有好處的

>>> NewType = type("NewType", (object,), {"x": "hello"})
>>> n = NewType()
>>> n.x
"hello"

type的第一個引數就是類名,第二個引數是繼承的父類,第三個引數是類的屬性.它完全等同於:

>>> class NewType(object):
>>>     x = "hello"
>>> n = NewType()
>>> n.x
"hello"

上下文管理器與with語句

上下文管理器(context manager)用於規定某個物件的使用範圍,進入或退出該範圍時,特殊的操作會被執行(比如關閉連線,釋放記憶體等等),語法是: with... as ... ,該特性在python2.5引入的. 上下文管理器協議有兩個方法組成contextmanager.__enter__() 和 contextmanager.__exit__() ,任何實現了這兩個方法的物件都稱之為上下文管理器物件,比如檔案物件就預設實現了該協議.

with open('foo.txt', 'w') as f:
    f.write('hello!')

字典的get()方法

字典的get()方法用來替換d['key'],後者如果是遇到key不存在會有異常,如果使用的d.get('key'),key不存在時它返回的是None,你可以指定兩個引數如:d.get('key',0)來用0取代返回的None

sum[value] = sum.get(value, 0) + 1

還有一個類似的方法 setdefault(key, value) ,如果字典中存在key,那麼就直接返回d[key],否則設定d[key]=value,並返回該值.

>>> d = {'key':123}
>>> d.setdefault('key',456)
123
>>> d['key']
123
>>> d.setdefault('key2',456)
456
>>> d['key2']
456

collections.Counter是dict的子類,用來統計可哈稀物件,

>>> cnt = Counter('helloworld')
>>> cnt
Counter({'l': 3, 'o': 2, 'e': 1, 'd': 1, 'h': 1, 'r': 1, 'w': 1})
>>> cnt['l']
3
>>> cnt['x'] = 10
>>> cnt.get('y')

描述符(Descriptors)

描述符是python的核心特新之一,當你使用 . 訪問成員時,(如:x.y),python首先在例項字典中查詢該成員,如果沒有發現再從類字典中查詢,如果這個物件實現了描述符(實現了 __get__,__set__,__delete__ ),那麼優先返回 __get__ 方法的返回值.

條件賦值

為什麼python中沒有類c語言的三目運算子,Guido van Rossum說過了,條件賦值更容易理解

x = 3 if (y == 1) else 2

這個表示式的意思就是:如果y等於那麼就把3賦值給x,否則把2賦值給x, 條件中的括號是可選的,為了可讀性可以考慮加上去.if else中的表示式可以是任何型別的,既可以函式,還可以類

(func1 if y == 1 else func2)(arg1, arg2) 

如果y等於1,那麼呼叫func1(arg1,arg2)否則呼叫func2(arg1,arg2)

x = (class1 if y == 1 else class2)(arg1, arg2)

class1,class2是兩個類

異常else語句塊

try:
   try_this(whatever)
except SomeException, exception:
   #Handle exception
else:
    # do something
finally:
    #do something

else語句塊會在沒有異常的情況下執行,先於finally,它的好處就是你可以明確知道它會在沒有異常的情況下執行,如果是把else語句塊放在try語句塊裡面就達不到這種效果.