Python3基础练习题详解，从入门到熟练的 50 个实例（一）

第一部分：基础语法和变量（1-10题）

1. 打印"Hello, World!"

python 复制代码

# 题目：编写程序输出"Hello, World!"
print("Hello, World!")

# 详解：print()是Python内置的输出函数
# 括号内可以是字符串（用引号包围）、变量或表达式

2. 变量赋值和基本运算

python 复制代码

# 题目：定义两个变量并计算它们的和、差、积、商
a = 10
b = 3

sum_result = a + b
difference = a - b
product = a * b
quotient = a / b  # 浮点数除法
integer_quotient = a // b  # 整数除法
remainder = a % b  # 取余
power = a ** b  # 幂运算

print(f"和: {sum_result}")
print(f"差: {difference}")
print(f"积: {product}")
print(f"商: {quotient:.2f}")  # 保留两位小数
print(f"整数商: {integer_quotient}")
print(f"余数: {remainder}")
print(f"幂: {power}")

# 详解：Python支持多种运算符，f-string用于格式化输出

3. 交换两个变量的值

python 复制代码

# 题目：交换两个变量的值
x = 5
y = 10

# 方法1：使用临时变量
temp = x
x = y
y = temp
print(f"方法1交换后: x={x}, y={y}")

# 方法2：Python特有方式（元组解包）
x, y = 5, 10  # 重新赋值
x, y = y, x
print(f"方法2交换后: x={x}, y={y}")

# 方法3：使用加减法（不需要临时变量）
x, y = 5, 10
x = x + y
y = x - y
x = x - y
print(f"方法3交换后: x={x}, y={y}")

4. 计算矩形的面积和周长

python 复制代码

# 题目：输入长和宽，计算矩形的面积和周长
length = float(input("请输入矩形的长: "))
width = float(input("请输入矩形的宽: "))

area = length * width
perimeter = 2 * (length + width)

print(f"矩形面积: {area:.2f}")
print(f"矩形周长: {perimeter:.2f}")

# 详解：input()用于接收用户输入，返回的是字符串
# float()将字符串转换为浮点数

5. 摄氏度转华氏度

python 复制代码

# 题目：将摄氏度转换为华氏度
# 公式：华氏度 = 摄氏度 × 9/5 + 32

celsius = float(input("请输入摄氏度: "))
fahrenheit = celsius * 9/5 + 32

print(f"{celsius}摄氏度 = {fahrenheit:.2f}华氏度")

6. 计算圆的面积和周长

python 复制代码

# 题目：输入半径，计算圆的面积和周长
import math

radius = float(input("请输入圆的半径: "))
area = math.pi * radius ** 2
circumference = 2 * math.pi * radius

print(f"圆的面积: {area:.2f}")
print(f"圆的周长: {circumference:.2f}")

# 详解：math.pi是圆周率常量，math是Python数学模块

7. 判断奇偶数

python 复制代码

# 题目：判断输入的数字是奇数还是偶数
number = int(input("请输入一个整数: "))

if number % 2 == 0:
    print(f"{number} 是偶数")
else:
    print(f"{number} 是奇数")

# 详解：% 是取余运算符，if-else是条件判断语句

8. 判断闰年

python 复制代码

# 题目：判断输入的年份是否为闰年
# 闰年规则：能被4整除但不能被100整除，或者能被400整除

year = int(input("请输入年份: "))

if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print(f"{year} 年是闰年")
else:
    print(f"{year} 年不是闰年")

9. 找出三个数中的最大值

python 复制代码

# 题目：找出三个数中的最大值
a = float(input("请输入第一个数: "))
b = float(input("请输入第二个数: "))
c = float(input("请输入第三个数: "))

# 方法1：使用max函数
max_value = max(a, b, c)
print(f"最大值是: {max_value}")

# 方法2：使用if语句
if a >= b and a >= c:
    max_value = a
elif b >= a and b >= c:
    max_value = b
else:
    max_value = c
print(f"最大值是: {max_value}")

10. 计算数字的各位之和

python 复制代码

# 题目：输入一个三位数，计算其各位数字之和
number = int(input("请输入一个三位数: "))

