Python for文の基本から応用まで完全攻略ガイド

この記事では、Python初心者がfor文を基礎から応用まで体系的に学習できます。リスト、タプル、辞書、セットなど各データ型での繰り返し処理、range関数の活用法、break・continueによる制御、reversed・zip・enumerate関数の使い方まで、豊富なサンプルコードで実践的に解説。繰り返し処理の書き方で悩む初心者から、より効率的なコードを書きたい方まで、Pythonプログラミングの基礎スキルが身につきます。

Pythonのfor文とは何か

プログラミングにおいて、同じ処理を繰り返し実行することは非常に重要な機能です。Pythonのfor文は、このような反復処理を効率的に実現するための制御構文の一つです。for文を理解することで、より簡潔で読みやすいコードを書くことができるようになります。

for文の基本概念と役割

Pythonのfor文は、指定された回数だけ処理を繰り返したり、リストやタプルなどのシーケンスオブジェクトの要素を順番に処理したりするための構文です。for文の基本的な役割は、手動で同じコードを何度も書く必要をなくし、プログラムの効率性と可読性を向上させることにあります。

for文の基本的な構文は以下のようになります：

for 変数 in シーケンス:
    処理内容

この構文において、「変数」にはシーケンスの各要素が順番に代入され、「処理内容」が繰り返し実行されます。シーケンスとは、リスト、タプル、文字列、辞書、セットなどのイテラブルオブジェクトを指します。

実際の使用例を見てみましょう：

# リストの要素を順番に処理
fruits = ['apple', 'banana', 'orange']
for fruit in fruits:
    print(f"好きな果物は{fruit}です")

# 数値の範囲を指定して処理
for i in range(5):
    print(f"カウント: {i}")

for文の主な役割は以下の通りです：

• データの一括処理：大量のデータを効率的に処理
• コードの簡素化：重複するコードを削減
• 自動化の実現：手動作業を自動化
• エラーの削減：手動でのコピー&ペーストによるミスを防止

Pythonにおけるfor文の特徴

Pythonのfor文は、他のプログラミング言語と比較して独特な特徴を持っています。これらの特徴により、Pythonのfor文は非常に柔軟で使いやすいものとなっています。

まず、Pythonのfor文はイテレータベースの設計になっている点が大きな特徴です。これは、for文がオブジェクトの`__iter__()`メソッドを呼び出して反復処理を行うことを意味します。この仕組みにより、リストやタプルだけでなく、文字列、辞書、セット、さらにはカスタムオブジェクトまで、様々なデータ型をfor文で処理できます。

# 文字列の各文字を処理
text = "Python"
for char in text:
    print(char)

# 辞書のキーと値を処理
person = {'name': '田中', 'age': 30, 'city': '東京'}
for key, value in person.items():
    print(f"{key}: {value}")

第二の特徴は、enumerate()関数との組み合わせです。enumerate()を使用することで、要素とそのインデックスを同時に取得できます：

languages = ['Python', 'Java', 'JavaScript']
for index, language in enumerate(languages):
    print(f"{index + 1}番目の言語: {language}")

第三の特徴として、zip()関数による複数のシーケンスの同時処理があります：

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(f"{name}は{age}歳です")

また、Pythonのfor文はelse節をサポートしている点も特徴的です。else節は、for文が正常に完了した場合（break文で中断されなかった場合）に実行されます：

numbers = [2, 4, 6, 8]
for num in numbers:
    if num % 2 != 0:
        print("奇数が見つかりました")
        break
else:
    print("すべて偶数でした")

さらに、Pythonではリスト内包表記という機能により、for文をより簡潔に記述することも可能です：

# 通常のfor文
squares = []
for i in range(10):
    squares.append(i ** 2)

# リスト内包表記
squares = [i ** 2 for i in range(10)]

これらの特徴により、Pythonのfor文は他の言語と比較して、より直感的で読みやすく、かつ強力な機能を提供しています。

Pythonのfor文の基本的な書き方

Pythonのfor文は、繰り返し処理を行うための重要な制御構造です。リストやタプル、文字列などの反復可能なオブジェクトに対して、要素を一つずつ取り出しながら処理を実行できます。他のプログラミング言語と比較して、Pythonのfor文は直感的で読みやすい構文を持っており、初心者でも理解しやすい特徴があります。

