Python 06：繰り返し・分岐・例外

Python の for は「取り出せるもの」から1つずつ

Python の for を一言でいうと、「中身を1つずつ取り出せるもの」から、尽きるまで1つずつ受け取って、中身の処理を繰り返す仕組みです。

たとえるなら、袋から1つずつ物を取り出す係です。袋がリストでも、文字列でも、ファイルでも、係に「次をちょうだい」と頼む手順は同じです。袋ごとの取り出し方の違いは、袋の側が知っています。

この「1つずつ取り出せるもの」を Python ではイテラブル（iterable＝反復できるもの）と呼びます。リスト・タプル・文字列・辞書・集合・ファイル・range(…) などが、すべてイテラブルです。

JS の書き方と並べると、図の表のようになります。

Python の for … in は、JS の `for…of` に近いものです。名前は in ですが、JS の for…in（キーを回す）とは別物なので注意してください。

実は JS の for…of も、裏では「イテレータ」という同じ考え方で動いています（Symbol.iterator）。Python はそれを唯一の for にした、と考えるとわかりやすいでしょう。

この裏側の仕組みは、少し先で図を動かして見ます。その前に、分岐の if を片付けておきます。

if / elif / else：波かっこの代わりにコロンと字下げ

条件で処理を分ける if は、JS とほとんど同じ考え方です。違うのは書き方です。

図の左が JS、右が Python です。気温 temp から「暑い」「ちょうどいい」「寒い」を決めています。

Python の三項演算子（条件式）は、並び順が JS と違います。

label = "暑い" if temp >= 30 else "ふつう"

「"暑い"、もし temp が30以上なら。そうでなければ "ふつう"」と、英語の語順で読むとわかりやすくなります。

条件に書ける値の真偽（空の文字列や 0、空のリスト、None は偽になる）や、and・or・not は第3章で見たとおりです。JS の &&・||・! は Python では使えません。

if city and temp is not None:
    print(city, temp)

is not None は「None ではない」の決まった書き方です（第3章の is）。

for の裏側 ①：iter() で「取り出し係」を作る

ここからは、for city in cities: print(city) と書いたとき、Python が裏で何をしているかを1段ずつ見ます。

図の左下のコードが、その「中身」を書き下したものです。for はこれと同じことを自動でやっています。実際にこのコードを実行しても、for と同じ結果になります。

最初にやるのは、iter(cities) を呼ぶことです。`iter()` は組み込みの関数で、渡されたものに「あなたの中身を1つずつ出してくれる係をちょうだい」と頼みます。返ってくるものをイテレータ（iterator）と呼びます。

実際に REPL（第1章）で試すと、こうなります。

>>> cities = ["東京", "大阪", "札幌"]
>>> it = iter(cities)
>>> it
<list_iterator object at 0x7f73be0adba0>

list_iterator という、リスト専用の取り出し係ができました（0x… の数字は実行するたびに変わります）。

なぜリストが直接「次」を出さず、わざわざ係を作るのでしょうか。リスト自体は「どこまで出したか」を覚えていないからです。覚えているのは係のほうです。

このおかげで、同じリストを2つの for で同時に回しても（たとえば for の中にもう1つ for を入れても）、それぞれが自分の係を持つので、位置が混ざりません。

for の裏側 ②：next() で1つ取り出し、中身を実行する

係ができたら、次は `next(it)` で1つ取り出します。係は「東京」を返し、自分の位置を1つ進めます。

>>> next(it)
'東京'
>>> next(it)
'大阪'

for は、取り出した値に city という名前を付けて（第4章の「札を付ける」）、for の中身、つまり print(city) を1回実行します。図の右下の出力に「東京」が出ました。

ここで大事なのは、`city` は毎回、新しい値に付け替えられる名前にすぎないということです。JS の for (const c of …) では回ごとに新しい c が作られますが、Python ではループが終わった後も city という名前は残り、最後に取り出した値を指したままになります。

>>> for city in cities:
...     pass
...
>>> city
'札幌'

Python には JS のような「ブロックの中だけの変数」（let のスコープ）がありません。for や if の中で作った名前は、その関数（またはファイル）全体で見えます（第5章のスコープ）。