# 方法1：数学方法
hundreds = number // 100
tens = (number // 10) % 10
units = number % 10
sum_digits = hundreds + tens + units

print(f"百位: {hundreds}, 十位: {tens}, 个位: {units}")
print(f"各位数字之和: {sum_digits}")

# 方法2：字符串方法
num_str = str(number)
sum_digits = int(num_str[0]) + int(num_str[1]) + int(num_str[2])
print(f"各位数字之和(方法2): {sum_digits}")

第二部分：字符串操作（11-20题）

11. 字符串反转

python 复制代码

# 题目：反转字符串
text = input("请输入一个字符串: ")

# 方法1：使用切片
reversed_text1 = text[::-1]
print(f"反转后的字符串(方法1): {reversed_text1}")

# 方法2：使用循环
reversed_text2 = ""
for char in text:
    reversed_text2 = char + reversed_text2
print(f"反转后的字符串(方法2): {reversed_text2}")

# 方法3：使用reversed函数
reversed_text3 = "".join(reversed(text))
print(f"反转后的字符串(方法3): {reversed_text3}")

# 详解：[::-1]是切片语法，start:stop:step

12. 判断回文字符串

python 复制代码

# 题目：判断字符串是否是回文（正读反读都一样）
text = input("请输入一个字符串: ")

# 方法1：直接比较
if text == text[::-1]:
    print(f"'{text}' 是回文字符串")
else:
    print(f"'{text}' 不是回文字符串")

# 方法2：忽略大小写和非字母数字字符
import re
cleaned_text = re.sub(r'[^a-zA-Z0-9]', '', text.lower())
if cleaned_text == cleaned_text[::-1]:
    print(f"忽略大小写和特殊字符后，'{text}' 是回文字符串")
else:
    print(f"'{text}' 不是回文字符串")

13. 统计字符出现次数

python 复制代码

# 题目：统计字符串中每个字符出现的次数
text = input("请输入一个字符串: ")

# 方法1：使用字典
char_count = {}
for char in text:
    if char in char_count:
        char_count[char] += 1
    else:
        char_count[char] = 1

print("字符出现次数统计:")
for char, count in char_count.items():
    print(f"'{char}': {count}次")

# 方法2：使用collections模块
from collections import Counter
char_count2 = Counter(text)
print("\n使用Counter统计结果:")
print(char_count2)

14. 字符串大小写转换

python 复制代码

# 题目：字符串大小写转换操作
text = "Hello World! Python Programming 2023"

print(f"原始字符串: {text}")
print(f"全部大写: {text.upper()}")
print(f"全部小写: {text.lower()}")
print(f"首字母大写: {text.capitalize()}")
print(f"每个单词首字母大写: {text.title()}")
print(f"大小写互换: {text.swapcase()}")

# 详解：字符串对象有多种方法可以修改大小写

15. 字符串查找和替换

python 复制代码

# 题目：在字符串中查找子串并进行替换
text = "Python是一门非常强大的编程语言，Python简单易学。"

# 查找
substring = "Python"
count = text.count(substring)
print(f"'{substring}' 出现了 {count} 次")

first_index = text.find(substring)
print(f"第一次出现的位置: {first_index}")

# 替换
new_text = text.replace("Python", "Java")
print(f"替换后的字符串: {new_text}")

# 全部替换（限制次数）
new_text2 = text.replace("Python", "Java", 1)
print(f"只替换一次: {new_text2}")

16. 字符串分割和连接

python 复制代码

# 题目：字符串的分割和连接操作
text = "apple,banana,orange,grape,mango"

# 分割
fruits = text.split(",")
print(f"分割后的列表: {fruits}")
print(f"第一个水果: {fruits[0]}")
print(f"最后一个水果: {fruits[-1]}")

# 连接
new_text = "-".join(fruits)
print(f"用'-'连接: {new_text}")

# 多行字符串分割
multiline_text = """第一行
第二行
第三行
第四行"""
lines = multiline_text.splitlines()
print(f"行数: {len(lines)}")
for i, line in enumerate(lines, 1):
    print(f"第{i}行: {line}")

17. 字符串去除空白字符

python 复制代码

# 题目：去除字符串中的空白字符
text = "   Python 编程  \t\n  "

print(f"原始字符串: '{text}'")
print(f"去除左侧空白: '{text.lstrip()}'")
print(f"去除右侧空白: '{text.rstrip()}'")
print(f"去除两侧空白: '{text.strip()}'")

# 去除特定字符
text2 = "***Python***"
print(f"去除*号: '{text2.strip('*')}'")

18. 字符串格式化

python 复制代码

# 题目：使用不同方法格式化字符串
name = "张三"
age = 25
score = 95.5

# 方法1：使用%格式化（旧式）
formatted1 = "姓名: %s, 年龄: %d, 分数: %.2f" % (name, age, score)
print(f"方法1: {formatted1}")

# 方法2：使用format方法（Python 2.6+）
formatted2 = "姓名: {}, 年龄: {}, 分数: {:.2f}".format(name, age, score)
print(f"方法2: {formatted2}")

# 方法3：使用f-string（Python 3.6+，推荐）
formatted3 = f"姓名: {name}, 年龄: {age}, 分数: {score:.2f}"
print(f"方法3: {formatted3}")

# 更复杂的格式化
import math
print(f"π的值: {math.pi:.4f}")  # 保留4位小数
print(f"年龄: {age:05d}")  # 宽度5，不足补0
print(f"分数: {score:8.2f}")  # 宽度8，保留2位小数

19. 检查字符串开头和结尾

python 复制代码

# 题目：检查字符串是否以特定内容开头或结尾
text = "example.txt"

# 检查开头
if text.startswith("ex"):
    print("字符串以'ex'开头")
    
if text.startswith(("ex", "ax", "bx")):  # 可以传入元组检查多个
    print("字符串以'ex', 'ax'或'bx'之一开头")

# 检查结尾
if text.endswith(".txt"):
    print("字符串以'.txt'结尾")
    
if text.endswith((".txt", ".pdf", ".doc")):
    print("字符串是文本或文档文件")

# 实际应用：文件类型检查
filename = "document.pdf"
if filename.endswith((".pdf", ".doc", ".docx")):
    print(f"{filename} 是一个文档文件")
elif filename.endswith((".jpg", ".png", ".gif")):
    print(f"{filename} 是一个图像文件")
else:
    print(f"{filename} 是其他类型的文件")

20. 字符串编码和解码

python 复制代码

# 题目：字符串的编码和解码操作
text = "你好，世界！"

# 编码为字节
encoded = text.encode("utf-8")
print(f"UTF-8编码: {encoded}")
print(f"编码类型: {type(encoded)}")

# 解码为字符串
decoded = encoded.decode("utf-8")
print(f"解码后: {decoded}")

# 其他编码方式
encoded_gbk = text.encode("gbk")
print(f"GBK编码: {encoded_gbk}")

# 处理编码错误
try:
    # 尝试用错误的编码解码
    wrong_decoded = encoded_gbk.decode("utf-8")
except UnicodeDecodeError as e:
    print(f"解码错误: {e}")
    # 使用错误处理参数
    safe_decoded = encoded_gbk.decode("utf-8", errors="ignore")
    print(f"忽略错误解码: {safe_decoded}")

第三部分：列表和元组（21-30题）

21. 列表基本操作

python 复制代码

# 题目：列表的创建、访问和修改
# 创建列表
fruits = ["apple", "banana", "cherry", "orange", "mango"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "apple", 3.14, True]

print(f"水果列表: {fruits}")
print(f"第二个水果: {fruits[1]}")
print(f"最后一个水果: {fruits[-1]}")

# 修改元素
fruits[1] = "blueberry"
print(f"修改后的列表: {fruits}")

# 添加元素
fruits.append("grape")  # 末尾添加
print(f"添加葡萄后: {fruits}")

fruits.insert(2, "kiwi")  # 指定位置插入
print(f"插入猕猴桃后: {fruits}")

# 删除元素
removed = fruits.pop()  # 删除最后一个
print(f"删除的元素: {removed}")
print(f"删除后: {fruits}")

fruits.remove("cherry")  # 删除指定元素
print(f"删除cherry后: {fruits}")

del fruits[0]  # 删除指定位置
print(f"删除第一个元素后: {fruits}")

22. 列表切片操作

python 复制代码

# 题目：列表的切片操作
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(f"完整列表: {numbers}")
print(f"前三个元素: {numbers[:3]}")
print(f"第三个到第六个元素: {numbers[2:6]}")
print(f"从第五个到末尾: {numbers[4:]}")
print(f"最后三个元素: {numbers[-3:]}")
print(f"所有元素（反转）: {numbers[::-1]}")
print(f"偶数索引元素: {numbers[::2]}")
print(f"奇数索引元素: {numbers[1::2]}")

# 切片修改
numbers[2:5] = [20, 30, 40]
print(f"修改切片后: {numbers}")

# 切片复制（浅拷贝）
numbers_copy = numbers[:]
numbers_copy[0] = 100
print(f"原列表: {numbers}")
print(f"复制列表: {numbers_copy}")

23. 列表排序和反转

python 复制代码

# 题目：列表的排序和反转操作
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]

# 排序（改变原列表）
numbers.sort()
print(f"升序排序: {numbers}")

numbers.sort(reverse=True)
print(f"降序排序: {numbers}")

# 排序（不改变原列表，返回新列表）
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]
sorted_numbers = sorted(numbers)
print(f"原列表: {numbers}")
print(f"新排序列表: {sorted_numbers}")

# 自定义排序
words = ["apple", "banana", "cherry", "date", "elderberry"]
words.sort(key=len)  # 按长度排序
print(f"按长度排序: {words}")

