摘要：如果需要在二元運(yùn)算符周圍做換行操作，例如和，那么需要將換行操作放在前面，這條規(guī)則源于數(shù)學(xué)，數(shù)學(xué)家同意在二元運(yùn)算符之前換行以可提高可讀性，比較以下兩個(gè)例子。在二元運(yùn)算符之前換行可以讓代碼更加具有可讀性，所鼓勵(lì)這種方式。

原文地址：How to Write Beautiful Python Code With PEP 8

作者：Jasmine Finer

翻譯：howie6879

目錄如下：

Why We Need PEP 8

Naming Conventions

Naming Styles

How to Choose Names

Code Layout

Blank Lines

Maximum Line Length and Line Breaking

Indentation

Tabs vs. Spaces

Indentation Following Line Breaks

Where to Put the Closing Brace

Comments

Block Comments

Inline Comments

Documentation Strings

Whitespace in Expressions and Statements

Whitespace Around Binary Operators

When to Avoid Adding Whitespace

Programming Recommendations

When to Ignore PEP 8

Tips and Tricks to Help Ensure Your Code Follows PEP 8

Linters

Autoformatters

Conclusion

PEP 8有時(shí)候讀作PEP8 或者PEP-8，是一份提供如何編寫Python代碼指南和最佳實(shí)踐的文檔，由Guido van Rossum, Barry Warsaw, Nick Coghlan在2001年完成。PEP 8主要注重于提高 Python 代碼的可讀性和一致性。

PEP全稱為：Python Enhancement Proposal，一個(gè)PEP是一份文檔，它描述了為Python提出的新特性以及為社區(qū)編寫的Python方面的文檔，比如設(shè)計(jì)和風(fēng)格。

本教程概述了PEP 8中列出的關(guān)鍵指南，它的目標(biāo)讀者是初級(jí)到中級(jí)程序員，因此我沒有涉及一些最高級(jí)的主題。不過你可以通過閱讀完整的PEP 8 — Style Guide for Python Code | Python.org文檔來學(xué)習(xí)高級(jí)主題。

在本教程結(jié)束時(shí)，你將能夠：

編寫遵從PEP 8規(guī)范的代碼

理解PEP 8中列出的指導(dǎo)原則背后的原因

設(shè)置你的開發(fā)環(huán)境，以便開始編寫符合PEP 8標(biāo)準(zhǔn)的Python代碼

可讀性很重要

PEP 8規(guī)范存在的目的在于提高Python代碼的可讀性，但為什么可讀性如此重要？為什么編寫具有可讀性的代碼是Python語言的指導(dǎo)原則之一？

正如Guido van Rossum所說：”代碼閱讀的頻率遠(yuǎn)遠(yuǎn)高于編寫的頻率“。你可能花費(fèi)幾分鐘或一整天時(shí)間編寫一段代碼來處理用戶身份驗(yàn)證，一旦你寫完它，你就再也不會(huì)重寫一次，但是你肯定會(huì)再讀一次，這段代碼可能仍然是你正在進(jìn)行的項(xiàng)目的一部分。每次你回到那個(gè)代碼文件，你必須要記住那部分代碼是做什么的以及你為什么要寫它，所以可讀性很重要。

如果你是Python新手，在你編寫代碼之后的幾天或幾周內(nèi)還要你記住代碼片段的含義可能有點(diǎn)困難。如果你遵循PEP 8標(biāo)準(zhǔn)，你可以很確定你對(duì)你的變量命名得很好，你會(huì)知道你添加了足夠的空格，因此更容易遵循代碼中的邏輯步驟，你還可以對(duì)你的代碼進(jìn)行很好的注釋，所有的這些都意味著你的代碼具有更高的可讀性，也更容易再次閱讀。作為初學(xué)者，遵循PEP 8的規(guī)則可以使學(xué)習(xí)Python成為更愉快的任務(wù)。

如果你正在找工作，那么遵循PEP 8標(biāo)準(zhǔn)尤為重要，編寫清晰可讀性高的代碼更會(huì)突出你的專業(yè)性，這將會(huì)側(cè)面告訴你的老板，你了解怎么很好地構(gòu)建你的代碼。

如果你擁有很多編寫Python代碼的經(jīng)驗(yàn)，然后你可能需要和其他人協(xié)作開發(fā)，編寫可讀性高的代碼在這里至關(guān)重要，其他人可能此前從未看過你這樣風(fēng)格的代碼，他必須重新閱讀且理解你的代碼風(fēng)格，如果擁有你遵循和認(rèn)可的指南將使其他人更容易閱讀你的代碼。

明了勝于晦澀

當(dāng)你編寫Python代碼的時(shí)候，你必須對(duì)很多東西命名：變量、函數(shù)、類、包等等，選擇合理的名字將為你節(jié)省時(shí)間和精力。你將能夠從名稱中找出某個(gè)變量，函數(shù)或類所代表的含義。你還要避免使用不恰當(dāng)?shù)拿Q，因?yàn)檫@樣可能會(huì)導(dǎo)致難以調(diào)試的錯(cuò)誤。

