【Python】予約語一覧と確認方法：変数名で使えない単語完全ガイド

Pythonプログラミングにおいて、予約語（キーワード）は言語の構文として特別な意味を持つ単語で、変数名や関数名として使用することができません。この記事では、Python予約語の完全一覧、確認方法、そして予約語を避けた適切な命名方法について詳しく解説します。

Python予約語とは

予約語（Reserved Words）またはキーワードは、Pythonの言語仕様で特別な意味を持つ単語です。これらの単語は、条件分岐、ループ、関数定義、クラス定義などの構文を構成するために使用され、変数名や関数名として使用することはできません。

予約語を使用した場合のエラー例

# 予約語を変数名として使用した場合のエラー例
try:
    exec("if = 10")  # 'if'は予約語
except SyntaxError as e:
    print(f"SyntaxError: {e}")
    # SyntaxError: invalid syntax

try:
    exec("class = 'Python'")  # 'class'は予約語
except SyntaxError as e:
    print(f"SyntaxError: {e}")
    # SyntaxError: invalid syntax

Python予約語の完全一覧

1. keyword モジュールを使用した確認

import keyword

# 現在のPythonバージョンの予約語を取得
reserved_words = keyword.kwlist
print(f"Python予約語の数: {len(reserved_words)}")
print("\n=== Python予約語一覧 ===")

# アルファベット順で表示
for i, word in enumerate(sorted(reserved_words), 1):
    print(f"{i:2d}. {word}")

# 予約語を5列で表示
print("\n=== 予約語（表形式）===")
sorted_words = sorted(reserved_words)
for i in range(0, len(sorted_words), 5):
    row = sorted_words[i:i+5]
    print(" | ".join(f"{word:<10}" for word in row))

2. カテゴリ別予約語一覧

def categorize_keywords():
    """予約語をカテゴリ別に分類"""
    
    categories = {
        "条件分岐": ["if", "elif", "else"],
        "ループ": ["for", "while", "break", "continue"],
        "関数・クラス": ["def", "class", "return", "yield", "lambda"],
        "例外処理": ["try", "except", "finally", "raise", "assert"],
        "論理演算": ["and", "or", "not", "is", "in"],
        "値・定数": ["True", "False", "None"],
        "インポート": ["import", "from", "as"],
        "変数・スコープ": ["global", "nonlocal", "del"],
        "非同期処理": ["async", "await"],
        "その他": ["pass", "with", "match", "case"]  # match, caseはPython 3.10以降
    }
    
    print("=== カテゴリ別Python予約語 ===")
    for category, words in categories.items():
        print(f"\n【{category}】")
        for word in words:
            if keyword.iskeyword(word):
                print(f"  ✓ {word}")
            else:
                print(f"  ✗ {word}（このバージョンでは予約語ではありません）")
    
    return categories

categorize_keywords()

3. バージョン別予約語の違い

import sys

def show_version_differences():
    """Pythonバージョンによる予約語の違いを表示"""
    
    current_version = sys.version_info
    print(f"現在のPythonバージョン: {current_version.major}.{current_version.minor}.{current_version.micro}")
    
    # バージョン別の追加予約語
    version_specific = {
        "3.5": ["async", "await"],
        "3.10": ["match", "case"],
    }
    
    print("\n=== バージョン別追加予約語 ===")
    for version, new_keywords in version_specific.items():
        print(f"Python {version}で追加:")
        for kw in new_keywords:
            is_keyword = keyword.iskeyword(kw)
            status = "✓" if is_keyword else "✗"
            print(f"  {status} {kw}")
    
    # 現在のバージョンで利用可能な予約語
    current_keywords = keyword.kwlist
    print(f"\n現在のバージョンの予約語数: {len(current_keywords)}")

show_version_differences()

予約語チェック機能

1. 基本的なチェック関数

import keyword

def is_reserved_word(word):
    """指定された単語が予約語かどうかチェック"""
    return keyword.iskeyword(word)

def check_multiple_words(words):
    """複数の単語をまとめてチェック"""
    results = {}
    for word in words:
        results[word] = keyword.iskeyword(word)
    return results

# テスト用の単語リスト
test_words = [
    "if", "name", "class", "user", "def", "variable",
    "for", "data", "import", "count", "True", "value"
]

print("=== 予約語チェック結果 ===")
results = check_multiple_words(test_words)
for word, is_keyword in results.items():
    status = "予約語" if is_keyword else "使用可能"
    print(f"{word:<10}: {status}")

2. インタラクティブ予約語チェッカー

