Python 编程入门实训 - 知识点总结

Python 编程入门实训 - 知识点总结

一、数据存储与运算

1.1 数据类型（Day02）

基础数据类型

1. 整型 (int): 整数数据

   num1 = 999
   print(f'num1 = {num1}')

2. 浮点型 (float): 小数数据

   num2 = 66.6
   print(f'num2 = {num2}, {type(num2)}')

3. 布尔型 (bool): 真/假 (True/False)

   is_visited = True
   # True + 1 = 2

4. 字符串类型 (str): 三种书写方式

   • 单引号：name1 = '玛利亚'
   • 双引号：name2 = "玛利亚"
   • 三引号（多行）：name4 = """玛利亚"""

5. 空值 (NoneType): 表示空或无值

   print(None)

高级数据类型（数据容器）

6. 列表 (list): 有序、可扩展、可重复

   names1 = ['张三','李四','王五','张三','李四','王五']

7. 元组 (tuple): 有序、不可扩展、可重复

   names2 = ('张三','李四','王五','张三','李四','王五')

8. 集合 (set): 无序、可扩展、不可重复

   names3 = {'张三','李四','王五','张三','李四'}  # 自动去重

9. 字典 (dict): 键值对 (key->value)

   stu_dict = {'stu_id':'1001','name':'张三','age':18,'score':100}

1.2 变量与标识符（Day02）

关键字

• Python 有 35 个关键字（保留字），不能用作变量名
• 查看关键字：import keyword; print(keyword.kwlist)

标识符命名规则

1. 数字不能开头
2. 只能使用 a-z, A-Z, 0-9, _(下划线)
3. Python 严格区分大小写

命名规范

• 小驼峰命名：tankHitWall
• 大驼峰命名：TankHitWall
• 下划线命名：tank_hit_wall
• 常量（全部大写）：PI, ID

1.3 运算符（Day03）

算术运算符

+    # 加法
-    # 减法
*    # 乘法
/    # 除法（结果为浮点数）10/5 = 2.0
//   # 整除（结果为整数）10//5 = 2
%    # 求余/求模 10%3 = 1
**   # 幂指数 10**3 = 1000

优先级 : ** > * / // % > + -

赋值运算符

=    # 基本赋值
+=   # 加法赋值
-=   # 减法赋值
*=   # 乘法赋值
/=   # 除法赋值
//=  # 整除赋值
%=   # 求模赋值
**=  # 幂指数赋值

比较运算符

==   # 等于
!=   # 不等于
>    # 大于
>=   # 大于等于
<    # 小于
<=   # 小于等于

逻辑运算符

and  # 逻辑与（并且）
or   # 逻辑或（或者）
not  # 逻辑非（取反）

1.4 数据运算实例

字符串格式化

1. f-string 格式化 (推荐):

   name = '大王'
   age = 20
   print(f'{name} is {age} years old')

2. % 格式化:

   print('%s is %d years old' % (name, age))
   # %s 字符串占位符
   # %d 整型占位符
   # %f 浮点占位符 (%.2f 保留 2 位小数)
   # %06d 整型不足 6 位用 0 补齐

3. 字符串拼接:

   s2 = '人生苦短' + '我要下班'
   # 只能拼接字符串，其他类型需 str(...) 转换

转义字符

\'   # 单引号
\"   # 双引号
\t   # 水平制表符（4 个空格）
\n   # 换行符

计算示例

# 苹果价格计算
price = 9.00
weight = 5.00
money = price * weight
print(f'苹果单价 %.2f 元/斤，购买了 %.2f 斤，需要支付 %.2f 元' % (price, weight, money))

# 1-100 奇数之和
total = 0
for i in range(1, 100, 2):
    total += i
print(total)  # 2500

---

二、数据的逻辑处理（流程控制）

2.1 输入输出（Day03）

input() 函数

• 获取键盘输入的数据
• 注意: 输入的任何数据都是字符串类型

name = input('请输入您的姓名：')
age = int(input('请输入您的年龄：'))  # 需要转换为 int

数据类型转换

int(...)    # 转为整型
str(...)    # 转为字符串
float(...)  # 转为浮点型
bool(...)   # 转为布尔型

2.2 条件判断（Day03）

if 语句

if条件:
    # 条件成立时执行
    print('条件成立')

if...else 语句

if条件:
    # 条件成立时执行操作 1