::Note: 永遠(yuǎn)不要使用 i，o，或 I 單字母名稱，因?yàn)檫@些名稱可能會(huì)被誤認(rèn)為1和0，具體取決于字體:::

# 這可能看起來像你試圖將2重新分配給零
0 = 2 

下表概述了Python代碼中的一些常見命名風(fēng)格以及何時(shí)應(yīng)該使用它們：

這些是一些常見的命名約定以及如何使用它們的示例，但是為了編寫高可讀性代碼，你仍然需要謹(jǐn)慎選擇字母和單詞。除了在代碼中選擇正確的命名風(fēng)格外，還必須仔細(xì)選擇名稱，以下是有關(guān)如何盡可能有效地執(zhí)行此操作的一些指示。

為變量、函數(shù)、類等選擇名稱是一項(xiàng)挑戰(zhàn)，在編寫代碼時(shí)，你應(yīng)該在命名選擇中加入相當(dāng)多的思考，因?yàn)檫@樣可以使代碼更具可讀性。在Python中為對(duì)象命名的最佳方法是使用描述性名稱來清楚表明對(duì)象所代表的內(nèi)容。

對(duì)變量進(jìn)行命名時(shí)，你可能會(huì)選擇簡(jiǎn)單的單字母小寫名稱，例如x。但是，除非你使用x作為數(shù)學(xué)函數(shù)的參數(shù)，否則并不清楚x代表什么。想象下你正在將一個(gè)人的名字保存為字符串，并且你希望使用字符串切片來格式化其名稱。你最終會(huì)得到這樣的東西：

# Not recommended
x = "John Smith"
y, z = x.split()
print(z, y, sep=", ")
# "Smith, John"

上面代碼可以很好的運(yùn)行，但是你必須追蹤x,y,z表示的含義，這樣也會(huì)讓你的代碼協(xié)作者產(chǎn)生困擾，更明確的名稱選擇將是這樣的：

# Recommended
name = "John Smith"
first_name, last_name = name.split()
print(last_name, first_name, sep=", ")
# "Smith, John"

同樣，為了減少輸入的數(shù)量，在選擇名稱時(shí)使用單詞縮寫也是很有誘惑力的，在下面的例子中，我定義了一個(gè)函數(shù)db()，它接受一個(gè)參數(shù)x并將其加倍返回：

# Not recommended
def db(x):
    return x * 2

乍一看，這似乎是一個(gè)明智的選擇。 db()很容易看成是double的縮寫，但想象一下，幾天后再看這段代碼，你可能已經(jīng)忘記了你試圖通過這個(gè)函數(shù)實(shí)現(xiàn)的目標(biāo)是什么，這將使猜測(cè)它原本的含義變得困難。

下面的例子就比較清晰，如果你幾天后再看這段代碼，你仍然可以閱讀并理解此函數(shù)的目標(biāo)：

# Recommended
def multiply_by_two(x):
    return x * 2

同樣的理念適用于Python中的所有其他數(shù)據(jù)類型和對(duì)象，盡量一直使用最簡(jiǎn)潔且最具描述性的名稱。

優(yōu)美勝于丑陋

如何對(duì)代碼布局對(duì)于提升它的可讀性有很大的作用。在本節(jié)中，你將學(xué)習(xí)如何添加垂直空格以提高代碼的可讀性。你還將學(xué)習(xí)如何處理PEP 8中建議的79字符行限制。

垂直空格或空行可以極大地提高代碼的可讀性，聚集在一起的代碼可能是壓倒性的且難以閱讀，同樣，代碼中的空行太多會(huì)使其看起來非常稀疏，讀者可能需要進(jìn)行沒必要的滾動(dòng)，以下是關(guān)于如何使用垂直空白的三個(gè)關(guān)鍵指南。

用兩個(gè)空行包圍頂級(jí)函數(shù)和類，頂級(jí)函數(shù)和類應(yīng)該是完全自包含的，并處理多帶帶的功能，在它們周圍放置額外的垂直空間是有意義的，因此很明顯它們是分開的：

class MyFirstClass:
    pass


class MySecondClass:
    pass


def top_level_function():
    return None

用一個(gè)空行包圍類中的方法定義，在一個(gè)類中，函數(shù)都彼此有聯(lián)系，最好只在它們之間留一行：

class MyClass:
    def first_method(self):
        return None

    def second_method(self):
        return None

在函數(shù)內(nèi)部謹(jǐn)慎地使用空行，以顯示清晰的步驟，有時(shí)候一個(gè)復(fù)雜的函數(shù)必須在return語句之前完成好幾個(gè)步驟，為了幫助閱讀者理解函數(shù)里面的邏輯，在每個(gè)步驟之間留一個(gè)空行會(huì)很有幫助。

在下面的示例中，有一個(gè)計(jì)算列表方差的函數(shù)，這個(gè)問題可以分為兩個(gè)步驟，所以我在每個(gè)步驟之間留下了一個(gè)空行，在return語句之前還有一個(gè)空行。這有助于讀者清楚地看到返回的內(nèi)容：