# 反转
numbers = [1, 2, 3, 4, 5]
numbers.reverse()
print(f"反转后: {numbers}")

# 使用切片反转（不改变原列表）
numbers = [1, 2, 3, 4, 5]
reversed_numbers = numbers[::-1]
print(f"原列表: {numbers}")
print(f"反转列表: {reversed_numbers}")

24. 列表推导式

python 复制代码

# 题目：使用列表推导式创建和转换列表
# 创建平方列表
numbers = [1, 2, 3, 4, 5]
squares = [x**2 for x in numbers]
print(f"平方列表: {squares}")

# 过滤偶数
evens = [x for x in numbers if x % 2 == 0]
print(f"偶数列表: {evens}")

# 双重循环
pairs = [(x, y) for x in range(3) for y in range(3)]
print(f"坐标对: {pairs}")

# 字符串处理
words = ["hello", "world", "python", "programming"]
lengths = [len(word) for word in words]
print(f"单词长度: {lengths}")

# 条件表达式
numbers = [1, 2, 3, 4, 5]
result = ["偶数" if x % 2 == 0 else "奇数" for x in numbers]
print(f"奇偶判断: {result}")

# 嵌套列表推导式
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(f"扁平化矩阵: {flattened}")

25. 列表合并和复制

python 复制代码

# 题目：列表的合并和复制操作
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = [7, 8, 9]

# 合并列表
combined = list1 + list2
print(f"合并后: {combined}")

# 扩展列表
list1.extend(list2)
print(f"扩展后list1: {list1}")

# 列表复制（浅拷贝）
original = [[1, 2], [3, 4]]
shallow_copy = original.copy()
shallow_copy[0][0] = 100
print(f"原列表: {original}")
print(f"浅拷贝: {shallow_copy}")

# 列表深拷贝
import copy
original = [[1, 2], [3, 4]]
deep_copy = copy.deepcopy(original)
deep_copy[0][0] = 100
print(f"原列表: {original}")
print(f"深拷贝: {deep_copy}")

# 乘法复制
repeated = [0] * 5
print(f"重复列表: {repeated}")

26. 元组基本操作

python 复制代码

# 题目：元组的创建和基本操作
# 创建元组
tuple1 = (1, 2, 3, 4, 5)
tuple2 = 1, 2, 3  # 括号可以省略
single_tuple = (5,)  # 单个元素的元组需要逗号
empty_tuple = ()

print(f"元组1: {tuple1}")
print(f"元组2: {tuple2}")
print(f"单个元素元组: {single_tuple}")
print(f"空元组: {empty_tuple}")

# 访问元素
print(f"第一个元素: {tuple1[0]}")
print(f"最后一个元素: {tuple1[-1]}")
print(f"切片: {tuple1[1:4]}")

# 元组是不可变的，不能修改
# tuple1[0] = 10  # 这行会报错

# 但可以重新赋值
tuple1 = (10, 20, 30)
print(f"重新赋值后: {tuple1}")

# 元组解包
a, b, c = (1, 2, 3)
print(f"解包: a={a}, b={b}, c={c}")

# 交换变量
x, y = 5, 10
x, y = y, x
print(f"交换后: x={x}, y={y}")

# 元组方法
numbers = (1, 2, 3, 2, 4, 2, 5)
print(f"2出现的次数: {numbers.count(2)}")
print(f"4的索引: {numbers.index(4)}")

27. 列表和元组的转换

python 复制代码

# 题目：列表和元组之间的转换
# 列表转元组
my_list = [1, 2, 3, 4, 5]
my_tuple = tuple(my_list)
print(f"列表: {my_list}")
print(f"转换后的元组: {my_tuple}")
print(f"类型: {type(my_tuple)}")

# 元组转列表
my_tuple = (6, 7, 8, 9, 10)
my_list = list(my_tuple)
print(f"\n元组: {my_tuple}")
print(f"转换后的列表: {my_list}")
print(f"类型: {type(my_list)}")

# 字符串转列表和元组
text = "Hello"
list_from_str = list(text)
tuple_from_str = tuple(text)
print(f"\n字符串: {text}")
print(f"字符串转列表: {list_from_str}")
print(f"字符串转元组: {tuple_from_str}")

# 实际应用：函数返回多个值
def get_stats(numbers):
    """返回列表的最小值、最大值和平均值"""
    return min(numbers), max(numbers), sum(numbers)/len(numbers)

data = [10, 20, 30, 40, 50]
stats = get_stats(data)
print(f"\n数据: {data}")
print(f"统计结果(元组): {stats}")
print(f"最小值: {stats[0]}, 最大值: {stats[1]}, 平均值: {stats[2]:.2f}")

# 直接解包
min_val, max_val, avg_val = get_stats(data)
print(f"解包: 最小值={min_val}, 最大值={max_val}, 平均值={avg_val:.2f}")

28. 列表常用方法

python 复制代码

# 题目：列表的常用方法练习
numbers = [1, 2, 3, 4, 5]

# 添加元素
numbers.append(6)  # 末尾添加
print(f"添加6后: {numbers}")

numbers.insert(2, 99)  # 指定位置插入
print(f"在位置2插入99后: {numbers}")

# 删除元素
removed = numbers.pop()  # 删除最后一个
print(f"删除的元素: {removed}")
print(f"删除后: {numbers}")

removed = numbers.pop(2)  # 删除指定位置
print(f"删除位置2的元素: {removed}")
print(f"删除后: {numbers}")

numbers.remove(4)  # 删除第一个匹配的元素
print(f"删除4后: {numbers}")

# 查找元素
if 3 in numbers:
    print("3在列表中")
    
index = numbers.index(3)
print(f"3的索引: {index}")

count = numbers.count(2)
print(f"2出现的次数: {count}")

# 清空列表
numbers.clear()
print(f"清空后: {numbers}")

# 扩展列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(f"扩展后: {list1}")

29. 列表的嵌套和遍历

python 复制代码

# 题目：嵌套列表的操作和遍历
# 创建嵌套列表（矩阵）
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

print("矩阵:")
for row in matrix:
    print(row)

# 访问元素
print(f"第一行: {matrix[0]}")
print(f"第二行第三个元素: {matrix[1][2]}")

# 修改元素
matrix[0][0] = 100
print(f"\n修改后的矩阵:")
for row in matrix:
    print(row)

# 遍历嵌套列表
print("\n遍历所有元素:")
for i in range(len(matrix)):
    for j in range(len(matrix[i])):
        print(f"matrix[{i}][{j}] = {matrix[i][j]}", end="  ")
    print()

print("\n使用enumerate:")
for i, row in enumerate(matrix):
    for j, value in enumerate(row):
        print(f"matrix[{i}][{j}] = {value}", end="  ")
    print()

# 创建三维列表
cube = [
    [[1, 2], [3, 4]],
    [[5, 6], [7, 8]]
]
print(f"\n三维列表: {cube}")
print(f"访问元素: cube[0][1][0] = {cube[0][1][0]}")