def interactive_keyword_checker():
    """インタラクティブな予約語チェッカー"""
    
    print("=== Python予約語チェッカー ===")
    print("単語を入力してください（'quit'で終了、'list'で予約語一覧表示）")
    
    while True:
        user_input = input("\n単語を入力: ").strip()
        
        if user_input.lower() == 'quit':
            print("チェッカーを終了します。")
            break
        
        if user_input.lower() == 'list':
            print("\n現在の予約語一覧:")
            for i, word in enumerate(sorted(keyword.kwlist), 1):
                print(f"{i:2d}. {word}")
            continue
        
        if not user_input:
            print("単語を入力してください。")
            continue
        
        if keyword.iskeyword(user_input):
            print(f"❌ '{user_input}' は予約語です。変数名として使用できません。")
            # 代替案を提案
            suggestions = [
                f"{user_input}_var",
                f"{user_input}_value", 
                f"my_{user_input}",
                f"{user_input}_data"
            ]
            print(f"代替案: {', '.join(suggestions)}")
        else:
            print(f"✅ '{user_input}' は予約語ではありません。変数名として使用できます。")

# インタラクティブチェッカーの実行例（コメントアウト）
# interactive_keyword_checker()

3. ファイル内の予約語使用チェック

import re
import keyword

def check_file_for_keywords(content):
    """ファイル内容で予約語が変数名として使われていないかチェック"""
    
    # 変数代入のパターンを検出
    assignment_pattern = r'(\w+)\s*='
    matches = re.findall(assignment_pattern, content)
    
    violations = []
    for match in matches:
        if keyword.iskeyword(match):
            violations.append(match)
    
    return violations

def analyze_code_content():
    """コード内容の分析例"""
    
    # 問題のあるコード例
    problematic_code = """
# 問題のあるコード例
if = 10          # 'if'は予約語
class = "Python" # 'class'は予約語
name = "正常"    # これは問題なし
for = 5          # 'for'は予約語
data = [1, 2, 3] # これは問題なし
"""
    
    print("=== コード分析結果 ===")
    print("問題のあるコード:")
    print(problematic_code)
    
    violations = check_file_for_keywords(problematic_code)
    
    if violations:
        print(f"\n❌ 発見された予約語の不正使用: {len(violations)}件")
        for violation in violations:
            print(f"  - '{violation}' は予約語です")
    else:
        print("\n✅ 予約語の不正使用は見つかりませんでした")

analyze_code_content()

予約語を避けた命名方法

1. 一般的な代替命名パターン

def show_naming_alternatives():
    """予約語の代替命名パターンを示す"""
    
    alternatives = {
        # 予約語: [代替案のリスト]
        "class": ["class_name", "cls", "class_type", "class_info"],
        "def": ["definition", "def_name", "function_def"],
        "if": ["condition", "if_condition", "check"],
        "for": ["loop_var", "iterator", "for_loop"],
        "import": ["import_name", "module_name", "imported"],
        "from": ["source", "from_location", "origin"],
        "try": ["attempt", "try_block", "trial"],
        "except": ["exception", "error_handler", "catch"],
        "return": ["result", "return_value", "output"],
        "True": ["is_true", "true_value", "boolean_true"],
        "False": ["is_false", "false_value", "boolean_false"],
        "None": ["none_value", "null_value", "empty_value"],
        "and": ["and_condition", "logical_and"],
        "or": ["or_condition", "logical_or"],
        "not": ["not_condition", "negation"],
        "in": ["inside", "within", "contains"],
        "is": ["equals", "is_equal", "identity"],
        "with": ["with_context", "context_manager"],
        "as": ["alias", "as_name", "renamed"],
        "pass": ["skip", "pass_through", "placeholder"],
        "break": ["break_point", "loop_break"],
        "continue": ["continue_flag", "loop_continue"],
        "while": ["while_condition", "loop_while"],
        "global": ["global_var", "global_scope"],
        "lambda": ["lambda_func", "anonymous_func"],
        "yield": ["yield_value", "generator_yield"],
        "del": ["delete", "remove", "del_item"],
        "raise": ["raise_error", "exception_raise"],
        "assert": ["assertion", "assert_check"],
        "finally": ["finally_block", "cleanup"],
        "else": ["else_condition", "alternative"],
        "elif": ["elif_condition", "else_if"],
        "nonlocal": ["nonlocal_var", "outer_scope"],
        "async": ["async_func", "asynchronous"],
        "await": ["await_result", "async_wait"],
    }
    
    print("=== 予約語の代替命名案 ===")
    for reserved_word, suggestions in alternatives.items():
        print(f"\n'{reserved_word}' の代替案:")
        for i, suggestion in enumerate(suggestions, 1):
            print(f"  {i}. {suggestion}")