def calculate_variance(number_list):
    sum_list = 0
    for number in number_list:
        sum_list = sum_list + number
    mean = sum_list / len(number_list)

    sum_squares = 0
    for number in number_list:
        sum_squares = sum_squares + number**2
    mean_squares = sum_squares / len(number_list)

    return mean_squares - mean**2

如果仔細(xì)地使用垂直空格，可以大大提高代碼的可讀性，它有助于讀者直觀地理解你的代碼如何分成幾個(gè)部分，以及這些部分如何相互關(guān)聯(lián)。

PEP 8建議每行代碼限制在79個(gè)字符以內(nèi)，這是因?yàn)樗试S多個(gè)文件并排打開，同時(shí)也避免了換行，當(dāng)然，將語句保持在79個(gè)字符以內(nèi)并不總是可行的。PEP 8概述了允許語句在多行上運(yùn)行的方法。

如果代碼包含在括號(hào)、方括號(hào)或大括號(hào)中，Python將會(huì)認(rèn)為代碼是一行的：

def function(arg_one, arg_two,
             arg_three, arg_four):
    return arg_one

如果不能用上述的方式進(jìn)行每行代碼延續(xù)，那么可以使用反斜杠代替換行：

from mypkg import example1, 
    example2, example3

但是，如果可以使用第一個(gè)方案，那么就應(yīng)該盡量這樣做。

如果需要在二元運(yùn)算符周圍做換行操作，例如+和*，那么需要將換行操作放在前面，這條規(guī)則源于數(shù)學(xué)，數(shù)學(xué)家同意在二元運(yùn)算符之前換行以可提高可讀性，比較以下兩個(gè)例子。

下面是在二元運(yùn)算符之前換行的示例：

# Recommended
total = (first_variable
         + second_variable
         - third_variable)

你可以馬上反應(yīng)過來哪些變量正在相加后者相減，因?yàn)椴僮鞣o鄰著變量。

現(xiàn)在，讓我們看一個(gè)在二元運(yùn)算符之后換行的示例：

# Not Recommended
total = (first_variable +
         second_variable -
         third_variable)

在這里，很難看出哪個(gè)變量被加，哪個(gè)變量被減。

在二元運(yùn)算符之前換行可以讓代碼更加具有可讀性，所PEP 8鼓勵(lì)這種方式。在二元運(yùn)算符之后換行的代碼仍然符合PEP 8，但是，我們鼓勵(lì)你在二元運(yùn)算符之前換行。

當(dāng)存在多種可能，不要嘗試去猜測(cè)  
而是盡量找一種，最好是唯一一種明顯的解決方案（如果不確定，就用窮舉法）

縮進(jìn)，即前導(dǎo)空格，在Python中非常重要。Python中代碼行的縮進(jìn)級(jí)別決定了語句如何組合在一起。

思考下面的例子：

x = 3
if x > 5:
    print("x is larger than 5")

縮進(jìn)的print語句使得Python明白只有if語句返回True才能繼續(xù)執(zhí)行它，同樣的縮進(jìn)適用于告訴 Python 在調(diào)用函數(shù)時(shí)要執(zhí)行哪些代碼，或者哪些代碼屬于給定的類。

PEP 8制定的關(guān)鍵縮進(jìn)規(guī)則如下：

使用4個(gè)連續(xù)的空格來表示縮進(jìn)。

選擇空格而不是制表符(Tab)。

如同上述所說，當(dāng)你進(jìn)行縮進(jìn)的時(shí)候，你最好用空格代替制表符，你可以直接對(duì)文本編輯器的設(shè)置進(jìn)行調(diào)整，當(dāng)你按Tab的時(shí)候轉(zhuǎn)換為4個(gè)空格的輸出

如果你使用的是Python 2并且混合使用了制表符和空格來縮進(jìn)代碼，當(dāng)你運(yùn)行的時(shí)候可能不會(huì)看見錯(cuò)誤。為了幫助你檢查一致性，可以在從命令行運(yùn)行Python 2代碼時(shí)添加-t標(biāo)志。當(dāng)你不一致地使用制表符和空格時(shí)，解釋器將會(huì)發(fā)出警告：

python2 -t code.py
code.py: inconsistent use of tabs and spaces in indentation

相反，如果你使用-tt標(biāo)志，解釋器將發(fā)出錯(cuò)誤而不是警告，使用此方法的好處是解釋器會(huì)告訴你縮進(jìn)不一致的位置在哪里：

python2 -tt code.py
File "code.py", line 3
    print(i, j)
             ^
TabError: inconsistent use of tabs and spaces in indentation

Python 3不允許制表符和空格混合使用，因此，如果你使用的是Python3，解釋器將會(huì)自動(dòng)報(bào)錯(cuò)：

python3 code.py
File "code.py", line 3
    print(i, j)
              ^
TabError: inconsistent use of tabs and spaces in indentation