30. 列表去重和统计

python 复制代码

# 题目：列表去重和元素统计
numbers = [1, 2, 2, 3, 4, 4, 4, 5, 5, 6, 6, 6, 6]

# 方法1：使用集合（不保持顺序）
unique_set = set(numbers)
unique_list1 = list(unique_set)
print(f"使用集合去重: {unique_list1}")

# 方法2：使用循环（保持顺序）
unique_list2 = []
for num in numbers:
    if num not in unique_list2:
        unique_list2.append(num)
print(f"使用循环去重(保持顺序): {unique_list2}")

# 方法3：使用字典（Python 3.7+保持顺序）
unique_list3 = list(dict.fromkeys(numbers))
print(f"使用字典去重(保持顺序): {unique_list3}")

# 统计元素出现次数
from collections import Counter
counter = Counter(numbers)
print(f"\n元素统计:")
for num, count in counter.items():
    print(f"{num}: {count}次")

# 找出出现次数最多的元素
most_common = counter.most_common(1)
print(f"出现次数最多的元素: {most_common[0][0]} (出现{most_common[0][1]}次)")

# 找出只出现一次的元素
unique_once = [num for num, count in counter.items() if count == 1]
print(f"只出现一次的元素: {unique_once}")

第四部分：字典和集合（31-40题）

31. 字典基本操作

python 复制代码

# 题目：字典的创建、访问和修改
# 创建字典
student = {
    "name": "张三",
    "age": 20,
    "major": "计算机科学",
    "grades": [85, 90, 88]
}

print(f"学生信息: {student}")
print(f"学生姓名: {student['name']}")
print(f"学生年龄: {student.get('age')}")

# 修改值
student["age"] = 21
print(f"修改年龄后: {student}")

# 添加新键值对
student["email"] = "zhangsan@example.com"
print(f"添加邮箱后: {student}")

# 删除键值对
removed = student.pop("grades")
print(f"删除的成绩: {removed}")
print(f"删除后: {student}")

del student["email"]
print(f"删除邮箱后: {student}")

# 清空字典
student.clear()
print(f"清空后: {student}")

32. 字典遍历

python 复制代码

# 题目：字典的遍历操作
student = {
    "name": "李四",
    "age": 22,
    "major": "数学",
    "university": "清华大学"
}

print("遍历键:")
for key in student:
    print(f"键: {key}")

print("\n遍历键(使用keys方法):")
for key in student.keys():
    print(f"键: {key}")

print("\n遍历值:")
for value in student.values():
    print(f"值: {value}")

print("\n遍历键值对:")
for key, value in student.items():
    print(f"{key}: {value}")

# 字典推导式
squares = {x: x**2 for x in range(1, 6)}
print(f"\n字典推导式创建的字典: {squares}")

# 过滤字典
student = {"name": "王五", "age": 23, "score": 95, "grade": "A"}
filtered = {k: v for k, v in student.items() if isinstance(v, str)}
print(f"只保留字符串值的字典: {filtered}")

33. 字典合并和更新

python 复制代码

# 题目：字典的合并和更新操作
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
dict3 = {"d": 5, "e": 6}

# 方法1：update方法（修改原字典）
dict1.update(dict2)
print(f"update后dict1: {dict1}")

# 方法2：字典解包（Python 3.5+）
merged = {**dict1, **dict3}
print(f"合并后: {merged}")

# 方法3：使用 | 运算符（Python 3.9+）
# merged = dict1 | dict3  # Python 3.9及以上支持
# print(f"使用|合并: {merged}")

# 实际应用：配置文件合并
default_config = {
    "host": "localhost",
    "port": 8080,
    "debug": False
}

user_config = {
    "port": 9000,
    "debug": True
}

# 合并配置，用户配置优先
final_config = {**default_config, **user_config}
print(f"\n默认配置: {default_config}")
print(f"用户配置: {user_config}")
print(f"最终配置: {final_config}")

34. 字典排序

python 复制代码

# 题目：字典按照键或值排序
student_scores = {
    "张三": 85,
    "李四": 92,
    "王五": 78,
    "赵六": 95,
    "钱七": 88
}

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

# 按键排序
sorted_by_key = dict(sorted(student_scores.items()))
print("\n按键排序:")
for name, score in sorted_by_key.items():
    print(f"{name}: {score}")

# 按值排序（升序）
sorted_by_value = dict(sorted(student_scores.items(), key=lambda item: item[1]))
print("\n按值排序(升序):")
for name, score in sorted_by_value.items():
    print(f"{name}: {score}")

# 按值排序（降序）
sorted_by_value_desc = dict(sorted(student_scores.items(), key=lambda item: item[1], reverse=True))
print("\n按值排序(降序):")
for name, score in sorted_by_value_desc.items():
    print(f"{name}: {score}")

# 获取最高分和最低分
highest = max(student_scores.items(), key=lambda item: item[1])
lowest = min(student_scores.items(), key=lambda item: item[1])
print(f"\n最高分: {highest[0]} ({highest[1]}分)")
print(f"最低分: {lowest[0]} ({lowest[1]}分)")

35. 嵌套字典

python 复制代码

# 题目：嵌套字典的操作
school = {
    "class1": {
        "teacher": "张老师",
        "students": ["张三", "李四", "王五"],
        "scores": {"数学": 85, "语文": 90, "英语": 88}
    },
    "class2": {
        "teacher": "李老师",
        "students": ["赵六", "钱七", "孙八"],
        "scores": {"数学": 92, "语文": 88, "英语": 95}
    }
}

print("学校信息:")
for class_name, class_info in school.items():
    print(f"\n{class_name}:")
    print(f"  班主任: {class_info['teacher']}")
    print(f"  学生: {', '.join(class_info['students'])}")
    print(f"  成绩:")
    for subject, score in class_info['scores'].items():
        print(f"    {subject}: {score}分")

# 访问嵌套元素
print(f"\n访问嵌套元素:")
print(f"class1的班主任: {school['class1']['teacher']}")
print(f"class2的数学成绩: {school['class2']['scores']['数学']}")

# 修改嵌套元素
school['class1']['scores']['数学'] = 90
school['class1']['students'].append("周九")

print(f"\n修改后class1的学生: {school['class1']['students']}")
print(f"修改后class1的数学成绩: {school['class1']['scores']['数学']}")

# 添加新班级
school['class3'] = {
    "teacher": "王老师",
    "students": ["吴十", "郑十一"],
    "scores": {"数学": 85, "语文": 92, "英语": 87}
}
print(f"\n添加新班级后，班级数量: {len(school)}")

36. 集合基本操作

python 复制代码

# 题目：集合的创建和基本操作
# 创建集合
set1 = {1, 2, 3, 4, 5}
set2 = set([4, 5, 6, 7, 8])
set3 = set()  # 空集合

print(f"set1: {set1}")
print(f"set2: {set2}")