for文の構文とルール

Pythonのfor文は、シンプルで覚えやすい構文を採用しています。基本的な書き方は「for 変数名 in 反復可能オブジェクト:」という形式で、コロン（:）の後にインデントを使って実行したい処理を記述します。

for文を記述する際の重要なルールとして、以下の点を押さえておく必要があります：

• インデントは必須で、通常4つのスペースまたは1つのタブを使用
• 反復変数名は任意の名前を設定可能だが、意味のある名前を選ぶことが推奨
• 処理ブロックの終了は、インデントレベルを元に戻すことで示される
• 反復可能オブジェクトには、リスト、タプル、文字列、辞書、セットなどが使用可能

また、for文では「range()」関数を使用することで、指定した回数だけ繰り返し処理を実行することも可能です。range()関数は整数のシーケンスを生成し、開始値、終了値、ステップ数を指定できる柔軟性を持っています。

実際のサンプルコードで学ぶ基本構造

理論だけでなく、実際のコードを通してPythonのfor文の動作を理解することが重要です。以下に、様々なパターンのfor文サンプルコードを示し、それぞれの特徴と使用場面を解説します。

最も基本的なリストの繰り返し処理：

fruits = ['apple', 'banana', 'orange']
for fruit in fruits:
    print(f"好きな果物は{fruit}です")

このコードでは、fruitsリストの各要素を順番に取り出し、fruit変数に代入しながら処理を実行しています。出力結果として、リストの要素数分だけprint文が実行されます。

range()関数を使用した数値の繰り返し：

for i in range(5):
    print(f"カウント: {i}")

for num in range(1, 11, 2):
    print(f"奇数: {num}")

最初の例では0から4までの数値を順番に処理し、2番目の例では1から10まで2つずつ増加する奇数を出力します。range()関数の引数によって、開始値、終了値、増分を制御できる点が特徴的です。

文字列の各文字に対する繰り返し処理：

message = "Python"
for char in message:
    print(f"文字: {char}")

Pythonでは文字列も反復可能オブジェクトとして扱われるため、for文を使って各文字に順次アクセスできます。この機能は文字列解析や文字単位の処理において非常に有用です。

辞書の繰り返し処理：

student_scores = {'田中': 85, '佐藤': 92, '鈴木': 78}

# キーのみの繰り返し
for name in student_scores:
    print(f"生徒名: {name}")

# キーと値の両方を取得
for name, score in student_scores.items():
    print(f"{name}さんの点数は{score}点です")

辞書に対するfor文では、デフォルトでキーが取得されますが、items()メソッドを使用することでキーと値の両方を同時に取得できます。この方法により、辞書の全要素に対して効率的な処理が可能になります。

データ型別のfor文活用方法

Pythonにおいてfor文は様々なデータ型に対して柔軟に使用できる強力な繰り返し処理です。リスト、タプル、辞書、セットといった主要なデータ型それぞれに最適化されたfor文の書き方を理解することで、効率的で読みやすいコードを書くことができます。各データ型の特性を活かしたfor文の活用方法を詳しく解説していきます。

リストを使った繰り返し処理

リストはPythonで最も頻繁に使用されるデータ型の一つで、for文との相性が非常に良い構造です。リストの要素を順番に取り出して処理する基本的な方法から、インデックスを同時に取得する応用的な方法まで、様々な書き方があります。

最も基本的なリストのfor文は以下のような形になります：

fruits = ['apple', 'banana', 'orange']
for fruit in fruits:
    print(fruit)

インデックスも同時に必要な場合は、enumerate()関数を使用することで効率的に処理できます：

fruits = ['apple', 'banana', 'orange']
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

リスト内包表記と組み合わせることで、より簡潔なコードを書くことも可能です。条件付きの処理や変換処理において、従来のfor文よりも高速で読みやすいコードを実現できます。

タプルを使った繰り返し処理

タプルは不変（immutable）なデータ型で、リストと同様にfor文で繰り返し処理が可能です。タプルの不変性により、処理中にデータが変更される心配がないため、安全な繰り返し処理を実現できます。

