player_name = "Haoran"
player_level = 1
print(f"Player {player_name}'s level is {player_level}")

energy = 100
damage = 25
energy = energy - damage
print(f"Remaining energy: {energy}")

num1 = int(input("Enter first number: "))
num2 = int(input("Enter second number: "))
sum_result = num1 + num2
print(f"{num1} + {num2} = {sum_result}")

num = int(input("Enter a number: "))
if num % 2 == 0:
    print(f"{num} is even")
else:
    print(f"{num} is odd")

steps = 5      # Steps taken / 步数
health = 7     # Health value / 生命值
score = 120    # Current score / 分数

# Maze Game - Variable Initialization / 迷宫游戏 - 变量初始化

# Core variables / 核心变量
steps = 0
energy = 10
initial_energy = 10  # Save initial value for score calculation / 保存初始值，用于计算分数
score = 0

# Print initial state / 打印初始状态
print("=== Game Start / 游戏开始 ===")
print(f"Steps: {steps}")
print(f"Energy: {energy}")
print(f"Score: {score}")

=== Game Start / 游戏开始 ===
Steps: 0
Energy: 10
Score: 0

# Simulate player movement function / 模拟玩家移动的函数
def player_move(hit_wall, hit_monster):
    global steps, energy, score, initial_energy
    
    # 1. Steps always +1 / 步数总是 +1
    steps = steps + 1
    
    # 2. If hit something, energy decreases / 如果撞到东西，能量减少
    if hit_wall or hit_monster:
        energy = energy - 3
    
    # 3. Recalculate score / 重新计算分数
    score = steps + (initial_energy - energy)
    
    # 4. Print current state / 打印当前状态
    print(f"After move -> Steps: {steps}, Energy: {energy}, Score: {score}")

# Initialization / 初始化
steps = 0
energy = 10
initial_energy = 10
score = 0

print("=== Game Start / 游戏开始 ===")
print(f"Steps: {steps}, Energy: {energy}, Score: {score}")

# Move 1: Open space (no collision) / 第一次移动：空地（没有碰撞）
print("\n--- Move 1: Open Space / 移动1：空地 ---")
player_move(hit_wall=False, hit_monster=False)

# Move 2: Hit wall / 第二次移动：撞墙
print("\n--- Move 2: Hit Wall / 移动2：撞墙 ---")
player_move(hit_wall=True, hit_monster=False)

# Move 3: Hit monster / 第三次移动：撞怪物
print("\n--- Move 3: Hit Monster / 移动3：撞怪物 ---")
player_move(hit_wall=False, hit_monster=True)

=== Game Start / 游戏开始 ===
Steps: 0, Energy: 10, Score: 0

--- Move 1: Open Space / 移动1：空地 ---
After move -> Steps: 1, Energy: 10, Score: 1

--- Move 2: Hit Wall / 移动2：撞墙 ---
After move -> Steps: 2, Energy: 7, Score: 5

--- Move 3: Hit Monster / 移动3：撞怪物 ---
After move -> Steps: 3, Energy: 4, Score: 9

steps = 0  # Variable outside function / 函数外部的变量

def move():
    global steps  # Tell Python: I want to modify the outer 'steps' / 告诉Python：我要修改外面的 steps
    steps = steps + 1

move()
print(steps)  # 1

steps = 0

def move():
    steps = steps + 1  # Error! Python thinks you're creating a local variable / 报错！Python 以为你在创建局部变量

move()  # UnboundLocalError

Energy / 能量：20 – 3×3 = 11

Score / 分数：3 + (20 – 11) = 3 + 9 = 12

Formula A / 公式A: Encourages exploring more (the more steps, the better), regardless of energy consumption.
鼓励走得越多越好（探索），不在乎能量消耗。

Formula B / 公式B: Encourages maintaining high energy (avoiding danger), regardless of steps taken.
鼓励保持高能量（躲避危险），不在乎走多少步。

Formula C / 公式C: Encourages balance — you need both many steps AND high energy, which is the most challenging.
鼓励平衡——既要走得多，又要保持能量，难度最大。

"""
Simple Maze Game Simulation
玩家可以输入移动方向，随机决定是否撞墙/怪物
"""

import random

# Initialize variables / 初始化变量
steps = 0
energy = 10
initial_energy = 10
score = 0
game_running = True

print("=== Maze Game / 迷宫游戏 ===")
print("Commands: w up / s down / a left / d right / q quit")
print("命令：w上 s下 a左 d右 q退出")
print(f"Initial state: Steps={steps}, Energy={energy}, Score={score}\n")

while game_running and energy > 0:
    command = input("Enter direction / 输入方向: ").lower()
    
    if command == 'q':
        print("Game over / 游戏结束")
        break
    
    if command not in ['w', 's', 'a', 'd']:
        print("Invalid input, please use w/s/a/d / 无效输入，请用 w/s/a/d")
        continue
    
    # Move: steps increase / 移动：步数增加
    steps += 1
    
    # Randomly decide if hitting something (30% probability)
    # 随机决定是否撞到东西（30% 概率）
    hit_something = random.random() < 0.3
    
    if hit_something:
        energy -= 3
        print("  Hit something! Energy -3 / 撞到东西了！能量 -3")
    else:
        print("  Safe move / 安全移动")
    
    # Recalculate score / 重新计算分数
    score = steps + (initial_energy - energy)
    
    # Display current state / 显示当前状态
    print(f"  Steps: {steps}, Energy: {energy}, Score: {score}\n")
    
    # Check game over conditions / 检查游戏结束条件
    if energy <= 0:
        print("Energy exhausted! Game over / 能量耗尽！游戏结束")
    elif steps >= 20:
        print("Congratulations! You completed 20 steps! / 恭喜！完成了 20 步！")

print(f"\nFinal result / 最终成绩: Steps={steps}, Energy={energy}, Score={score}")

❌ Error 1: Forgetting to update variables

错误1：忘记更新变量

# Wrong / 错误
steps = 0
steps + 1  # This line does nothing! / 这行什么都没做！
print(steps)  # Still 0 / 还是 0

# Correct / 正确
steps = steps + 1

❌ Error 2: Confusing = and ==

错误2：混淆 = 和 ==

# = is assignment / = 是赋值
x = 10  # Put 10 into x / 把 10 放进 x

# == is comparison / == 是比较
if x == 10:  # Judge if x equals 10 / 判断 x 是否等于 10

❌ Error 3: Wrong calculation order

错误3：分数公式写错位置

# Wrong / 错误: Calculate score BEFORE energy change
score = steps + (10 - energy)
energy = energy - 3

