我們都喜歡 Python，因為它讓編程和理解變的更為簡單。但是一不小心，我們就會忽略規則，以非 Pythonic 方式編寫一堆垃圾代碼，從而浪費 Python 這個出色的語言賦予我們的優雅。Python 的代碼風格是非常優雅、明確和簡單，在 Python 解釋器中執行?import this?你可以看到 Tim Peters 編寫的 Python 之禪：

>>>?import?this

The?Zen?of?Python,?by?Tim?Peters

Beautiful?is?better?than?ugly.

Explicit?is?better?than?implicit.

Simple?is?better?than?complex.

Complex?is?better?than?complicated.

Flat?is?better?than?nested.

Sparse?is?better?than?dense.

Readability?counts.

Special?cases?aren't?special?enough?to?break?the?rules.

Although?practicality?beats?purity.

Errors?should?never?pass?silently.

Unless?explicitly?silenced.

In?the?face?of?ambiguity,?refuse?the?temptation?to?guess.

There?should?be?one--?and?preferably?only?one?--obvious?way?to?do?it.

Although?that?way?may?not?be?obvious?at?first?unless?you're?Dutch.

Now?is?better?than?never.

Although?never?is?often?better?than?*right*?now.

If?the?implementation?is?hard?to?explain,?it's?a?bad?idea.

If?the?implementation?is?easy?to?explain,?it?may?be?a?good?idea.

Namespaces?are?one?honking?great?idea?--?let's?do?more?of?those!

這里我找了目前最好的中文版本：

美 優于 丑

明確 優于 隱晦

簡單 優于 復雜

復雜 也好過 繁復

扁平 優于 嵌套

稀疏 優于 擁擠

可讀性很重要

固然代碼實用與否 比潔癖更重要，

我們以為的特例也往往沒有特殊到必須打破上述規則的程度

除非刻意地靜默，否則不要無故忽視異常

如果遇到模棱兩可的邏輯，請不要自作聰明地瞎猜。

應該提供一種，且最好只提供一種，一目了然的解決方案

當然這是沒法一蹴而就的，除非你是荷蘭人[1]

固然，立刻著手 好過 永遠不做。

然而，永遠不做 也好過 不審慎思考一擼袖子就莽著干

如果你的實現很難解釋，它就一定不是個好主意

即使你的實現簡單到爆，它也有可能是個好辦法

命名空間大法好，不搞不是地球人！

[1]：本文作者 Tim peters 解釋說這里的荷蘭人指的是 Python 的作者 Guido van Rossum.

以下是用 Python 編寫更好的代碼的 8 種方法：

一、忘掉類 C 語言風格

如果需要打印列表中的所有元素及其索引，你想到的第一件事是：

for?i?in?range(len(arr)):

print(i,?arr[i])

那么你仍然在編寫 C 代碼。擺脫這一點，請牢記 Python 關鍵字 enumerate 。它索引列表/字符串中的所有元素，并且支持設置索引的起始編號：

>>>?for?index,?item?in?enumerate(['a','b','c']):

...?????print(index,?item)

...

0?a

1?b

2?c

>>>?for?index,?item?in?enumerate(['a','b','c'],1):?#這里第二個參數可以設置起始編號

...?????print(index,item)

...

1?a

2?b

3?c

現在看起來更好了，而且更加 Pythonic。將列表轉換成字符串呢？如果你這樣寫：

#?The?C?way

string?=?''

for?i?in?arr:

string?+=?i

就是 C 風格，如果使用 Python 的關鍵字 join，不僅效率更高，而且更優雅：

#?The?Python?way

string?=?''.join(arr)

就像 join 一樣 ?，Python 有很多神奇的關鍵字，因此請不要為語言工作，而是使用該語言為你工作。

二、牢記 PEP8

我不是要求你完全遵循 PEP8，而是要求遵循其中的大多數規則，何況現在有很多自動格式化的工具，足以讓你的代碼更加美觀，我們的 Python 之父也說過：閱讀代碼的頻率遠遠高于寫代碼的頻率，他是如此的正確！因此代碼的可讀性非常重要。

你是否對自己曾經寫過的代碼感到好奇？為什么這么寫，這句話為什么在這？好吧，PEP8 是大多數這類問題的答案。盡管代碼注釋是個好方法，但是代碼的風格也需要加以調整，比如變量 i ， j ， count 等即使第一次出現時寫了注釋，也不能保證后面你仍然記得住，這樣來看就浪費了寶貴的時間。