単純なタプルの繰り返し処理は以下のように書けます：

coordinates = (10, 20, 30)
for coordinate in coordinates:
    print(coordinate)

タプルのリストを扱う場合、アンパッキング（展開）を利用することで、各要素を個別の変数に代入できます：

points = [(1, 2), (3, 4), (5, 6)]
for x, y in points:
    print(f"x: {x}, y: {y}")

この方法は座標データや組み合わせデータを扱う際に特に有効で、コードの可読性を大幅に向上させることができます。関数から複数の値を返す際にタプルを使用し、for文でそれらを効率的に処理する パターンは実務でよく使われます。

辞書を使った繰り返し処理

辞書（dict）は키と値のペアで構成されるデータ型で、for文では키、値、またはその両方を取得する複数の方法があります。辞書の構造を理解し、適切なメソッドを選択することで、効率的なデータ処理が可能になります。

키のみを取得する場合は、最もシンプルな書き方ができます：

student_scores = {'Alice': 85, 'Bob': 92, 'Charlie': 78}
for name in student_scores:
    print(name)

値のみが必要な場合は、values()メソッドを使用します：

for score in student_scores.values():
    print(score)

키と値の両方が必要な場合は、items()メソッドを使用することで効率的に処理できます：

for name, score in student_scores.items():
    print(f"{name}: {score}")

辞書のfor文では、処理の目的に応じて適切なメソッドを選択することが重要です。データの検索、集計、変換などの処理において、これらの方法を使い分けることで、パフォーマンスの向上とコードの簡潔性を両立できます。

セットを使った繰り返し処理

セット（set）は重複のない要素の集合を表すデータ型で、for文による繰り返し処理では順序が保証されない特徴があります。重複除去や集合演算の結果を処理する際に、セットのfor文は非常に有効です。

基本的なセットの繰り返し処理は以下のように記述します：

unique_numbers = {1, 2, 3, 4, 5}
for number in unique_numbers:
    print(number)

セットは重複を自動的に除去するため、リストから重複を取り除いた処理を行う際に特に効果的です：

numbers_with_duplicates = [1, 2, 2, 3, 3, 4, 5]
unique_numbers = set(numbers_with_duplicates)
for number in unique_numbers:
    print(number)

複数のセット間で集合演算を行い、その結果をfor文で処理することも可能です。和集合、積集合、差集合などの演算結果を効率的に処理できるため、データ分析や条件に基づく フィルタリング処理において威力を発揮します。

range関数を活用したfor文の応用

Pythonのfor文をより効果的に使うためには、range関数の活用が欠かせません。range関数を組み合わせることで、単純な繰り返し処理から高度な数値制御まで、幅広い処理を実現できます。この章では、range関数とfor文の組み合わせによる実践的な活用方法を詳しく解説していきます。

range関数の基本的な使い方

range関数は、Python for文で最も頻繁に使用される組み込み関数の一つです。基本的な構文は非常にシンプルで、指定した回数だけ繰り返し処理を実行する際に使用します。

最もシンプルなrange関数の使い方は、引数を一つだけ指定する方法です：

for i in range(5):
    print(f"繰り返し回数: {i}")

この例では、0から4まで（合計5回）の繰り返し処理が実行されます。注意すべき点は、range関数は0から開始し、指定した数値の1つ前で終了することです。

実際のプログラミングでは、以下のような場面でrange関数の基本形が活用されます：

• リストの要素数分だけ処理を繰り返したい場合
• 特定の回数だけ計算処理を実行したい場合
• カウンターを使った制御処理を行いたい場合
• 初期化処理やテストデータの生成時

また、range関数をlist()と組み合わせることで、数値のリストを簡単に生成することも可能です：

numbers = list(range(10))
print(numbers)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

範囲指定による繰り返し処理

range関数に2つの引数を指定することで、開始値と終了値を明示的に設定できます。この機能により、Python for文でより柔軟な範囲指定による繰り返し処理が可能になります。

基本的な構文は以下のようになります：

for i in range(開始値, 終了値):
    # 処理内容

具体的な例を見てみましょう：