# Correct / 正确: Calculate score AFTER energy change
energy = energy - 3
score = steps + (10 - energy)

❌ Error 4: Forgetting global

错误4：忘记 global

steps = 0

def move():
    steps = steps + 1  # Error! Need "global steps" / 错误！需要 global steps

move()  # UnboundLocalError

# Correct / 正确
def move():
    global steps
    steps = steps + 1

health = 100
health -= 30
print(health)

def apply_damage(current_energy, damage):
    new_energy = current_energy - damage
    if new_energy < 0:
        return 0
    return new_energy

import random

steps = 0
energy = 10

while energy > 0:
    steps += 1
    if random.random() < 0.5:
        energy -= 3
        print(f"Step {steps}: Hit something, energy={energy}")
    else:
        print(f"Step {steps}: Safe, energy={energy}")

if condition:
    # Code to execute when condition is true
    # 条件成立时执行的代码

energy = 5

if energy <= 0:
    print("Game Over / 游戏结束")

# = is assignment, puts right value into left variable / = 是赋值，把右边的值放入左边的变量
x = 10

# == is comparison, checks if left and right are equal / == 是比较，判断左右两边是否相等
if x == 10:
    print("x equals 10 / x 等于 10")

# Most common mistake / 最容易犯的错误：
if x = 10:   # Wrong! This is assignment, not comparison / 错误！这是赋值，不是比较

energy = 10

if energy <= 0:
    print("Game Over / 游戏结束")
else:
    print(f"Game continues, {energy} energy left")
    print(f"游戏继续，还剩 {energy} 能量")

score = 85

if score >= 90:
    print("Excellent / 优秀")
elif score >= 70:
    print("Good / 良好")
elif score >= 60:
    print("Pass / 及格")
else:
    print("Fail / 不及格")
# Output: Good / 良好

# Wrong order / 错误顺序
score = 85
if score >= 60:
    print("Pass / 及格")      # This will execute
elif score >= 70:
    print("Good / 良好")      # Never executes
elif score >= 90:
    print("Excellent / 优秀") # Never executes

# Correct order / 正确做法：put strictest conditions first / 把最严格的条件放在最前面
if score >= 90:
    print("Excellent / 优秀")
elif score >= 70:
    print("Good / 良好")
elif score >= 60:
    print("Pass / 及格")

energy = 15
has_key = True

if energy >= 10 and has_key:
    print("You can open the door / 可以打开大门")

key_pressed = "SPACE"
is_jumping = False

if key_pressed == "SPACE" or is_jumping:
    print("Perform jump / 执行跳跃动作")

has_revive_potion = False
has_checkpoint = True

if has_revive_potion or has_checkpoint:
    print("Can revive / 可以复活")
else:
    print("Game permanently over / 游戏永久结束")
# Output: Can revive / 可以复活 (because has_checkpoint is True)

def handle_key_press(keyCode, current_energy):
    """
    Handle keyboard key press event
    处理键盘按键事件
    """
    
    # Direction keys or WASD movement / 方向键或 WASD 移动
    if keyCode == "LEFT" or keyCode == "A":
        print("Move left / 向左移动")
        return current_energy
    
    elif keyCode == "RIGHT" or keyCode == "D":
        print("Move right / 向右移动")
        return current_energy
    
    elif keyCode == "UP" or keyCode == "W":
        print("Move up / 向上移动")
        return current_energy
    
    elif keyCode == "DOWN" or keyCode == "S":
        print("Move down / 向下移动")
        return current_energy
    
    # SPACE key: special function (random teleport) / 空格键：特殊功能（随机传送）
    elif keyCode == "SPACE":
        if current_energy >= 20:
            print("Random teleport! Consume 15 energy / 随机传送！消耗 15 能量")
            return current_energy - 15
        else:
            print(f"Not enough energy! Need 20, have {current_energy}")
            print(f"能量不足！需要 20，当前 {current_energy}")
            return current_energy
    
    # Other keys / 其他按键
    else:
        print(f"Invalid key: {keyCode} / 无效按键: {keyCode}")
        return current_energy

Line 1 → Line 2 → Line 3 → ... → End

Wait for player key press → Handle → Wait for next event → Handle → ...

Game start
Display maze

Loop (repeat forever):
    Wait for player key press
    Handle the key (move/teleport/etc.)
    Check if victory or defeat
    Update screen display

Game over

def handle_key(keyCode, energy, steps, score):
    if keyCode == "H":
        print("Help: Use arrow keys to move, avoid monsters, collect energy")
        print("帮助：用方向键移动，避开怪物，收集能量")
        return True  # Game continues / 游戏继续
    
    elif keyCode == "I":
        # Complete this section / 请补全：显示玩家信息
        ____________________
        return True
    
    elif keyCode == "Q":
        print("Quit game / 退出游戏")
        return False  # Game over / 游戏结束
    
    else:
        return True

def check_position(player_x, player_y, monster_positions, energy_positions, exit_x, exit_y):
    """
    Check player's current position
    检查玩家当前位置
    Returns: event string / 返回：发生的事件（字符串）
    """
    
    # 1. Check if hit monster / 检查是否碰到怪物
    for monster in monster_positions:
        if player_x == monster[0] and player_y == monster[1]:
            return "MONSTER"
    
    # 2. Complete: check if hit energy pickup (energy_positions has same format)
    # 请补全：检查是否碰到能量块（energy_positions 格式相同）
    ____________________
    
    # 3. Complete: check if reached exit / 请补全：检查是否到达出口
    ____________________
    
    return "NOTHING"

def handle_collision(event, current_energy, current_score):
    """
    Update game state based on collision event
    根据碰撞事件，更新游戏状态
    Returns: (new_energy, new_score, game_continues) / 返回：(新能量, 新分数, 游戏是否继续)
    """
    
    if event == "MONSTER":
        new_energy = current_energy - 3
        print("You hit a monster! Energy -3 / 你撞到了怪物！能量 -3")
        return new_energy, current_score, True
    
    elif event == "ENERGY":
        # Complete this section: energy +5, print message / 请补全：能量 +5，打印消息
        ____________________
    
    elif event == "EXIT":
        print("You reached the exit! Victory! / 你到达了出口！胜利！")
        return current_energy, current_score, False  # Game over / 游戏结束
    
    else:
        return current_energy, current_score, True

"""
A simple text maze game
一个简单的文字迷宫游戏
Use conditional statements to handle different inputs and events
用条件语句处理不同的输入和事件
"""

import random