你可以在編寫Python代碼中使用制表符或空格來表示縮進(jìn)，但是，如果你使用的是Python 3，則必須與你的選擇保持一致，否則你的代碼將不能運(yùn)行。PEP 8推薦你總是使用4個(gè)連續(xù)的空格來表示縮進(jìn)。

當(dāng)你為了保證每行在79個(gè)字符以下而進(jìn)行換行時(shí)，使用縮進(jìn)來提高代碼可讀性是很有用的，它允許讀者區(qū)分兩行代碼和跨越兩行的單行代碼，這里有兩種縮進(jìn)風(fēng)格供你選擇。

第一個(gè)是將縮進(jìn)塊與開始的分隔符對(duì)齊:

def function(arg_one, arg_two,
             arg_three, arg_four):
    return arg_one

有時(shí)你會(huì)發(fā)現(xiàn)只需要4個(gè)空格就可以與開口分隔符對(duì)齊，這種情況經(jīng)常發(fā)生在 if 語句中，如果跨多行的if+ +(構(gòu)成4個(gè)字符，那么就會(huì)發(fā)生這種情況，在這種情況下，很難確定 if 語句中嵌套的代碼塊從哪里開始:

x = 5
if (x > 3 and
    x < 10):
    print(x)

在這種情況下，PEP 8提供了兩種替代方案來幫助你提高代碼可讀性：

在最后的條件后添加注釋，由于大多數(shù)編輯器中有語法高亮顯示，這可以將條件與嵌套代碼分開：

x = 5
if (x > 3 and
    x < 10):
    # Both conditions satisfied
    print(x)

在換行中添加額外的縮進(jìn)：

x = 5
if (x > 3 and
        x < 10):
    print(x)

換行符后的另一種縮進(jìn)方式是懸掛縮進(jìn)(hanging indent)，這是一個(gè)印刷術(shù)語，意思是段落或語句中除第一行以外的每一行都縮進(jìn)，可以使用懸掛縮進(jìn)直觀地表示一行代碼的延續(xù)。下面是一個(gè)例子:

var = function(
    arg_one, arg_two,
    arg_three, arg_four)

::Note：當(dāng)你正在使用hanging indent時(shí)，第一行不得有任何參數(shù)。以下示例不符合PEP 8::

# Not Recommended
var = function(arg_one, arg_two,
    arg_three, arg_four)

使用hanging indent時(shí)，可以添加額外的縮進(jìn)以區(qū)分連續(xù)行與函數(shù)內(nèi)包含的代碼。下面是一個(gè)難以閱讀的例子，因?yàn)楹瘮?shù)里面的代碼和連續(xù)行的縮進(jìn)等級(jí)是相同的：

# Not Recommended
def function(
    arg_one, arg_two,
    arg_three, arg_four):
    return arg_one

相反，最好在一行代碼換行后使用雙縮進(jìn)，這有助于你區(qū)分函數(shù)參數(shù)和函數(shù)內(nèi)部構(gòu)造，從而提高可讀性：

def function(
        arg_one, arg_two,
        arg_three, arg_four):
    return arg_one

當(dāng)你編寫遵循PEP 8規(guī)范代碼的時(shí)候，每行字符在79之內(nèi)的規(guī)則使你必須強(qiáng)制換行，為了提高可讀性，你應(yīng)該縮進(jìn)一行，以表明它是一個(gè)連續(xù)的行。做到這一點(diǎn)有兩種方法，第一種是將縮進(jìn)的塊與開始的分隔符對(duì)齊，第二種是使用懸掛縮進(jìn)，在換行之后，你可以自由選擇使用哪種方法進(jìn)行縮進(jìn)。

一行代碼的換行操作允許你在括號(hào)、方括號(hào)或大括號(hào)后面斷開一行，這會(huì)造成一個(gè)問題，就是很容易忘記關(guān)閉括號(hào)，但重要的是要把它放在合理的地方，否則，它會(huì)使讀者感到困惑，Pep 8為隱含的行延續(xù)中的結(jié)束括號(hào)的位置提供了兩個(gè)選項(xiàng):

使用前一行的第一個(gè)非空白字符排列右括號(hào)：

list_of_numbers = [
    1, 2, 3,
    4, 5, 6,
    7, 8, 9
    ]

將結(jié)束括號(hào)與聲明行的第一個(gè)字符對(duì)齊:

list_of_numbers = [
    1, 2, 3,
    4, 5, 6,
    7, 8, 9
]

你可以自由地選擇任何一種方式，但是，和之前說的一樣，一致性是關(guān)鍵，所以之后的代碼就要堅(jiān)持使用你選擇的某一個(gè)方案以保持代碼一致性。

如果你無法向人描述你的方案，那肯定不是一個(gè)好方案；反之亦然

你應(yīng)該使用注釋來說明編寫的代碼，這對(duì)記錄你的代碼非常重要，這樣你的任何協(xié)作者都可以理解它。當(dāng)你或者其他人閱讀代碼注釋，他們應(yīng)該能夠很容易地理解注釋所應(yīng)用的代碼，以及它如何與代碼的其余部分相匹配。