for i in range(3, 8):
    print(f"現在の値: {i}")
# 出力: 3, 4, 5, 6, 7

この範囲指定機能は、様々な実用的な場面で活用できます。例えば、配列の特定の部分だけを処理したい場合や、特定の範囲内での計算処理を行いたい場合に非常に有効です：

# リストの一部分を処理する例
data_list = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
for i in range(2, 7):
    data_list[i] = data_list[i] * 2
    print(f"インデックス{i}: {data_list[i]}")

範囲指定による繰り返し処理の主要な活用場面は以下の通りです：

1. 配列やリストの特定範囲を処理する場合
2. 数学的な計算で特定の数値範囲を扱う場合
3. ページネーション処理での範囲指定
4. グラフや表の特定範囲データの処理

さらに、負の数値を使用することで、負の範囲での処理も可能です：

for i in range(-3, 2):
    print(f"負の範囲を含む値: {i}")
# 出力: -3, -2, -1, 0, 1

増加量を指定した繰り返し処理

range関数の最も高度な使い方として、3つ目の引数に増加量（ステップ）を指定する方法があります。この機能により、Python for文で等間隔での値の変化や逆順処理など、より複雑な繰り返しパターンを実現できます。

基本的な構文は以下のようになります：

for i in range(開始値, 終了値, 増加量):
    # 処理内容

正の増加量を指定した例を見てみましょう：

for i in range(0, 20, 3):
    print(f"3ずつ増加: {i}")
# 出力: 0, 3, 6, 9, 12, 15, 18

特に実用的なのが、負の増加量を使用した逆順処理です。これにより、大きい値から小さい値へ向かって処理を進めることができます：

for i in range(10, 0, -1):
    print(f"カウントダウン: {i}")
# 出力: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

増加量を指定した繰り返し処理の実践的な活用例を以下の表にまとめました：

実際のプログラムでは、以下のような場面で増加量指定が威力を発揮します：

• 配列の偶数インデックスまたは奇数インデックスのみを処理したい場合
• グラフのプロットで等間隔の点を設定したい場合
• パフォーマンステストで段階的に負荷を増加させたい場合
• データの間引き処理を行いたい場合

また、増加量に0を指定することはできない点に注意が必要です。0を指定すると無限ループとなってしまうため、Pythonはエラーを発生させます。

# 実用例: リストを逆順で処理
my_list = ['A', 'B', 'C', 'D', 'E']
for i in range(len(my_list)-1, -1, -1):
    print(f"逆順インデックス{i}: {my_list[i]}")
# 出力: E, D, C, B, A

for文で使える制御文の活用法

Pythonのfor文は単純な繰り返し処理だけでなく、制御文を組み合わせることで柔軟で効率的なプログラムを作成できます。制御文を適切に使用することで、条件に応じて処理を終了したり、特定の処理をスキップしたり、繰り返し完了後に特別な処理を実行したりすることが可能になります。

Python for文で使用できる主要な制御文には、break、continue、elseがあります。これらの制御文を理解し活用することで、より読みやすく効率的なコードを書くことができるようになります。

breakを使った途中終了の実装

break文は、Python for文の実行を条件に応じて途中で終了させる際に使用します。特定の条件が満たされた時点で繰り返し処理を中断したい場合に非常に有効です。

break文の基本的な使い方は以下の通りです：

for i in range(10):
    if i == 5:
        break
    print(i)
# 出力: 0, 1, 2, 3, 4

実用的な例として、リスト内で特定の値を検索する処理を考えてみましょう：

numbers = [1, 3, 7, 2, 9, 5, 8]
target = 9

for i, num in enumerate(numbers):
    if num == target:
        print(f"値{target}はインデックス{i}で見つかりました")
        break
else:
    print(f"値{target}は見つかりませんでした")

break文を使用することで、目的の値が見つかった時点で無駄な検索処理を停止できます。これにより処理効率が向上し、大量のデータを扱う際に特に有効です。

continueを使った処理スキップ

continue文は、Python for文の現在の反復をスキップして次の反復に進む際に使用します。特定の条件下で処理を飛ばしたい場合に重宝する制御文です。

