4. その他の制御フローツール—Pythonドキュメント

4.4。 その他の制御フローツール

導入されたばかりの while ステートメントに加えて、Pythonは他の言語で知られている通常のフロー制御ステートメントを使用しますが、いくつかの工夫が加えられています。

4.1。 もしもステートメント

おそらく最もよく知られているステートメントタイプは if ステートメントです。 例えば：

>>> x = int(raw_input("Please enter an integer: "))
Please enter an integer: 42
>>> if x < 0:
...     x = 0
...     print 'Negative changed to zero'
... elif x == 0:
...     print 'Zero'
... elif x == 1:
...     print 'Single'
... else:
...     print 'More'
...
More

elif パーツはゼロ個以上にすることができ、 else パーツはオプションです。 キーワード ' elif 'は 'else if'の略で、過度のインデントを回避するのに役立ちます。 if … elif … elif …シーケンスは、他の言語で見られるswitchまたはcaseステートメントの代わりになります。

4.2。 にとってステートメント

Pythonの for ステートメントは、CまたはPascalで慣れているものとは少し異なります。 Pythonの for ステートメントは、（Pascalのように）常に数値の等差数列を反復したり、反復ステップと停止条件の両方を定義する機能（Cとして）をユーザーに提供したりするのではなく、シーケンスに表示される順序での任意のシーケンス（リストまたは文字列）。 例（しゃれは意図されていません）：

>>> # Measure some strings:
... words = ['cat', 'window', 'defenestrate']
>>> for w in words:
...     print w, len(w)
...
cat 3
window 6
defenestrate 12

ループ内で繰り返し処理するシーケンスを変更する必要がある場合（たとえば、選択したアイテムを複製する場合）、最初にコピーを作成することをお勧めします。 シーケンスを反復処理しても、暗黙的にコピーは作成されません。 スライス表記により、これは特に便利です。

>>> for w in words[:]:  # Loop over a slice copy of the entire list.
...     if len(w) > 6:
...         words.insert(0, w)
...
>>> words
['defenestrate', 'cat', 'window', 'defenestrate']

4.3。 NS 範囲（） 関数

一連の数値を反復処理する必要がある場合は、組み込み関数 range（）が便利です。 等差数列を含むリストを生成します。

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

指定されたエンドポイントは、生成されたリストの一部になることはありません。 range(10)は、長さ10のシーケンスのアイテムの有効なインデックスである10個の値のリストを生成します。 範囲を別の数値で開始したり、別の増分を指定したりすることができます（負の場合でも、これは「ステップ」と呼ばれることもあります）。

>>> range(5, 10)
[5, 6, 7, 8, 9]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(-10, -100, -30)
[-10, -40, -70]

シーケンスのインデックスを反復処理するには、次のように range（）と len（）を組み合わせることができます。

>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
...     print i, a[i]
...
0 Mary
1 had
2 a
3 little
4 lamb

ただし、このようなほとんどの場合、 enumerate（）関数を使用すると便利です。ループテクニックを参照してください。

4.4。 壊すと継続するステートメント、およびそうしないとループに関する句

break ステートメントは、Cの場合と同様に、最も内側を囲む for または while ループから抜け出します。

ループステートメントにはelse句が含まれる場合があります。 リストの枯渇によりループが終了した場合（ for ）、または条件がfalseになった場合（ while ）に実行されますが、ループがによって終了した場合は実行されません。 ] break ステートメント。 これは、素数を検索する次のループによって例示されます。

>>> for n in range(2, 10):
...     for x in range(2, n):
...         if n % x == 0:
...             print n, 'equals', x, '*', n/x
...             break
...     else:
...         # loop fell through without finding a factor
...         print n, 'is a prime number'
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

（はい、これは正しいコードです。 よく見てください。else句は for ループに属しており、ではなく if ステートメントに属しています。）

ループで使用する場合、else句は、 if ステートメントよりも try ステートメントのelse句との共通点が多くなります。 ： try ステートメントのelse句は、例外が発生しないときに実行され、ループのelse句は、breakが発生しないときに実行されます。 try ステートメントと例外の詳細については、例外の処理を参照してください。

