【2025年最新】Python for文の使い方完全マスター：基礎から上級テクニックまで徹底解説
Python for文は、繰り返し処理を行うための最も重要な制御構文の一つです。初心者から上級者まで、日常的に使用するfor文について、基礎から応用まで網羅的に解説します。
この記事を読むことで、Python for文のすべてを理解し、効率的で Pythonic なコードが書けるようになります。
目次
- Python for文の基礎知識
- 基本的なfor文の書き方
- range関数の完全活用
- リスト・タプル・辞書の反復処理
- enumerate関数でインデックス取得
- zip関数で複数リストを同時処理
- ネストしたfor文（二重ループ）
- for文とelse文の組み合わせ
- 内包表記（リスト・辞書・集合）
- itertools モジュールの活用
- ジェネレータとイテレータ
- パフォーマンス最適化テクニック
- 実践的な応用例
- よくある間違いと対処法
Python for文の基礎知識 {#基礎知識}
for文は、イテラブル（反復可能）なオブジェクトの各要素に対して、同じ処理を繰り返し実行する制御構文です。
for文の基本構文
for 変数 in イテラブルオブジェクト:
実行したい処理
重要なポイント：
- イテラブルオブジェクトの後には必ずコロン（:）を付ける
- 実行したい処理は4つの半角スペース（またはタブ）でインデントする
- Pythonの for文は「for-each」スタイル
基本的なfor文の書き方 {#基本的な書き方}
リストの要素を順番に処理
# 文字列のリスト
fruits = ["りんご", "バナナ", "オレンジ"]
for fruit in fruits:
print(f"好きな果物は{fruit}です")
# 数値のリスト
numbers = [1, 2, 3, 4, 5]
total = 0
for num in numbers:
total += num
print(f"合計: {total}")
文字列の文字を一つずつ処理
word = "Python"
for char in word:
print(f"文字: {char}")
# 文字列の処理例
text = "Hello World"
vowels = "aeiouAEIOU"
vowel_count = 0
for char in text:
if char in vowels:
vowel_count += 1
print(f"母音の数: {vowel_count}")
辞書の反復処理
# キーのみを取得
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 score in student_scores.values():
print(f"点数: {score}")
range関数の完全活用 {#range関数}
range関数は、連続した整数を生成するために使用される最も重要な関数の一つです。
range関数の基本形
# range(stop) - 0からstop-1まで
for i in range(5):
print(i) # 0, 1, 2, 3, 4
# range(start, stop) - startからstop-1まで
for i in range(2, 8):
print(i) # 2, 3, 4, 5, 6, 7
# range(start, stop, step) - startからstop-1まで、step刻み
for i in range(0, 10, 2):
print(i) # 0, 2, 4, 6, 8
range関数の応用例
# 逆順ループ
for i in range(10, 0, -1):
print(f"カウントダウン: {i}")
# リストのインデックスでアクセス
items = ["a", "b", "c", "d"]
for i in range(len(items)):
print(f"インデックス{i}: {items[i]}")
# 九九の表
for i in range(1, 10):
for j in range(1, 10):
print(f"{i} × {j} = {i*j:2d}", end=" ")
print() # 改行
range関数のメモリ効率
# range はジェネレータオブジェクト（メモリ効率が良い）
print(type(range(1000000))) # <class 'range'>
# リストに変換すると大量のメモリを使用
# big_list = list(range(1000000)) # 大量メモリ使用
# range を直接使用すれば省メモリ
for i in range(1000000):
if i > 10:
break
print(i)
リスト・タプル・辞書の反復処理 {#データ型別処理}
リストの高度な処理
# ネストしたリスト
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for row in matrix:
for element in row:
print(element, end=" ")
print() # 改行
# リストの要素を条件付きで処理
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = []
for num in numbers:
if num % 2 == 0:
even_numbers.append(num)
print(f"偶数: {even_numbers}")
タプルの処理
# 座標データの処理
coordinates = [(0, 0), (1, 2), (3, 4), (5, 6)]
for x, y in coordinates:
distance = (x**2 + y**2)**0.5
print(f"点({x}, {y})の原点からの距離: {distance:.2f}")
# タプルのアンパック
person_data = [("田中", 25, "エンジニア"), ("佐藤", 30, "デザイナー")]
for name, age, job in person_data:
print(f"名前: {name}, 年齢: {age}, 職業: {job}")
辞書の高度な処理
# ネストした辞書
company_data = {
"技術部": {"田中": 85, "佐藤": 92},
"営業部": {"鈴木": 78, "山田": 88},
"人事部": {"高橋": 95, "伊藤": 82}
}
for department, employees in company_data.items():
print(f"\n{department}:")
for name, score in employees.items():
print(f" {name}: {score}点")
# 辞書の値でソートして処理
scores = {"Alice": 85, "Bob": 92, "Charlie": 78, "David": 95}
for name, score in sorted(scores.items(), key=lambda x: x[1], reverse=True):
print(f"{name}: {score}点")
enumerate関数でインデックス取得 {#enumerate}
enumerate関数は、イテラブルオブジェクトのインデックスと値を同時に取得できる便利な関数です。
enumerate関数の基本使用法
# 基本的な使い方
fruits = ["りんご", "バナナ", "オレンジ"]
for index, fruit in enumerate(fruits):
print(f"{index}: {fruit}")
# 開始インデックスを指定
colors = ["赤", "青", "緑"]
for i, color in enumerate(colors, start=1):
print(f"{i}番目の色: {color}")
enumerate関数の実践例
# ファイルの行番号付き表示
def display_file_with_line_numbers(filename):
try:
with open(filename, 'r', encoding='utf-8') as file:
for line_num, line in enumerate(file, start=1):
print(f"{line_num:3d}: {line.rstrip()}")
except FileNotFoundError:
print(f"ファイル {filename} が見つかりません")
# リストの特定の要素を検索
def find_all_indices(lst, target):
indices = []
for index, value in enumerate(lst):
if value == target:
indices.append(index)
return indices
# 使用例
numbers = [1, 3, 5, 3, 7, 3, 9]
result = find_all_indices(numbers, 3)
print(f"値3のインデックス: {result}") # [1, 3, 5]
enumerate vs range(len())の比較
items = ["a", "b", "c", "d"]
# 非推奨な方法
for i in range(len(items)):
print(f"{i}: {items[i]}")
# 推奨される方法（Pythonic）
for i, item in enumerate(items):
print(f"{i}: {item}")
zip関数で複数リストを同時処理 {#zip関数}
zip関数は、複数のイテラブルオブジェクトを同時に処理する際に使用します。
zip関数の基本使用法
# 2つのリストを同時処理
names = ["田中", "佐藤", "鈴木"]
ages = [25, 30, 28]
for name, age in zip(names, ages):
print(f"{name}さんは{age}歳です")
# 3つ以上のリストも可能
subjects = ["数学", "英語", "理科"]
scores = [85, 92, 78]
grades = ["B", "A", "C"]
for subject, score, grade in zip(subjects, scores, grades):
print(f"{subject}: {score}点 ({grade})")
zip関数の高度な活用
# 辞書の作成
keys = ["name", "age", "city"]
values = ["田中", 30, "東京"]
person = dict(zip(keys, values))
print(person) # {'name': '田中', 'age': 30, 'city': '東京'}
# リストの転置（行列の転置）
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transposed = list(zip(*matrix))
print(transposed) # [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
# 最短のイテラブルで終了
list1 = [1, 2, 3, 4, 5]
list2 = ["a", "b", "c"]
for num, char in zip(list1, list2):
print(f"{num}: {char}") # 3回だけ実行される
itertools.zip_longestで長さの異なるリストを処理
from itertools import zip_longest
list1 = [1, 2, 3, 4, 5]
list2 = ["a", "b", "c"]
# 長い方に合わせて処理（足りない部分はNone）
for num, char in zip_longest(list1, list2):
print(f"{num}: {char}")
# デフォルト値を指定
for num, char in zip_longest(list1, list2, fillvalue="N/A"):
print(f"{num}: {char}")
ネストしたfor文（二重ループ） {#ネスト}
ネストしたfor文は、多次元データの処理や組み合わせの生成に使用されます。
基本的なネストループ
# 二次元リストの処理
grid = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
for i in range(len(grid)):
for j in range(len(grid[i])):
print(f"grid[{i}][{j}] = {grid[i][j]}")
# より Pythonic な書き方
for row_idx, row in enumerate(grid):
for col_idx, value in enumerate(row):
print(f"grid[{row_idx}][{col_idx}] = {value}")
実践的なネストループの例
# 組み合わせの生成
colors = ["赤", "青", "緑"]
sizes = ["S", "M", "L"]
print("商品バリエーション:")
for color in colors:
for size in sizes:
print(f"{color} - {size}サイズ")
# パスワードの生成（簡単な例）
import string
digits = string.digits[:3] # "012"
letters = string.ascii_lowercase[:3] # "abc"
passwords = []
for d1 in digits:
for d2 in digits:
for letter in letters:
passwords.append(f"{d1}{d2}{letter}")
print(f"生成されたパスワード数: {len(passwords)}")
print(f"最初の5個: {passwords[:5]}")
ネストループの最適化
# 効率の悪い例：不要な計算を繰り返す
def find_pairs_slow(numbers, target):
pairs = []
for i in range(len(numbers)):
for j in range(len(numbers)):
if i != j and numbers[i] + numbers[j] == target:
pairs.append((numbers[i], numbers[j]))
return pairs
# 最適化された例
def find_pairs_fast(numbers, target):
pairs = []
for i in range(len(numbers)):
for j in range(i + 1, len(numbers)): # 重複を避ける
if numbers[i] + numbers[j] == target:
pairs.append((numbers[i], numbers[j]))
return pairs
# 使用例
nums = [1, 2, 3, 4, 5, 6]
target_sum = 7
result = find_pairs_fast(nums, target_sum)
print(f"合計が{target_sum}になるペア: {result}")
for文とelse文の組み合わせ {#for-else}
Pythonのfor文には、他の言語にはないelse節を付けることができます。
for-else文の基本概念
# else節はループが正常終了したときに実行される
for i in range(5):
print(i)
else:
print("ループが正常に終了しました")
# breakで中断された場合、else節は実行されない
for i in range(5):
if i == 3:
print("ループを中断します")
break
print(i)
else:
print("この行は実行されません")
実践的なfor-else文の使用例
# 素数判定
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} は素数ではありません")
# リスト内の検索
def find_item(items, target):
for index, item in enumerate(items):
if item == target:
print(f"'{target}' をインデックス {index} で発見")
break
else:
print(f"'{target}' は見つかりませんでした")
# 使用例
fruits = ["りんご", "バナナ", "オレンジ"]
find_item(fruits, "バナナ") # 見つかる
find_item(fruits, "メロン") # 見つからない
内包表記（リスト・辞書・集合） {#内包表記}
内包表記は、for文を使った処理を簡潔に記述できるPythonの強力な機能です。
リスト内包表記
# 基本的なリスト内包表記
numbers = [1, 2, 3, 4, 5]
squares = [x**2 for x in numbers]
print(squares) # [1, 4, 9, 16, 25]
# 条件付きリスト内包表記
even_squares = [x**2 for x in numbers if x % 2 == 0]
print(even_squares) # [4, 16]
# 従来のfor文との比較
# 従来の書き方
result = []
for x in numbers:
if x % 2 == 0:
result.append(x**2)
# 内包表記（Pythonic）
result = [x**2 for x in numbers if x % 2 == 0]
複雑なリスト内包表記
# ネストしたループの内包表記
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [item for row in matrix for item in row]
print(flattened) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 条件分岐を含む内包表記
words = ["python", "java", "javascript", "go", "rust"]
result = [word.upper() if len(word) > 4 else word for word in words]
print(result) # ['PYTHON', 'java', 'JAVASCRIPT', 'go', 'rust']
# 文字列処理の例
text = "Hello World"
vowels = [char for char in text.lower() if char in 'aeiou']
print(vowels) # ['e', 'o', 'o']
辞書内包表記
# 基本的な辞書内包表記
numbers = [1, 2, 3, 4, 5]
squares_dict = {x: x**2 for x in numbers}
print(squares_dict) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# 条件付き辞書内包表記
even_squares_dict = {x: x**2 for x in numbers if x % 2 == 0}
print(even_squares_dict) # {2: 4, 4: 16}
# 辞書の変換
original_dict = {"apple": 5, "banana": 3, "orange": 8}
expensive_items = {k: v for k, v in original_dict.items() if v > 4}
print(expensive_items) # {'apple': 5, 'orange': 8}
集合内包表記
# 基本的な集合内包表記
numbers = [1, 2, 2, 3, 3, 4, 5]
unique_squares = {x**2 for x in numbers}
print(unique_squares) # {1, 4, 9, 16, 25}
# 文字列から文字の集合を作成
text = "programming"
unique_chars = {char for char in text if char.isalpha()}
print(unique_chars) # {'p', 'r', 'o', 'g', 'a', 'm', 'i', 'n'}
ジェネレータ式
# ジェネレータ式（メモリ効率が良い）
numbers = range(10)
squares_gen = (x**2 for x in numbers)
print(type(squares_gen)) # <class 'generator'>
# ジェネレータから値を取得
for square in squares_gen:
if square > 20:
break
print(square)
# sum関数と組み合わせる例
total = sum(x**2 for x in range(100) if x % 2 == 0)
print(f"偶数の平方の合計: {total}")
itertools モジュールの活用 {#itertools}
itertoolsモジュールは、イテレータを効率的に操作するための多くの関数を提供します。
基本的なitertools関数
import itertools
# count: 無限カウンター
counter = itertools.count(start=1, step=2)
for i, num in enumerate(counter):
if i >= 5:
break
print(num) # 1, 3, 5, 7, 9
# cycle: 要素を循環
colors = ['red', 'green', 'blue']
color_cycle = itertools.cycle(colors)
for i, color in enumerate(color_cycle):
if i >= 8:
break
print(f"{i}: {color}")
# repeat: 同じ値を繰り返し
repeated = itertools.repeat('Hello', 3)
for item in repeated:
print(item)
組み合わせとかけ合わせ
import itertools
# combinations: 組み合わせ
items = ['A', 'B', 'C', 'D']
for combo in itertools.combinations(items, 2):
print(combo) # ('A', 'B'), ('A', 'C'), ...
# permutations: 順列
for perm in itertools.permutations(['X', 'Y', 'Z'], 2):
print(perm) # ('X', 'Y'), ('X', 'Z'), ...
# product: デカルト積
for item in itertools.product(['A', 'B'], [1, 2]):
print(item) # ('A', 1), ('A', 2), ('B', 1), ('B', 2)
グループ化と連鎖
import itertools
# groupby: 連続する同じ要素をグループ化
data = ['A', 'A', 'B', 'B', 'B', 'C', 'A']
for key, group in itertools.groupby(data):
print(f"{key}: {list(group)}")
# chain: 複数のイテラブルを連結
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
list3 = [10, 20]
chained = itertools.chain(list1, list2, list3)
print(list(chained)) # [1, 2, 3, 'a', 'b', 'c', 10, 20]
# islice: スライス機能
numbers = itertools.count() # 無限カウンター
first_10_even = list(itertools.islice(
(x for x in numbers if x % 2 == 0), 10
))
print(first_10_even) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
ジェネレータとイテレータ {#ジェネレータ}
ジェネレータは、メモリ効率的な繰り返し処理を可能にする重要な概念です。
ジェネレータ関数の作成
# 基本的なジェネレータ関数
def count_up_to(max_num):
count = 1
while count <= max_num:
yield count
count += 1
# 使用例
counter = count_up_to(5)
for num in counter:
print(num)
# フィボナッチ数列のジェネレータ
def fibonacci(n):
a, b = 0, 1
for _ in range(n):
yield a
a, b = b, a + b
# 使用例
fib_gen = fibonacci(10)
fib_numbers = list(fib_gen)
print(fib_numbers) # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
大容量データの処理
# メモリ効率的なファイル処理
def read_large_file(filename):
"""大きなファイルを行ごとに処理"""
try:
with open(filename, 'r', encoding='utf-8') as file:
for line_num, line in enumerate(file, 1):
yield line_num, line.strip()
except FileNotFoundError:
print(f"ファイル {filename} が見つかりません")
# 数値処理のジェネレータ
def prime_numbers(limit):
"""指定した数までの素数を生成"""
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
return True
for num in range(2, limit + 1):
if is_prime(num):
yield num
# 使用例
primes = list(prime_numbers(30))
print(f"30以下の素数: {primes}")
イテレータのカスタム実装
class CountDown:
"""カウントダウンイテレータ"""
def __init__(self, start):
self.start = start
def __iter__(self):
return self
def __next__(self):
if self.start <= 0:
raise StopIteration
self.start -= 1
return self.start + 1
# 使用例
countdown = CountDown(5)
for num in countdown:
print(f"カウントダウン: {num}")
# より実用的な例：バッチ処理イテレータ
class BatchIterator:
"""データを指定サイズのバッチに分割"""
def __init__(self, data, batch_size):
self.data = data
self.batch_size = batch_size
self.index = 0
def __iter__(self):
return self
def __next__(self):
if self.index >= len(self.data):
raise StopIteration
batch = self.data[self.index:self.index + self.batch_size]
self.index += self.batch_size
return batch
# 使用例
data = list(range(23))
batch_iter = BatchIterator(data, 5)
for i, batch in enumerate(batch_iter, 1):
print(f"バッチ {i}: {batch}")
パフォーマンス最適化テクニック {#最適化}
for文のパフォーマンスを向上させるテクニックを紹介します。
リスト内包表記 vs 通常のfor文
import time
# パフォーマンス測定関数
def measure_time(func):
start = time.time()
result = func()
end = time.time()
return result, end - start
# 通常のfor文
def traditional_loop():
result = []
for i in range(100000):
if i % 2 == 0:
result.append(i * 2)
return result
# リスト内包表記
def list_comprehension():
return [i * 2 for i in range(100000) if i % 2 == 0]
# パフォーマンス比較
result1, time1 = measure_time(traditional_loop)
result2, time2 = measure_time(list_comprehension)
print(f"通常のfor文: {time1:.4f}秒")
print(f"リスト内包表記: {time2:.4f}秒")
print(f"速度比: {time1/time2:.2f}倍")
ジェネレータを使ったメモリ最適化
import sys
# リストを使った場合（メモリを大量消費）
def create_large_list():
return [x**2 for x in range(100000)]
# ジェネレータを使った場合（メモリ効率的）
def create_large_generator():
return (x**2 for x in range(100000))
# メモリ使用量の比較
large_list = create_large_list()
large_gen = create_large_generator()
print(f"リストのサイズ: {sys.getsizeof(large_list)} bytes")
print(f"ジェネレータのサイズ: {sys.getsizeof(large_gen)} bytes")
# 実際の処理では同じ結果を得られる
list_sum = sum(large_list)
gen_sum = sum(create_large_generator()) # 新しいジェネレータを作成
print(f"結果は同じ: {list_sum == gen_sum}")
ループの最適化テクニック
# 効率の悪い例：毎回len()を計算
def inefficient_loop(items):
result = []
for i in range(len(items)): # 毎回len()が呼ばれる
if items[i] > 0:
result.append(items[i] * 2)
return result
# 最適化された例
def optimized_loop(items):
result = []
for item in items: # 直接要素にアクセス
if item > 0:
result.append(item * 2)
return result
# さらに最適化（リスト内包表記）
def most_optimized(items):
return [item * 2 for item in items if item > 0]
# set を使った高速な検索
def slow_membership_test(items, targets):
result = []
for item in items:
if item in targets: # リストでの検索は O(n)
result.append(item)
return result
def fast_membership_test(items, targets):
target_set = set(targets) # set での検索は O(1)
result = []
for item in items:
if item in target_set:
result.append(item)
return result
実践的な応用例 {#実践例}
データ分析での活用
# CSVデータの処理例
def analyze_sales_data(sales_data):
"""売上データの分析"""
total_sales = 0
product_sales = {}
monthly_sales = {}
for record in sales_data:
# 各レコードは {"product": "商品名", "amount": 金額, "month": "月"} 形式
product = record["product"]
amount = record["amount"]
month = record["month"]
# 合計売上
total_sales += amount
# 商品別売上
if product in product_sales:
product_sales[product] += amount
else:
product_sales[product] = amount
# 月別売上
if month in monthly_sales:
monthly_sales[month] += amount
else:
monthly_sales[month] = amount
return {
"total": total_sales,
"by_product": product_sales,
"by_month": monthly_sales
}
# サンプルデータ
sales_data = [
{"product": "商品A", "amount": 1000, "month": "1月"},
{"product": "商品B", "amount": 1500, "month": "1月"},
{"product": "商品A", "amount": 1200, "month": "2月"},
{"product": "商品C", "amount": 800, "month": "2月"},
]
analysis = analyze_sales_data(sales_data)
print("売上分析結果:")
for key, value in analysis.items():
print(f"{key}: {value}")
ファイル処理の実践例
import os
from collections import defaultdict
def analyze_directory(directory_path):
"""ディレクトリ内のファイルを分析"""
file_stats = {
"total_files": 0,
"total_size": 0,
"extensions": defaultdict(int),
"size_by_extension": defaultdict(int)
}
try:
for root, dirs, files in os.walk(directory_path):
for filename in files:
filepath = os.path.join(root, filename)
# ファイルサイズ取得
try:
file_size = os.path.getsize(filepath)
file_stats["total_files"] += 1
file_stats["total_size"] += file_size
# 拡張子別統計
_, ext = os.path.splitext(filename)
ext = ext.lower() if ext else "拡張子なし"
file_stats["extensions"][ext] += 1
file_stats["size_by_extension"][ext] += file_size
except OSError:
continue # アクセスできないファイルをスキップ
except OSError as e:
print(f"ディレクトリアクセスエラー: {e}")
return None
return file_stats
# ログファイル分析の例
def analyze_log_file(log_file_path):
"""ログファイルの分析"""
log_stats = {
"total_lines": 0,
"error_count": 0,
"warning_count": 0,
"ip_addresses": defaultdict(int)
}
try:
with open(log_file_path, 'r', encoding='utf-8') as file:
for line_num, line in enumerate(file, 1):
log_stats["total_lines"] += 1
line = line.strip()
# エラーログのカウント
if "ERROR" in line.upper():
log_stats["error_count"] += 1
elif "WARNING" in line.upper():
log_stats["warning_count"] += 1
# IPアドレスの抽出（簡単な例）
import re
ip_pattern = r'\b(?:\d{1,3}\.){3}\d{1,3}\b'
ip_matches = re.findall(ip_pattern, line)
for ip in ip_matches:
log_stats["ip_addresses"][ip] += 1
except FileNotFoundError:
print(f"ファイル {log_file_path} が見つかりません")
return None
except Exception as e:
print(f"ファイル処理エラー: {e}")
return None
return log_stats
アルゴリズムの実装例
# ソートアルゴリズム：バブルソート
def bubble_sort(arr):
"""バブルソートの実装"""
n = len(arr)
arr = arr.copy() # 元の配列を変更しない
for i in range(n):
swapped = False
for j in range(0, n - i - 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
swapped = True
# 交換が発生しなかった場合、ソート完了
if not swapped:
break
return arr
# 検索アルゴリズム：線形検索
def linear_search(arr, target):
"""線形検索で全ての一致インデックスを返す"""
indices = []
for index, value in enumerate(arr):
if value == target:
indices.append(index)
return indices
# グラフアルゴリズム：幅優先探索（BFS）
from collections import deque
def bfs(graph, start_node):
"""幅優先探索の実装"""
visited = set()
queue = deque([start_node])
result = []
while queue:
node = queue.popleft()
if node not in visited:
visited.add(node)
result.append(node)
# 隣接ノードをキューに追加
for neighbor in graph.get(node, []):
if neighbor not in visited:
queue.append(neighbor)
return result
# 使用例
graph = {
'A': ['B', 'C'],
'B': ['A', 'D', 'E'],
'C': ['A', 'F'],
'D': ['B'],
'E': ['B', 'F'],
'F': ['C', 'E']
}
bfs_result = bfs(graph, 'A')
print(f"BFS探索結果: {bfs_result}")
よくある間違いと対処法 {#よくある間違い}
間違い1: ループ中でのリスト変更
# 間違い：ループ中にリストを変更
numbers = [1, 2, 3, 4, 5, 6]
for num in numbers:
if num % 2 == 0:
numbers.remove(num) # これは危険
print(numbers) # 期待した結果にならない
# 正しい方法1：新しいリストを作成
numbers = [1, 2, 3, 4, 5, 6]
odd_numbers = [num for num in numbers if num % 2 != 0]
print(odd_numbers)
# 正しい方法2：逆順でループ
numbers = [1, 2, 3, 4, 5, 6]
for i in range(len(numbers) - 1, -1, -1):
if numbers[i] % 2 == 0:
numbers.pop(i)
print(numbers)
# 正しい方法3：filterを使用
numbers = [1, 2, 3, 4, 5, 6]
numbers = list(filter(lambda x: x % 2 != 0, numbers))
print(numbers)
間違い2: ネストしたループでの変数名の混同
# 問題のあるコード
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for i in range(len(matrix)):
for i in range(len(matrix[i])): # 変数名が重複
print(matrix[i][i]) # 期待した動作にならない
# 正しいコード
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]}")
# より Pythonic な方法
for row_idx, row in enumerate(matrix):
for col_idx, value in enumerate(row):
print(f"matrix[{row_idx}][{col_idx}] = {value}")
間違い3: ジェネレータの再利用
# 問題：ジェネレータは一度しか使えない
def number_generator():
for i in range(5):
yield i
gen = number_generator()
print("1回目:", list(gen)) # [0, 1, 2, 3, 4]
print("2回目:", list(gen)) # [] 空のリスト
# 解決方法1：毎回新しいジェネレータを作成
def use_generator_correctly():
for attempt in ["1回目", "2回目"]:
gen = number_generator()
print(f"{attempt}:", list(gen))
# 解決方法2：リストに変換して保存
gen = number_generator()
numbers = list(gen)
print("1回目:", numbers)
print("2回目:", numbers)
間違い4: 浮動小数点数の範囲指定
# 問題：浮動小数点数を range で使用しようとする
# for i in range(0.0, 1.0, 0.1): # TypeError
# 解決方法1：整数を使って計算
for i in range(10):
value = i * 0.1
print(f"{value:.1f}")
# 解決方法2：numpy を使用（推奨）
import numpy as np
for value in np.arange(0.0, 1.0, 0.1):
print(f"{value:.1f}")
# 解決方法3：カスタム関数
def float_range(start, stop, step):
while start < stop:
yield start
start += step
for value in float_range(0.0, 1.0, 0.1):
print(f"{value:.1f}")
デバッグとトラブルシューティング
for文のデバッグテクニック
# デバッグ用の詳細出力
def debug_loop(items, process_func):
"""ループ処理をデバッグモードで実行"""
print(f"処理開始: {len(items)}個のアイテム")
for index, item in enumerate(items):
try:
print(f"[{index}] 処理中: {item}")
result = process_func(item)
print(f"[{index}] 結果: {result}")
except Exception as e:
print(f"[{index}] エラー: {e}")
continue
print("処理完了")
# 使用例
def risky_process(x):
if x == 0:
raise ValueError("ゼロ除算エラー")
return 10 / x
test_data = [1, 2, 0, 4, 5]
debug_loop(test_data, risky_process)
パフォーマンス分析
import time
import functools
def time_loop(func):
"""ループ処理の実行時間を測定するデコレータ"""
@functools.wraps(func)
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"{func.__name__} 実行時間: {end_time - start_time:.4f}秒")
return result
return wrapper
@time_loop
def process_large_data(size):
return [x**2 for x in range(size)]
# 使用例
result = process_large_data(100000)
最新のPython機能（Python 3.8+）
ウォルラス演算子（:=）をfor文で活用
# Python 3.8+ のウォルラス演算子
data = [1, 4, 9, 16, 25, 36, 49]
# 従来の書き方
for x in data:
sqrt_x = x ** 0.5
if sqrt_x > 4:
print(f"{x} の平方根は {sqrt_x}")
# ウォルラス演算子を使用
for x in data:
if (sqrt_x := x ** 0.5) > 4:
print(f"{x} の平方根は {sqrt_x}")
# ファイル処理での活用
def process_file_lines(filename):
try:
with open(filename, 'r') as file:
while (line := file.readline()):
if 'ERROR' in line:
print(f"エラー行発見: {line.strip()}")
except FileNotFoundError:
print(f"ファイル {filename} が見つかりません")
match文（Python 3.10+）での複雑なパターンマッチング
# Python 3.10+ のmatch文を for文と組み合わせ
def process_mixed_data(data_list):
"""様々な型のデータを処理"""
for item in data_list:
match item:
case int() if item > 0:
print(f"正の整数: {item}")
case int() if item <= 0:
print(f"ゼロまたは負の整数: {item}")
case str() if len(item) > 5:
print(f"長い文字列: {item}")
case str():
print(f"短い文字列: {item}")
case list() | tuple():
print(f"シーケンス（長さ{len(item)}）: {item}")
case dict():
print(f"辞書（{len(item)}個のキー）")
case _:
print(f"その他の型: {type(item).__name__}")
# 使用例
mixed_data = [42, -5, "Hello", "World!!!", [1, 2, 3], {"key": "value"}, 3.14]
process_mixed_data(mixed_data)
まとめ
Python for文は、プログラミングにおいて最も重要で頻繁に使用される制御構文の一つです。基本的な反復処理から高度なジェネレータ、内包表記まで、様々な場面で活用できます。
重要なポイントの総まとめ:
基礎レベル:
- 基本構文:
for 変数 in イテラブル:の形式を理解 - range関数: 数値の範囲を効率的に生成
- enumerate: インデックスと値を同時に取得
- zip: 複数のリストを同時に処理
中級レベル:
- 内包表記: リスト、辞書、集合を簡潔に作成
- ジェネレータ: メモリ効率的な大容量データ処理
- itertools: 高度な反復処理パターン
- for-else: ループの正常終了を検出
上級レベル:
- パフォーマンス最適化: 適切なデータ構造とアルゴリズムの選択
- カスタムイテレータ: 独自の反復可能オブジェクトの作成
- エラーハンドリング: 堅牢なループ処理の実装
- デバッグテクニック: 効率的な問題解決手法
実践で重要な考慮点:
- 可読性: コードの意図が明確に伝わる書き方を選択
- 効率性: データサイズとパフォーマンス要件に応じた最適化
- 保守性: 将来の変更に対応しやすい構造
- Pythonic: Python らしい慣用的な表現の使用
これらの知識を組み合わせることで、あらゆる場面で効果的なfor文を記述できるようになります。継続的な練習と実際のプロジェクトでの応用を通じて、Python for文を完全にマスターしていきましょう。
最後に: for文は単なる繰り返し処理の道具ではなく、データの変換、フィルタリング、集約など、データ処理の中核を担う重要な機能です。この記事で紹介したテクニックを組み合わせて、より良いPythonコードを書いていってください。
この記事は2025年の最新情報に基づいて作成されています。Pythonのバージョンアップデートにより、さらに便利な機能が追加される可能性があります。
■プロンプトだけでオリジナルアプリを開発・公開してみた！！
■AI時代の第一歩！「AI駆動開発コース」はじめました！
テックジム東京本校で先行開始。
■テックジム東京本校
「武田塾」のプログラミング版といえば「テックジム」。
講義動画なし、教科書なし。「進捗管理とコーチング」で効率学習。
より早く、より安く、しかも対面型のプログラミングスクールです。