continue文の基本的な動作例：

for i in range(10):
    if i % 2 == 0:
        continue
    print(i)
# 出力: 1, 3, 5, 7, 9

実際の開発現場でよく使用される例として、データの前処理における無効値のスキップがあります：

data_list = ["apple", "", "banana", None, "cherry", ""]
processed_data = []

for item in data_list:
    if not item:  # 空文字列やNoneをスキップ
        continue
    if len(item)  3:  # 3文字未満をスキップ
        continue
    processed_data.append(item.upper())

print(processed_data)  # ['APPLE', 'BANANA', 'CHERRY']

continue文を活用することで、ネストした条件分岐を避けてコードの可読性を向上させることができます。エラーハンドリングやデータフィルタリングの場面で特に効果を発揮します。

elseを使った繰り返し完了後の処理

Python for文におけるelse節は、他のプログラミング言語にはあまり見られない独特な機能です。for文が正常に完了した場合（break文で中断されなかった場合）にのみ実行される処理を定義できます。

for-else文の基本構文と動作：

for i in range(5):
    print(i)
else:
    print("繰り返し処理が正常に完了しました")
# 出力: 0, 1, 2, 3, 4, 繰り返し処理が正常に完了しました

break文で中断された場合、else節は実行されません：

for i in range(5):
    if i == 3:
        break
    print(i)
else:
    print("この文は実行されません")
# 出力: 0, 1, 2

実用的な活用例として、リスト内の素数判定処理があります：

def is_prime(n):
    if n  2:
        return False
    
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    else:
        return True

numbers = [17, 18, 19, 20]
for num in numbers:
    if is_prime(num):
        print(f"{num}は素数です")
    else:
        print(f"{num}は素数ではありません")

else節を適切に使用することで、検索処理の成功・失敗や、バリデーション処理の完了状態を明確に表現できます。これにより、フラグ変数を使用する必要がなくなり、よりPythonらしい簡潔なコードを書くことが可能になります。

for文の高度な応用テクニック

Pythonのfor文は基本的な反復処理以外にも、様々な組み込み関数と組み合わせることで高度な処理を実現できます。これらのテクニックを習得することで、より効率的で読みやすいコードを書くことができるようになります。

reversedを使った逆順取得

Pythonのreversed関数をfor文と組み合わせることで、リストやタプルなどのシーケンスを逆順で処理することができます。この機能は元のデータを変更することなく、逆順での反復処理を実現する便利な方法です。

reversed関数の基本的な使用方法は以下の通りです：

fruits = ['apple', 'banana', 'cherry', 'date']
for fruit in reversed(fruits):
    print(fruit)
# 出力: date, cherry, banana, apple

reversed関数は文字列に対しても使用することができ、一文字ずつ逆順で処理することが可能です：

text = "Python"
for char in reversed(text):
    print(char, end="")
# 出力: nohtyP

数値の範囲を逆順で処理したい場合は、range関数と組み合わせて使用します：

for i in reversed(range(1, 6)):
    print(i)
# 出力: 5, 4, 3, 2, 1

zip関数を使った複数リストの同時処理

zip関数をfor文と組み合わせることで、複数のリストやタプルを同時に処理することができます。この機能により、関連するデータを効率的に扱うことが可能になり、コードの可読性も向上します。

基本的なzip関数の使用例を以下に示します：

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
cities = ['Tokyo', 'Osaka', 'Kyoto']

for name, age, city in zip(names, ages, cities):
    print(f"{name}は{age}歳で{city}に住んでいます")
# 出力: Aliceは25歳でTokyoに住んでいます
#       Bobは30歳でOsakaに住んでいます
#       Charlieは35歳でKyotoに住んでいます

zip関数は最も短いシーケンスの長さに合わせて処理を行います。長さが異なるリストを扱う際は注意が必要です：

list1 = [1, 2, 3, 4, 5]
list2 = ['a', 'b', 'c']

for num, letter in zip(list1, list2):
    print(f"{num}: {letter}")
# 出力: 1: a, 2: b, 3: c（4と5は処理されない）

辞書の作成にもzip関数は非常に有用です：

