Edit: 小朋友的Python冒险之旅

编辑文章

标题 *

URL 别名 *

内容 * (支持 Markdown 格式)

# 《小码农的Python冒险之旅》

## 前言：开启你的编程魔法世界

亲爱的小朋友们，欢迎来到Python编程的魔法世界！在这里，你将学会用代码创造奇迹，让计算机听从你的指令，创作出属于自己的游戏和程序。就像哈利·波特学习魔法咒语一样，我们将一起学习Python这门神奇的"编程语言"。

Python是一种非常友好的编程语言，它的名字来源于创造者喜欢的一个喜剧团体。Python就像是一位和蔼可亲的老师，用最简单的方式教会我们编程的奥秘。准备好了吗？让我们一起开始这段奇妙的冒险之旅！

## 第一章：认识你的新朋友Python

### 1.1 Python是什么？

想象一下，如果你想和来自不同国家的朋友交流，你需要学习他们的语言，对吗？同样的道理，如果我们想让计算机帮我们做事情，就需要学习计算机能够理解的语言——这就是编程语言。

Python就是众多编程语言中的一种，它特别适合初学者，因为：
- 它的语法简单，就像在写英语句子
- 它功能强大，可以做游戏、画图、计算数学题
- 全世界有很多人都在使用它，包括谷歌、YouTube等大公司

### 1.2 安装Python魔法工具箱

在开始编程之前，我们需要在电脑上安装Python。这就像画画之前要准备好画笔和颜料一样。

安装步骤：
1. 请爸爸妈妈帮你打开Python官方网站（python.org）
2. 下载适合你电脑系统的Python版本
3. 运行安装程序，记得勾选"Add Python to PATH"选项
4. 安装完成后，我们还需要一个写代码的"魔法本"——推荐使用Thonny，这是专门为初学者设计的Python编辑器

### 1.3 第一个魔法咒语：Hello World！

现在让我们施展第一个Python魔法！打开Thonny，输入下面这行代码：

```python
print("Hello, World!")
```

点击运行按钮，你会看到屏幕上出现了"Hello, World!"。恭喜你！你刚刚让计算机说出了它的第一句话！

让我们再试试其他的：

```python
print("我叫小明")
print("我今年10岁")
print("我喜欢编程！")
```

看，计算机会按照你写的顺序，一句一句地显示出来。`print()`就像是一个魔法咒语，它能让计算机在屏幕上显示文字。括号里的内容要用引号包起来，这样Python才知道这是要显示的文字。

### 1.4 Python可以做数学题

Python不仅会说话，还是个数学小天才呢！试试看：

```python
print(5 + 3)
print(10 - 4)
print(6 * 7)
print(20 / 4)
```

运行这段代码，你会发现Python帮你算出了所有答案。在Python中：
- `+` 表示加法
- `-` 表示减法
- `*` 表示乘法
- `/` 表示除法

你甚至可以让Python帮你算更复杂的题目：

```python
print("小明有5个苹果，小红给了他3个，他现在有几个？")
print(5 + 3)

print("妈妈买了24个糖果，平均分给6个小朋友，每人能得到几个？")
print(24 / 6)
```

## 第二章：变量——神奇的储物盒

### 2.1 什么是变量？

在生活中，我们会用盒子来装东西，比如用铅笔盒装铅笔，用书包装书本。在Python中，变量就像是一个个神奇的盒子，可以用来存放各种信息。

```python
my_name = "小明"
my_age = 10
my_height = 140.5

print(my_name)
print(my_age)
print(my_height)
```

在这个例子中：
- `my_name` 是一个盒子，里面装着文字"小明"
- `my_age` 是另一个盒子，里面装着数字10
- `my_height` 也是一个盒子，装着小数140.5

### 2.2 给变量起名字的规则

就像给宠物起名字一样，给变量起名字也有一些规则：

1. 名字可以包含字母、数字和下划线（_）
2. 名字不能以数字开头
3. 名字不能包含空格
4. 不能使用Python的关键词（比如print）

好的变量名：
```python
student_name = "小红"
score = 95
is_happy = True
favorite_color = "蓝色"
```

不好的变量名：
```python
# 这些都是错误的！
# 2student = "小明"  # 不能以数字开头
# my name = "小红"   # 不能有空格
# print = 100        # 不能使用关键词
```

### 2.3 变量的魔法：可以改变！

变量最神奇的地方是它们可以改变内容，就像魔法盒子可以重新装东西：

```python
pocket_money = 10
print("我的零花钱有：", pocket_money, "元")

# 妈妈又给了5元
pocket_money = pocket_money + 5
print("现在我有：", pocket_money, "元")

# 买了一支3元的冰淇淋
pocket_money = pocket_money - 3
print("买完冰淇淋还剩：", pocket_money, "元")
```

### 2.4 不同类型的变量

Python中的变量可以存放不同类型的数据：

```python
# 字符串（文字）
favorite_food = "披萨"
school_name = "阳光小学"

# 整数
student_count = 30
book_pages = 256

# 小数（浮点数）
temperature = 26.5
pi = 3.14159

# 布尔值（对或错）
is_sunny = True
is_raining = False

print("我最喜欢吃", favorite_food)
print("今天温度是", temperature, "度")
print("今天是晴天吗？", is_sunny)
```

## 第三章：和Python对话——输入与输出

### 3.1 让Python听懂你的话

到目前为止，我们一直在让Python说话，现在让我们教Python听我们说话！使用`input()`函数：

```python
name = input("请问你叫什么名字？")
print("你好，", name, "！很高兴认识你！")

age = input("你今年几岁了？")
print("哇，", age, "岁是个很棒的年纪！")
```

运行这段代码，Python会等待你输入答案，然后根据你的回答做出回应。

### 3.2 制作一个自我介绍程序

让我们做一个更有趣的程序：

```python
print("=== 自我介绍小程序 ===")

name = input("你的名字是：")
age = input("你的年龄是：")
hobby = input("你最喜欢做什么：")
pet = input("你有什么宠物吗：")

print("\n--- 自我介绍 ---")
print("大家好！我叫" + name)
print("我今年" + age + "岁")
print("我最喜欢" + hobby)
print("我的宠物是" + pet)
print("很高兴认识大家！")
```

### 3.3 数字输入的小技巧

当我们需要输入数字进行计算时，需要特别注意：

```python
# 这样会出错！
age = input("你几岁了？")
next_year_age = age + 1  # 错误！不能把文字和数字相加

# 正确的做法
age = input("你几岁了？")
age = int(age)  # 把文字转换成数字
next_year_age = age + 1
print("明年你就", next_year_age, "岁了！")
```

更简单的写法：

```python
age = int(input("你几岁了？"))
print("10年后你就", age + 10, "岁了！")
```

### 3.4 制作一个简单的计算器

```python
print("=== 小小计算器 ===")

num1 = float(input("请输入第一个数字："))
num2 = float(input("请输入第二个数字："))

print("\n计算结果：")
print(num1, "+", num2, "=", num1 + num2)
print(num1, "-", num2, "=", num1 - num2)
print(num1, "×", num2, "=", num1 * num2)
print(num1, "÷", num2, "=", num1 / num2)
```

## 第四章：做决定的魔法——条件判断

### 4.1 如果...那么...

在生活中，我们经常需要做决定：如果今天下雨，那么带伞；如果作业做完了，那么可以玩游戏。Python也可以做这样的决定！

```python
weather = input("今天的天气怎么样？（晴天/雨天）")

if weather == "雨天":
    print("记得带伞哦！")
    print("穿上雨鞋会更好")
```

注意：
- `if` 后面要加冒号 `:`
- 要执行的代码需要缩进（按Tab键或4个空格）
- `==` 表示"等于"（两个等号）

### 4.2 如果...否则...

```python
score = int(input("你的考试分数是多少？"))

if score >= 90:
    print("太棒了！你得了A！")
    print("继续保持！")
else:
    print("没关系，下次继续努力！")
    print("我相信你可以做得更好！")
```

### 4.3 多重选择

有时候我们需要更多选择：

```python
score = int(input("请输入你的分数："))

if score >= 90:
    print("优秀！等级：A")
elif score >= 80:
    print("良好！等级：B")
elif score >= 70:
    print("中等！等级：C")
elif score >= 60:
    print("及格！等级：D")
else:
    print("需要加油！等级：F")
```

### 4.4 制作一个小游戏：猜年龄

```python
print("=== 猜年龄游戏 ===")
print("我在想一个1到10之间的数字，你能猜到吗？")

secret_age = 7  # 这是要猜的数字
guess = int(input("请输入你的猜测："))

if guess == secret_age:
    print("哇！你猜对了！真厉害！")
elif guess > secret_age:
    print("太大了！实际数字更小一些")
else:
    print("太小了！实际数字更大一些")
```

### 4.5 组合条件

我们可以用 `and`（并且）和 `or`（或者）来组合条件：

```python
age = int(input("你几岁了？"))
height = float(input("你的身高是多少厘米？"))

# 过山车的要求：年龄大于8岁 并且 身高超过120厘米
if age > 8 and height > 120:
    print("你可以玩过山车了！")
else:
    print("对不起，你还不能玩过山车")

# 游泳池的规则：带了泳帽 或者 是游泳队成员
has_cap = input("你带泳帽了吗？（是/否）")
is_member = input("你是游泳队成员吗？（是/否）")

if has_cap == "是" or is_member == "是":
    print("欢迎进入游泳池！")
else:
    print("请准备好泳帽再来")
```

## 第五章：重复的魔法——循环

### 5.1 for循环：数数字

当我们需要重复做某件事时，循环就派上用场了！

```python
# 从1数到10
for i in range(1, 11):
    print(i)

# 打印5次"我爱Python！"
for i in range(5):
    print("我爱Python！")
```

`range()`函数的用法：
- `range(5)` 表示 0, 1, 2, 3, 4
- `range(1, 6)` 表示 1, 2, 3, 4, 5
- `range(0, 10, 2)` 表示 0, 2, 4, 6, 8

### 5.2 用循环画图案

```python
# 画一个三角形
for i in range(1, 6):
    print("*" * i)

# 画一个正方形
size = 5
for i in range(size):
    print("* " * size)

# 画一个倒三角形
for i in range(5, 0, -1):
    print("*" * i)
```

### 5.3 while循环：一直做直到...