show_naming_alternatives()

2. 文脈に応じた命名例

def contextual_naming_examples():
    """文脈に応じた具体的な命名例"""
    
    contexts = {
        "データベース": {
            "class": "table_class",
            "from": "source_table", 
            "import": "imported_data",
            "in": "exists_in_db"
        },
        "Web開発": {
            "class": "css_class",
            "from": "request_from",
            "import": "module_import",
            "return": "response_data"
        },
        "データ分析": {
            "class": "data_class",
            "for": "loop_counter",
            "in": "data_contains",
            "if": "data_condition"
        },
        "ファイル処理": {
            "with": "file_context",
            "as": "file_alias",
            "from": "file_source",
            "import": "imported_module"
        }
    }
    
    print("=== 文脈に応じた命名例 ===")
    for context, naming_map in contexts.items():
        print(f"\n【{context}分野】")
        for reserved_word, alternative in naming_map.items():
            print(f"  '{reserved_word}' → '{alternative}'")

contextual_naming_examples()

3. 命名規則のベストプラクティス

def naming_best_practices():
    """命名規則のベストプラクティス"""
    
    practices = [
        {
            "rule": "意味を明確にする",
            "bad_example": "data",
            "good_example": "user_data",
            "reason": "何のデータか分かりやすい"
        },
        {
            "rule": "予約語に接尾辞を付ける",
            "bad_example": "class",
            "good_example": "class_name",
            "reason": "予約語を避けつつ意味を保持"
        },
        {
            "rule": "文脈を含める",
            "bad_example": "if",
            "good_example": "if_user_exists",
            "reason": "条件の内容が明確"
        },
        {
            "rule": "型や用途を示す",
            "bad_example": "for",
            "good_example": "for_loop_counter",
            "reason": "変数の用途が明確"
        },
        {
            "rule": "省略形を活用",
            "bad_example": "import",
            "good_example": "imp",
            "reason": "短く分かりやすい"
        }
    ]
    
    print("=== 命名ベストプラクティス ===")
    for i, practice in enumerate(practices, 1):
        print(f"\n{i}. {practice['rule']}")
        print(f"   ❌ 悪い例: {practice['bad_example']}")
        print(f"   ✅ 良い例: {practice['good_example']}")
        print(f"   理由: {practice['reason']}")

naming_best_practices()

実践的な使用例

1. 設定ファイル処理での予約語回避

import json
import keyword

class ConfigProcessor:
    """設定ファイル処理で予約語を避ける例"""
    
    def __init__(self):
        self.config_data = {}
        self.reserved_word_mappings = {
            "class": "class_name",
            "type": "data_type",  # typeは予約語ではないが組み込み関数
            "import": "import_path",
            "from": "source_path",
            "if": "condition",
            "else": "alternative",
            "for": "iteration",
            "while": "loop_condition"
        }
    
    def safe_key_name(self, key):
        """安全なキー名に変換"""
        if keyword.iskeyword(key):
            return self.reserved_word_mappings.get(key, f"{key}_value")
        return key
    
    def process_config(self, config_dict):
        """設定辞書を安全に処理"""
        safe_config = {}
        
        for key, value in config_dict.items():
            safe_key = self.safe_key_name(key)
            
            if safe_key != key:
                print(f"キー名変更: '{key}' → '{safe_key}'")
            
            # 値が辞書の場合は再帰的に処理
            if isinstance(value, dict):
                safe_config[safe_key] = self.process_config(value)
            else:
                safe_config[safe_key] = value
        
        return safe_config

# 使用例
processor = ConfigProcessor()

# 問題のある設定例
problematic_config = {
    "class": "UserModel",
    "import": "/path/to/module", 
    "if": "age > 18",
    "normal_key": "normal_value",
    "nested": {
        "for": "range(10)",
        "while": "condition == True"
    }
}

print("=== 設定ファイル処理例 ===")
print("元の設定:")
for key, value in problematic_config.items():
    print(f"  {key}: {value}")

safe_config = processor.process_config(problematic_config)

print("\n処理後の設定:")
for key, value in safe_config.items():
    print(f"  {key}: {value}")

2. 動的な変数作成での予約語チェック