keys = ['name', 'age', 'occupation']
values = ['田中太郎', 28, 'エンジニア']
person_dict = dict(zip(keys, values))
print(person_dict)
# 出力: {'name': '田中太郎', 'age': 28, 'occupation': 'エンジニア'}

enumerate関数を使ったインデックス付き処理

enumerate関数をfor文と組み合わせることで、リストの要素とそのインデックスを同時に取得することができます。これにより、従来のrange(len())を使用した方法よりも、よりPythonらしい美しいコードを書くことが可能になります。

enumerate関数の基本的な使用方法は以下の通りです：

languages = ['Python', 'Java', 'JavaScript', 'C++']
for index, language in enumerate(languages):
    print(f"{index}: {language}")
# 出力: 0: Python, 1: Java, 2: JavaScript, 3: C++

enumerate関数では開始インデックスを指定することも可能です：

subjects = ['数学', '英語', '国語', '理科']
for num, subject in enumerate(subjects, start=1):
    print(f"第{num}科目: {subject}")
# 出力: 第1科目: 数学, 第2科目: 英語, 第3科目: 国語, 第4科目: 理科

条件分岐と組み合わせて、特定の位置の要素のみを処理することも可能です：

numbers = [10, 25, 30, 45, 50]
for i, num in enumerate(numbers):
    if i % 2 == 0:  # 偶数インデックスのみ
        print(f"偶数位置({i}): {num}")
# 出力: 偶数位置(0): 10, 偶数位置(2): 30, 偶数位置(4): 50

スライスを使った部分要素の抽出

Pythonのスライス機能をfor文と組み合わせることで、リストやタプルの特定の部分のみを効率的に処理することができます。この手法により、メモリ効率を向上させながら、必要な範囲のデータのみを対象とした処理が可能になります。

基本的なスライスを使った部分要素の処理例を以下に示します：

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

# 最初の5個の要素を処理
for item in data[:5]:
    print(f"前半: {item}")

# 後半の5個の要素を処理
for item in data[5:]:
    print(f"後半: {item}")

# 中間の要素を処理
for item in data[3:7]:
    print(f"中間: {item}")

ステップを指定したスライスにより、一定間隔で要素を処理することも可能です：

numbers = list(range(20))

# 偶数インデックスの要素のみ処理
for num in numbers[::2]:
    print(f"偶数インデックス: {num}")

# 奇数インデックスの要素のみ処理
for num in numbers[1::2]:
    print(f"奇数インデックス: {num}")

# 逆順で2つおきに処理
for num in numbers[::-2]:
    print(f"逆順2つおき: {num}")

文字列に対してもスライスを適用することで、部分文字列を効率的に処理できます：

text = "PythonProgramming"

# 最初の6文字を処理
for char in text[:6]:
    print(f"Python部分: {char}")

# 7文字目以降を処理
for char in text[6:]:
    print(f"Programming部分: {char}")

# 2文字おきに処理
for char in text[::2]:
    print(f"2文字おき: {char}")

スライスとenumerate関数を組み合わせることで、より柔軟で強力な処理を実現することができます：

scores = [85, 92, 78, 96, 88, 91, 83, 89]

# 上位5位までのスコアとその順位を表示
for rank, score in enumerate(sorted(scores, reverse=True)[:5], start=1):
    print(f"第{rank}位: {score}点")

多重ループとfor文の応用パターン

Pythonにおいてfor文を使った多重ループは、二次元配列の処理や複雑なデータ構造の操作において欠かせない技術です。単純なループとは異なり、ループの中にさらにループを配置することで、より高度なデータ処理を実現できます。多重ループを効果的に活用することで、プログラムの処理能力を大幅に向上させることが可能になります。

多重ループの基本的な考え方は、外側のループが1回実行される間に、内側のループが完全に実行されるという仕組みです。この特性を理解することで、二次元リストの要素アクセスや、組み合わせ処理、パターンマッチングなど様々な場面で応用できるようになります。

ネストしたfor文の書き方

ネストしたfor文の基本構文は、外側のループの処理ブロック内に内側のループを記述する形になります。最も基本的な二重ループの構文を以下に示します。