# 集合运算
print(f"\n并集: {set1 | set2}")
print(f"交集: {set1 & set2}")
print(f"差集(set1-set2): {set1 - set2}")
print(f"差集(set2-set1): {set2 - set1}")
print(f"对称差集: {set1 ^ set2}")  # 在set1或set2中，但不同时在两者中

# 集合方法
set1.add(6)
print(f"\n添加6后set1: {set1}")

set1.remove(6)  # 如果元素不存在会报错
print(f"删除6后set1: {set1}")

set1.discard(10)  # 如果元素不存在不会报错
print(f"尝试删除10后set1: {set1}")

popped = set1.pop()  # 随机删除一个元素
print(f"弹出元素: {popped}")
print(f"弹出后set1: {set1}")

# 集合推导式
squares = {x**2 for x in range(1, 6)}
print(f"\n平方集合: {squares}")

37. 集合去重和成员检查

python 复制代码

# 题目：使用集合进行去重和成员检查
# 列表去重
numbers = [1, 2, 2, 3, 4, 4, 4, 5, 5, 6, 6, 6, 6]
unique_numbers = list(set(numbers))
print(f"原始列表: {numbers}")
print(f"去重后: {unique_numbers}")

# 保持顺序的去重方法
def deduplicate_keep_order(lst):
    seen = set()
    result = []
    for item in lst:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result

ordered_unique = deduplicate_keep_order(numbers)
print(f"保持顺序的去重: {ordered_unique}")

# 成员检查效率比较
import time

large_list = list(range(1000000))
large_set = set(large_list)

# 列表成员检查
start = time.time()
999999 in large_list
list_time = time.time() - start

# 集合成员检查
start = time.time()
999999 in large_set
set_time = time.time() - start

print(f"\n成员检查效率:")
print(f"列表查找时间: {list_time:.6f}秒")
print(f"集合查找时间: {set_time:.6f}秒")
print(f"集合比列表快 {list_time/set_time:.0f} 倍")

# 实际应用：查找共同元素
students_math = {"张三", "李四", "王五", "赵六"}
students_physics = {"李四", "王五", "钱七", "孙八"}

both_courses = students_math & students_physics
print(f"\n同时选修数学和物理的学生: {both_courses}")
print(f"只选修数学的学生: {students_math - students_physics}")
print(f"只选修物理的学生: {students_physics - students_math}")
print(f"选修任意一门的学生: {students_math | students_physics}")

38. 字典的默认值处理

python 复制代码

# 题目：字典的默认值处理
# 统计单词频率
text = "apple banana apple orange banana apple mango"
words = text.split()

# 方法1：使用if语句
word_count1 = {}
for word in words:
    if word in word_count1:
        word_count1[word] += 1
    else:
        word_count1[word] = 1
print(f"方法1统计结果: {word_count1}")

# 方法2：使用get方法
word_count2 = {}
for word in words:
    word_count2[word] = word_count2.get(word, 0) + 1
print(f"方法2统计结果: {word_count2}")

# 方法3：使用defaultdict
from collections import defaultdict
word_count3 = defaultdict(int)  # 默认值为0
for word in words:
    word_count3[word] += 1
print(f"方法3统计结果: {dict(word_count3)}")

# 更复杂的默认值
def default_factory():
    return {"count": 0, "positions": []}

word_info = defaultdict(default_factory)
for i, word in enumerate(words):
    word_info[word]["count"] += 1
    word_info[word]["positions"].append(i)

print("\n详细单词信息:")
for word, info in word_info.items():
    print(f"{word}: 出现{info['count']}次，位置{info['positions']}")

39. 字典和JSON转换

python 复制代码

# 题目：字典和JSON之间的转换
import json

# Python字典
student = {
    "name": "张三",
    "age": 20,
    "courses": ["数学", "物理", "化学"],
    "grades": {"数学": 90, "物理": 85, "化学": 92},
    "graduated": False
}

# 字典转JSON
json_str = json.dumps(student, ensure_ascii=False, indent=2)
print("字典转JSON:")
print(json_str)

# JSON转字典
parsed_dict = json.loads(json_str)
print("\nJSON转字典:")
print(parsed_dict)
print(f"类型: {type(parsed_dict)}")

# 读写JSON文件
# 写入文件
with open("student.json", "w", encoding="utf-8") as f:
    json.dump(student, f, ensure_ascii=False, indent=2)

# 读取文件
with open("student.json", "r", encoding="utf-8") as f:
    loaded_dict = json.load(f)

print("\n从文件加载的字典:")
print(loaded_dict)

# 处理特殊类型
import datetime

data = {
    "name": "测试",
    "date": datetime.datetime.now(),
    "price": 99.99
}

# 自定义序列化函数
def custom_serializer(obj):
    if isinstance(obj, datetime.datetime):
        return obj.isoformat()
    raise TypeError(f"类型 {type(obj)} 不可序列化")

json_str2 = json.dumps(data, default=custom_serializer, ensure_ascii=False)
print(f"\n自定义序列化: {json_str2}")

40. 字典视图对象

python 复制代码

# 题目：字典视图对象的使用
student = {
    "name": "李四",
    "age": 22,
    "major": "计算机科学",
    "university": "清华大学"
}

# 获取视图对象
keys_view = student.keys()
values_view = student.values()
items_view = student.items()

print(f"原始字典: {student}")
print(f"键视图: {keys_view}")
print(f"值视图: {values_view}")
print(f"键值对视图: {items_view}")

# 视图是动态的
student["email"] = "lisi@example.com"
print(f"\n添加邮箱后:")
print(f"键视图: {keys_view}")
print(f"值视图: {values_view}")

# 视图可以迭代和转换为其他类型
print(f"\n转换为列表:")
print(f"键列表: {list(keys_view)}")
print(f"值列表: {list(values_view)}")
print(f"键值对列表: {list(items_view)}")

# 视图支持集合操作
student2 = {"name": "王五", "age": 23, "city": "北京"}

common_keys = student.keys() & student2.keys()
print(f"\n共同键: {common_keys}")

unique_to_student = student.keys() - student2.keys()
print(f"student独有的键: {unique_to_student}")

# 实际应用：筛选字典
# 只保留两个字典中都有的键
common_dict = {k: student[k] for k in common_keys}
print(f"共同键对应的字典: {common_dict}")

第五部分：函数和模块（41-50题）

41. 函数定义和调用

python 复制代码

# 题目：函数的定义和调用
# 定义简单函数
def greet(name):
    """向指定的人问好"""
    return f"你好，{name}！"

# 调用函数
message = greet("张三")
print(message)

# 带默认参数的函数
def greet_person(name, greeting="你好", punctuation="！"):
    """带默认参数的问候函数"""
    return f"{greeting}，{name}{punctuation}"

print(greet_person("李四"))
print(greet_person("王五", greeting="Hello", punctuation="!"))

