1
# for循环示例1：遍历数字序列
2
# range(5) 生成一个从0开始（包含）到5结束（不包含）的整数序列：0, 1, 2, 3, 4。
3
# 循环将依次把这些数字赋值给变量i，并执行循环体。
4
print("--- for 循环示例1 ---")
5
for i in range(5):  # 循环5次，i从0到4
6
    print(f"当前数字: {i}") # 每次循环打印当前i的值。
7

8
# for循环示例2：遍历列表
9
print("\n--- for 循环示例2 ---")
10
fruits = ["苹果", "香蕉", "橙子"]
11
for fruit in fruits:
12
    print(f"我喜欢吃: {fruit}")
13

14
# for循环示例3：遍历字符串
15
print("\n--- for 循环示例3 ---")
16
word = "Python"
17
for char in word:
18
    print(f"字符: {char}")
19

20
# for循环示例4：结合enumerate获取索引和值
21
print("\n--- for 循环示例4 ---")
22
for index, fruit in enumerate(fruits):
23
    print(f"索引 {index}: {fruit}")

1
# while循环示例1：计数器
2
print("\n--- while 循环示例1 ---")
3
count = 0 # 初始化计数器变量。
4
while count < 5: # 只要count小于5，循环就继续。
5
    print(f"当前计数: {count}") # 打印当前计数。
6
    count += 1 # 每次循环结束后，将count加1，确保循环最终会停止。
7

8
# while循环示例2：用户输入直到满足条件
9
print("\n--- while 循环示例2 ---")
10
password = ""
11
while password != "secret":
12
    password = input("请输入密码: ")
13
    if password == "secret":
14
        print("密码正确，欢迎！")
15
    else:
16
        print("密码错误，请重试。")

1
# break 和 continue 示例
2
print("\n--- break 和 continue 示例 ---")
3
for i in range(10):
4
    if i == 3:
5
        print("遇到3，跳过本次循环的剩余部分 (continue)")
6
        continue # 当i为3时，跳过下面的print，直接进入下一次循环。
7
    if i == 7:
8
        print("遇到7，终止整个循环 (break)")
9
        break # 当i为7时，立即终止整个for循环。
10
    print(f"当前数字: {i}")

1
# 定义函数 (Function Definition)
2
# def 关键字用于定义函数，后面跟着函数名和括号()，括号内可以包含参数。
3
# 冒号(:)表示函数头的结束，函数体通过缩进来定义。
4
def calculate_area(length, width): # 定义一个名为calculate_area的函数，它接受两个参数：length和width。
5
    """计算矩形面积的函数""" # 这是一个文档字符串(docstring)，用于描述函数的功能。良好的文档字符串是代码可读性的关键。
6
    # return 语句用于从函数中返回值。如果函数没有明确的return语句，它将默认返回None。
7
    return length * width # 函数体：计算length和width的乘积并返回结果。
8

9
# 另一个函数定义示例：不带参数，不返回值（隐式返回None）
10
def say_hello():
11
    print("Hello, Python!")

1
# 调用函数 (Function Call)
2
# 调用calculate_area函数，并传入参数5和3。
3
area = calculate_area(5, 3) # 函数执行后，返回的结果(15)会被赋值给变量area。
4
print(f"面积是：{area}") # 输出计算出的面积。
5

6
# 调用不带参数的函数
7
say_hello() # 执行say_hello函数，它会打印"Hello, Python!"。

1
# 带默认参数的函数 (Functions with Default Arguments)
2
# 定义一个greet函数，name参数有一个默认值"访客"。
3
def greet(name="访客", greeting="你好"): # name和greeting都是带默认值的参数。
4
    return f"{greeting}，{name}！" # 返回一个格式化的问候语。
5

6
# 调用greet函数：
7
print(greet()) # 不传入任何参数，使用所有默认值。输出: "你好，访客！"
8
print(greet("小明")) # 传入name参数，使用默认的greeting。输出: "你好，小明！"
9
print(greet(name="小红", greeting="早上好")) # 使用关键字参数，顺序可以颠倒。输出: "早上好，小红！"
10
print(greet(greeting="晚上好", name="李华")) # 关键字参数的顺序不影响。

1
def collect_info(name, *args, **kwargs):
2
    print(f"姓名: {name}")
3
    print(f"其他位置信息: {args}") # args是一个元组
4
    print(f"其他关键字信息: {kwargs}") # kwargs是一个字典
5

6
collect_info("张三", 25, "男", city="北京", job="工程师")
7
# 输出：
8
# 姓名: 张三
9
# 其他位置信息: (25, '男')
10
# 其他关键字信息: {'city': '北京', 'job': '工程师'}

1
# 列表（List）：有序、可变、可包含重复元素
2
fruits = ["苹果", "香蕉", "橙子"] # 创建一个包含三个字符串的列表。
3
print(f"原始列表: {fruits}")
4

5
fruits.append("葡萄")  # 使用append()方法在列表末尾添加一个元素。
6
print(f"添加元素后: {fruits}")
7

8
fruits.insert(1, "草莓") # 使用insert()方法在指定索引位置插入元素。
9
print(f"插入元素后: {fruits}")
10

11
fruits.remove("香蕉") # 使用remove()方法移除指定值的第一个匹配项。
12
print(f"移除元素后: {fruits}")
13