for i in range(外側の範囲):
    for j in range(内側の範囲):
        # 処理内容
        print(f"外側: {i}, 内側: {j}")

実際の活用例として、二次元リストの全要素を処理する場合を見てみましょう。

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

for i in range(len(matrix)):
    for j in range(len(matrix[i])):
        print(f"matrix[{i}][{j}] = {matrix[i][j]}")

より実践的な例として、九九の計算表を作成するプログラムを示します。

print("九九の表")
for i in range(1, 10):
    for j in range(1, 10):
        result = i * j
        print(f"{result:2d}", end=" ")
    print()  # 改行

三重ループを使用する場合は、さらに処理が複雑になりますが、三次元データの処理や複数の条件を組み合わせた検索処理に活用できます。

for x in range(3):
    for y in range(3):
        for z in range(3):
            coordinate = (x, y, z)
            print(f"座標: {coordinate}")

多重ループでのcontinue活用法

多重ループにおいてcontinue文を適切に使用することで、特定の条件下で処理をスキップし、効率的なプログラムを作成できます。continue文は、その文が配置されているループの現在の反復を終了し、次の反復に進む制御文です。

基本的なcontinue文の動作を確認してみましょう。以下の例では、偶数の場合のみ処理をスキップします。

for i in range(1, 4):
    for j in range(1, 4):
        if j % 2 == 0:
            continue  # 内側ループの次の反復へ
        print(f"i={i}, j={j}")

実用的な例として、二次元配列から特定の条件に合致しない要素をスキップする処理を示します。

data = [[1, 2, 3], [4, 0, 6], [7, 8, 9]]

print("0以外の要素のみ処理:")
for i in range(len(data)):
    for j in range(len(data[i])):
        if data[i][j] == 0:
            continue  # 0の場合はスキップ
        print(f"処理対象: data[{i}][{j}] = {data[i][j]}")

より複雑な条件分岐を含むcontinue文の活用例も見てみましょう。以下は、対角線上の要素を除いて処理する例です。

matrix_size = 4

print("対角線以外の要素:")
for i in range(matrix_size):
    for j in range(matrix_size):
        if i == j:  # 主対角線
            continue
        if i + j == matrix_size - 1:  # 副対角線
            continue
        print(f"位置({i}, {j})を処理")

注意すべき点として、continue文は最も内側のループにのみ影響することを覚えておきましょう。外側のループに影響を与えたい場合は、フラグ変数を使用するか、関数として分離してreturn文を使用する方法があります。

# フラグを使用した外側ループの制御例
for i in range(3):
    skip_outer = False
    for j in range(3):
        if i == 1 and j == 1:
            skip_outer = True
            break
        print(f"i={i}, j={j}")
    if skip_outer:
        continue
    print(f"外側ループ {i} 完了")

for文を使いこなすためのまとめ

Python for文は、プログラミングにおいて繰り返し処理を効率的に実行するための重要な構文です。初心者から上級者まで、様々な場面でfor文を活用することで、コードの可読性と実行効率を大幅に向上させることができます。ここでは、Python for文を使いこなすために押さえておきたい重要なポイントを総合的にまとめます。

基本的なfor文の構文と書き方

Python for文の基本構文は、他のプログラミング言語と比較してシンプルで直感的です。最も基本的な形は以下のようになります。

for 変数 in イテラブルオブジェクト:
    実行する処理

この構文では、イテラブルオブジェクト（リスト、タプル、文字列など）の各要素に対して順番に処理を実行します。例えば、リストの各要素を出力する場合は以下のように記述します。

fruits = ['apple', 'banana', 'orange']
for fruit in fruits:
    print(fruit)

Python for文の特徴は、C言語やJavaのようなカウンタ変数を明示的に管理する必要がない点にあります。これにより、コードがより読みやすく、エラーが発生しにくくなります。

range()関数を活用した数値の反復処理

数値の範囲を指定して繰り返し処理を行う場合、range()関数とfor文を組み合わせて使用します。range()関数は非常に柔軟で、様々なパターンの数値シーケンスを生成できます。

基本的なrange()の使用方法には以下の3つのパターンがあります。

• range(stop): 0からstop-1まで
• range(start, stop): startからstop-1まで
• range(start, stop, step): startからstop-1まで、step刻み