# 返回多个值
def calculate_stats(numbers):
    """计算数字列表的统计信息"""
    count = len(numbers)
    total = sum(numbers)
    average = total / count if count > 0 else 0
    maximum = max(numbers) if numbers else None
    minimum = min(numbers) if numbers else None
    return count, total, average, maximum, minimum

data = [10, 20, 30, 40, 50]
stats = calculate_stats(data)
print(f"\n数据统计:")
print(f"数量: {stats[0]}")
print(f"总和: {stats[1]}")
print(f"平均值: {stats[2]:.2f}")
print(f"最大值: {stats[3]}")
print(f"最小值: {stats[4]}")

# 解包返回值
count, total, avg, max_val, min_val = calculate_stats(data)
print(f"\n解包结果: 总和={total}, 平均值={avg:.2f}")

42. 函数参数类型

python 复制代码

# 题目：不同类型参数的函数
# 位置参数
def power(base, exponent):
    """计算幂"""
    return base ** exponent

print(f"2的3次方: {power(2, 3)}")

# 关键字参数
def describe_pet(pet_name, animal_type="狗"):
    """描述宠物"""
    print(f"我有一只{animal_type}，它的名字叫{pet_name}。")

describe_pet(pet_name="小黑")
describe_pet(animal_type="猫", pet_name="小花")

# 可变位置参数(*args)
def sum_numbers(*args):
    """计算任意数量数字的和"""
    return sum(args)

print(f"\n数字和: {sum_numbers(1, 2, 3, 4, 5)}")
print(f"数字和: {sum_numbers(10, 20, 30)}")

# 可变关键字参数(**kwargs)
def print_info(**kwargs):
    """打印任意关键字参数"""
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print("\n个人信息:")
print_info(name="张三", age=25, city="北京", job="工程师")

# 混合使用
def mixed_args(a, b, *args, option=True, **kwargs):
    """混合使用各种参数"""
    print(f"a={a}, b={b}")
    print(f"args={args}")
    print(f"option={option}")
    print(f"kwargs={kwargs}")

mixed_args(1, 2, 3, 4, 5, option=False, x=10, y=20)

43. 递归函数

python 复制代码

# 题目：递归函数的实现
# 计算阶乘
def factorial(n):
    """递归计算阶乘"""
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)

print(f"5的阶乘: {factorial(5)}")
print(f"10的阶乘: {factorial(10)}")

# 斐波那契数列
def fibonacci(n):
    """递归计算斐波那契数列第n项"""
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

print(f"\n斐波那契数列前10项:")
for i in range(1, 11):
    print(f"第{i}项: {fibonacci(i)}")

# 递归深度限制
import sys
print(f"\nPython递归深度限制: {sys.getrecursionlimit()}")

# 尾递归优化示例（Python不支持真正的尾递归优化）
def factorial_tail(n, accumulator=1):
    """尾递归形式的阶乘函数"""
    if n == 0 or n == 1:
        return accumulator
    else:
        return factorial_tail(n - 1, n * accumulator)

print(f"\n尾递归计算5的阶乘: {factorial_tail(5)}")

# 实际应用：目录遍历
import os

def list_files(path, indent=0):
    """递归列出目录下所有文件"""
    items = os.listdir(path)
    for item in items:
        item_path = os.path.join(path, item)
        if os.path.isdir(item_path):
            print("  " * indent + f"[目录] {item}")
            list_files(item_path, indent + 1)
        else:
            print("  " * indent + f"[文件] {item}")

# 列出当前目录
print("\n当前目录结构:")
list_files(".", 0)

44. lambda表达式

python 复制代码

# 题目：lambda表达式的使用
# 基本lambda函数
add = lambda x, y: x + y
print(f"3 + 5 = {add(3, 5)}")

# 立即执行的lambda
result = (lambda x: x**2)(5)
print(f"5的平方: {result}")

# 在列表排序中使用
students = [
    {"name": "张三", "score": 85},
    {"name": "李四", "score": 92},
    {"name": "王五", "score": 78},
    {"name": "赵六", "score": 95}
]

# 按分数排序
sorted_students = sorted(students, key=lambda s: s["score"], reverse=True)
print("\n按分数降序排序:")
for student in sorted_students:
    print(f"{student['name']}: {student['score']}分")

# 在map中使用
numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, numbers))
print(f"\n数字平方: {squares}")

# 在filter中使用
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(f"偶数: {even_numbers}")

# 在reduce中使用
from functools import reduce
product = reduce(lambda x, y: x * y, numbers)
print(f"数字乘积: {product}")

# lambda与条件表达式
max_value = lambda a, b: a if a > b else b
print(f"\n最大值(10, 20): {max_value(10, 20)}")

# 多个参数的lambda
calculate = lambda x, y, operation: {
    "add": x + y,
    "subtract": x - y,
    "multiply": x * y,
    "divide": x / y if y != 0 else "错误：除数为0"
}.get(operation, "未知操作")

print(f"10 + 5 = {calculate(10, 5, 'add')}")
print(f"10 * 5 = {calculate(10, 5, 'multiply')}")

45. 闭包和装饰器

python 复制代码

# 题目：闭包和装饰器的使用
# 闭包示例
def make_multiplier(factor):
    """创建乘法器闭包"""
    def multiplier(number):
        return number * factor
    return multiplier

double = make_multiplier(2)
triple = make_multiplier(3)

print(f"2的2倍: {double(2)}")
print(f"2的3倍: {triple(2)}")

# 带状态的闭包
def counter():
    """计数器闭包"""
    count = 0
    
    def increment():
        nonlocal count
        count += 1
        return count
    
    return increment

c1 = counter()
print(f"\n计数器1: {c1()}, {c1()}, {c1()}")

c2 = counter()
print(f"计数器2: {c2()}, {c2()}")

# 简单装饰器
def simple_decorator(func):
    """简单的装饰器"""
    def wrapper():
        print("函数执行前...")
        result = func()
        print("函数执行后...")
        return result
    return wrapper

@simple_decorator
def say_hello():
    print("Hello, World!")

print("\n使用装饰器:")
say_hello()