14
popped_fruit = fruits.pop() # 使用pop()方法移除并返回列表末尾的元素（默认）。
15
print(f"弹出元素: {popped_fruit}, 列表变为: {fruits}")
16

17
# 列表索引和切片
18
print(f"第一个元素: {fruits[0]}") # 访问列表的第一个元素（索引从0开始）。
19
print(f"从索引1到2的元素: {fruits[1:3]}") # 切片操作，获取子列表。
20

21
# 列表可以包含不同类型的数据
22
mixed_list = [1, "hello", 3.14, True]
23
print(f"混合类型列表: {mixed_list}")

1
# 字典（Dictionary）：无序、可变、键值对存储
2
person = { # 创建一个字典，包含姓名、年龄和城市信息。
3
    "name": "小明",
4
    "age": 18,
5
    "city": "北京"
6
}
7
print(f"原始字典: {person}")
8

9
print(f"姓名: {person["name"]}") # 通过键访问字典中的值。
10

11
person["age"] = 19 # 修改字典中键对应的值。
12
print(f"修改年龄后: {person}")
13

14
person["gender"] = "男" # 添加新的键值对。
15
print(f"添加性别后: {person}")
16

17
del person["city"] # 使用del关键字删除键值对。
18
print(f"删除城市后: {person}")
19

20
# 遍历字典
21
print("\n遍历字典的键:")
22
for key in person.keys(): # 获取所有键。
23
    print(key)
24

25
print("\n遍历字典的值:")
26
for value in person.values(): # 获取所有值。
27
    print(value)
28

29
print("\n遍历字典的键值对:")
30
for key, value in person.items(): # 获取所有键值对。
31
    print(f"{key}: {value}")

1
# 集合（Set）：无序、可变、元素唯一
2
numbers = {1, 2, 3, 3, 4}  # 创建一个集合，重复的3会被自动去除。
3
print(f"原始集合: {numbers}") # 结果是{1, 2, 3, 4}
4

5
numbers.add(5) # 添加元素。
6
print(f"添加元素后: {numbers}")
7

8
numbers.remove(1) # 移除元素。
9
print(f"移除元素后: {numbers}")
10

11
# 集合操作：并集、交集、差集
12
set_a = {1, 2, 3}
13
set_b = {3, 4, 5}
14
print(f"并集: {set_a.union(set_b)}") # 或 set_a | set_b
15
print(f"交集: {set_a.intersection(set_b)}") # 或 set_a & set_b
16
print(f"差集 (A-B): {set_a.difference(set_b)}") # 或 set_a - set_b

1
# 元组（Tuple）：有序、不可变、可包含重复元素
2
coordinates = (10, 20) # 创建一个包含两个数字的元组。
3
print(f"原始元组: {coordinates}")
4

5
# 尝试修改元组会报错
6
# coordinates[0] = 15 # 这会引发TypeError
7

8
# 元组的解包
9
x, y = coordinates # 将元组的元素分别赋值给x和y。
10
print(f"解包后的x: {x}, y: {y}")
11

12
# 包含单个元素的元组需要逗号
13
single_element_tuple = (1,) # 必须有逗号，否则会被认为是普通表达式。
14
print(f"单元素元组: {single_element_tuple}")
15

16
# 元组常用于函数返回多个值，或作为字典的键（因为其不可变性）。

1
# 安全打开文件的最佳实践
2
try:
3
    # 以读取模式打开文本文件，显式指定UTF-8编码
4
    with open('data.txt', 'r', encoding='utf-8') as file:
5
        content = file.read()
6
        print(content)
7
except FileNotFoundError:
8
    print("文件未找到，请检查路径是否正确")
9
except UnicodeDecodeError:
10
    print("文件编码错误，请尝试其他编码方式")
11
except Exception as e:
12
    print(f"打开文件时发生错误: {e}")

1
# 写入文件 (Writing to a File)
2
# 使用 'w' 模式打开文件，如果文件不存在则创建，如果存在则清空内容。
3
# encoding='utf-8' 指定了文件的编码格式，这对于处理包含非ASCII字符（如中文）的文本非常重要。
4
# 'with' 语句确保文件在操作完成后自动关闭，即使发生异常。
5
file_path_write = "example_write.txt"
6
with open(file_path_write, "w", encoding="utf-8") as f:
7
    # write() 方法将字符串写入文件，不会自动添加换行符
8
    f.write("这是一个示例文件。\n") # 写入一行文本到文件。
9
    f.write("这是第二行内容。\n") # 继续写入第二行。
10

11
    # writelines() 方法可以写入字符串列表，同样不会自动添加换行符
12
    lines = ["第三行内容\n", "第四行内容\n"]
13
    f.writelines(lines)
14

15
    print(f"内容已写入到 {file_path_write}")
16

17
# 文件写入的缓冲区：默认情况下，写入操作会先写入内存缓冲区，而不是立即写入磁盘
18
# 可以使用 flush() 方法强制将缓冲区内容写入磁盘
19
# 或者设置 buffering 参数来控制缓冲区大小
20

21
**核心概念：**
22
* **写入方法**:
23
  - `write()`: 写入单个字符串
24
  - `writelines()`: 写入字符串序列
25
* **换行处理**: Python不会自动添加换行符，需要显式添加 `\n`
26
* **缓冲区**: 写入操作通常使用缓冲区，可通过 `flush()` 强制写入或设置 `buffering` 参数
27
* **原子写入**: 对于关键数据，可能需要临时文件+重命名的方式确保原子性
28
* **性能考虑**: 大量小写入操作比少量大写入操作性能差
29