下面是一些你為你代碼作注釋時(shí)候需要注意的關(guān)鍵點(diǎn)：

將注釋和文檔字符串的行長(zhǎng)限制為72個(gè)字符

使用完整的句子，以大寫字母開頭

注釋隨著代碼的更新而更新

使用塊注釋來記錄一小部分代碼，當(dāng)你必須編寫幾行代碼來執(zhí)行單個(gè)操作時(shí)，它們非常有用，例如從文件導(dǎo)入數(shù)據(jù)或更新數(shù)據(jù)庫記錄。其重要性在于它們可以幫助其他人理解給定代碼塊的用途和功能。

PEP 8提供以下規(guī)則來編寫注釋：

將塊注釋縮進(jìn)到其描述代碼的相同級(jí)別

用#加上一個(gè)空格開始每一行的注釋

用包含單個(gè)＃的行分隔段落

這是一個(gè)解釋for循環(huán)功能的塊注釋，請(qǐng)注意，句子為了每行保留79個(gè)字符行限制進(jìn)行了換行：

for i in range(0, 10):
    # Loop over i ten times and print out the value of i, followed by a
    # new line character
    print(i, "
")

有時(shí)，如果代碼技術(shù)性較強(qiáng)，那么有必要在塊注釋中使用多個(gè)段落：

def quadratic(a, b, c, x):
    # Calculate the solution to a quadratic equation using the quadratic
    # formula.
    #
    # There are always two solutions to a quadratic equation, x_1 and x_2.
    x_1 = (- b+(b**2-4*a*c)**(1/2)) / (2*a)
    x_2 = (- b-(b**2-4*a*c)**(1/2)) / (2*a)
    return x_1, x_2

如果你不確定什么樣的注釋類型是合適的，那么塊注釋通常是正確的選擇。請(qǐng)盡量在你的代碼中添加注釋，一旦你對(duì)代碼進(jìn)行了更新也請(qǐng)務(wù)必對(duì)注釋進(jìn)行更新！

行內(nèi)注釋對(duì)單個(gè)語句中的一段代碼進(jìn)行了解釋，這有助于提醒你或者其他人為什么某行代碼是必須的，以下是 PEP 8對(duì)他們的評(píng)價(jià):

謹(jǐn)慎使用行內(nèi)注釋

在與它們引用的語句相同的行上寫入行內(nèi)注釋

從語句中用兩個(gè)或多個(gè)空格分隔行內(nèi)注釋

像塊注釋那樣，用#加上一個(gè)空格開始每一行的注釋

不要用它們來解釋明顯的問題

下面是一個(gè)行內(nèi)注釋的例子：

x = 5  # This is an inline comment

有時(shí)，行內(nèi)注釋似乎是必要的，但是你可以使用更好的命名約定，下面是一個(gè)例子:

x = "John Smith"  # Student Name

這里，行內(nèi)注釋為變量提供了額外的說明信息，然而用x作為一個(gè)人名的變量名不是很好的做法，如果你對(duì)變量重命名，是可以不用使用行內(nèi)注釋的：

student_name = "John Smith"

最后，像這樣的行內(nèi)注釋是不好的做法，因?yàn)樗鼈冴愂隽孙@而易見且雜亂的代碼：

empty_list = []  # Initialize empty list

x = 5
x = x * 5  # Multiply x by 5

行內(nèi)注釋比塊注釋更具體，并且容易在非必要時(shí)候添加它們，這會(huì)導(dǎo)致代碼混亂。除非你確定需要行內(nèi)注釋，不然使用塊注釋避免代碼混亂的問題比較好，堅(jiān)持使用塊注釋，可以讓你的代碼更加符合PEP8的標(biāo)準(zhǔn)。

Documentation strings 或者說docstrings， 是用雙引號(hào)（”””）或單引號(hào)（’’’）括起來的字符串，它們出現(xiàn)在任何函數(shù)，類，方法或模塊的第一行，你可以使用它們來解釋和記錄特定的代碼塊。這里有一個(gè)對(duì)應(yīng)的PEP，見PEP 257，但你可以從本節(jié)閱讀總結(jié)的經(jīng)驗(yàn)：

使用文檔字符串的重要規(guī)則如下：

文檔字符串兩邊都有三個(gè)雙引號(hào)環(huán)繞，比如："""This is a docstring"""

為所有公共模塊，函數(shù)，類和方法編寫docstrings

使用單行"""結(jié)束多行docstring

def quadratic(a, b, c, x):
    """Solve quadratic equation via the quadratic formula.

    A quadratic equation has the following form:
    ax**2 + bx + c = 0

    There always two solutions to a quadratic equation: x_1 & x_2.
    """
    x_1 = (- b+(b**2-4*a*c)**(1/2)) / (2*a)
    x_2 = (- b-(b**2-4*a*c)**(1/2)) / (2*a)

    return x_1, x_2

對(duì)于單行docstrings，保持"""在同一行：

