PEP 8で美しいPythonコードを書く方法

PEP 8で美しいPythonコードを書く方法

PEP 8は、PEP8またはPEP-8と綴られることもありますが、Pythonコードの記述方法に関するガイドラインとベストプラクティスを提供するドキュメントです。 2001年にGuido van Rossum、Barry Warsaw、およびNick Coghlanによって書かれました。 PEP 8の主な焦点は、Pythonコードの可読性と一貫性を改善することです。

PEPはPython Enhancement Proposalの略で、いくつかあります。 PEPは、Python向けに提案された新しい機能を説明するドキュメントであり、コミュニティ向けにPythonのデザインやスタイルなどの側面を文書化したものです。

このチュートリアルでは、PEP 8で規定されている主要なガイドラインの概要を説明します。 初心者から中級のプログラマーを対象としているため、最も高度なトピックのいくつかは取り上げていません。 これらの詳細については、https://www.python.org/dev/peps/pep-0008/[PEP 8]のドキュメント全体をご覧ください。

このチュートリアルの終わりまでに、次のことができるようになります

  • PEP 8に準拠するPythonコードを書く

  • PEP 8に記載されているガイドラインの背後にある理由を理解する

  • 開発環境をセットアップして、PEP 8準拠のPythonコードの記述を開始できるようにします

無料ボーナス: link:[5 Thoughts On Python Mastery]、Python開発者向けの無料コースで、Pythonのスキルを次のレベルに引き上げるのに必要なロードマップと考え方を示します。

PEP 8が必要な理由

_ _ 「読みやすさは重要です。」

Pythonの禅 _ _

PEP 8は、Pythonコードの可読性を向上させるために存在します。 しかし、なぜ読みやすさがそれほど重要なのでしょうか? 読み取り可能なコードを記述することがPython言語の基本原則の1つであるのはなぜですか?

Guido van Rossumが言ったように、「コードは書かれているよりもずっと頻繁に読まれます。」ユーザー認証を処理するためのコードを書くのに数分、または丸1日かかることがあります。 一度書いたら、二度と書きません。 ただし、必ずもう一度読む必要があります。 そのコードは、現在取り組んでいるプロジェクトの一部である可能性があります。 そのファイルに戻るたびに、そのコードが何をするのか、なぜコードを書いたのかを覚えておく必要があるため、読みやすさが重要になります。

Pythonを初めて使用する場合、コードを書いてから数日または数週間後にコードが何をするかを覚えるのは困難です。 PEP 8に従うと、変数に適切な名前を付けたことを確認できます。 コード内の論理的な手順を簡単に実行できるように、十分な空白を追加したことがわかります。 また、コードに適切にコメントすることもできます。 これはすべて、コードが読みやすく、簡単にアクセスできることを意味します。 初心者として、PEP 8のルールに従うことで、Pythonをより快適に学ぶことができます。

開発の仕事を探している場合は、PEP 8に従うことが特に重要です。 明確で読みやすいコードを書くことは、プロ意識を示しています。 コードをうまく構成する方法を理解していることを雇用者に伝えます。

Pythonコードの作成経験が豊富な場合は、他の人と協力する必要があるかもしれません。 ここに読み取り可能なコードを書くことが重要です。 あなたに会ったことがないか、あなたのコーディングスタイルを見たことがない人は、あなたのコードを読んで理解する必要があります。 ガイドラインを遵守し、認識しておくと、他の人がコードを読みやすくなります。

命名規則

_ _ 「明示的は暗黙的よりも優れています。」

Pythonの禅 _ _

Pythonコードを作成するときは、変数、関数、クラス、パッケージなど、多くの名前を付ける必要があります。 賢明な名前を選択すると、後で時間とエネルギーを節約できます。 名前から、特定の変数、関数、またはクラスが何を表すかを把握できます。 また、デバッグが困難なエラーを引き起こす可能性のある不適切な名前の使用も避けます。

注意:書体によっては、「+ l 」、「 O 」、または「 I 」の単一文字名を使用しないでください。これらは「+1」および「0」と間違われる可能性があります。

O = 2  # This may look like you're trying to reassign 2 to zero