def safe_dynamic_variables():
    """動的変数作成時の予約語チェック"""
    
    def create_safe_variable(name, value):
        """安全な変数を動的に作成"""
        if keyword.iskeyword(name):
            safe_name = f"var_{name}"
            print(f"予約語検出: '{name}' → '{safe_name}'")
            globals()[safe_name] = value
            return safe_name
        else:
            globals()[name] = value
            return name
    
    # テストデータ
    variable_definitions = [
        ("user_name", "太郎"),
        ("class", "Python"),      # 予約語
        ("count", 100),
        ("if", "条件"),           # 予約語
        ("data_list", [1, 2, 3]),
        ("for", "ループ"),        # 予約語
    ]
    
    print("=== 動的変数作成例 ===")
    created_variables = []
    
    for name, value in variable_definitions:
        actual_name = create_safe_variable(name, value)
        created_variables.append(actual_name)
        print(f"作成された変数: {actual_name} = {value}")
    
    # 作成された変数の確認
    print("\n作成された変数の値:")
    for var_name in created_variables:
        if var_name in globals():
            print(f"{var_name}: {globals()[var_name]}")

safe_dynamic_variables()

3. コード生成での予約語処理

def code_generator_with_keyword_check():
    """コード生成時の予約語チェック機能"""
    
    class PythonCodeGenerator:
        def __init__(self):
            self.generated_code = []
            self.variable_counter = 0
        
        def safe_variable_name(self, preferred_name):
            """安全な変数名を生成"""
            if keyword.iskeyword(preferred_name):
                # 予約語の場合は接尾辞を追加
                return f"{preferred_name}_var"
            return preferred_name
        
        def generate_assignment(self, var_name, value):
            """代入文を生成"""
            safe_name = self.safe_variable_name(var_name)
            
            if isinstance(value, str):
                code_line = f'{safe_name} = "{value}"'
            else:
                code_line = f'{safe_name} = {value}'
            
            self.generated_code.append(code_line)
            return safe_name
        
        def generate_function_def(self, func_name, params):
            """関数定義を生成"""
            safe_name = self.safe_variable_name(func_name)
            safe_params = [self.safe_variable_name(p) for p in params]
            
            param_str = ", ".join(safe_params)
            code_line = f"def {safe_name}({param_str}):"
            self.generated_code.append(code_line)
            self.generated_code.append("    pass")
            
            return safe_name
        
        def get_code(self):
            """生成されたコードを取得"""
            return "\n".join(self.generated_code)
    
    # 使用例
    generator = PythonCodeGenerator()
    
    # 変数定義（一部に予約語を含む）
    variables = [
        ("name", "太郎"),
        ("class", "Student"),     # 予約語
        ("age", 20),
        ("if", "条件"),           # 予約語
        ("score", 85.5),
    ]
    
    # 関数定義（予約語を含む）
    functions = [
        ("calculate", ["value", "rate"]),
        ("for", ["items"]),       # 予約語
        ("process_data", ["data", "import"]),  # paramに予約語
    ]
    
    print("=== コード生成例 ===")
    
    # 変数生成
    for var_name, value in variables:
        actual_name = generator.generate_assignment(var_name, value)
        if actual_name != var_name:
            print(f"変数名変更: {var_name} → {actual_name}")
    
    # 関数生成
    for func_name, params in functions:
        actual_name = generator.generate_function_def(func_name, params)
        if actual_name != func_name:
            print(f"関数名変更: {func_name} → {actual_name}")
    
    print("\n生成されたコード:")
    print(generator.get_code())

code_generator_with_keyword_check()

デバッグとトラブルシューティング

1. 予約語関連エラーの分析

import traceback
import re

def analyze_keyword_errors():
    """予約語関連エラーの分析"""
    
    error_patterns = {
        r"invalid syntax.*near '(\w+)'": "予約語の不正使用の可能性",
        r"keyword can't be an expression target": "予約語への代入エラー",
        r"invalid decimal literal": "数字で始まる変数名（予約語以外の問題）"
    }
    
    def analyze_error_message(error_msg):
        """エラーメッセージを分析"""
        for pattern, description in error_patterns.items():
            match = re.search(pattern, error_msg)
            if match:
                return description, match.groups()
        return "不明なエラー", ()
    
    # エラー例のテスト
    test_codes = [
        "class = 'Python'",       # 予約語への代入
        "if = 10",                # 予約語への代入
        "def = function",         # 予約語への代入
    ]
    
    print("=== 予約語エラー分析 ===")
    for code in test_codes:
        try:
            exec(code)
        except SyntaxError as e:
            error_type, groups = analyze_error_message(str(e))
            print(f"コード: {code}")
            print(f"エラー: {e}")
            print(f"分析: {error_type}")
            if groups:
                print(f"検出された単語: {groups}")
            print("-" * 40)

