Python while文の使い方｜break・continueと無限ループ

Pythonのwhile文とは、「条件式がTrueと見なされるあいだ、字下げしたブロックをくり返し実行する」ための構文です。 while 条件式: と書き、ブロックの中で条件にかかわる変数を更新していきます。途中で抜けたいときは break、その回の残りを飛ばして次の判定に進みたいときは continue を使います。

この記事では、while文の基本から、while True と break を組み合わせた定番の形（入力の再要求・リトライ・メニュー）、無限ループの止め方、while-else、セイウチ演算子、forとの使い分けまでを1ページにまとめました。コードはすべて Python 3.14.7 で実行し、出力をそのまま載せています。 continueの前でカウンタの更新を忘れたときに何が起きるかも、実際に動かして確かめています。

Python while文の早見表

while文の基本の書き方

count = 1
while count <= 3:
    print(f"{count}回目")
    count += 1      # 条件に使う変数を更新する
print("終了。countは", count)

1回目
2回目
3回目
終了。countは 4

while文は次の順番で動きます。

1. 条件式 count <= 3 を評価する
2. Trueならブロックを上から下まで実行し、1に戻る
3. Falseならブロックを実行せず、while文の次の行へ進む

count が4になった時点で条件がFalseになり、ループが終わります。最初から条件がFalseなら、ブロックは1回も実行されません。

flowchart TD
    A[開始] --> B{count <= 3}
    B -- True --> C[ブロックを実行]
    C --> D[count を更新]
    D --> B
    B -- False --> E[ループの次の行へ]

while文に必要な3つの部品

コロンを書き忘れた場合のエラーは次のとおりです。

  File "b19.py", line 2
    while count < 3
                   ^
SyntaxError: expected ':'

条件を組み合わせる

if文と同じく、and・or・not で条件を組み合わせられます。

# 複数条件: 所持金がある かつ 5回未満
money = 500
times = 0
while money >= 120 and times < 5:
    money -= 120
    times += 1
    print(f"{times}回目の購入。残り{money}円")
print("ループ終了")

1回目の購入。残り380円
2回目の購入。残り260円
3回目の購入。残り140円
4回目の購入。残り20円
ループ終了

5回に達する前に所持金が120円を下回ったので、4回で終わりました。

回数がわからない処理こそwhileの出番

whileは「何回くり返すかが、やってみるまでわからない」処理に向いています。

n = 27
steps = 0
while n != 1:
    n = n // 2 if n % 2 == 0 else 3 * n + 1
    steps += 1
print(f"{steps}回で1になりました")

# 桁数を数える
value = 12345
digits = 0
while value > 0:
    value //= 10
    digits += 1
print("桁数:", digits)

111回で1になりました
桁数: 5

1つ目は「偶数なら2で割る、奇数なら3倍して1を足す」を1になるまでくり返す計算です。27から始めると111回かかりますが、この回数は事前にはわかりません。

breakでループを途中で抜ける

break を実行すると、条件式に関係なく、その場でループを抜けます。

total = 0
n = 1
while True:
    total += n
    if total > 20:
        break           # ループを抜ける
    n += 1
print(f"1から{n}まで足すと{total}（20を超えた）")

1から6まで足すと21（20を超えた）

while True: は条件が常にTrueなので、break が唯一の出口になります。「抜ける条件がループの途中で決まる」ときに読みやすい形です。

continueでその回の残りを飛ばす

continue を実行すると、ブロックの残りを飛ばして条件判定に戻ります。ループ自体は続きます。

n = 0
while n < 6:
    n += 1              # continue より前で更新する
    if n % 2 == 0:
        continue        # 偶数は以降をスキップして条件判定へ戻る
    print(n)

1
3
5

continueの前にカウンタ更新を忘れるとどうなるか

whileとcontinueの組み合わせで、いちばんつまずきやすいのがここです。更新を continue より後ろに書いた例を実行してみます。

n = 0
while n < 6:
    if n % 2 == 0:
        continue        # n が 0 のまま、ここから先へ進まない
    print(n)
    n += 1

このプログラムを、2秒で打ち切る timeout コマンドを付けて実行した結果です。

$ timeout 2 python3.14 b04.py
$ echo $?
124

何も表示されないまま2秒間動き続け、打ち切られました（終了コード124は timeout による打ち切りを表します）。n は0で偶数なので continue が実行され、n += 1 に届かないまま条件判定へ戻ります。n は0のままなので、同じことが永遠にくり返されます。