```python
# 倒计时
count = 10
while count > 0:
    print(count)
    count = count - 1
print("发射！")

# 累加零花钱
total_money = 0
day = 1

while day <= 7:
    print("第", day, "天")
    money = int(input("今天得到多少零花钱？"))
    total_money = total_money + money
    day = day + 1

print("这周总共得到", total_money, "元零花钱")
```

### 5.4 猜数字游戏（完整版）

```python
import random

print("=== 猜数字游戏 ===")
secret_number = random.randint(1, 100)
guess_count = 0

print("我想了一个1到100之间的数字，你能猜到吗？")

while True:
    guess = int(input("请输入你的猜测："))
    guess_count = guess_count + 1
    
    if guess == secret_number:
        print("恭喜你猜对了！")
        print("你一共猜了", guess_count, "次")
        break
    elif guess > secret_number:
        print("太大了！再小一点")
    else:
        print("太小了！再大一点")
```

### 5.5 嵌套循环：循环中的循环

```python
# 九九乘法表
for i in range(1, 10):
    for j in range(1, i + 1):
        print(j, "×", i, "=", i * j, end="  ")
    print()  # 换行

# 画一个由星星组成的矩形
rows = 4
cols = 6

for i in range(rows):
    for j in range(cols):
        print("*", end=" ")
    print()  # 每行结束后换行
```

## 第六章：列表——超级储物架

### 6.1 什么是列表？

如果变量是一个盒子，那么列表就是一个有很多格子的储物架，每个格子都可以放东西！

```python
# 创建一个列表
fruits = ["苹果", "香蕉", "橙子", "葡萄"]
print(fruits)

# 我的朋友们
friends = ["小明", "小红", "小华", "小李"]
print("我的朋友有：", friends)

# 考试分数
scores = [85, 92, 78, 96, 88]
print("这次考试的分数：", scores)
```

### 6.2 访问列表中的元素

列表中的每个位置都有一个编号，从0开始：

```python
fruits = ["苹果", "香蕉", "橙子", "葡萄"]

print("第一个水果是：", fruits[0])  # 苹果
print("第二个水果是：", fruits[1])  # 香蕉
print("最后一个水果是：", fruits[-1])  # 葡萄

# 修改列表中的元素
fruits[1] = "芒果"
print("现在的水果列表：", fruits)
```

### 6.3 列表的魔法操作

```python
# 添加元素
pets = ["小狗", "小猫"]
pets.append("小兔子")  # 在末尾添加
print(pets)

# 插入元素
pets.insert(1, "小鸟")  # 在位置1插入
print(pets)

# 删除元素
pets.remove("小猫")  # 删除指定元素
print(pets)

# 列表长度
print("我有", len(pets), "只宠物")

# 检查元素是否在列表中
if "小狗" in pets:
    print("我有一只小狗！")
```

### 6.4 用循环遍历列表

```python
# 打印所有水果
fruits = ["苹果", "香蕉", "橙子", "葡萄", "西瓜"]

print("我喜欢的水果有：")
for fruit in fruits:
    print("- " + fruit)

# 计算总分和平均分
scores = [85, 92, 78, 96, 88]
total = 0

for score in scores:
    total = total + score

average = total / len(scores)
print("总分：", total)
print("平均分：", average)
```

### 6.5 列表小游戏：购物清单

```python
print("=== 购物清单管理器 ===")
shopping_list = []

while True:
    print("\n当前购物清单：", shopping_list)
    print("1. 添加物品")
    print("2. 删除物品")
    print("3. 查看清单")
    print("4. 退出")
    
    choice = input("请选择操作（1-4）：")
    
    if choice == "1":
        item = input("要添加什么物品？")
        shopping_list.append(item)
        print(item, "已添加到购物清单")
    
    elif choice == "2":
        if len(shopping_list) == 0:
            print("购物清单是空的！")
        else:
            item = input("要删除什么物品？")
            if item in shopping_list:
                shopping_list.remove(item)
                print(item, "已从购物清单删除")
            else:
                print("清单中没有这个物品")
    
    elif choice == "3":
        if len(shopping_list) == 0:
            print("购物清单是空的！")
        else:
            print("需要购买的物品：")
            for i, item in enumerate(shopping_list, 1):
                print(f"{i}. {item}")
    
    elif choice == "4":
        print("再见！")
        break
    
    else:
        print("无效的选择，请重试")
```

## 第七章：函数——你的编程助手

### 7.1 什么是函数？

函数就像是一个小助手，你告诉它做什么，它就会帮你完成。我们已经用过一些函数了，比如`print()`和`input()`。现在让我们学习创建自己的函数！

```python
# 定义一个打招呼的函数
def say_hello():
    print("你好！")
    print("欢迎来到Python世界！")

# 调用函数
say_hello()
say_hello()  # 可以多次调用
```

### 7.2 带参数的函数

函数可以接收信息（参数），根据不同的信息做不同的事：

```python
def greet(name):
    print("你好，" + name + "！")
    print("很高兴见到你！")

# 调用函数时提供参数
greet("小明")
greet("老师")

# 多个参数的函数
def introduce(name, age, hobby):
    print(f"我叫{name}")
    print(f"我今年{age}岁")
    print(f"我喜欢{hobby}")

introduce("小红", 10, "画画")
```

### 7.3 返回值的函数

函数不仅可以做事，还可以计算并返回结果：

```python
def add(a, b):
    result = a + b
    return result

# 使用函数的返回值
sum = add(5, 3)
print("5 + 3 =", sum)

# 计算矩形面积的函数
def rectangle_area(length, width):
    area = length * width
    return area

my_area = rectangle_area(10, 5)
print("矩形的面积是：", my_area)
```

### 7.4 实用的函数例子

```python
# 判断是否及格
def is_pass(score):
    if score >= 60:
        return True
    else:
        return False

# 计算平均分
def calculate_average(scores):
    total = sum(scores)
    average = total / len(scores)
    return average

# 生成问候语
def make_greeting(time_of_day):
    if time_of_day == "早上":
        return "早上好！祝你有美好的一天！"
    elif time_of_day == "下午":
        return "下午好！别忘了喝水哦！"
    elif time_of_day == "晚上":
        return "晚上好！今天过得怎么样？"
    else:
        return "你好！"

# 使用这些函数
print(is_pass(75))
print(calculate_average([80, 90, 85, 92]))
print(make_greeting("早上"))
```

### 7.5 制作一个简单的游戏菜单

```python
def show_menu():
    print("\n=== 游戏菜单 ===")
    print("1. 猜数字")
    print("2. 石头剪刀布")
    print("3. 数学测验")
    print("4. 退出游戏")

def guess_number_game():
    import random
    number = random.randint(1, 10)
    guess = int(input("猜一个1到10的数字："))
    
    if guess == number:
        print("猜对了！")
    else:
        print(f"错了，正确答案是{number}")

def rock_paper_scissors():
    import random
    choices = ["石头", "剪刀", "布"]
    computer_choice = random.choice(choices)
    
    player_choice = input("请出拳（石头/剪刀/布）：")
    print(f"电脑出了：{computer_choice}")
    
    if player_choice == computer_choice:
        print("平局！")
    elif (player_choice == "石头" and computer_choice == "剪刀") or \
         (player_choice == "剪刀" and computer_choice == "布") or \
         (player_choice == "布" and computer_choice == "石头"):
        print("你赢了！")
    else:
        print("你输了！")

def math_quiz():
    import random
    num1 = random.randint(1, 20)
    num2 = random.randint(1, 20)
    
    answer = int(input(f"{num1} + {num2} = "))
    
    if answer == num1 + num2:
        print("答对了！真棒！")
    else:
        print(f"答错了，正确答案是 {num1 + num2}")

# 主程序
while True:
    show_menu()
    choice = input("请选择（1-4）：")
    
    if choice == "1":
        guess_number_game()
    elif choice == "2":
        rock_paper_scissors()
    elif choice == "3":
        math_quiz()
    elif choice == "4":
        print("谢谢游玩，再见！")
        break
    else:
        print("无效选择，请重试")
```

## 第八章：字符串的魔法

### 8.1 字符串是什么？

字符串就是文字的集合，可以是一个字母、一个词或一句话。在Python中，我们用引号把文字包起来就成了字符串。

```python
# 不同的字符串
name = "小明"
sentence = "我喜欢编程！"
story = "从前有座山，山里有座庙..."

# 单引号和双引号都可以
msg1 = "你好"
msg2 = '你好'
print(msg1 == msg2)  # True，它们是一样的

# 多行字符串
poem = """
床前明月光，
疑是地上霜。
举头望明月，
低头思故乡。
"""
print(poem)
```

### 8.2 字符串的操作

```python
# 字符串拼接
first_name = "张"
last_name = "小明"
full_name = first_name + last_name
print(full_name)

# 重复字符串
laugh = "哈"
big_laugh = laugh * 5
print(big_laugh)  # 哈哈哈哈哈

# 字符串长度
message = "Hello Python"
print(len(message))  # 12

# 访问字符串中的字符
word = "Python"
print(word[0])  # P
print(word[1])  # y
print(word[-1]) # n（最后一个）
```

### 8.3 字符串的方法

```python
# 大小写转换
text = "Hello World"
print(text.upper())  # HELLO WORLD
print(text.lower())  # hello world

# 查找和替换
sentence = "我喜欢苹果，苹果很好吃"
print(sentence.count("苹果"))  # 2
print(sentence.replace("苹果", "香蕉"))

# 分割字符串
fruits = "苹果,香蕉,橙子,葡萄"
fruit_list = fruits.split(",")
print(fruit_list)  # ['苹果', '香蕉', '橙子', '葡萄']

# 去除空格
name = "  小明  "
print(name.strip())  # "小明"
```

### 8.4 格式化字符串

```python
# 使用 f-string（推荐）
name = "小红"
age = 10
height = 145.5

introduction = f"我叫{name}，今年{age}岁，身高{height}厘米"
print(introduction)

# 在f-string中进行计算
price = 15
quantity = 3
print(f"单价{price}元，买{quantity}个，总共{price * quantity}元")

# 格式化数字
pi = 3.14159265
print(f"圆周率约等于{pi:.2f}")  # 保留2位小数
```

### 8.5 字符串小游戏：词语接龙