def quadratic(a, b, c, x):
    """Use the quadratic formula"""
    x_1 = (- b+(b**2-4*a*c)**(1/2)) / (2*a)
    x_2 = (- b-(b**2-4*a*c)**(1/2)) / (2*a)

    return x_1, x_2

想要了解更多，請(qǐng)閱讀Documenting Python Code: A Complete Guide – Real Python

間隔勝于緊湊

正確使用空格在表達(dá)式和語句中非常有用，如果代碼中沒有足夠的空格，那么代碼應(yīng)該很難閱讀，因?yàn)樗麄兌紲愒谝黄?，如果空格太多，又?huì)難以在視覺上將完整的語句聯(lián)系出來。

在進(jìn)行以下二元操作的時(shí)候，應(yīng)該在其兩邊加上空格：

分配操作（=, +=, -=, 等等）

比較（==, !=, >, <. >=, <=）和 （is, is not, in, not in）

布爾（and, not, or）

::Note：當(dāng)=是為一個(gè)函數(shù)的參數(shù)賦值時(shí)候就不用在兩邊加空格::

# Recommended
def function(default_parameter=5):
    # ...


# Not recommended
def function(default_parameter = 5):
    # ...

如果語句中有多個(gè)運(yùn)算符，則在每個(gè)運(yùn)算符前后添加單個(gè)空格可能會(huì)讓人感到困惑，相反，最好只在優(yōu)先級(jí)最低的運(yùn)算符周圍添加空格，尤其是在執(zhí)行數(shù)學(xué)運(yùn)算時(shí)。以下是幾個(gè)例子：

# Recommended
y = x**2 + 5
z = (x+y) * (x-y)

# Not Recommended
y = x ** 2 + 5
z = (x + y) * (x - y)

還可以將此應(yīng)用于有多個(gè)條件的if語句：

# Not recommended
if x > 5 and x % 2 == 0:
    print("x is larger than 5 and divisible by 2!")

在上面的示例中，and操作具有最低優(yōu)先級(jí)，因此，可以下面這樣更清楚地表達(dá)if語句：

# Recommended
if x>5 and x%2==0:
    print("x is larger than 5 and divisible by 2!")

你可以自由選擇哪個(gè)方式更清晰，但需要注意的是你必須在運(yùn)算符的任何一側(cè)使用相同數(shù)量的空格。

下面的例子是不被允許的：

# Definitely do not do this!
if x >5 and x% 2== 0:
    print("x is larger than 5 and divisible by 2!")

在切片中，冒號(hào)作為二元運(yùn)算符。因此，上一節(jié)中概述的規(guī)則也適用于此，并且其任何一方都應(yīng)該有相同數(shù)量的空白，以下列表切片示例是合法的：

list[3:4]

# Treat the colon as the operator with lowest priority
list[x+1 : x+2]

# In an extended slice, both colons must be
# surrounded by the same amount of whitespace
list[3:4:5]
list[x+1 : x+2 : x+3]

# The space is omitted if a slice parameter is omitted
list[x+1 : x+2 :]

總之，你應(yīng)該使用空格包圍大多數(shù)運(yùn)算符，但是，此規(guī)則有一些注意事項(xiàng)，例如在函數(shù)參數(shù)中或在一個(gè)語句中組合多個(gè)運(yùn)算符時(shí)。

在某些情況下，添加空格可能會(huì)使代碼難以閱讀，太多的空格會(huì)使代碼過于稀疏而難以理解。 PEP 8概述了一些非常明顯的例子應(yīng)當(dāng)不使用空格

在一行的末尾避免添加空格是最重要的地方，這稱為trailing whitespace，它是不可見的，可能產(chǎn)生難以追蹤的錯(cuò)誤。

以下列表概述了一些應(yīng)避免添加空格的情況：

直接放在括號(hào)、方括號(hào)或大括號(hào)內(nèi):

# Recommended
my_list = [1, 2, 3]

# Not recommended
my_list = [ 1, 2, 3, ]

在逗號(hào)，分號(hào)或冒號(hào)之前：

x = 5
y = 6

# Recommended
print(x, y)

# Not recommended
print(x , y)

在打開函數(shù)調(diào)用的參數(shù)列表的開括號(hào)之前：

def double(x):
    return x * 2

# Recommended
double(3)

# Not recommended
double (3)

在開始索引或切片的開括號(hào)之前:

# Recommended
list[3]

# Not recommended
list [3]

在尾隨逗號(hào)和右括號(hào)之間：

# Recommended
tuple = (1,)

# Not recommended
tuple = (1, )

對(duì)齊賦值運(yùn)算符：

# Recommended
var1 = 5
var2 = 6
some_long_var = 7

# Not recommended
var1          = 5
var2          = 6
some_long_var = 7

確保你的代碼中沒有尾隨空格。 在其他情況下，PEP 8不鼓勵(lì)添加額外的空格，例如立直接放在括號(hào)、方括號(hào)或大括號(hào)內(nèi)，以及逗號(hào)和冒號(hào)之前。 為了對(duì)齊操作符，也不應(yīng)該添加額外的空格。