確認用に周回数の上限を付けると、状況がはっきり見えます。

n = 0
loops = 0
while n < 6:
    loops += 1
    if loops > 5:                       # 確認用の上限
        print("5周しても n は", n, "のまま")
        break
    if n % 2 == 0:
        continue
    print(n)
    n += 1

5周しても n は 0 のまま

「更新はcontinueより前」と覚えておくと防げます。forに書き換えられる処理（for n in range(1, 7):）であれば、更新を自分で書く必要がなくなるので、この種類のつまずき自体が起きません。

while True＋breakの定番パターン（コピペ用）

while True は「出口を break で書く」ことを前提にした形です。よく使う3つをそのまま貼って動く形で載せます。

パターン1：正しい値が入力されるまで聞き直す

while True:
    text = input("1〜5の整数を入力してください: ")
    if not text.isdecimal():
        print("  数字で入力してください")
        continue
    number = int(text)
    if 1 <= number <= 5:
        break
    print("  1〜5の範囲で入力してください")

print(f"入力された値: {number}")

abc、9、3 の順に入力したときの結果です（入力は標準入力から流し込んだため、入力した文字そのものは画面に表示されていません）。

1〜5の整数を入力してください:   数字で入力してください
1〜5の整数を入力してください:   1〜5の範囲で入力してください
1〜5の整数を入力してください: 入力された値: 3

• 条件に合わないときは continue で先頭へ戻り、もう一度入力を求めます。
• 条件に合ったときだけ break で抜けるので、ループの後ろでは number が必ず1〜5になっています。

パターン2：上限つきでリトライする

通信など、時間をおいてやり直すと成功する処理に使います。回数の上限を付けておくのがポイントです。

import time

calls = 0
def fetch():
    """3回目で成功する処理（動作確認用）"""
    global calls
    calls += 1
    if calls < 3:
        raise ConnectionError(f"{calls}回目は接続できませんでした")
    return "データ取得OK"

MAX_RETRY = 5
attempt = 0
while True:
    attempt += 1
    try:
        result = fetch()
        break                               # 成功したら抜ける
    except ConnectionError as e:
        print(f"[{attempt}/{MAX_RETRY}] {e}")
        if attempt >= MAX_RETRY:
            raise                           # 上限に達したら例外をそのまま上へ
        wait = 0.1 * 2 ** (attempt - 1)     # 0.1秒, 0.2秒, 0.4秒…と間隔を広げる
        print(f"    {wait:.1f}秒待って再試行")
        time.sleep(wait)

print(f"{attempt}回目で成功: {result}")

[1/5] 1回目は接続できませんでした
    0.1秒待って再試行
[2/5] 2回目は接続できませんでした
    0.2秒待って再試行
3回目で成功: データ取得OK

fetch() を自分の処理に、ConnectionError を想定する例外に置き換えて使います。待ち時間を回ごとに倍にしていく方法は、相手側の負荷を上げにくい定番の待ち方です。

パターン3：終了が選ばれるまでメニューをくり返す

tasks = []

while True:
    print("\n1: 追加  2: 一覧  3: 終了")
    choice = input("番号を選んでください: ").strip()

    if choice == "1":
        title = input("タスク名: ").strip()
        tasks.append(title)
        print(f"  「{title}」を追加しました")
    elif choice == "2":
        if not tasks:
            print("  タスクはまだありません")
        for i, t in enumerate(tasks, start=1):
            print(f"  {i}. {t}")
    elif choice == "3":
        print("終了します")
        break
    else:
        print("  1〜3で選んでください")

2、1（資料を作る）、1（備品を注文）、2、9、3 の順に入力したときの結果です。

1: 追加  2: 一覧  3: 終了
番号を選んでください:   タスクはまだありません

1: 追加  2: 一覧  3: 終了
番号を選んでください: タスク名:   「資料を作る」を追加しました

1: 追加  2: 一覧  3: 終了
番号を選んでください: タスク名:   「備品を注文」を追加しました

1: 追加  2: 一覧  3: 終了
番号を選んでください:   1. 資料を作る
  2. 備品を注文

1: 追加  2: 一覧  3: 終了
番号を選んでください:   1〜3で選んでください

1: 追加  2: 一覧  3: 終了
番号を選んでください: 終了します

最低1回は実行する形（do-while相当）

Pythonにはdo-while文がありません。「まず1回実行し、そのあとで続けるかを判定する」処理は、while True と末尾の break で書きます。