# 0から4まで
for i in range(5):
    print(i)

# 1から10まで
for i in range(1, 11):
    print(i)

# 0から10まで2刻み
for i in range(0, 11, 2):
    print(i)

range()関数は実際にはジェネレータオブジェクトを返すため、メモリ効率が良く、大きな数値範囲でも安全に使用できます。

enumerate()とzip()による高度な反復処理

Python for文をより効果的に活用するために、enumerate()とzip()関数の使い方をマスターすることが重要です。これらの関数を使用することで、複雑な反復処理も簡潔に記述できます。

enumerate()関数は、イテラブルオブジェクトの各要素にインデックス番号を付けて返します。リストの要素とその位置情報を同時に取得したい場合に非常に便利です。

languages = ['Python', 'Java', 'JavaScript']
for index, language in enumerate(languages):
    print(f"{index}: {language}")

# 開始インデックスを指定することも可能
for index, language in enumerate(languages, start=1):
    print(f"{index}. {language}")

zip()関数は、複数のイテラブルオブジェクトを並行して処理する際に使用します。同じ長さの複数のリストを同時に処理したい場合に特に有効です。

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
cities = ['Tokyo', 'Osaka', 'Kyoto']

for name, age, city in zip(names, ages, cities):
    print(f"{name} is {age} years old and lives in {city}")

リスト内包表記によるコンパクトなコード記述

Python for文の応用として、リスト内包表記（List Comprehension）は非常に強力な機能です。従来のfor文よりも簡潔で読みやすいコードを書くことができ、実行速度も向上する場合が多くあります。

基本的なリスト内包表記の構文は以下の通りです。

[式 for 変数 in イテラブル]

条件分岐を含める場合は、以下のように記述します。

[式 for 変数 in イテラブル if 条件]

具体的な使用例を見てみましょう。

# 通常のfor文
squares = []
for x in range(1, 11):
    squares.append(x ** 2)

# リスト内包表記
squares = [x ** 2 for x in range(1, 11)]

# 条件付きリスト内包表記
even_squares = [x ** 2 for x in range(1, 11) if x % 2 == 0]

リスト内包表記は、辞書内包表記やセット内包表記にも応用でき、Pythonらしい効率的なコードを書くための重要なテクニックです。

ネストしたfor文とbreak、continue文の活用

複雑なデータ構造を扱う際には、for文をネストして使用することがあります。また、特定の条件でループを制御するbreak文とcontinue文の適切な使用方法を理解することも重要です。

ネストしたfor文は、2次元リストの処理や複数の組み合わせを生成する際に使用します。

# 2次元リストの処理
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for row in matrix:
    for element in row:
        print(element, end=' ')
    print()  # 改行

# 組み合わせの生成
for i in range(1, 4):
    for j in range(1, 4):
        print(f"({i}, {j})", end=' ')
    print()

break文は現在のループを完全に終了し、continue文は現在の反復をスキップして次の反復に進みます。

# break文の使用例
for i in range(1, 11):
    if i == 5:
        break
    print(i)  # 1, 2, 3, 4が出力される

# continue文の使用例
for i in range(1, 11):
    if i % 2 == 0:
        continue
    print(i)  # 奇数のみが出力される

ネストが深くなりすぎると可読性が低下するため、適切な関数分割や他のアプローチを検討することも重要です。

エラーハンドリングとパフォーマンス最適化

実際のプロジェクトでPython for文を使用する際は、エラーハンドリングとパフォーマンスの観点も考慮する必要があります。適切な例外処理とパフォーマンス最適化により、堅牢で効率的なコードを作成できます。

for文内での例外処理では、try-except文を適切に配置することが重要です。

numbers = ['1', '2', 'abc', '4', '5']
valid_numbers = []

for num in numbers:
    try:
        converted = int(num)
        valid_numbers.append(converted)
    except ValueError:
        print(f"'{num}' is not a valid number")
        continue

パフォーマンス最適化の観点では、以下の点に注意する必要があります。

適切なデータ構造の選択と組み合わせることで、Python for文のパフォーマンスを最大限に引き出すことができます。