命名スタイル

以下の表は、Pythonコードの一般的な命名スタイルのいくつかと、それらをいつ使用すべきかを示しています。

Type Naming Convention Examples

Function

Use a lowercase word or words. Separate words by underscores to improve readability.

function, my_function

Variable

Use a lowercase single letter, word, or words. Separate words with underscores to improve readability.

x, var, my_variable

Class

Start each word with a capital letter. Do not separate words with underscores. This style is called camel case.

Model, MyClass

Method

Use a lowercase word or words. Separate words with underscores to improve readability.

class_method, method

Constant

Use an uppercase single letter, word, or words. Separate words with underscores to improve readability.

CONSTANT, MY_CONSTANT, MY_LONG_CONSTANT

Module

Use a short, lowercase word or words. Separate words with underscores to improve readability.

module.py, my_module.py

Package

Use a short, lowercase word or words. Do not separate words with underscores.

package, mypackage

これらは、いくつかの一般的な命名規則とそれらの使用方法の例です。 ただし、読み取り可能なコードを記述するためには、文字と単語の選択に注意する必要があります。 コードで正しい命名スタイルを選択することに加えて、名前も慎重に選択する必要があります。 以下は、これを可能な限り効果的に行う方法に関するいくつかの指針です。

名前の選び方

変数、関数、クラスなどの名前を選択するのは難しい場合があります。 コードをより読みやすくするため、コードを記述するときは、命名の選択にかなりの量の考慮を払う必要があります。 Pythonでオブジェクトに名前を付ける最良の方法は、わかりやすい名前を使用して、オブジェクトが何を表しているかを明確にすることです。

変数に名前を付けるときは、 `+ x `のような単純な1文字の小文字の名前を選択したくなるかもしれません。 しかし、数学関数の引数として「 x 」を使用していない限り、「 x +」が何を表すのかは明確ではありません。 人の名前を文字列として保存しており、文字列スライスを使用して名前の形式を変えたいとします。 次のような結果になる可能性があります。

>>>

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

これは機能しますが、「+ x 」、「 y 」、および「 z +」が何を表すかを追跡する必要があります。 共同制作者にとっても混乱を招く可能性があります。 より明確な名前の選択は、次のようなものになります。

>>>

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

同様に、入力する回数を減らすために、名前を選択するときに略語を使用することもできます。 以下の例では、単一の引数 `+ x `を取り、それを2倍にする関数 ` db()+`を定義しています。

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

一見、これは賢明な選択のように思えるかもしれません。 `+ db()+`は簡単にdoubleの略語になります。 しかし、数日後にこのコードに戻ることを想像してください。 この機能で何を達成しようとしていたかを忘れてしまった可能性があります。そのため、どのように短縮したかを推測するのが難しくなります。

次の例はより明確です。 書いてから数日後にこのコードに戻っても、この関数の目的を読んで理解することができます。

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

同じ哲学が、Pythonの他のすべてのデータ型とオブジェクトに適用されます。 できるだけ簡潔でわかりやすい名前を使用してください。

コードレイアウト

_ _ 「美しいのはいよりはましです。」

Pythonの禅 _ _

コードのレイアウト方法は、コードの読みやすさにおいて大きな役割を果たします。 このセクションでは、コードの読みやすさを改善するために垂直方向の空白を追加する方法を学びます。 また、PEP 8で推奨されている79文字の行制限を処理する方法も学習します。

空白行

垂直方向の空白、つまり空白行は、コードの可読性を大幅に向上させる可能性があります。 一緒にまとめられたコードは、圧倒的で読みにくい場合があります。 同様に、コードの空白行が多すぎると、コードが非常にまばらに見えるため、読者は必要以上にスクロールする必要がある場合があります。 以下は、垂直空白の使用方法に関する3つの重要なガイドラインです。

*トップレベルの関数とクラスを2行の空白行で囲みます。*トップレベルの関数とクラスは、自己完結型であり、個別の機能を処理する必要があります。 それらの周りに余分な垂直スペースを置くことは理にかなっています。

class MyFirstClass:
    pass


class MySecondClass:
    pass


def top_level_function():
    return None