import random
random.seed(1)

# 「最低1回は実行し、そのあと条件を確認する」形（do-while 相当）
while True:
    dice = random.randint(1, 6)
    print("出た目:", dice)
    if dice == 6:
        break
print("6が出たので終了")

出た目: 2
出た目: 5
出た目: 1
出た目: 3
出た目: 1
出た目: 4
出た目: 4
出た目: 4
出た目: 6
6が出たので終了

無限ループの止め方

まずCtrl+Cを押す

ターミナルで実行中のPythonプログラムは、Ctrl+C で止められます。Ctrl+Cを押すとプログラムに割り込みの合図（SIGINT）が送られ、Pythonの中で KeyboardInterrupt という例外が発生します。何も対策をしていないプログラムは、次のような表示を出して終了します。

import time
while True:
    time.sleep(0.2)

Traceback (most recent call last):
  File "b08b.py", line 3, in <module>
    time.sleep(0.2)
    ~~~~~~~~~~^^^^^
KeyboardInterrupt

この出力は、Ctrl+Cと同じ合図（SIGINT）を1秒後にプログラムへ送って確認したものです。Tracebackは「どの行を実行中に止められたか」を示しているだけで、プログラムの不具合ではありません。

Tracebackで「どこを回っていたか」を調べる

止めたときのTracebackは、原因を探す手がかりになります。先ほどの「continueの前で更新を忘れた」プログラムに同じ合図を送ると、次の表示になりました。

Traceback (most recent call last):
  File "b04.py", line 4, in <module>
    continue        # n が 0 のまま、ここから先へ進まない
    ^^^^^^^^
KeyboardInterrupt

止められた瞬間に実行していたのが4行目の continue だとわかります。終わらないループを止めたら、まずTracebackの行番号を見ると、どの付近をくり返していたのかをすぐに絞り込めます。あわせて、ループの先頭に print(n) のような表示を一時的に入れ、条件に使う変数が変化しているかを確かめると原因が見つかりやすくなります。

環境ごとの止め方

この表の操作は一般に知られた手順をまとめたもので、今回の検証環境（Linuxのターミナル）ではSIGINTの送信のみ実行し、ほかの環境での操作は未実行です。

なお、LinuxやmacOSで Ctrl+Z を押すと、プログラムは終了せず一時停止（サスペンド）の状態で残ります。止めたいときはCtrl+Cを使い、Ctrl+Zを押してしまったときは fg で戻してからCtrl+Cを押します。

KeyboardInterruptを捕捉して後片付けをする

止められたときに「ここまでの結果を表示する」「ファイルを閉じる」といった処理をしたい場合は、try と except KeyboardInterrupt でループを囲みます。

import time

count = 0
try:
    while True:
        count += 1
        time.sleep(0.2)
except KeyboardInterrupt:
    print(f"\n中断されました。{count}回くり返しました")
finally:
    print("後片付け（ファイルを閉じる、接続を切るなど）")
print("プログラムを正常に終了します")

中断されました。5回くり返しました
後片付け（ファイルを閉じる、接続を切るなど）
プログラムを正常に終了します

（開始から1秒後にSIGINTを送って確認した結果です。）

try はループの外側に置くのがポイントです。ループの内側に置いて except の中で何もしないと、Ctrl+Cを押してもループが続き、止められないプログラムになります。同じ理由で、ループの中で except:（例外の種類を書かない形）を使うとKeyboardInterruptまで受け止めてしまうので、except Exception: のように種類を書いておくと安心です。

無限ループにならないための書き方

4つ目の例を確かめます。

x = 0.0
steps = 0
while x != 1.0:
    x += 0.1
    steps += 1
    if steps >= 12:                 # 確認用の上限
        print("12回足しても 1.0 とぴったり一致しない:", x)
        break

x = 0.0
steps = 0
while x < 1.0 - 1e-9:               # 大小比較にする
    x += 0.1
    steps += 1
print(steps, "回で終了")

i = 0
while i < 10:                       # 整数で数えるのが確実
    i += 1
print(i, "回で終了", i / 10)

12回足しても 1.0 とぴったり一致しない: 1.2
10 回で終了
10 回で終了 1.0

0.1を10回足しても、小数の誤差でぴったり1.0にはなりません。終了条件は != より < などの大小比較で書き、回数は整数で数えると確実に終わります。

時間の上限を付けて待つ