```python
print("=== 词语接龙游戏 ===")
print("规则：下一个词的第一个字必须是上一个词的最后一个字")

words = ["苹果"]
print(f"第一个词是：{words[0]}")

while True:
    last_word = words[-1]
    last_char = last_word[-1]
    
    print(f"\n当前词语：{last_word}")
    print(f"请输入一个以'{last_char}'开头的词语")
    
    new_word = input("你的词语：")
    
    if new_word == "退出":
        break
    
    if len(new_word) < 2:
        print("词语至少要有两个字！")
        continue
    
    if new_word[0] != last_char:
        print(f"错误！必须以'{last_char}'开头")
        continue
    
    if new_word in words:
        print("这个词已经用过了！")
        continue
    
    words.append(new_word)
    print("好词！继续！")

print(f"\n游戏结束！你一共接了{len(words)}个词")
print("所有词语：", " -> ".join(words))
```

## 第九章：字典——超级通讯录

### 9.1 什么是字典？

如果列表像是一个储物架，那字典就像是一个通讯录。在通讯录中，每个人的名字对应着他的电话号码。在Python字典中，每个"键"对应着一个"值"。

```python
# 创建一个字典
student = {
    "姓名": "小明",
    "年龄": 10,
    "年级": "四年级",
    "爱好": "踢足球"
}

print(student)
print(student["姓名"])  # 小明
print(student["爱好"])  # 踢足球
```

### 9.2 字典的操作

```python
# 创建一个宠物信息字典
pet = {
    "名字": "毛毛",
    "种类": "小狗",
    "年龄": 3,
    "颜色": "棕色"
}

# 修改值
pet["年龄"] = 4
print(f"{pet['名字']}现在{pet['年龄']}岁了")

# 添加新的键值对
pet["最爱的食物"] = "骨头"
print(pet)

# 删除键值对
del pet["颜色"]

# 检查键是否存在
if "名字" in pet:
    print(f"宠物的名字是{pet['名字']}")
```

### 9.3 遍历字典

```python
# 学生成绩单
scores = {
    "语文": 92,
    "数学": 88,
    "英语": 95,
    "科学": 90,
    "体育": 98
}

# 遍历所有科目和分数
print("成绩单：")
for subject, score in scores.items():
    print(f"{subject}: {score}分")

# 计算总分和平均分
total = sum(scores.values())
average = total / len(scores)
print(f"\n总分：{total}分")
print(f"平均分：{average:.1f}分")

# 找出最高分的科目
max_score = max(scores.values())
for subject, score in scores.items():
    if score == max_score:
        print(f"最擅长的科目是{subject}，得了{score}分！")
```

### 9.4 嵌套字典

```python
# 班级通讯录
class_contacts = {
    "小明": {
        "电话": "13812345678",
        "邮箱": "xiaoming@email.com",
        "地址": "阳光小区1号楼"
    },
    "小红": {
        "电话": "13887654321",
        "邮箱": "xiaohong@email.com",
        "地址": "花园小区2号楼"
    },
    "小华": {
        "电话": "13856781234",
        "邮箱": "xiaohua@email.com",
        "地址": "幸福小区3号楼"
    }
}

# 查找某人的信息
name = input("要查找谁的信息？")
if name in class_contacts:
    info = class_contacts[name]
    print(f"\n{name}的信息：")
    for key, value in info.items():
        print(f"{key}: {value}")
else:
    print("没有找到这个人的信息")
```

### 9.5 字典应用：简单的单词本

```python
print("=== 英语单词本 ===")

word_book = {
    "apple": "苹果",
    "banana": "香蕉",
    "cat": "猫",
    "dog": "狗",
    "elephant": "大象",
    "flower": "花",
    "good": "好的",
    "happy": "快乐的",
    "ice cream": "冰淇淋",
    "juice": "果汁"
}

while True:
    print("\n1. 查单词")
    print("2. 添加新单词")
    print("3. 显示所有单词")
    print("4. 单词测试")
    print("5. 退出")
    
    choice = input("请选择（1-5）：")
    
    if choice == "1":
        word = input("请输入要查的英文单词：").lower()
        if word in word_book:
            print(f"{word} 的意思是：{word_book[word]}")
        else:
            print("单词本里还没有这个单词")
    
    elif choice == "2":
        english = input("请输入英文单词：").lower()
        chinese = input("请输入中文意思：")
        word_book[english] = chinese
        print("单词已添加！")
    
    elif choice == "3":
        print("\n单词本中的所有单词：")
        for eng, chi in word_book.items():
            print(f"{eng} - {chi}")
    
    elif choice == "4":
        import random
        test_word = random.choice(list(word_book.keys()))
        answer = input(f"{test_word} 的意思是什么？")
        
        if answer == word_book[test_word]:
            print("答对了！真棒！")
        else:
            print(f"答错了，{test_word} 的意思是 {word_book[test_word]}")
    
    elif choice == "5":
        print("再见！继续努力学习哦！")
        break
```

## 第十章：文件操作——保存你的作品

### 10.1 写入文件

到目前为止，我们的程序运行结束后，所有数据都会消失。现在让我们学习如何把数据保存到文件中！

```python
# 写入文件
with open("my_diary.txt", "w", encoding="utf-8") as file:
    file.write("今天是个好天气！\n")
    file.write("我学会了Python文件操作。\n")
    file.write("感觉自己越来越厉害了！")

print("日记已保存！")

# 写入多行
diary_lines = [
    "2024年10月20日 星期日\n",
    "今天我和朋友一起去公园玩。\n",
    "我们看到了很多漂亮的花。\n",
    "还喂了池塘里的小鱼。\n",
    "真是开心的一天！"
]

with open("my_diary2.txt", "w", encoding="utf-8") as file:
    file.writelines(diary_lines)
```

### 10.2 读取文件

```python
# 读取整个文件
with open("my_diary.txt", "r", encoding="utf-8") as file:
    content = file.read()
    print("日记内容：")
    print(content)

# 逐行读取
print("\n逐行读取：")
with open("my_diary.txt", "r", encoding="utf-8") as file:
    for line in file:
        print(">>", line.strip())  # strip()去除行尾的换行符
```

### 10.3 追加内容

```python
# 追加模式 - 在文件末尾添加内容
with open("my_diary.txt", "a", encoding="utf-8") as file:
    file.write("\n\n新的一天：\n")
    file.write("今天又学会了新知识！\n")

print("新内容已追加到日记中！")
```

### 10.4 成绩管理系统

```python
import json

def save_scores(scores_dict):
    """保存成绩到文件"""
    with open("scores.json", "w", encoding="utf-8") as file:
        json.dump(scores_dict, file, ensure_ascii=False, indent=2)
    print("成绩已保存！")

def load_scores():
    """从文件读取成绩"""
    try:
        with open("scores.json", "r", encoding="utf-8") as file:
            return json.load(file)
    except FileNotFoundError:
        return {}

def main():
    print("=== 成绩管理系统 ===")
    scores = load_scores()
    
    while True:
        print("\n1. 添加成绩")
        print("2. 查看成绩")
        print("3. 查看所有成绩")
        print("4. 退出")
        
        choice = input("请选择（1-4）：")
        
        if choice == "1":
            name = input("学生姓名：")
            subject = input("科目：")
            score = int(input("分数："))
            
            if name not in scores:
                scores[name] = {}
            scores[name][subject] = score
            save_scores(scores)
            
        elif choice == "2":
            name = input("要查看谁的成绩？")
            if name in scores:
                print(f"\n{name}的成绩：")
                for subject, score in scores[name].items():
                    print(f"{subject}: {score}分")
            else:
                print("没有找到这个学生的成绩")
        
        elif choice == "3":
            if scores:
                print("\n所有学生成绩：")
                for name, subjects in scores.items():
                    print(f"\n{name}:")
                    for subject, score in subjects.items():
                        print(f"  {subject}: {score}分")
            else:
                print("还没有任何成绩记录")
        
        elif choice == "4":
            print("再见！")
            break

if __name__ == "__main__":
    main()
```

### 10.5 制作一个简单的通讯录

```python
def save_contacts(contacts):
    """保存通讯录到文件"""
    with open("contacts.txt", "w", encoding="utf-8") as file:
        for name, phone in contacts.items():
            file.write(f"{name},{phone}\n")

def load_contacts():
    """从文件加载通讯录"""
    contacts = {}
    try:
        with open("contacts.txt", "r", encoding="utf-8") as file:
            for line in file:
                line = line.strip()
                if line:
                    name, phone = line.split(",")
                    contacts[name] = phone
    except FileNotFoundError:
        pass
    return contacts

print("=== 我的通讯录 ===")
contacts = load_contacts()

while True:
    print("\n1. 添加联系人")
    print("2. 查找联系人")
    print("3. 显示所有联系人")
    print("4. 删除联系人")
    print("5. 退出")
    
    choice = input("请选择（1-5）：")
    
    if choice == "1":
        name = input("姓名：")
        phone = input("电话：")
        contacts[name] = phone
        save_contacts(contacts)
        print("联系人已添加！")
    
    elif choice == "2":
        name = input("要查找谁？")
        if name in contacts:
            print(f"{name}的电话是：{contacts[name]}")
        else:
            print("没有找到这个联系人")
    
    elif choice == "3":
        if contacts:
            print("\n所有联系人：")
            for name, phone in contacts.items():
                print(f"{name}: {phone}")
        else:
            print("通讯录是空的")
    
    elif choice == "4":
        name = input("要删除谁？")
        if name in contacts:
            del contacts[name]
            save_contacts(contacts)
            print("联系人已删除！")
        else:
            print("没有找到这个联系人")
    
    elif choice == "5":
        print("再见！")
        break
```

## 第十一章：图形编程——让程序动起来

### 11.1 认识Turtle图形库

Turtle（海龟）是Python内置的图形库，我们可以想象有一只小海龟在屏幕上爬行，它爬过的地方会留下轨迹，这样就能画出各种图形了！

```python
import turtle

# 创建画布和海龟
screen = turtle.Screen()
screen.title("我的第一个图形程序")
t = turtle.Turtle()

# 画一个正方形
for i in range(4):
    t.forward(100)  # 前进100步
    t.right(90)     # 右转90度

# 保持窗口打开
turtle.done()
```

### 11.2 基本绘图命令

```python
import turtle

t = turtle.Turtle()
t.speed(5)  # 设置速度（1-10，10最快）

# 移动命令
t.forward(100)    # 前进100步
t.backward(50)    # 后退50步
t.right(90)       # 右转90度
t.left(45)        # 左转45度

# 画笔控制
t.penup()         # 抬起画笔（移动时不画线）
t.goto(0, 0)      # 移动到坐标(0,0)
t.pendown()       # 放下画笔

# 颜色和粗细
t.pencolor("red")     # 设置画笔颜色
t.pensize(3)          # 设置画笔粗细
t.fillcolor("yellow") # 设置填充颜色

# 画一个填充的圆
t.begin_fill()
t.circle(50)      # 画半径为50的圆
t.end_fill()

turtle.done()
```