30
# 追加内容到文件 (Appending to a File)
31
# 使用 'a' 模式打开文件，如果文件存在则在末尾追加内容。
32
file_path_append = "example_append.txt"
33
with open(file_path_append, "a", encoding="utf-8") as f:
34
    f.write("这是追加的第一行。\n")
35
    f.write("这是追加的第二行。\n")
36
    print(f"内容已追加到 {file_path_append}")

1
#### 读取文件
2

3
```python
4
# 读取文件 (Reading from a File)
5
# 使用 'r' 模式打开文件。
6
file_path_read = "example_write.txt" # 读取之前写入的文件。
7

8
try:
9
    with open(file_path_read, "r", encoding="utf-8") as f:
10
        # read() 方法读取文件的所有内容作为一个字符串。可以指定读取的字符数。
11
        content_full = f.read()
12
        print(f"\n从 {file_path_read} 读取到的全部内容:\n{content_full}")
13

14
        # seek(0) 将文件指针重置到文件开头，以便重新读取。
15
        f.seek(0)
16
        # readline() 方法读取文件的一行内容，包括换行符。
17
        first_line = f.readline()
18
        print(f"\n从 {file_path_read} 读取到的第一行:\n{first_line.strip()}")
19

20
        f.seek(0)
21
        # readlines() 方法读取所有行并返回一个字符串列表，每行包含换行符。
22
        all_lines = f.readlines()
23
        print(f"\n从 {file_path_read} 读取到的所有行(列表形式):\n{all_lines}")
24

25
        f.seek(0)
26
        # 也可以逐行读取文件，这是处理大文件的推荐方式。
27
        print(f"\n逐行从 {file_path_read} 读取到的内容:")
28
        for line in f: # 迭代文件对象可以逐行读取，内存效率高。
29
            print(f"行: {line.strip()}") # strip() 移除行末的换行符。
30

31
except FileNotFoundError:
32
    print(f"错误: 文件 {file_path_read} 未找到。")
33
except Exception as e:
34
    print(f"读取文件时发生错误: {e}")
35

36
# 读取大文件时，逐行读取或分块读取更高效，避免一次性加载所有内容到内存。

1
**核心概念：**
2
*   **文件对象**: `open()` 函数返回一个文件对象，通过它进行读写操作。
3
*   **`with` 语句**: 推荐使用 `with open(...) as f:` 语法，它被称为上下文管理器。它能确保文件在使用完毕后（无论是正常结束还是发生异常）自动关闭，从而避免资源泄露。
4
*   **文件模式**: 根据读写需求选择合适的模式（`'r'`, `'w'`, `'a'`, `'x'` 等）。
5
*   **编码**: 处理文本文件时，指定正确的 `encoding` 参数（如 `'utf-8'`）非常重要，以避免乱码问题。
6
*   **文件指针**: 读取和写入操作会移动文件内部的指针。`seek()` 方法可以用来改变文件指针的位置。
7
*   **缓冲区**: 文件操作通常涉及缓冲区，理解其工作原理有助于优化性能。
8
*   **路径操作**: Python的 `os.path` 模块提供了处理文件路径的工具，如判断路径是否存在、获取文件名、目录名等。
9
*   **文件系统操作**: `os` 模块还提供了创建、删除目录，重命名文件等功能。
10

11
### 异常处理
12
异常（Exception）是在程序执行期间发生的事件，它会中断程序的正常流程。当Python脚本遇到无法处理的错误时，它会抛出一个异常。异常处理机制允许程序优雅地处理这些错误，而不是突然崩溃。Python使用 `try`、`except`、`else` 和 `finally` 关键字来构建异常处理结构。
13

14
#### `try-except` 块
15
*   `try` 块：包含可能会引发异常的代码。
16
*   `except` 块：当 `try` 块中的代码引发特定类型的异常时，`except` 块中的代码会被执行。
17

18
**代码示例：**
19

20
```python
21
# 异常处理示例
22
print("--- 异常处理示例 ---")
23
try:
24
    # 尝试执行可能出错的代码
25
    number_str = input("请输入一个数字：") # 从用户获取输入，这是一个字符串。
26
    number = int(number_str) # 尝试将字符串转换为整数。如果输入不是有效数字，会引发ValueError。
27
    result = 10 / number # 尝试执行除法。如果number为0，会引发ZeroDivisionError。
28
    print(f"结果是：{result}") # 如果以上操作都成功，打印结果。
29
except ValueError: # 捕获ValueError异常。
30
    print("错误：请输入有效的整数！") # 当用户输入非数字字符串时执行。
31
except ZeroDivisionError: # 捕获ZeroDivisionError异常。
32
    print("错误：不能除以零！") # 当用户输入0时执行。
33
except Exception as e: # 捕获所有其他未被特定except捕获的异常。
34
    print(f"发生了未知错误: {e}") # 打印错误信息。
35

36
print("程序继续执行...") # 无论是否发生异常，程序都会继续执行到这里。

1
# try-except-else 示例
2
print("\n--- try-except-else 示例 ---")
3
try:
4
    num1 = int(input("请输入第一个数字: "))
5
    num2 = int(input("请输入第二个数字: "))
6
    division_result = num1 / num2
7
except ValueError:
8
    print("输入无效，请确保输入的是数字。")