「準備ができるまで待つ。ただし最長2秒まで」のような処理は、締め切りの時刻を先に決めておきます。

import time

def is_ready():
    return time.monotonic() - start > 0.35   # 0.35秒後に準備完了になる想定

start = time.monotonic()
deadline = start + 2.0          # 最長2秒まで待つ
checks = 0
while time.monotonic() < deadline:
    checks += 1
    if is_ready():
        print(f"準備完了（{checks}回目の確認）")
        break
    time.sleep(0.1)
else:
    print("時間内に準備が終わりませんでした")

準備完了（5回目の確認）

time.sleep() を入れておくと、確認のたびに少し休むのでCPUを使い続けずに済みます。最後の else は次の節で説明します。

while-elseで「見つからなかった」を書く

while文には else を付けられます。elseのブロックは、条件がFalseになってループが終わったときに実行され、break で抜けたときは実行されません。

def find_first_multiple(numbers, base):
    i = 0
    while i < len(numbers):
        if numbers[i] % base == 0:
            print(f"{base}の倍数が見つかりました: {numbers[i]}")
            break
        i += 1
    else:
        # break されずに条件が False になったときだけ実行される
        print(f"{base}の倍数はありませんでした")

find_first_multiple([3, 8, 10, 7], 5)
find_first_multiple([3, 8, 11, 7], 5)

5の倍数が見つかりました: 10
5の倍数はありませんでした

Python公式ドキュメント（言語リファレンスの複合文、今回3.14.8版のページで確認）でも、「else節は式が偽になった場合に実行され、breakが実行されるとelse節を実行せずにループを終了する」と説明されています。elseを「breakしなかったら」と読み替えると覚えやすくなります。フラグ用の変数（found = False など）を用意しなくて済むのが利点です。

セイウチ演算子で読み込みと判定をまとめる

「値を取得する → その値で続けるか判定する」という処理は、取得のコードを2か所に書く形になりがちです。セイウチ演算子 :=（Python 3.8以降）を使うと、代入と条件判定を1行にまとめられます。

import io

# 直す前: 同じ読み込みを2か所に書く
f = io.StringIO("apple\nbanana\norange\n")
line = f.readline()
while line:
    print("A:", line.rstrip())
    line = f.readline()

# セイウチ演算子（:=）: 代入しながら条件判定（Python 3.8以降）
f = io.StringIO("apple\nbanana\norange\n")
while line := f.readline():
    print("B:", line.rstrip())

# 4文字ずつ読む
f = io.StringIO("ABCDEFGHIJ")
while (chunk := f.read(4)) != "":
    print("C:", chunk)

A: apple
A: banana
A: orange
B: apple
B: banana
B: orange
C: ABCD
C: EFGH
C: IJ

入力の受け付けにも使えます。

while (text := input("コマンド> ")) != "quit":
    print(f"  実行: {text}")
print("終了")

list、add、quit の順に入力した結果です。

コマンド>   実行: list
コマンド>   実行: add
コマンド> 終了

比較と組み合わせるときは、代入の部分をかっこで囲みます。 while text := input() != "quit": と書くと、text には比較の結果（TrueかFalse）が入ってしまいます。実際にかっこなしの形で hello と入力して text の中身を表示すると、入力した文字列ではなく True が表示されました。:= は比較演算子よりも後に評価されるためです。

空になるまでくり返す

空のリストはFalseと見なされるので、while リスト: で「空になるまで」を書けます。

from collections import deque

stack = ["a", "b", "c"]
while stack:                    # 空リストは False と見なされる
    print("pop:", stack.pop())

queue = deque(["注文1", "注文2"])
while queue:
    item = queue.popleft()
    print("処理:", item)
    if item == "注文1":
        queue.append("注文1の再確認")   # 処理中に追加してもよい

pop: c
pop: b
pop: a
処理: 注文1
処理: 注文2
処理: 注文1の再確認

処理の途中で対象が増えていく「待ち行列」は、whileが得意とする形です。先頭から取り出すときは、リストよりも collections.deque の popleft() が効率的です。

二重ループから抜ける

break が抜けるのは、いちばん内側のループ1つだけです。

# break は「いちばん内側のループ」だけを抜ける
y = 0
while y < 3:
    x = 0
    while x < 3:
        if x == 1:
            break
        print(f"(y={y}, x={x})")
        x += 1
    y += 1
print("--- 関数にして return で一度に抜ける")