# 带参数的装饰器
def repeat(n):
    """重复执行n次的装饰器"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            for i in range(n):
                print(f"第{i+1}次执行:")
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def greet(name):
    print(f"你好，{name}！")

print("\n重复执行装饰器:")
greet("张三")

# 类装饰器
class TimerDecorator:
    """计时装饰器"""
    def __init__(self, func):
        self.func = func
    
    def __call__(self, *args, **kwargs):
        import time
        start = time.time()
        result = self.func(*args, **kwargs)
        end = time.time()
        print(f"函数执行时间: {end - start:.6f}秒")
        return result

@TimerDecorator
def slow_function():
    """模拟耗时函数"""
    import time
    time.sleep(1)
    return "完成"

print("\n计时装饰器:")
slow_function()

46. 生成器和yield

python 复制代码

# 题目：生成器和yield关键字
# 简单生成器
def count_up_to(n):
    """计数到n的生成器"""
    count = 1
    while count <= n:
        yield count
        count += 1

print("计数生成器:")
for number in count_up_to(5):
    print(number, end=" ")

# 生成器表达式
squares = (x**2 for x in range(1, 6))
print(f"\n\n生成器表达式计算的平方: {list(squares)}")

# 无限生成器
def fibonacci_generator():
    """斐波那契数列生成器"""
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib = fibonacci_generator()
print("\n斐波那契数列前10项:")
for _ in range(10):
    print(next(fib), end=" ")

# 生成器发送值
def accumulator():
    """累加器生成器"""
    total = 0
    while True:
        value = yield total
        if value is not None:
            total += value

acc = accumulator()
next(acc)  # 启动生成器
print(f"\n\n累加器:")
print(f"当前值: {acc.send(10)}")  # 发送10并获取当前值
print(f"当前值: {acc.send(20)}")  # 发送20并获取当前值
print(f"当前值: {acc.send(5)}")   # 发送5并获取当前值

# 实际应用：读取大文件
def read_large_file(file_path):
    """逐行读取大文件的生成器"""
    with open(file_path, 'r', encoding='utf-8') as file:
        for line in file:
            yield line.strip()

# 模拟大文件读取
print("\n模拟读取大文件:")
lines = ["第1行", "第2行", "第3行", "第4行", "第5行"]
for line in lines:
    print(line)

# 生成器管道
def filter_even(numbers):
    """过滤偶数的生成器"""
    for n in numbers:
        if n % 2 == 0:
            yield n

def square(numbers):
    """计算平方的生成器"""
    for n in numbers:
        yield n**2

numbers = range(10)
pipeline = square(filter_even(numbers))
print(f"\n生成器管道处理结果: {list(pipeline)}")

47. 模块的导入和使用

python 复制代码

# 题目：模块的导入和使用
# 导入整个模块
import math

print(f"π的值: {math.pi}")
print(f"平方根: {math.sqrt(16)}")
print(f"正弦值: {math.sin(math.pi/2)}")

# 导入特定函数
from random import randint, choice

print(f"\n随机整数: {randint(1, 100)}")
print(f"随机选择: {choice(['苹果', '香蕉', '橙子'])}")

# 导入并重命名
import datetime as dt
from math import factorial as fact

now = dt.datetime.now()
print(f"\n当前时间: {now}")
print(f"10的阶乘: {fact(10)}")

# 导入所有内容（不推荐）
from math import *
print(f"\n使用*导入:")
print(f"e的值: {e}")
print(f"对数: {log(100, 10)}")

# 自定义模块
# 假设有一个名为my_module.py的文件，内容如下：
"""
# my_module.py
def greet(name):
    return f"Hello, {name}!"

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