*単一の空白行でクラス内のメソッド定義をサラウンドします。*クラス内では、関数はすべて互いに関連しています。 それらの間に1行だけを残すことをお勧めします。

class MyClass:
    def first_method(self):
        return None

    def second_method(self):
        return None

*関数内では空白行を控えめに使用して、明確なステップを示します。*複雑な関数は、 `+ return +`ステートメントの前にいくつかのステップを完了する必要がある場合があります。 読者が関数内のロジックを理解しやすくするために、各ステップの間に空白行を入れておくと役立ちます。

以下の例には、リストの分散を計算する関数があります。 これは2ステップの問題であるため、各ステップの間に空白行を残して各ステップを示しました。 `+ return +`ステートメントの前にも空白行があります。 これにより、読者は返品内容を明確に確認できます。

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

垂直方向の空白を慎重に使用すると、コードの可読性が大幅に向上します。 コードをセクションに分割する方法と、それらのセクションが互いにどのように関連するかを視覚的に理解するのに役立ちます。

最大行長と改行

PEP 8は、行を79文字に制限することを提案しています。 これは、行の折り返しを回避しながら、複数のファイルを隣り合わせに開くことができるためです。

もちろん、文を79文字以下に保つことは常に可能ではありません。 PEP 8では、ステートメントを複数の行にわたって実行できるようにする方法の概要を説明しています。

コードが括弧、括弧、または括弧内に含まれている場合、Pythonは行の継続を想定します。

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

暗黙の継続を使用できない場合は、代わりにバックスラッシュを使用して行を分割できます。

from mypkg import example1, \
    example2, example3

ただし、暗黙の継続を使用できる場合は、そうする必要があります。

`+`や `+ * +`のように、バイナリ演算子の周りで改行を行う必要がある場合は、演算子の前で改行する必要があります。 このルールは数学に由来します。 数学者は、二項演算子の前にブレークすると読みやすさが向上することに同意します。 次の2つの例を比較してください。

以下は、バイナリ演算子の前にブレークする例です。

# Recommended
total = (first_variable
         + second_variable
         - third_variable)

演算子は操作対象の変数のすぐ隣にあるため、どの変数が加算または減算されているかをすぐに確認できます。

次に、二項演算子の後のブレークの例を見てみましょう。

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

ここでは、どの変数が追加され、どの変数が減算されるかを確認するのが難しくなります。

バイナリ演算子の前にブレークすると、より読みやすいコードが生成されるため、PEP 8が推奨しています。 バイナリ演算子が引き続きPEP 8に準拠した後に_consistently_破損するコード。 ただし、二項演算子の前にブレークすることをお勧めします。

インデント

_ _ 「それを行うための明白な方法は1つ、できれば1つだけである必要があります。」

Pythonの禅 _ _

インデント、または先頭の空白は、Pythonで非常に重要です。 Pythonのコード行のインデントレベルにより、ステートメントをグループ化する方法が決まります。

次の例を見てください。

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

インデントされた `+ print `ステートメントは、 ` if `ステートメントが ` True +`を返す場合にのみ実行されるべきであることをPythonに知らせます。 同じインデントが適用され、関数が呼び出されたときに実行するコード、または特定のクラスに属するコードをPythonに伝えます。

PEP 8で規定されている主要なインデントルールは次のとおりです。

  • インデントを示すには、4つの連続したスペースを使用します。

  • タブよりもスペースを優先します。

タブと スペース

前述のように、コードをインデントするときは、タブではなくスペースを使用する必要があります。 [.keys]#Tab#キーを押すと、テキストエディターの設定を調整して、タブ文字の代わりに4つのスペースを出力できます。

Python 2を使用していて、コードをインデントするためにタブとスペースを組み合わせて使用​​している場合、実行しようとしてもエラーは表示されません。 一貫性を確認しやすくするために、コマンドラインからPython 2コードを実行するときに `+ -t +`フラグを追加できます。 インタープリターは、タブとスペースの使用に矛盾がある場合に警告を発行します。

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

代わりに、 `+ -tt +`フラグを使用すると、インタープリターは警告ではなくエラーを発行し、コードは実行されません。 この方法を使用する利点は、インタープリターが矛盾の場所を通知することです。

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