# Game state / 游戏状态
player_x = 0
player_y = 0
energy = 10
steps = 0
has_key = False

# Exit position / 出口位置
exit_x = 4
exit_y = 4

# Game running flag / 游戏是否继续
game_running = True

def show_status():
    """Display current status / 显示当前状态"""
    print(f"\nPosition / 位置: ({player_x}, {player_y})")
    print(f"Energy / 能量: {energy} | Steps / 步数: {steps} | Key / 钥匙: {'Yes / 有' if has_key else 'No / 无'}")

def check_position():
    """Check current position, return event / 检查当前位置，返回发生的事件"""
    # Check exit (need key) / 检查出口（需要钥匙）
    if player_x == exit_x and player_y == exit_y:
        if has_key:
            return "EXIT_WITH_KEY"
        else:
            return "EXIT_LOCKED"
    
    # Random events (simplified: random positions may have monsters or energy)
    # 随机事件（简化版：随机位置可能有怪物或能量）
    event_roll = random.random()
    
    if event_roll < 0.2:  # 20% chance to encounter monster / 20% 概率遇到怪物
        return "MONSTER"
    elif event_roll < 0.3:  # 10% chance to encounter energy / 10% 概率遇到能量
        return "ENERGY"
    elif event_roll < 0.35:  # 5% chance to find key / 5% 概率找到钥匙
        return "KEY"
    else:
        return "NOTHING"

def handle_move(direction):
    global player_x, player_y, steps, energy, game_running, has_key
    
    # Record coordinates before move / 记录移动前的坐标
    old_x, old_y = player_x, player_y
    
    # Move according to direction / 根据方向移动
    if direction == "w":
        player_y += 1
    elif direction == "s":
        player_y -= 1
    elif direction == "a":
        player_x -= 1
    elif direction == "d":
        player_x += 1
    else:
        print("Invalid direction! Use w/a/s/d / 无效方向！请用 w/a/s/d")
        return
    
    # Boundary check (0-4 range) / 边界检查（0-4 范围）
    if player_x < 0 or player_x > 4 or player_y < 0 or player_y > 4:
        print("Hit the wall! Cannot go beyond boundary / 撞墙了！不能走出边界")
        player_x, player_y = old_x, old_y
        energy -= 1
        print(f"Energy -1, remaining {energy} / 能量 -1，剩余 {energy}")
        steps += 1
        return
    
    # Valid move / 有效移动
    steps += 1
    print(f"Moved to ({player_x}, {player_y}) / 移动到了 ({player_x}, {player_y})")
    
    # Check position event / 检查位置事件
    event = check_position()
    
    if event == "MONSTER":
        energy -= 3
        print("You encountered a monster! Energy -3 / 你遇到了怪物！能量 -3")
    elif event == "ENERGY":
        energy += 5
        print("You found an energy crystal! Energy +5 / 你发现了能量水晶！能量 +5")
    elif event == "KEY":
        has_key = True
        print("You found a key! / 你找到了一把钥匙！")
    elif event == "EXIT_LOCKED":
        print("The exit is locked! You need a key / 出口被锁住了！你需要一把钥匙")
    elif event == "EXIT_WITH_KEY":
        print("You opened the exit with the key! Victory! / 你用钥匙打开了出口！胜利！")
        game_running = False
        return
    
    # Check game over / 检查游戏结束
    if energy <= 0:
        print("Energy exhausted! Game over / 能量耗尽！游戏结束")
        game_running = False

def show_help():
    print("\n=== Game Instructions / 游戏说明 ===")
    print("w: up / 向上  s: down / 向下  a: left / 向左  d: right / 向右")
    print("h: show help / 显示帮助  q: quit / 退出")
    print("Goal: Reach (4,4) and find the key / 目标是到达 (4,4) 并找到钥匙")

# Main game loop / 主游戏循环
print("=== Text Maze Game / 文字迷宫游戏 ===")
show_help()

while game_running:
    show_status()
    
    command = input("\nEnter command / 输入命令: ").lower()
    
    if command == 'q':
        print("Game over / 游戏结束")
        break
    elif command == 'h':
        show_help()
    elif command in ['w', 's', 'a', 'd']:
        handle_move(command)
    else:
        print("Invalid command, press h for help / 无效命令，按 h 查看帮助")

print(f"\nFinal result / 最终成绩: Steps={steps}, Energy={energy}")

❌ Error 1: Indentation Error / 缩进错误

# Wrong / 错误：缩进不一致
if energy > 0:
print("Game continues")   # Should be indented / 应该缩进

# Correct / 正确
if energy > 0:
    print("Game continues")

❌ Error 2: Missing Colon / 忘记冒号

# Wrong / 错误
if energy > 0    # Missing colon / 缺少冒号
    print("Game continues")

# Correct / 正确
if energy > 0:
    print("Game continues")

❌ Error 3: Using = instead of == / 用 = 代替 ==

# Wrong / 错误 (doesn't cause error but logic is wrong / 不会报错，但逻辑错误)
if energy = 0:    # This is assignment, not comparison / 这是赋值，不是比较
    print("Energy is zero")

# Correct / 正确
if energy == 0:
    print("Energy is zero")

❌ Error 4: Wrong Condition Order / 条件顺序不当

score = 85

# Wrong / 错误：所有分数都会进入第一个条件
if score >= 60:
    print("Pass / 及格")
elif score >= 70:
    print("Good / 良好")   # Never executes / 永远不会执行

# Correct / 正确：从高到低排列
if score >= 90:
    print("Excellent / 优秀")
elif score >= 70:
    print("Good / 良好")
elif score >= 60:
    print("Pass / 及格")

if num > 0:
    print("Positive / 正数")
elif num < 0:
    print("Negative / 负数")
else:
    print("Zero / 零")

if energy >= 20 and has_potion:
    print("Can use ultimate / 可以使用大招")

if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print("Leap year / 闰年")
else:
    print("Common year / 平年")

def get_grade(score):
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    elif score >= 60:
        return "D"
    else:
        return "F"

def can_teleport(energy, has_teleport_item, is_special_zone):
    if energy >= 20 or has_teleport_item or is_special_zone:
        return True
    else:
        return False

# More concise / 更简洁的写法
def can_teleport(energy, has_teleport_item, is_special_zone):
    return energy >= 20 or has_teleport_item or is_special_zone

# Stop when finding the first even number / 找到第一个偶数就停止
numbers = [1, 3, 5, 6, 7, 9]

for num in numbers:
    if num % 2 == 0:
        print(f"Found first even number: {num} / 找到第一个偶数: {num}")
        break  # Exit the loop / 跳出循环