9
except ZeroDivisionError:
10
    print("除数不能为零。")
11
else:
12
    # 如果try块没有发生异常，则执行此处的代码
13
    print(f"两个数字相除的结果是: {division_result}")

1
# try-except-finally 示例
2
print("\n--- try-except-finally 示例 ---")
3
file = None
4
try:
5
    file = open("non_existent_file.txt", "r") # 尝试打开一个不存在的文件，会引发FileNotFoundError。
6
    content = file.read()
7
    print(content)
8
except FileNotFoundError:
9
    print("文件未找到。")
10
finally:
11
    # 无论是否发生异常，都会执行这里的代码
12
    if file:
13
        file.close() # 确保文件被关闭，释放资源。
14
        print("文件已关闭。")
15
    print("程序执行完毕。")

1
# 定义一个名为Student的类
2
class Student:
3
    # 类的属性（通常在__init__方法中定义实例属性）
4
    school_name = "某某大学" # 这是一个类属性，所有Student的实例共享。
5

6
    # 构造方法 (Constructor): __init__
7
    # 这是一个特殊的方法，当创建类的新实例（对象）时会自动调用。
8
    # self 参数是必须的，它代表了类的实例本身。
9
    # name 和 age 是实例属性，它们属于每个Student对象独有。
10
    def __init__(self, name, age):
11
        self.name = name # 将传入的name参数赋值给实例的name属性。
12
        self.age = age   # 将传入的age参数赋值给实例的age属性。
13
        print(f"学生 {self.name} 已创建。")
14

15
    # 实例方法 (Instance Method)
16
    # 方法是定义在类中的函数，用于描述对象的行为。它们也必须接受self作为第一个参数。
17
    def introduce(self):
18
        # 访问实例属性和类属性
19
        return f"我叫{self.name}，今年{self.age}岁，就读于 {Student.school_name}。"
20

21
    def celebrate_birthday(self):
22
        self.age += 1 # 修改实例属性
23
        print(f"{self.name} 庆祝了生日，现在 {self.age} 岁了！")

1
# 创建对象 (Creating Objects / Instances)
2
# 通过调用类名并传入__init__方法所需的参数来创建Student类的实例。
3
student1 = Student("小明", 18) # 创建第一个Student对象。
4
student2 = Student("小红", 19) # 创建第二个Student对象。
5

6
# 访问对象的属性
7
print(f"学生1的姓名: {student1.name}")
8
print(f"学生2的年龄: {student2.age}")
9
print(f"学生1的学校: {student1.school_name}") # 可以通过实例访问类属性
10
print(f"学生2的学校: {Student.school_name}") # 也可以通过类名访问类属性
11

12
# 调用对象的方法
13
print(student1.introduce()) # 调用student1对象的introduce方法。
14
print(student2.introduce()) # 调用student2对象的introduce方法。
15

16
student1.celebrate_birthday() # 调用student1的生日方法
17
print(student1.introduce())

1
# 定义父类 (Parent Class / Base Class)
2
class Person:
3
    def __init__(self, name, age):
4
        self.name = name # 实例属性：姓名
5
        self.age = age   # 实例属性：年龄
6
        print(f"Person {self.name} 已创建。")
7

8
    def greet(self):
9
        """父类方法：打招呼"""
10
        return f"你好，我是{self.name}，我今年{self.age}岁。"
11

12
# 定义子类 (Child Class / Derived Class)
13
# Teacher类继承自Person类，在类名后括号中指定父类。
14
class Teacher(Person):
15
    # 子类的构造方法
16
    # 当子类有自己的__init__方法时，它会覆盖父类的__init__方法。
17
    # 如果需要调用父类的__init__方法来初始化父类的属性，必须显式调用super().__init__()。
18
    def __init__(self, name, age, subject):
19
        # 调用父类Person的构造方法，初始化name和age属性。
20
        # super() 函数返回父类的代理对象，允许你调用父类的方法。
21
        super().__init__(name, age)
22
        self.subject = subject # 子类特有的属性：教授科目。
23
        print(f"Teacher {self.name} (教授{self.subject}) 已创建。")
24

25
    # 子类特有的方法
26
    def teach(self):
27
        """子类特有方法：教学"""
28
        return f"我叫{self.name}，我教{self.subject}。"
29

30
# 创建子类对象
31
teacher = Teacher("张老师", 35, "数学")
32

33
# 调用继承自父类的方法
34
print(teacher.greet())  # 输出: 你好，我是张老师，我今年35岁。
35

36
# 调用子类特有的方法
37
print(teacher.teach())  # 输出: 我叫张老师，我教数学。
38

39
# 检查对象类型
40
print(f"teacher是Person的实例吗？ {isinstance(teacher, Person)}") # True
41
print(f"teacher是Teacher的实例吗？ {isinstance(teacher, Teacher)}") # True
42

43
# 检查类之间的继承关系
44
print(f"Teacher是Person的子类吗？ {issubclass(Teacher, Person)}") # True
45
print(f"Person是Teacher的子类吗？ {issubclass(Person, Teacher)}") # False

1
class Animal:
2
    def speak(self):
3
        """父类方法：动物发出声音"""
4
        return "动物发出声音"
5

6
class Dog(Animal):
7
    def speak(self):
8
        """子类重写方法：狗发出声音"""
9
        # 可以在重写的方法中调用父类的方法，以扩展而非完全替换父类行为