else:
    # 条件不成立时执行操作 2

if...elif...else 语句

if条件 1:
    操作 1
elif条件 2:
    操作 2
else:
    操作 3

嵌套 if 示例（三角形判断）

a = int(input('请输入第一边的边长：'))
b = int(input('请输入第二边的边长：'))
c = int(input('请输入第三边的边长：'))

if a+b>c and a+c>b and b+c>a:
    if a==b and b==c:
        print('等边三角形')
    elif a==b or b==c or a==c:
        print('等腰三角形')
    else:
        print('普通三角形')
else:
    print('不能构成三角形')

2.3 模式匹配 match...case（Day04）

基本语法

match 表达式:
    case 值 1:
        操作 1
    case 值 2:
        操作 2
    case _:
        默认操作  # 相当于 else

多值匹配

day = input('请输入星期几（1-7）：')
match day:
    case '1' | '2' | '3' | '4' | '5':
        print('是周内')
    case _:
        print('输入不符合')

if 守卫条件

grade = input("请输入学生成绩等级（A/B/C/D）：")
is_class_leader = input("该学生是否是班干部（是/否）：") == "是"

match grade:
    case "A" if is_class_leader:
        print("奖励 500 元（A 等级 + 班干部）")
    case "A" if not is_class_leader:
        print("奖励 300 元（A 等级 + 非班干部）")
    case "B" if is_class_leader:
        print("奖励 200 元（B 等级 + 班干部）")
    case "B" if not is_class_leader:
        print("奖励 100 元（B 等级 + 非班干部）")
    case "C" | "D":
        print("口头表扬（C/D 等级）")
    case _:
        print("输入错误！")

2.4 循环语句（Day04）

while 循环

i = 0
while i < 3:
    print('人生苦短，我用 python')
    i += 1
else:
    print('循环正常结束')

for 循环

msg = 'Hello World'
for i in msg:
    print(i, end='  ')
else:
    print('循环结束')

range() 函数

range(end)           # 0 到 end-1
range(start, end)    # start 到 end-1
range(start, end, step)  # 带步长
# 示例:
range(5)      # 0,1,2,3,4
range(2, 8)   # 2,3,4,5,6,7
range(2, 8, 3)  # 2,5,8

循环控制关键字

• break: 结束跳出循环（else 代码不会执行）
• continue: 中断本次循环，直接进入下一次循环

嵌套循环示例

# 打印长方形
m = int(input('请输入长方形的长度：'))
n = int(input('请输入长方形的宽度：'))
for j in range(n):
    for i in range(m):
        print('*', end='  ')
    print()

# 打印 99 乘法表
for i in range(1, 10):
    for j in range(1, i+1):
        print(f'{i}*{j}={i*j}', end='\t')
    print()

综合应用：登录系统

while True:
    username = input('请输入用户名：')
    password = input('请输入密码：')
    
    if username == '' or password == '':
        print('用户名和密码不能为空！')
        continue
    
    if username == 'admin' and password == '666888':
        print('登录成功，进入 B 站首页')
        break
    elif username == 'zhangsan' and password == '123456':
        print('登录成功，进入 B 站首页')
        break
    elif username == 'taoge' and password == '888666':
        print('登录成功，进入 B 站首页')
        break
    else:
        print('用户名或密码错误，请重新输入')

---

三、注释规范（Day01-Day02）

单行注释

# 这是一个单行注释
print('Hello')  # 行尾注释

多行注释

'''
这是多行注释
可以写多行内容
常用于文档说明
'''

特殊用法

# 多行字符串（可作为注释或存储多行文本）
fozu1 = '''
aaaaaaaaa1
bbbbbbbbbbbbbbb
cccccccccccccccccccccc
'''

# 续行符 \ (告诉 Python 这一行还没结束)
fozu2 = '''
aaaaaaaaa2\
bbbbbbbbbbbbbbb\
cccccccccccccccccccccc
'''

---

四、核心要点总结

Day01 基础

• Hello World 输出
• 注释的使用（单行/多行）
• 多行字符串的书写

Day02 进阶

• 关键字与标识符规则
• 9 大数据类型（4 基础 +4 容器 +1 空值）
• 变量定义与命名规范
• 字符串格式化（f-string、%占位符）
• 转义字符

Day03 条件控制