for の裏側 ③：尽きるまで同じことを繰り返す

あとは同じことの繰り返しです。

図では、リストの3つの札がすべて灰色になり、取り出し係の位置は「次は3番目」になりました。リストには0〜2番目しか無いので、もう出すものはありません。

私たちが書いたのは print(city) だけです。iter() を呼ぶのも、next() を何度も呼ぶのも、名前を付け替えるのも、すべて for が代わりにやってくれています。

逆にいえば、`iter()` と `next()` に応えられる物なら、何でも `for` で回せます。リストかどうかは関係ありません。自分で作ったクラスでも、__iter__ と __next__ という特殊メソッド（第7章）を書けば回せるようになります。

for の裏側 ④：尽きたら StopIteration で終わる

4回目の next(it) では、もう出すものがありません。このとき係は値を返す代わりに、`StopIteration` という例外を投げます。

>>> next(it)
Traceback (most recent call last):
  ...
StopIteration

例外とは「ふつうに値を返せない事情が起きた」ことを知らせる仕組みで、この章の後半で詳しく見ます。ここでは StopIteration はエラーではなく「おしまい」の合図だと考えてください。

図の左下のコードでは、except StopIteration: がこの合図を受け止めて break し、while True: のループを抜けています。本物の for も同じで、StopIteration を受け止めると静かにループを終えます。だから画面には何も出ません。

JS の for…of も、同じ役目を { value, done: true } という戻り値で表しています。JS は「終わったかどうか」を戻り値に入れ、Python は「例外を投げる」という形を選んだ、という違いです。

係は一度尽きると、それっきりです。同じ係でもう一度 for を回しても、何も出てきません。リストを回し直すと新しい係が作られるので、何度でも回せます。

>>> it = iter(cities)
>>> list(it)
['東京', '大阪', '札幌']
>>> list(it)
[]

回せるものは、リストだけではない

iter() に応える物なら、何でも for で回せます。よく使うものを図の表にまとめました。

辞書を回すとキーが出てくるのは、JS の for…in に似ています。値も欲しいときは次に出てくる items() を使います。

数を数えたいとき、JS では for (let i = 0; i < 3; i++) と書きました。Python にはこの形の for がありません。代わりに `range()` を回します。

for i in range(3):          # 0, 1, 2
    print(i)
for i in range(1, 10, 3):   # 1, 4, 7（1から、10の手前まで、3ずつ）
    print(i)

range(3) は、[0, 1, 2] というリストを作るわけではありません。REPL で見ると range(0, 3) と表示されます。「0から3の手前まで」という決まりだけを持った小さな物で、next() を頼まれるたびに次の数を計算して返します。だから range(10**9) と書いても、10億個の数でメモリがあふれることはありません。

中身をまとめて見たいときは list(range(3)) のようにリストに変換します。結果は [0, 1, 2] です。

番号も欲しい・並べて回したい・辞書を回したい

for を使っていると、よく次の3つが欲しくなります。どれも組み込みの道具で書けます。

実際に動かした結果が図のとおりです。

cities = ["東京", "大阪", "札幌"]
temps = [21.5, 24.0, 15.2]
for i, c in enumerate(cities, 1):
    print(i, c)          # 1 東京 / 2 大阪 / 3 札幌
for c, t in zip(cities, temps):
    print(c, t)          # 東京 21.5 / 大阪 24.0 / 札幌 15.2

for i, c in … のように、名前を2つ並べて受け取っているのに注目してください。enumerate が出すのは (1, "東京") というタプル（第4章）1つです。それを i と c に分けて受け取っています。これをアンパック（分けて受け取ること）と呼びます。JS の分割代入 const [i, c] = [1, "東京"] と同じ考え方です。

zip は、短いほうが尽きたところで止まります。

>>> list(zip(cities, [1, 2]))
[('東京', 1), ('大阪', 2)]

札幌が黙って消えました。長さが違うとエラーにならずに一部が捨てられるので、長さが同じはずのものを並べるときは気をつけてください（長さが違ったらエラーにしたいときは zip(a, b, strict=True) と書けます）。