def find(grid, target):
    y = 0
    while y < len(grid):
        x = 0
        while x < len(grid[y]):
            if grid[y][x] == target:
                return y, x
            x += 1
        y += 1
    return None

print(find([[1, 2], [3, 4], [5, 6]], 4))
print(find([[1, 2], [3, 4], [5, 6]], 9))

(y=0, x=0)
(y=1, x=0)
(y=2, x=0)
--- 関数にして return で一度に抜ける
(1, 1)
None

内側で break しても、外側のループは続いています。外側まで一度に抜けたいときは、ループを関数にまとめて return を使うのがいちばん簡潔です。

sys.exit("メッセージ") は、メッセージを表示してプログラム全体を終了します（終了コードは1）。

import sys
count = 0
while True:
    count += 1
    if count == 3:
        sys.exit("3回目で終了します")   # プログラム全体を終える

3回目で終了します

whileとforの使い分け

使い分けの判断表

「回数や対象が決まっているならfor、条件で終わるならwhile」が基本の考え方です。

同じ処理を両方で書いてみる

nums = [4, 9, 16]

i = 0
while i < len(nums):        # while: 添字を自分で管理する
    print(i, nums[i])
    i += 1

for i, n in enumerate(nums):   # for: 取り出しを任せる
    print(i, n)

0 4
1 9
2 16
0 4
1 9
2 16

リストを順に処理するだけなら、forのほうが短く、更新の書き忘れも起きません。

速度を計ってみる

0から999,999までの合計を、while・for・組み込み関数 sum() の3通りで計算し、5回のうち最も短かった時間を比べました。

import timeit

def by_while(n):
    total = 0
    i = 0
    while i < n:
        total += i
        i += 1
    return total

def by_for(n):
    total = 0
    for i in range(n):
        total += i
    return total

N = 1_000_000
print(by_while(N) == by_for(N) == sum(range(N)))
for name, fn in [("while", lambda: by_while(N)), ("for + range", lambda: by_for(N)), ("sum(range)", lambda: sum(range(N)))]:
    t = min(timeit.repeat(fn, number=1, repeat=5))
    print(f"{name:<12} {t * 1000:7.1f} ms")

True
while           37.2 ms
for + range     27.2 ms
sum(range)       8.7 ms

この環境（Python 3.14.7、Linux）では、forがwhileより3割ほど短い時間で終わりました。whileは条件の比較と i += 1 をPythonのコードとして毎回実行するためです。数値は環境によって変わりますが、決まった回数のくり返しはfor、合計のように用意された関数があるものは関数を使う、という選び方の裏付けになります。

while文を書いたあとのチェックリスト

よくある質問

Q. while True: と while 1: はちがいますか？ A. 動きは同じです。1 はTrueと見なされるので、どちらも無限ループになります。読んだときに意図が伝わりやすい while True: が広く使われています。

Q. 無限ループに入ってしまいました。どう止めればよいですか？ A. ターミナルならCtrl+C、Jupyterならツールバーの ■ ボタンで止められます。止めたあとは、条件に使っている変数がブロックの中で更新されているか、更新が continue より前にあるかを確認します。

Q. breakとcontinueのちがいは何ですか？ A. break はループそのものを終わらせ、ループの次の行へ進みます。continue はその回の残りだけを飛ばし、条件判定に戻ってループを続けます。

Q. while-elseのelseはいつ実行されますか？ A. 条件がFalseになってループが終わったときに実行されます。break で抜けたときは実行されません。「探して見つからなかったとき」の処理を書くのに向いています。

まとめ

• while文は「条件がTrueのあいだくり返す」。初期化・条件式・更新の3つをそろえる
• breakはループを抜け、continueはその回の残りを飛ばす。更新は必ずcontinueより前に書く
• while True + break は、入力の再要求・リトライ・メニューの定番形。回数や時間の上限を付けると出口が保証される
• 無限ループはCtrl+Cで止める。except KeyboardInterrupt と finally で後片付けができる
• while-elseのelseは「breakしなかったとき」に実行される。フラグ変数なしで「見つからなかった」を書ける
• セイウチ演算子 := は、取得と判定を1行にまとめる。比較と組み合わせるときはかっこで囲む
• 回数や対象が決まっているならfor、条件で終わるならwhileを選ぶ

株式会社RJCでは、Pythonのwhile文とループ処理の書き方を仲間と学び合っています。こうした知識を共有しながら、日々技術を磨いています。

株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。