Python 3では、タブとスペースを混在させることはできません。 したがって、Python 3を使用している場合、これらのエラーは自動的に発行されます。

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

インデントを示すタブまたはスペースを使用してPythonコードを作成できます。 ただし、Python 3を使用している場合は、選択と一致している必要があります。 そうしないと、コードは実行されません。 PEP 8では、インデントを示すために常に4つの連続したスペースを使用することをお勧めします。

改行後のインデント

行の継続を使用して行を79文字未満に保つ場合、インデントを使用すると読みやすくなります。 これにより、読者は2行のコードと2行にわたる1行のコードを区別できます。 使用できるインデントには2つのスタイルがあります。

これらの最初の方法は、インデントされたブロックを開始区切り文字に揃えることです。

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

場合によっては、開始区切り文字と位置合わせするために必要なスペースは4つだけであることがわかります。 これは、多くの場合、複数の行にまたがる「+ if 」ステートメントで発生します。「 if 」、スペース、および開き括弧が4文字を構成するためです。 この場合、 ` if +`ステートメント内のネストされたコードブロックの開始位置を判断するのは困難です。

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

この場合、PEP 8は読みやすさを改善するために2つの代替手段を提供します。

  • 最終条件の後にコメントを追加します。 ほとんどのエディターでは構文が強調表示されるため、これにより条件がネストされたコードから分離されます。

x = 5
if (x > 3 and
    x < 10):
    # Both conditions satisfied
    print(x)
  • 行の継続に追加のインデントを追加します。

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

改行に続く代替スタイルのインデントは hanging indent です。 これは、段落またはステートメントの最初の行以外のすべての行がインデントされることを意味する印刷上の用語です。 ぶら下げインデントを使用して、コード行の続きを視覚的に表すことができます。 例を示しましょう。

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

:ぶら下げインデントを使用している場合、最初の行に引数があってはなりません。 次の例は、PEP 8に準拠していません。

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

ぶら下げインデントを使用する場合は、追加のインデントを追加して、関数内に含まれるコードから継続行を区別します。 次の例は、関数内のコードが継続行と同じインデントレベルにあるため、読みにくくなっています。

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

代わりに、行の継続で二重インデントを使用することをお勧めします。 これにより、関数の引数と関数本体を区別しやすくなり、読みやすくなります。

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

PEP 8準拠のコードを記述する場合、79文字の行制限により、コードに改行を追加する必要があります。 読みやすさを改善するには、継続行をインデントして、継続行であることを示す必要があります。 これを行うには2つの方法があります。 1つ目は、インデントされたブロックを開始区切り文字に揃えることです。 2つ目は、ぶら下げインデントを使用することです。 改行の後に使用するインデント方法を自由に選択できます。

閉じブレースを配置する場所

行の継続により、括弧、括弧、または括弧内の行を分割できます。 閉じ括弧を忘れるのは簡単ですが、賢明な場所に置くことが重要です。 そうしないと、読者を混乱させる可能性があります。 PEP 8は、暗黙の行の継続における閉じ括弧の位置に2つのオプションを提供します。

  • 前の行の最初の非空白文字で右中括弧を並べます:

list_of_numbers = [
    1, 2, 3,
    4, 5, 6,
    7, 8, 9
    ]
  • 構成要素を開始する行の最初の文字と右中括弧を並べます。

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

使用するオプションを自由に選択できます。 しかし、いつものように、一貫性が重要なので、上記の方法のいずれかに固執するようにしてください。

_ _ 「実装の説明が難しい場合、それは悪い考えです。」

Pythonの禅 _ _

コメントを使用して、記述されたとおりにコードを文書化する必要があります。 コードを文書化して、あなたと共同編集者が理解できるようにすることが重要です。 あなたまたは他の誰かがコメントを読むとき、彼らはコメントが適用されるコードとそれがあなたのコードの他の部分にどのように適合するかを簡単に理解できるはずです。