• 输入输出 (input/print)
• 数据类型转换
• 四大运算符（算术、赋值、比较、逻辑）
• if条件判断（if/if-else/if-elif-else/嵌套）

Day04 流程控制

• match-case 模式匹配（含 if 守卫）
• while 循环
• for 循环
• range() 数字序列生成
• 嵌套循环
• break/continue 控制
• 综合实战应用

---

五、最佳实践建议

1. 变量命名: 使用有意义的英文单词，遵循下划线命名法
2. 代码缩进: 统一使用 4 个空格或 1 个 Tab
3. 注释: 复杂逻辑必须添加注释说明
4. 类型转换: input() 获取的数据要及时转换
5. 循环终止: 规划好循环终止条件，避免死循环
6. 异常处理: 实际开发中应添加 try-except 处理异常
7. 代码复用: 重复代码应封装为函数

---

六、数据容器详解（Day05）

6.1 列表 list

基本操作

# 定义列表
s = [54, 15, 75, 256, 'A', 'Hello', True]
print(type(s))  # <class 'list'>

# 获取元素（索引）
print(s[2])    # 正向索引，从 0 开始 -> 75
print(s[-3])   # 反向索引，从 -1 开始 -> A

# 修改元素
s[5] = '修改的'

# 删除元素
del s[5]

# 遍历列表
for item in s:
    print(item)

切片操作

# 语法：序列数据 [开始索引：结束索引：步长]
s = ['A','B','C','D','E','F']

print(s[0:5:1])  # ['A', 'B', 'C', 'D', 'E'] 等价于 s[:5]
print(s[0:5:2])  # ['A', 'C', 'E']
print(s[0:-2:2]) # 截取时不包括最后一个

常用方法

s = [56, 90, 88, 65, 90, 100, 209, 72, 145]

# append() - 在列表尾部追加元素
s.append(10086)

# insert() - 在指定索引之前插入元素
s.insert(0, 92)

# remove() - 移除列表中第一个匹配到的值
s.remove(75)

# pop() - 删除列表中指定索引位置的元素
s.pop(2)      # 删除索引 2 的元素
s.pop()       # 默认删除最后一个

# sort() - 对列表排序（元素类型需一致）
s.sort()

# reverse() - 反转列表
s.reverse()

# 列表拼接
print(s + [10086])

案例：推导式

# 列表推导式
# 示例：生成 1-10 的平方
squares = [x**2 for x in range(1, 11)]

6.2 字符串 str

基本操作

# 字符串定义
s1 = '人生苦短'
s2 = "我要 python"
s3 = '''多行
字符串'''

# 字符串拼接
msg = s1 + s2

# 字符串访问
name = 'Hello World'
print(name[0])     # H
print(name[-1])    # d
print(name[0:5])   # Hello

常用方法

s = 'hello world'

# 大小写转换
s.upper()          # 'HELLO WORLD'
s.lower()          # 'hello world'
s.capitalize()     # 'Hello world'
s.title()          # 'Hello World'

# 查找与替换
s.find('o')        # 4 (首次出现位置)
s.count('o')       # 2 (出现次数)
s.replace('o', '0') # 'hell0 w0rld'

# 分割与连接
s.split()          # ['hello', 'world']
'-'.join(['a','b']) # 'a-b'

# 去除空白
s.strip()
s.lstrip()
s.rstrip()

# 判断
s.startswith('he') # True
s.endswith('ld')   # True
s.isalpha()        # 是否全字母
s.isdigit()        # 是否全数字

案例

# 案例 1：统计字符串中每个字符出现的次数
text = 'hello world'
char_count = {}
for char in text:
    char_count[char] = char_count.get(char, 0) + 1

# 案例 2：字符串反转
text = 'abcdef'
reversed_text = text[::-1]  # 'fedcba'

6.3 元组 tuple

基本操作

# 定义元组
t1 = ('张三','李四','王五')
t2 = (1, 2, 3, 4, 5)
t3 = ()  # 空元组
t4 = (1,)  # 单元素元组（需要逗号）

# 访问元素
print(t1[0])    # 张三
print(t1[-1])   # 王五

# 元组不可修改（只读）
# t1[0] = '赵六'  # 错误！

组包与解包

# 组包
person = ('张三', 18, '北京')

# 解包
name, age, city = person
print(name)  # 张三
print(age)   # 18

# 交换变量
a, b = 1, 2
a, b = b, a  # a=2, b=1