analyze_keyword_errors()

2. 予約語使用状況の監視

def monitor_keyword_usage():
    """コード内の予約語使用状況を監視"""
    
    def extract_identifiers(code):
        """コードから識別子を抽出"""
        # 簡単な識別子抽出（実際にはASTを使う方が良い）
        identifier_pattern = r'\b([a-zA-Z_][a-zA-Z0-9_]*)\b'
        return re.findall(identifier_pattern, code)
    
    def analyze_code_keywords(code):
        """コード内の予約語使用を分析"""
        identifiers = extract_identifiers(code)
        keyword_usage = {}
        
        for identifier in set(identifiers):
            if keyword.iskeyword(identifier):
                # 予約語がどのような文脈で使われているかを簡易チェック
                contexts = []
                
                # 代入文での使用をチェック
                if re.search(rf'\b{re.escape(identifier)}\s*=', code):
                    contexts.append("変数代入")
                
                # 関数定義での使用をチェック
                if re.search(rf'def\s+{re.escape(identifier)}\s*\(', code):
                    contexts.append("関数名")
                
                # 通常の使用（予約語として）
                if not contexts:
                    contexts.append("正常な予約語使用")
                
                keyword_usage[identifier] = contexts
        
        return keyword_usage
    
    # テストコード例
    test_code = """
# 正常なコード
if condition:
    for item in items:
        print(item)

def process_data(data):
    return data * 2

# 問題のあるコード（コメント内）
# class = "Student"  # これは実際には実行されない
# if = 10           # これも実行されない
"""
    
    print("=== 予約語使用状況監視 ===")
    print("分析対象コード:")
    print(test_code)
    
    usage = analyze_code_keywords(test_code)
    
    if usage:
        print("\n予約語使用状況:")
        for keyword_name, contexts in usage.items():
            print(f"'{keyword_name}': {', '.join(contexts)}")
    else:
        print("\n予約語の不正使用は検出されませんでした。")

monitor_keyword_usage()

予約語学習支援ツール

1. 予約語クイズ機能

import random

def keyword_quiz():
    """予約語学習用クイズ"""
    
    quiz_data = [
        {"word": "if", "category": "条件分岐", "description": "条件分岐の開始"},
        {"word": "def", "category": "関数定義", "description": "関数を定義する"},
        {"word": "class", "category": "クラス定義", "description": "クラスを定義する"},
        {"word": "import", "category": "モジュール", "description": "モジュールを読み込む"},
        {"word": "try", "category": "例外処理", "description": "例外処理ブロックの開始"},
        {"word": "lambda", "category": "関数", "description": "無名関数を定義する"},
        {"word": "yield", "category": "ジェネレータ", "description": "ジェネレータで値を返す"},
        {"word": "async", "category": "非同期", "description": "非同期関数を定義する"},
    ]
    
    # 非予約語も混ぜる
    non_keywords = [
        {"word": "name", "is_keyword": False},
        {"word": "data", "is_keyword": False},
        {"word": "value", "is_keyword": False},
        {"word": "count", "is_keyword": False},
    ]
    
    def quiz_question_1():
        """クイズ1: これは予約語？"""
        all_words = [(item["word"], True) for item in quiz_data] + [(item["word"], False) for item in non_keywords]
        word, is_keyword = random.choice(all_words)
        
        print(f"\nクイズ1: '{word}' は予約語でしょうか？")
        print("1. はい  2. いいえ")
        
        return word, is_keyword
    
    def quiz_question_2():
        """クイズ2: カテゴリ当て"""
        item = random.choice(quiz_data)
        
        categories = list(set(q["category"] for q in quiz_data))
        correct_category = item["category"]
        
        # 選択肢を作成
        other_categories = 
        choices = [correct_category] + random.sample(other_categories, min(2, len(other_categories)))
        random.shuffle(choices)
        
        print(f"\nクイズ2: '{item['word']}' はどのカテゴリの予約語？")
        for i, choice in enumerate(choices, 1):
            print(f"{i}. {choice}")
        
        return item["word"], correct_category, choices
    
    print("=== Python予約語クイズ ===")
    print("予約語の理解度をチェックしましょう！")
    
    # サンプルクイズを実行
    word, is_keyword = quiz_question_1()
    actual_is_keyword = keyword.iskeyword(word)
    print(f"答え: {'はい' if actual_is_keyword else 'いいえ'}")
    
    keyword_word, correct_cat, choices = quiz_question_2()
    print(f"答え: {correct_cat}")