簡(jiǎn)潔勝于復(fù)雜

你經(jīng)常會(huì)發(fā)現(xiàn)有幾種方法可以在 Python (以及任何其他編程語言)中執(zhí)行類似的操作。在本節(jié)中，你將看到PEP 8提供的一些建議用來消除這種歧義并且保持一致性。

不要使用等價(jià)運(yùn)算符將布爾值與True或False進(jìn)行比較，你經(jīng)常需要檢查布爾值是True還是False，當(dāng)這樣操作時(shí)，請(qǐng)使用如下所示的語句直觀地執(zhí)行此操作：

# Not recommended
my_bool = 6 > 5
if my_bool == True:
    return "6 is bigger than 5"

這里不需要使用等價(jià)運(yùn)算符==， bool只能取值True或False，按照下面這樣寫就行了：

# Recommended
if my_bool:
    return "6 is bigger than 5"

這種在if語句中使用bool的方式可以寫更少的代碼并且更加簡(jiǎn)單，因此PEP 8鼓勵(lì)使用這種方式。

在if語句中判斷列表是否為空，當(dāng)你希望確定列表是否為空時(shí)，你通常會(huì)判斷列表的長(zhǎng)度，如果列表為空，那么長(zhǎng)度為0，在if語句中使用時(shí)等于False，這里有一個(gè)例子：

# Not recommended
my_list = []
if not len(my_list):
    print("List is empty!")

但是，在Python中，任何空列表，字符串或元組都可以當(dāng)為False的。因此，我們可以提出一個(gè)更簡(jiǎn)單的替代方案：

# Recommended
my_list = []
if not my_list:
    print("List is empty!")

兩種方法都可以判斷列表是否為空，但是第二種方式更加簡(jiǎn)潔，因此PEP 8鼓勵(lì)使用這種方式。

在if語句中，使用 is not 比 no ... is in 好，當(dāng)你需要確定一個(gè)變量是否被賦值，這里有兩種方法，第一種是評(píng)估if語句中的x是不是為非None，如下所示：

# Recommended
if x is not None:
    return "x exists!"

第二種方案是現(xiàn)在if語句中判斷x是不是None，再進(jìn)行not操作：

# Not recommended
if not x is None:
    return "x exists!"

兩種方法都可以判斷x是否為None，但是第一種方式更加簡(jiǎn)單，因此PEP 8鼓勵(lì)使用這種方式。

當(dāng)你想表達(dá)if x is not None時(shí)，不要使用if x，有時(shí)候，你可能擁有一個(gè)函數(shù)帶有默認(rèn)值為None的參數(shù)，當(dāng)對(duì)參數(shù)arg檢查是否帶有不同的值的時(shí)候經(jīng)常會(huì)犯下面這樣的錯(cuò)誤：

# Not Recommended
if arg:
    # Do something with arg...

此代碼檢查的是arg是否為真，但相對(duì)的你要的是檢查是否為None，所以下面這樣寫比較好：

# Recommended
if arg is not None:
    # Do something with arg...

上面的錯(cuò)誤會(huì)使得判斷是否為真和not None相等，你可以設(shè)置arg = []，如上所述，空列表在Python中被認(rèn)為是False，因此，盡管參數(shù)被聲明為[]，但條件并沒有滿足，因此函數(shù)里面的代碼if聲明并不能被執(zhí)行。

用.startswith() 和.endswith()代替切片，如果你想檢查一段字符串的前綴或者后綴是否帶有字符串cat，這看起來使用列表切片似乎比較明智，但是，列表切片容易出錯(cuò)，您必須對(duì)前綴或后綴中的字符數(shù)進(jìn)行硬編碼，對(duì)于那些不太熟悉Python列表切片的人來說很難看清楚你想要實(shí)現(xiàn)的目的：

# Not recommended
if word[:3] == "cat":
    print("The word starts with "cat"")

然而，還是使用.startswith():可讀性比較高：

# Recommended
if word.startswith("cat"):
    print("The word starts with "cat"")

同樣的，當(dāng)你想檢查字符串后綴也是同樣的原理，下面的示例概述了如何檢查字符串是否以jpg結(jié)尾：

# Not recommended
if file_name[-3:] == "jpg":
    print("The file is a JPEG")

雖然結(jié)果是正確的，但是符號(hào)有點(diǎn)復(fù)雜且難以閱讀，與之相對(duì)的，你可以用.endswith()實(shí)現(xiàn)，看下面例子：

# Recommended
if file_name.endswith("jpg"):
    print("The file is a JPEG")

就像上面的列出的編程建議，我們目標(biāo)是編寫清晰以及可讀性較高的代碼，在Python中，有許多不同的方法可以實(shí)現(xiàn)相同的結(jié)果，因此有關(guān)選擇哪種方法的指南很有幫助。

什么時(shí)候忽略PEP 8？對(duì)于這個(gè)問題有個(gè)簡(jiǎn)短的答案，那就是永遠(yuǎn)不會(huì)