「番号が欲しいから」と for i in range(len(cities)): と書いて cities[i] を取り出す人がいますが、Python では enumerate を使うのがふつうです。

while・break・continue、それと for の else

`while` は、条件が真の間だけ繰り返します。JS の while と同じです。

break（ループを抜ける）と continue（その回の残りを飛ばして次の回へ）も JS と同じ意味です。図の左のコードでは、n が2のときは continue で print を飛ばし、4のときは break で抜けるので、出力は「1」と「3」だけになります。

気をつけたいのは、Python には `n++` が無いことです。n += 1 と書きます。

図の右は、JS には無い `for … else` です。else の中は「`break` せずに最後まで回り切ったとき」だけ実行されます。

for c in cities:
    if c == "名古屋":
        print("見つけた")
        break
else:
    print("見つからなかった")

名古屋はリストに無いので、break されずにループが終わり、「見つからなかった」が出ます。「探して、見つからなかったら…」を、目印の変数（found = False など）無しで書けるのが利点です。

ただ、if の else と見間違えやすく、Python に慣れた人でも読み違えることがあります。使うなら短いループだけにしておくのが無難です。

match：switch に似ているが、形で分ける

Python 3.10 から `match` 文が使えるようになりました。見た目は JS の switch に似ています。

図の左は、天気の番号（0なら快晴、1〜3なら晴れ…）を言葉に変える describe() です。この本の tenki で使う番号は、気象の世界で広く使われている天気の番号の一部を借りたものだと思ってください。

JS の switch でよくある「break を書き忘れて、次の case まで実行された」事故は、Python では起きません。

match の本領は、値の形で分けられることです。たとえば tenki にコマンドを付けたくなったとします。

def handle(cmd):
    match cmd.split():
        case ["now", city]:
            return f"{city} の今の天気"
        case ["week", city, *rest]:
            return f"{city} の週間 {rest}"
        case _:
            return "使い方: now 都市"

handle("now 東京") は「東京 の今の天気」を返します。case ["now", city]: は「要素が2つのリストで、1つ目が "now"」のときに当たり、2つ目を city という名前で取り出します。当たるかどうかの判定と、中身の取り出しが一度にできるのです。

とはいえ、ただの値の分岐なら if / elif でも十分です。match は Python 3.10 より前の版では動かないことも覚えておいてください。

例外：うまくいかないことを「投げて」知らせる

ここからは、失敗の扱いです。

tenki で、データの無い都市「名古屋」を表示しようとしたとします。図の右のコードでは、main() が show("名古屋") を呼び、show の中で辞書 WEATHER["名古屋"] を読もうとします。

辞書に無いキーを [ ] で読むと、Python は値を返す代わりに `KeyError` という例外（exception）を投げます。JS ではオブジェクトに無いキーを読むと undefined が返るだけですが、Python ははっきり失敗として知らせるのです。

例外が投げられると、その行で処理が止まり、例外は呼んだ側へ遡っていきます。図の左の積み重ねで見ると、③の WEATHER["名古屋"] で投げられた KeyError（赤い小包）は、まず②の show() に戻ります。show の中には受け止める仕組みが無いので、show の残りの行（print）は実行されず、さらに上の①の main() へ遡ります。

この「呼んだ側の積み重ね」を呼び出しスタックと呼びます。例外は、受け止めてくれる場所が見つかるまで、スタックを1段ずつ上がっていきます。

無いキーで例外にしたくないときは、WEATHER.get("名古屋") と書くと、例外の代わりに None が返ります（第4章）。

遡った先に except があれば、そこで受け止める

①の main() では、show(city) の呼び出しを try: で包み、その下に except KeyError: を書いていました。遡ってきた KeyError は、ここで受け止められます。

try:
    show(city)
except KeyError:
    print(city, "はデータなし")

受け止めた後は、except の中身（「名古屋 はデータなし」を表示）を実行し、そのまま try 文の次へ進みます。for の中なので、次の都市の処理が続きます。

図で灰色になった②の show() は、途中で打ち切られたままです。print(f"{city}: {temp}℃") の行は実行されていません。