任何普通的程序員都可以編寫計算機可以理解的代碼。只有好的程序員可以編寫人類可以理解的代碼。

首選 CamelCase 作為類， UPPER_WITH_UNDERSCORES 作為常量，而 lower_with_underscores 作為變量，方法和模塊名稱。即使使用，也要避免使用單一名稱功能 lambda 。

三、善用推導式

常用的推導式有：列表推導式，集合推導式，字典推導式。先說下列表推導式。

列表推導式就是當我們需要基于一個已有的列表創建新的列表時，所使用的語法格式，列表推導式包含以下四個部分：

1、一個輸入序列(Input Sequence) 2、一個變量，代表著輸入序列的一個成員(Variable) 3、一個可選的判定表達式，表達這個變量滿足的條件(Optional Predicate ) 4、一個輸出序列，根據 2 和 3 生成一個輸出序列(Output Expression)

比如有個列表既有數字，又有字符，現在需要計算數字的平方，并將結果放在新的列表中，如果不用列表推導式，寫出的代碼就是這樣的：

#?bad?code

a_list?=?[1,?‘4’,?9,?‘a’,?0,?4]

squared_ints?=?[]

for?item?in?a_list:

if?type(item)?==?types.IntType:

squared_ints.append(item**2)

如果使用列表推導式，只需要兩行代碼，非常的優雅：

a_list?=?[1,?‘4’,?9,?‘a’,?0,?4]

squared_ints?=?[?e**2?for?e?in?a_list?if?type(e)?==?types.IntType?]

當然，如果你喜歡 map 和 filter，你還可以這樣做，當時這是不推薦的，因為可讀性不好：

map(lambda?e:?e**2,?filter(lambda?e:?type(e)?==?types.IntType,?a_list))

比如集合推導式的使用：

給定輸入

names?=?[?'Bob',?'JOHN',?'alice',?'bob',?'ALICE',?'J',?'Bob'?]

希望得到：

{?'Bob',?'John',?'Alice'?}

那么集合推導式就是：

{?name[0].upper()?+?name[1:].lower()?for?name?in?names?if?len(name)?>?1?}

再比如字典推導式：

mcase?=?{'a':10,?'b':?34,?'A':?7,?'Z':3}

mcase_frequency?=?{?k.lower()?:?mcase.get(k.lower(),?0)?+?mcase.get(k.upper(),?0)?for?k?in?mcase.keys()?}

#?mcase_frequency?==?{'a':?17,?'z':?3,?'b':?34}

從上面可以看出。推導式風格的代碼是優雅的，人類易讀的。

四、你還在顯式的關閉文件嗎？

如果你在寫代碼時仍然在顯式的關閉文件，就像上圖中的 programmer，你在為編程語言工作，如果你學會了使用 with 上下文管理器，那么你就是一個 Python programmer，讓編程語言為你工作：

with?open('filename.txt',?'w')?as?filename:????filename.write('Hello')

當程序退出 with 塊時，文件會自動關閉。with 語句的語法格式：

with?VAR?as?EXPR:????BLOCK

相當于：

mgr?=?(EXPR)

exit?=?type(mgr).__exit__??#?Not?calling?it?yet

value?=?type(mgr).__enter__(mgr)

exc?=?True

try:

try:

VAR?=?value??#?Only?if?"as?VAR"?is?present

BLOCK

except:

#?The?exceptional?case?is?handled?here

exc?=?False

if?not?exit(mgr,?*sys.exc_info()):

raise

#?The?exception?is?swallowed?if?exit()?returns?true

finally:

#?The?normal?and?non-local-goto?cases?are?handled?here

if?exc:

exit(mgr,?None,?None,?None)

有很多網絡連接、數據庫連接庫都會提供 with 功能。甚至熟悉了 with 的實現機制后，可以自行實現 with 功能:

class?File(object):

def?__init__(self,?file_name,?method):

self.file_obj?=?open(file_name,?method)

def?__enter__(self):

return?self.file_obj

def?__exit__(self,?type,?value,?traceback):

self.file_obj.close()

只要定義了?__enter__,__exit__方法，就可以使用 with 語句：

with?File('demo.txt',?'w')?as?opened_file:????opened_file.write('Hola!')

五、使用迭代器和生成器

迭代器：iterator 生成器：generator