如果你嚴(yán)格遵循 PEP 8，就可以保證您擁有干凈、專業(yè)和可讀的代碼。 這對(duì)你以及合作者和潛在雇主都有好處。

但是，PEP 8中的一些指導(dǎo)方針在以下實(shí)例中不適用：

如果遵守PEP 8將破壞與現(xiàn)有軟件的兼容性

如果你正在從事的工作的代碼與 PEP 8不一致

如果代碼需要與舊版本的Python版本保持兼容

想要你的代碼兼容PEP 8，那你得記住不少規(guī)范，在開發(fā)代碼時(shí)，記住所有這些規(guī)則可能是一項(xiàng)艱巨的任務(wù)。特別是對(duì)老項(xiàng)目進(jìn)行更新以兼容PEP 8時(shí)，幸運(yùn)的是，有些工具可以幫助你加快這一過程，這里有兩個(gè)工具可以幫你強(qiáng)制兼容PEP 8規(guī)范：linters和autoformatters。

Linters是分析代碼和標(biāo)記錯(cuò)誤的程序，他們可以為你如何修復(fù)錯(cuò)誤提供建議，在作為文本編輯器的擴(kuò)展安裝時(shí)，Linters特別有用，因?yàn)樗鼈儤?biāo)記了你編程時(shí)的錯(cuò)誤和格式問題。在本節(jié)中，您將看到Linters程序是如何工作的大綱，最后還有文本編輯器擴(kuò)展的鏈接。

對(duì)于Python代碼，最好的linters如下：

pycodestyle)是一個(gè)根據(jù)PEP 8中的某些風(fēng)格約定來檢查Python代碼的工具

# 使用pip安裝pycodestyle
pip install pycodestyle

使用以下命令在終端中使用pycodestyle：

pycodestyle code.py
code.py:1:17: E231 missing whitespace after ","
code.py:2:21: E231 missing whitespace after ","
code.py:6:19: E711 comparison to None should be "if cond is None:"

flake8是一個(gè)結(jié)合了調(diào)試器，pyflakes和pycodestyle的工具

# 使用pip安裝flake8
pip install flake8

使用以下命令在終端中使用pycodestyle：

flake8 code.py
code.py:1:17: E231 missing whitespace after ","
code.py:2:21: E231 missing whitespace after ","
code.py:3:17: E999 SyntaxError: invalid syntax
code.py:6:19: E711 comparison to None should be "if cond is None:"

還顯示了輸出的示例。

::Note：額外輸出的一行表示語法錯(cuò)誤。::

這些也可用作Atom，Sublime Text，Visual Studio Code和VIM的擴(kuò)展。您還可以找到有關(guān)為Python開發(fā)設(shè)置Sublime Text和VIM的指南，以及Real Python中一些流行的文本編輯器的概述。

Autoformatters可以重構(gòu)你的代碼以使其符合PEP 8規(guī)范，像black程序就可以根據(jù)PEP 8規(guī)范重新格式化你的代碼，一個(gè)很大的區(qū)別是它將行長(zhǎng)度限制為88個(gè)字符，而不是79個(gè)字符。但是，您可以通過添加命令行標(biāo)志來覆蓋它，如下面的示例所示。

可以使用pip安裝black，它需要Python 3.6+：

pip install black

它可以通過命令行運(yùn)行，就像Linters一樣。假設(shè)你從名為code.py里面不符合PEP 8規(guī)范的代碼開始：

for i in range(0,3):
    for j in range(0,3):
        if (i==2):
            print(i,j)

你可以在命令行中運(yùn)行如下代碼：

black code.py
reformatted code.py
All done!

code.py將會(huì)被重新格式化為如下所示：

for i in range(0, 3):
    for j in range(0, 3):
        if i == 2:
            print(i, j)

如果你想要更改行長(zhǎng)度限制，則可以使用—line-length標(biāo)志：

black --line-length=79 code.py
reformatted code.py
All done!

另外兩個(gè)autoformatters 分別為autopep8和yapf，它們和black操作類似。

另一個(gè)Real Python教程，由 Alexander van Tol編寫的Python Code Quality: Tools & Best Practices詳細(xì)解釋了如何使用這些工具。

你現(xiàn)在已經(jīng)知道如何使用PEP 8中的指南編寫高質(zhì)量，可讀高的Python代碼，雖然指南看起來很迂腐，但遵循它們可以真正改善你的代碼，特別是在與潛在雇主或合作者共享代碼時(shí)。

在本教程中你了解到：

什么是 PEP 8以及其存在的原因

為什么你應(yīng)該編寫符合PEP 8標(biāo)準(zhǔn)的代碼

如何編寫符合PEP 8的代碼

除此之外，您還了解了如何使用linters和autoformatters根據(jù)PEP 8指南檢查代碼。

如果你想了解更多，可以閱讀full documentation)或者瀏覽pep8.org，這些教程不僅提供了類似的信息同時(shí)也提供了很好的格式讓你閱讀，在這些文檔中，您將找到本教程未涉及的其余PEP 8指南。