### 11.3 画出美丽的图案

```python
import turtle

# 画彩虹色的花朵
def draw_flower():
    t = turtle.Turtle()
    t.speed(10)
    colors = ["red", "orange", "yellow", "green", "blue", "purple"]
    
    for i in range(36):
        t.color(colors[i % 6])
        t.circle(100)
        t.right(10)
    
    turtle.done()

# 画螺旋图案
def draw_spiral():
    t = turtle.Turtle()
    t.speed(10)
    colors = ["red", "blue", "green", "yellow"]
    
    for i in range(100):
        t.color(colors[i % 4])
        t.forward(i * 2)
        t.right(91)
    
    turtle.done()

# 画五角星
def draw_star():
    t = turtle.Turtle()
    t.color("gold")
    t.begin_fill()
    
    for i in range(5):
        t.forward(100)
        t.right(144)
    
    t.end_fill()
    turtle.done()

# 选择要画的图案
print("选择要画的图案：")
print("1. 彩虹花朵")
print("2. 螺旋图案")
print("3. 五角星")

choice = input("请选择（1-3）：")

if choice == "1":
    draw_flower()
elif choice == "2":
    draw_spiral()
elif choice == "3":
    draw_star()
```

### 11.4 交互式绘图

```python
import turtle

# 创建画布和海龟
screen = turtle.Screen()
screen.title("键盘控制画图")
screen.bgcolor("lightblue")

t = turtle.Turtle()
t.speed(0)
t.width(2)

# 定义移动函数
def move_up():
    t.setheading(90)  # 朝上
    t.forward(10)

def move_down():
    t.setheading(270)  # 朝下
    t.forward(10)

def move_left():
    t.setheading(180)  # 朝左
    t.forward(10)

def move_right():
    t.setheading(0)   # 朝右
    t.forward(10)

def pen_up():
    t.penup()

def pen_down():
    t.pendown()

def change_color():
    colors = ["red", "blue", "green", "yellow", "purple", "orange"]
    import random
    t.color(random.choice(colors))

def clear_screen():
    t.clear()
    t.penup()
    t.home()
    t.pendown()

# 绑定按键
screen.onkey(move_up, "Up")
screen.onkey(move_down, "Down")
screen.onkey(move_left, "Left")
screen.onkey(move_right, "Right")
screen.onkey(pen_up, "u")
screen.onkey(pen_down, "d")
screen.onkey(change_color, "c")
screen.onkey(clear_screen, "space")

# 显示说明
t.penup()
t.goto(-200, 200)
t.write("使用方向键移动，U抬笔，D落笔，C换颜色，空格清屏", 
        font=("Arial", 12, "normal"))
t.goto(0, 0)
t.pendown()

# 监听按键
screen.listen()
screen.mainloop()
```

### 11.5 小海龟赛跑游戏

```python
import turtle
import random

# 设置屏幕
screen = turtle.Screen()
screen.title("小海龟赛跑")
screen.bgcolor("lightgreen")
screen.setup(width=800, height=600)

# 画起跑线
line = turtle.Turtle()
line.hideturtle()
line.penup()
line.goto(-300, 200)
line.pendown()
line.goto(-300, -200)

# 画终点线
line.penup()
line.goto(300, 200)
line.pendown()
line.goto(300, -200)

# 创建参赛海龟
colors = ["red", "blue", "green", "yellow", "purple"]
turtles = []
y_positions = [100, 50, 0, -50, -100]

for i in range(5):
    racer = turtle.Turtle()
    racer.shape("turtle")
    racer.color(colors[i])
    racer.penup()
    racer.goto(-320, y_positions[i])
    turtles.append(racer)

# 让用户下注
user_bet = screen.textinput("下注", "哪只海龟会赢？输入颜色：")

# 开始比赛
race_on = True
winner = None

while race_on:
    for racer in turtles:
        if racer.xcor() > 280:
            race_on = False
            winner = racer.pencolor()
            break
        
        # 随机移动距离
        distance = random.randint(1, 10)
        racer.forward(distance)

# 宣布结果
result = turtle.Turtle()
result.hideturtle()
result.penup()
result.goto(0, 250)

if winner == user_bet:
    result.write(f"{winner}海龟赢了！你猜对了！", 
                 align="center", font=("Arial", 20, "bold"))
else:
    result.write(f"{winner}海龟赢了！你猜的是{user_bet}", 
                 align="center", font=("Arial", 20, "bold"))

screen.exitonclick()
```

## 第十二章：面向对象编程——创建你的游戏角色

### 12.1 什么是类和对象？

想象一下，"类"就像是一个模具，而"对象"就是用这个模具制作出来的具体东西。比如，"汽车"是一个类，而你家的那辆红色小汽车就是一个对象。

```python
# 创建一个宠物类
class Pet:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def introduce(self):
        print(f"我是{self.name}，今年{self.age}岁了！")
    
    def make_sound(self):
        print("宠物发出了声音")

# 创建宠物对象
my_pet = Pet("小白", 3)
my_pet.introduce()
my_pet.make_sound()

# 创建更多宠物
pet2 = Pet("花花", 2)
pet2.introduce()
```

### 12.2 继承——创建不同种类的宠物

```python
# 基础宠物类
class Pet:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.happiness = 50
        self.hunger = 50
    
    def feed(self):
        self.hunger -= 10
        self.happiness += 5
        print(f"{self.name}吃饱了！饥饿度-10，快乐度+5")
    
    def play(self):
        self.happiness += 10
        self.hunger += 5
        print(f"{self.name}玩得很开心！快乐度+10，饥饿度+5")
    
    def status(self):
        print(f"\n{self.name}的状态：")
        print(f"年龄：{self.age}岁")
        print(f"快乐度：{self.happiness}")
        print(f"饥饿度：{self.hunger}")

# 狗类（继承自Pet）
class Dog(Pet):
    def make_sound(self):
        print(f"{self.name}：汪汪汪！")
    
    def fetch(self):
        print(f"{self.name}叼回了球！")
        self.happiness += 15

# 猫类（继承自Pet）
class Cat(Pet):
    def make_sound(self):
        print(f"{self.name}：喵喵喵~")
    
    def scratch(self):
        print(f"{self.name}在磨爪子")
        self.happiness += 10

# 创建不同的宠物
my_dog = Dog("旺财", 4)
my_cat = Cat("咪咪", 2)

# 互动
my_dog.make_sound()
my_dog.feed()
my_dog.fetch()
my_dog.status()

print("\n" + "="*30 + "\n")

my_cat.make_sound()
my_cat.play()
my_cat.scratch()
my_cat.status()
```

### 12.3 创建一个学生类

```python
class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade
        self.scores = {}
        self.homework_done = []
    
    def add_score(self, subject, score):
        self.scores[subject] = score
        print(f"{self.name}的{subject}成绩已记录：{score}分")
    
    def do_homework(self, subject):
        self.homework_done.append(subject)
        print(f"{self.name}完成了{subject}作业！")
    
    def get_average_score(self):
        if not self.scores:
            return 0
        total = sum(self.scores.values())
        average = total / len(self.scores)
        return average
    
    def report_card(self):
        print(f"\n===== {self.name}的成绩单 =====")
        print(f"年级：{self.grade}")
        print("\n各科成绩：")
        for subject, score in self.scores.items():
            print(f"{subject}: {score}分")
        print(f"\n平均分：{self.get_average_score():.1f}分")
        print(f"已完成的作业：{', '.join(self.homework_done)}")

# 创建学生对象
student1 = Student("小明", "五年级")
student1.add_score("语文", 92)
student1.add_score("数学", 88)
student1.add_score("英语", 95)
student1.do_homework("语文")
student1.do_homework("数学")
student1.report_card()
```

### 12.4 创建一个简单的游戏角色系统

```python
import random

class GameCharacter:
    def __init__(self, name, character_type):
        self.name = name
        self.type = character_type
        self.level = 1
        self.hp = 100
        self.max_hp = 100
        self.attack_power = 10
        self.defense = 5
        self.exp = 0
    
    def attack(self, enemy):
        damage = self.attack_power + random.randint(-3, 3)
        actual_damage = max(1, damage - enemy.defense)
        enemy.hp -= actual_damage
        print(f"{self.name}攻击了{enemy.name}，造成{actual_damage}点伤害！")
        
        if enemy.hp <= 0:
            enemy.hp = 0
            print(f"{enemy.name}被打败了！")
            self.gain_exp(50)
    
    def heal(self, amount):
        old_hp = self.hp
        self.hp = min(self.max_hp, self.hp + amount)
        healed = self.hp - old_hp
        print(f"{self.name}恢复了{healed}点生命值！当前HP: {self.hp}/{self.max_hp}")
    
    def gain_exp(self, amount):
        self.exp += amount
        print(f"{self.name}获得了{amount}点经验值！")
        
        # 检查是否升级
        if self.exp >= self.level * 100:
            self.level_up()
    
    def level_up(self):
        self.level += 1
        self.max_hp += 20
        self.hp = self.max_hp
        self.attack_power += 5
        self.defense += 2
        print(f"\n🎉 {self.name}升级了！现在是{self.level}级！")
        print(f"HP: {self.max_hp}, 攻击力: {self.attack_power}, 防御力: {self.defense}")
    
    def show_status(self):
        print(f"\n{self.name} ({self.type})")
        print(f"等级: {self.level}")
        print(f"HP: {self.hp}/{self.max_hp}")
        print(f"攻击力: {self.attack_power}")
        print(f"防御力: {self.defense}")
        print(f"经验值: {self.exp}")

# 创建不同类型的角色
class Warrior(GameCharacter):
    def __init__(self, name):
        super().__init__(name, "战士")
        self.attack_power = 15
        self.defense = 8
        self.max_hp = 120
        self.hp = 120
    
    def power_strike(self, enemy):
        print(f"{self.name}使用了力量打击！")
        original_attack = self.attack_power
        self.attack_power *= 2
        self.attack(enemy)
        self.attack_power = original_attack

class Mage(GameCharacter):
    def __init__(self, name):
        super().__init__(name, "法师")
        self.attack_power = 20
        self.defense = 3
        self.max_hp = 80
        self.hp = 80
        self.mana = 50
    
    def fireball(self, enemy):
        if self.mana >= 10:
            print(f"{self.name}发射了火球术！")
            damage = 30
            enemy.hp -= damage
            self.mana -= 10
            print(f"造成{damage}点魔法伤害！剩余魔力: {self.mana}")
            
            if enemy.hp <= 0:
                enemy.hp = 0
                print(f"{enemy.name}被打败了！")
                self.gain_exp(50)
        else:
            print(f"{self.name}魔力不足！")

# 游戏演示
print("=== 角色战斗演示 ===")

# 创建角色
hero = Warrior("勇者")
enemy = GameCharacter("史莱姆", "怪物")

# 显示初始状态
hero.show_status()
enemy.show_status()

# 战斗
print("\n--- 战斗开始！---")
while hero.hp > 0 and enemy.hp > 0:
    print(f"\n{hero.name}的回合：")
    action = input("选择行动：1.普通攻击 2.力量打击 3.查看状态: ")
    
    if action == "1":
        hero.attack(enemy)
    elif action == "2":
        hero.power_strike(enemy)
    elif action == "3":
        hero.show_status()
        continue
    
    # 敌人反击
    if enemy.hp > 0:
        print(f"\n{enemy.name}的回合：")
        enemy.attack(hero)

# 战斗结果
if hero.hp > 0:
    print("\n🎊 你赢了！")
else:
    print("\n💀 游戏结束...")
```