keyword_quiz()

2. 予約語暗記支援ツール

def keyword_memorization_tool():
    """予約語暗記支援ツール"""
    
    keyword_groups = {
        "基本制御": {
            "keywords": ["if", "elif", "else", "for", "while", "break", "continue"],
            "mnemonic": "条件分岐とループの基本セット"
        },
        "関数とクラス": {
            "keywords": ["def", "class", "return", "yield", "lambda"],
            "mnemonic": "関数やクラスを定義・操作する"
        },
        "例外処理": {
            "keywords": ["try", "except", "finally", "raise", "assert"],
            "mnemonic": "エラーハンドリングの完全セット"
        },
        "論理演算": {
            "keywords": ["and", "or", "not", "is", "in"],
            "mnemonic": "論理判定に使用する演算子"
        },
        "特殊値": {
            "keywords": ["True", "False", "None"],
            "mnemonic": "Pythonの特殊な値"
        },
        "スコープ": {
            "keywords": ["global", "nonlocal", "del"],
            "mnemonic": "変数のスコープ制御"
        },
        "モジュール": {
            "keywords": ["import", "from", "as"],
            "mnemonic": "モジュールの読み込み"
        },
        "非同期": {
            "keywords": ["async", "await"],
            "mnemonic": "非同期プログラミング"
        },
        "その他": {
            "keywords": ["pass", "with", "match", "case"],
            "mnemonic": "特殊な制御構文"
        }
    }
    
    print("=== Python予約語暗記支援 ===")
    print("グループ別に予約語を覚えましょう！\n")
    
    for group_name, group_data in keyword_groups.items():
        print(f"【{group_name}】")
        print(f"覚え方: {group_data['mnemonic']}")
        
        valid_keywords = [kw for kw in group_data['keywords'] if keyword.iskeyword(kw)]
        invalid_keywords = [kw for kw in group_data['keywords'] if not keyword.iskeyword(kw)]
        
        if valid_keywords:
            print(f"予約語: {', '.join(valid_keywords)}")
        
        if invalid_keywords:
            print(f"このバージョンでは予約語ではない: {', '.join(invalid_keywords)}")
        
        print("-" * 40)
    
    # 暗記チェック機能
    print("\n=== 暗記チェック ===")
    all_keywords = [kw for group in keyword_groups.values() for kw in group['keywords'] if keyword.iskeyword(kw)]
    sample_keywords = random.sample(all_keywords, min(5, len(all_keywords)))
    
    print("以下の単語は予約語ですか？覚えているかチェック！")
    for i, kw in enumerate(sample_keywords, 1):
        print(f"{i}. {kw}")
    
    print(f"\n答え: すべて予約語です！（現在のPythonバージョンで確認済み）")

keyword_memorization_tool()

3. 予約語カードゲーム

def keyword_card_game():
    """予約語学習カードゲーム"""
    
    cards = [
        {"word": "if", "usage": "if condition:", "example": "if age > 18:"},
        {"word": "def", "usage": "def function_name():", "example": "def calculate(x, y):"},
        {"word": "class", "usage": "class ClassName:", "example": "class Student:"},
        {"word": "for", "usage": "for item in iterable:", "example": "for i in range(10):"},
        {"word": "while", "usage": "while condition:", "example": "while count < 100:"},
        {"word": "try", "usage": "try:", "example": "try:\n    risky_operation()"},
        {"word": "import", "usage": "import module", "example": "import math"},
        {"word": "return", "usage": "return value", "example": "return result"},
    ]
    
    def show_card(card):
        """カードを表示"""
        print("┌" + "─" * 30 + "┐")
        print(f"│ 予約語: {card['word']:<20} │")
        print("├" + "─" * 30 + "┤")
        print(f"│ 使用法: {card['usage']:<19} │")
        print("├" + "─" * 30 + "┤")
        print(f"│ 例:                      │")
        example_lines = card['example'].split('\n')
        for line in example_lines:
            print(f"│ {line:<28} │")
        print("└" + "─" * 30 + "┘")
    
    print("=== Python予約語カードゲーム ===")
    print("ランダムに選ばれた予約語カードを確認しよう！\n")
    
    # ランダムにカードを選択
    selected_cards = random.sample(cards, min(3, len(cards)))
    
    for i, card in enumerate(selected_cards, 1):
        print(f"カード {i}:")
        show_card(card)
        print()