同じくCから借用した continue ステートメントは、ループの次の反復を続行します。

>>> for num in range(2, 10):
...     if num % 2 == 0:
...         print "Found an even number", num
...         continue
...     print "Found a number", num
Found an even number 2
Found a number 3
Found an even number 4
Found a number 5
Found an even number 6
Found a number 7
Found an even number 8
Found a number 9

4.5。 合格ステートメント

pass ステートメントは何もしません。 文が構文的に必要であるが、プログラムがアクションを必要としない場合に使用できます。 例えば：

>>> while True:
...     pass  # Busy-wait for keyboard interrupt (Ctrl+C)
...

これは通常、最小限のクラスを作成するために使用されます。

>>> class MyEmptyClass:
...     pass
...

pass を使用できるもう1つの場所は、新しいコードで作業するときの関数または条件付き本体のプレースホルダーとして使用できるため、より抽象的なレベルで考え続けることができます。 pass は黙って無視されます。

>>> def initlog(*args):
...     pass   # Remember to implement this!
...

4.6。 関数の定義

フィボナッチ数列を任意の境界に書き込む関数を作成できます。

>>> def fib(n):    # write Fibonacci series up to n
...     """Print a Fibonacci series up to n."""
...     a, b = 0, 1
...     while a < n:
...         print a,
...         a, b = b, a+b
...
>>> # Now call the function we just defined:
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

キーワード def は、関数 defined を導入します。 その後に、関数名と仮パラメーターの括弧で囲まれたリストを続ける必要があります。 関数の本体を形成するステートメントは次の行から始まり、インデントする必要があります。

関数本体の最初のステートメントは、オプションで文字列リテラルにすることができます。 この文字列リテラルは、関数のドキュメント文字列、または docstring です。 （docstringの詳細については、 Documentation Strings のセクションを参照してください。）docstringを使用して、オンラインまたは印刷されたドキュメントを自動的に作成したり、ユーザーがコードをインタラクティブに参照できるようにするツールがあります。 作成するコードにdocstringを含めることをお勧めします。そのため、習慣を身に付けてください。

関数の実行は、関数のローカル変数に使用される新しいシンボルテーブルを導入します。 より正確には、関数内のすべての変数割り当ては、ローカルシンボルテーブルに値を格納します。 一方、変数参照は、最初にローカルシンボルテーブルを調べ、次にそれを囲む関数のローカルシンボルテーブルを調べ、次にグローバルシンボルテーブルを調べ、最後に組み込み名のテーブルを調べます。 したがって、グローバル変数は、参照される場合でも、関数内で値を直接割り当てることはできません（ global ステートメントで指定されている場合を除く）。

関数呼び出しの実際のパラメーター（引数）は、呼び出されたときに呼び出された関数のローカルシンボルテーブルに導入されます。 したがって、引数は call by value を使用して渡されます（ value は常にオブジェクト reference であり、オブジェクトの値ではありません）。 1 関数が別の関数を呼び出すと、その呼び出しに対して新しいローカルシンボルテーブルが作成されます。

関数定義は、現在のシンボルテーブルに関数名を導入します。 関数名の値は、インタープリターによってユーザー定義関数として認識されるタイプを持っています。 この値を別の名前に割り当てることができ、その名前を関数として使用することもできます。 これは、一般的な名前変更メカニズムとして機能します。

>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89

他の言語から来ている場合、fibは値を返さないため、関数ではなくプロシージャであることに異議を唱えるかもしれません。 実際、 return ステートメントのない関数でさえ、かなり退屈な値ではありますが、値を返します。 この値はNoneと呼ばれます（これは組み込みの名前です）。 値Noneの書き込みは、それが書き込まれる唯一の値である場合、通常、インタープリターによって抑制されます。 print を本当に使用したい場合は、次のように表示されます。

>>> fib(0)
>>> print fib(0)
None

印刷する代わりに、フィボナッチ数列の数のリストを返す関数を作成するのは簡単です。