### 12.5 创建一个虚拟宠物游戏

```python
import time
import random

class VirtualPet:
    def __init__(self, name, pet_type):
        self.name = name
        self.type = pet_type
        self.hunger = 50
        self.happiness = 50
        self.health = 100
        self.age = 0
        self.is_alive = True
    
    def feed(self):
        if self.hunger <= 0:
            print(f"{self.name}不饿，不想吃东西")
        else:
            foods = ["🍎苹果", "🍖肉骨头", "🐟小鱼", "🥕胡萝卜"]
            food = random.choice(foods)
            self.hunger = max(0, self.hunger - 20)
            self.happiness += 10
            print(f"{self.name}吃了{food}，真好吃！")
    
    def play(self):
        games = ["接飞盘", "追尾巴", "捉迷藏", "玩球"]
        game = random.choice(games)
        self.happiness = min(100, self.happiness + 20)
        self.hunger += 10
        self.health -= 5
        print(f"{self.name}玩了{game}，好开心！")
    
    def sleep(self):
        print(f"{self.name}睡觉中...Zzz...")
        self.health = min(100, self.health + 20)
        self.hunger += 15
        self.happiness += 5
        print(f"{self.name}睡醒了，精神满满！")
    
    def check_status(self):
        # 检查宠物状态并更新
        if self.hunger >= 100:
            self.health -= 20
            print(f"⚠️ {self.name}太饿了，健康值下降！")
        
        if self.happiness <= 0:
            self.health -= 10
            print(f"⚠️ {self.name}很不开心，健康值下降！")
        
        if self.health <= 0:
            self.is_alive = False
            print(f"😢 {self.name}生病了，需要好好照顾...")
    
    def show_status(self):
        print(f"\n===== {self.name}的状态 =====")
        print(f"类型：{self.type}")
        print(f"年龄：{self.age}天")
        print(f"饥饿度：{'🟥' * (self.hunger // 10)}{'⬜' * (10 - self.hunger // 10)} {self.hunger}/100")
        print(f"快乐度：{'🟦' * (self.happiness // 10)}{'⬜' * (10 - self.happiness // 10)} {self.happiness}/100")
        print(f"健康度：{'🟩' * (self.health // 10)}{'⬜' * (10 - self.health // 10)} {self.health}/100")
        
        # 显示宠物心情
        if self.happiness >= 80:
            print(f"心情：😄 非常开心")
        elif self.happiness >= 50:
            print(f"心情：🙂 还不错")
        elif self.happiness >= 20:
            print(f"心情：😐 一般般")
        else:
            print(f"心情：😢 不开心")
    
    def time_pass(self):
        # 时间流逝的影响
        self.hunger = min(100, self.hunger + 5)
        self.happiness = max(0, self.happiness - 3)
        self.age += 1
        
        # 随机事件
        event = random.randint(1, 10)
        if event == 1:
            print(f"💝 {self.name}找到了一个玩具，快乐度+5！")
            self.happiness = min(100, self.happiness + 5)
        elif event == 2:
            print(f"🌧️ 下雨了，{self.name}有点郁闷，快乐度-5")
            self.happiness = max(0, self.happiness - 5)

# 游戏主程序
def main():
    print("=== 虚拟宠物养成游戏 ===")
    
    pet_name = input("给你的宠物起个名字：")
    print("\n选择宠物类型：")
    print("1. 🐶 小狗")
    print("2. 🐱 小猫")
    print("3. 🐰 小兔子")
    
    choice = input("请选择（1-3）：")
    pet_types = {
        "1": "小狗",
        "2": "小猫",
        "3": "小兔子"
    }
    
    pet_type = pet_types.get(choice, "神秘宠物")
    my_pet = VirtualPet(pet_name, pet_type)
    
    print(f"\n恭喜你获得了一只{pet_type}！好好照顾{pet_name}吧！")
    
    while my_pet.is_alive:
        my_pet.show_status()
        
        print("\n你想做什么？")
        print("1. 🍖 喂食")
        print("2. 🎮 玩耍")
        print("3. 😴 睡觉")
        print("4. ⏭️  什么都不做")
        print("5. 👋 退出游戏")
        
        action = input("请选择（1-5）：")
        
        if action == "1":
            my_pet.feed()
        elif action == "2":
            my_pet.play()
        elif action == "3":
            my_pet.sleep()
        elif action == "4":
            print("时间流逝...")
        elif action == "5":
            print(f"再见！记得回来看{pet_name}哦！")
            break
        else:
            print("无效选择")
            continue
        
        # 时间流逝
        my_pet.time_pass()
        my_pet.check_status()
        
        if not my_pet.is_alive:
            print(f"\n游戏结束。{pet_name}活了{my_pet.age}天。")
            print("下次要更好地照顾你的宠物哦！")

if __name__ == "__main__":
    main()
```

## 第十三章：错误处理——让程序更强壮

### 13.1 什么是错误？

编程时难免会遇到错误，就像我们做数学题可能会算错一样。Python会告诉我们哪里出错了，这样我们就能修正它。

```python
# 常见的错误类型

# 1. 语法错误 - 代码写错了
# print("Hello"  # 缺少右括号

# 2. 名称错误 - 使用了不存在的变量
# print(my_variable)  # my_variable没有定义

# 3. 类型错误 - 对错误的类型进行操作
# number = "5"
# result = number + 10  # 不能把字符串和数字相加

# 4. 索引错误 - 访问了不存在的位置
# my_list = [1, 2, 3]
# print(my_list[10])  # 列表只有3个元素

# 5. 零除错误
# result = 10 / 0  # 不能除以零
```

### 13.2 处理错误 - try和except

```python
# 基本的错误处理
try:
    number = int(input("请输入一个数字："))
    result = 10 / number
    print(f"10除以{number}等于{result}")
except ValueError:
    print("输入的不是有效的数字！")
except ZeroDivisionError:
    print("不能除以零！")

# 处理多种错误
def safe_divide():
    try:
        a = float(input("请输入被除数："))
        b = float(input("请输入除数："))
        result = a / b
        print(f"{a} ÷ {b} = {result}")
    except ValueError:
        print("❌ 请输入有效的数字！")
    except ZeroDivisionError:
        print("❌ 除数不能为零！")
    except Exception as e:
        print(f"❌ 发生了错误：{e}")

safe_divide()
```

### 13.3 创建一个防错的计算器

```python
def safe_calculator():
    print("=== 安全计算器 ===")
    print("支持的运算：+, -, *, /")
    
    while True:
        try:
            # 获取用户输入
            expression = input("\n请输入算式（如：5 + 3）或输入'退出'结束：")
            
            if expression == "退出":
                print("再见！")
                break
            
            # 分解算式
            parts = expression.split()
            if len(parts) != 3:
                print("❌ 格式错误！请输入如 '5 + 3' 的格式")
                continue
            
            num1 = float(parts[0])
            operator = parts[1]
            num2 = float(parts[2])
            
            # 执行计算
            if operator == '+':
                result = num1 + num2
            elif operator == '-':
                result = num1 - num2
            elif operator == '*':
                result = num1 * num2
            elif operator == '/':
                if num2 == 0:
                    print("❌ 不能除以零！")
                    continue
                result = num1 / num2
            else:
                print("❌ 不支持的运算符！")
                continue
            
            print(f"✅ 结果：{num1} {operator} {num2} = {result}")
            
        except ValueError:
            print("❌ 请输入有效的数字！")
        except Exception as e:
            print(f"❌ 发生错误：{e}")

safe_calculator()
```

### 13.4 文件操作的错误处理

```python
def safe_file_reader():
    filename = input("请输入要读取的文件名：")
    
    try:
        with open(filename, 'r', encoding='utf-8') as file:
            content = file.read()
            print(f"\n文件内容：\n{content}")
    except FileNotFoundError:
        print(f"❌ 找不到文件 '{filename}'")
        create = input("是否创建这个文件？(是/否): ")
        if create == "是":
            try:
                with open(filename, 'w', encoding='utf-8') as file:
                    file.write("这是一个新创建的文件！")
                print("✅ 文件创建成功！")
            except Exception as e:
                print(f"❌ 创建文件失败：{e}")
    except PermissionError:
        print(f"❌ 没有权限读取文件 '{filename}'")
    except Exception as e:
        print(f"❌ 读取文件时发生错误：{e}")

safe_file_reader()
```

### 13.5 创建一个健壮的成绩管理系统