10
        # return f"{super().speak()}，然后汪汪叫"
11
        return "汪汪叫"
12

13
class Cat(Animal):
14
    def speak(self):
15
        """子类重写方法：猫发出声音"""
16
        return "喵喵叫"
17

18
animal = Animal()
19
dog = Dog()
20
cat = Cat()
21

22
print(animal.speak()) # 输出: 动物发出声音
23
print(dog.speak())    # 输出: 汪汪叫 (子类重写了方法)
24
print(cat.speak())    # 输出: 喵喵叫 (子类重写了方法)

1
class Flyer:
2
    def fly(self):
3
        return "我会飞！"
4

5
class Swimmer:
6
    def swim(self):
7
        return "我会游泳！"
8

9
class Duck(Flyer, Swimmer):
10
    def quack(self):
11
        return "嘎嘎！"
12

13
duck = Duck()
14
print(duck.fly())   # 输出: 我会飞！
15
print(duck.swim())  # 输出: 我会游泳！
16
print(duck.quack()) # 输出: 嘎嘎！
17

18
# 查看方法解析顺序 (MRO)
19
print(Duck.__mro__)
20
# 输出示例: (<class '__main__.Duck'>, <class '__main__.Flyer'>, <class '__main__.Swimmer'>, <class 'object'>)

1
# 导入整个模块
2
# import math 语句导入Python的内置math模块，该模块提供了许多数学函数和常量。
3
import math
4
print(f"圆周率 (math.pi): {math.pi}") # 通过模块名.属性名的方式访问模块中的常量。
5
print(f"16的平方根 (math.sqrt(16)): {math.sqrt(16)}") # 访问模块中的函数。
6

7
# 从模块中导入特定函数或变量
8
# from random import randint 语句只导入random模块中的randint函数，可以直接使用randint而不需要加random前缀。
9
from random import randint
10
random_number = randint(1, 10) # 生成一个1到10之间的随机整数（包含1和10）。
11
print(f"随机整数 (randint(1, 10)): {random_number}")
12

13
# 导入模块并使用别名
14
# import numpy as np 导入numpy模块并给它一个别名np，方便后续使用。
15
# import collections as coll
16
# from datetime import datetime as dt
17

18
# 导入模块中的所有内容（不推荐，可能导致命名冲突）
19
# from os import *
20
# print(getcwd()) # 可以直接使用getcwd函数

1
my_project/
2
├── main.py
3
└── my_package/
4
    ├── __init__.py
5
    ├── module_a.py
6
    └── sub_package/
7
        ├── __init__.py
8
        └── module_b.py

1
# 假设有上述包结构，并且在my_package/module_a.py中有如下内容：
2
# def func_a():
3
#     return "Hello from module_a!"
4

5
# 假设在my_package/sub_package/module_b.py中有如下内容：
6
# def func_b():
7
#     return "Hello from module_b!"
8

9
# 导入包中的模块
10
import my_package.module_a  # 导入my_package包中的module_a模块
11
print(my_package.module_a.func_a()) # 访问方式：包名.模块名.函数名
12

13
# 从包中导入特定模块
14
from my_package import module_a
15
print(module_a.func_a()) # 访问方式：模块名.函数名
16

17
# 从包中的模块导入特定函数
18
from my_package.module_a import func_a
19
print(func_a()) # 访问方式：函数名
20

21
# 导入子包中的模块
22
from my_package.sub_package import module_b
23
print(module_b.func_b()) # 访问方式：模块名.函数名
24

25
# 使用 __all__ 控制导入行为
26
# 在 __init__.py 中定义 __all__ = ['module1', 'module2'] 可以控制 from mypackage import * 的行为
27

28
# 相对导入（在包内部使用）
29
# from . import module1  # 导入同级模块
30
# from .. import parent_module  # 导入上级模块
31
# from .subpackage import module3  # 导入子包模块

1
# 定义一个简单的装饰器
2
# my_decorator 是一个装饰器函数，它接收一个函数 func 作为参数。
3
def my_decorator(func):
4
    """
5
    基础装饰器示例
6
    :param func: 被装饰的函数
7
    :return: 包装后的函数
8
    """
9
    # wrapper 是一个内部函数，它将替代原始函数 func 被调用。
10
    # *args 和 **kwargs 允许 wrapper 函数接受任意数量的位置参数和关键字参数，并将它们传递给原始函数 func。
11
    def wrapper(*args, **kwargs):
12
        print("Something is happening before the function is called.") # 在原始函数执行前打印一条消息。
13
        result = func(*args, **kwargs) # 调用原始函数 func，并将其返回值存储在 result 中。
14
        print("Something is happening after the function is called.")  # 在原始函数执行后打印一条消息。
15
        return result # 返回原始函数的执行结果。
16
    return wrapper # 装饰器返回 wrapper 函数。
17

18
# 使用 @ 语法糖应用装饰器
19
# @my_decorator 相当于 say_hello = my_decorator(say_hello)。
20
# 当 say_hello() 被调用时，实际上是调用了 my_decorator 返回的 wrapper 函数。
21
@my_decorator
22
def say_hello():
23
    """被装饰的函数示例"""
24
    print("Hello!")
25

26
# 调用被装饰的函数
27
say_hello()
28
# 输出：
29
# Something is happening before the function is called.
30
# Hello!
31
# Something is happening after the function is called.
32

