# 传统写法 - 又长又臭
squares = []
for i in range(1, 11):
    squares.append(i ** 2)

print(squares)
# 输出: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
1.
2.
3.
4.
5.
6.
7.

# 列表推导式 - 一行搞定
squares = [i ** 2 for i in range(1, 11)]

print(squares)
# 输出: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
1.
2.
3.
4.
5.

# 只保留偶数的平方
even_squares = [i ** 2 for i in range(1, 11) if i % 2 == 0]
print(even_squares)
# 输出: [4, 16, 36, 64, 100]
1.
2.
3.
4.

如果你想同时遍历列表的索引和值：

```python
# 传统写法 - 麻烦！
fruits = ['苹果', '香蕉', '橘子']

for i in range(len(fruits)):
    print(f"第{i}个水果是: {fruits[i]}")

# 输出:
# 第0个水果是: 苹果
# 第1个水果是: 香蕉
# 第2个水果是: 橘子
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

# enumerate - 自动给你索引
fruits = ['苹果', '香蕉', '橘子']

for i, fruit in enumerate(fruits, 1):  # 从1开始计数
    print(f"第{i}个水果是: {fruit}")

# 输出:
# 第1个水果是: 苹果
# 第2个水果是: 香蕉
# 第3个水果是: 橘子
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

# 同时遍历名字和年龄
names = ['小明', '小红', '小刚']
ages = [18, 20, 22]

for name, age in zip(names, ages):
    print(f"{name}今年{age}岁")

# 输出:
# 小明今年18岁
# 小红今年20岁
# 小刚今年22岁
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

# 一次性生成所有数据 - 内存爆炸警告！
numbers = [i ** 2 for i in range(1000000)]  # 这得占多少内存！

for num in numbers:
    print(num)
1.
2.
3.
4.
5.

# 生成器 - 用多少取多少，不浪费！
defsquare_generator(n):
    for i inrange(n):
        yield i ** 2

# 使用生成器
gen = square_generator(1000000)

# 每次只取一个值，内存占用极低！
for num in gen:
    print(num)
    if num > 100:  # 演示一下，不需要遍历全部
        break

# 输出:
# 0
# 1
# 4
# 9
# 16
# ...
# 121
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.

# 还能用圆括号创建生成器
gen = (i ** 2 for i in range(1000000))

print(next(gen))  # 0
print(next(gen))  # 1
print(next(gen))  # 4
1.
2.
3.
4.
5.
6.

# 传统写法 - 容易出错！
person = {'name': '小明', 'age': 18}

# 访问不存在的键会报错！
print(person['gender'])  # KeyError: 'gender'
1.
2.
3.
4.
5.

person = {'name': '小明', 'age': 18}

# get()方法 - 不存在就返回None，不会报错！
gender = person.get('gender')
print(gender)  # None

# 还能指定默认值
gender = person.get('gender', '未知')
print(gender)  # 未知
1.
2.
3.
4.
5.
6.
7.
8.
9.

person = {'name': '小明', 'age': 18}

# 如果键不存在，就设置为默认值
person.setdefault('gender', '未知')
print(person)  # {'name': '小明', 'age': 18, 'gender': '未知'}

# 如果键已存在，就不改变
person.setdefault('name', '小红')
print(person['name'])  # 小明（还是原来的值）
1.
2.
3.
4.
5.
6.
7.
8.
9.

# 老式写法 - 麻烦！
name = '小明'
age = 18
height = 1.75

# %格式化
print("我叫%s，今年%d岁，身高%.2f米" % (name, age, height))

# format方法
print("我叫{}，今年{}岁，身高{:.2f}米".format(name, age, height))
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

# f-string - 简单粗暴直接插入变量！
name = '小明'
age = 18
height = 1.75

print(f"我叫{name}，今年{age}岁，身高{height:.2f}米")

# 输出: 我叫小明，今年18岁，身高1.75米

# 还能运算！
print(f"明年我就{age + 1}岁了")
# 输出: 明年我就19岁了
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

# 格式化数字
num = 1234.5678
print(f"金额: {num:,.2f}")  # 金额: 1,234.57

# 对齐
names = ['小明', '小红', '小刚']
for name in names:
    print(f"{name:^10}爱你")  # 居中对齐

# 输出:
#    小明    爱你
#    小红    爱你
#    小刚    爱你
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

# 想去掉列表中的重复元素？
items = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]

# 传统方法 - 麻烦！
unique = []
for item in items:
    if item not in unique:
        unique.append(item)

print(unique)  # [1, 2, 3, 4]
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

# set - 一行搞定去重！
items = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]

unique = list(set(items))
print(unique)  # [1, 2, 3, 4]

# 注意：set是无序的，如果需要保持顺序，可以用 dict.fromkeys()
unique_ordered = list(dict.fromkeys(items))
print(unique_ordered)  # [1, 2, 3, 4]
1.
2.
3.
4.
5.
6.
7.
8.
9.

# 判断元素是否在列表中 - O(n)复杂度
items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(5 in items)  # True - 列表需要遍历

# 判断元素是否在集合中 - O(1)复杂度
items_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
print(5 in items_set)  # True - 集合直接定位，超级快！
1.
2.
3.
4.
5.
6.
7.

# 集合的交、并、差运算
set_a = {1, 2, 3, 4, 5}
set_b = {4, 5, 6, 7, 8}

print(set_a | set_b)  # 并集: {1, 2, 3, 4, 5, 6, 7, 8}
print(set_a & set_b)  # 交集: {4, 5}
print(set_a - set_b)  # 差集: {1, 2, 3}
print(set_a ^ set_b)  # 对称差集: {1, 2, 3, 6, 7, 8}
1.
2.
3.
4.
5.
6.
7.
8.

# 定义一个装饰器 - 打印函数执行时间
import time

deftimer(func):
    defwrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"函数{func.__name__}执行了{end - start:.4f}秒")
        return result
    return wrapper

# 使用装饰器
@timer
defslow_function():
    time.sleep(1)  # 模拟耗时操作
    return"执行完成！"

# 调用函数
result = slow_function()
# 输出: 函数slow_function执行了1.0012秒
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.

# 1. 日志记录
deflog(func):
    defwrapper(*args, **kwargs):
        print(f"调用函数: {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

# 2. 权限检查
defrequire_login(func):
    defwrapper(user):
        if user.get('is_login'):
            return func(user)
        else:
            return"请先登录！"
    return wrapper

# 使用
@require_login
defget_profile(user):
    returnf"欢迎{user['name']}！"

# 测试
user1 = {'name': '小明', 'is_login': True}
user2 = {'name': '小红', 'is_login': False}

print(get_profile(user1))  # 欢迎小明！
print(get_profile(user2))  # 请先登录！
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.

# 传统文件操作 - 容易忘记关闭！
f = open('test.txt', 'w')
f.write('你好')
f.close()  # 忘记关就麻烦了！

# 如果中途出错，文件可能没关闭！
# f = open('test.txt', 'w')
# f.write('你好')
# raise Exception("出错了！")  # 这时候f.close()根本执行不到！
1.
2.
3.
4.
5.
6.
7.
8.
9.

# with语句 - 自动帮你关闭资源！
with open('test.txt', 'w', encoding='utf-8') as f:
    f.write('你好，小甲鱼！')
    # 即使这里出错，文件也会正确关闭

# 文件自动关闭了，可以继续用
with open('test.txt', 'r', encoding='utf-8') as f:
    content = f.read()
    print(content)  # 你好，小甲鱼！
1.
2.
3.
4.
5.
6.
7.
8.
9.

# 上下文管理器协议
classMyContextManager:
    def__enter__(self):
        print("进入上下文")
        returnself
    
    def__exit__(self, exc_type, exc_val, exc_tb):
        print("退出上下文")
        # 如果返回True，异常会被吞掉
        returnFalse

with MyContextManager() as cm:
    print("在上下文中执行")
    # 即使出错，也会执行__exit__

# 输出:
# 进入上下文
# 在上下文中执行
# 退出上下文
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

# 硬编码类型检查 - 不好！
def process(data):
    if type(data) == str:
        return data.upper()
    elif type(data) == int:
        return data * 2
    elif type(data) == list:
        return sum(data)
1.
2.
3.
4.
5.
6.
7.
8.

# isinstance - 支持继承关系！
defprocess(data):
    ifisinstance(data, str):
        return data.upper()
    elifisinstance(data, (int, float)):  # 同时检查多个类型
        return data * 2
    elifisinstance(data, list):
        returnsum(data)

# 测试
print(process("hello"))    # HELLO
print(process(10))         # 20
print(process(3.14))       # 6.28
print(process([1, 2, 3]))  # 6
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

# 检查自定义类
classAnimal:
    pass

classDog(Animal):
    pass

classCat(Animal):
    pass

dog = Dog()

# isinstance考虑继承关系
print(isinstance(dog, Dog))    # True
print(isinstance(dog, Animal)) # True - Dog是Animal的子类！

# type不考虑继承
print(type(dog) == Animal)     # False
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

# 更好的方式：鸭子类型
# 不要检查类型，而是检查行为
defprocess(data):
    # 如果有upper方法，就调用它
    ifhasattr(data, 'upper'):
        return data.upper()
    # 如果可以相乘
    elifhasattr(data, '__mul__'):
        return data * 2
    # 如果可以求和
    elifhasattr(data, '__add__'):
        returnsum(data)

# 这样更灵活，字符串、数字、列表都能处理！
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

# 用if判断来处理错误 - 代码又臭又长！
def divide(a, b):
    if b == 0:
        return "不能除以0！"
    else:
        return a / b

# 每个地方都要判断，烦不烦？
result = divide(10, 0)
print(result)
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

# 用try-except - 更优雅！
def divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return "不能除以0！"

# 测试
print(divide(10, 2))  # 5.0
print(divide(10, 0))  # 不能除以0！
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

# 处理多种异常
defprocess(data):
    try:
        result = int(data) / 0
        return result
    except ValueError:
        return"无法转换为数字"
    except ZeroDivisionError:
        return"不能除以0"
    except Exception as e:
        returnf"未知错误: {e}"

print(process("abc"))  # 无法转换为数字
print(process("10"))   # 不能除以0
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

# 完整的异常处理结构
try:
    # 尝试执行的代码
    result = 10 / 2
except ZeroDivisionError:
    # 发生ZeroDivisionError时执行
    print("除以0了！")
else:
    # 没有异常时执行
    print(f"计算结果是{result}")
finally:
    # 无论有没有异常都执行
    print("这段代码无论如何都会执行")

# 输出:
# 计算结果是5.0
# 这段代码无论如何都会执行
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

# 读取文件，兼容各种错误
defread_file(filename):
    try:
        withopen(filename, 'r', encoding='utf-8') as f:
            return f.read()
    except FileNotFoundError:
        returnf"文件{filename}不存在"
    except PermissionError:
        returnf"没有权限读取{filename}"
    except UnicodeDecodeError:
        return"文件编码错误"

# 完美！
print(read_file('不存在的文件.txt'))  # 文件不存在的文件.txt不存在
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

"""
学生信息管理系统 v2.0
用上我们今天学的所有技巧！
"""

classStudent:
    """学生类"""
    def__init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score
    
    def__repr__(self):
        returnf"Student(name='{self.name}', age={self.age}, score={self.score})"

classStudentManager:
    """学生管理系统 - 优化版"""
    
    def__init__(self):
        # 使用字典存储学生，id为键
        self.students = {}
        self.next_id = 1
    
    # 技巧七：装饰器 - 添加日志功能
    deflog_operation(func):
        """记录操作日志的装饰器"""
        defwrapper(self, *args, **kwargs):
            print(f"n[操作] 开始执行: {func.__name__}")
            result = func(self, *args, **kwargs)
            print(f"[操作] 完成: {func.__name__}")
            return result
        return wrapper
    
    # 技巧一：列表推导式 - 快速添加学生
    @log_operation
    defadd_student(self, name, age, score):
        """添加学生"""
        # 技巧四：字典安全访问 - 不需要
        # 技巧五：f-string - 格式化输出
        student_id = self.next_id
        self.students[student_id] = Student(name, age, score)
        self.next_id += 1
        print(f"✅ 添加成功: {name}, 学号: {student_id}")
        return student_id
    
    @log_operation
    defadd_multiple_students(self, student_list):
        """批量添加学生 - 使用列表推导式"""
        # 列表推导式 + 生成器
        student_ids = [
            self.add_student(name, age, score) 
            for name, age, score in student_list
        ]
        print(f"✅ 批量添加了 {len(student_ids)} 个学生")
        return student_ids
    
    # 技巧二：enumerate - 遍历学生列表
    deflist_students(self):
        """列出所有学生"""
        ifnotself.students:
            print("? 还没有学生记录")
            return
        
        print("n? 学生列表:")
        print("-" * 50)
        # enumerate + f-string
        for i, (sid, student) inenumerate(self.students.items(), 1):
            print(f"{i}. 学号:{sid} | 姓名:{student.name} | "
                  f"年龄:{student.age} | 分数:{student.score}")
        print("-" * 50)
    
    # 技巧三：生成器 - 遍历高分学生
    defget_top_scorers(self, threshold=60):
        """获取高分学生 - 使用生成器"""
        # 生成器表达式
        return (
            (sid, student) 
            for sid, student inself.students.items() 
            if student.score >= threshold
        )
    
    defshow_top_scorers(self, threshold=60):
        """显示高分学生"""
        print(f"n? 分数 >= {threshold} 的学生:")
        top_students = list(self.get_top_scorers(threshold))
        
        ifnot top_students:
            print("没有找到高分学生")
            return
        
        # 技巧二：zip - 同时展示排名
        for rank, (sid, student) inenumerate(top_students, 1):
            print(f"  {rank}. {student.name} - {student.score}分")
    
    # 技巧六：集合操作 - 查找学生
    defsearch_by_name(self, name):
        """搜索学生 - 使用集合"""
        # 找到所有名字包含关键字的学生
        results = {
            sid: student 
            for sid, student inself.students.items() 
            if name in student.name
        }
        return results
    
    # 技巧八：with语句 - 安全的文件操作
    defsave_to_file(self, filename="students.txt"):
        """保存到文件"""
        try:
            withopen(filename, 'w', encoding='utf-8') as f:
                for sid, student inself.students.items():
                    # 技巧五：f-string 格式化
                    f.write(f"{sid},{student.name},{student.age},{student.score}n")
            print(f"? 已保存到 {filename}")
        except Exception as e:
            print(f"❌ 保存失败: {e}")
    
    defload_from_file(self, filename="students.txt"):
        """从文件加载"""
        try:
            withopen(filename, 'r', encoding='utf-8') as f:
                # 读取并解析
                for line in f:
                    line = line.strip()
                    ifnot line:
                        continue
                    
                    parts = line.split(',')
                    iflen(parts) == 4:
                        sid, name, age, score = parts
                        self.students[int(sid)] = Student(name, int(age), float(score))
                        self.next_id = max(self.next_id, int(sid) + 1)
            
            print(f"? 已从 {filename} 加载")
        except FileNotFoundError:
            print(f"? 文件 {filename} 不存在")
        except Exception as e:
            print(f"❌ 加载失败: {e}")
    
    # 技巧十：异常处理 - 安全的删除操作
    @log_operation
    defdelete_student(self, student_id):
        """删除学生"""
        try:
            # 技巧九：isinstance 类型检查
            ifnotisinstance(student_id, int):
                student_id = int(student_id)
            
            # 技巧四：字典安全访问
            student = self.students.get(student_id)
            if student isNone:
                print(f"❌ 学号 {student_id} 不存在")
                returnFalse
            
            delself.students[student_id]
            print(f"?️ 已删除学生: {student.name}")
            returnTrue
            
        except ValueError:
            print("❌ 学号必须是数字")
            returnFalse
        except Exception as e:
            print(f"❌ 删除失败: {e}")
            returnFalse


# ==================== 主程序 ====================
defmain():
    """主程序 - 演示所有功能"""
    print("=" * 50)
    print("? 学生信息管理系统 v2.0")
    print("=" * 50)
    
    # 创建管理器
    manager = StudentManager()
    
    # 1. 批量添加学生 - 用列表推导式
    print("n【添加学生】")
    students_data = [
        ("小明", 18, 85),
        ("小红", 19, 92),
        ("小刚", 20, 78),
        ("小丽", 18, 95),
        ("小强", 19, 88),
    ]
    manager.add_multiple_students(students_data)
    
    # 2. 列出所有学生 - 用enumerate
    print("n【查看学生】")
    manager.list_students()
    
    # 3. 显示高分学生 - 用生成器
    print("n【高分学生】")
    manager.show_top_scorers(85)
    
    # 4. 搜索学生 - 用字典推导式
    print("n【搜索学生】")
    results = manager.search_by_name("小")
    print(f"找到 {len(results)} 个包含'小'的学生:")
    for sid, s in results.items():
        print(f"  - {s.name}")
    
    # 5. 删除学生 - 用异常处理
    print("n【删除学生】")
    manager.delete_student(1)
    manager.list_students()
    
    # 6. 保存和加载 - 用with语句
    print("n【文件操作】")
    manager.save_to_file()
    manager.load_from_file()
    
    print("n" + "=" * 50)
    print("? 程序结束！")
    print("=" * 50)


if __name__ == "__main__":
    main()
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
156.
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169.
170.
171.
172.
173.
174.
175.
176.
177.
178.
179.
180.
181.
182.
183.
184.
185.
186.
187.
188.
189.
190.
191.
192.
193.
194.
195.
196.
197.
198.
199.
200.
201.
202.
203.
204.
205.
206.
207.
208.
209.
210.
211.
212.
213.
214.
215.
216.
217.
218.
219.

==================================================
? 学生信息管理系统 v2.0
==================================================

[操作] 开始执行: add_multiple_students

[操作] 完成: add_multiple_students
✅ 批量添加了 5 个学生

【查看学生】

? 学生列表:
--------------------------------------------------
1. 学号:1 | 姓名:小明 | 年龄:18 | 分数:85.0
2. 学号:2 | 姓名:小红 | 年龄:19 | 分数:92.0
3. 学号:3 | 姓名:小刚 | 年龄:20 | 分数:78.0
4. 学号:4 | 姓名:小丽 | 年龄:18 | 分数:95.0
5. 学号:5 | 姓名:小强 | 年龄:19 | 分数:88.0
--------------------------------------------------

【高分学生】

? 分数 >= 85 的学生:
  1. 小红 - 92.0分
  2. 小丽 - 95.0分
  3. 小强 - 88.0分
  4. 小明 - 85.0分
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.

# 错误做法！
nums = [1, 2, 3, 4, 5]
for n in nums:
    if n % 2 == 0:
        nums.remove(n)
print(nums)  # 结果不可预测！

# 正确做法：创建新列表
nums = [1, 2, 3, 4, 5]
nums = [n for n in nums if n % 2 != 0]
print(nums)  # [1, 3, 5]
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

# 错误做法！
defadd_item(item, list=[]):  # 危险！
    list.append(item)
    returnlist

print(add_item(1))  # [1]
print(add_item(2))  # [1, 2] - 预期是[2]吧？

# 正确做法
defadd_item(item, list=None):
    iflistisNone:
        list = []
    list.append(item)
    returnlist
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

# 错误做法！列表推导式不是万能的
result = []
for i in range(10):
    for j in range(10):
        result.append(i * j)
# 这就不应该用列表推导式，代码反而更难读！

# 正确做法：简单的情况用推导式，复杂的情况用普通循环
result = [i * j for i in range(10) for j in range(10)]  # 这个还可以

# 但更复杂的逻辑还是用循环吧，别硬凑！
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

# 错误做法！
f = open('data.txt', 'r')
content = f.read()
# 如果这里出错，文件永远不会关闭！

# 正确做法：永远用with！
with open('data.txt', 'r') as f:
    content = f.read()
# 自动关闭，妥妥的！
1.
2.
3.
4.
5.
6.
7.
8.
9.

# 错误做法！
try:
    result = data['key']
except KeyError:
    result = '默认值'

# 正确做法：用get()
result = data.get('key', '默认值')
# 只有在真正"异常"的情况下才用try-except
1.
2.
3.
4.
5.
6.
7.
8.
9.