```python
class GradeManager:
    def __init__(self):
        self.students = {}
    
    def add_student(self):
        try:
            name = input("学生姓名：").strip()
            if not name:
                raise ValueError("姓名不能为空")
            if name in self.students:
                raise ValueError("该学生已存在")
            
            self.students[name] = {}
            print(f"✅ 学生 {name} 添加成功！")
        except ValueError as e:
            print(f"❌ 错误：{e}")
    
    def add_grade(self):
        try:
            name = input("学生姓名：").strip()
            if name not in self.students:
                raise ValueError("找不到该学生")
            
            subject = input("科目：").strip()
            if not subject:
                raise ValueError("科目不能为空")
            
            score = input("分数：").strip()
            score = float(score)
            
            if score < 0 or score > 100:
                raise ValueError("分数必须在0-100之间")
            
            self.students[name][subject] = score
            print(f"✅ 成绩录入成功！")
            
        except ValueError as e:
            if "could not convert" in str(e):
                print("❌ 错误：分数必须是数字")
            else:
                print(f"❌ 错误：{e}")
        except Exception as e:
            print(f"❌ 发生未知错误：{e}")
    
    def view_grades(self):
        try:
            if not self.students:
                print("📋 还没有学生记录")
                return
            
            name = input("查看哪位学生的成绩（输入'全部'查看所有）：").strip()
            
            if name == '全部':
                for student, grades in self.students.items():
                    print(f"\n📊 {student}的成绩：")
                    if grades:
                        for subject, score in grades.items():
                            print(f"  {subject}: {score}分")
                        avg = sum(grades.values()) / len(grades)
                        print(f"  平均分: {avg:.1f}")
                    else:
                        print("  还没有成绩记录")
            elif name in self.students:
                grades = self.students[name]
                if grades:
                    print(f"\n📊 {name}的成绩：")
                    for subject, score in grades.items():
                        print(f"  {subject}: {score}分")
                    avg = sum(grades.values()) / len(grades)
                    print(f"  平均分: {avg:.1f}")
                else:
                    print(f"{name}还没有成绩记录")
            else:
                raise ValueError("找不到该学生")
                
        except ValueError as e:
            print(f"❌ 错误：{e}")
        except Exception as e:
            print(f"❌ 发生错误：{e}")
    
    def save_data(self):
        try:
            import json
            with open("grades.json", "w", encoding="utf-8") as file:
                json.dump(self.students, file, ensure_ascii=False, indent=2)
            print("✅ 数据保存成功！")
        except Exception as e:
            print(f"❌ 保存失败：{e}")
    
    def load_data(self):
        try:
            import json
            with open("grades.json", "r", encoding="utf-8") as file:
                self.students = json.load(file)
            print("✅ 数据加载成功！")
        except FileNotFoundError:
            print("📋 没有找到保存的数据，将创建新的记录")
        except Exception as e:
            print(f"❌ 加载数据失败：{e}")
    
    def run(self):
        print("=== 成绩管理系统 v2.0 ===")
        self.load_data()
        
        while True:
            print("\n1. 添加学生")
            print("2. 录入成绩")
            print("3. 查看成绩")
            print("4. 保存数据")
            print("5. 退出")
            
            try:
                choice = input("请选择（1-5）：").strip()
                
                if choice == "1":
                    self.add_student()
                elif choice == "2":
                    self.add_grade()
                elif choice == "3":
                    self.view_grades()
                elif choice == "4":
                    self.save_data()
                elif choice == "5":
                    save = input("退出前是否保存？(是/否): ")
                    if save == "是":
                        self.save_data()
                    print("再见！")
                    break
                else:
                    print("❌ 无效的选择，请输入1-5")
                    
            except KeyboardInterrupt:
                print("\n\n程序被中断")
                break
            except Exception as e:
                print(f"❌ 发生错误：{e}")

# 运行程序
if __name__ == "__main__":
    manager = GradeManager()
    manager.run()
```

## 第十四章：小项目实战——综合运用所学知识

### 14.1 项目一：天气记录器

```python
import datetime
import json
import os

class WeatherDiary:
    def __init__(self):
        self.filename = "weather_diary.json"
        self.records = self.load_records()
    
    def load_records(self):
        """加载已有的天气记录"""
        if os.path.exists(self.filename):
            try:
                with open(self.filename, 'r', encoding='utf-8') as file:
                    return json.load(file)
            except:
                return {}
        return {}
    
    def save_records(self):
        """保存天气记录"""
        with open(self.filename, 'w', encoding='utf-8') as file:
            json.dump(self.records, file, ensure_ascii=False, indent=2)
    
    def add_record(self):
        """添加今天的天气记录"""
        today = datetime.date.today().strftime("%Y-%m-%d")
        
        print(f"\n📅 记录日期：{today}")
        
        # 天气选项
        weather_options = ["☀️ 晴天", "☁️ 多云", "🌧️ 雨天", "❄️ 雪天", "🌫️ 雾天"]
        print("\n选择今天的天气：")
        for i, weather in enumerate(weather_options, 1):
            print(f"{i}. {weather}")
        
        try:
            choice = int(input("请选择（1-5）："))
            weather = weather_options[choice - 1]
        except:
            print("❌ 无效选择，默认设为晴天")
            weather = weather_options[0]
        
        # 温度
        try:
            temp = float(input("今天的温度（℃）："))
        except:
            temp = 20.0
            print("❌ 无效输入，默认设为20℃")
        
        # 心情
        mood = input("今天的心情如何？")
        
        # 保存记录
        self.records[today] = {
            "weather": weather,
            "temperature": temp,
            "mood": mood,
            "timestamp": datetime.datetime.now().strftime("%H:%M:%S")
        }
        
        self.save_records()
        print("✅ 天气记录已保存！")
    
    def view_records(self):
        """查看天气记录"""
        if not self.records:
            print("📋 还没有天气记录")
            return
        
        print("\n=== 天气记录 ===")
        # 按日期排序
        sorted_dates = sorted(self.records.keys(), reverse=True)
        
        for date in sorted_dates[:7]:  # 显示最近7天
            record = self.records[date]
            print(f"\n📅 {date}")
            print(f"  天气：{record['weather']}")
            print(f"  温度：{record['temperature']}℃")
            print(f"  心情：{record['mood']}")
    
    def weather_statistics(self):
        """天气统计"""
        if not self.records:
            print("📋 还没有足够的数据进行统计")
            return
        
        # 统计各种天气出现的次数
        weather_count = {}
        total_temp = 0
        
        for record in self.records.values():
            weather = record['weather']
            weather_count[weather] = weather_count.get(weather, 0) + 1
            total_temp += record['temperature']
        
        print("\n=== 天气统计 ===")
        print(f"总记录天数：{len(self.records)}")
        print(f"平均温度：{total_temp / len(self.records):.1f}℃")
        
        print("\n各种天气出现次数：")
        for weather, count in weather_count.items():
            percentage = count / len(self.records) * 100
            print(f"{weather}: {count}次 ({percentage:.1f}%)")
    
    def run(self):
        """主程序"""
        print("=== 天气记录器 ===")
        
        while True:
            print("\n1. 📝 记录今天的天气")
            print("2. 📊 查看天气记录")
            print("3. 📈 天气统计")
            print("4. 🚪 退出")
            
            choice = input("请选择（1-4）：")
            
            if choice == "1":
                self.add_record()
            elif choice == "2":
                self.view_records()
            elif choice == "3":
                self.weather_statistics()
            elif choice == "4":
                print("再见！记得每天记录天气哦！")
                break
            else:
                print("❌ 无效选择")

# 运行天气记录器
if __name__ == "__main__":
    diary = WeatherDiary()
    diary.run()
```

### 14.2 项目二：单词记忆游戏

```python
import random
import time
import json

class WordMemoryGame:
    def __init__(self):
        self.words = {
            "easy": {
                "cat": "猫",
                "dog": "狗",
                "book": "书",
                "pen": "笔",
                "red": "红色",
                "blue": "蓝色",
                "happy": "快乐",
                "sad": "悲伤",
                "big": "大",
                "small": "小"
            },
            "medium": {
                "computer": "电脑",
                "elephant": "大象",
                "beautiful": "美丽的",
                "important": "重要的",
                "breakfast": "早餐",
                "homework": "作业",
                "friend": "朋友",
                "family": "家庭",
                "teacher": "老师",
                "student": "学生"
            },
            "hard": {
                "dictionary": "字典",
                "environment": "环境",
                "technology": "技术",
                "international": "国际的",
                "communication": "交流",
                "congratulations": "祝贺",
                "responsibility": "责任",
                "achievement": "成就",
                "knowledge": "知识",
                "experience": "经验"
            }
        }
        self.score = 0
        self.high_scores = self.load_high_scores()
    
    def load_high_scores(self):
        """加载最高分记录"""
        try:
            with open("word_game_scores.json", "r") as file:
                return json.load(file)
        except:
            return {"easy": 0, "medium": 0, "hard": 0}
    
    def save_high_scores(self):
        """保存最高分"""
        with open("word_game_scores.json", "w") as file:
            json.dump(self.high_scores, file)
    
    def play_round(self, difficulty):
        """进行一轮游戏"""
        word_dict = self.words[difficulty]
        words_list = list(word_dict.items())
        random.shuffle(words_list)
        
        correct = 0
        total = min(5, len(words_list))  # 每轮5个单词
        
        print(f"\n=== {difficulty.upper()} 难度 ===")
        print(f"准备好了吗？游戏即将开始！\n")
        time.sleep(2)
        
        for i in range(total):
            english, chinese = words_list[i]
            
            print(f"\n第 {i+1}/{total} 题")
            print(f"请问 '{english}' 的中文意思是什么？")
            
            # 生成选项
            options = [chinese]
            other_meanings = [meaning for _, meaning in word_dict.items() if meaning != chinese]
            options.extend(random.sample(other_meanings, min(3, len(other_meanings))))
            random.shuffle(options)
            
            # 显示选项
            for j, option in enumerate(options, 1):
                print(f"{j}. {option}")
            
            # 获取答案
            try:
                answer = int(input("你的选择（输入数字）："))
                if 1 <= answer <= len(options) and options[answer-1] == chinese:
                    print("✅ 正确！")
                    correct += 1
                    self.score += {"easy": 10, "medium": 20, "hard": 30}[difficulty]
                else:
                    print(f"❌ 错误！正确答案是：{chinese}")
            except:
                print(f"❌ 错误！正确答案是：{chinese}")
        
        # 显示本轮成绩
        accuracy = correct / total * 100
        print(f"\n本轮成绩：{correct}/{total} (正确率：{accuracy:.0f}%)")
        print(f"当前总分：{self.score}")
        
        # 更新最高分
        if self.score > self.high_scores[difficulty]:
            self.high_scores[difficulty] = self.score
            print(f"🎉 新纪录！{difficulty}难度最高分：{self.score}")
            self.save_high_scores()
    
    def study_mode(self):
        """学习模式 - 浏览所有单词"""
        print("\n=== 学习模式 ===")
        print("选择要学习的难度：")
        print("1. Easy (简单)")
        print("2. Medium (中等)")
        print("3. Hard (困难)")
        
        choice = input("请选择（1-3）：")
        difficulty_map = {"1": "easy", "2": "medium", "3": "hard"}
        
        if choice not in difficulty_map:
            print("❌ 无效选择")
            return
        
        difficulty = difficulty_map[choice]
        word_dict = self.words[difficulty]
        
        print(f"\n{difficulty.upper()} 难度的单词：")
        for english, chinese in word_dict.items():
            print(f"{english:20} - {chinese}")
            time.sleep(0.5)  # 慢慢显示，方便记忆
    
    def show_high_scores(self):
        """显示最高分"""
        print("\n=== 最高分记录 ===")
        for difficulty, score in self.high_scores.items():
            print(f"{difficulty.capitalize():10} : {score} 分")
    
    def run(self):
        """主程序"""
        print("=== 单词记忆游戏 ===")
        print("通过游戏学习英语单词！")
        
        while True:
            print("\n1. 🎮 开始游戏")
            print("2. 📚 学习模式")
            print("3. 🏆 查看最高分")
            print("4. 🚪 退出游戏")
            
            choice = input("请选择（1-4）：")
            
            if choice == "1":
                print("\n选择难度：")
                print("1. Easy (简单)")
                print("2. Medium (中等)")
                print("3. Hard (困难)")
                
                diff_choice = input("请选择（1-3）：")
                difficulty_map = {"1": "easy", "2": "medium", "3": "hard"}
                
                if diff_choice in difficulty_map:
                    self.score = 0  # 重置分数
                    self.play_round(difficulty_map[diff_choice])
                else:
                    print("❌ 无效选择")
            
            elif choice == "2":
                self.study_mode()
            
            elif choice == "3":
                self.show_high_scores()
            
            elif choice == "4":
                print("再见！继续努力学习英语哦！")
                break
            
            else:
                print("❌ 无效选择")

# 运行游戏
if __name__ == "__main__":
    game = WordMemoryGame()
    game.run()
```