迭代器和生成器都是 Python 中功能強大的工具，值得精通。迭代器是一個更籠統的概念：任何一個對象只要它所屬的類具有__next__方法(Python 2是next)和具有返回 self 的__iter__方法都是迭代器。

每個生成器都是一個迭代器，但反之不然。生成器是通過調用具有一個或多個 yield 表達式的函數而構建的，并且該函數是滿足上一段對iterator 的定義的對象。

使用區別：

網絡上很多技術博主都說生成器是懶人版的迭代器，比迭代器更節省內存，其實是錯誤的，他們都很節省內存(我會舉例子)。

他們真正的區別是：當你需要一個具有某些復雜的狀態維護行為的類，或者想要公開除__next__(和__iter__和__init__)之外的其他方法時，你就需要自定義迭代器，而不是生成器。

通常，一個生成器(有時，對于足夠簡單的需求，一個生成器表達式)就足夠了，并且它更容易編寫代碼。

比如說計算正整數 a 到 b (b 遠遠大于 a)直接的平方，生成器的話就是：

def?squares(start,?stop):????for?i?in?range(start,?stop):????????yield?i?*?i generator?=?squares(a,?b)

或者：

generator?=?(i*i?for?i?in?range(a,?b))

如果是迭代器，則是這樣：

class?Squares(object):????def?__init__(self,?start,?stop):???????self.start?=?start???????self.stop?=?stop????def?__iter__(self):?return?self????def?__next__(self):?#?next?in?Python?2???????if?self.start?>=?self.stop:???????????raise?StopIteration???????current?=?self.start?*?self.start???????self.start?+=?1???????return?current iterator?=?Squares(a,?b)

可以看出，迭代器寫起來稍麻煩，當也更為靈活，比如你想提供一個 current 方法時，可以直接添加到 Squares 類中：

def?current(self):???????return?self.start

從上述可以看出，迭代器并沒有保存 a 到 b 之間的所有值，所有并不消耗過多的內存，這一點也可以自行測試，代碼如下：

>>>?from?collections.abc?import?Iterator>>>?from?sys?import?getsizeof>>>?a?=?[i?for?i?in?range(1001)]>>>?print(type(a))>>>?print(getsizeof(a))9016>>>>>>?b?=?iter(a)>>>?print(type(b))>>>?print(isinstance(b,Iterator))True>>>?print(getsizeof(b))48>>>?c?=?(i?for?i?in?range(1001))>>>?print(getsizeof(b))48>>>?type(c)>>>?type(b)

可以看出 b 是 iterator，c 是 generator，它們占用的內存大小是一樣的。

六、善用 itertools

itertools 模塊標準化了一個快速、高效利用內存的核心工具集，這些工具本身或組合都很有用。它們一起形成了“迭代器代數”，這使得在純 Python 中有可以創建簡潔又高效的專用工具。比如，如果你想要字符串中所有字符的組合或列表中數字的所有組合，則只需編寫

from?itertools?import?combinationsnames?=?'ABC'for?combination?in?combinations(names,?2):????print(combination)'''?Output?-????('A',?'B')????('A',?'C')????('B',?'C')'''

這是一個值得經常使用的標準庫，更多詳細功能請參考官方文檔:https://docs.python.org/zh-cn/3/library/itertools.html[1]

七、善用 collections

這又是一個值得使用的標準庫 collections，它提供替代內置的數據類型的多個容器，如 defaultdict、OrderedDict、namedtuple、Counter、deque 等，非常使用，而且比自己實現要安全穩定的多。比如：

#?frequency?of?all?characters?in?a?string?in?sorted?orderfrom?collections?import?(OrderedDict,?Counter)string?=?'abcbcaaba'freq?=?Counter(string)freq_sorted?=?OrderedDict(freq.most_common())for?key,?val?in?freq_sorted.items():????print(key,?val)'''?Output?-????('a',?4)????('b',?3)????('c',?2)'''

不多說了，看官方文檔：https://docs.python.org/3/library/collections.html[2]

八、不要過度使用類

不要過度使用類。堅持用 Java 和 C ++ 的程序員會經常使用類，但是在使用 Python 時，可以在函數和模塊的幫助下復用代碼。除非絕對需要，否則不必創建類。

本文講述類 8 個讓你寫出更好 Python 代碼的方法，希望對你有所幫助。

總結

以上是生活随笔為你收集整理的python代码怎么写出色_如何写出更具有Python风格的代码，五分钟教会你！的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。