案例

# 案例：返回多个值
def get_person_info():
    return '张三', 18, '北京'

info = get_person_info()
name, age, city = info

案例优化

# 使用 * 解包多余元素
numbers = (1, 2, 3, 4, 5)
first, *middle, last = numbers
print(first)   # 1
print(middle)  # [2, 3, 4]
print(last)    # 5

6.4 集合 set

基本操作

# 定义集合
s1 = {'张三','李四','王五'}
s2 = {1, 2, 3, 4, 5}
s3 = set()  # 空集合

# 特点：无序、不重复
s = {'张三','李四','王五','张三','李四'}
print(s)  # {'王五', '李四', '张三'} 自动去重

# 添加元素
s.add('赵六')
s.update(['钱七','孙八'])

# 删除元素
s.remove('张三')  # 不存在会报错
s.discard('张三') # 不存在不会报错
s.pop()           # 随机删除一个元素

集合运算

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

# 交集
print(A & B)  # {3, 4}

# 并集
print(A | B)  # {1, 2, 3, 4, 5, 6}

# 差集
print(A - B)  # {1, 2}
print(B - A)  # {5, 6}

# 对称差集
print(A ^ B)  # {1, 2, 5, 6}

案例

# 案例：去重
names = ['张三','李四','张三','王五','李四']
unique_names = list(set(names))
print(unique_names)  # ['张三', '王五', '李四']

# 案例：判断两个列表是否有相同元素
list1 = [1, 2, 3]
list2 = [3, 4, 5]
has_common = bool(set(list1) & set(list2))

6.5 字典 dict

介绍

# 字典：键值对 (key-value) 存储
stu_dict = {
    'stu_id': '1001',
    'name': '张三',
    'age': 18,
    'score': 100
}

# 特点：
# 1. key 唯一，不能重复
# 2. key 必须是不可变类型（字符串、数字、元组）
# 3. 无序（Python 3.7+ 保持插入顺序）

常用操作

# 访问
print(stu_dict['name'])  # 张三
print(stu_dict.get('age'))  # 18

# 修改
stu_dict['age'] = 19
stu_dict['score'] = 95

# 添加
stu_dict['city'] = '北京'

# 删除
stu_dict.pop('city')      # 删除指定 key
del stu_dict['score']     # 删除
stu_dict.popitem()        # 删除最后一项

# 遍历
for key in stu_dict:
    print(key, stu_dict[key])

for key, value in stu_dict.items():
    print(f'{key}: {value}')

# 获取所有键、值、项
stu_dict.keys()    # 所有键
stu_dict.values()  # 所有值
stu_dict.items()   # 所有键值对

案例实现

# 案例：学生成绩管理系统
students = {}

# 添加学生
def add_student(student_id, name, score):
    students[student_id] = {
        'name': name,
        'score': score
    }

# 查询学生
def get_student(student_id):
    return students.get(student_id)

# 删除学生
def delete_student(student_id):
    students.pop(student_id, None)

# 显示所有学生
def show_all():
    for sid, info in students.items():
        print(f"{sid}: {info['name']} - {info['score']}")

案例测试

# 测试代码
add_student('001', '张三', 90)
add_student('002', '李四', 85)
add_student('003', '王五', 95)

show_all()

# 查询
stu = get_student('002')
print(stu)  # {'name': '李四', 'score': 85}

# 字典推导式
squares = {x: x**2 for x in range(1, 6)}
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

6.6 数据容器总结

容器类型	可变性	有序性	可重复	索引	典型用途
list	可变	有序	可重复	✅	存储序列数据
str	不可变	有序	可重复	✅	文本处理
tuple	不可变	有序	可重复	✅	保护数据不被修改
set	可变	无序	不重复	❌	去重、集合运算
dict	可变	有序*	key 不重复	❌	键值对映射

*Python 3.7+ 保持插入顺序

---

七、函数基础

7.1 函数介绍

# 为什么需要函数？
# 1. 代码复用
# 2. 模块化编程
# 3. 提高代码可读性

# 函数定义
def greet():
    print('Hello!')

# 函数调用
greet()

7.2 函数定义

def function_name(参数列表):
    """函数文档字符串"""
    # 函数体
    # 执行语句
    return 返回值  # 可选

7.3 函数参数与返回值

# 无参数无返回值
def say_hello():
    print('Hello!')