33
print("\n-- 带有参数的函数装饰器 --")
34

35
@my_decorator
36
def greet(name):
37
    """带参数的被装饰函数"""
38
    print(f"Hello, {name}!")
39

40
greet("Alice")
41
# 输出：
42
# Something is happening before the function is called.
43
# Hello, Alice!
44
# Something is happening after the function is called.
45

46
print("\n-- 带有返回值的函数装饰器 --")
47

48
@my_decorator
49
def add(a, b):
50
    """带返回值的被装饰函数"""
51
    print(f"Adding {a} and {b}")
52
    return a + b
53

54
sum_result = add(5, 3)
55
print(f"Sum: {sum_result}")
56
# 输出：
57
# Something is happening before the function is called.
58
# Adding 5 and 3
59
# Something is happening after the function is called.
60
# Sum: 8
61

62
print("\n-- 带参数的装饰器 --")
63

64
def repeat(num_times):
65
    """
66
    带参数的装饰器工厂函数
67
    :param num_times: 重复执行的次数
68
    :return: 装饰器函数
69
    """
70
    def decorator_repeat(func):
71
        def wrapper(*args, **kwargs):
72
            for _ in range(num_times):
73
                result = func(*args, **kwargs)
74
            return result
75
        return wrapper
76
    return decorator_repeat
77

78
@repeat(num_times=3)
79
def greet_repeated(name):
80
    print(f"Hello, {name}!")
81

82
greet_repeated("Bob")
83
# 输出：
84
# Hello, Bob!
85
# Hello, Bob!
86
# Hello, Bob!
87

88
print("\n-- 类装饰器 --")
89

90
class CountCalls:
91
    """
92
    类装饰器示例，记录函数调用次数
93
    """
94
    def __init__(self, func):
95
        self.func = func
96
        self.num_calls = 0
97

98
    def __call__(self, *args, **kwargs):
99
        self.num_calls += 1
100
        print(f"Call {self.num_calls} of {self.func.__name__}")
101
        return self.func(*args, **kwargs)
102

103
@CountCalls
104
def say_hello_counted():
105
    print("Hello!")
106

107
say_hello_counted()
108
# 输出：
109
# Call 1 of say_hello_counted
110
# Hello!
111

112
say_hello_counted()
113
# 输出：
114
# Call 2 of say_hello_counted
115
# Hello!

1
# 1. 生成器函数示例
2
# my_generator 是一个生成器函数，因为它包含了 yield 关键字。
3
def my_generator():
4
    print("开始生成...")
5
    yield 1 # 第一次调用 next() 时，函数执行到这里，返回1，并暂停。
6
    print("继续生成...")
7
    yield 2 # 第二次调用 next() 时，从上次暂停的地方继续，执行到这里，返回2，并暂停。
8
    print("再次生成...")
9
    yield 3 # 第三次调用 next() 时，从上次暂停的地方继续，执行到这里，返回3，并暂停。
10
    print("生成结束。")
11

12
# 创建一个生成器对象
13
gen = my_generator()
14

15
# 使用 next() 函数获取生成器中的下一个值
16
print(f"第一次 next(): {next(gen)}")
17
print(f"第二次 next(): {next(gen)}")
18
print(f"第三次 next(): {next(gen)}")
19

20
# 当没有更多值可生成时，再次调用 next() 会引发 StopIteration 异常。
21
try:
22
    print(f"第四次 next(): {next(gen)}")
23
except StopIteration:
24
    print("生成器已耗尽，捕获到 StopIteration 异常。")
25

26
print("\n-- 使用 for 循环遍历生成器 --")
27
# 生成器是可迭代的，所以可以使用 for 循环来遍历它，for 循环会自动处理 StopIteration 异常。
28
for value in my_generator():
29
    print(f"通过 for 循环获取的值: {value}")
30

31
print("\n-- 2. 生成器表达式示例 --")
32
# 创建一个生成器表达式，类似于列表推导式，但使用圆括号。
33
# 它不会立即计算所有值，而是创建一个生成器对象。
34
gen_exp = (x * x for x in range(5))
35

36
print(f"生成器表达式对象: {gen_exp}") # 打印的是生成器对象本身，而不是值。
37

38
# 遍历生成器表达式获取值
39
print("遍历生成器表达式:")
40
for num in gen_exp:
41
    print(num)
42

43
print("\n-- 内存效率示例 --")
44
# 比较列表推导式和生成器表达式的内存使用
45
import sys
46

47
# 列表推导式会一次性生成所有元素并存储在内存中
48
my_list = [i for i in range(1000000)]
49
print(f"列表占用内存: {sys.getsizeof(my_list)} bytes")
50

51
# 生成器表达式只在需要时生成元素，内存占用很小
52
my_generator_exp = (i for i in range(1000000))
53
print(f"生成器占用内存: {sys.getsizeof(my_generator_exp)} bytes")

1
# 1. 自定义上下文管理器类
2
# FileManager 类实现了上下文管理器协议，用于安全地处理文件。
3
class FileManager:
4
    """
5
    一个自定义的文件上下文管理器，确保文件在使用后被正确关闭。
6
    """
7
    # 构造函数，初始化文件名为 filename。
8
    def __init__(self, filename, mode='r'):
9
        self.filename = filename
10
        self.mode = mode
11
        self.file = None
12

13
    # 进入上下文时调用此方法。
14
    def __enter__(self):