Found first even number: 6 / 找到第一个偶数: 6

# Print only odd numbers / 只打印奇数
for num in range(1, 11):
    if num % 2 == 0:
        continue  # Skip even numbers / 跳过偶数
    print(num)

1
3
5
7
9

# Task: Calculate the sum of 1 to 100 / 计算 1 到 100 的和
# Complete the code / 请补全代码

total = 0
for i in range(1, 101):
    ________________  # Accumulate / 累加

print(f"Sum of 1 to 100 is: {total} / 1 到 100 的和是: {total}")

# Task: Countdown from 10 to 1, then print "Blast off!"
# 任务：从 10 开始倒计时到 1，然后打印 "发射！"
# Complete the code / 请补全代码

count = 10
while ________________:
    print(count)
    ________________

print("Blast off! / 发射！")

# Task: Print all numbers greater than 5 in the list
# 任务：打印列表中所有大于 5 的数字
numbers = [3, 8, 2, 10, 4, 7, 1]

for num in numbers:
    if ________________:
        print(num)

# Without functions (repeating code) / 没有函数的方式（重复代码）
a1, b1 = 10, 20
avg1 = (a1 + b1) / 2
print(avg1)

a2, b2 = 15, 25
avg2 = (a2 + b2) / 2
print(avg2)

a3, b3 = 30, 40
avg3 = (a3 + b3) / 2
print(avg3)

# With functions (reusable code) / 有函数的方式（复用代码）
def average(x, y):
    return (x + y) / 2

print(average(10, 20))
print(average(15, 25))
print(average(30, 40))

def function_name(parameter1, parameter2, ...):
    # Function body / 函数体
    return return_value

def say_hello():
    print("Hello!")

# Call the function / 调用函数
say_hello()

Hello!

def greet(name):
    print(f"Hello, {name}!")

greet("Haoran")
greet("Alice")

Hello, Haoran!
Hello, Alice!

def add(a, b):
    return a + b

result = add(5, 3)
print(result)  # 8

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Haoran")           # Hello, Haoran!
greet("Haoran", "Hi")     # Hi, Haoran!

def check_energy(energy):
    if energy <= 0:
        return "Game Over / 游戏结束"
    return "Game continues / 游戏继续"
    
    # This line will never execute / 这行永远不会执行
    print("This won't print / 这行不会打印")

result = check_energy(5)
print(result)  # Game continues / 游戏继续

result = check_energy(0)
print(result)  # Game Over / 游戏结束

def say_hello(name):
    print(f"Hello {name}")

result = say_hello("Haoran")
print(result)  # None

def my_function():
    x = 10  # Local variable / 局部变量
    print(x)

my_function()
# print(x)  # Error! x doesn't exist here / 错误！x 在这里不存在

player_name = "Haoran"  # Global variable / 全局变量

def show_name():
    print(player_name)  # Can read / 可以读取

show_name()  # Haoran

energy = 10  # Global variable / 全局变量

def take_damage(amount):
    global energy  # Tell Python to modify global variable / 告诉 Python 要修改全局变量
    energy = energy - amount

take_damage(3)
print(energy)  # 7

energy = 10

def take_damage(amount):
    energy = energy - amount  # Error! Creates local variable / 错误！会创建局部变量

take_damage(3)  # UnboundLocalError

def is_even(number):
    """Check if a number is even / 判断一个数是否是偶数"""
    return number % 2 == 0

print(is_even(4))   # True
print(is_even(7))   # False

def check_game_over(energy, steps, target_score):
    """Check if game is over, return (is_over, reason)
    检查游戏是否结束，返回 (是否结束, 原因)"""
    if energy <= 0:
        return True, "Energy exhausted / 能量耗尽"
    elif steps >= 100:
        return True, "Max steps reached / 步数上限达到"
    elif target_score >= 100:
        return True, "Target score reached / 达到目标分数"
    else:
        return False, "Game continues / 游戏继续"

def update_score(steps, energy, initial_energy):
    """Calculate score based on steps and energy
    根据步数和能量计算分数"""
    return steps + (initial_energy - energy)

# Problem: Find and print all even numbers in a list
# 问题：找出列表中所有偶数并打印

def is_even(num):
    return num % 2 == 0

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

for num in numbers:
    if is_even(num):
        print(f"{num} is even / {num} 是偶数")

def double(x):
    return x * 2

def square(x):
    return x ** 2

numbers = [1, 2, 3, 4, 5]

# Calculate double of each number / 计算每个数的两倍
print("Doubles / 两倍:")
for num in numbers:
    print(double(num))

# Calculate square of each number / 计算每个数的平方
print("Squares / 平方:")
for num in numbers:
    print(square(num))

# Task: Write a function celsius_to_fahrenheit(celsius)
# 任务：写一个函数 celsius_to_fahrenheit(celsius)
# Formula: Fahrenheit = Celsius × 9/5 + 32 / 公式：华氏 = 摄氏 × 9/5 + 32
# Test: 0°C = 32°F, 100°C = 212°F

def celsius_to_fahrenheit(celsius):
    ________________

# Test / 测试
print(celsius_to_fahrenheit(0))   # Should output 32 / 应该输出 32
print(celsius_to_fahrenheit(100)) # Should output 212 / 应该输出 212

# Task: Find all prime numbers between 1 and 50
# 任务：找出 1 到 50 之间所有的质数
# First use a function to check if a number is prime
# 先用函数判断一个数是否是质数
# Then loop through 1 to 50 / 再用循环遍历 1 到 50

def is_prime(n):
    """Check if n is prime (only divisible by 1 and itself)
    判断 n 是否是质数（只能被 1 和自身整除）"""
    if n < 2:
        return False
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

# Complete: print all prime numbers from 1 to 50
# 请补全：打印 1 到 50 中所有的质数
for num in range(1, 51):
    if ________________:
        print(num)

"""
Maze game core logic using loops and functions
使用循环和函数构建迷宫游戏的核心逻辑
"""

import random

# ========== Function Definitions / 函数定义 ==========

def init_game():
    """Initialize game state / 初始化游戏状态"""
    return {
        "steps": 0,
        "energy": 10,
        "initial_energy": 10,
        "score": 0,
        "game_over": False,
        "win": False
    }

def calculate_score(steps, energy, initial_energy):
    """Calculate current score / 计算当前分数"""
    return steps + (initial_energy - energy)