# 有参数无返回值
def greet(name):
    print(f'Hello, {name}!')

# 有参数有返回值
def add(a, b):
    return a + b

# 无参数有返回值
def get_pi():
    return 3.14159

# 多返回值
def get_person():
    return '张三', 18, '北京'

name, age, city = get_person()

7.4 函数说明文档

def calculate_area(width, height):
    """
    计算矩形面积
    
    参数:
        width: 宽度
        height: 高度
    
    返回:
        面积值
    """
    return width * height

# 查看文档
help(calculate_area)
print(calculate_area.__doc__)

7.5 函数嵌套调用

def func1():
    print('func1 start')
    func2()
    print('func1 end')

def func2():
    print('func2 start')
    func3()
    print('func2 end')

def func3():
    print('func3')

func1()

7.6 案例

# 案例：计算器
def calculator(a, b, operator):
    """简单计算器"""
    if operator == '+':
        return a + b
    elif operator == '-':
        return a - b
    elif operator == '*':
        return a * b
    elif operator == '/':
        return a / b
    else:
        return '不支持的运算符'

result = calculator(10, 5, '+')
print(result)  # 15

---

八、函数进阶

8.1 变量作用域

# 局部变量：函数内部定义的变量
def func():
    local_var = 100  # 局部变量
    print(local_var)

# 全局变量：函数外部定义的变量
global_var = 200

def func2():
    print(global_var)  # 可以访问全局变量

# 修改全局变量
def func3():
    global global_var
    global_var = 300

8.2 传参方式

# 位置参数
def greet(name, age):
    print(f'{name}, {age}岁')

greet('张三', 18)  # 按位置传递

# 关键字参数
greet(age=18, name='张三')  # 按名称传递

8.3 默认参数

def greet(name, greeting='你好'):
    print(f'{greeting}, {name}!')

greet('张三')              # 你好，张三!
greet('张三', 'Hello')     # Hello, 张三!

8.4 不定长参数

# *args - 接收任意数量的位置参数
def sum_all(*args):
    return sum(args)

print(sum_all(1, 2, 3))      # 6
print(sum_all(1, 2, 3, 4, 5)) # 15

# **kwargs - 接收任意数量的关键字参数
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f'{key}: {value}')

print_info(name='张三', age=18, city='北京')

8.5 参数类型（函数作为参数）

def apply_operation(func, value):
    """将函数作为参数传入"""
    return func(value)

def square(x):
    return x ** 2

result = apply_operation(square, 5)
print(result)  # 25

# 使用 lambda
result = apply_operation(lambda x: x**2, 5)

8.6 匿名函数（lambda 表达式）

# 基本语法
lambda 参数：表达式

# 示例
add = lambda a, b: a + b
print(add(3, 5))  # 8

# 与内置函数配合使用
numbers = [5, 2, 8, 1, 9]
sorted_numbers = sorted(numbers, key=lambda x: -x)

8.7 案例 1（递归）

# 递归函数：函数调用自身

# 案例：计算阶乘
def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5))  # 120

# 案例：斐波那契数列
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))  # 55

8.8 案例 2

# 综合案例：数据处理函数
def process_data(data, operation='sum', **options):
    """通用数据处理函数"""
    if operation == 'sum':
        return sum(data)
    elif operation == 'avg':
        return sum(data) / len(data)
    elif operation == 'max':
        return max(data)
    elif operation == 'min':
        return min(data)
    elif operation == 'filter':
        threshold = options.get('threshold', 0)
        return [x for x in data if x > threshold]
    else:
        raise ValueError('不支持的操作')

numbers = [1, 2, 3, 4, 5]
print(process_data(numbers, 'avg'))  # 3.0
print(process_data(numbers, 'filter', threshold=2))  # [3, 4, 5]

---

九、类型注解

9.1 介绍

# 类型注解的作用：
# 1. 提高代码可读性
# 2. IDE 智能提示
# 3. 静态类型检查

# 基本语法
variable: type = value

9.2 函数的类型注解

from typing import List, Dict, Tuple, Optional

# 参数和返回值类型注解
def greet(name: str, age: int) -> str:
    return f'{name}, {age}岁'

# 复杂类型
def process_list(items: List[int]) -> List[int]:
    return [x * 2 for x in items]

def get_user_info() -> Dict[str, any]:
    return {'name': '张三', 'age': 18}