### 14.3 项目三：班级值日表管理系统

```python
import datetime
import json
import random

class DutyScheduler:
    def __init__(self):
        self.students = []
        self.schedule = {}
        self.tasks = ["擦黑板", "扫地", "拖地", "倒垃圾", "整理讲台", "浇花"]
        self.load_data()
    
    def load_data(self):
        """加载数据"""
        try:
            with open("duty_data.json", "r", encoding="utf-8") as file:
                data = json.load(file)
                self.students = data.get("students", [])
                self.schedule = data.get("schedule", {})
        except:
            pass
    
    def save_data(self):
        """保存数据"""
        data = {
            "students": self.students,
            "schedule": self.schedule
        }
        with open("duty_data.json", "w", encoding="utf-8") as file:
            json.dump(data, file, ensure_ascii=False, indent=2)
    
    def manage_students(self):
        """管理学生名单"""
        while True:
            print(f"\n当前学生名单（{len(self.students)}人）：")
            if self.students:
                for i, student in enumerate(self.students, 1):
                    print(f"{i}. {student}")
            else:
                print("还没有学生")
            
            print("\n1. 添加学生")
            print("2. 删除学生")
            print("3. 返回主菜单")
            
            choice = input("请选择（1-3）：")
            
            if choice == "1":
                name = input("学生姓名：").strip()
                if name and name not in self.students:
                    self.students.append(name)
                    print(f"✅ {name} 已添加")
                    self.save_data()
                else:
                    print("❌ 姓名无效或已存在")
            
            elif choice == "2":
                if self.students:
                    try:
                        index = int(input("要删除的学生编号：")) - 1
                        if 0 <= index < len(self.students):
                            removed = self.students.pop(index)
                            print(f"✅ {removed} 已删除")
                            self.save_data()
                        else:
                            print("❌ 无效的编号")
                    except:
                        print("❌ 请输入有效的数字")
                else:
                    print("❌ 没有可删除的学生")
            
            elif choice == "3":
                break
    
    def generate_schedule(self):
        """生成值日表"""
        if len(self.students) < len(self.tasks):
            print(f"❌ 学生人数（{len(self.students)}）少于任务数（{len(self.tasks)}）")
            print("请先添加更多学生")
            return
        
        # 获取日期范围
        try:
            days = int(input("生成几天的值日表？"))
            if days <= 0:
                raise ValueError
        except:
            print("❌ 请输入有效的天数")
            return
        
        # 生成值日表
        start_date = datetime.date.today()
        
        for i in range(days):
            current_date = start_date + datetime.timedelta(days=i)
            date_str = current_date.strftime("%Y-%m-%d")
            
            # 为这一天随机分配学生
            available_students = self.students.copy()
            random.shuffle(available_students)
            
            day_schedule = {}
            for j, task in enumerate(self.tasks):
                if j < len(available_students):
                    day_schedule[task] = available_students[j]
            
            self.schedule[date_str] = day_schedule
        
        self.save_data()
        print(f"✅ 已生成{days}天的值日表")
    
    def view_schedule(self):
        """查看值日表"""
        if not self.schedule:
            print("📋 还没有值日表")
            return
        
        print("\n查看选项：")
        print("1. 今天的值日安排")
        print("2. 本周的值日安排")
        print("3. 查看特定日期")
        print("4. 查看所有安排")
        
        choice = input("请选择（1-4）：")
        
        if choice == "1":
            today = datetime.date.today().strftime("%Y-%m-%d")
            if today in self.schedule:
                self._print_day_schedule(today)
            else:
                print("❌ 今天没有值日安排")
        
        elif choice == "2":
            today = datetime.date.today()
            monday = today - datetime.timedelta(days=today.weekday())
            
            print("\n=== 本周值日表 ===")
            for i in range(7):
                date = monday + datetime.timedelta(days=i)
                date_str = date.strftime("%Y-%m-%d")
                if date_str in self.schedule:
                    self._print_day_schedule(date_str)
        
        elif choice == "3":
            date_str = input("请输入日期（格式：YYYY-MM-DD）：")
            if date_str in self.schedule:
                self._print_day_schedule(date_str)
            else:
                print("❌ 该日期没有值日安排")
        
        elif choice == "4":
            sorted_dates = sorted(self.schedule.keys())
            for date_str in sorted_dates:
                self._print_day_schedule(date_str)
    
    def _print_day_schedule(self, date_str):
        """打印某一天的值日安排"""
        # 解析日期
        date = datetime.datetime.strptime(date_str, "%Y-%m-%d").date()
        weekday = ["星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"][date.weekday()]
        
        print(f"\n📅 {date_str} {weekday}")
        day_schedule = self.schedule[date_str]
        for task, student in day_schedule.items():
            print(f"  {task}: {student}")
    
    def check_duty_record(self):
        """查看值日统计"""
        if not self.schedule:
            print("📋 还没有值日记录")
            return
        
        # 统计每个学生的值日次数
        duty_count = {}
        for day_schedule in self.schedule.values():
            for task, student in day_schedule.items():
                if student not in duty_count:
                    duty_count[student] = {"total": 0, "tasks": {}}
                duty_count[student]["total"] += 1
                duty_count[student]["tasks"][task] = duty_count[student]["tasks"].get(task, 0) + 1
        
        print("\n=== 值日统计 ===")
        for student in sorted(duty_count.keys()):
            info = duty_count[student]
            print(f"\n{student}:")
            print(f"  总值日次数：{info['total']}")
            print("  各项任务次数：")
            for task, count in info["tasks"].items():
                print(f"    {task}: {count}次")
    
    def run(self):
        """主程序"""
        print("=== 班级值日表管理系统 ===")
        
        while True:
            print("\n1. 👥 管理学生名单")
            print("2. 📝 生成值日表")
            print("3. 📅 查看值日表")
            print("4. 📊 值日统计")
            print("5. 🚪 退出系统")
            
            choice = input("请选择（1-5）：")
            
            if choice == "1":
                self.manage_students()
            elif choice == "2":
                self.generate_schedule()
            elif choice == "3":
                self.view_schedule()
            elif choice == "4":
                self.check_duty_record()
            elif choice == "5":
                print("再见！")
                break
            else:
                print("❌ 无效选择")

# 运行系统
if __name__ == "__main__":
    scheduler = DutyScheduler()
    scheduler.run()
```

## 第十五章：Python进阶探索

### 15.1 模块和包

当我们的程序越来越大时，把所有代码放在一个文件里会变得很难管理。这时我们可以把代码分成不同的模块（文件）。

```python
# math_tools.py - 数学工具模块
def add(a, b):
    """加法"""
    return a + b

def multiply(a, b):
    """乘法"""
    return a * b

def factorial(n):
    """计算阶乘"""
    if n <= 1:
        return 1
    return n * factorial(n - 1)

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

# main.py - 主程序
import math_tools

# 使用模块中的函数
print(math_tools.add(5, 3))
print(math_tools.factorial(5))
print(math_tools.is_prime(17))
```

### 15.2 使用标准库

Python自带了很多有用的模块，我们可以直接使用：

```python
# 1. random - 随机数模块
import random

# 随机整数
dice = random.randint(1, 6)
print(f"掷骰子：{dice}")

# 随机选择
fruits = ["苹果", "香蕉", "橙子", "葡萄"]
choice = random.choice(fruits)
print(f"随机水果：{choice}")

# 打乱列表
cards = list(range(1, 11))
random.shuffle(cards)
print(f"洗牌后：{cards}")

# 2. datetime - 日期时间模块
import datetime

# 当前时间
now = datetime.datetime.now()
print(f"现在是：{now.strftime('%Y年%m月%d日 %H:%M:%S')}")

# 计算年龄
birthday = datetime.date(2014, 5, 20)
today = datetime.date.today()
age = today.year - birthday.year
print(f"年龄：{age}岁")

# 3. os - 操作系统模块
import os

# 获取当前目录
current_dir = os.getcwd()
print(f"当前目录：{current_dir}")

# 列出目录内容
files = os.listdir(".")
print(f"目录内容：{files}")

# 4. math - 数学模块
import math

# 数学常数
print(f"圆周率：{math.pi}")
print(f"自然常数：{math.e}")

# 数学函数
print(f"16的平方根：{math.sqrt(16)}")
print(f"2的8次方：{math.pow(2, 8)}")
print(f"sin(90°)：{math.sin(math.radians(90))}")
```