def apply_move(game_state, hit_wall, hit_monster):
    """Apply a move effect / 应用一次移动的效果"""
    game_state["steps"] += 1
    
    if hit_wall or hit_monster:
        game_state["energy"] -= 3
    
    game_state["score"] = calculate_score(
        game_state["steps"],
        game_state["energy"],
        game_state["initial_energy"]
    )
    
    # Check game over conditions / 检查游戏结束条件
    if game_state["energy"] <= 0:
        game_state["game_over"] = True
        return "Energy exhausted! Game over / 能量耗尽！游戏结束"
    
    return None

def simulate_random_moves(game_state, num_moves):
    """Simulate multiple random moves / 随机模拟多次移动"""
    results = []
    
    for i in range(num_moves):
        # Randomly decide if hitting something (30% chance)
        hit_wall = random.random() < 0.3
        hit_monster = random.random() < 0.2
        
        result = apply_move(game_state, hit_wall, hit_monster)
        
        results.append({
            "move": i + 1,
            "steps": game_state["steps"],
            "energy": game_state["energy"],
            "score": game_state["score"]
        })
        
        if game_state["game_over"]:
            break
    
    return results

def print_move_history(history):
    """Print move history / 打印移动历史"""
    print("\n=== Move History / 移动记录 ===")
    print("Move | Steps | Energy | Score")
    print("移动 | 步数 | 能量 | 分数")
    print("-----|-------|--------|-------")
    for record in history:
        print(f"  {record['move']}   |   {record['steps']}   |   {record['energy']}   |   {record['score']}")

# ========== Main Program / 主程序 ==========

# Initialize game / 初始化游戏
game = init_game()
print("=== Game Start / 游戏开始 ===")
print(f"Initial state: Steps={game['steps']}, Energy={game['energy']}, Score={game['score']}")
print(f"初始状态: 步数={game['steps']}, 能量={game['energy']}, 分数={game['score']}")

# Simulate 10 moves / 模拟 10 次移动
print("\nSimulating 10 moves... / 模拟 10 次移动...")
history = simulate_random_moves(game, 10)

# Display results / 显示结果
print_move_history(history)

if game["game_over"]:
    print(f"\nGame over! Final: Steps={game['steps']}, Energy={game['energy']}, Score={game['score']}")
    print(f"游戏结束！最终步数={game['steps']}, 能量={game['energy']}, 分数={game['score']}")
else:
    print(f"\nSimulation complete! Current: Steps={game['steps']}, Energy={game['energy']}, Score={game['score']}")
    print(f"模拟完成！当前步数={game['steps']}, 能量={game['energy']}, 分数={game['score']}")

numbers = [10, 20, 30, 40, 50]

print(len(numbers))     # 5
print(sum(numbers))     # 150
print(max(numbers))     # 50
print(min(numbers))     # 10

❌ Error 1: Forgetting to call the function (writing function name without parentheses)

错误1：忘记调用函数（只写了函数名）

def say_hello():
    print("Hello")

say_hello  # Wrong: no parentheses, won't execute / 错误：没有括号，不会执行
say_hello()  # Correct / 正确

❌ Error 2: Function definition after call

错误2：函数定义在前，调用在后

# Wrong: call before definition / 错误：调用在定义之前
greet()  # NameError

def greet():
    print("Hello")

# Correct: define first, then call / 正确：先定义后调用
def greet():
    print("Hello")

greet()

❌ Error 3: Return value not used

错误3：返回值没有被使用

def add(a, b):
    return a + b

add(5, 3)  # Calculates 8 but not saved / 计算了 8，但没有保存
print(add(5, 3))  # Correct: print return value / 正确：打印返回值
result = add(5, 3)  # Correct: save to variable / 正确：保存到变量

❌ Error 4: Infinite loop

错误4：无限循环

# Wrong: condition never becomes False / 错误：条件永远为 True
i = 0
while i < 10:
    print(i)
    # Forgot i += 1, infinite loop / 忘记 i += 1，永远循环

# Correct / 正确
i = 0
while i < 10:
    print(i)
    i += 1

for i in range(1, 21, 2):
    print(i)

i = 1
while i <= 10:
    print(f"5 × {i} = {5 * i}")
    i += 1

def max_of_two(a, b):
    if a > b:
        return a
    else:
        return b

numbers = [15, 22, 8, 19, 31, 7]
max_num = numbers[0]

for num in numbers:
    if num > max_num:
        max_num = num

print(max_num)  # 31

def is_palindrome(word):
    # Method 1: Compare with reversed string / 方法1：比较原字符串和反转后的字符串
    return word == word[::-1]

# Test / 测试
print(is_palindrome("radar"))   # True
print(is_palindrome("hello"))   # False

def count_vowels(text):
    vowels = "aeiouAEIOU"
    count = 0
    for char in text:
        if char in vowels:
            count += 1
    return count

print(count_vowels("Hello World"))  # 3 (e, o, o)

# Task: Perform the following operations / 对列表进行以下操作
animals = ["cat", "dog", "bird"]

# 1. Add "fish" to the end / 在末尾添加 "fish"
________________

# 2. Insert "rabbit" at index 1 / 在索引 1 的位置插入 "rabbit"
________________

# 3. Remove "bird" / 删除 "bird"
________________

# 4. Print the final list / 打印最终列表
print(animals)

# Task: Find all numbers greater than 10 in the list
# 任务：找出列表中所有大于 10 的数字，存入新列表
numbers = [5, 12, 3, 18, 7, 20, 4]
large_numbers = []

for num in numbers:
    if ________________:
        ________________

print(large_numbers)  # Should output [12, 18, 20] / 应该输出 [12, 18, 20]

# Simple inventory system using lists / 用列表实现简单的物品栏系统

inventory = []

def show_inventory():
    """Display inventory / 显示物品栏"""
    if len(inventory) == 0:
        print("Inventory is empty / 物品栏是空的")
    else:
        print("=== Inventory / 物品栏 ===")
        for i, item in enumerate(inventory):
            print(f"{i+1}. {item}")

def add_item(item):
    """Add item / 添加物品"""
    inventory.append(item)
    print(f"Obtained: {item} / 获得: {item}")

def remove_item(item):
    """Remove item / 移除物品"""
    if item in inventory:
        inventory.remove(item)
        print(f"Used: {item} / 使用: {item}")
    else:
        print(f"No {item} / 没有 {item}")

def use_item(index):
    """Use item at position / 使用指定位置的物品"""
    if 0 <= index < len(inventory):
        item = inventory.pop(index)
        print(f"Used: {item} / 使用: {item}")
    else:
        print("Invalid index / 无效的索引")