# Optional 表示可以为 None
def find_user(user_id: int) -> Optional[str]:
    users = {1: '张三', 2: '李四'}
    return users.get(user_id)

---

十、模块

10.1 介绍

# 模块的作用：
# 1. 代码组织和管理
# 2. 避免命名冲突
# 3. 代码复用

10.2 导入模块

# 导入整个模块
import math
print(math.sqrt(16))

# 导入特定函数
from math import sqrt, pi
print(sqrt(16))

# 导入并重命名
import numpy as np

# 导入所有
from math import *

10.3 自定义模块

# my_module.py
def say_hello():
    print('Hello!')

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

PI = 3.14159

# main.py
import my_module
my_module.say_hello()

from my_module import add
result = add(3, 5)

10.4 包（package）

# 包的结构：
# my_package/
#     __init__.py
#     module1.py
#     module2.py

# 导入包中的模块
from my_package import module1
from my_package.module1 import function1

# __init__.py 的作用：
# 1. 标识目录为包
# 2. 初始化包
# 3. 控制导出

---

十一、面向对象基础

11.1 概述

# 面向对象编程（OOP）的特点：
# 1. 封装：隐藏实现细节
# 2. 继承：代码复用
# 3. 多态：同一接口不同实现

# 类 vs 对象
# 类：模板、蓝图
# 对象：类的实例

11.2 类与对象

class Person:
    """人类"""
    pass

# 创建对象
p1 = Person()
p2 = Person()

11.3 实例方法

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def introduce(self):
        """自我介绍"""
        print(f'我是{self.name}，今年{self.age}岁')
    
    def grow_up(self, years=1):
        """长大"""
        self.age += years

# 使用
p = Person('张三', 18)
p.introduce()  # 我是张三，今年 18 岁
p.grow_up()

11.4 魔法方法

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __str__(self):
        """对象的字符串表示"""
        return f'{self.name}({self.age}岁)'
    
    def __repr__(self):
        """开发调试时的字符串表示"""
        return f'Person({self.name!r}, {self.age})'
    
    def __eq__(self, other):
        """比较是否相等"""
        return self.name == other.name and self.age == other.age

p = Person('张三', 18)
print(p)  # 张三 (18 岁)

11.5 实例属性与类属性

class Person:
    # 类属性（所有实例共享）
    species = '人类'
    
    def __init__(self, name, age):
        # 实例属性（每个实例独立）
        self.name = name
        self.age = age

p1 = Person('张三', 18)
p2 = Person('李四', 20)

print(p1.species)  # 人类
print(p2.species)  # 人类
Person.species = '智人'
print(p1.species)  # 智人

11.6 案例：教务系统（准备）

class Student:
    """学生类"""
    def __init__(self, student_id, name, age):
        self.student_id = student_id
        self.name = name
        self.age = age
        self.courses = []
    
    def add_course(self, course):
        self.courses.append(course)
    
    def __str__(self):
        return f'{self.name}(学号：{self.student_id})'


class Course:
    """课程类"""
    def __init__(self, course_id, name, teacher):
        self.course_id = course_id
        self.name = name
        self.teacher = teacher
        self.students = []
    
    def add_student(self, student):
        self.students.append(student)

11.7 案例：教务系统（添加学生）

class StudentManager:
    """学生管理器"""
    def __init__(self):
        self.students = {}
    
    def add_student(self, student_id, name, age):
        """添加学生"""
        if student_id in self.students:
            print('学生已存在')
            return
        
        student = Student(student_id, name, age)
        self.students[student_id] = student
        print(f'添加学生成功：{name}')
    
    def get_student(self, student_id):
        """获取学生信息"""
        return self.students.get(student_id)

11.8 案例：教务系统（修改学生）

class StudentManager:
    # ... 前面的代码 ...
    
    def update_student(self, student_id, **kwargs):
        """修改学生信息"""
        student = self.get_student(student_id)
        if not student:
            print('学生不存在')
            return
        
        for key, value in kwargs.items():
            if hasattr(student, key):
                setattr(student, key, value)
        
        print('修改成功')
    
    def delete_student(self, student_id):
        """删除学生"""
        if student_id in self.students:
            del self.students[student_id]
            print('删除成功')
        else:
            print('学生不存在')

11.9 案例：教务系统（运行）

