Python入門之你必須了解的實用技巧
本文主要記錄 Python 中一些常用技巧，所描述的是告訴你怎么寫才是更好? 如果你并不熟悉Python語法，希望你能在下面代碼片段中看到Python的簡單、優雅; 如果你象我這樣，對 Python 有興趣或并正在學習，我相信下面的技巧并不會讓你失望; 如果你已經是一名 Pythoner ，那么很樂于你分享你的經驗和技巧。
Python 禪道
這是Python的指導原則，但有不同詮釋。
如果您使用的一種編程語言是以小品喜劇藝術團命名的，你***有幽默感。
美麗優于丑陋。
明確優于含蓄。
簡單比復雜好。
平倘優于嵌套。
稀疏比密集更好。
特殊情況不能特殊到打破規則。
錯誤不應該默默傳遞。
......
代碼風格: 提高可讀性
Programs must be written for people to read, and only incidentally for machines to execute.
—Abelson & Sussman, Structure and Interpretation of Computer Programs
PEP 8: Python 代碼風格指南
值得閱讀:
http://www.python.org/dev/peps/pep-0008/
空格(行)使用 (1)
◆ 使用 4 個空格縮進。
◆ 不要使用制表符。
◆ 不要將制表符和空格混合使用。
◆ IDEL和Emacs的Python的都支持 spaces模式。
◆ 每個函數之間應該有一個空行。
◆ 每一個 Class 之間應該有兩個空行。
空格(行)使用 (2)
◆ 在使用 字典(dict), 列表(list), 元組(tuple), 參數(argument)列表時， 應在 "," 前添加一個空格, 并且使用字典(dict)時，在 ":" 號后添加空格，而不是在前面添加。
◆ 在括號之前或參數之前不添加空格。
◆ 在文檔注釋中前后應該沒有空格。
Python代碼
- def make_squares(key, value=0):
- """Return a dictionary and a list..."""
- d = {key: value}
- l = [key, value]
- return d, l
命名
◆ joined_lower 可以是 函數名, 方法名, 屬性名
◆ joined_lower or ALL_CAPS 是常量
◆ StudlyCaps 類名
◆ camelCase 只有在預先制定好的命名規范使用
◆ 屬性: interface, _internal, __private
◆ 但盡量避免__private形式。下面兩個鏈接解釋了 為什么python中沒有 private聲明?
http://stackoverflow.com/questions/70528/why-are-pythons-private-methods-not-actually-private
http://stackoverflow.com/questions/1641219/does-python-have-private-variables-in-classes
較長代碼行
保持一行代碼在 80 個字符長度。
在括號內使用隱含的行延續：
Python代碼
- def __init__(self, first, second, third,
- fourth, fifth, sixth):
- output = (first + second + third
- + fourth + fifth + sixth)
或者在需要換行的位置使用 \ 來延續行：
Python代碼
- VeryLong.left_hand_side \
- = even_longer.right_hand_side()
另外，使用反斜杠是有風險的，如果你添加一個空格在反斜杠后面，它就出錯了。此外，它使代碼難看。
較長字符串
將相鄰的字符串進行連接的做法：
Python代碼
- >>> print 'o' 'n' "e"
- one
雖然字符之間的空格不是必需的，但是這樣有助于可讀性。
Python代碼
- >>> print 't' r'\/\/' """o"""
- t\/\/o
用一個 “r“ 開頭的字符串是一個“raw“的字符串(類似java中的轉義符)。上面的反斜杠就會當成普通字符串處理。他們對正則表達式和Windows文件系統路徑非常有用。
注意：使用字符串變量名無法通過以上方式進行連接。
Python代碼
- >>> a = 'three'
- >>> b = 'four'
- >>> a b
- File "<stdin>", line 1
- a b
- ^
- SyntaxError: invalid syntax
這是因為自動連接是由Python解析器/編譯器來處理的，因為其無法在編譯時對變量值進行"翻譯"，所以就這種必須在運行時使用“+“運算符來連接變量。
復合語句
Good：
Python代碼
- if foo == 'blah':
- do_something()
- do_one()
- do_two()
- do_three()
Bad：
Python代碼
- if foo == 'blah': do_something()
- do_one(); do_two(); do_three()
文檔注釋(Docstrings) & 注釋
文檔注釋 = 用于解釋如何使用代碼
文檔注釋公約：http://www.python.org/dev/peps/pep-0257/
注釋 = 為什么 (理由) & 代碼如何工作的如：
Python代碼
- # !!! BUG: ...
- # !!! FIX: This is a hack
- # ??? Why is this here?
注釋對于任何語言開發者來說已經最基本的東西了，這里就不詳細說了.
交換變量
在其它語言的交換變量的做法一般是:
Java代碼
- temp = a
- a = b
- b = temp
Python的做法：
Python代碼
- b, a = a, b
也許你見到過這樣的情況，但是你知道它是如何工作的嗎?
◆ 首先，逗號是元組構造語法。
◆ 等號的右邊是定義一個元組 (tuple packing).
◆ 其左邊為一個目標元組 (tuple unpacking)).
右邊的元組根據名稱被 unpacked 到左邊的無組。
更多關于 unpacked例子：
Python代碼
- >>> info =['David', 'Pythonista', '+1250']
- >>> name, title, phone = info
- >>> name
- 'Davids'
- >>> title
- 'Pythonista'
- >>> phone
- '+1250'
在結構化的數據上使用循環：
info 是在上面定義的一個 list . 所以下面的 people 有兩個項, 兩個項都是分別都擁有三個項的 list.
Python代碼
- >>> people = [info, ['Guido', 'BDFL', 'unlisted']]
- >>> for (name, title, phone) in people:
- ... print name, phone
- ...
- David +1250
- Guido unlisted
以上循環中，people中的兩個項(list item)，都已經被 unpacked 到 (name, title, phone) 無組中。
可以任意嵌套(只要左右兩邊的結構一定要能夠匹配得上):
Python代碼
- >>> david, (gname, gtitle, gphone) = people
- >>> gname
- 'Guido'
- >>> gtitle
- 'BDFL'
- >>> gphone
- 'unlisted'
- >>> david
- ['David', 'Pythonista', '+1250']
#p#
更多關于 Tuples
我們看到的是元組通過逗號構造，而不是括號。例如：
Python代碼
- >>> 1,
- (1,)
Python的解釋器會為你顯示括號，所以建議你使用括號：
Python代碼
- >>> (1,)
- (1,)
千萬不要忘記逗號!
Python代碼
- >>> (1)
- 1
在只有一個元素的元組，尾隨逗號是必須的，在2 + 元素的元組，尾隨逗號是可選的。 如果創建一個 0或空元組，一對括號是快捷的語法：
Python代碼
- >>> ()
- ()
- >>> tuple()
- ()
一個常見的錯誤當你并不想要一個無組，卻無意的添加了一個逗號，很容易造成你在代碼中的錯誤，如：
Python代碼
- >>> value = 1,
- >>> value # is a tuple, not a int
- (1,)
所以，當你發現一個元組時，趕緊去找一下那個,號吧。
關于 "_"
是一個非常有用的功能，但是卻很少有人知道。
當你在交互式模式下(如 IDEL)計算一個表達式或調用一個函數后，其結果必然是一個臨時名稱，_(下劃線)：
Python代碼
- >>> 1 + 1
- 2
- >>> _
- 2
在 _ 中存儲***輸出的值。
當輸出的結果是 None 或沒有任何輸出時，而 _ 的值并不會改變，仍然保存上一次的值。這就是方便所在。
當然，這只能交互式的模式中使用，在模塊中不能支持。
這在交互式模式中是非常有用的，當你在過程中沒有保存計算結果 或 你想看***一步的執行的輸出結果：
Python代碼
- >>> import math
- >>> math.pi / 3
- 1.0471975511965976
- >>> angle = _
- >>> math.cos(angle)
- 0.50000000000000011
- >>> _
- 0.50000000000000011
創建String: 從列表中創建
開始定義一個 string 列表：
Python代碼
- colors = ['red', 'blue', 'green', 'yellow']
當我們需要將上面的列表連接成一個字符串。尤其當 list 是一個很大的列表時....
不要這樣做：
Python代碼
- result = ''
- for s in colors:
- result += s
這種方式效率非常低下的，它有可怕的內存使用問題，至于為什么，如果你是 javaer 的話，其中的 string 連接，我想你并不陌生。
相反，你應該這樣做：
Python代碼
- result = ''.join(colors)
當你只有幾十或幾百個string項連接時，它們效率上并不會太大的差別。但你要在養成寫高效代碼的習慣，因為當字符串數千時，join 比起 for 連接性能會能有所提升。
如果你需要使用一個函數來生成一個字符串列表，同樣可以使用：
Python代碼
- result = ''.join(fn(i) for i in items)
盡可能的使用
Good:
Python代碼
- for key in d:
- print key
◆ 使用 in 一般情況下是非常快的。
◆ 這種方式也適用于其它的容器對象(如 list，tuple 和 set)。
◆ in 是操作符(正如上面所看到的)。
Bad:
Python代碼
- for key in d.keys():
- print key
保持與上面的一致性，使用 use key in dict 方式，而不是 dict.has_key():
Python代碼
- # do this:
- if key in d:
- ...do something with d[key]
- # not this:
- if d.has_key(key):
- ...do something with d[key]
#p#
字典中的 get 函數
我們經常需要在字典中初始化數據：
以下是不好的實現方法：
Python代碼
- navs = {}
- for (portfolio, equity, position) in data:
- if portfolio not in navs:
- navs[portfolio] = 0
- navs[portfolio] += position * prices[equity]
使用dict.get(key, default) 刪除 if 判斷代碼：
Python代碼
- navs = {}
- for (portfolio, equity, position) in data:
- navs[portfolio] = (navs.get(portfolio, 0)
- + position * prices[equity])
這種方式更為直接。
字典中的 setdefault 函數 (1)
當我們要初始化一個可變字典的值。每個字典的值將是一個列表。下面是不好的做法：
初始化可變字典的值：
Python代碼
- equities = {}
- for (portfolio, equity) in data:
- if portfolio in equities:
- equities[portfolio].append(equity)
- else:
- equities[portfolio] = [equity]
通過 dict.setdefault(key, default) 使這段代碼工作的更好:
Python代碼
- equities = {}
- for (portfolio, equity) in data:
- equities.setdefault(portfolio, []).append(
- equity)
dict.setdefault()等同于“ get, or set & get“ 或"如果沒有，就設置"; 如果你的字典Key是復雜的計算或long類型，使用 setdefault 是特別有效的。
字典中的 setdefault 函數 (2)
在我們看到的setdefault字典方法也可以作為一個獨立的語句使用：
Python代碼
- avs = {}
- for (portfolio, equity, position) in data:
- navs.setdefault(portfolio, 0)
- navs[portfolio] += position * prices[equity]
我們在這里忽略了字典的setdefault方法返回的默認值。我們正利用的setdefault中的作用，僅僅只是在dict中沒有 key 的值的時候才會設置。
創建 & 分割字典
如果你有兩份 list 對象，希望通過這兩個對象構建一個 dict 對象。
Python代碼
- given = ['John', 'Eric', 'Terry', 'Michael']
- family = ['Cleese', 'Idle', 'Gilliam', 'Palin']
- pythons = dict(zip(given, family))
- >>> pprint.pprint(pythons)
- {'John': 'Cleese',
- 'Michael': 'Palin',
- 'Eric': 'Idle',
- 'Terry': 'Gilliam'}
同樣，如果希望獲取兩份列表，也是非常簡單：
Python代碼
- >>> pythons.keys()
- ['John', 'Michael', 'Eric', 'Terry']
- >>> pythons.values()
- ['Cleese', 'Palin', 'Idle', 'Gilliam']
需要注意的是，上面 list 雖然是有序的，但是 dict 中的 keys 和 values 是無序的，這正是因為 dict 本質就是無序存儲的。
索引 & 項 (1)
如果你需要一個列表，這里有一個可愛的方式來節省你的輸入：
Python代碼
- >>> items = 'zero one two three'.split()
- >>> print items
- ['zero', 'one', 'two', 'three']
如果我們需要遍歷這個 list ，而且需要 index 和 item：
Python代碼
- - or -
- i = 0
- for item in items: for i in range(len(items)):
- print i, item print i, items[i]
- i += 1
索引 & 項 (2): enumerate
通過 enumerate 可以返回 list 中的 (index, item)元組：
Python代碼
- >>> print list(enumerate(items))
- [(0, 'zero'), (1, 'one'), (2, 'two'), (3, 'three')]
于是，遍歷list獲取index 及 item 就更加簡單了：
Python代碼
- for (index, item) in enumerate(items):
- print index, item
Python代碼
- # compare: # compare:
- index = 0 for i in range(len(items)):
- for item in items: print i, items[i]
- print index, item
- index += 1
不難看出，使用 enumerate 比起下面兩種方式，更加簡單，更加容易閱讀，這正是我們想要的。
下面是例子是如何通過 enumerate 返回迭代器：
Python代碼
- >>> enumerate(items)
- <enumerate object at 0x011EA1C0>
- >>> e = enumerate(items)
- >>> e.next()
- (0, 'zero')
- >>> e.next()
- (1, 'one')
- >>> e.next()
- (2, 'two')
- >>> e.next()
- (3, 'three')
- >>> e.next()
- Traceback (most recent call last):
- File "<stdin>", line 1, in ?
- StopIteration
默認參數值
這是對于一個初學者常犯的錯誤，甚至于一些高級開發人員也會遇到，因為他們并不了解 Python 中的 names.
Python代碼
- def bad_append(new_item, a_list=[]):
- a_list.append(new_item)
- return a_list
這里的問題是，a_list是一個空列表，默認值是在函數定義時進行初始化。因此，每次調用該函數，你會得到不相同的默認值。嘗試了好幾次：
Python代碼
- >>> print bad_append('one')
- ['one']
- >>> print bad_append('two')
- ['one', 'two']
列表是可變對象，你可以改變它們的內容。正確的方式是先獲得一個默認的列表(或dict，或sets)并在運行時創建它。
Python代碼
- def good_append(new_item, a_list=None):
- if a_list is None:
- a_list = []
- a_list.append(new_item)
- return a_list
判斷 True 值
Python代碼
- # do this: # not this:
- if x: if x == True:
- pass pass
它的優勢在于效率和優雅。
判斷一個list：
Python代碼
- # do this: # not this:
- if items: if len(items) != 0:
- pass pass
- # and definitely not this:
- if items != []:
- pass
True 值
True和False是內置的bool類型的布爾值的實例。誰都只有其中的一個實例。
| False | True |
| False (== 0) | True (== 1) |
| "" (empty string) | any string but "" (" ", "anything") |
| 0, 0.0 | any number but 0 (1, 0.1, -1, 3.14) |
| [], (), {}, set() | any non-empty container ([0], (None,), ['']) |
| None | almost any object that's not explicitly False |
簡單比復雜好
Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it.
—Brian W. Kernighan
不要重新發明輪子
在寫任何代碼之前,
➔ ➔ ➔ ➔
檢查python 標準庫.http://docs.python.org/library/index.html
檢查Python的包索引 (the "Cheese Shop"):
http://cheeseshop.python.org/pypi
Search the web. Google is your friend.
原文：[urlhttp://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html][url]
【編輯推薦】