コードにコメントを追加する際に覚えておくべき重要なポイントを次に示します。

  • コメントとdocstringの行の長さを72文字に制限します。

  • 大文字で始まる完全な文を使用してください。

  • コードを変更する場合は、コメントを更新してください。

ブロックコメントを使用して、コードの小さなセクションを文書化します。 ファイルからデータをインポートする、データベースエントリを更新するなど、単一のアクションを実行するために複数行のコードを記述する必要がある場合に便利です。 これらは、特定のコードブロックの目的と機能を他の人が理解するのに役立つため、重要です。

PEP 8は、ブロックコメントを記述するために次のルールを提供します。

  • ブロックコメントを、それらが記述するコードと同じレベルにインデントします。

  • 各行を「#」で始め、その後に単一のスペースを続けます。

  • 単一の「#」を含む行で段落を区切ります。

以下に、「+ for +」ループの機能を説明するブロックコメントを示します。 79文字の行制限を維持するために、文が改行で折り返されることに注意してください。

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, '\n')

コードが非常に技術的なものである場合は、ブロックコメントで複数の段落を使用する必要がある場合があります。

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

どのタイプのコメントが適切であるか疑問がある場合は、コメントをブロックすることがよくあります。 コード全体で可能な限りそれらを使用しますが、コードを変更する場合は必ず更新してください!

インラインコメントは、コード内の単一のステートメントを説明します。 特定のコード行が必要な理由を思い出させたり、他の人に説明するのに役立ちます。 PEP 8がそれらについて述べなければならないことは次のとおりです。

  • インラインコメントは慎重に使用してください。

  • 参照するステートメントと同じ行にインラインコメントを記述します。

  • インラインコメントは、ステートメントから2つ以上のスペースで区切ります。

  • インラインコメントは、ブロックコメントのように、「#」と単一のスペースで開始します。 *明白な説明のためにそれらを使用しないでください。

以下は、インラインコメントの例です。

x = 5  # This is an inline comment

インラインコメントが必要なように見える場合もありますが、代わりにより良い命名規則を使用できます。 例を示しましょう。

x = 'John Smith'  # Student Name

ここで、インラインコメントは追加情報を提供します。 ただし、人の名前の変数名として「+ x +」を使用するのは悪い習慣です。 変数の名前を変更する場合、インラインコメントは不要です。

student_name = 'John Smith'

最後に、これらのようなインラインコメントは、明確で煩雑なコードを述べているため、悪い習慣です。

empty_list = []  # Initialize empty list

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

インラインコメントはブロックコメントよりも具体的であり、不要な場合は簡単に追加できるため、混乱が生じます。 ブロックコメントを使用するだけで済むので、インラインコメントが必要であることが確実でない限り、ブロックコメントに固執するとコードはPEP 8に準拠する可能性が高くなります。

ドキュメント文字列