15
        print(f"进入上下文：尝试打开文件 {self.filename} (模式: {self.mode})")
16
        try:
17
            self.file = open(self.filename, self.mode) # 打开文件。
18
        except Exception as e:
19
            print(f"打开文件失败: {e}")
20
            # 重新抛出异常，或者根据需要处理
21
            raise
22
        return self.file # 返回文件对象，它将被赋给 with 语句中的变量（如 f）。
23

24
    # 退出上下文时调用此方法。
25
    # exc_type, exc_val, exc_tb 分别是异常类型、异常值和回溯信息。
26
    def __exit__(self, exc_type, exc_val, exc_tb):
27
        print(f"退出上下文：尝试关闭文件 {self.filename}")
28
        if self.file: # 确保文件对象存在。
29
            self.file.close() # 关闭文件，释放资源。
30
            print(f"文件 {self.filename} 已成功关闭。")
31

32
        # 如果 __exit__ 方法返回 True，则表示已经处理了异常，异常不会继续传播。
33
        # 如果返回 False 或 None，则异常会继续传播。
34
        if exc_type: # 如果发生了异常
35
            print(f"在上下文管理器中捕获到异常：{exc_type.__name__}: {exc_val}")
36
            # 可以选择在这里处理异常，例如记录日志，然后返回 True 阻止异常传播。
37
            # return True # 如果返回 True，异常将被抑制。
38
        return False # 默认返回 False，让异常正常传播。
39

40
# 使用自定义上下文管理器
41
file_path = 'my_test_file.txt'
42
print("\n--- 写入文件示例 ---")
43
with FileManager(file_path, 'w') as f: # 进入上下文，文件被打开。
44
    f.write('Hello, Python Context Manager!\n')
45
    f.write('This is a test line.\n')
46
print(f"文件 '{file_path}' 已写入并关闭。") # 退出上下文，文件被关闭。
47

48
print("\n--- 读取文件示例 ---")
49
with FileManager(file_path, 'r') as f: # 进入上下文，文件被打开。
50
    content = f.read()
51
    print(f"文件 '{file_path}' 内容:\n{content}")
52
print(f"文件 '{file_path}' 已读取并关闭。") # 退出上下文，文件被关闭。
53

54
print("\n--- 异常处理示例 ---")
55
try:
56
    with FileManager(file_path, 'r') as f: # 进入上下文
57
        print("尝试读取文件...")
58
        # 故意制造一个错误，例如尝试对文件对象进行不存在的操作
59
        f.non_existent_method()
60
except AttributeError as e:
61
    print(f"在外部捕获到异常: {e}")
62
print("程序继续执行。")
63

64
# 2. 使用 contextlib 模块的 @contextmanager 装饰器
65
# 对于简单的上下文管理器，可以使用 contextlib 模块的 @contextmanager 装饰器来简化实现。
66
# 它将一个生成器函数转换为上下文管理器。
67
from contextlib import contextmanager
68

69
@contextmanager
70
def open_file_context(path, mode):
71
    """
72
    使用 @contextmanager 装饰器实现的上下文管理器，用于文件操作。
73
    """
74
    file = None
75
    try:
76
        file = open(path, mode)
77
        yield file # yield 之前是 __enter__ 的逻辑，yield 之后是 __exit__ 的逻辑。
78
    finally:
79
        if file:
80
            file.close()
81
            print(f"文件 {path} 已通过 contextmanager 装饰器关闭。")
82

83
print("\n--- 使用 @contextmanager 装饰器示例 ---")
84
with open_file_context('another_test_file.txt', 'w') as f:
85
    f.write('Hello from contextmanager decorator!\n')
86
print("文件 'another_test_file.txt' 已写入并关闭 (通过装饰器)。")
87

88
print("\n--- 锁的上下文管理器示例 ---")
89
import threading
90

91
lock = threading.Lock()
92

93
# 使用 with 语句管理锁的获取和释放
94
with lock:
95
    print("锁已被获取，执行临界区代码...")
96
    # 临界区代码
97
    print("临界区代码执行完毕。")
98
# 离开 with 块时，锁会自动释放
99
print("锁已自动释放。")
100

101
print("\n--- 数据库连接的上下文管理器示例 (伪代码) ---")
102
# 假设有一个数据库连接类
103
class DatabaseConnection:
104
    def __init__(self, db_name):
105
        self.db_name = db_name
106
        self.connection = None
107

108
    def __enter__(self):
109
        print(f"连接到数据库: {self.db_name}")
110
        # 模拟数据库连接操作
111
        self.connection = f"Connection to {self.db_name}"
112
        return self.connection
113

114
    def __exit__(self, exc_type, exc_val, exc_tb):
115
        print(f"关闭数据库连接: {self.db_name}")
116
        # 模拟关闭数据库连接操作
117
        self.connection = None
118
        if exc_type:
119
            print(f"数据库操作中发生异常: {exc_val}")
120

121
with DatabaseConnection("my_database") as db:
122
    print(f"执行数据库查询: {db}")
123
    # 模拟执行查询
124
    # raise ValueError("模拟数据库错误") # 可以测试异常处理
125
print("数据库连接已关闭。")
126

127

