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

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

一、数据存储与运算

1.1 数据类型（Day02）

基础数据类型

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

1.2 变量与标识符（Day02）

关键字

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

标识符命名规则

命名规范

• 小驼峰命名：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 数据运算实例

字符串格式化

转义字符

\\' # 单引号
\\" # 双引号
\\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 控制
• 综合实战应用

五、最佳实践建议

六、数据容器详解（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 数据容器总结

*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 最佳实践建议

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结构
• 主动抛出异常
• 实际案例代码完善