ドキュメント文字列、またはドキュメント文字列は、関数、クラス、メソッド、またはモジュールの最初の行に表示される二重( +" "" + `)または単一( + '' '+ `)引用符で囲まれた文字列です。 これらを使用して、特定のコードブロックを説明および文書化できます。 DocstringsをカバーするPEP全体https://www.python.org/dev/peps/pep-0257/[PEP 257]がありますが、このセクションで要約を取得します。

docstringに適用される最も重要なルールは次のとおりです。

  • `" "" This is a docstring "" "`のように、両側に3つの二重引用符を付けてdocstringを囲みます。

  • すべてのパブリックモジュール、関数、クラス、およびメソッドに対してそれらを記述します。

  • 複数行の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
  • 1行のdocstringの場合、同じ行に `+" "" + `を保持します:

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

Pythonコードのドキュメント化に関する詳細な記事については、James Mertzによるhttps://realpython.com/documenting-python-code/#docstrings-background[Pythonコードのドキュメント化:完全ガイド]を参照してください。

式とステートメントの空白

_ _ 「スパースは、デンスよりも優れています。」

Pythonの禅 _ _

空白は、適切に使用すると式やステートメントで非常に役立ちます。 十分な空白がない場合、コードはすべてまとめられるため、読みにくくなる可能性があります。 空白が多すぎると、関連する用語をステートメントで視覚的に組み合わせることが困難になる場合があります。

二項演算子の周りの空白

次の2項演算子を、両側に1つのスペースで囲みます。

  • 代入演算子( + = +++ = +、 `+-= +`など)

  • 比較( + == ++!= ++> ++ <++> = ++ ⇐ +)および( + is ++ is not ++ in ++ not in +

  • ブール値( + and ++ not ++ or +

注意:関数の引数にデフォルト値を割り当てるために「+ = +」が使用される場合、スペースで囲まないでください。

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


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

ステートメントに複数の演算子が含まれる場合、各演算子の前後に1つのスペースを追加すると混乱する場合があります。 代わりに、特に数学的な操作を実行する場合は、優先度が最も低い演算子の周りに空白のみを追加することをお勧めします。 いくつか例を挙げます。

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

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

これを複数の条件がある `+ if +`ステートメントに適用することもできます:

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

上記の例では、「+ and 」演算子の優先度が最も低くなります。 したがって、 ` if +`ステートメントを次のように表現する方が明確な場合があります。

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

演算子の両側で同じ量の空白を使用する必要があるという注意事項を使用して、どちらを明確にするかを自由に選択できます。

以下は受け入れられません。

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

スライスでは、コロンは二項演算子として機能します。 したがって、前のセクションで説明した規則が適用され、どちらの側にも同じ量の空白が存在するはずです。 次のリストスライスの例は有効です。

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 :]

要約すると、ほとんどの演算子は空白で囲む必要があります。 ただし、関数の引数や、1つのステートメントで複数の演算子を組み合わせる場合など、この規則にはいくつかの注意事項があります。

空白を追加しない場合

場合によっては、空白を追加するとコードが読みにくくなることがあります。 余白が多すぎると、コードが過度にまばらになり、追跡が難しくなります。 PEP 8は、空白が不適切な非常に明確な例を概説しています。

空白の追加を避けるための最も重要な場所は行末です。 これは*末尾の空白*と呼ばれます。 目に見えないため、トレースが困難なエラーが発生する可能性があります。

次のリストは、空白の追加を避ける必要があるいくつかのケースの概要を示しています。

  • 括弧、括弧、または中括弧のすぐ内側:

# Recommended
my_list = [1, 2, 3]

# Not recommended
my_list = [ 1, 2, 3, ]
  • コンマ、セミコロン、またはコロンの前:

x = 5
y = 6

# Recommended
print(x, y)

# Not recommended
print(x , y)
*関数呼び出しの引数リストを開始する開き括弧の前:
def double(x):
    return x* 2

# Recommended
double(3)

# Not recommended
double (3)
  • インデックスまたはスライスを開始するオープンブラケットの前:

# Recommended
list[3]

# Not recommended
list [3]
  • 末尾のコンマと閉じ括弧の間:

# Recommended
tuple = (1,)

# Not recommended
tuple = (1, )
  • 代入演算子を整列するには:

# Recommended
var1 = 5
var2 = 6
some_long_var = 7

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

コードの末尾に空白がないことを確認してください。 PEP 8では、ブラケットのすぐ内側やコンマやコロンの前など、余分な空白を追加することをお勧めしません。 また、演算子を揃えるために余分な空白を追加しないでください。

プログラミングの推奨事項

_ _ 「単純なものは複雑なものより優れています。」

Pythonの禅 _ _

Python(および他のプログラミング言語)で同様のアクションを実行する方法がいくつかあることがよくわかります。 このセクションでは、PEP 8が提供するいくつかの提案を参照して、あいまいさを取り除き、一貫性を維持します。

*等価演算子を使用してブール値を「+ True 」または「 False +」と比較しないでください。*ブール値がTrueかFalseかを確認する必要があることがよくあります。 そうするとき、以下のようなステートメントでこれを行うことは直感的です:

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

ここでは、等価演算子 `+ == `の使用は不要です。 ` bool `は、 ` True `または ` False +`の値のみを取ります。 以下を書くだけで十分です。

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

ブール値を使用して `+ if +`ステートメントを実行するこの方法は、必要なコードが少なく、よりシンプルなので、PEP 8が推奨しています。

*空のシーケンスが `+ if `ステートメントで偽であるという事実を使用してください。*リストが空かどうかを確認したい場合、リストの長さを確認したくなるかもしれません。 リストが空の場合、その長さは「+0」であり、これは「+ if 」ステートメントで使用した場合の「 False +」と同等です。 例を示しましょう。

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

ただし、Pythonでは、空のリスト、文字列、またはタプルはhttps://docs.python.org/3/library/stdtypes.html#truth-value-testing[falsy]です。 したがって、上記のより簡単な代替案を考え出すことができます。

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

どちらの例も `+ List is empty!+`を出力しますが、2番目のオプションはよりシンプルなので、PEP 8が推奨しています。

*「+ not …​」ではなく「+ is not 」を使用 ` if `ステートメントのis + `。*変数に定義された値があるかどうかを確認しようとする場合、2つのオプションがあります。 最初の方法は、次の例のように、「 x is not None 」ではなく「 if +」ステートメントを評価することです。

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

2番目のオプションは、「+ x is None 」を評価してから、「 not 」の結果に基づいて「 if +」ステートメントを作成することです。

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

両方のオプションが正しく評価されますが、最初の方が簡単なので、PEP 8が推奨します。

*「+ if xがNone:+ `ではない」という意味の場合は、「+ if x:」を使用しないでください。 このような引数 ` arg +`に別の値が与えられているかどうかを確認する際のよくある間違いは、次のものを使用することです。

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

このコードは、「+ arg 」が真実であることを確認します。 代わりに、 ` arg `が ` not None +`であることを確認したいので、以下を使用した方が良いでしょう:

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

ここで犯される間違いは、「+ not None 」と真実性が同等であると仮定することです。 ` arg = [] `を設定することもできます。 上で見たように、空のリストはPythonで偽と評価されます。 したがって、引数 ` arg `が割り当てられていても、条件は満たされないため、 ` if +`ステートメントの本文のコードは実行されません。

*スライスする代わりに、 `+ .startswith()`と ` .endswith()`を使用します。*文字列 ` word `が単語 ` cat +`でプレフィックスまたはサフィックスされているかどうかを確認しようとした場合、https://realpython.com/python-strings/#string-slicing [list slicing]を使用するのが賢明に思えるかもしれません。 ただし、リストのスライスはエラーを起こしやすいため、プレフィックスまたはサフィックスの文字数をハードコーディングする必要があります。 Pythonリストに精通していない人があなたが達成しようとしているものをスライスすることも明確ではありません:

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

ただし、これは `+ .startswith()+`を使用するほど読みやすくありません。

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

同様に、接尾辞を確認するときも同じ原則が適用されます。 以下の例は、文字列が `+ jpg +`で終わるかどうかを確認する方法の概要を示しています。

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

結果は正しいが、表記は少し不格好で読みにくい。 代わりに、次の例のように `+ .endswith()+`を使用できます。

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

これらのプログラミングの推奨事項のほとんどと同様に、目標は読みやすさとシンプルさです。 Pythonには、同じアクションを実行するさまざまな方法があるため、どのメソッドを選択するかのガイドラインが役立ちます。

PEP 8を無視する場合

この質問に対する短い答えは決してありません。 PEP 8に従ってレターを作成すれば、クリーンでプロフェッショナルで読みやすいコードを確実に入手できます。 これは、共同作業者や潜在的な雇用者だけでなく、あなたにとっても有益です。

ただし、PEP 8の一部のガイドラインは、次の場合には不便です。

  • PEP 8に準拠すると、既存のソフトウェアとの互換性が損なわれる場合

  • 作業内容を取り巻くコードがPEP 8と矛盾している場合

  • コードが古いバージョンのPythonとの互換性を維持する必要がある場合

コードがPEP 8に準拠していることを確認するためのヒントとコツ

コードがPEP 8に準拠していることを確認することを忘れないでください。 コードを開発する際に、これらのすべてのルールを覚えるのは大変なことです。 特に過去のプロジェクトをPEP 8に準拠するように更新するには時間がかかります。 幸いなことに、このプロセスをスピードアップするのに役立つツールがあります。 PEP 8コンプライアンスを実施するために使用できるツールには、リンターとオートフォーマッターの2つのクラスがあります。

リンター

リンターは、コードを分析してエラーにフラグを立てるプログラムです。 エラーの修正方法に関する提案を提供します。 リンターは、テキストエディターの拡張機能としてインストールした場合に特に役立ちます。これは、作成中にエラーや文体の問題にフラグを立てるためです。 このセクションでは、リンターの仕組みの概要と、最後にテキストエディター拡張機能へのリンクが表示されます。

Pythonコードに最適なリンターは次のとおりです。

  • + pycodestyle + は、PEP 8のスタイル規則のいくつかに対して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 + は、デバッガー「+ pyflakes 」と「 pycodestyle 」を組み合わせたツールです。 + ` pip `を使用して ` flake8 `をインストールします:

$ pip install flake8

次のコマンドを使用して、ターミナルから「 flake8 +」を実行します。

$ 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:'

+出力の例も示されています。

注意:出力の余分な行は、構文エラーを示しています。

これらは、https://atom.io/packages/linter-flake8 [Atom]、https://github.com/SublimeLinter/SublimeLinter-flake8 [Sublime Text]、https://code.visualstudioの拡張機能としても利用できます。 com/docs/python/linting#_flake8 [Visual Studio Code]、およびhttps://github.com/nvie/vim-flake8[VIM]。 Sublime Textおよびhttps://realpython.com/vimのセットアップに関するガイドもあります。 -and-python-a-match-made-in-heaven/#code-folding [VIM] Python開発、およびhttps://realpython.com/python-ides-code-editors-guide/[概要] _Real Python_の人気のあるテキストエディタの一部]。

オートフォーマッター

オートフォーマッタは、コードをリファクタリングしてPEP 8に自動的に準拠するプログラムです。 そのようなプログラムがhttps://pypi.org/project/black/[+ black +]になったら、PEP 8のルールの_most_に続くコードを自動フォーマットします。 大きな違いの1つは、行の長さが79文字ではなく88文字に制限されていることです。 ただし、次の例に示すように、コマンドラインフラグを追加してこれを上書きできます。

`+ pip `を使用して ` black +`をインストールします。 実行するにはPython 3.6以降が必要です。

$ pip install black

リンターと同様に、コマンドラインから実行できます。 `+ code.py +`というファイルでPEP 8に準拠していない次のコードから始めたとしましょう:

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

その後、コマンドラインから次のコマンドを実行できます。

$ black code.py
reformatted code.py
All done! ✨ ???? ✨

`+ code.py +`は次のように自動的に再フォーマットされます:

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

行の長さの制限を変更する場合は、 `+-line-length +`フラグを使用できます。

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

他の2つのオートフォーマッター、https://pypi.org/project/autopep8/[+ autopep8 +]およびhttps://pypi.org/project/yapf/[+ yapf +]は、 ` + black + `があります。

Alexander van Tolによる別の_Real Python_チュートリアル、https://realpython.com/python-code-quality/[Python Code Quality:Tools&Best Practices]では、これらのツールの使用方法について徹底的に説明しています。

結論

これで、PEP 8で規定されたガイドラインを使用して、高品質で読み取り可能なPythonコードを作成する方法がわかりました。 ガイドラインは見栄えが良いように見えますが、特に潜在的な雇用者または協力者とコードを共有する場合は、ガイドラインに従うことでコードを本当に改善できます。

このチュートリアルでは、次のことを学びました。

  • PEP 8とは何か、なぜ存在するのか

  • PEP 8準拠のコードを書くことを目指すべき理由

  • PEP 8準拠のコードを書く方法

さらに、リンターとオートフォーマッターを使用して、PEP 8ガイドラインに照らしてコードをチェックする方法も確認しました。

PEP 8の詳細については、https://www.python.org/dev/peps/pep-0008/[完全なドキュメント]を参照するか、https://pep8.org [pep8]にアクセスしてください。 org]。同じ情報が含まれていますが、適切にフォーマットされています。 これらのドキュメントには、このチュートリアルでカバーされていないPEP 8ガイドラインの残りの部分があります。