# Test / 测试
add_item("Key / 钥匙")
add_item("Potion / 药水")
add_item("Sword / 宝剑")
show_inventory()

remove_item("Potion / 药水")
show_inventory()

use_item(0)
show_inventory()

# Store animals and their sounds / 存储动物和叫声
animals = ["Lion", "Frog", "Cat", "Dog", "Bird", "Mouse", "Horse", "Elephant", "Pig", "Cow"]
sounds = ["Roar", "Croak", "Meow", "Bark", "Chirp", "Squeak", "Neigh", "Trumpet", "Oink", "Moo"]

def get_player_message(player_number):
    """
    Return personalized welcome message based on player number (0-9)
    根据玩家编号（0-9）返回个性化欢迎消息
    """
    if player_number < 0 or player_number >= len(animals):
        return "Invalid player number / 无效的玩家编号"
    
    animal = animals[player_number]
    sound = sounds[player_number]
    
    return f"Welcome {animal} Person! Give me a {sound}!"
    return f"欢迎 {animal} 勇士！发出 {sound} 的声音！"

# Test / 测试
for i in range(5):
    print(f"Player {i}: {get_player_message(i)}")

# 2D list representing a maze map / 用二维列表表示迷宫地图
# 0 = empty path / 空地, 1 = wall / 墙, 2 = player / 玩家, 3 = exit / 出口

maze = [
    [0, 0, 0, 1, 0],
    [0, 1, 0, 1, 0],
    [0, 0, 0, 0, 0],
    [1, 1, 0, 1, 0],
    [0, 0, 0, 0, 3]
]

def print_maze(maze):
    """Print the maze / 打印迷宫"""
    for row in maze:
        for cell in row:
            if cell == 0:
                print("·", end=" ")
            elif cell == 1:
                print("█", end=" ")
            elif cell == 2:
                print("P", end=" ")
            elif cell == 3:
                print("E", end=" ")
        print()  # New line / 换行

def find_player(maze):
    """Find player position / 找到玩家的位置"""
    for y in range(len(maze)):
        for x in range(len(maze[y])):
            if maze[y][x] == 2:
                return x, y
    return None

def find_exit(maze):
    """Find exit position / 找到出口的位置"""
    for y in range(len(maze)):
        for x in range(len(maze[y])):
            if maze[y][x] == 3:
                return x, y
    return None

print("=== Maze / 迷宫 ===")
print_maze(maze)

# Place player at start / 把玩家放到起点
maze[0][0] = 2

print("\n=== Player Position / 玩家位置 ===")
print_maze(maze)

player_pos = find_player(maze)
exit_pos = find_exit(maze)

print(f"\nPlayer position / 玩家位置: {player_pos}")
print(f"Exit position / 出口位置: {exit_pos}")

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

# Get indices 2 to 5 (not including 5) / 获取索引 2 到 5（不包括 5）
print(numbers[2:5])   # [2, 3, 4]

# From start to index 5 / 从开头到索引 5
print(numbers[:5])    # [0, 1, 2, 3, 4]

# From index 5 to end / 从索引 5 到结尾
print(numbers[5:])    # [5, 6, 7, 8, 9]

# Copy entire list / 复制整个列表
copy = numbers[:]
print(copy)           # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Step (take every 2nd) / 步长（每 2 个取一个）
print(numbers[::2])   # [0, 2, 4, 6, 8]