# 主程序
def main():
    manager = StudentManager()
    
    # 添加学生
    manager.add_student('001', '张三', 18)
    manager.add_student('002', '李四', 19)
    manager.add_student('003', '王五', 20)
    
    # 查询学生
    stu = manager.get_student('001')
    print(stu)
    
    # 修改学生
    manager.update_student('001', age=19, name='张三丰')
    
    # 删除学生
    manager.delete_student('003')

if __name__ == '__main__':
    main()

---

十二、异常处理

12.1 介绍

# 异常的作用：
# 1. 处理程序错误
# 2. 提高程序健壮性
# 3. 优雅地处理异常情况

# 常见异常类型：
# ZeroDivisionError: 除零错误
# FileNotFoundError: 文件不存在
# ValueError: 值错误
# TypeError: 类型错误
# KeyError: 键不存在
# IndexError: 索引越界

12.2 异常处理基本语法

try:
    # 可能出错的代码
    result = 10 / 0
except ZeroDivisionError:
    # 处理特定异常
    print('除数不能为零')
except Exception as e:
    # 处理其他异常
    print(f'发生错误：{e}')
else:
    # 没有异常时执行
    print('计算成功')
finally:
    # 无论是否异常都执行
    print('清理工作')

12.3 主动抛出异常

def set_age(age):
    if age < 0 or age > 150:
        raise ValueError('年龄必须在 0-150 之间')
    return age

try:
    set_age(-1)
except ValueError as e:
    print(e)

12.4 案例代码完善

class StudentManager:
    def add_student(self, student_id, name, age):
        try:
            # 验证学号
            if not student_id:
                raise ValueError('学号不能为空')
            
            # 验证姓名
            if not name or len(name) < 2:
                raise ValueError('姓名至少 2 个字符')
            
            # 验证年龄
            if age < 0 or age > 150:
                raise ValueError('年龄必须在 0-150 之间')
            
            # 检查是否已存在
            if student_id in self.students:
                raise ValueError('学生已存在')
            
            # 添加学生
            student = Student(student_id, name, age)
            self.students[student_id] = student
            print('添加成功')
            
        except ValueError as e:
            print(f'输入错误：{e}')
        except Exception as e:
            print(f'未知错误：{e}')

---

十三、总结与建议

13.1 最佳实践建议

1. 变量命名: 使用有意义的英文单词，遵循下划线命名法
2. 代码缩进: 统一使用 4 个空格或 1 个 Tab
3. 注释规范: 复杂逻辑必须添加注释说明
4. 类型转换: input() 获取的数据要及时转换
5. 循环终止: 规划好循环终止条件，避免死循环
6. 异常处理: 实际开发中应添加 try-except 处理异常
7. 代码复用: 重复代码应封装为函数
8. 类型注解: 建议使用类型注解提高代码可读性
9. 文档字符串: 函数和类应该包含文档字符串
10. 单一职责: 每个函数只做一件事

13.2 学习路线总结

Day01 基础

• Hello World 输出
• 注释的使用（单行/多行）
• 多行字符串的书写

Day02 进阶

• 关键字与标识符规则
• 9 大数据类型（4 基础 +4 容器 +1 空值）
• 变量定义与命名规范
• 字符串格式化（f-string、%占位符）
• 转义字符

Day03 条件控制

• 输入输出 (input/print)
• 数据类型转换
• 四大运算符（算术、赋值、比较、逻辑）
• if条件判断（if/if-else/if-elif-else/嵌套）

Day04 流程控制

• match-case 模式匹配（含 if 守卫）
• while 循环
• for 循环
• range() 数字序列生成
• 嵌套循环
• break/continue 控制
• 综合实战应用

Day05 数据容器

• 列表 list（切片、推导式、常用方法）
• 字符串 str（常用方法、案例）
• 元组 tuple（组包解包、案例优化）
• 集合 set（集合运算、去重）
• 字典 dict（键值对操作、案例实现）

函数篇

• 函数基础（定义、参数、返回值、文档）
• 函数进阶（作用域、不定长参数、lambda、递归）
• 类型注解（参数注解、返回值注解）

模块与面向对象

• 模块（导入、自定义模块、包）
• 面向对象（类与对象、魔法方法、属性）
• 综合案例（教务系统完整实现）

异常处理

• 异常介绍与语法
• try-except-finally结构
• 主动抛出异常
• 实际案例代码完善

---