もしどこにも `except` が無かったら、例外はいちばん上（ファイルの一番外側）まで遡り、Python は Traceback（遡ってきた道すじ）を表示してプログラムを止めます。JS で catch されなかったエラーがコンソールに出て処理が止まるのと同じです。

try の4つの枠 ①：うまくいったとき

Python の try 文には、最大で4種類の枠があります。

図の左の parse() は、文字列を小数に変換する関数です。parse("21.5") を実行すると、float("21.5") は成功します。

このときの道すじは、図の右の緑の矢印のとおりです。try の中が最後まで通ったので except は飛ばされ、else の「成功: 21.5」、finally の「必ず通る」の順に実行されて、return t に進みます。左下の出力が実際に動かした結果です。

else は JS には無い枠です。「成功したときだけやること」は try の中の最後に書いても動きます。わざわざ else に分けるのは、`try` で包む範囲を、失敗しうる行だけに絞るためです。try の中に行を詰め込むと、別の行で起きた同じ型の例外まで、うっかり受け止めてしまいます。

try の4つの枠 ②：失敗したとき

今度は parse("はれ") です。float("はれ") は小数にできないので、`ValueError` を投げます。

道すじは図の赤い矢印です。try の中の残りは飛ばされ、except ValueError as e: が受け止めます。as e と書くと、投げられた例外そのものに e という名前が付き、中のメッセージを読めます。

>>> parse("はれ")
失敗: could not convert string to float: 'はれ'
必ず通る

else は飛ばされ、finally は失敗したときも通ります。finally は、開いたものを閉じる、一時ファイルを消す、といった「何があってもやる後片付け」を書く場所です。

finally が通るのは、ここで挙げた2つの場合だけではありません。

JS の finally とまったく同じ考え方です。

JS の try/catch との違い：型ごとに受け分ける

JS と Python の例外の扱いを並べると、図の表のようになります。いちばん大きな違いは受け分け方です。

JS では catch (e) を1つだけ書き、中で「どんなエラーか」を調べます。

try {
  show(city);
} catch (e) {
  if (e instanceof TypeError) { /* … */ } else { throw e; }
}

Python では、`except` を型ごとに並べ、上から順に見て、合った最初の1つに入ります。合うものが無ければ、例外はそのまま呼んだ側へ遡ります。

try:
    show(city)
except KeyError:
    print("データなし")
except (ValueError, TypeError) as e:
    print("データが壊れている:", e)

「合う」とは、その型か、その子孫の型であることです。Python の例外には親子関係があり、実際に調べるとこうなっています。