keyword_card_game()

予約語関連のトラブル事例

1. 実際のエラー事例と解決法

def real_world_error_cases():
    """実際のプロジェクトでよくある予約語エラー事例"""
    
    error_cases = [
        {
            "title": "JSON設定ファイルでの予約語キー",
            "problem": """
# 設定ファイル（config.json）
{
    "class": "UserModel",
    "import": "/path/to/module",
    "if": "condition_check"
}

# Pythonコード
with open('config.json') as f:
    config = json.load(f)
    class = config['class']  # エラー！
""",
            "solution": """
# 解決法1: 辞書アクセスを使用
config_class = config['class']

# 解決法2: getattr風のアクセス
class_name = config.get('class')

# 解決法3: 設定ファイル自体を修正
{
    "class_name": "UserModel",
    "import_path": "/path/to/module", 
    "condition": "condition_check"
}
""",
            "lesson": "設定ファイルのキー名も予約語を避ける"
        },
        
        {
            "title": "データベースカラム名での予約語",
            "problem": """
# SQLでテーブル作成
CREATE TABLE users (
    id INT,
    class VARCHAR(50),  -- 'class'は多くのDBで予約語
    from VARCHAR(100)   -- 'from'も予約語
);

# Pythonでアクセス
cursor.execute("SELECT class FROM users")  # エラーの可能性
""",
            "solution": """
# 解決法1: カラム名を変更
CREATE TABLE users (
    id INT,
    user_class VARCHAR(50),
    origin_from VARCHAR(100)
);

# 解決法2: バッククォートを使用（MySQL）
SELECT `class` FROM users;

# 解決法3: ダブルクォートを使用（PostgreSQL）
SELECT "class" FROM users;
""",
            "lesson": "データベース設計時も予約語を考慮する"
        },
        
        {
            "title": "動的属性設定での予約語",
            "problem": """
# オブジェクトに動的に属性を設定
class DynamicObject:
    pass

obj = DynamicObject()
attributes = ['name', 'class', 'type', 'if']

for attr in attributes:
    setattr(obj, attr, f"value_{attr}")
    # 'class', 'if'は予約語だが、setattr()では使える
    # しかし、直接アクセスはできない
    
print(obj.class)  # SyntaxError!
""",
            "solution": """
# 解決法1: getattr()を使用
for attr in attributes:
    setattr(obj, attr, f"value_{attr}")
    value = getattr(obj, attr)
    print(f"{attr}: {value}")

# 解決法2: 属性名を事前に変換
safe_attributes = []
for attr in attributes:
    if keyword.iskeyword(attr):
        safe_attr = f"{attr}_attr"
    else:
        safe_attr = attr
    safe_attributes.append(safe_attr)
    setattr(obj, safe_attr, f"value_{attr}")
""",
            "lesson": "動的属性設定では getattr/setattr を活用"
        }
    ]
    
    print("=== 実際のトラブル事例と解決法 ===")
    for i, case in enumerate(error_cases, 1):
        print(f"\n{i}. {case['title']}")
        print(f"問題:")
        print(case['problem'])
        print(f"\n解決法:")
        print(case['solution'])
        print(f"\n教訓: {case['lesson']}")
        print("=" * 60)

real_world_error_cases()

2. チーム開発での予約語対策

def team_development_strategies():
    """チーム開発での予約語対策"""
    
    strategies = {
        "コードレビューチェックリスト": [
            "変数名・関数名に予約語が使われていないか",
            "設定ファイルのキー名に予約語が含まれていないか", 
            "データベーススキーマで予約語を避けているか",
            "APIのパラメータ名が予約語でないか"
        ],
        
        "自動チェックツール": [
            "flake8やpylintでの構文チェック",
            "カスタムlinterでの予約語検出",
            "pre-commitフックでの自動チェック",
            "CIパイプラインでの継続的チェック"
        ],
        
        "チーム内ルール": [
            "命名規則の文書化と共有",
            "予約語代替案の標準化",
            "新人研修での予約語教育",
            "コードテンプレートでの予約語回避"
        ],
        
        "開発環境設定": [
            "IDEでの予約語ハイライト",
            "オートコンプリートでの予約語警告",
            "カスタムスニペットでの安全な命名",
            "リアルタイムコードチェック"
        ]
    }
    
    print("=== チーム開発での予約語対策 ===")
    for strategy_type, items in strategies.items():
        print(f"\n【{strategy_type}】")
        for item in items:
            print(f"  ✓ {item}")
    
    # サンプルのpre-commitチェック
    print(f"\n=== サンプル: pre-commitチェック関数 ===")
    print("""
def check_keywords_in_file(file_path):
    \"\"\"ファイル内の予約語使用をチェック\"\"\"
    with open(file_path, 'r', encoding='utf-8') as f:
        content = f.read()
    
    # 変数代入のパターンをチェック
    assignment_pattern = r'(\w+)\s*='
    matches = re.findall(assignment_pattern, content)
    
    violations = []
    for match in matches:
        if keyword.iskeyword(match):
            violations.append(f"Line contains keyword assignment: {match}")
    
    return violations
""")