### 15.3 简单的网络编程

```python
# 获取网页内容（需要安装requests: pip install requests）
import requests

def get_joke():
    """从API获取一个笑话"""
    try:
        # 这是一个返回随机笑话的API
        response = requests.get("https://official-joke-api.appspot.com/random_joke")
        if response.status_code == 200:
            joke_data = response.json()
            print(f"Q: {joke_data['setup']}")
            input("按回车看答案...")
            print(f"A: {joke_data['punchline']}")
        else:
            print("获取笑话失败")
    except Exception as e:
        print(f"出错了：{e}")

# 简单的天气查询（示例）
def check_weather_example():
    """模拟天气查询"""
    cities = {
        "北京": {"temp": 25, "weather": "晴"},
        "上海": {"temp": 28, "weather": "多云"},
        "广州": {"temp": 32, "weather": "雨"},
        "成都": {"temp": 22, "weather": "阴"}
    }
    
    city = input("查询哪个城市的天气？")
    if city in cities:
        info = cities[city]
        print(f"{city}天气：{info['weather']}，温度：{info['temp']}℃")
    else:
        print("暂不支持该城市")
```

### 15.4 简单的数据分析

```python
# 学生成绩分析系统
class GradeAnalyzer:
    def __init__(self):
        self.students_data = {}
    
    def add_student_grades(self, name, grades):
        """添加学生成绩"""
        self.students_data[name] = grades
    
    def analyze_student(self, name):
        """分析单个学生"""
        if name not in self.students_data:
            print(f"找不到学生：{name}")
            return
        
        grades = self.students_data[name]
        total = sum(grades.values())
        average = total / len(grades)
        highest = max(grades.values())
        lowest = min(grades.values())
        
        print(f"\n{name}的成绩分析：")
        print(f"总分：{total}")
        print(f"平均分：{average:.1f}")
        print(f"最高分：{highest} ({[k for k, v in grades.items() if v == highest][0]})")
        print(f"最低分：{lowest} ({[k for k, v in grades.items() if v == lowest][0]})")
        
        # 成绩评级
        if average >= 90:
            grade = "A (优秀)"
        elif average >= 80:
            grade = "B (良好)"
        elif average >= 70:
            grade = "C (中等)"
        elif average >= 60:
            grade = "D (及格)"
        else:
            grade = "F (需要努力)"
        
        print(f"综合评级：{grade}")
    
    def class_statistics(self):
        """班级统计"""
        if not self.students_data:
            print("还没有数据")
            return
        
        # 计算各科平均分
        subjects = set()
        for grades in self.students_data.values():
            subjects.update(grades.keys())
        
        print("\n班级统计报告：")
        print(f"学生人数：{len(self.students_data)}")
        
        print("\n各科平均分：")
        for subject in subjects:
            scores = [grades.get(subject, 0) for grades in self.students_data.values()]
            avg = sum(scores) / len(scores)
            print(f"{subject}: {avg:.1f}分")
        
        # 找出班级前三名
        student_averages = {}
        for name, grades in self.students_data.items():
            avg = sum(grades.values()) / len(grades)
            student_averages[name] = avg
        
        top_students = sorted(student_averages.items(), key=lambda x: x[1], reverse=True)[:3]
        
        print("\n班级前三名：")
        for i, (name, avg) in enumerate(top_students, 1):
            print(f"{i}. {name} - 平均分：{avg:.1f}")
    
    def generate_report(self):
        """生成成绩报告"""
        with open("class_report.txt", "w", encoding="utf-8") as file:
            file.write("=== 班级成绩报告 ===\n")
            file.write(f"生成时间：{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
            
            for name, grades in self.students_data.items():
                file.write(f"{name}的成绩：\n")
                for subject, score in grades.items():
                    file.write(f"  {subject}: {score}分\n")
                avg = sum(grades.values()) / len(grades)
                file.write(f"  平均分: {avg:.1f}\n\n")
        
        print("✅ 报告已生成：class_report.txt")

# 使用示例
analyzer = GradeAnalyzer()
analyzer.add_student_grades("小明", {"语文": 85, "数学": 92, "英语": 88})
analyzer.add_student_grades("小红", {"语文": 92, "数学": 88, "英语": 95})
analyzer.add_student_grades("小华", {"语文": 78, "数学": 85, "英语": 82})

analyzer.analyze_student("小明")
analyzer.class_statistics()
analyzer.generate_report()
```

### 15.5 创建你的第一个GUI程序

```python
import tkinter as tk
from tkinter import messagebox
import random

class NumberGuessingGUI:
    def __init__(self):
        self.window = tk.Tk()
        self.window.title("猜数字游戏")
        self.window.geometry("400x300")
        
        self.secret_number = random.randint(1, 100)
        self.attempts = 0
        
        self.create_widgets()
    
    def create_widgets(self):
        # 标题
        title_label = tk.Label(
            self.window, 
            text="猜数字游戏", 
            font=("Arial", 20, "bold")
        )
        title_label.pack(pady=20)
        
        # 说明
        info_label = tk.Label(
            self.window,
            text="我想了一个1到100之间的数字，你能猜到吗？",
            font=("Arial", 12)
        )
        info_label.pack()
        
        # 输入框
        self.entry = tk.Entry(self.window, font=("Arial", 14), width=10)
        self.entry.pack(pady=20)
        self.entry.bind("<Return>", lambda e: self.check_guess())
        
        # 猜测按钮
        guess_button = tk.Button(
            self.window,
            text="猜！",
            command=self.check_guess,
            font=("Arial", 14),
            bg="lightblue",
            width=10
        )
        guess_button.pack()
        
        # 反馈标签
        self.feedback_label = tk.Label(
            self.window,
            text="",
            font=("Arial", 12),
            fg="blue"
        )
        self.feedback_label.pack(pady=20)
        
        # 重新开始按钮
        restart_button = tk.Button(
            self.window,
            text="重新开始",
            command=self.restart_game,
            font=("Arial", 12)
        )
        restart_button.pack()
    
    def check_guess(self):
        try:
            guess = int(self.entry.get())
            self.attempts += 1
            
            if guess == self.secret_number:
                messagebox.showinfo(
                    "恭喜！",
                    f"你猜对了！\n数字是{self.secret_number}\n你用了{self.attempts}次"
                )
                self.restart_game()
            elif guess < self.secret_number:
                self.feedback_label.config(text="太小了！再大一点", fg="red")
            else:
                self.feedback_label.config(text="太大了！再小一点", fg="red")
            
            self.entry.delete(0, tk.END)
            
        except ValueError:
            messagebox.showerror("错误", "请输入一个有效的数字！")
    
    def restart_game(self):
        self.secret_number = random.randint(1, 100)
        self.attempts = 0
        self.entry.delete(0, tk.END)
        self.feedback_label.config(text="")
    
    def run(self):
        self.window.mainloop()

# 简单的计算器GUI
class SimpleCalculatorGUI:
    def __init__(self):
        self.window = tk.Tk()
        self.window.title("简单计算器")
        self.window.geometry("300x400")
        
        self.result_var = tk.StringVar()
        self.result_var.set("0")
        
        self.create_widgets()
    
    def create_widgets(self):
        # 显示屏
        display = tk.Label(
            self.window,
            textvariable=self.result_var,
            font=("Arial", 24),
            bg="white",
            anchor="e",
            padx=10
        )
        display.grid(row=0, column=0, columnspan=4, sticky="ew", padx=10, pady=10)
        
        # 按钮
        buttons = [
            ('7', 1, 0), ('8', 1, 1), ('9', 1, 2), ('/', 1, 3),
            ('4', 2, 0), ('5', 2, 1), ('6', 2, 2), ('*', 2, 3),
            ('1', 3, 0), ('2', 3, 1), ('3', 3, 2), ('-', 3, 3),
            ('0', 4, 0), ('.', 4, 1), ('=', 4, 2), ('+', 4, 3),
            ('C', 5, 0)
        ]
        
        for (text, row, col) in buttons:
            button = tk.Button(
                self.window,
                text=text,
                font=("Arial", 18),
                width=5,
                height=2,
                command=lambda t=text: self.button_click(t)
            )
            button.grid(row=row, column=col, padx=5, pady=5)
            
            if text == 'C':
                button.config(columnspan=4, width=23)
    
    def button_click(self, char):
        current = self.result_var.get()
        
        if char == 'C':
            self.result_var.set('0')
        elif char == '=':
            try:
                result = eval(current)
                self.result_var.set(str(result))
            except:
                self.result_var.set('错误')
        else:
            if current == '0' or current == '错误':
                self.result_var.set(char)
            else:
                self.result_var.set(current + char)
    
    def run(self):
        self.window.mainloop()

# 选择要运行的程序
print("选择要运行的GUI程序：")
print("1. 猜数字游戏")
print("2. 简单计算器")

choice = input("请选择（1-2）：")

if choice == "1":
    game = NumberGuessingGUI()
    game.run()
elif choice == "2":
    calc = SimpleCalculatorGUI()
    calc.run()
```

## 结语：继续你的编程之旅

亲爱的小程序员，恭喜你完成了Python编程的基础学习！在这段旅程中，你学会了：

1. **基础知识**：变量、数据类型、输入输出
2. **控制结构**：条件判断、循环
3. **数据结构**：列表、字典
4. **函数和类**：代码重用和面向对象编程
5. **文件操作**：保存和读取数据
6. **图形编程**：用Turtle画图
7. **错误处理**：让程序更健壮
8. **实际项目**：综合运用所学知识

### 下一步学什么？

1. **深入Python**：学习更多高级特性，如装饰器、生成器等
2. **Web开发**：用Flask或Django创建网站
3. **数据科学**：用NumPy、Pandas分析数据
4. **人工智能**：了解机器学习基础
5. **游戏开发**：用Pygame制作更复杂的游戏

### 编程建议

1. **多动手实践**：编程是一门实践的艺术
2. **不怕出错**：错误是最好的老师
3. **保持好奇心**：探索新的可能性
4. **分享你的作品**：和朋友一起学习
5. **坚持不懈**：每天进步一点点

记住，每一位伟大的程序员都是从"Hello, World!"开始的。保持热情，继续探索，相信有一天你会创造出令人惊叹的程序！

祝你在编程的道路上越走越远！加油！🚀

配图 (可多选)

选择新图片文件或拖拽到此处

标签