>>> def fib2(n):  # return Fibonacci series up to n
...     """Return a list containing the Fibonacci series up to n."""
...     result = []
...     a, b = 0, 1
...     while a < n:
...         result.append(a)    # see below
...         a, b = b, a+b
...     return result
...
>>> f100 = fib2(100)    # call it
>>> f100                # write the result
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

この例は、いつものように、いくつかの新しいPython機能を示しています。

• return ステートメントは、関数からの値を返します。 式引数なしの return は、Noneを返します。 関数の終わりから外れると、Noneも返されます。
• ステートメントresult.append(a)は、リストオブジェクトresultのメソッドを呼び出します。 メソッドは、オブジェクトに「属する」関数であり、obj.methodnameという名前が付けられます。ここで、objはオブジェクト（これは式の場合があります）であり、methodnameは名前です。オブジェクトのタイプによって定義されるメソッドの。 異なるタイプは異なるメソッドを定義します。 異なるタイプのメソッドは、あいまいさを引き起こすことなく同じ名前を持つことができます。 （ classes を使用して、独自のオブジェクトタイプとメソッドを定義できます。 Classes を参照してください。）例に示すメソッドappend()は、リストオブジェクトに対して定義されています。 リストの最後に新しい要素を追加します。 この例では、result = result + [a]と同等ですが、より効率的です。

4.7。 関数の定義の詳細

可変数の引数を使用して関数を定義することもできます。 組み合わせることができる3つの形式があります。

4.7.1。 デフォルトの引数値

最も便利な形式は、1つ以上の引数のデフォルト値を指定することです。 これにより、定義されているよりも少ない引数で呼び出すことができる関数が作成されます。 例えば：

def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
    while True:
        ok = raw_input(prompt)
        if ok in ('y', 'ye', 'yes'):
            return True
        if ok in ('n', 'no', 'nop', 'nope'):
            return False
        retries = retries - 1
        if retries < 0:
            raise IOError('refusenik user')
        print complaint

この関数は、いくつかの方法で呼び出すことができます。

• 必須の引数のみを与える：ask_ok('Do you really want to quit?')
• オプションの引数の1つを与える：ask_ok('OK to overwrite the file?', 2)
• またはすべての引数を与えることさえ：ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')

この例では、 in キーワードも紹介しています。 これは、シーケンスに特定の値が含まれているかどうかをテストします。

デフォルト値は、 defined スコープの関数定義の時点で評価されるため、次のようになります。

i = 5

def f(arg=i):
    print arg

i = 6
f()

5を印刷します。

重要な警告：デフォルト値は1回だけ評価されます。 これは、デフォルトがリスト、ディクショナリ、またはほとんどのクラスのインスタンスなどの可変オブジェクトである場合に違いを生みます。 たとえば、次の関数は、後続の呼び出しで渡された引数を累積します。

def f(a, L=[]):
    L.append(a)
    return L

print f(1)
print f(2)
print f(3)

これは印刷されます

[1]
[1, 2]
[1, 2, 3]

後続の呼び出し間でデフォルトを共有したくない場合は、代わりに次のような関数を記述できます。

def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L

4.7.2。 キーワード引数

関数は、kwarg=valueの形式のキーワード引数を使用して呼び出すこともできます。 たとえば、次の関数：

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print "-- This parrot wouldn't", action,
    print "if you put", voltage, "volts through it."
    print "-- Lovely plumage, the", type
    print "-- It's", state, "!"

1つの必須引数（voltage）と3つのオプション引数（state、action、およびtype）を受け入れます。 この関数は、次のいずれかの方法で呼び出すことができます。

parrot(1000)                                          # 1 positional argument
parrot(voltage=1000)                                  # 1 keyword argument
parrot(voltage=1000000, action='VOOOOOM')             # 2 keyword arguments
parrot(action='VOOOOOM', voltage=1000000)             # 2 keyword arguments
parrot('a million', 'bereft of life', 'jump')         # 3 positional arguments
parrot('a thousand', state='pushing up the daisies')  # 1 positional, 1 keyword