# Reverse / 反转
print(numbers[::-1])  # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# Traditional way / 传统方式
squares = []
for i in range(10):
    squares.append(i ** 2)
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# List comprehension (one line) / 列表推导式（一行搞定）
squares = [i ** 2 for i in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# With condition / 带条件的列表推导式
even_squares = [i ** 2 for i in range(10) if i % 2 == 0]
print(even_squares)  # [0, 4, 16, 36, 64]

❌ Error 1: Index Out of Range / 索引越界（IndexError）

fruits = ["apple", "banana"]
print(fruits[2])  # IndexError: list index out of range

✓ Solution / 解决：确保索引小于列表长度

if index < len(fruits):
    print(fruits[index])

❌ Error 2: Removing Items While Iterating

错误2：遍历时删除元素

# Wrong - skips elements / 错误（会跳过元素）
numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num % 2 == 0:
        numbers.remove(num)  # Modifying list while iterating is problematic

# Correct - create new list / 正确：创建新列表
numbers = [1, 2, 3, 4, 5]
odds = [num for num in numbers if num % 2 != 0]

numbers = [10, 20, 30, 40, 50]
print(numbers[2])      # 30
numbers[1] = 25
numbers.append(60)
print(numbers)         # [10, 25, 30, 40, 50, 60]

numbers = [5, 2, 8, 1, 9, 3]
max_num = numbers[0]
min_num = numbers[0]

for num in numbers:
    if num > max_num:
        max_num = num
    if num < min_num:
        min_num = num

print(f"Max: {max_num}, Min: {min_num}")  # Max: 9, Min: 1

def reverse_list(my_list):
    reversed_list = []
    for i in range(len(my_list) - 1, -1, -1):
        reversed_list.append(my_list[i])
    return reversed_list

print(reverse_list([1, 2, 3, 4]))  # [4, 3, 2, 1]

def remove_duplicates(my_list):
    result = []
    for item in my_list:
        if item not in result:
            result.append(item)
    return result

print(remove_duplicates([1, 2, 2, 3, 3, 3, 4]))  # [1, 2, 3, 4]

todos = []

while True:
    print("\n=== Todo List / 待办事项 ===")
    print("1. Add task / 添加任务")
    print("2. View tasks / 查看任务")
    print("3. Complete task / 完成任务")
    print("4. Exit / 退出")
    
    choice = input("Choose / 选择: ")
    
    if choice == "1":
        task = input("Enter task / 输入任务: ")
        todos.append(task)
        print(f"Added: {task} / 已添加: {task}")
    
    elif choice == "2":
        if len(todos) == 0:
            print("No tasks / 暂无任务")
        else:
            for i, task in enumerate(todos):
                print(f"{i+1}. {task}")
    
    elif choice == "3":
        if len(todos) == 0:
            print("No tasks / 暂无任务")
        else:
            for i, task in enumerate(todos):
                print(f"{i+1}. {task}")
            num = int(input("Complete which one? / 完成第几个？")) - 1
            if 0 <= num < len(todos):
                removed = todos.pop(num)
                print(f"Completed: {removed} / 已完成: {removed}")
            else:
                print("Invalid / 无效")
    
    elif choice == "4":
        print("Goodbye! / 再见！")
        break
    
    else:
        print("Invalid choice / 无效选择")

import csv  # 1. Import csv module / 导入 csv 模块

# 2. Open file / 打开文件
with open("playerCustomisation.csv", "r") as file:
    # 3. Create reader / 创建读取器
    reader = csv.reader(file)
    
    # 4. Read header (first row) / 读取表头（第一行）
    header = next(reader)
    
    # 5. Iterate through data rows / 遍历数据行
    for row in reader:
        print(row)  # Each row is a list / 每行是一个列表

import csv

# Open and read CSV file / 打开并读取 CSV 文件
with open("playerCustomisation.csv", "r") as file:
    reader = csv.reader(file)
    
    # Read header / 读取表头
    header = next(reader)
    print("Header / 表头:", header)
    
    # Read all data rows / 读取所有数据行
    print("\nData rows / 数据行:")
    for row in reader:
        print(row)

import csv

def load_player_config(file_name, target_player_number):
    """
    Load player configuration from CSV file
    从 CSV 文件中加载指定玩家的配置
    Parameters / 参数:
        file_name: CSV file name / CSV 文件名
        target_player_number: player number to find / 要查找的玩家编号
    Returns / 返回:
        Dictionary with player config, or None if not found
        包含玩家配置的字典，如果没找到返回 None
    """
    with open(file_name, "r") as file:
        reader = csv.reader(file)
        
        # Read header / 读取表头
        header = next(reader)
        
        # Find column indices / 找到各列的索引
        player_idx = header.index("PlayerNumber")
        width_idx = header.index("Width")
        height_idx = header.index("Height")
        monster_idx = header.index("MonsterCount")
        wall_idx = header.index("WallCount")
        energy_idx = header.index("Energy")
        animal_idx = header.index("Animal")
        sound_idx = header.index("Sound")
        
        # Iterate through data rows to find matching player
        # 遍历数据行，查找匹配的玩家
        for row in reader:
            if row[player_idx] == str(target_player_number):
                # Store data in dictionary / 把数据存入字典
                config = {
                    "player_number": int(row[player_idx]),
                    "width": int(row[width_idx]),
                    "height": int(row[height_idx]),
                    "monster_count": int(row[monster_idx]),
                    "wall_count": int(row[wall_idx]),
                    "energy": int(row[energy_idx]),
                    "animal": row[animal_idx],
                    "sound": row[sound_idx]
                }
                return config
        
        # Not found / 没找到
        return None

# Usage example / 使用示例
config = load_player_config("playerCustomisation.csv", 0)

if config:
    print("=== Player Configuration / 玩家配置 ===")
    print(f"Player Number / 玩家编号: {config['player_number']}")
    print(f"Maze Size / 迷宫大小: {config['width']} x {config['height']}")
    print(f"Monster Count / 怪物数量: {config['monster_count']}")
    print(f"Wall Count / 墙数量: {config['wall_count']}")
    print(f"Initial Energy / 初始能量: {config['energy']}")
    print(f"Animal / 动物: {config['animal']}")
    print(f"Sound / 叫声: {config['sound']}")
    
    message = f"Welcome {config['animal']} Person! Give me a {config['sound']}!"
    print(f"\n{message}")
else:
    print("Player not found / 未找到该玩家的配置")

header = ["PlayerNumber", "Width", "Height", "Energy"]

print(header.index("PlayerNumber"))  # 0
print(header.index("Width"))         # 1
print(header.index("Height"))        # 2
print(header.index("Energy"))        # 3

header = ["ID", "Name", "Score", "Level"]

print(header.index("Name"))   # ?
print(header.index("Level"))  # ?
print(header.index("ID"))     # ?

row = ["0", "20", "15", "10"]  # All are strings / 都是字符串

# Convert when needed / 需要时转换为数字
player_number = int(row[0])    # 0 (integer / 整数)
width = int(row[1])            # 20 (integer / 整数)

import csv

# Data to write / 要写入的数据
data = [
    ["PlayerNumber", "Name", "Score"],  # Header / 表头
    [1, "Alice", 100],
    [2, "Bob", 85],
    [3, "Charlie", 92]
]

# Write to CSV file / 写入 CSV 文件
with open("scores.csv", "w", newline="") as file:
    writer = csv.writer(file)
    
    # Write multiple rows / 写入多行
    writer.writerows(data)

print("File saved / 文件已保存")

# Append one row to the end of the file / 追加一行到文件末尾
with open("scores.csv", "a", newline="") as file:
    writer = csv.writer(file)
    writer.writerow([4, "David", 78])

# list is a class / 列表是一个类（list）
# [1, 2, 3] is a list object / [1, 2, 3] 是一个列表对象
my_list = [1, 2, 3]  # my_list is an object of the list class

# str is a class / 字符串是一个类（str）
# "Hello" is a string object / "Hello" 是一个字符串对象
my_string = "Hello"  # my_string is an object of the str class

# csv.reader() returns an object / csv.reader() 返回的是一个对象
reader = csv.reader(file)  # reader is an object of the reader class

# Define a Player class / 定义一个 Player 类
class Player:
    def __init__(self, name, energy):
        self.name = name      # Attribute / 属性
        self.energy = energy  # Attribute / 属性
    
    def move(self):
        self.energy -= 1
        print(f"{self.name} moved, energy left: {self.energy}")
        print(f"{self.name} 移动了，能量剩 {self.energy}")
    
    def show_status(self):
        print(f"Player: {self.name}, Energy: {self.energy}")
        print(f"玩家: {self.name}, 能量: {self.energy}")

# Create Player objects (instances) / 创建 Player 类的对象（实例）
player1 = Player("Haoran", 10)
player2 = Player("Alice", 15)

# Call object methods / 调用对象的方法
player1.show_status()  # Player: Haoran, Energy: 10
player2.show_status()  # Player: Alice, Energy: 15

player1.move()         # Haoran moved, energy left: 9
player1.move()         # Haoran moved, energy left: 8

"""
Project: Player Configuration Loader
项目：玩家配置加载器
Features / 功能:
1. Read player configuration from CSV file / 从 CSV 文件读取玩家配置
2. Display personalized message by player number / 根据玩家编号显示个性化消息
3. Show all player list / 支持显示所有玩家列表
4. Add new player configuration / 支持添加新玩家配置
"""

import csv

# ========== Global Variables / 全局变量 ==========
CONFIG_FILE = "playerCustomisation.csv"

# ========== Function Definitions / 函数定义 ==========

def load_all_players(file_name):
    """Load all player configurations / 加载所有玩家的配置"""
    players = []
    
    try:
        with open(file_name, "r") as file:
            reader = csv.reader(file)
            header = next(reader)  # Skip header / 跳过表头
            
            for row in reader:
                if len(row) >= 8:
                    player = {
                        "player_number": int(row[0]),
                        "width": int(row[1]),
                        "height": int(row[2]),
                        "monster_count": int(row[3]),
                        "wall_count": int(row[4]),
                        "energy": int(row[5]),
                        "animal": row[6],
                        "sound": row[7]
                    }
                    players.append(player)
    except FileNotFoundError:
        print(f"Error: File not found {file_name} / 错误: 找不到文件 {file_name}")
        return []
    
    return players

def find_player(players, player_number):
    """Find player configuration by player number / 根据玩家编号查找配置"""
    for player in players:
        if player["player_number"] == player_number:
            return player
    return None

def get_welcome_message(player):
    """Generate welcome message / 生成欢迎消息"""
    if player is None:
        return "Player does not exist / 玩家不存在"
    
    return f"Welcome {player['animal']} Person! Give me a {player['sound']}!"

def show_all_players(players):
    """Show all players / 显示所有玩家"""
    if not players:
        print("No player data / 暂无玩家数据")
        return
    
    print("\n=== All Player Configurations / 所有玩家配置 ===")
    print("ID | Animal | Sound | Maze Size | Monsters | Walls | Energy")
    print("-" * 60)
    
    for p in players:
        print(f"{p['player_number']:2} | {p['animal']:6} | {p['sound']:6} | "
              f"{p['width']}x{p['height']:2} | {p['monster_count']:3} | {p['wall_count']:2} | {p['energy']:3}")

def add_player(file_name, player_data):
    """Add new player configuration to file / 添加新玩家配置到文件"""
    with open(file_name, "a", newline="") as file:
        writer = csv.writer(file)
        row = [
            player_data["player_number"],
            player_data["width"],
            player_data["height"],
            player_data["monster_count"],
            player_data["wall_count"],
            player_data["energy"],
            player_data["animal"],
            player_data["sound"]
        ]
        writer.writerow(row)
    print(f"Added player {player_data['player_number']} / 已添加玩家 {player_data['player_number']}")

# ========== Main Program / 主程序 ==========

def main():
    print("=== Player Configuration Loader / 玩家配置加载器 ===")
    
    # Load all player configurations / 加载所有玩家配置
    players = load_all_players(CONFIG_FILE)
    
    while True:
        print("\n=== Menu / 菜单 ===")
        print("1. View all players / 查看所有玩家")
        print("2. Find player configuration / 查找玩家配置")
        print("3. Add new player / 添加新玩家")
        print("4. Generate welcome message / 生成欢迎消息")
        print("5. Exit / 退出")
        
        choice = input("Choose / 请选择: ")
        
        if choice == "1":
            show_all_players(players)
        
        elif choice == "2":
            try:
                num = int(input("Enter player number / 请输入玩家编号: "))
                player = find_player(players, num)
                if player:
                    print(f"\nPlayer {num} configuration / 玩家 {num} 的配置:")
                    for key, value in player.items():
                        print(f"  {key}: {value}")
                else:
                    print(f"Player {num} not found / 未找到玩家 {num}")
            except ValueError:
                print("Please enter a valid number / 请输入有效的数字")
        
        elif choice == "3":
            print("\n=== Add New Player / 添加新玩家 ===")
            try:
                new_player = {
                    "player_number": int(input("Player number / 玩家编号: ")),
                    "width": int(input("Maze width / 迷宫宽度: ")),
                    "height": int(input("Maze height / 迷宫高度: ")),
                    "monster_count": int(input("Monster count / 怪物数量: ")),
                    "wall_count": int(input("Wall count / 墙数量: ")),
                    "energy": int(input("Initial energy / 初始能量: ")),
                    "animal": input("Animal / 动物: "),
                    "sound": input("Sound / 叫声: ")
                }
                add_player(CONFIG_FILE, new_player)
                # Reload player list / 重新加载玩家列表
                players = load_all_players(CONFIG_FILE)
            except ValueError:
                print("Please enter valid numbers / 请输入有效的数字")
        
        elif choice == "4":
            try:
                num = int(input("Enter player number / 请输入玩家编号: "))
                player = find_player(players, num)
                print(get_welcome_message(player))
            except ValueError:
                print("Please enter a valid number / 请输入有效的数字")
        
        elif choice == "5":
            print("Goodbye! / 再见！")
            break
        
        else:
            print("Invalid choice / 无效选择")

# Run main program / 运行主程序
if __name__ == "__main__":
    main()

❌ Error 1: File Not Found

with open("not_exist.csv", "r") as file:
    # FileNotFoundError

✓ Solution: Check if file exists first / 先检查文件是否存在

import os
if os.path.exists("not_exist.csv"):
    with open("not_exist.csv", "r") as file:
        # ...
else:
    print("File not found / 文件不存在")

❌ Error 2: Forgetting Type Conversion

错误2：忘记转换数据类型

# Wrong / 错误
row = ["0", "20", "15"]
if row[0] == 0:  # "0" == 0 is False
    # Never executes / 永远不会执行

# Correct / 正确
if int(row[0]) == 0:
    # Will execute / 会执行

❌ Error 3: Column Name Mismatch

错误3：表头列名不匹配

# Wrong / 错误
player_idx = header.index("PlayerNumber")  # Correct
player_idx = header.index("player_number") # Wrong (case/underscore)

✓ Solution: Ensure column names match exactly / 确保列名与 CSV 文件完全一致

❌ Error 4: Index Out of Range

错误4：索引越界

# Wrong / 错误
row = ["0", "20"]  # Only 2 columns / 只有 2 列
animal = row[6]    # IndexError

# Correct / 正确
if len(row) >= 8:
    animal = row[6]

import csv

with open("file.csv", "r") as f:
    reader = csv.reader(f)

import csv

def read_first_n_rows(file_name, n):
    rows = []
    with open(file_name, "r") as f:
        reader = csv.reader(f)
        for i, row in enumerate(reader):
            if i >= n:
                break
            rows.append(row)
    return rows

import csv

def filter_by_column(file_name, column_name, value):
    results = []
    with open(file_name, "r") as f:
        reader = csv.reader(f)
        header = next(reader)
        
        if column_name not in header:
            return results
        
        col_index = header.index(column_name)
        
        for row in reader:
            if len(row) > col_index and row[col_index] == str(value):
                results.append(row)
    
    return results