Pythonでは条件分岐をするために if 文あるいは match 文を使います。
Pythonでは条件分岐をするために if 文を使います{{Cite web
|url=https://docs.python.org/3/tutorial/controlflow.html#if-statements
|title=4.1. if Statements
|date=2024/01/06
|accessdate=2024/01/17
。基本的な形は以下のようになります:
 
if 条件:
    条件が真の場合に実行されるコード
elif 別の条件:
    別の条件が真の場合に実行されるコード
else:
    どの条件も満たされない場合に実行されるコード
例えば、ある変数 x の値に基づいて条件分岐する場合を考えてみましょう:
x = 10
if x > 10:
    print("xは10より大きいです")
elif x < 10:
    print("xは10より小さいです")
else:
    print("xは10です")
 
この場合、x の値が10なので、最初の条件と最後の条件のどちらも満たされますが、最初の条件が先に評価されます。そのため、"xは10です" と出力されます。
条件分岐を使うことで、プログラムが特定の条件下で異なる動作をするように制御することができます。
Python 3.10以降では、match文が導入されました{{Cite web
|url=https://docs.python.org/3/tutorial/controlflow.html#match-statements
|title=4.1. if Statements
|date=2024/01/06
|accessdate=2024/01/17
。match文は、特定の値に基づいてパターンをマッチングし、対応するブロックを実行するのに使用されます。match文は、複数の値や条件を一度に比較し、コードをより読みやすくし、処理をシンプルにするのに役立ちます。
以下は、match文の基本的な使い方です:
def check_value(x):
    match x:
        case 1:
            print("xは1です")
        case 2:
            print("xは2です")
        case _:
            print("その他の値です")
この例では、x の値に応じて異なる処理を行います。match文では、caseキーワードを使用して値やパターンを指定し、そのパターンがマッチした場合に対応するブロックが実行されます。また、case _:のように_を使用することで、どのケースにもマッチしない残りのケースを処理することができます。
さらに、match文では複数の条件やパターンをまとめて処理することもできます。例えば、タプルやリスト、または|演算子を使用して複数の条件を指定できます:
def check_pair(pair):
    match pair:
        case (0, 0):
            print("原点です")
        case (x, y) if x == y:
            print("xとyは同じ値です")
        case (x, _) if x > 0:
            print("xは正の値です")
        case _:
            print("その他のケースです")
この例では、(0, 0)ならば原点、(x, y)でxとyが同じなら同じ値、(x, _)でxが正の値なら正の値、それ以外のケースを処理します。
match文はパターンマッチングを使用して柔軟な条件分岐を行うのに役立ちます。これにより、コードの読みやすさと保守性を向上させることができます。
条件式はプログラミングで特定の条件が成立するかどうかを判定するために使われます。Pythonでは、if文を使って条件式を評価し、条件が真である場合に特定のコードブロックを実行します。
基本的な構文は以下のようになります：
if 条件式:
    条件が真の場合に実行されるコード
else:
    条件が偽の場合に実行されるコード
elseは省略可能で、条件が偽の場合に何も実行しないようにすることができます。
Pythonでは比較演算子や論理演算子を使って条件式を組み立てることができます。主な比較演算子は以下の通りです：
例えば：
 
x = 5
if x == 5:
    print("xは5です")
else:
    print("xは5ではありません")
比較演算の特異な例
x = float("nan")
if x > 0.0:
    print("xは正の数です")
elif x < 0.0:
    print("xは負の数です")
elif x == 0.0:
    print("xは零です")
else:
    print(f"xは{x}です")
実行結果:
xはnanです
{{コラム|nanってナニ？|2=
唐突に float("nan")、が出てきましたが、これがPythonでNaN（Not a Number; 非数）を得る方法で、他には math を import して math.nan を使う方法もあります。
nan は、浮動小数点演算の結果として、不正なオペランドを与えられたために生じた結果を表す値またはシンボルでただし、Pythonでは math.asin(2) ↑ValueError であったりnanを返す前に例外が上がる事が多々あります。、NaNの体系的仕様は、無限大の表現などと共に1985年の IEEE 754 浮動小数点規格で標準が与えられています。
nanの特徴
さらに、複数の条件を組み合わせるために論理演算子を使用できます：
例えば：
 
x = 10
y = 5
if x > 5 and y < 10:
    print("xは5より大きく、yは10より小さいです")
このようにして、条件式を使うことでプログラム内で特定の条件が成立するかどうかを判断し、それに応じた処理を行うことができます。
{{コラム|複数の比較演算子の連結|上記の例では、and 演算子の説明のため
としていますが、これは
と書くこともできます。両者は同じ意味になりますがxの参照は後者は一度だけになります。
in演算子はPythonで非常に便利な演算子の1つです。in演算子は特定の要素がコレクション（リスト、タプル、文字列など）に含まれているかどうかをチェックするのに使います。
例えば、リスト内に特定の要素が含まれているかを確認する場合に使えます:
 
my_list = [1, 2, 3, 4, 5]
if 3 in my_list:
    print("3はリスト内に含まれています")
同様に、文字列内で特定の部分文字列が存在するかを確認することもできます:
 
my_string = "Hello, World!"
if "Hello" in my_string:
    print("文字列内に'Hello'が含まれています")
in演算子は、リストや文字列の他にも、辞書や集合などのコレクションでの要素の存在をチェックするのに役立ちます。条件式にin演算子を使うことで、特定の要素がコレクションに含まれているかどうかを簡単に判断できます。
Pythonの条件式では、整数、文字列、リストなどのさまざまなデータ型を使用することができます。条件式では、その値が真か偽かを判定します。
整数を条件式として使用する場合、0は偽として扱われ、0以外の整数は真として扱われます。例えば：
 
x = 5
if x:
    print("xは真です")
else:
    print("xは偽です")
ここでは、xが0以外の値（真）を持っているため、"xは真です"と出力されます。
文字列やリストなどのシーケンスも条件式として使用できます。空の文字列や空のリストは偽として扱われます。例えば：
 
my_string = ""
my_list = []
if my_string or my_list:
    print("空ではありません")
else:
    print("空です")
上記の場合、my_stringとmy_listの両方が空なので、"空です"と出力されます。
このように、Pythonの条件式では値が真か偽かを判定し、それに基づいてコードを実行することができます。整数、文字列、リストなど、さまざまなデータ型を条件式として使用することで、柔軟な条件分岐を行うことができます。
Pythonのif文は、条件に基づいてコードの実行を制御するためのものでしたが、Python3.8からはif式（または三項演算子）が導入されました。if式は、1行で条件に応じて値を返すことができます。
if式の基本的な構文は以下の通りです：
value_if_true if condition else value_if_false
 
これは、条件が真の場合にvalue_if_trueを返し、偽の場合にvalue_if_falseを返します。
例えば、次のように使えます：
 
x = 5
result = "Even" if x % 2 == 0 else "Odd"
print(result)
この場合、xが偶数なら"Even"が、奇数なら"Odd"が出力されます。
このように、if式を使うと簡潔に条件に応じて値を設定したり、返したりすることができます。特に、1行で簡潔に条件式を表現したい場合に便利です。
内包表記とif式は、Pythonでコードを短く、効率的に書くための強力な機能です。
内包表記は、リスト、集合、辞書などのデータ構造を構築するための簡潔な方法です。if式を内包表記に組み込むことで、特定の条件を満たす要素のみを含むリストや集合を生成できます。
リスト内包表記でifを使う例を見てみましょう：
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = [x for x in numbers if x % 2 == 0]
print(even_numbers)
 
このコードでは、numbersリストから偶数のみを取り出してeven_numbersリストを生成しています。リスト内包表記の中でifを使用することで、条件に合致する要素だけを含むリストを作成できます。
同様に、辞書内包表記や集合内包表記でもif式を使用できます。例えば：
odd_squares_dict = {x: x**2 for x in numbers if x % 2 != 0}
print(odd_squares_dict)
even_set = {x for x in numbers if x % 2 == 0}
print(even_set)
 
これらの例は、内包表記を使って条件に基づいてリスト、辞書、集合を生成する方法を示しています。if式を内包表記に組み込むことで、コンパクトで読みやすいコードを書くことができます。
Python 3.10 から、パターンマッチングを行う match 文がサポートされました{{Cite web
|url=https://docs.python.org/3/tutorial/controlflow.html#tut-match
|title=4.6. match Statements
|date=2021/11/17
|accessdate=2021/11/18
。
正規表現の match メソッドとは別です。
match文を使った条件分岐:
for x in range(10):
    print(x,"=", end=" ")
    match x:
        case 2:
            print('two')
        case 5:
            print('five')
        case 7:
            print('seven')
        case _:
            print('ELSE')
実行結果:
0 = ELSE
1 = ELSE
2 = two
3 = ELSE
4 = ELSE
5 = five
6 = ELSE
7 = seven
8 = ELSE
9 = ELSE
_ は、ワイルドカードバターンで全てにマッチします。
match文は、2021年に導入された新しい機能で、3.9以前のバージョンのpythonではmatch文は使えません。
Pythonの match 文で使用されるパターンは、以下のようなものがあります。
以下で、それぞれについて詳しく解説します。
value パターンは、値が等しいかどうかを比較するためのパターンです。以下は、例です。
match color:
    case "red":
        print("赤色です")
    case "blue":
        print("青色です")
    case "green":
        print("緑色です")
この例では、color という変数に格納された値に応じて、条件分岐を行っています。case "red": は、color が "red" と等しい場合にマッチします。
ワイルドカードパターンは、どの値にもマッチするパターンです。ワイルドカードパターンは、_ という記号で表現します。
 
match value:
    case _:
        # valueがどの値にもマッチする場合の処理
ガードパターンは、条件式が True である場合にマッチするパターンです。ガードパターンは、if キーワードを使って表現します。
match value:
    case x if x > 0:
        # valueが0より大きい場合の処理
    case y if y < 0:
        # valueが0より小さい場合の処理
    ...
type パターンは、型が等しいかどうかを比較するためのパターンです。以下は、例です。
 
match value:
    case int:
        print("整数型です")
    case float:
        print("浮動小数点型です")
    case str:
        print("文字列型です")
    case _:
        print("不明な型です")
この例では、value という変数に格納された値の型に応じて、条件分岐を行っています。case int: は、value の型が整数型の場合にマッチします。
as パターンは、値を別名で参照するためのパターンです。以下は、例です。
 
match value:
    case int as n:
        print("整数型です。値は", n, "です")
    case float as f:
        print("浮動小数点型です。値は", f, "です")
    case str as s:
        print("文字列型です。値は", s, "です")
    case _:
        print("不明な型です")
この例では、value という変数に格納された値の型に応じて、条件分岐を行っています。case int as n: は、value の型が整数型の場合にマッチし、value の値を n という名前で参照することができます。
orパターンは、二つのパターンのいずれかにマッチする場合に使用されます。例えば、次のように使用します。
match x:
    case 0 or 1:
        print("x is either 0 or 1")
    case 2 or 3:
        print("x is either 2 or 3")
    case _:
        print("x is something else")
listパターンは、リストに対してマッチする場合に使用されます。次のように、リストの要素を一つ一つマッチングします。
match my_list:
    case [0, 1]:
        print("my_list is [0, 1]")
    case [2, 3]:
        print("my_list is [2, 3]")
    case [4, _, _]:
        print("my_list starts with 4 and has at least 3 elements")
    case _:
        print("my_list is something else")
tupleパターンは、タプルに対してマッチする場合に使用されます。リストの場合と同様に、タプルの要素を一つ一つマッチングします。
match my_tuple:
    case (0, 1):
        print("my_tuple is (0, 1)")
    case (2, 3):
        print("my_tuple is (2, 3)")
    case (4, _, _):
        print("my_tuple starts with 4 and has at least 3 elements")
    case _:
        print("my_tuple is something else")
dictパターンは、辞書に対してマッチする場合に使用されます。次のように、辞書のキーと値を一つ一つマッチングします。
match my_dict:
    case {'a': 1, 'b': 2}:
        print("my_dict is {'a': 1, 'b': 2}")
    case {'c': 3, 'd': 4}:
        print("my_dict is {'c': 3, 'd': 4}")
    case {'e': 5, 'f': _}:
        print("my_dict has the key 'e' with the value 5 and the key 'f' with some other value")
    case _:
        print("my_dict is something else")
classパターンは、特定のクラスのインスタンスに対してマッチする場合に使用されます。次のように、クラス名を指定して、クラスのインスタンスにマッチングします。
class MyClass:
    def __init__(self, x, y):
        self.x = x
        self.y = y
match my_obj:
    case MyClass(0, 1):
        print("my_obj is an instance of MyClass with x=0 and y=1")
    case MyClass(2, 3):
        print("my_obj is an instance of MyClass with x=2
Pythonのシーケンスパターンは、リスト、タプル、文字列、バイト列のようなシーケンス型のデータをマッチングするために使用されます。シーケンスパターンは、複数の要素を一度にマッチングするために使用され、組み込みの結合演算子を使用して複数のパターンを結合することができます。
以下は、シーケンスパターンを使用してリストをマッチングする例です。
 
match my_list:
    case [1, 2, 3]:
        print("Matched [1, 2, 3]")
    case [1, _, _]:
        print("Matched [1, _, _]")
    case [1, *rest]:
        print("Matched [1, *rest]")
        print("rest =", rest)
    case _:
        print("Matched anything else")
上記の例では、my_listが4つの異なるパターンにマッチするように定義されています。最初のパターン [1, 2, 3]は、my_listが要素が1, 2, 3のリストである場合にマッチします。2番目のパターン [1, _, _]は、my_listが最初の要素が1で、次の2つの要素が何であってもマッチします。3番目のパターン [1, *rest]は、my_listが最初の要素が1である場合にマッチし、*restはリストの残りの部分をキャプチャします。最後のパターン _は、どのリストにもマッチするため、最後のパターンは常に True を返します。
シーケンスパターンは、パターンの部分を任意の式で置き換えることができるため、マッチングされた要素にアクセスして処理を実行することができます。例えば、以下の例ではリストの最初の2つの要素にアクセスしていることがわかります。
 
match my_list:
    case [x, y, *rest]:
        print("First two elements:", x, y)
        print("Rest of the list:", rest)
この例では、xとyは最初の2つの要素を表し、restは残りのリストを表します。
rest はキーワードではありませんが、レストパターンを引き受ける変数の名前としてよく使われます。
match文の最初の例は、辞書を使って下のように書き換えることができます。
[https://paiza.io/projects/-c2_s18bUngaNFWE7KVdSQ?language=python3 辞書を使った例]:
h = { 2: "two", 5: "five", 7: "seven"}
for x in range(10) :
    print(f"{x} =", x in h and h[x] or "ELSE")
Python 3.4からは、enumモジュールが標準ライブラリとして提供されています{{Cite web
|url=https://docs.python.org/3/library/enum.html
|title=enum — Support for enumerations
|date=2021/11/17
|accessdate=2021/11/18
。
以下は、enumパッケージを使用した簡単な例です。
from enum import Enum
class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3
 
このように、Enumを継承したクラスを作成し、クラス属性として定数を定義することで、独自の列挙型を定義できます。
上記の例では、Colorという列挙型を定義し、RED、GREEN、BLUEという3つの定数を定義しています。
列挙型を使用すると、例えばColor.REDというように、定数に直接アクセスすることができます。
 
print(Color.RED)   # Color.RED
print(Color.RED.name)  # RED
print(Color.RED.value)  # 1
また、列挙型はforループを使って列挙することができます。
 
for color in Color:
    print(color)
match文と組み合わせると、列挙型の値に基づいた処理を簡潔に記述できます。
 
match color:
    case Color.RED:
        print("Red color")
    case Color.GREEN:
        print("Green color")
    case Color.BLUE:
        print("Blue color")
Python 3.10以降では、enumパッケージにauto()という新しい機能が導入されました。これにより、列挙型に自動的に連番の値を割り当てることができます。
 
from enum import Enum, auto
class Color(Enum):
    RED = auto()
    GREEN = auto()
    BLUE = auto()
for color in Color:
    print(color.value)
上記のコードでは、auto()を使用して列挙型に自動的に連番の値を割り当てています。結果として、Color.REDは1、Color.GREENは2、Color.BLUEは3の値を持ちます。
まとめ
from enum import Enum
class MyEnum(Enum):
    VALUE1 = 1
    VALUE2 = 2
    VALUE3 = 3
print(list(MyEnum))
print(MyEnum.VALUE1.value)
print(MyEnum['VALUE2'])
print(MyEnum(3))
class MyEnum(Enum):
    VALUE1 = 1
    VALUE2 = 2
    VALUE3 = 3
class MyOtherEnum(Enum):
    VALUE1 = 1
    VALUE2 = 2
    VALUE3 = 3
print(MyEnum.VALUE1 == MyOtherEnum.VALUE1)  # False
print(MyEnum.VALUE1 == MyEnum.VALUE1)        # True
class MyExtendedEnum(MyEnum):
    VALUE4 = 4
    VALUE5 = 5
from enum import Enum, auto
class MyAutoEnum(Enum):
    VALUE1 = auto()
    VALUE2 = auto()
    VALUE3 = auto()
print(MyAutoEnum.VALUE1.value)  # 1
print(MyAutoEnum.VALUE2.value)  # 2
print(MyAutoEnum.VALUE3.value)  # 3
Pythonには、さまざまな繰り返しの方法があります。主なものは for ループと while ループです。
for ループは、リスト、タプル、辞書、集合などのイテラブル（要素を一つずつ取り出せるオブジェクト）を繰り返し処理するのに使います。
リストの例:
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)
fruitsリスト内の各要素を順番に取り出して、その要素をfruitという変数に格納してループ内で使用しています。
辞書の例:
person = {"name": "Alice", "age": 30, "city": "New York"}
for key, value in person.items():
    print(f"{key}: {value}")
items()メソッドを使って辞書のキーと値のペアを取得し、keyとvalueにそれぞれ格納しています。
while ループは指定された条件が真の間、繰り返し処理を実行します。
count = 0
while count < 5:
    print(count)
    count += 1
 
この例では、countが5未満の場合にループが実行され、countの値が表示されます。count += 1によってcountが1ずつ増加します。
=演算子はPython 3.8で導入された「セイウチ演算子（Walrus operator）」として知られています。これは式内で変数に値を代入するためのもので、通常の代入文とif文を組み合わせたような構文を、より簡潔に記述できるようにします。
例えば、whileループでの使用方法を見てみましょう：
total = 0
while (input_value := int(input("Enter a number (0 to stop): "))) != 0:
    total += input_value
print(f"The total is: {total}")
 
この例では、input()関数を使ってユーザーから数値を入力し、:=演算子を使用して同時にinput_valueに代入しています。そして、入力された値が0でない限り、ループは継続され、totalに入力値を加算し続けます。入力された数値が0であればループは終了し、最終的な合計値が表示されます。
この演算子は、ループ内で変数を初めて定義する際や、式内で一時的な変数を使う場合などに特に便利です。ただし、適切に使うことでコードの読みやすさを損なわないように注意が必要です。
breakやcontinueなどの制御構造も使えます。breakはループを抜け出し、continueはループの現在のイテレーションをスキップして次のイテレーションに進みます。
for i in range(10):
    if i == 3:
        continue
    if i == 8:
        break
    print(i)
 
この例では、continueはiが3のときに処理をスキップし、breakはiが8のときにループを抜けます。
これらの方法を使って、Pythonで繰り返し処理を行う機能を活用することができます。
while文あるいはfor文がbreak文で中断しなかった場合、forにつづくelse節が実行されます。else節は、大概のプログラミング言語ではif文と組合わせて使いますが、Pythonではこれに加え繰返し（while文あるいはfor文）と組合わせることができます。
[https://paiza.io/projects/4s_1wWSiw8nbGB2jGNVjww?language=python3 while+else]:
i = 0
while i < 100:
    print(i, end=" ")
    i += 3
else:
    print("done!")
i = 0
while i < 100:
    if i > 10:
        break
    print(i, end=" ")
    i += 3
else:
    print("done!")
実行結果:
0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45 48 51 54 57 60 63 66 69 72 75 78 81 84 87 90 93 96 99 done!
0 3 6 9 
ループを完走した場合は else 節を実行し、break （や return）で中断すると else 節は実行されません。
1つ目のwhileループは、変数iを0から3ずつ増やし、100以上になるまでループを繰り返します。ループの本体では、変数iの値を印刷します。end=" "は、印刷された各値の後に空白を追加し、すべてを1行に表示するためのものです。最後に、else節で"done!"というメッセージを印刷します。
2つ目のwhileループは、変数iを0から3ずつ増やし、10を超えるまでループを繰り返します。ループの本体では、変数iの値を印刷し、それが10を超えた場合は、breakステートメントが呼び出され、ループが終了します。最後に、else節が実行されず、"done!"というメッセージは印刷されません。
{{コラム|ループと結合したelseの使いどころ|2=
Pythonでは、ループが完走したときに実行されるelse節を置くことができます。
では、このelse節は何に使うのでしょう？
1000以下の素数を求める（フラッグ版）:
i = 2
while i <= 1000:
    j = 2
    is_prime = True
    while j * j <= i:
        if i % j == 0:
            is_prime = False
            break
        j += 1
    if is_prime:
        print(i, end=" ")
    i += 1
break で抜けたかをフラッグ is_prime で判断しています。
ゴチャゴチャしています。
1000以下の素数を求める（else版）:
i = 2
while i <= 1000:
    j = 2
    while j * j <= i:
        if i % j == 0:
            break
        j += 1
    else:
        print(i, end=" ")
    i += 1
フラッグがなくなり簡素になりました。
1000以下の素数を求める（for+range版）:
for i in range(2, 1000):
    for j in range(2, i):
        if i % j == 0:
            break
    else:
        print(i, end=" ")
こちらの方がより簡潔ですね。
while版と比べ内側のループが廻りすぎていますが（本来 sqrt(i)までで良い）、j2がなくなっているので1000までの区間なら性能劣化は軽微。
1000以下の素数を求める（素数集合更新版）:
primes = []
for i in range(2, 1000):
    for prime in primes:
        if i % prime == 0:
            break
    else:
        primes.append(i)
        print(i, end=" ")
primes は素数が小さい順に保持されるので最も効率よく因数を探せます。
ループ完走のelseを使うと、「因数が見つからなかった」ケースをフラッグなしに表現でき、記述力が向上し、より洗練されたアルゴリズムの探求に貢献しています。
もし、素数集合更新版をフラッグで表現したら、これより遥かに記述性が劣るでしょう。
Python以外の言語では、Zigでも else を伴ったループ構文があります。
[https://paiza.io/projects/sM0j7iLBt7T2RipkLflGOw?language=python3 for+else]:
h = {2: "two", 5: "five", 7: "seven"}
for x in list(h):
    print(h[x])
else:
    print("I didn't take a break.")
for x, v in h.items():
    if x == 7:
        break
    print(x, v)
else:
    print("I didn't take a break.")
実行結果:
two
five
seven
I didn't take a break.
2 two
5 five
ループをカンストした場合は else 節を実行し、break （や return）で中断すると else 節は実行されません。
{{コラム|ループとelseを組合わせた大域脱出|2=
Pythonはgoto分やラベル付きbreak文を持っていないので、大域脱出する場合は
などの工夫が必要です。
ここでは、ループと結合したelseを使った大域脱出を紹介します。
ループと結合したelseを使った大域脱出:
for i in range(10):
    for j in range(10):
        for k in range(10):
            if (i == 2 and j == 3 and k == 5):
                break
            print(f"{i}{j}{k}", end=" ")
        else:
            print()
            continue
        break
    else:
        continue
    break
else:
    print("done!")
実行結果:
000 001 002 003 004 005 006 007 008 009 
010 011 012 013 014 015 016 017 018 019 
020 021 022 023 024 025 026 027 028 029 
030 031 032 033 034 035 036 037 038 039 
040 041 042 043 044 045 046 047 048 049 
050 051 052 053 054 055 056 057 058 059 
060 061 062 063 064 065 066 067 068 069 
070 071 072 073 074 075 076 077 078 079 
080 081 082 083 084 085 086 087 088 089 
090 091 092 093 094 095 096 097 098 099 
100 101 102 103 104 105 106 107 108 109 
110 111 112 113 114 115 116 117 118 119 
120 121 122 123 124 125 126 127 128 129 
130 131 132 133 134 135 136 137 138 139 
140 141 142 143 144 145 146 147 148 149 
150 151 152 153 154 155 156 157 158 159 
160 161 162 163 164 165 166 167 168 169 
170 171 172 173 174 175 176 177 178 179 
180 181 182 183 184 185 186 187 188 189 
190 191 192 193 194 195 196 197 198 199 
200 201 202 203 204 205 206 207 208 209 
210 211 212 213 214 215 216 217 218 219 
220 221 222 223 224 225 226 227 228 229 
230 231 232 233 234 
最外周のprint("done!")は（breakされた場合は）実行されません。
Pythonでは、ループはスコープを作りません。
[https://paiza.io/projects/TSbRsnv1oAaOQ3_5ErbRVg?language=python3 ループはスコープを作りません]:
i = "abc"
j = "xyz"
print(f"forの前： {i=}、{j=}")
for i in range(5):
    j = 2 * i
    print(f"forの中： {i=}、{j=}")
print(f"forの後： {i=}、{j=}")
実行結果:
forの前： i='abc'、j='xyz'
forの中： i=0、j=0
forの中： i=1、j=2
forの中： i=2、j=4
forの中： i=3、j=6
forの中： i=4、j=8 
forの後： i=4、j=8