>>> KeyError.__mro__
(<class 'KeyError'>, <class 'LookupError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)

KeyError の親は LookupError、その親は Exception です。だから except LookupError: と書けば KeyError も IndexError も受け止められ、except Exception: と書けばふつうの例外はほぼすべて受け止められます。

JS では文字列でも何でも throw できますが、Python で raise できるのは `BaseException` の子孫だけです。raise "失敗" と書くと、それ自体が TypeError になります。

自分で raise する・自分の例外を作る

例外は、自分で投げることもできます。JS の throw に当たるのが `raise` です。

raise ValueError("気温が読めません")

JS の throw new Error("…") と違い、new は書きません。Python ではクラスを呼ぶだけで物が作られるからです（第7章）。

図の左のように、`Exception` を親にしたクラスを作れば、自分専用の例外になります。中身は pass（何もしない）で十分です。

class CityNotFound(Exception):
    pass

こうしておくと、呼ぶ側は except CityNotFound: と書いて、「都市が見つからない」失敗だけを狙って受け止められます。KeyError のような汎用の例外と混ざりません。

誰も受け止めないと、図の右のような Traceback が表示されてプログラムが止まります（実際の表示にはファイルの完全なパスや、どこで起きたかを示す ~~~^^^ の印も出ます）。

Traceback は下から読むのが基本です。

Traceback の読み方は第18章でもう一度まとめます。

with：後片付けを忘れさせない書き方

ファイルを開いたら、使い終わったら閉じる必要があります。閉じ忘れると、開いたままのファイルが溜まっていきます。また、書き込んだ内容はいったんメモリに溜められ（バッファ）、閉じたときなどにまとめてファイルへ書き出されるので、閉じないと反映が遅れることがあります。

確実に閉じるには、図の左下のように try / finally で包めば済みます。途中で例外が起きても finally は必ず通るからです。ただ、毎回これを書くのは面倒で、忘れがちです。

そこで Python には `with` 文があります。

with open("cities.txt", encoding="utf-8") as f:
    for line in f:
        print(line.strip())
print(f.closed)   # True

with のブロックを抜けた瞬間、ファイルは必ず閉じられます。ブロックの中で例外が起きても、return で抜けても同じです。実際に動かすと、最後の f.closed は True（閉じている）になります。

open() に encoding="utf-8" を付けているのは、日本語のファイルを読むためです。付けないと OS の既定の文字コードが使われ、Windows などで文字化けやエラーになることがあります。

図の右は、Node.js で同じことをした例です。fs/promises の open() で得たファイルを、try / finally で閉じています。JS では、この try / finally を自分で書くのがふつうです。

with の裏側：入るとき __enter__、出るとき __exit__

with は、ファイル専用の仕組みではありません。`__enter__` と `__exit__` という2つのメソッドを持つ物なら、何でも with に渡せます。こういう物をコンテキストマネージャーと呼びます。

with X() as t: で起きることを、図の番号の順に追います。

図の左は、この2つを自分で書いた Timer です。中身の途中で ValueError を投げても、実行結果（左下）のとおり「片付ける」が出ています。__exit__ には、起きた例外の型（<class 'ValueError'>）も渡されます。ふつうに終わったときは None が渡されます。

__exit__ が済んだ後、例外はそのまま外へ遡ります。with は例外を握りつぶすわけではなく、「外へ出る前に必ず片付けを挟む」だけです（__exit__ が True を返すと例外を止められますが、ふつうはしません）。

open() が返すファイルも、この2つを持っています。ファイルの __exit__ がやっていることが close() です。つまり with とは、前の図の try / finally を、相手の物に書いておいてもらう仕組みです。

__init__ や __exit__ のように、前後に __ が2つずつ付いた名前は特殊メソッドと呼ばれ、Python が決まった場面で自動で呼びます。第7章で詳しく見ます。

tenki に入れる：3都市を回し、1都市の失敗で止めない

ここまでの道具を tenki に入れます。まだ本物の天気を取りにはいかず（それは第11章で requests を入れてから）、辞書 WEATHER に仮のデータを置いています。describe() は match の例で書いたものです。

def main(cities):
    failed = 0
    for city in cities:
        try:
            show(city)
        except KeyError:
            print(f"{city}: データがありません")
            failed += 1
    return failed

実際に動かした結果が図の右です。名古屋でデータが無くても、大阪の表示まで進んでいます。最後の 1 は、失敗した都市の数（main の戻り値）です。

大事なのは、`try` で包む範囲を「1都市ぶん」にしていることです。

もう1つ、受け止めているのは KeyError だけです。except Exception: と広く書くと、show の中の書き間違い（たとえば変数名の打ち間違いで起きる NameError）まで「データがありません」と表示されてしまい、本当の原因が見えなくなります。受け止める例外は、想定している失敗だけに絞るのが基本です。

よくある間違いと、そのときのメッセージ

この章の内容で、JS から来た人がよくつまずく所をまとめました。エラーの最後の行（型の名前とメッセージ）を読めば、たいてい原因の見当がつきます。

回している最中に remove すると、たとえば [1, 2, 2, 3] から2を消そうとして [1, 2, 3] が残ります。取り出し係は「次は何番目」と位置だけで進むので、要素が詰められると1つ飛ばしてしまうのです（iter の図の仕組みそのままです）。

except: と型を書かないと、Ctrl+C で投げられる KeyboardInterrupt まで受け止めてしまいます。これは Exception ではなく BaseException の直接の子なので、except Exception: なら受け止めずに済みます。

except の中で raise とだけ書くと、受け止めた例外をそのまま投げ直せます。「記録だけして、処理は呼んだ側に任せる」ときに使います。