128
**核心概念：**
129
*   **资源管理**: 上下文管理器的核心目的是确保资源（如文件句柄、网络连接、数据库连接、线程锁等）在使用后能够被正确地获取和释放，即使在代码执行过程中发生异常也能保证资源的清理，从而避免资源泄露。
130
*   **`with` 语句**: Python 提供的一种语法糖，用于简化资源管理。它确保在进入 `with` 块时资源被正确设置，并在退出 `with` 块时（无论是正常退出还是因异常退出）资源被正确清理。
131
*   **`__enter__` 方法**: 当 `with` 语句执行时，首先调用上下文管理器的 `__enter__` 方法。此方法负责资源的获取和初始化，并返回一个值（通常是资源本身），这个值会被赋给 `as` 关键字后面的变量。
132
*   **`__exit__` 方法**: 当 `with` 语句块执行完毕或发生异常时，`__exit__` 方法会被调用。它负责资源的清理和释放。该方法接收三个参数：`exc_type`（异常类型）、`exc_val`（异常值）和 `exc_tb`（回溯信息）。如果 `with` 块中没有发生异常，这三个参数都将是 `None`。
133
*   **异常安全**: `__exit__` 方法的强大之处在于其异常处理能力。即使 `with` 块内部发生未捕获的异常，`__exit__` 方法也总会被调用，从而保证资源得到清理。如果 `__exit__` 方法返回 `True`，则表示它已经处理了异常，该异常将不会向外传播；如果返回 `False` 或 `None`，则异常会继续传播。
134
*   **`contextlib` 模块**: Python 标准库中的 `contextlib` 模块提供了用于创建和使用上下文管理器的实用工具。其中最常用的是 `@contextmanager` 装饰器，它允许你使用简单的生成器函数来创建上下文管理器，而无需手动实现 `__enter__` 和 `__exit__` 方法，极大地简化了上下文管理器的编写。
135
*   **常见应用场景**: 文件操作（自动关闭文件）、数据库连接（自动关闭连接）、线程锁（自动释放锁）、网络连接、临时目录创建与清理等。
136

137
### 多线程和多进程
138
在Python中，多线程（Multithreading）和多进程（Multiprocessing）是实现并发（Concurrency）和并行（Parallelism）的两种主要方式。它们允许程序同时执行多个任务，从而提高程序的效率和响应速度。理解这两种机制的差异和适用场景对于编写高性能的Python程序至关重要。
139

140
#### 1. 多线程 (Multithreading)
141
线程是进程中的一个执行单元。一个进程可以包含多个线程，这些线程共享进程的内存空间。Python的 `threading` 模块提供了多线程支持。
142

143
**特点：**
144
*   **共享内存**: 线程共享进程的内存空间，因此数据共享方便，但需要注意线程安全问题，避免数据竞争。
145
*   **GIL (Global Interpreter Lock)**: Python的全局解释器锁（GIL）是一个互斥锁，它限制了在任何给定时刻只有一个线程可以执行Python字节码。这意味着Python多线程在CPU密集型任务上无法实现真正的并行计算（因为GIL会阻止多个线程同时执行Python代码），但在I/O密集型任务（如网络请求、文件读写）上仍然可以提高效率，因为在等待I/O时GIL会被释放，允许其他线程运行。
146
*   **开销小**: 线程的创建和销毁开销相对较小，上下文切换速度快。
147

148
```python
149
import threading # 导入Python的线程模块。
150
import time      # 导入时间模块，用于模拟耗时操作。
151
import os        # 导入os模块，用于获取进程ID。
152

153
# 定义一个共享资源
154
shared_data = 0
155
# 创建一个锁对象，用于保护共享资源
156
data_lock = threading.Lock()
157

158
# 定义一个线程函数，这将是每个线程执行的任务。
159
def thread_worker(name, duration):
160
    global shared_data
161
    pid = os.getpid() # 获取当前进程的ID。所有线程都属于同一个进程，所以PID会相同。
162
    thread_id = threading.get_ident() # 获取当前线程的唯一标识符。
163
    print(f"线程 {name} (PID: {pid}, Thread ID: {thread_id}) 开始工作，预计持续 {duration} 秒...")
164
    time.sleep(duration) # 模拟一个耗时的操作，例如网络请求或文件读写。
165

166
    # 使用锁来保护共享数据
167
    with data_lock:
168
        shared_data += 1
169
        print(f"线程 {name} 更新共享数据，当前值为: {shared_data}")
170

171
    print(f"线程 {name} (PID: {pid}, Thread ID: {thread_id}) 完成工作。")
172

173
print("\n--- 多线程示例 ---")
174
threads = [] # 用于存储所有线程对象的列表。
175
# 创建并启动多个线程。
176
for i in range(3):
177
    # threading.Thread 创建一个线程对象。
178
    # target 参数指定线程启动后要执行的函数（即 thread_worker）。
179
    # args 参数以元组形式传递给 target 函数的参数。这里传递了线程名称和模拟持续时间。
180
    t = threading.Thread(target=thread_worker, args=(f"Thread-{i}", 1))
181
    threads.append(t) # 将创建的线程对象添加到列表中。
182
    t.start() # 启动线程。调用 start() 方法后，线程会开始执行其 target 函数。
183

184
# 等待所有线程完成。
185
# t.join() 方法会阻塞当前线程（在这里是主线程），直到 t 线程执行完毕。
186
# 确保所有子线程都执行完成后，主线程才继续执行后续代码。
187
for t in threads:
188
    t.join()
189
print(f"所有线程任务完成。主线程继续执行。最终共享数据: {shared_data}")