ただし、次のすべての呼び出しは無効になります。

parrot()                     # required argument missing
parrot(voltage=5.0, 'dead')  # non-keyword argument after a keyword argument
parrot(110, voltage=220)     # duplicate value for the same argument
parrot(actor='John Cleese')  # unknown keyword argument

関数呼び出しでは、キーワード引数は位置引数の後に続く必要があります。 渡されるすべてのキーワード引数は、関数によって受け入れられる引数の1つと一致する必要があります（例： actorはparrot関数の有効な引数ではなく、その順序は重要ではありません。 これには、オプションではない引数も含まれます（例： parrot(voltage=1000)も有効です）。 引数が値を複数回受け取ることはできません。 この制限が原因で失敗する例を次に示します。

>>> def function(a):
...     pass
...
>>> function(0, a=0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: function() got multiple values for keyword argument 'a'

**name形式の最終仮パラメーターが存在する場合、仮パラメーターに対応するものを除くすべてのキーワード引数を含む辞書（マッピングタイプ— dict を参照）を受け取ります。 これは、*name（次のサブセクションで説明）の形式の仮パラメーターと組み合わせることができます。このパラメーターは、仮パラメーターリスト以外の位置引数を含むタプルを受け取ります。 （*nameは**nameの前に発生する必要があります。）たとえば、次のような関数を定義する場合：

def cheeseshop(kind, *arguments, **keywords):
    print "-- Do you have any", kind, "?"
    print "-- I'm sorry, we're all out of", kind
    for arg in arguments:
        print arg
    print "-" * 40
    keys = sorted(keywords.keys())
    for kw in keys:
        print kw, ":", keywords[kw]

これは次のように呼び出すことができます：

cheeseshop("Limburger", "It's very runny, sir.",
           "It's really very, VERY runny, sir.",
           shopkeeper='Michael Palin',
           client="John Cleese",
           sketch="Cheese Shop Sketch")

そしてもちろん、それは印刷します：

-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
client : John Cleese
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch

キーワード引数名のリストは、その内容を出力する前に、キーワード辞書のkeys()メソッドの結果をソートすることによって作成されることに注意してください。 これが行われない場合、引数が出力される順序は定義されていません。

4.7.3。 任意の引数リスト

最後に、最も使用頻度の低いオプションは、任意の数の引数を使用して関数を呼び出すことができることを指定することです。 これらの引数はタプルにまとめられます（タプルとシーケンスを参照）。 可変数の引数の前に、0個以上の通常の引数が発生する場合があります。

def write_multiple_items(file, separator, *args):
    file.write(separator.join(args))

4.7.4。 引数リストの解凍

逆の状況は、引数がすでにリストまたはタプルにあるが、個別の位置引数を必要とする関数呼び出しのために解凍する必要がある場合に発生します。 たとえば、組み込みの range（）関数は、別々の start 引数と stop 引数を必要とします。 個別に使用できない場合は、*演算子を使用して関数呼び出しを記述し、リストまたはタプルから引数を解凍します。

>>> range(3, 6)             # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> range(*args)            # call with arguments unpacked from a list
[3, 4, 5]

同様に、辞書は**演算子を使用してキーワード引数を配信できます。

>>> def parrot(voltage, state='a stiff', action='voom'):
...     print "-- This parrot wouldn't", action,
...     print "if you put", voltage, "volts through it.",
...     print "E's", state, "!"
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

4.7.5。 ラムダ式

lambda キーワードを使用して、小さな無名関数を作成できます。 この関数は、lambda a, b: a+bという2つの引数の合計を返します。 ラムダ関数は、関数オブジェクトが必要な場所ならどこでも使用できます。 それらは構文的に単一の式に制限されています。 意味的には、これらは通常の関数定義の単なる構文糖衣です。 ネストされた関数定義と同様に、ラムダ関数は含まれているスコープから変数を参照できます。

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43

上記の例では、ラムダ式を使用して関数を返します。 もう1つの使用法は、小さな関数を引数として渡すことです。

>>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
>>> pairs.sort(key=lambda pair: pair[1])
>>> pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

4.7.6。 ドキュメント文字列

ドキュメント文字列の内容とフォーマットに関する新しい規則があります。

最初の行は、常にオブジェクトの目的の短く簡潔な要約である必要があります。 簡潔にするために、オブジェクトの名前またはタイプを明示的に記述しないでください。これらは他の手段で使用できるためです（名前が関数の操作を説明する動詞である場合を除く）。 この行は大文字で始まり、ピリオドで終わる必要があります。

ドキュメント文字列にさらに行がある場合は、2行目を空白にして、要約を残りの説明から視覚的に分離する必要があります。 次の行は、オブジェクトの呼び出し規約、その副作用などを説明する1つ以上の段落である必要があります。

Pythonパーサーは、Pythonの複数行の文字列リテラルからインデントを削除しないため、ドキュメントを処理するツールは、必要に応じてインデントを削除する必要があります。 これは、次の規則を使用して行われます。 文字列の最初の行の後の最初の非空白行は、ドキュメント文字列全体のインデントの量を決定します。 （最初の行は通常、文字列の開始引用符に隣接しているため、文字列リテラルではインデントがわかりません。）このインデントに「相当する」空白は、文字列のすべての行の先頭から削除されます。 。 インデントが少ない行は発生しないはずですが、発生する場合は、先頭の空白をすべて削除する必要があります。 空白の同等性は、タブを拡張した後にテストする必要があります（通常は8スペースに）。

複数行のdocstringの例を次に示します。

>>> def my_function():
...     """Do nothing, but document it.
...
...     No, really, it doesn't do anything.
...     """
...     pass
...
>>> print my_function.__doc__
Do nothing, but document it.

    No, really, it doesn't do anything.

4.8。 Intermezzo：コーディングスタイル

より長く、より複雑なPythonを作成しようとしているので、コーディングスタイルについて話す良い機会です。 ほとんどの言語は、さまざまなスタイルで書くことができます（または、より簡潔に、フォーマット）。 他のものより読みやすいものもあります。 他の人があなたのコードを読みやすくすることは常に良い考えであり、素晴らしいコーディングスタイルを採用することはそのために非常に役立ちます。

Pythonの場合、 PEP 8 が、ほとんどのプロジェクトが準拠するスタイルガイドとして登場しました。 それは非常に読みやすく、目を楽しませてくれるコーディングスタイルを促進します。 すべてのPython開発者は、ある時点でそれを読む必要があります。 ここにあなたのために抽出された最も重要なポイントがあります：

• 4スペースのインデントを使用し、タブは使用しません。

  4つのスペースは、小さなインデント（ネストの深さを大きくすることができます）と大きなインデント（読みやすく）の間の適切な妥協点です。 タブは混乱を招き、除外するのが最善です。

• 79文字を超えないように行を折り返します。

  これにより、小さなディスプレイを使用するユーザーが支援され、大きなディスプレイに複数のコードファイルを並べて表示できるようになります。

• 空白行を使用して、関数とクラス、および関数内のコードのより大きなブロックを区切ります。

• 可能であれば、独自の行にコメントを付けてください。

• docstringを使用します。

• 演算子の前後とコンマの後にスペースを使用しますが、ブラケット構造のすぐ内側には使用しないでください：a = f(1, 2) + g(3, 4)。

• クラスと関数に一貫した名前を付けます。 慣例では、クラスにはCamelCaseを使用し、関数とメソッドにはlower_case_with_underscoresを使用します。 最初のメソッド引数の名前として常にselfを使用します（クラスとメソッドの詳細については、クラスの最初の確認を参照してください）。

• コードが国際的な環境で使用されることを意図している場合は、派手なエンコーディングを使用しないでください。 プレーンASCIIは、どのような場合でも最適に機能します。

脚注

1

実際には、オブジェクト参照による呼び出しの方が適切な説明になります。これは、可変オブジェクトが渡されると、呼び出し先がオブジェクトに加えた変更（リストに挿入されたアイテム）が表示されるためです。