team_development_strategies()

まとめと今後の学習

Python予約語マスターチェックリスト

def create_mastery_checklist():
    """予約語マスタリーのチェックリスト"""
    
    checklist = {
        "基礎知識": [
            "□ Python予約語が何かを理解している",
            "□ keyword.kwlistで予約語一覧を確認できる", 
            "□ keyword.iskeyword()で予約語判定ができる",
            "□ 予約語を変数名に使えない理由を説明できる"
        ],
        
        "実践スキル": [
            "□ 予約語を避けた変数名を考えられる",
            "□ エラーメッセージから予約語問題を特定できる",
            "□ 動的な変数作成で予約語チェックができる",
            "□ 設定ファイルやDBで予約語を避けられる"
        ],
        
        "応用力": [
            "□ チーム開発で予約語ルールを策定できる",
            "□ 自動チェックツールを導入できる",
            "□ コードレビューで予約語問題を指摘できる",
            "□ 予約語関連のバグを素早く修正できる"
        ],
        
        "トラブルシューティング": [
            "□ SyntaxErrorから予約語問題を診断できる",
            "□ 既存コードの予約語問題を発見・修正できる",
            "□ 外部ライブラリとの予約語競合を解決できる",
            "□ 予約語問題の予防策を実装できる"
        ]
    }
    
    print("=== Python予約語マスターチェックリスト ===")
    print("自分の理解度をチェックしてみましょう！\n")
    
    total_items = 0
    for category, items in checklist.items():
        print(f"【{category}】")
        for item in items:
            print(f"  {item}")
            total_items += 1
        print()
    
    print(f"合計チェック項目: {total_items}個")
    print("すべてにチェックが付けられるようになれば、予約語マスターです！")

create_mastery_checklist()

最終まとめ

Pythonの予約語について重要なポイントをまとめます：

🔑 基本知識

• 予約語は言語の構文要素として特別な意味を持つ単語
• 変数名や関数名として使用することはできない
• keyword.kwlistで現在の予約語一覧を確認可能
• keyword.iskeyword()で予約語判定が可能

❌ よくある間違い

• 予約語を変数名として使用
• 設定ファイルのキーに予約語を使用
• データベースのカラム名に予約語を使用
• 動的属性設定での予約語見落とし

✅ 対処法

• 意味のある接尾辞を追加（class → class_name）
• 文脈を含めた命名（if → if_condition）
• getattr/setattr による安全なアクセス
• 事前チェック機能の実装

🛠️ 実践のコツ

• IDEの予約語ハイライト機能を活用
• コードレビューでの予約語チェック
• 自動チェックツールの導入
• チーム内での命名規則統一

📚 さらなる学習

• PEP 8（Pythonスタイルガイド）の学習
• 各Pythonバージョンでの予約語変更の確認
• 他言語の予約語との比較
• 大規模プロジェクトでの命名戦略

これらの知識を活用して、より読みやすく保守しやすいPythonコードを書きましょう！初心者の方は基本的な予約語から覚え始め、段階的に理解を深めていくことをお勧めします。また、実際のプロジェクトでは予約語チェック機能を組み込んで、未然にエラーを防ぐことが重要です。

■プロンプトだけでオリジナルアプリを開発・公開してみた！！

■AI時代の第一歩！「AI駆動開発コース」はじめました！

テックジム東京本校で先行開始。

■テックジム東京本校

「武田塾」のプログラミング版といえば「テックジム」。
講義動画なし、教科書なし。「進捗管理とコーチング」で効率学習。
より早く、より安く、しかも対面型のプログラミングスクールです。

＜短期講習＞5日で5万円の「Pythonミニキャンプ」開催中。

＜月1開催＞放送作家による映像ディレクター養成講座

＜オンライン無料＞ゼロから始めるPython爆速講座