PI = 3.14159
"""

# 在实际环境中，可以这样导入：
# import my_module
# print(my_module.greet("Alice"))

# 检查模块属性
print(f"\nmath模块的部分属性:")
print(f"属性列表: {dir(math)[:10]}")  # 前10个属性

# 使用__name__属性
def test_function():
    print("这是一个测试函数")

if __name__ == "__main__":
    print("\n这个脚本是直接运行的")
    test_function()
else:
    print("这个脚本是被导入的")

48. 文件操作基础

python 复制代码

# 题目：基本的文件操作
# 写入文件
with open("example.txt", "w", encoding="utf-8") as file:
    file.write("这是第一行\n")
    file.write("这是第二行\n")
    file.write("这是第三行\n")

print("文件写入完成")

# 读取整个文件
with open("example.txt", "r", encoding="utf-8") as file:
    content = file.read()
    print("\n文件内容(全部):")
    print(content)

# 逐行读取
with open("example.txt", "r", encoding="utf-8") as file:
    print("\n文件内容(逐行):")
    for line in file:
        print(line.strip())  # strip()移除换行符

# 读取所有行到列表
with open("example.txt", "r", encoding="utf-8") as file:
    lines = file.readlines()
    print(f"\n文件行数: {len(lines)}")
    for i, line in enumerate(lines, 1):
        print(f"第{i}行: {line.strip()}")

# 追加内容
with open("example.txt", "a", encoding="utf-8") as file:
    file.write("这是追加的行\n")

print("\n追加后的文件内容:")
with open("example.txt", "r", encoding="utf-8") as file:
    print(file.read())

# 读取二进制文件
binary_data = b"Hello, World!"
with open("binary.bin", "wb") as file:
    file.write(binary_data)

with open("binary.bin", "rb") as file:
    data = file.read()
    print(f"\n二进制文件内容: {data}")

# 文件定位
with open("example.txt", "r", encoding="utf-8") as file:
    file.seek(10)  # 移动到第10个字节
    partial = file.read(5)  # 读取5个字节
    print(f"\n从第10字节读取5个字节: {partial}")
    
    position = file.tell()
    print(f"当前位置: {position}")

# 清理：删除创建的文件
import os
os.remove("example.txt")
os.remove("binary.bin")
print("\n临时文件已清理")

49. 异常处理

python 复制代码

# 题目：异常处理机制
# 基本异常处理
try:
    num = int(input("请输入一个整数: "))
    result = 10 / num
    print(f"10除以{num}的结果是: {result}")
except ValueError:
    print("错误：请输入有效的整数！")
except ZeroDivisionError:
    print("错误：除数不能为零！")
except Exception as e:
    print(f"发生未知错误: {e}")
else:
    print("计算成功完成！")
finally:
    print("程序执行结束。")

# 多个异常合并处理
try:
    data = {"a": 1, "b": 2}
    print(data["c"])
except (KeyError, IndexError) as e:
    print(f"访问错误: {type(e).__name__} - {e}")

# 自定义异常
class NegativeNumberError(Exception):
    """自定义异常：负数错误"""
    def __init__(self, value):
        self.value = value
        self.message = f"负数错误: {value} 不能为负数"
        super().__init__(self.message)

def calculate_square_root(x):
    """计算平方根，如果x为负数则抛出异常"""
    if x < 0:
        raise NegativeNumberError(x)
    return x ** 0.5

print("\n自定义异常测试:")
try:
    print(f"4的平方根: {calculate_square_root(4)}")
    print(f"-4的平方根: {calculate_square_root(-4)}")
except NegativeNumberError as e:
    print(f"捕获自定义异常: {e}")

# 异常链
def function_a():
    try:
        return 1 / 0
    except ZeroDivisionError as e:
        raise ValueError("转换错误") from e

def function_b():
    try:
        function_a()
    except ValueError as e:
        print(f"捕获的异常: {e}")
        print(f"原始异常: {e.__cause__}")

print("\n异常链测试:")
function_b()

# 使用else和finally
def read_file_safely(filename):
    """安全读取文件"""
    try:
        file = open(filename, "r", encoding="utf-8")
    except FileNotFoundError:
        print(f"文件 {filename} 不存在")
        return None
    except IOError as e:
        print(f"读取文件时发生错误: {e}")
        return None
    else:
        try:
            content = file.read()
            return content
        except Exception as e:
            print(f"处理文件时发生错误: {e}")
            return None
        finally:
            file.close()

print("\n安全读取文件测试:")
content = read_file_safely("不存在的文件.txt")
print(f"文件内容: {content}")

50. 综合练习：学生成绩管理系统

python 复制代码

# 题目：综合应用 - 学生成绩管理系统
import json
import os
from datetime import datetime

class StudentGradeSystem:
    """学生成绩管理系统"""
    
    def __init__(self, filename="grades.json"):
        self.filename = filename
        self.students = self.load_data()
    
    def load_data(self):
        """从文件加载数据"""
        if os.path.exists(self.filename):
            try:
                with open(self.filename, 'r', encoding='utf-8') as f:
                    return json.load(f)
            except Exception as e:
                print(f"加载数据失败: {e}")
                return {}
        return {}
    
    def save_data(self):
        """保存数据到文件"""
        try:
            with open(self.filename, 'w', encoding='utf-8') as f:
                json.dump(self.students, f, ensure_ascii=False, indent=2)
            return True
        except Exception as e:
            print(f"保存数据失败: {e}")
            return False
    
    def add_student(self, student_id, name):
        """添加学生"""
        if student_id in self.students:
            print(f"学生 {student_id} 已存在")
            return False
        
        self.students[student_id] = {
            "name": name,
            "grades": {},
            "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "updated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        }
        self.save_data()
        print(f"学生 {name}({student_id}) 添加成功")
        return True
    
    def add_grade(self, student_id, subject, grade):
        """添加成绩"""
        if student_id not in self.students:
            print(f"学生 {student_id} 不存在")
            return False
        
        try:
            grade = float(grade)
            if grade < 0 or grade > 100:
                print("成绩必须在0-100之间")
                return False
        except ValueError:
            print("成绩必须是数字")
            return False
        
        self.students[student_id]["grades"][subject] = grade
        self.students[student_id]["updated_at"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        self.save_data()
        print(f"学生 {self.students[student_id]['name']} 的{subject}成绩添加成功: {grade}")
        return True
    
    def get_student_grades(self, student_id):
        """获取学生成绩"""
        if student_id not in self.students:
            print(f"学生 {student_id} 不存在")
            return None
        
        student = self.students[student_id]
        grades = student["grades"]
        
        if not grades:
            print(f"学生 {student['name']} 暂无成绩")
            return {}
        
        print(f"\n学生: {student['name']}({student_id})")
        print("成绩单:")
        for subject, grade in grades.items():
            print(f"  {subject}: {grade}")
        
        average = sum(grades.values()) / len(grades)
        print(f"平均分: {average:.2f}")
        
        return grades
    
    def get_class_average(self, subject):
        """获取班级某科目平均分"""
        total = 0
        count = 0
        
        for student_id, student in self.students.items():
            if subject in student["grades"]:
                total += student["grades"][subject]
                count += 1
        
        if count == 0:
            print(f"没有学生有{subject}成绩")
            return None
        
        average = total / count
        print(f"{subject}班级平均分: {average:.2f} (共{count}人)")
        return average
    
    def list_all_students(self):
        """列出所有学生"""
        if not self.students:
            print("暂无学生信息")
            return
        
        print("\n所有学生信息:")
        for student_id, student in self.students.items():
            grade_count = len(student["grades"])
            print(f"学号: {student_id}, 姓名: {student['name']}, 成绩科目数: {grade_count}")
    
    def remove_student(self, student_id):
        """删除学生"""
        if student_id not in self.students:
            print(f"学生 {student_id} 不存在")
            return False
        
        name = self.students[student_id]["name"]
        del self.students[student_id]
        self.save_data()
        print(f"学生 {name}({student_id}) 删除成功")
        return True
    
    def export_to_csv(self, filename="grades.csv"):
        """导出为CSV文件"""
        try:
            with open(filename, 'w', encoding='utf-8') as f:
                f.write("学号,姓名,科目,成绩,更新时间\n")
                for student_id, student in self.students.items():
                    for subject, grade in student["grades"].items():
                        f.write(f"{student_id},{student['name']},{subject},{grade},{student['updated_at']}\n")
            print(f"数据已导出到 {filename}")
            return True
        except Exception as e:
            print(f"导出失败: {e}")
            return False

def main():
    """主程序"""
    system = StudentGradeSystem()
    
    while True:
        print("\n" + "="*50)
        print("学生成绩管理系统")
        print("="*50)
        print("1. 添加学生")
        print("2. 添加成绩")
        print("3. 查看学生成绩")
        print("4. 查看班级平均分")
        print("5. 列出所有学生")
        print("6. 删除学生")
        print("7. 导出数据")
        print("8. 退出系统")
        print("="*50)
        
        choice = input("请选择操作 (1-8): ")
        
        if choice == "1":
            student_id = input("请输入学号: ").strip()
            name = input("请输入姓名: ").strip()
            system.add_student(student_id, name)
        
        elif choice == "2":
            student_id = input("请输入学号: ").strip()
            subject = input("请输入科目: ").strip()
            grade = input("请输入成绩: ").strip()
            system.add_grade(student_id, subject, grade)
        
        elif choice == "3":
            student_id = input("请输入学号: ").strip()
            system.get_student_grades(student_id)
        
        elif choice == "4":
            subject = input("请输入科目: ").strip()
            system.get_class_average(subject)
        
        elif choice == "5":
            system.list_all_students()
        
        elif choice == "6":
            student_id = input("请输入要删除的学号: ").strip()
            system.remove_student(student_id)
        
        elif choice == "7":
            filename = input("请输入导出文件名 (默认: grades.csv): ").strip()
            if not filename:
                filename = "grades.csv"
            system.export_to_csv(filename)
        
        elif choice == "8":
            print("感谢使用学生成绩管理系统，再见！")
            break
        
        else:
            print("无效的选择，请重新输入")

if __name__ == "__main__":
    main()

总结

这50个Python3基础练习题涵盖了从基本语法到进阶应用的各个方面：

基础语法：变量、运算符、输入输出
控制结构：条件判断、循环
数据结构：字符串、列表、元组、字典、集合
函数编程：函数定义、参数、递归、lambda、装饰器
文件操作：读写文件、异常处理
模块使用：标准库、自定义模块
面向对象：类定义、方法、属性
综合应用：项目开发、系统设计

每个练习都包含详细注释和解释，帮助你理解Python编程的核心概念。通过完成这些练习，你将能够：

掌握Python基础语法和常用数据类型
理解函数式编程和面向对象编程
学会处理文件和异常
能够使用Python解决实际问题
为进一步学习Python高级特性打下基础

建议你按照顺序完成这些练习，并尝试修改和扩展每个练习的功能。编程能力的提升需要不断练习和实践，祝你学习顺利！