Python系统课程 on UU 技术站

Python 基础第一课：你好世界

Fri, 01 May 2026 10:00:00 +0800

Python 基础第一课：你好世界

课程概述

欢迎来到 Python 编程系列课程的第一天！本节课我们将一起踏入 Python 编程的精彩世界。今天的学习内容包括：Python 语言简介、安装与运行环境、print() 函数的标准输出、代码注释的写法，以及现代 Python 中最常用的 f-string（格式化字符串字面量）。本课程内容基于 Python 3.11 编写，涵盖了 Python 3.11 中引入的最新语法特性与最佳实践。无论你是完全没有编程经验的初学者，还是从其他语言转来的开发者，本课程都将帮助你建立扎实的基础。

Python 由荷兰程序员 Guido van Rossum 于 1991 年首次发布，至今已有超过 30 年的发展历史。Python 的设计哲学强调代码的可读性和简洁性，其核心原则之一就是"Readability counts"（可读性很重要）。Python 使用缩进（indentation）来划分代码块，而不是像许多其他语言那样使用大括号 {} 或 begin/end 关键字。这种独特的设计使得 Python 代码在视觉上非常清晰，也强制开发者写出格式良好的代码。Python 的另一条著名的设计原则是"Simple is better than complex"（简单优于复杂），这使得 Python 成为最适合初学者入门的编程语言之一。

Python 3.11 的新特性

在学习基础知识之前，我们有必要了解一下 Python 3.11 相比之前版本带来了哪些重要改进。Python 3.11 于 2022 年 10 月正式发布，被誉为"Python 史上最快的版本"，其解释器启动速度比 Python 3.10 快了 10-15%，而平均执行速度更是提升了 25%。这些性能的提升主要来自于对 Python 虚拟机（Virtual Machine）的深度优化和重构。Python 3.11 还引入了更为精确的错误提示信息（Better Error Messages），当程序出现异常时，Python 3.11 会显示更多上下文信息，帮助开发者更快地定位和修复问题。

Python 第二课：变量、数据类型与类型转换

Fri, 01 May 2026 10:00:00 +0800

Python 第二课：变量、数据类型与类型转换

课程概述

本节课我们将深入学习 Python 编程中最核心的概念之一——变量（Variables）。变量是存储数据的容器，是所有程序的基础构建块。我们还将全面介绍 Python 的内置数据类型（Built-in Data Types），包括整数（int）、浮点数（float）、字符串（str）、布尔值（bool）、列表（list）、元组（tuple）、字典（dict）和集合（set）。此外，我们还将学习 Python 中的类型转换（Type Conversion）和 f-string 高级格式化技巧。本课程所有内容基于 Python 3.11 标准，涵盖了 Python 3.11 中关于类型系统的新特性和改进。Python 是一门动态类型语言（dynamically typed language），这意味着变量不需要显式声明类型，Python 解释器会根据赋给变量的值自动推断类型。但与此同时，Python 也是一门强类型语言（strongly typed language），不同类型的数据不能随意进行混合运算，必须通过显式的类型转换来实现。

变量详解

变量的基本概念

在 Python 中，变量是用于存储数据值的容器。你可以形象地将变量想象为一个贴有标签的盒子，盒子里存放着数据，而标签就是变量的名字。每次给变量赋值时，变量就会指向新的数据对象。

# 变量的基本赋值
name = "张三"       # 字符串变量
age = 25            # 整数变量
height = 1.75       # 浮点数变量
is_student = True   # 布尔变量

print(f"姓名：{name}")
print(f"年龄：{age}")
print(f"身高：{height} 米")
print(f"是否学生：{is_student}")

输出：

姓名：张三年龄：25 身高：1.75 米是否学生：True

变量的命名规则

Python 中的变量名必须遵守以下规则：

变量名只能包含字母、数字和下划线（_），不能包含空格或特殊字符。
变量名不能以数字开头。
变量名不能使用 Python 的保留关键字（keywords）。
变量名区分大小写（name 和 Name 是两个不同的变量）。

# 合法的变量名
my_variable = 10
_private_data = "secret"
camelCase = "驼峰命名"
CONSTANT_VALUE = 100  # 常量习惯用全大写

# Python 3.11 中还可以使用 Unicode 字符作为变量名
姓名 = "李四"
π = 3.14159

# 不合法的变量名（会导致 SyntaxError）
# 2nd_value = 20      # 不能以数字开头
# my-var = 30         # 不能使用连字符
# class = "高级"       # 不能使用保留关键字

Python 保留关键字

以下是 Python 3.11 中的所有保留关键字（35个），你不能将它们作为变量名使用：

Python 第三课：运算符、优先级与海象运算符

Fri, 01 May 2026 10:00:00 +0800

Python 第三课：运算符、优先级与海象运算符

课程概述

本节课我们将全面学习 Python 中的运算符（Operators）。运算符是用于执行各种运算操作的符号，Python 提供了丰富的运算符，包括算术运算符、比较运算符、逻辑运算符、位运算符、赋值运算符、身份运算符和成员运算符。我们还将深入探讨运算符的优先级（Operator Precedence），理解 Python 如何按照固定的规则计算包含多个运算符的表达式。此外，本课将重点介绍 Python 3.8 引入的海象运算符（Walrus Operator），即赋值表达式（Assignment Expression），它允许在表达式内部进行变量赋值，是一个非常强大且实用的特性。本课程所有内容基于 Python 3.11 编写，涵盖了 Python 3.11 中运算符语法的最新变化和最佳实践。

Python 的运算符系统设计得既强大又优雅。Python 支持运算符重载（Operator Overloading），这意味着同一个运算符在不同数据类型上可能有不同的行为。例如，+ 运算符可以用于数字相加、字符串拼接、列表合并等多种场景，这种设计被称为"魔法方法"（Dunder Methods）或运算符重载。理解运算符的工作原理对于编写高效、简洁的 Python 代码至关重要。

算术运算符

算术运算符是最常用的运算符类型，用于执行基本的数学运算。

基本算术运算符

# 加减乘除
a, b = 15, 4

print(f"a = {a}, b = {b}")
print(f"a + b = {a + b}")    # 19
print(f"a - b = {a - b}")    # 11
print(f"a * b = {a * b}")    # 60
print(f"a / b = {a / b:.4f}")    # 3.7500（浮点除法）

# 整除（向下取整）
print(f"a // b = {a // b}")   # 3

# 取余（模运算）
print(f"a % b = {a % b}")     # 3（15 = 4 * 3 + 3）

# 幂运算（指数运算）
print(f"a ** b = {a ** b}")   # 15^4 = 50625

# 负数运算
print(f"-a = {-a}")           # -15
print(f"+a = {+a}")           # 15（正号，一元运算符）

整数除法的特殊情况

# Python 3.11 中整数除法的行为
print(f"5 / 2 = {5 / 2}")          # 2.5（总是返回浮点数）
print(f"5 // 2 = {5 // 2}")        # 2（向下取整）
print(f"-5 // 2 = {-5 // 2}")      # -3（向下取整，负数向更小的整数取整）
print(f"5 // -2 = {5 // -2}")      # -3
print(f"-5 // -2 = {-5 // -2}")    # 2

# 模运算与整除的关系
print(f"5 % 2 = {5 % 2}")          # 1
print(f"-5 % 2 = {-5 % 2}")        # 1（Python 保证 a % b 的符号与 b 相同）
print(f"5 % -2 = {5 % -2}")        # -1
print(f"-5 % -2 = {-5 % -2}")      # -1

算术运算符的组合赋值

# 组合赋值运算符
x = 10
print(f"初始 x = {x}")

x += 5    # 等价于 x = x + 5
print(f"x += 5 后，x = {x}")

x -= 3    # 等价于 x = x - 3
print(f"x -= 3 后，x = {x}")

x *= 2    # 等价于 x = x * 2
print(f"x *= 2 后，x = {x}")

x /= 4    # 等价于 x = x / 4
print(f"x /= 4 后，x = {x}")

x //= 2   # 等价于 x = x // 2
print(f"x //= 2 后，x = {x}")

x **= 3   # 等价于 x = x ** 3
print(f"x **= 3 后，x = {x}")

x %= 10   # 等价于 x = x % 10
print(f"x %= 10 后，x = {x}")

算术运算符的字符串和序列操作

# 字符串的乘法运算
text = "Python "
print(f"text * 3 = '{text * 3}'")

# 列表的加法和乘法
list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(f"list1 + list2 = {list1 + list2}")   # 列表拼接
print(f"list1 * 2 = {list1 * 2}")           # 列表重复

# 元组的加法和乘法
t1 = (1, 2, 3)
t2 = (4, 5, 6)
print(f"t1 + t2 = {t1 + t2}")
print(f"t1 * 3 = {t1 * 3}")

比较运算符

比较运算符用于比较两个值的大小或相等性，返回布尔值（True 或 False）。

Python 第四课：条件语句与结构化模式匹配

Fri, 01 May 2026 10:00:00 +0800

Python 第四课：条件语句与结构化模式匹配

课程概述

本节课我们将学习 Python 中最重要的控制流工具之一——条件语句（Conditional Statements）。条件语句允许程序根据特定条件的真假来选择执行不同的代码路径。我们将详细学习 if、elif（else if 的缩写）和 else 语句的用法，以及条件表达式（三元运算符）的使用。此外，本课还将重点介绍 Python 3.10 引入的革命性新特性——match-case 结构化模式匹配（Structural Pattern Matching）。match-case 是 Python 历史上最重要的语法特性之一，它借鉴自函数式编程语言如 Haskell 和 OCaml，允许开发者以声明式的方式对值、结构和类型进行匹配和解析。本课程所有内容基于 Python 3.11 编写，涵盖了 Python 3.10 和 Python 3.11 中 match-case 的最新改进。

条件语句是编程的基础构建块，几乎所有程序都需要根据不同的条件做出不同的决策。在 Python 中，条件语句不仅支持简单的布尔判断，还支持复杂的表达式、多重条件判断，以及与循环、异常处理等控制流工具的组合使用。Python 的条件语句设计得非常优雅，使用缩进而不是大括号来划分代码块，这使得代码既简洁又具有良好的可读性。

if 语句基础

最基本的 if 语句

if 语句是最简单的条件语句，其基本语法如下：

# 基本语法
if 条件:
    条件为真时执行的代码

# 示例
age = 20

if age >= 18:
    print("你已经成年了！")
    print("可以观看这部电影")

print("程序继续执行...")

在 Python 中，if 语句后的条件表达式不需要使用括号（虽然技术上可以使用括号），条件的真假由 Python 的布尔规则决定。如果条件为真（True），则执行缩进后的代码块；如果为假（False），则跳过该代码块。

Python 第五课：逻辑运算符、短路求值与链式比较

Fri, 01 May 2026 10:00:00 +0800

Python 第五课：逻辑运算符、短路求值与链式比较

课程概述

本节课我们将深入探讨 Python 中三个最重要的逻辑运算符——and、or 和 not的工作原理，以及与它们密切相关的短路求值（Short-circuit Evaluation，也称为最小化求值）机制。我们还将详细学习 Python 特有的链式比较（Chained Comparisons）语法，这是 Python 语言中最优雅的特性之一。此外，本课还将涵盖 Python 中所有对象的布尔值规则、真值测试（Truth Value Testing），以及如何利用逻辑运算符的特性编写更加简洁、高效和安全的代码。本课程所有内容基于 Python 3.11 编写，涵盖了 Python 3.11 中关于布尔运算和比较操作的最新实现细节和优化。

逻辑运算符是所有编程语言的基石之一，它们构成了条件判断、循环控制和程序逻辑的核心。Python 的逻辑运算符相比其他语言有一些独特的设计：Python 使用英语单词 and、or、not 而不是 &&、||、! 这样的符号，这使得代码更接近自然语言，可读性更强。更重要的是，Python 的逻辑运算符遵循短路求值原则，这不仅提高了代码效率，还为编写安全的代码提供了独特的手段。

逻辑运算符基础

and（逻辑与）

and 运算符当且仅当两个操作数都为 True 时结果才为 True。在任何其他情况下，结果都是 False。

# and 运算符的真值表
print("=" * 50)
print("and 运算符真值表")
print("=" * 50)
print(f"True  and True  = {True and True}")
print(f"True  and False = {True and False}")
print(f"False and True  = {False and True}")
print(f"False and False = {False and False}")
print()

# and 运算符返回的是最后一个求值的表达式，而不是单纯的 True/False
print("and 返回的值：")
print(f"1 and 2  = {1 and 2}")     # 返回 2
print(f"1 and 0  = {1 and 0}")     # 返回 0
print(f"0 and 1  = {0 and 1}")     # 返回 0
print(f"'a' and 'b' = {'a' and 'b'}")  # 返回 'b'
print(f"'' and 'b' = {'' and 'b'}")    # 返回 ''

or（逻辑或）

or 运算符当任意一个操作数为 True 时结果就为 True。只有两个操作数都为 False 时结果才为 False。

Day6 while循环基础

Fri, 01 May 2026 10:00:00 +0800

来源：03_循环 hm_01~hm_07 + Python官方文档 + 网络资料整理

一、详细讲解

1.1 核心概念

while循环是Python编程中的重要知识点，在本课程的第6天我们将系统学习while循环、计数器控制、无限循环、以及while-else结构的完整知识体系。

while循环是一种条件驱动的循环结构，它会在条件为True时反复执行代码块，直到条件变为False为止。这种循环特别适用于迭代次数不确定的场景，比如等待用户输入、读取文件直到结束、或者进行未知次数的搜索操作。

与for循环不同，while循环需要程序员手动管理循环变量，确保循环最终能够终止，否则会产生无限循环。因此，使用while循环时需要格外注意循环条件的设置和计数器变量的更新。

1.2 while循环语法详解

1.2.1 基本语法结构

# while循环的基本语法
while 条件表达式:
    # 循环体 - 当条件为True时执行
    语句块

语法说明：

条件表达式是一个布尔值或可以转换为布尔值的表达式
当条件为True时，执行循环体中的语句
执行完循环体后，会再次评估条件表达式
这个过程重复进行，直到条件变为False

1.2.2 计数循环的实现

# 计数器初始化
counter = 0

# 条件判断
while counter < 5:
    # 循环体
    print(f"计数器当前值: {counter}")
    # 计数器更新 - 这是防止无限循环的关键
    counter += 1

print("循环结束")

运行结果：

计数器当前值: 0 计数器当前值: 1 计数器当前值: 2 计数器当前值: 3 计数器当前值: 4 循环结束

1.3 while循环的执行流程

┌─────────────────┐ │ 初始化计数器 │ └────────┬────────┘ │ ▼ ┌─────────────────┐ │ 评估条件表达式 │◄──────────┐ └────────┬────────┘ │ │ │ 条件为True? │ │ │ ┌────┴────┐ │ │ │ │ Yes No │ │ │ │ ▼ ▼ │ ┌─────────┐ ┌─────────┐ │ │ 执行循环体│ │ 退出循环 │ │ │ 更新计数器│ └─────────┘ │ └────┬────┘ │ │ │ └────────────────────────┘

1.4 实用示例

1.4.1 1~100累加求和

# 计算1到100的累加和
i = 1        # 初始化计数器，起始值为1
total = 0    # 初始化求和变量

while i <= 100:      # 条件：i小于等于100
    total += i       # 累加当前i的值
    i += 1            # 计数器递增

print(f"1+2+3+...+100 = {total}")  # 输出: 5050

算法分析：

Day7 循环控制break与continue

Fri, 01 May 2026 10:00:00 +0800

来源：03_循环 hm_06~hm_07 + Python官方文档 + 网络资料整理

一、详细讲解

1.1 核心概念

循环控制break与continue是Python编程中用于精确控制循环执行流程的两个重要关键字。在本课程的第7天，我们将深入学习break语句、continue语句、以及它们与循环else子句的配合使用。

在实际的程序开发中，我们经常需要在循环执行过程中根据某些条件提前退出循环（break）或者跳过本次循环的剩余代码（continue）。这两个语句为我们提供了这种精细控制的能力，使得我们可以编写出更加灵活和高效的循环逻辑。

理解break和continue的区别以及它们对循环else子句的影响，是掌握Python循环控制的关键。

1.2 break语句详解

1.2.1 break的基本语法

break语句用于立即终止当前所在的最内层循环，并将控制流转移到循环体之外的下一条语句。

# break语句的语法位置
for 变量 in 序列:
    if 条件:
        break    # 跳出当前循环
    循环体

# while循环中的break
while 条件:
    if 条件:
        break    # 跳出当前循环
    循环体

1.2.2 break在for循环中的使用

# 示例1：查找第一个符合条件的元素
fruits = ["apple", "banana", "cherry", "date", "elderberry"]

for fruit in fruits:
    if len(fruit) > 5:
        print(f"第一个长度大于5的水果: {fruit}")
        break
# 输出: 第一个长度大于5的水果: banana

# 示例2：遍历列表，找到目标后立即停止
numbers = [1, 3, 5, 7, 9, 11, 13, 15]
target = 11

for num in numbers:
    if num == target:
        print(f"找到目标: {target}")
        break
    print(f"检查: {num}")

print("搜索完成")

运行结果：

Day8 for循环与range

Fri, 01 May 2026 10:00:00 +0800

来源：03_循环 hm_01~hm_05 + Python官方文档 + 网络资料整理

一、详细讲解

1.1 核心概念

for循环与range是Python编程中最常用和重要的迭代结构。在本课程的第8天，我们将系统学习for循环的基本语法、range函数的使用、enumerate和zip等内置函数的配合使用，以及序列解包在for循环中的应用。

for循环是一种基于迭代器的循环结构，它依次从可迭代对象中取出每个元素进行处理。与while循环不同，for循环不需要手动管理计数器，Python解释器会自动处理迭代的细节。这使得for循环更加简洁、安全，是处理已知序列或需要遍历元素场景的首选。

1.2 for循环语法详解

1.2.1 基本语法结构

# for循环的基本语法
for 变量 in 可迭代对象:
    # 循环体
    语句块

1.2.2 遍历各种序列类型

# 遍历字符串
print("=== 遍历字符串 ===")
for char in "Python":
    print(char)

# 遍历列表
print("\n=== 遍历列表 ===")
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# 遍历元组
print("\n=== 遍历元组 ===")
coordinates = (10, 20, 30)
for coord in coordinates:
    print(f"坐标: {coord}")

# 遍历字典（默认遍历键）
print("\n=== 遍历字典 ===")
person = {"name": "Alice", "age": 30, "city": "Beijing"}
for key in person:
    print(f"{key}: {person[key]}")

运行结果：

Day9 嵌套循环与图案打印

Fri, 01 May 2026 10:00:00 +0800

来源：03_循环 hm_10~hm_12 + 网络资料整理

一、详细讲解

1.1 核心概念

嵌套循环与图案打印是Python编程中用于处理二维结构数据的重要知识点。在本课程的第9天，我们将学习循环嵌套的基础概念、九九乘法表的实现、以及各种图案的打印技巧。

嵌套循环是指一个循环内部包含另一个循环的结构。外层循环控制行或外层维度的变化，内层循环控制列或内层维度的变化。通过合理使用嵌套循环，我们可以打印各种规则或不规则的图案，处理矩阵数据，以及解决需要多层迭代的问题。

1.2 嵌套循环基础

1.2.1 嵌套循环的执行原理

# 嵌套循环的基本结构
for i in range(外层次数):    # 外层循环
    for j in range(内层次数):  # 内层循环
        # 内层循环体
    # 外层循环体（内层循环结束后执行）

1.2.2 执行次数计算

# 嵌套循环总执行次数 = 外层次数 × 内层次数
print("=== 嵌套循环执行次数 ===")
outer_times = 3
inner_times = 4
total_executions = outer_times * inner_times
print(f"外层循环 {outer_times} 次 × 内层循环 {inner_times} 次 = 总执行 {total_executions} 次")

# 演示
count = 0
for i in range(3):
    for j in range(4):
        count += 1
        print(f"i={i}, j={j}", end="  ")
    print()  # 内层循环结束后换行
print(f"\n实际执行次数: {count}")

输出：

Day10 函数定义与调用

Fri, 01 May 2026 10:00:00 +0800

来源：04_函数 hm_01~hm_06 + Python官方文档 + 网络资料整理

一、详细讲解

1.1 核心概念

函数定义与调用是Python编程中的核心知识点，也是代码模块化、复用和组织的基石。在本课程的第10天，我们将系统学习函数的基本概念、定义语法、参数传递、返回值处理，以及文档字符串的编写。

函数是一段组织好的、可重复使用的、用来实现单一或相关联功能的代码块。在Python中，函数不仅是一种代码复用的手段，更是实现面向过程编程和模块化设计的基础。通过函数，我们可以将复杂的问题分解为多个小问题，使程序结构更加清晰、易于维护。

1.2 函数基础

1.2.1 为什么要使用函数

# 不使用函数：代码重复
print("=== 计算圆的面积 ===")
radius = 5
area = 3.14159 * radius ** 2
print(f"半径{radius}的圆面积: {area}")

radius = 10
area = 3.14159 * radius ** 2
print(f"半径{radius}的圆面积: {area}")

radius = 15
area = 3.14159 * radius ** 2
print(f"半径{radius}的圆面积: {area}")

# 使用函数：代码复用
def calculate_circle_area(radius):
    """计算圆的面积"""
    area = 3.14159 * radius ** 2
    return area

print("\n=== 使用函数 ===")
for r in [5, 10, 15]:
    print(f"半径{r}的圆面积: {calculate_circle_area(r)}")

1.2.2 函数定义的基本语法

# 函数定义的基本结构
def 函数名(参数1, 参数2, ...):
    """文档字符串（可选）"""
    # 函数体
    return 返回值  # 可选

1.3 函数的定义与调用

1.3.1 无参函数

# 无参函数：不需要输入参数
def greet():
    """简单的问候函数"""
    print("Hello, World!")
    print("Welcome to Python!")

# 调用函数
greet()

# 可以多次调用
greet()
greet()

1.3.2 有参函数

# 有参函数：需要输入参数
def greet_person(name):
    """向指定的人打招呼"""
    print(f"Hello, {name}!")
    print(f"Welcome, {name}!")

# 调用函数，传入参数
greet_person("Alice")
print()
greet_person("Bob")

1.3.3 多参数函数

# 多个参数的函数
def calculate_rectangle(length, width):
    """计算矩形的面积和周长"""
    area = length * width
    perimeter = 2 * (length + width)
    return area, perimeter

# 调用函数
result = calculate_rectangle(5, 3)
print(f"面积: {result[0]}, 周长: {result[1]}")

# 使用解包
area, perimeter = calculate_rectangle(5, 3)
print(f"面积: {area}")
print(f"周长: {perimeter}")

1.4 参数详解

1.4.1 位置参数

# 位置参数：按顺序传递
def introduce(name, age, city):
    """自我介绍"""
    print(f"我叫{name}，今年{age}岁，来自{city}。")

# 调用时按位置传递
introduce("张三", 25, "北京")
introduce("李四", 30, "上海")
introduce("王五", 28, "广州")

# 位置参数必须传递，且顺序不能错
# introduce("赵六")  # 错误：缺少参数
# introduce(25, "钱七", "深圳")  # 错误：类型不匹配

1.4.2 关键字参数

# 关键字参数：按名称传递
def introduce(name, age, city):
    """自我介绍"""
    print(f"我叫{name}，今年{age}岁，来自{city}。")

# 使用关键字参数，顺序可以改变
introduce(age=30, name="张三", city="北京")

# 混合使用：位置参数必须在关键字参数前面
introduce("李四", city="上海", age=28)

1.4.3 默认参数

# 默认参数：给参数设置默认值
def greet(name, greeting="Hello"):
    """带默认参数的问候函数"""
    print(f"{greeting}, {name}!")

# 调用时可以不指定默认参数
greet("Alice")  # Hello, Alice!
greet("Bob", "Hi")  # Hi, Bob!

# 默认参数必须在位置参数后面
# def greet(greeting="Hello", name):  # 错误！
# 默认参数可以是有副作用的可变对象（需要注意）

1.4.4 默认参数的最佳实践

# 避免使用可变对象作为默认参数
# 错误示例
def add_to_list(item, target_list=[]):  # 危险！
    target_list.append(item)
    return target_list

print(add_to_list(1))  # [1]
print(add_to_list(2))  # [1, 2] - 不是 [2]！

# 正确示例
def add_to_list(item, target_list=None):  # 正确
    if target_list is None:
        target_list = []
    target_list.append(item)
    return target_list

print(add_to_list(1))  # [1]
print(add_to_list(2))  # [2]

1.5 返回值详解

1.5.1 无返回值函数

# 没有return语句的函数，默认返回None
def print_sum(a, b):
    """打印两个数的和，不返回值"""
    print(f"{a} + {b} = {a + b}")

result = print_sum(3, 5)
print(f"返回值: {result}")  # None

# 使用return单独返回None
def check_positive(n):
    """检查是否是正数"""
    if n > 0:
        return True
    else:
        return None

print(check_positive(5))   # True
print(check_positive(-1))  # None

1.5.2 单返回值

# 返回单个值
def square(n):
    """返回n的平方"""
    return n ** 2

result = square(5)
print(f"5的平方: {result}")  # 25

1.5.3 多返回值

# 返回多个值（实际是返回元组）
def calculate(a, b):
    """返回和、差、积"""
    return a + b, a - b, a * b

# 使用元组接收
result = calculate(10, 3)
print(f"结果类型: {type(result)}")
print(f"结果值: {result}")

# 使用解包接收
sum_val, diff, prod = calculate(10, 3)
print(f"和: {sum_val}, 差: {diff}, 积: {prod}")

1.5.4 提前返回

# 使用多个return语句
def absolute_value(n):
    """返回绝对值"""
    if n < 0:
        return -n
    return n

print(absolute_value(-5))  # 5
print(absolute_value(5))   # 5

# 早期返回（Early Return）模式
def process_data(data):
    """处理数据"""
    # 验证输入
    if not data:
        return None
    
    # 主处理逻辑
    result = []
    for item in data:
        if is_valid(item):
            result.append(process(item))
    
    return result

1.6 文档字符串（Docstring）

1.6.1 文档字符串的作用

文档字符串是紧跟在函数定义之后的一个字符串，用于说明函数的功能、参数、返回值、使用示例等信息。

Python 第十一天：函数返回值与 None

Fri, 01 May 2026 10:00:00 +0800

Python 第十一天：函数返回值与 None

1. 函数返回值基础

什么是返回值

返回值是函数执行完毕后向调用者提供的结果数据。在 Python 中，使用 return 语句来指定函数的返回值。当一个函数没有 return 语句，或者 return 语句后面没有任何表达式时，函数默认返回 None。

# 最简单的返回值示例
def greet():
    return "你好，世界！"

result = greet()
print(result)  # 输出: 你好，世界！

返回值的基本类型

Python 函数可以返回各种类型的数据，包括但不限于：

字符串：返回文本信息
数字：返回计算结果
布尔值：返回判断结果
列表/元组/字典：返回集合数据
对象：返回自定义类的实例
None：表示空或无返回值

# 返回不同类型的示例
def return_types_demo():
    return "Hello"           # 字符串
    return 42                 # 数字
    return [1, 2, 3]          # 列表
    return {"name": "Alice"}  # 字典
    return True               # 布尔值
    return None               # None 值

注意：函数一旦执行到 return 语句就会立即结束，后面的代码不会执行。上面的例子中，只有第一个 return 会生效。

Python 第十二天：*args、**kwargs 与默认参数

Fri, 01 May 2026 10:00:00 +0800

Python 第十二天：*args、**kwargs 与默认参数

1. 函数参数基础回顾

位置参数

位置参数是最基本的参数类型，必须按照定义顺序传递：

def greet(name, age, city):
    """三个位置参数"""
    return f"我是{name}，今年{age}岁，来自{city}"

# 必须按顺序传递
print(greet("张三", 25, "北京"))
# 输出: 我是张三，今年25岁，来自北京

# 错误示例：顺序不对
print(greet("北京", "张三", 25))  # 结果可能不符合预期

关键字参数

使用参数名传递，可以不按顺序：

def greet(name, age, city):
    return f"我是{name}，今年{age}岁，来自{city}"

# 使用关键字参数，顺序可以任意
print(greet(age=25, city="北京", name="张三"))
# 输出: 我是张三，今年25岁，来自北京

# 混合使用：位置参数在前，关键字参数在后
print(greet("张三", city="北京", age=25))
# 输出: 我是张三，今年25岁，来自北京

2. 默认参数详解

基本语法

在函数定义时给参数指定默认值，使其成为可选参数：

def greet(name, greeting="你好", punctuation="!"):
    """默认参数示例"""
    return f"{greeting}，{name}{punctuation}"

# 使用默认 greeting 和 punctuation
print(greet("张三"))              # 你好，张三!
print(greet("李四", "早上好"))    # 早上好，李四!
print(greet("王五", "晚上好", "。")) # 晚上好，王五。

默认参数的重要性

# 没有默认参数：每次都要提供所有参数
def connect_db(host, port, user, password, database):
    """连接数据库（无默认参数）"""
    return f"连接 {host}:{port}/{database} 用户={user}"

# 必须提供所有参数
conn1 = connect_db("localhost", 3306, "root", "123456", "mydb")

# 有默认参数：简化调用
def connect_db_default(host, port=3306, user="root", password="", database="test"):
    """连接数据库（带默认参数）"""
    return f"连接 {host}:{port}/{database} 用户={user}"

# 使用默认值
conn2 = connect_db_default("localhost")
conn3 = connect_db_default("localhost", user="admin")
conn4 = connect_db_default("localhost", database="production")

默认参数的常见陷阱

陷阱1：使用可变对象作为默认值

这是 Python 中最常见的错误之一！

Day17 字典遍历与嵌套

Fri, 01 May 2026 10:00:00 +0800

来源：黑马程序员Python基础课程 + Python 3.11官方文档 + 网络资料整理

一、详细讲解

1.1 字典遍历三种方式

Python 字典提供三个核心视图对象，用于遍历键、值或键值对：

person = {"name": "小明", "age": 18, "city": "北京", "job": "工程师"}

# 遍历所有键（最常用）
for key in person:
    print(f"{key}: {person[key]}")

# 遍历所有键（显式）
for key in person.keys():
    print(key)

# 遍历所有值
for value in person.values():
    print(value)

# 遍历键值对（最推荐）
for key, value in person.items():
    print(f"{key}: {value}")

输出：

name: 小明 age: 18 city: 北京 job: 工程师小明 18 北京工程师 name: 小明 age: 18 city: 北京 job: 工程师

1.2 items() 视图对象的高级用法

items() 返回的是视图对象，不是列表，具有内存高效的特点：

Day18 字符串全解

Fri, 01 May 2026 10:00:00 +0800

来源：黑马程序员Python基础课程 + Python 3.11官方文档 + 网络资料整理

一、详细讲解

1.1 字符串基本特性

Python 字符串是不可变序列（Immutable Sequence），所有修改操作都会返回新字符串：

s = "Hello"
# s[0] = "J"  # TypeError: 'str' object does not support item assignment

# 正确做法：创建新字符串
s2 = "J" + s[1:]
print(s2)  # Jello

# 字符串长度
print(len("Hello"))  # 5

1.2 字符串索引与切片

s = "Python是最流行的编程语言"

# 正向索引（从0开始）
print(s[0])   # P
print(s[7])   # 是

# 反向索引（从-1开始）
print(s[-1])  # 言
print(s[-4])  # 编

# 切片 s[start:end:step]
print(s[0:6])     # Python（不含end）
print(s[7:10])     # 是最流
print(s[:6])       # Python（省略start=0）
print(s[7:])       # 是最流行的编程语言（省略end=len）
print(s[::2])      # Pto无流编言言（步长2）
print(s[::-1])     # 言语言程编的行流最是（逆序）

1.3 常用字符串方法

查找与替换：

Day19 集合操作全解

Fri, 01 May 2026 10:00:00 +0800

来源：黑马程序员Python基础课程 + Python 3.11官方文档 + 网络资料整理

一、详细讲解

1.1 集合的基本特性

Python 集合（Set）是无序、不重复的可变容器：

# 创建集合
s1 = {1, 2, 3, 4, 5}
s2 = set([1, 2, 2, 3, 3, 4, 4])  # set()从列表创建，自动去重
print(s2)  # {1, 2, 3, 4}

# 创建空集合（不能用{}，那是dict）
empty = set()
print(type(empty))  # <class 'set'>

# 集合特点：无序 + 不重复
s = {3, 1, 4, 1, 5, 9, 2, 6}
print(s)  # {1, 2, 3, 4, 5, 6, 9}（顺序不确定）

# 自动去重
nums = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique = set(nums)
print(unique)  # {1, 2, 3, 4}

1.2 集合的增删操作

s = {1, 2, 3}

# 添加元素
s.add(4)          # 添加一个元素
print(s)           # {1, 2, 3, 4}
s.add(2)           # 已存在的元素，集合不变
print(s)           # {1, 2, 3, 4}

s.update([5, 6, 7])  # 批量添加（传入可迭代对象）
print(s)              # {1, 2, 3, 4, 5, 6, 7}

# 删除元素
s.remove(3)          # 删除指定元素，不存在则抛KeyError
print(s)              # {1, 2, 4, 5, 6, 7}

s.discard(10)        # 删除指定元素，不存在也不报错
print(s)              # {1, 2, 4, 5, 6, 7}

popped = s.pop()     # 随机删除并返回一个元素
print(popped)        # 1（通常删除第一个）
print(s)              # {2, 4, 5, 6, 7}

s.clear()            # 清空集合
print(s)              # set()

1.3 集合运算（重点）

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

# 交集：两个集合都有的元素
print(A & B)               # {4, 5}
print(A.intersection(B))    # {4, 5}

# 并集：所有元素（去重）
print(A | B)               # {1, 2, 3, 4, 5, 6, 7, 8}
print(A.union(B))           # {1, 2, 3, 4, 5, 6, 7, 8}

# 差集：A有B没有的元素
print(A - B)               # {1, 2, 3}
print(A.difference(B))      # {1, 2, 3}

# 对称差集：A和B互相没有的元素
print(A ^ B)               # {1, 2, 3, 6, 7, 8}
print(A.symmetric_difference(B))  # {1, 2, 3, 6, 7, 8}

# 子集与超集
X = {1, 2, 3}
Y = {1, 2, 3, 4, 5}
print(X < Y)   # True（X是Y的真子集）
print(Y > X)   # True（Y是X的真超集）
print(X <= Y)  # True（X是Y的子集，包含相等情况）
print(Y >= X)  # True（Y是X的超集）

# 判断是否相交（无交集返回True）
print(A.isdisjoint(B))  # False（有交集4,5）
C = {10, 20}
print(A.isdisjoint(C))  # True（无交集）

1.4 集合的成员测试

s = {1, 2, 3, 4, 5}

print(3 in s)     # True
print(10 in s)    # False
print(3 not in s) # False

# 集合成员测试比列表快很多（O(1) vs O(n)）

1.5 集合推导式

# 基本集合推导式
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = {x for x in nums if x % 2 == 0}
print(evens)  # {2, 4, 6, 8, 10}

# 带计算的集合推导式
squares = {x**2 for x in range(1, 6)}
print(squares)  # {1, 4, 9, 16, 25}

# 实际应用：从字符串提取不重复字符
text = "hello world"
unique_chars = {c for c in text if c.isalpha()}
print(unique_chars)  # {'h', 'e', 'l', 'o', 'w', 'r', 'd'}

1.6 frozenset（不可变集合）

frozenset 是不可变版本，创建后不能修改：

Day20 综合练习：名片管理系统

Fri, 01 May 2026 10:00:00 +0800

来源：黑马程序员Python基础课程 + 原创项目设计

一、详细讲解

1.1 项目概述

名片管理系统是一个经典的 Python 入门综合项目，涉及：

字典存储名片数据
无限循环 while True 实现菜单
函数封装增删改查操作
if-elif 多重分支处理用户选择

1.2 数据结构设计

# 名片数据结构（字典）
card = {
    "name": "张三",
    "phone": "13800138000",
    "email": "zhangsan@example.com",
    "company": "百度公司"
}

# 名片列表（所有名片存储在列表中）
cards_list = [
    {"name": "张三", "phone": "13800138000", "email": "zhangsan@example.com", "company": "百度"},
    {"name": "李四", "phone": "13900139000", "email": "lisi@example.com", "company": "阿里"},
]

1.3 核心函数实现

# ========== 1. 显示菜单 ==========
def show_menu():
    print("=" * 50)
    print("  名片管理系统 V1.0")
    print("  1. 新增名片")
    print("  2. 显示全部")
    print("  3. 搜索名片")
    print("  4. 修改名片")
    print("  5. 删除名片")
    print("  0. 退出系统")
    print("=" * 50)

# ========== 2. 新增名片 ==========
def add_card(cards):
    name = input("请输入姓名：")
    phone = input("请输入电话：")
    email = input("请输入邮箱：")
    company = input("请输入公司：")
    
    card = {
        "name": name,
        "phone": phone,
        "email": email,
        "company": company
    }
    cards.append(card)
    print(f"√ 名片「{name}」添加成功！")

# ========== 3. 显示全部名片 ==========
def show_all(cards):
    if len(cards) == 0:
        print("当前没有任何名片，请先添加！")
        return
    
    print(f"共找到 {len(cards)} 张名片：")
    print("-" * 60)
    for card in cards:
        print(f"姓名：{card['name']}")
        print(f"电话：{card['phone']}")
        print(f"邮箱：{card['email']}")
        print(f"公司：{card['company']}")
        print("-" * 60)

# ========== 4. 搜索名片 ==========
def search_card(cards):
    if len(cards) == 0:
        print("当前没有任何名片！")
        return None
    
    search_name = input("请输入要搜索的姓名：")
    results = [c for c in cards if c["name"] == search_name]
    
    if results:
        print(f"找到 {len(results)} 张名片：")
        for card in results:
            print(f"  姓名：{card['name']}，电话：{card['phone']}")
        return results
    else:
        print(f"没有找到名为「{search_name}」的名片")
        return None

# ========== 5. 修改名片 ==========
def modify_card(cards):
    if len(cards) == 0:
        print("当前没有任何名片！")
        return
    
    search_name = input("请输入要修改的姓名：")
    for card in cards:
        if card["name"] == search_name:
            print("请输入新的信息（直接回车保留原值）：")
            new_phone = input(f"电话[{card['phone']}]：")
            new_email = input(f"邮箱[{card['email']}]：")
            new_company = input(f"公司[{card['company']}]：")
            
            if new_phone:
                card["phone"] = new_phone
            if new_email:
                card["email"] = new_email
            if new_company:
                card["company"] = new_company
            
            print(f"√ 名片「{search_name}」修改成功！")
            return
    
    print(f"没有找到名为「{search_name}」的名片")

# ========== 6. 删除名片 ==========
def delete_card(cards):
    if len(cards) == 0:
        print("当前没有任何名片！")
        return
    
    search_name = input("请输入要删除的姓名：")
    for i, card in enumerate(cards):
        if card["name"] == search_name:
            confirm = input(f"确定删除名片「{search_name}」？(y/n)：")
            if confirm.lower() == "y":
                cards.pop(i)
                print(f"√ 名片「{search_name}」已删除！")
            return
    
    print(f"没有找到名为「{search_name}」的名片")

1.4 主程序循环

def main():
    cards = []  # 存储所有名片的列表
    
    while True:
        show_menu()
        user_choice = input("请选择操作（0-5）：")
        
        if user_choice == "1":
            add_card(cards)
        elif user_choice == "2":
            show_all(cards)
        elif user_choice == "3":
            search_card(cards)
        elif user_choice == "4":
            modify_card(cards)
        elif user_choice == "5":
            delete_card(cards)
        elif user_choice == "0":
            print("感谢使用，再见！")
            break
        else:
            print("无效选择，请输入 0-5 之间的数字")

if __name__ == "__main__":
    main()

1.5 运行效果示例

================================================== 名片管理系统 V1.0 1. 新增名片 2. 显示全部 3. 搜索名片 4. 修改名片 5. 删除名片 0. 退出系统 ================================================== 请选择操作（0-5）：1 请输入姓名：张三请输入电话：13800138000 请输入邮箱：zhangsan@example.com 请输入公司：百度公司 √ 名片「张三」添加成功！请选择操作（0-5）：2 共找到 1 张名片： ------------------------------------------------------------ 姓名：张三电话：13800138000 邮箱：zhangsan@example.com 公司：百度公司 ------------------------------------------------------------ 请选择操作（0-5）：0 感谢使用，再见！

1.6 模块化改进（进阶）

将代码拆分为多个文件：

Day 21 - 面向对象编程：类与对象基础

Fri, 01 May 2026 10:00:00 +0800

Day 21 - 面向对象编程：类与对象基础

什么是面向对象编程（OOP）？

面向对象编程（Object-Oriented Programming，简称OOP）是一种程序设计范式，它使用"对象"来描述现实世界中的事物。Python 是一种多范式编程语言，完全支持面向对象编程。在 Python 中，一切皆为对象——数字、字符串、列表、字典，甚至函数都是对象。理解类和对象的概念是掌握 Python 编程的关键一步。

面向对象编程的核心思想是将数据和操作数据的方法封装在一起，形成一个独立的单元——类（Class）。类就像是一张蓝图或者模板，定义了某种类型对象所具有的属性（特征）和方法（行为）。而对象（Object）则是根据类这张蓝图创建出来的具体实例。打个比方，“汽车"是一个类，而一辆具体的红色 BMW 汽车就是一个对象；“学生"是一个类，而"张三"这位具体的学生就是一个对象。

类的定义与语法

在 Python 中，使用 class 关键字来定义一个类。类名通常采用 PascalCase 命名法（每个单词首字母大写），例如 Student、Person、BankAccount 等。类的定义体包含属性（数据）和方法（函数）。让我们从一个最简单的例子开始：

class Person:
    """一个人类的简单表示"""
    
    def say_hello(self):
        """打招呼的方法"""
        print("你好！")

# 创建对象
p = Person()
p.say_hello()

在这个例子中，我们定义了一个名为 Person 的类。类中有一个 say_hello 方法。注意方法定义中的第一个参数 self，这是面向对象编程中最重要的概念之一。

self 参数详解

self 参数是类方法（除了类方法和静态方法之外）的第一个参数，它指向对象本身。当我们调用 p.say_hello() 时，Python 内部会将这个调用转换为 Person.say_hello(p)，也就是说，self 接收到了调用该方法的对象 p 本身。

self 这个名字并不是关键字，你可以用其他名字来代替它，但按照 Python 的惯例，始终使用 self 是一个良好的编程习惯。使用其他名字虽然不会报错，但会让你的代码难以被其他程序员理解，因为 Python 社区已经形成了使用 self 的共识。

self 的主要作用体现在以下几个方面：

访问对象的属性（实例变量）
调用对象的其他方法
在方法之间传递对象本身
判断两个对象是否是同一个对象（使用 is 运算符）

class Dog:
    def __init__(self, name, age):
        self.name = name      # 将name存储在当前对象中
        self.age = age        # 将age存储在当前对象中
    
    def bark(self):
        print(f"{self.name} 在叫：汪汪汪！")
    
    def info(self):
        print(f"名字：{self.name}，年龄：{self.age}岁")

dog1 = Dog("旺财", 3)
dog2 = Dog("小白", 5)

dog1.bark()    # 输出：旺财 在叫：汪汪汪！
dog2.bark()    # 输出：小白 在叫：汪汪汪！

dog1.info()    # 输出：名字：旺财，年龄：3岁
dog2.info()    # 输出：名字：小白，年龄：5岁

类与对象的关系

类和对象之间的关系是"模板"与"实例"的关系。类定义了创建对象的蓝图，描述了一类对象共同的特征和行为；对象是类的具体实现，每个对象都有自己独立的属性值，但共享类中定义的方法。

Day 22 - 构造函数 init 详解

Fri, 01 May 2026 10:00:00 +0800

Day 22 - 构造函数 init 详解

什么是 init 方法？

__init__ 是 Python 类中的一个特殊方法，也被称为"构造函数"或"初始化方法"。当我们使用 类名() 创建对象时，__init__ 方法会被自动调用。它的主要作用是对新创建的对象进行初始化设置，比如给对象的属性赋初值、建立对象之间的关联关系等。

__init__ 这个名字来源于 “initialize”（初始化）这个词。在 Python 中，以双下划线 __ 开头和结尾的方法称为"魔术方法"（Magic Methods）或"特殊方法"（Special Methods），它们有特殊的用途，会在特定情况下被 Python 自动调用。

init 的基本语法

class 类名:
    def __init__(self, 参数1, 参数2, ...):
        # 初始化代码
        self.属性1 = 参数1
        self.属性2 = 参数2

__init__ 方法的第一个参数永远是 self（指向正在创建的对象），后面的参数是你在创建对象时需要传入的值。

class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
        print(f"新对象创建：{self.name}")

# 创建对象时传入参数
person1 = Person("张三", 25, "男")
person2 = Person("李四", 30, "女")

print(f"{person1.name} 是 {person1.age} 岁的 {person1.gender}生")
print(f"{person2.name} 是 {person2.age} 岁的 {person2.gender}生")

输出：

Day 23 - 字符串表示 str 与 del

Fri, 01 May 2026 10:00:00 +0800

Day 23 - 字符串表示 str 与 del

对象的字符串表示概述

在 Python 中，每个对象都可以被转换为字符串。当你使用 print() 函数打印一个对象，或者在某些需要字符串的地方使用对象时，Python 需要将对象转换为字符串。默认的实现通常显示的是类似 <__main__.ClassName object at 0x7f8a9c123456> 这样的信息，虽然包含了对象的内存地址，但对于人类阅读来说并不友好。

为了提供更有意义的字符串表示，Python 提供了两个魔术方法：__str__ 和 __repr__。通过在类中重写这两个方法，你可以自定义对象的字符串表现形式，使输出更加友好和有意义。

这两个方法的区别在于：__str__ 是面向用户的字符串表示，用于给终端用户查看；而 __repr__ 是面向开发者的字符串表示，应该尽可能提供详细的信息，以便开发者调试。

str 方法详解

__str__ 方法在以下情况会被调用：

使用 print() 函数打印对象时
使用 str() 函数转换对象时
在需要字符串的地方使用 f-string 格式化对象时
用户友好的错误消息中

__str__ 方法应该返回一个字符串。如果没有定义 __str__，Python 会使用 __repr__ 作为备选。

class Book:
    def __init__(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages
    
    def __str__(self):
        """返回用户友好的字符串表示"""
        return f"《{self.title}》 - {self.author}"

book = Book("活着", "余华", 500)

print(book)           # 《活着》 - 余华
print(str(book))      # 《活着》 - 余华
print(f"我正在读{book}")  # 我正在读《活着》 - 余华

repr 方法详解

__repr__ 方法在以下情况会被调用：

Day 24 - 私有属性与封装

Fri, 01 May 2026 10:00:00 +0800

Day 24 - 私有属性与封装

什么是封装？

封装（Encapsulation）是面向对象编程的三大基本特性之一（另外两个是继承和多态）。封装的核心理念是将数据（属性）和操作数据的方法（行为）打包在一起，对外隐藏内部实现细节，只暴露必要的接口。这样做的好处是：提高代码的可维护性、降低模块间的耦合度、保护数据不被意外或恶意修改。

在 Python 中，封装并不是像 Java 或 C++ 那样通过严格的访问控制关键字（public、private、protected）来实现的。Python 采用了一种"约定优于配置"的方式，通过命名规范来标识成员的访问级别。

Python 的命名规范

Python 中以下划线的前缀和数量来表示属性的访问级别：

_name（单下划线）：受保护的属性，按照约定，外部代码不应该直接访问，但 Python 不会阻止这种访问。这是一种"软私有"的约定。
__name（双下划线开头）：名称改写（Name Mangling）机制，会将属性名改写为 _类名__name 的形式。这提供了一定程度的"硬私有"保护，但通过改写后的名称仍然可以访问。
__name__（双下划线开头和结尾）：这是魔术方法/属性的保留命名空间，如 __init__、__str__、__dict__ 等。普通属性不应该使用这种命名方式。

class BankAccount:
    def __init__(self, account_id, initial_balance):
        self.account_id = account_id      # 公开属性
        self._transactions = []            # 受保护属性（约定不直接访问）
        self.__balance = initial_balance   # 私有属性（名称改写）
    
    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("存款金额必须为正数")
        self.__balance += amount
        self._transactions.append(("存款", amount))
    
    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("取款金额必须为正数")
        if amount > self.__balance:
            raise ValueError("余额不足")
        self.__balance -= amount
        self._transactions.append(("取款", -amount))
    
    def get_balance(self):
        """获取余额（受控访问）"""
        return self.__balance
    
    def get_transactions(self):
        """获取交易记录"""
        return self._transactions.copy()

# 创建账户
account = BankAccount("ACC001", 1000)

# 公开属性可以直接访问
print(f"账号：{account.account_id}")

# 受保护属性（可以访问，但不推荐）
print(f"交易记录：{account._transactions}")

# 私有属性（访问会报错）
# print(account.__balance)  # AttributeError

# 但可以通过改写后的名称访问（不推荐）
print(account._BankAccount__balance)  # 1000

# 通过方法访问私有属性（推荐方式）
print(f"余额：{account.get_balance()}")

# 存款和取款
account.deposit(500)
account.withdraw(200)
print(f"交易记录：{account.get_transactions()}")
# [('存款', 500), ('取款', -200)]

为什么要使用私有属性？

假设我们有一个 BankAccount 类，余额是一个私有属性。如果允许外部代码直接访问和修改余额，那么可能会出现以下问题：

Day 25 - 继承与 super 函数

Fri, 01 May 2026 10:00:00 +0800

Day 25 - 继承与 super 函数

什么是继承？

继承（Inheritance）是面向对象编程中最核心的概念之一，它允许我们定义一个类（子类）作为另一个类（父类或基类）的扩展。子类继承了父类的属性和方法，同时可以添加自己特有的属性和方法，或者重写（override）父类的方法来改变行为。

继承的主要好处是代码复用：公共的属性和方法只需要在父类中定义一次，子类自动拥有这些特性。此外，继承还体现了"是一个"（is-a）的关系，例如：狗是一种动物，学生是一个人，苹果是一种水果。

在 Python 中，使用圆括号 () 在类名后指定父类来实现继承。

继承的基本语法

class 父类:
    # 父类的定义

class 子类(父类):
    # 子类的定义

class Animal:
    """动物基类"""
    
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def speak(self):
        raise NotImplementedError("子类必须实现 speak 方法")
    
    def info(self):
        print(f"名字：{self.name}，年龄：{self.age}")

class Dog(Animal):
    """狗类，继承自动物类"""
    
    def speak(self):
        print(f"{self.name} 在叫：汪汪汪！")

class Cat(Animal):
    """猫类，继承自动物类"""
    
    def speak(self):
        print(f"{self.name} 在叫：喵喵喵！")

# 创建子类对象
dog = Dog("旺财", 3)
cat = Cat("小白", 2)

dog.info()   # 名字：旺财，年龄：3
dog.speak()  # 旺财 在叫：汪汪汪！

cat.info()   # 名字：小白，年龄：2
cat.speak()  # 小白 在叫：喵喵喵！

单继承与多继承

Python 支持两种继承方式：单继承（一个类只继承一个父类）和多继承（一个类继承多个父类）。虽然多继承功能强大，但容易导致代码复杂度增加和菱形继承问题，因此在使用时需要特别小心。

Day 26 - 多重继承与方法解析顺序（MRO）

Fri, 01 May 2026 10:00:00 +0800

Day 26 - 多重继承与方法解析顺序（MRO）

多重继承的概念

多重继承（Multiple Inheritance）是指一个类可以直接继承多个父类。Python 完整地支持多重继承，这使得类可以从多个不相关的类中继承功能。然而，多重继承也带来了复杂性，特别是在方法解析顺序（Method Resolution Order，MRO）和菱形继承问题上。

class Flyer:
    def fly(self):
        print("我可以飞翔")

class Swimmer:
    def swim(self):
        print("我可以游泳")

class Walker:
    def walk(self):
        print("我可以行走")

class Duck(Flyer, Swimmer, Walker):
    """鸭子继承三种能力"""
    pass

duck = Duck()
duck.fly()   # 我可以飞翔
duck.swim()  # 我可以游泳
duck.walk()  # 我可以行走

菱形继承问题

菱形继承（Diamond Inheritance）是指两个类继承自同一个基类，然后又有一个类同时继承这两个类，形成菱形结构。这种结构在多重继承中容易引发问题：如果基类有实例属性或方法，在子类中应该如何访问？

class A:
    def greet(self):
        print("A 的 greet 方法")

class B(A):
    def greet(self):
        print("B 的 greet 方法")
        super().greet()

class C(A):
    def greet(self):
        print("C 的 greet 方法")
        super().greet()

class D(B, C):
    def greet(self):
        print("D 的 greet 方法")
        super().greet()

# 创建 D 的实例并调用 greet
d = D()
d.greet()

输出：

Day 27 - 多态与鸭子类型

Fri, 01 May 2026 10:00:00 +0800

Day 27 - 多态与鸭子类型

什么是多态？

多态（Polymorphism）是面向对象编程的三大基本特性之一，意思是"多种形态"。在 Python 中，多态指的是同一种操作（如调用同一个方法）在不同类型的对象上会产生不同的行为。

多态的核心思想是：关注对象的"行为"而非"类型"。当我们调用一个对象的方法时，不需要关心这个对象是什么类型的具体类，只需要知道它支持这个方法即可。这大大增强了代码的灵活性和可扩展性。

class Dog:
    def speak(self):
        return "汪汪汪"

class Cat:
    def speak(self):
        return "喵喵喵"

class Duck:
    def speak(self):
        return "嘎嘎嘎"

# 多态：同一个方法调用，不同对象产生不同行为
animals = [Dog(), Cat(), Duck()]

for animal in animals:
    print(f"{animal.__class__.__name__} 说：{animal.speak()}")

# 输出：
# Dog 说：汪汪汪
# Cat 说：喵喵喵
# Duck 说：嘎嘎嘎

Python 中的多态实现

Python 是动态类型语言，天生支持多态。在静态类型语言（如 Java、C++）中，多态需要通过继承和接口来实现。但在 Python 中，任何定义了 speak() 方法的对象都可以被调用，而不需要继承关系。

class People:
    def speak(self):
        return "你好！"

class Bird:
    def speak(self):
        return "叽叽喳喳"

def make_speak(obj):
    """多态函数：接收任何有 speak 方法的对象"""
    print(obj.speak())

person = People()
bird = Bird()

make_speak(person)  # 你好！
make_speak(bird)    # 叽叽喳喳

抽象基类与多态

虽然 Python 不强制使用抽象基类，但抽象基类（ABC）提供了一种方式来定义接口规范，确保子类实现了必要的方法。这在大型项目中很有用。

Day 28 - @classmethod 装饰器详解

Fri, 01 May 2026 10:00:00 +0800

Day 28 - @classmethod 装饰器详解

什么是类方法？

类方法（Class Method）是绑定到类而不是实例的方法。类方法使用 @classmethod 装饰器装饰，第一个参数是类本身（通常命名为 cls），而不是实例（self）。

类方法的主要用途包括：

工厂方法：创建类的实例的不同方式
访问或修改类属性
不依赖于特定实例的功能

class MyClass:
    class_attr = "类属性值"
    
    def __init__(self, value):
        self.instance_attr = value
    
    @classmethod
    def class_method(cls):
        """类方法"""
        print(f"类方法被调用")
        print(f"cls 是：{cls}")
        print(f"cls.class_attr = {cls.class_attr}")
        return cls("通过类方法创建")  # 可以使用 cls 创建实例

# 通过类调用类方法
MyClass.class_method()
# 类方法被调用
# cls 是：<class '__main__.MyClass'>
# cls.class_attr = 类属性值

# 通过实例调用类方法（不推荐，但可以）
obj = MyClass("实例值")
obj.class_method()  # cls 仍然是 MyClass，不是 obj 的类

实例方法 vs 类方法 vs 静态方法

Python 中有三种类型的方法：

Day 29 - @staticmethod 装饰器与单例模式

Fri, 01 May 2026 10:00:00 +0800

Day 29 - @staticmethod 装饰器与单例模式

什么是静态方法？

静态方法（Static Method）是使用 @staticmethod 装饰器装饰的方法。它不需要 self 或 cls 参数，可以像普通函数一样定义，但在类内部定义，属于类的命名空间。

静态方法的主要用途：

将一些与类相关的功能封装在类内部，使代码更组织化
不需要访问类属性或实例属性的功能
可以被子类继承（但不能通过 super() 调用父类的静态方法）

class MathUtils:
    """数学工具类"""
    
    @staticmethod
    def add(a, b):
        """加法"""
        return a + b
    
    @staticmethod
    def multiply(a, b):
        """乘法"""
        return a * b
    
    @staticmethod
    def is_prime(n):
        """判断素数"""
        if n < 2:
            return False
        for i in range(2, int(n**0.5) + 1):
            if n % i == 0:
                return False
        return True

# 调用静态方法
print(MathUtils.add(3, 5))      # 8
print(MathUtils.multiply(4, 7)) # 28
print(MathUtils.is_prime(17))   # True
print(MathUtils.is_prime(15))   # False

# 也可以通过实例调用
utils = MathUtils()
print(utils.add(2, 3))  # 5

三种方法的对比

class Example:
    class_attr = "类属性"
    
    def __init__(self, value):
        self.value = value
    
    def instance_method(self):
        """实例方法：需要 self"""
        return f"实例方法，value={self.value}"
    
    @classmethod
    def class_method(cls):
        """类方法：需要 cls"""
        return f"类方法，class_attr={cls.class_attr}"
    
    @staticmethod
    def static_method():
        """静态方法：不需要 self 或 cls"""
        return "静态方法，不依赖类或实例"

# 对比
obj = Example("test")

# 实例方法：需要实例调用
print(obj.instance_method())
# Example.instance_method(obj)  # 需要显式传递实例

# 类方法：类或实例都可以调用
print(Example.class_method())
print(obj.class_method())

# 静态方法：类或实例都可以调用
print(Example.static_method())
print(obj.static_method())

静态方法与命名空间

静态方法的一个重要作用是将相关的函数组织在类的命名空间中，避免污染全局命名空间。

Day 30 - 异常处理：try-except-else-finally

Fri, 01 May 2026 10:00:00 +0800

Day 30 - 异常处理：try-except-else-finally

什么是异常？

异常（Exception）是 Python 程序在运行过程中发生的错误。当异常发生时，程序会停止执行，并创建一个异常对象。如果异常没有被捕获和处理，程序会打印一个回溯（traceback）并终止。

Python 的异常处理机制允许我们捕获异常并自定义处理方式，而不是让程序直接崩溃。这对于编写健壮的程序至关重要。

# 常见的异常类型
print(10 / 0)  # ZeroDivisionError: division by zero
print(int("abc"))  # ValueError: invalid literal for int()
print([1, 2, 3][10])  # IndexError: list index out of range
print({}["key"])  # KeyError: 'key'

try-except 基本语法

try:
    # 可能发生异常的代码
    result = 10 / 0
except ZeroDivisionError:
    # 处理 ZeroDivisionError 异常
    print("不能除以零！")

完整的异常处理结构

try:
    # 可能发生异常的代码
    num = int(input("请输入一个数字："))
    result = 10 / num
except ValueError:
    # 处理值错误（输入不是数字）
    print("输入无效，请输入数字！")
except ZeroDivisionError:
    # 处理除以零错误
    print("不能除以零！")
else:
    # 只有在没有异常时才会执行
    print(f"结果：{result}")
finally:
    # 无论是否有异常都会执行
    print("程序结束")

except 的多种写法

捕获特定异常

try:
    value = int("abc")
except ValueError:
    print("ValueError 被捕获")

try:
    lst = [1, 2, 3]
    value = lst[10]
except IndexError:
    print("IndexError 被捕获")

捕获多种异常（方式1）

try:
    value = int("abc")
except (ValueError, TypeError):
    print("ValueError 或 TypeError 被捕获")

捕获多种异常（方式2）

try:
    value = int("abc")
except ValueError:
    print("ValueError 被捕获")
except TypeError:
    print("TypeError 被捕获")

获取异常信息

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"异常信息：{e}")
    print(f"异常类型：{type(e).__name__}")

完整的 try-except-else-finally

def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("错误：除数不能为零")
        return None
    except TypeError:
        print("错误：参数类型错误")
        return None
    else:
        # 只有在没有异常时执行
        print(f"计算成功：{a} / {b} = {result}")
        return result
    finally:
        # 无论是否有异常都会执行
        print("divide 函数执行完毕")

print("测试 10 / 2：")
divide(10, 2)

print("\n测试 10 / 0：")
divide(10, 0)

print("\n测试 '10' / 2：")
divide('10', 2)

异常对象的属性和方法

异常对象是 Python 的内置异常类的实例，具有以下常用属性：

Day 31 - raise 语句与自定义异常

Fri, 01 May 2026 10:00:00 +0800

Day 31 - raise 语句与自定义异常

raise 语句基础

raise 语句用于显式地抛出异常。在 Python 中，你可以抛出任何继承自 BaseException 的对象，但通常我们应该抛出 Exception 的子类。

# 基本语法
raise Exception("错误信息")

# 重新抛出当前捕获的异常
try:
    raise ValueError("原始错误")
except ValueError:
    print("处理异常")
    raise  # 重新抛出

# 使用 raise from 链接异常
try:
    raise ValueError("原始错误")
except ValueError as e:
    raise RuntimeError("新错误") from e

常见的内置异常

Python 提供了一系列内置异常，按层次结构组织：

BaseException ├── SystemExit ├── KeyboardInterrupt ├── GeneratorExit └── Exception ├── StopIteration ├── ArithmeticError │ ├── FloatingPointError │ ├── OverflowError │ └── ZeroDivisionError ├── LookupError │ ├── IndexError │ └── KeyError ├── OSError (IOError) │ ├── FileNotFoundError │ ├── PermissionError │ └── TimeoutError ├── TypeError ├── ValueError ├── RuntimeError └── ...

# 触发各种内置异常
print(10 / 0)  # ZeroDivisionError
print(int("abc"))  # ValueError
print([1,2][10])  # IndexError
print({}["key"])  # KeyError
open("nonexistent.txt")  # FileNotFoundError

自定义异常类

自定义异常应该继承自 Exception 或其子类。通常，自定义异常类比较简单，只需要定义构造函数和异常消息。

Day32 - 模块与导入系统详解

Fri, 01 May 2026 10:00:00 +0800

Day32 - 模块与导入系统详解

详细讲解

1. 模块基础概念

模块（Module） 是 Python 中组织代码的基本单位。一个 .py 文件就是一个模块，模块中可以包含函数、类、变量以及可执行代码。

# mymodule.py
def greet(name):
    return f"你好，{name}！"

class Calculator:
    def add(self, a, b):
        return a + b
    
    def subtract(self, a, b):
        return a - b

PI = 3.14159

2. import 语句详解

2.1 基本导入

import mymodule

# 调用函数
result = mymodule.greet("张三")
print(result)  # 输出: 你好，张三！

# 使用类
calc = mymodule.Calculator()
print(calc.add(10, 5))  # 输出: 15

# 访问变量
print(mymodule.PI)  # 输出: 3.14159

2.2 from…import 语句

# 导入特定成员
from mymodule import greet, PI

# 直接使用（无需模块名前缀）
print(greet("李四"))  # 输出: 你好，李四！
print(PI)  # 输出: 3.14159

# 导入所有成员（不推荐）
from mymodule import *

2.3 as 别名使用

import mymodule as m

# 使用简短别名
print(m.greet("王五"))  # 输出: 你好，王五！

# 部分导入起别名
from mymodule import Calculator as Calc, PI as PI_VALUE

calc = Calc()
print(calc.add(100, 200))  # 输出: 300

3. sys.path 与模块搜索路径

Python 导入模块时，会按照以下顺序搜索：

Day33 - 包与命名空间详解

Fri, 01 May 2026 10:00:00 +0800

Day33 - 包与命名空间详解

详细讲解

1. 包的基本概念

包（Package） 是包含 __init__.py 文件的目录，用于组织多个模块。包可以嵌套，形成层次结构。

mypackage/ ├── __init__.py # 包初始化文件（必需） ├── module1.py ├── module2.py └── subpackage/ ├── __init__.py └── module3.py

2. `init.py` 文件详解

2.1 作用

__init__.py 是 Python 包的标识文件，有以下作用：

标识该目录是一个包
在包被导入时执行初始化代码
控制包的导出内容

# mypackage/__init__.py

# 1. 初始化代码（包导入时执行）
print("mypackage 已被导入")

# 2. 定义包的版本
__version__ = "1.0.0"

# 3. 简化包的导入接口
from .module1 import Class1
from .module2 import function1

# 4. 定义 __all__ 控制 from package import *
__all__ = ['Class1', 'function1', 'subpackage']

2.2 包的多级初始化

# mypackage/subpackage/__init__.py
"""子包初始化"""

print("mypackage.subpackage 已加载")

# 从模块导入到包级别
from .module3 import ServiceClass

__all__ = ['ServiceClass']

2.3 `init.py` 常见用法

# 方式1：全部导入（不推荐）
import mypackage.module1
import mypackage.module2

# 方式2：使用 __init__.py 暴露接口
# 在 __init__.py 中：
# from .module1 import useful_function
# 使用时：
from mypackage import useful_function

# 方式3：导入所有公开接口
# 在 __init__.py 中设置 __all__

3. `name` 属性详解

__name__ 是 Python 的内置变量，其值取决于代码的执行方式。

Day34 - 文件读写与JSON处理

Fri, 01 May 2026 10:00:00 +0800

Day34 - 文件读写与JSON处理

详细讲解

1. 文件打开与关闭

1.1 基本语法

# 传统方式 - 需要手动关闭
file = open('example.txt', 'r', encoding='utf-8')
content = file.read()
file.close()  # 忘记关闭会导致资源泄漏

# 推荐方式 - 使用 with 语句（自动关闭）
with open('example.txt', 'r', encoding='utf-8') as file:
    content = file.read()
    # 文件在 with 块结束后自动关闭

1.2 文件打开模式

模式	说明	文件指针位置	如果文件存在	如果文件不存在
`'r'`	读取（默认）	开头	读取	报错
`'w'`	写入	开头	覆盖	创建
`'x'`	创建并写入	开头	报错	创建
`'a'`	追加	末尾	追加	创建
`'r+'`	读取+写入	开头	读取	报错
`'w+'`	读取+写入	开头	覆盖	创建
`'a+'`	读取+追加	末尾	追加	创建

1.3 编码问题

# 推荐使用 UTF-8 编码
with open('file.txt', 'r', encoding='utf-8') as f:
    content = f.read()

# 处理不同编码
with open('file.txt', 'r', encoding='gbk') as f:
    content = f.read()

# 遇到编码错误时的处理
with open('file.txt', 'r', encoding='utf-8', errors='ignore') as f:
    content = f.read()

with open('file.txt', 'r', encoding='utf-8', errors='replace') as f:
    content = f.read()  # 替换为 ?

2. 文件读取操作

2.1 读取全部内容

# 读取整个文件
with open('example.txt', 'r', encoding='utf-8') as f:
    content = f.read()  # 返回字符串

# 读取前 N 个字符
with open('example.txt', 'r', encoding='utf-8') as f:
    content = f.read(100)  # 读取前100个字符

2.2 按行读取

# 读取单行（包含换行符）
with open('example.txt', 'r', encoding='utf-8') as f:
    line1 = f.readline()
    line2 = f.readline()

# 读取所有行（返回列表）
with open('example.txt', 'r', encoding='utf-8') as f:
    lines = f.readlines()

# 直接迭代文件对象（推荐，内存高效）
with open('example.txt', 'r', encoding='utf-8') as f:
    for line in f:
        print(line.strip())  # strip() 去除换行符

2.3 逐字符读取

with open('example.txt', 'r', encoding='utf-8') as f:
    while True:
        char = f.read(1)  # 读取单个字符
        if not char:
            break
        print(char, end='')

3. 文件写入操作

3.1 写入字符串

# 写入单行（不自动添加换行符）
with open('output.txt', 'w', encoding='utf-8') as f:
    f.write('第一行')
    f.write('第二行')  # 不会换行

# 写入多行
with open('output.txt', 'w', encoding='utf-8') as f:
    lines = ['第一行\n', '第二行\n', '第三行\n']
    f.writelines(lines)

# 使用 print 函数写入（自动添加换行符）
with open('output.txt', 'w', encoding='utf-8') as f:
    print('第一行', file=f)
    print('第二行', file=f)

3.2 追加模式

# 在文件末尾追加
with open('log.txt', 'a', encoding='utf-8') as f:
    f.write('新的日志条目\n')

3.3 二进制文件

# 写入二进制数据
with open('data.bin', 'wb') as f:
    f.write(b'\x00\x01\x02\x03')

# 读取二进制数据
with open('data.bin', 'rb') as f:
    data = f.read()
    print(data)  # b'\x00\x01\x02\x03'

4. 文件指针操作

with open('example.txt', 'r', encoding='utf-8') as f:
    # 获取文件指针位置
    print(f.tell())  # 0
    
    # 读取一些内容
    content = f.read(10)
    print(f.tell())  # 10
    
    # 移动文件指针
    f.seek(0)        # 移到开头
    print(f.tell())  # 0
    
    f.seek(5)        # 移到第5个字节
    print(f.tell())  # 5
    
    # 从末尾往前移动（需要使用二进制模式）
    # f.seek(-10, 2)  # 从文件末尾往前10字节

5. JSON 数据处理

5.1 JSON 模块概述

JSON（JavaScript Object Notation）是一种轻量级数据交换格式。

Day35 - 文件处理综合 (CSV/shutil/os/pathlib)

Fri, 01 May 2026 10:00:00 +0800

Day35 - 文件处理综合 (CSV/shutil/os/pathlib)

详细讲解

1. CSV 文件处理

1.1 CSV 模块基础

import csv

# 准备数据
data = [
    ['姓名', '年龄', '城市'],
    ['张三', '25', '北京'],
    ['李四', '30', '上海'],
    ['王五', '28', '广州']
]

# 写入 CSV 文件
with open('output.csv', 'w', newline='', encoding='utf-8') as f:
    writer = csv.writer(f)
    writer.writerows(data)  # 写入多行

# 读取 CSV 文件
with open('output.csv', 'r', encoding='utf-8') as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

注意：newline='' 在写入 CSV 时必须使用，否则在 Windows 上可能导致行距加倍。

1.2 字典方式操作 CSV

import csv

# 写入字典格式
fieldnames = ['name', 'age', 'city']
data = [
    {'name': '张三', 'age': 25, 'city': '北京'},
    {'name': '李四', 'age': 30, 'city': '上海'}
]

with open('dict_data.csv', 'w', newline='', encoding='utf-8') as f:
    writer = csv.DictWriter(f, fieldnames=fieldnames)
    writer.writeheader()  # 写入表头
    writer.writerows(data)

# 读取字典格式
with open('dict_data.csv', 'r', encoding='utf-8') as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(f"{row['name']} - {row['age']} - {row['city']}")

1.3 CSV 高级选项

import csv

# 自定义分隔符
with open('tab_data.tsv', 'w', newline='', encoding='utf-8') as f:
    writer = csv.writer(f, delimiter='\t')
    writer.writerows(data)

# 引用处理
with open('quoted.csv', 'w', newline='', encoding='utf-8') as f:
    writer = csv.writer(f, quoting=csv.QUOTE_ALL)  # 所有字段加引号
    writer.writerows(data)

# quoting 选项：
# QUOTE_ALL      - 所有字段加引号
# QUOTE_MINIMAL  - 特殊字符字段加引号（默认）
# QUOTE_NONNUMERIC - 非数字字段加引号
# QUOTE_NONE     - 不加引号

1.4 处理大 CSV 文件

import csv

# 使用生成器处理大文件
def read_csv_chunked(filepath, chunk_size=1000):
    """分块读取大 CSV 文件"""
    with open(filepath, 'r', encoding='utf-8') as f:
        reader = csv.reader(f)
        header = next(reader)  # 读取表头
        
        chunk = []
        for row in reader:
            chunk.append(row)
            if len(chunk) >= chunk_size:
                yield header, chunk
                chunk = []
        
        if chunk:  # 处理最后一块
            yield header, chunk

# 使用
for header, chunk in read_csv_chunked('large_file.csv'):
    print(f"处理 {len(chunk)} 条记录")
    # 处理每块数据

2. shutil 模块 - 高级文件操作

2.1 复制操作

import shutil

# 复制文件
shutil.copy('source.txt', 'dest.txt')      # 复制文件内容
shutil.copy2('source.txt', 'dest.txt')    # 复制文件并保留元数据

# 复制目录
shutil.copytree('source_dir', 'dest_dir')  # 递归复制整个目录

# 复制到文件夹
shutil.copy('file.txt', 'target_dir/')     # 目标可以是目录

2.2 移动和重命名

import shutil

# 移动文件
shutil.move('source.txt', 'dest.txt')

# 移动目录
shutil.move('source_dir', 'dest_dir')

# 重命名（同一目录下移动即重命名）
shutil.move('old_name.txt', 'new_name.txt')

2.3 删除操作

import shutil

# 删除目录（必须是空目录）
import os
os.rmdir('empty_dir')

# 删除目录树（递归删除）
shutil.rmtree('dir_to_remove')

# 安全删除（移动到回收站，可安装 send2trash 库）
# pip install send2trash
try:
    import send2trash
    send2trash.send2trash('file_to_delete.txt')
except ImportError:
    print("请安装: pip install send2trash")

2.4 归档和压缩

import shutil

# 创建归档（zip, tar, gztar, bztar, xztar）
shutil.make_archive('backup', 'zip', 'directory_to_backup')

# 解压归档
shutil.unpack_archive('backup.zip', 'extract_here')

# 列出支持的格式
print(shutil.get_archive_formats())
print(shutil.get_unpack_formats())

2.5 其他有用功能

import shutil

# 获取磁盘使用情况
total, used, free = shutil.disk_usage('/')
print(f"总容量: {total // (2**30)} GB")
print(f"已使用: {used // (2**30)} GB")
print(f"剩余: {free // (2**30)} GB")

# 复制权限（仅 Unix）
# shutil.copystat(src, dst)

# 获取临时目录
print(shutil.gettempdir())

# 命令行工具包装
# shutil.which('python')  # 查找命令路径

3. os 模块 - 系统交互

3.1 路径操作

import os

# 获取当前工作目录
print(os.getcwd())

# 改变当前目录
os.chdir('/path/to/directory')

# 返回绝对路径
os.path.abspath('relative/path')

# 判断路径类型
os.path.isfile('file.txt')     # 是否为文件
os.path.isdir('directory')     # 是否为目录
os.path.islink('link')         # 是否为符号链接
os.path.exists('path')         # 路径是否存在

# 路径连接
path = os.path.join('dir', 'subdir', 'file.txt')
# 输出: dir/subdir/file.txt (Unix) 或 dir\subdir\file.txt (Windows)

# 分割路径
dirname, basename = os.path.split('/path/to/file.txt')
# dirname: /path/to, basename: file.txt

# 分割扩展名
name, ext = os.path.splitext('file.txt')
# name: file, ext: .txt

3.2 目录操作

import os

# 创建目录
os.mkdir('new_dir')           # 创建单级目录（父目录必须存在）
os.makedirs('path/to/new/dir')  # 递归创建目录

# 列出目录内容
os.listdir('.')               # 返回列表

# 遍历目录树
for dirpath, dirnames, filenames in os.walk('.'):
    print(f"目录: {dirpath}")
    print(f"子目录: {dirnames}")
    print(f"文件: {filenames}")

# 删除
os.remove('file.txt')         # 删除文件
os.rmdir('empty_dir')         # 删除空目录

3.3 文件信息

import os
import datetime

# 获取文件大小（字节）
size = os.path.getsize('file.txt')

# 获取文件修改时间
mtime = os.path.getmtime('file.txt')
print(datetime.datetime.fromtimestamp(mtime))

# 获取创建时间
ctime = os.path.getctime('file.txt')

# 获取文件详细信息
stat_info = os.stat('file.txt')
print(f"大小: {stat_info.st_size} 字节")
print(f"修改: {datetime.datetime.fromtimestamp(stat_info.st_mtime)}")

3.4 环境变量

import os

# 获取环境变量
home = os.environ.get('HOME')           # Unix
# home = os.environ.get('USERPROFILE') # Windows
path = os.environ.get('PATH', '')

# 设置环境变量
os.environ['MY_VAR'] = 'value'

# 获取所有环境变量
for key, value in os.environ.items():
    print(f"{key}={value}")

4. pathlib 模块 - 面向对象路径操作

Python 3.4+ 推荐使用 pathlib，比 os.path 更直观。

Day36 - 浅拷贝与深拷贝详解

Fri, 01 May 2026 10:00:00 +0800

Day36 - 浅拷贝与深拷贝详解

详细讲解

1. 对象赋值与引用

在 Python 中，一切皆对象。赋值语句（如 a = b）并不复制对象，而是创建了对同一对象的引用。

# 赋值 - 同一个对象的不同引用
a = [1, 2, 3]
b = a

print(f"a: {a}")   # [1, 2, 3]
print(f"b: {b}")   # [1, 2, 3]
print(f"a is b: {a is b}")  # True - 同一对象

# 修改 a，b 也会变化
a.append(4)
print(f"修改后 a: {a}")   # [1, 2, 3, 4]
print(f"修改后 b: {b}")   # [1, 2, 3, 4] - b 也变了！

# id() 显示对象身份
print(f"id(a): {id(a)}")
print(f"id(b): {id(b)}")  # 相同

2. 浅拷贝（Shallow Copy）

浅拷贝创建一个新对象，但只复制原对象中的第一层引用。对于嵌套对象，只复制其引用，不复制嵌套对象本身。

Day37 - 迭代器与生成器详解

Fri, 01 May 2026 10:00:00 +0800

Day37 - 迭代器与生成器详解

详细讲解

1. 迭代器基础

1.1 可迭代对象与迭代器

可迭代对象（Iterable）：可以使用 for 循环遍历的对象，如 list, dict, str, file 等。

迭代器（Iterator）：实现了 __iter__() 和 __next__() 方法的对象。

# 可迭代对象
numbers = [1, 2, 3]  # list 是可迭代对象

# 获取迭代器
iterator = iter(numbers)
print(f"迭代器: {iterator}")

# 手动迭代
print(next(iterator))  # 1
print(next(iterator))  # 2
print(next(iterator))  # 3
print(next(iterator))  # StopIteration 异常

1.2 迭代器协议

# 迭代器必须实现的两个方法
class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0
    
    def __iter__(self):
        """返回迭代器本身"""
        return self
    
    def __next__(self):
        """返回下一个元素"""
        if self.index >= len(self.data):
            raise StopIteration
        value = self.data[self.index]
        self.index += 1
        return value

# 使用
it = MyIterator([10, 20, 30])
for item in it:
    print(item)

1.3 iter() 和 next() 内置函数

# iter() 可以接受两个参数：可迭代对象 + 哨兵值
# 这样会在每次 next() 时调用可迭代对象，直到返回值等于哨兵值

# 示例：读取行直到空行
with open('lines.txt', 'r') as f:
    for line in iter(f.readline, ''):
        print(line.strip())

# next() 可以指定默认值
numbers = [1, 2, 3]
it = iter(numbers)
print(next(it, '默认值'))  # 1
print(next(it, '默认值'))  # 2
print(next(it, '默认值'))  # 3
print(next(it, '默认值'))  # 默认值（不会抛出 StopIteration）

2. 生成器基础

生成器是一种特殊的迭代器，使用 yield 关键字来产生值，而不是 return。

Day38 装饰器详解

Fri, 01 May 2026 10:00:00 +0800

Day38 - 装饰器详解 (@decorator/wraps/闭包)

详细讲解

1. 闭包基础

1.1 什么是闭包

闭包是指一个函数记住其创建时所处的环境（外部作用域的变量）的机制。

def outer():
    x = 10  # 外部变量
    
    def inner():
        print(x)  # 引用外部变量
    
    return inner

# 创建闭包
closure = outer()
closure()  # 输出 10

# 验证闭包
print(f"closure.__closure__: {closure.__closure__}")  # 闭包变量
print(f"closure.__code__.co_freevars: {closure.__code__.co_freevars}")  # 自由变量名

1.2 闭包的经典应用

def make_multiplier(factor):
    """创建乘数函数（闭包）"""
    def multiply(x):
        return x * factor
    return multiply

# 创建两个不同的乘数
times_2 = make_multiplier(2)
times_3 = make_multiplier(3)
times_5 = make_multiplier(5)

print(times_2(10))  # 20
print(times_3(10))  # 30
print(times_5(10))  # 50

# 闭包会记住创建时的 factor 值
print(f"times_2 的闭包: {times_2.__closure__[0].cell_contents}")  # 2

1.3 闭包的常见陷阱

# 陷阱：循环中的闭包
def create_funcs():
    funcs = []
    for i in range(3):
        # 错误！所有函数都会引用同一个 i
        def func():
            return i
        funcs.append(func)
    return funcs

funcs = create_funcs()
print([f() for f in funcs])  # [2, 2, 2] - 不是 [0, 1, 2]！

# 正确做法：使用默认参数捕获当前值
def create_funcs_fixed():
    funcs = []
    for i in range(3):
        def func(i=i):  # 默认参数在定义时绑定
            return i
        funcs.append(func)
    return funcs

funcs = create_funcs_fixed()
print([f() for f in funcs])  # [0, 1, 2]

2. 装饰器基础

装饰器是一个返回函数的高阶函数，用于在不修改原函数的情况下扩展功能。

Day39 - 正则表达式基础

Fri, 01 May 2026 10:00:00 +0800

Day39 - 正则表达式基础

详细讲解

1. 正则表达式简介

正则表达式是一种用于匹配字符串的模式表达式，在文本处理、数据提取、验证等场景中广泛应用。

import re

# 最简单的匹配
pattern = r'hello'
text = 'hello world'

if re.search(pattern, text):
    print("找到匹配！")

# 常用场景
# 1. 验证邮箱格式
# 2. 提取网页中的链接
# 3. 处理日志文件
# 4. 数据清洗和转换

2. re 模块主要函数

2.1 `re.match()` - 从开头匹配

import re

# match() 从字符串开头匹配
result = re.match(r'hello', 'hello world')
print(result)  # <re.Match object>
print(result.group())  # 'hello'
print(result.span())   # (0, 5)

# 如果开头不匹配，返回 None
result = re.match(r'world', 'hello world')
print(result)  # None

# 使用分组
result = re.match(r'(\w+), (\w+)', 'hello, world')
if result:
    print(result.group(1))  # 'hello'
    print(result.group(2))  # 'world'
    print(result.groups())  # ('hello', 'world')

2.2 `re.search()` - 搜索匹配

# search() 在字符串任意位置查找第一个匹配
result = re.search(r'world', 'hello world')
print(result.group())  # 'world'
print(result.span())   # (6, 11)

# 搜索邮箱
text = "联系邮箱: test@example.com 或 admin@test.org"
result = re.search(r'\w+@\w+\.\w+', text)
print(result.group())  # 'test@example.com'

# 找不到返回 None
result = re.search(r'notfound', 'hello')
print(result)  # None

2.3 `re.findall()` - 查找所有匹配

# findall() 返回所有匹配的列表
text = "我的邮箱是 test@example.com，副邮箱是 backup@example.org"

# 查找所有邮箱
emails = re.findall(r'\w+@\w+\.\w+', text)
print(emails)  # ['test@example.com', 'backup@example.org']

# 查找所有数字
numbers = re.findall(r'\d+', '我有 3 个苹果，5 个橙子，共 8 个水果')
print(numbers)  # ['3', '5', '8']

# 使用分组 - 返回分组内容的列表
text = "红色: #FF0000, 绿色: #00FF00, 蓝色: #0000FF"
colors = re.findall(r'#([0-9A-Fa-f]{6})', text)
print(colors)  # ['FF0000', '00FF00', '0000FF']

2.4 `re.finditer()` - 迭代器版本

# finditer() 返回迭代器，比 findall() 内存效率高
text = "邮箱: a@test.com, b@test.com, c@test.com"

for match in re.finditer(r'\w+@\w+\.\w+', text):
    print(f"位置 {match.span()}: {match.group()}")

3. 字符类（Character Classes）

# [] - 匹配方括号内的任意一个字符

# 匹配元音字母
vowels = re.findall(r'[aeiouAEIOU]', 'Hello World')
print(vowels)  # ['e', 'o', 'o']

# 匹配数字或字母
alphanum = re.findall(r'[a-zA-Z0-9]', 'Hello123!')
print(alphanum)  # ['H', 'e', 'l', 'l', 'o', '1', '2', '3']

# [^] - 否定，匹配不在方括号内的字符
non_vowels = re.findall(r'[^aeiouAEIOU]', 'Hello')
print(non_vowels)  # ['H', 'l', 'l']

# 常用简写
# \d  = [0-9]        数字
# \D  = [^0-9]       非数字
# \w  = [a-zA-Z0-9_] 单词字符
# \W  = [^a-zA-Z0-9_] 非单词字符
# \s  = [ \t\n\r\f\v] 空白字符
# \S  = [^ \t\n\r\f\v] 非空白字符
# .   = 任意字符（除换行符）

# 示例
text = "用户: ZhangSan, 年龄: 25, 电话: 138-0000-8888"

ages = re.findall(r'\d+', text)
print(ages)  # ['25', '138', '0000', '8888']

words = re.findall(r'\w+', text)
print(words)  # ['用户', 'ZhangSan', '年龄', '25', '电话', '138', '0000', '8888']

4. 量词（Quantifiers）

# *    - 0 次或多次
# +    - 1 次或多次
# ?    - 0 次或 1 次
# {n}  - 恰好 n 次
# {n,} - 至少 n 次
# {n,m} - n 到 m 次

# * 示例：匹配任意数量字符
pattern = r'ab*c'  # ac, abc, abbc, abbbc, ...
print(re.findall(r'ab*c', 'ac abc abbc abbbc'))  # ['ac', 'abc', 'abbc', 'abbbc']

# + 示例：至少一个
pattern = r'ab+c'  # abc, abbc, abbbc, ... (不包括 ac)
print(re.findall(r'ab+c', 'ac abc abbc'))  # ['abc', 'abbc']

# ? 示例：可选
pattern = r'colou?r'  # color, colour
print(re.findall(r'colou?r', 'color colour'))  # ['color', 'colour']

# {n} 示例：精确次数
pattern = r'\d{4}'  # 4 位数字
print(re.findall(r'\d{4}', '2024年 12345月'))  # ['2024', '1234']

# {n,m} 示例：范围次数
pattern = r'\d{2,4}'  # 2-4 位数字
print(re.findall(r'\d{2,4}', '1 12 123 1234 12345'))
# ['12', '123', '1234', '1234', '5'] - 注意贪婪匹配

# 贪婪 vs 非贪婪（最小匹配）
text = '<div>content</div>'

# 贪婪：尽可能多匹配
print(re.findall(r'<div>.*</div>', text))  # ['<div>content</div>']

# 非贪婪：尽可能少匹配
print(re.findall(r'<div>.*?</div>', text))  # ['<div>content</div>']

# 非贪婪添加 ?
text = '<div>div1</div><div>div2</div>'
print(re.findall(r'<div>.*?</div>', text))  # ['<div>div1</div>', '<div>div2</div>']

5. 边界匹配

# ^  - 字符串开头
# $  - 字符串结尾
# \b - 单词边界
# \B - 非单词边界

# 匹配以数字开头的行
text = "123abc\nhello\n456xyz"
lines = re.findall(r'^\d+', text, re.MULTILINE)
print(lines)  # ['123', '456']

# 匹配以.com结尾的域名
domains = re.findall(r'\w+\.com$', 'test.com\nexample.org\nmail.com')
print(domains)  # ['test.com', 'mail.com']

# \b 边界示例
text = "a cat a the in cat"

# 匹配完整的单词 'cat'
cats = re.findall(r'\bcat\b', text)
print(cats)  # ['cat', 'cat'] - 两个独立的 cat

# 不使用边界
cats_all = re.findall(r'cat', text)
print(cats_all)  # ['cat', 'cat', 'cat'] - 包括 a[cat] 中的 cat

# \B 非边界示例
text = "abc abc"
print(re.findall(r'ab\B', text))  # ['ab'] - abc 中的 ab
print(re.findall(r'\Bab\B', text))  # [] - 开头和结尾的 ab 都不匹配

6. 分组（Groups）

# () - 创建分组

# 提取邮箱用户名和域名
text = "邮箱: john@example.com 和 jane@test.org"
matches = re.findall(r'(\w+)@(\w+)\.(\w+)', text)
print(matches)  # [('john', 'example', 'com'), ('jane', 'test', 'org')]

# 嵌套分组
text = "2024-05-01"
match = re.search(r'(\d{4})-(\d{2})-(\d{2})', text)
if match:
    print(match.groups())  # ('2024', '05', '01')
    print(match.group(1))  # '2024' 年
    print(match.group(2))  # '05' 月
    print(match.group(3))  # '01' 日

# 命名分组
pattern = r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})'
match = re.search(pattern, '2024-05-01')
if match:
    print(match.group('year'))   # '2024'
    print(match.group('month'))  # '05'
    print(match.group('day'))     # '01'
    print(match.groupdict())     # {'year': '2024', 'month': '05', 'day': '01'}

# 非捕获分组 (?:)
text = "abc123def"
# 捕获分组会作为 groups 返回
match = re.search(r'(?:abc)(\d+)', text)
print(match.groups())  # ('123',)

# 分组在替换中的应用
text = "2024-05-01"
result = re.sub(r'(\d{4})-(\d{2})-(\d{2})', r'\2/\3/\1', text)
print(result)  # 05/01/2024

7. re.compile() 编译正则

# 编译正则表达式，提高匹配效率
pattern = re.compile(r'\d{4}-\d{2}-\d{2}')

# 使用编译后的 pattern
text = "今天是 2024-05-01，明天是 2024-05-02"

print(pattern.findall(text))  # ['2024-05-01', '2024-05-02']
print(pattern.search(text).group())  # '2024-05-01'

# 编译时指定 flags
pattern = re.compile(r'hello', re.IGNORECASE)
print(pattern.findall('Hello HELLO hello'))  # ['Hello', 'HELLO', 'hello']

8. re 模块的 flags

# re.IGNORECASE / re.I - 忽略大小写
print(re.findall(r'hello', 'Hello HELLO', re.I))

# re.MULTILINE / re.M - 多行模式
text = "line1\nline2\nline3"
print(re.findall(r'^line\d', text, re.M))  # ['line1', 'line2', 'line3']

# re.DOTALL / re.S - 点号匹配所有字符（包括换行）
text = "hello\nworld"
print(re.findall(r'hello.*world', text))    # [] - 默认不匹配换行
print(re.findall(r'hello.*world', text, re.S))  # ['hello\nworld']

# re.VERBOSE / re.X - 详细模式（忽略空白和注释）
pattern = re.compile(r'''
    \d{3}  # 区号
    -      # 分隔符
    \d{4}  # 号码
''', re.VERBOSE)

# 可以组合使用
pattern = re.compile(r'hello', re.I | re.M)

背诵版

核心速查

┌─────────────────────────────────────────────────────────────┐ │ re 模块主要函数 │ ├─────────────────────────────────────────────────────────────┤ │ re.match() │ 从字符串开头匹配 │ │ re.search() │ 搜索第一个匹配 │ │ re.findall() │ 返回所有匹配的列表 │ │ re.finditer() │ 返回匹配的迭代器 │ │ re.sub() │ 替换匹配项 │ │ re.split() │ 按匹配分割 │ │ re.compile() │ 编译正则表达式 │ └─────────────────────────────────────────────────────────────┘

字符类速查

模式	说明	等价
`\d`	数字	`[0-9]`
`\D`	非数字	`[^0-9]`
`\w`	单词字符	`[a-zA-Z0-9_]`
`\W`	非单词字符	`[^a-zA-Z0-9_]`
`\s`	空白字符	`[ \t\n\r\f\v]`
`\S`	非空白字符	`[^ \t\n\r\f\v]`
`.`	任意字符	-

量词速查

量词	说明
`*`	0 次或多次
`+`	1 次或多次
`?`	0 次或 1 次
`{n}`	恰好 n 次
`{n,}`	至少 n 次
`{n,m}`	n 到 m 次

考前记忆

面试重点

match vs search

Day40 - 正则表达式高级与综合项目

Fri, 01 May 2026 10:00:00 +0800

Day40 - 正则表达式高级与综合项目

详细讲解

1. 分组高级用法

1.1 捕获分组与非捕获分组

import re

# 捕获分组 - 会保存到 groups() 中
text = "2024-05-01"
match = re.search(r'(\d{4})-(\d{2})-(\d{2})', text)
print(match.groups())  # ('2024', '05', '01')

# 非捕获分组 (?:...) - 不保存到 groups()
match = re.search(r'(\d{4})-(?:\d{2})-(\d{2})', text)
print(match.groups())  # ('2024', '01')

# 使用场景：提高效率（不需要的分组不用保存）
# 当分组多时，非捕获分组性能更好

1.2 命名分组

# (?P<name>pattern) - 命名分组
text = "John Doe <john@example.com>"

match = re.search(r'(?P<name>\w+) (?P<surname>\w+) <(?P<email>\w+@\w+\.\w+)>', text)
if match:
    print(match.groupdict())
    # {'name': 'John', 'surname': 'Doe', 'email': 'john@example.com'}

    # 按名称访问
    print(match.group('name'))   # 'John'
    print(match.group('email'))  # 'john@example.com'

# 命名分组在替换中也很方便
text = "2024-05-01"
result = re.sub(r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})',
                 r'\g<month>/\g<day>/\g<year>', text)
print(result)  # 05/01/2024

1.3 反向引用

# \1, \2 等 - 引用前面的分组

# 匹配重复的单词
text = "the the cat cat dog"
pattern = r'(\w+) \1'  # \1 引用第一个分组
print(re.findall(pattern, text))  # ['the', 'cat']

# 匹配 HTML 标签
text = "<div>content</div> <span>text</span>"
pattern = r'<(\w+)>.*?</\1>'  # \1 引用前面的标签名
print(re.findall(pattern, text))  # ['div', 'span']

# 匹配引号
pattern = r'(["\'])(.*?)\1'  # \1 引用开头的引号
print(re.findall(pattern, "'hello' and \"world\""))  # ["'", 'hello', '"', 'world']

1.4 条件匹配

# (?(id)yes_pattern|no_pattern) - 如果 id 存在则匹配 yes_pattern，否则匹配 no_pattern

# 匹配带引号或不带引号的单词
text = '"hello" world "python"'

# 如果有引号，则匹配引号内的内容；否则匹配单词
pattern = r'(["\'])?(?(1)(.*?)\1|(\w+))'
matches = re.findall(pattern, text)
print(matches)  # [('"', 'hello', ''), ('', '', 'world'), ('"', 'python', '')]

2. `re.sub()` 高级用法

2.1 基本替换

import re

# 基本替换
text = "Hello World"
result = re.sub(r'World', 'Python', text)
print(result)  # Hello Python

# 使用分组引用
text = "2024-05-01"
result = re.sub(r'(\d{4})-(\d{2})-(\d{2})', r'\2/\3/\1', text)
print(result)  # 05/01/2024

# 命名分组引用
result = re.sub(r'(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})',
                 r'\g<d>-\g<m>-\g<y>', text)
print(result)  # 01-05-2024

2.2 替换函数

# 传入函数作为替换参数

def expand_date(match):
    """日期转换函数"""
    year, month, day = match.groups()
    
    months = {
        '01': 'January', '02': 'February', '03': 'March',
        '04': 'April',   '05': 'May',      '06': 'June',
        '07': 'July',    '08': 'August',   '09': 'September',
        '10': 'October', '11': 'November', '12': 'December'
    }
    
    return f"{months[month]} {day}, {year}"

text = "Date: 2024-05-01"
result = re.sub(r'(\d{4})-(\d{2})-(\d{2})', expand_date, text)
print(result)  # Date: May 01, 2024

# 数字格式化
def format_number(match):
    num = int(match.group())
    return f"{num:,}"  # 添加千分位

text = "金额: 1234567"
result = re.sub(r'\d+', format_number, text)
print(result)  # 金额: 1,234,567

2.3 `re.subn()` - 返回替换次数

# subn() 返回 (新字符串, 替换次数)
text = "aaa bbb aaa ccc aaa"
result, count = re.subn(r'aaa', 'XXX', text)
print(f"替换后: {result}, 替换次数: {count}")
# 替换后: XXX bbb XXX ccc XXX, 替换次数: 3

3. `re.split()` 高级用法

import re

# 基本分割
text = "apple,banana,cherry"
parts = re.split(r',', text)
print(parts)  # ['apple', 'banana', 'cherry']

# 使用分组分割 - 分组会保留在结果中
text = "apple1banana2cherry"
parts = re.split(r'(\d)', text)
print(parts)  # ['apple', '1', 'banana', '2', 'cherry']

# 限制分割次数
text = "a:b:c:d:e"
parts = re.split(r':', text, maxsplit=2)
print(parts)  # ['a', 'b', 'c:d:e']

# 按多种分隔符分割
text = "apple,bana;na|cherry"
parts = re.split(r'[,;|]', text)
print(parts)  # ['apple', 'bana', 'na', 'cherry']

4. 零宽断言（Lookaround）

4.1 正向先行断言 `(?=...)`

# 匹配后面跟着特定内容的前缀
text = "Windows10 Windows11 Windows12"

# 匹配前面是 Windows，后面是数字的 Windows
result = re.findall(r'Windows(?=\d)', text)
print(result)  # ['Windows', 'Windows', 'Windows']

# 更实用的例子：获取价格（数字前的货币符号）
text = "价格: $100, €50, ¥200"
result = re.findall(r'[$€¥]\d+', text)
print(result)  # ['$100', '€50', '¥200']

# 匹配后面是 .com 的域名部分
text = "example.com test.org hello.com"
result = re.findall(r'\w+(?=\.com)', text)
print(result)  # ['example', 'hello']

4.2 负向先行断言 `(?!...)`

# 匹配后面不跟着特定内容的前缀
text = "Windows10 WindowsMac Windows11"

# 匹配后面不是数字的 Windows
result = re.findall(r'Windows(?!\d)', text)
print(result)  # ['WindowsMac']

# 排除特定结尾
text = ["file.txt", "file.log", "file.txt.bak", "data.csv"]
txt_files = [f for f in text if re.match(r'.*\.txt(?!\.)', f)]
print(txt_files)  # ['file.txt']

4.3 正向后行断言 `(?<=...)`

# 匹配前面跟着特定内容的后缀
text = "价格: 100元, 200元, 300美元"

# 匹配"元"前面的数字
result = re.findall(r'(?<=[元])\d+', text)
print(result)  # ['100', '200']

# 提取 HTML 中的文本内容
html = "<div>Hello</div><span>World</span>"
result = re.findall(r'(?<=<[a-z]+>)[^<]+', html)
print(result)  # ['Hello', 'World']

# 提取域名后的路径
text = "https://example.com/path1 http://test.org/path2"
result = re.findall(r'(?<=//[^/]+/).+', text)
print(result)  # ['/path1', '/path2']

4.4 负向后行断言 `(?<!...)`

# 匹配前面不跟着特定内容的后缀
text = "100元 200美元 300元 400日元"

# 匹配前面不是"元"的数字
result = re.findall(r'(?<![元])\d+', text)
print(result)  # ['200', '400']

# 更实用的例子：提取不是来自某个前缀的内容
text = "abc123 abc456 xyz789"
result = re.findall(r'(?<!abc)\d+', text)
print(result)  # ['3456', '789'] - abc123 中的 1 被排除

5. 综合项目实践

5.1 日志分析器

import re
from collections import Counter
from datetime import datetime

class LogAnalyzer:
    """日志分析器"""
    
    # 日志格式正则（示例：Apache 访问日志）
    LOG_PATTERN = re.compile(
        r'(?P<ip>[\d.]+) '  # IP 地址
        r'- - '
        r'\[(?P<timestamp>[^\]]+)\] '  # 时间戳
        r'"(?P<method>\w+) (?P<path>[^\s]+) [^"]+" '  # 请求方法和路径
        r'(?P<status>\d{3}) '  # 状态码
        r'(?P<size>\d+)'
    )
    
    # 错误日志正则
    ERROR_PATTERN = re.compile(
        r'\[(?P<timestamp>[^\]]+)\] '
        r'\[(?P<level>\w+)\] '
        r'(?P<message>.+)'
    )
    
    @classmethod
    def parse_access_log(cls, log_text):
        """解析访问日志"""
        results = []
        for line in log_text.strip().split('\n'):
            match = cls.LOG_PATTERN.search(line)
            if match:
                results.append(match.groupdict())
        return results
    
    @classmethod
    def analyze_traffic(cls, log_text):
        """流量分析"""
        entries = cls.parse_access_log(log_text)
        
        # 统计各状态码数量
        status_counts = Counter(e['status'] for e in entries)
        
        # 统计各路径访问量
        path_counts = Counter(e['path'] for e in entries)
        
        # 统计各 IP 访问量
        ip_counts = Counter(e['ip'] for e in entries)
        
        # 计算总流量
        total_bytes = sum(int(e['size']) for e in entries)
        
        return {
            'total_requests': len(entries),
            'status_codes': dict(status_counts),
            'top_paths': path_counts.most_common(10),
            'top_ips': ip_counts.most_common(10),
            'total_bytes': total_bytes
        }
    
    @classmethod
    def extract_errors(cls, log_text):
        """提取错误信息"""
        errors = []
        for line in log_text.strip().split('\n'):
            match = cls.ERROR_PATTERN.search(line)
            if match:
                errors.append(match.groupdict())
        return errors

# 使用示例
sample_log = '''
127.0.0.1 - - [01/May/2024:10:00:00 +0000] "GET /index.html HTTP/1.1" 200 1234
127.0.0.1 - - [01/May/2024:10:00:01 +0000] "GET /style.css HTTP/1.1" 200 5678
127.0.0.2 - - [01/May/2024:10:00:02 +0000] "GET /api/users HTTP/1.1" 404 0
192.168.1.1 - - [01/May/2024:10:00:03 +0000] "POST /login HTTP/1.1" 200 89
192.168.1.1 - - [01/May/2024:10:00:04 +0000] "POST /login HTTP/1.1" 401 23
'''

analyzer = LogAnalyzer()
result = analyzer.analyze_traffic(sample_log)

print(f"总请求数: {result['total_requests']}")
print(f"状态码统计: {result['status_codes']}")
print(f"Top 路径: {result['top_paths']}")
print(f"Top IPs: {result['top_ips']}")

5.2 文本数据清洗工具

import re

class TextCleaner:
    """文本数据清洗工具"""
    
    @staticmethod
    def clean_html(text):
        """移除 HTML 标签"""
        # 移除 script 和 style 内容
        text = re.sub(r'<script[^>]*>.*?</script>', '', text, flags=re.DOTALL | re.IGNORECASE)
        text = re.sub(r'<style[^>]*>.*?</style>', '', text, flags=re.DOTALL | re.IGNORECASE)
        # 移除所有 HTML 标签
        text = re.sub(r'<[^>]+>', '', text)
        # 解码 HTML 实体
        text = TextCleaner._decode_html_entities(text)
        return text.strip()
    
    @staticmethod
    def _decode_html_entities(text):
        """解码 HTML 实体"""
        entities = {
            '&nbsp;': ' ', '&amp;': '&', '&lt;': '<', '&gt;': '>',
            '&quot;': '"', '&#39;': "'", '&apos;': "'"
        }
        for entity, char in entities.items():
            text = text.replace(entity, char)
        # 处理数字形式的实体
        text = re.sub(r'&#(\d+);', lambda m: chr(int(m.group(1))), text)
        return text
    
    @staticmethod
    def normalize_whitespace(text):
        """规范化空白字符"""
        # 将所有连续空白替换为单个空格
        text = re.sub(r'\s+', ' ', text)
        # 移除首尾空白
        return text.strip()
    
    @staticmethod
    def remove_special_chars(text, keep_pattern=''):
        """移除特殊字符"""
        if keep_pattern:
            pattern = f'[^a-zA-Z0-9{re.escape(keep_pattern)}]'
        else:
            pattern = r'[^a-zA-Z0-9\u4e00-\u9fff]'  # 保留中文
        return re.sub(pattern, '', text)
    
    @staticmethod
    def extract_phones(text):
        """提取电话号码"""
        patterns = [
            r'1[3-9]\d{9}',           # 手机号
            r'\d{3,4}-\d{7,8}',       # 固话
            r'\+\d{1,3}-\d{3,4}-\d{7,8}'  # 国际电话
        ]
        phones = []
        for pattern in patterns:
            phones.extend(re.findall(pattern, text))
        return list(set(phones))  # 去重
    
    @staticmethod
    def extract_emails(text):
        """提取邮箱地址"""
        pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
        return re.findall(pattern, text)
    
    @staticmethod
    def mask_sensitive(text, mask_type='phone'):
        """脱敏处理"""
        if mask_type == 'phone':
            return re.sub(r'(1[3-9]\d{9})', 
                         lambda m: m.group(1)[:3] + '****' + m.group(1)[7:], text)
        elif mask_type == 'email':
            return re.sub(r'([a-zA-Z0-9]{2})[a-zA-Z0-9]*@',
                         r'\1***@', text)
        return text

# 使用示例
html_text = '''
<div class="content">
    <script>alert("bad");</script>
    <p>联系我们: 010-12345678 或 13812345678</p>
    <p>邮箱: contact@example.com</p>
    <p>地址: 北京市海淀区中关村大街1号</p>
</div>
'''

cleaner = TextCleaner()
text = cleaner.clean_html(html_text)
print(f"清洗后: {text}")

print(f"提取电话: {cleaner.extract_phones(text)}")
print(f"提取邮箱: {cleaner.extract_emails(text)}")
print(f"脱敏电话: {cleaner.mask_sensitive(text, 'phone')}")

5.3 URL 解析器

import re
from urllib.parse import urlparse, parse_qs

class URLParser:
    """URL 解析器"""
    
    # 更完整的 URL 正则
    URL_PATTERN = re.compile(
        r'^(?P<scheme>https?)://'  # 协议
        r'(?P<domain>[^/:]+)'       # 域名
        r'(?::(?P<port>\d+))?'      # 端口（可选）
        r'(?P<path>/[^?#]*)?'       # 路径
        r'(?:\?(?P<query>[^#]+))?'  # 查询字符串
        r'(?:#(?P<fragment>.+))?'   # 锚点
    )
    
    @classmethod
    def parse(cls, url):
        """解析 URL"""
        # 尝试用正则解析
        match = cls.URL_PATTERN.match(url)
        if match:
            return match.groupdict()
        
        # 回退到 urllib
        parsed = urlparse(url)
        return {
            'scheme': parsed.scheme,
            'domain': parsed.netloc,
            'port': parsed.port,
            'path': parsed.path,
            'query': parsed.query,
            'fragment': parsed.fragment
        }
    
    @classmethod
    def extract_params(cls, url):
        """提取 URL 参数"""
        parsed = urlparse(url)
        params = parse_qs(parsed.query)
        # 转换为简单字典（值列表转单值）
        return {k: v[0] if len(v) == 1 else v for k, v in params.items()}
    
    @classmethod
    def build_url(cls, scheme='https', domain='', path='/', params=None, fragment=''):
        """构建 URL"""
        url = f"{scheme}://{domain}{path}"
        if params:
            query = '&'.join(f"{k}={v}" for k, v in params.items())
            url += f"?{query}"
        if fragment:
            url += f"#{fragment}"
        return url
    
    @classmethod
    def extract_domain_info(cls, domain):
        """提取域名信息"""
        # 提取子域名
        parts = domain.split('.')
        if len(parts) >= 3:
            subdomain = parts[0]
            main_domain = '.'.join(parts[1:])
        else:
            subdomain = None
            main_domain = domain
        
        # 提取顶级域
        tld = parts[-1] if parts else ''
        
        return {
            'original': domain,
            'subdomain': subdomain,
            'domain': main_domain,
            'tld': tld
        }

# 使用示例
urls = [
    'https://example.com:8080/path/to/page?id=123&name=test#section',
    'http://sub.domain.co.uk/api/v1/users?page=1',
    'https://www.test.org'
]

parser = URLParser()
for url in urls:
    print(f"\n解析: {url}")
    info = parser.parse(url)
    print(f"  域名: {info['domain']}")
    print(f"  路径: {info.get('path', '/')}")
    print(f"  参数: {parser.extract_params(url)}")
    
    if info.get('domain'):
        domain_info = parser.extract_domain_info(info['domain'])
        print(f"  域名信息: {domain_info}")

5.4 数据验证器

import re

class Validator:
    """常用数据验证器"""
    
    @staticmethod
    def is_valid_email(email):
        """验证邮箱"""
        pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
        return re.match(pattern, email) is not None
    
    @staticmethod
    def is_valid_phone(phone, region='CN'):
        """验证手机号"""
        if region == 'CN':
            # 中国手机号（11位，以1开头，第2位3-9）
            pattern = r'^1[3-9]\d{9}$'
        elif region == 'US':
            # 美国电话（10位）
            pattern = r'^\d{10}$'
        else:
            pattern = r'^\+?\d{6,15}$'
        return re.match(pattern, phone) is not None
    
    @staticmethod
    def is_valid_url(url):
        """验证 URL"""
        pattern = r'^https?://[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(/.*)?$'
        return re.match(pattern, url) is not None
    
    @staticmethod
    def is_valid_ip(ip):
        """验证 IPv4 地址"""
        pattern = r'^(\d{1,3}\.){3}\d{1,3}$'
        if not re.match(pattern, ip):
            return False
        # 检查每段是否在 0-255
        return all(0 <= int(octet) <= 255 for octet in ip.split('.'))
    
    @staticmethod
    def is_valid_date(date_str, format='%Y-%m-%d'):
        """验证日期格式"""
        from datetime import datetime
        try:
            datetime.strptime(date_str, format)
            return True
        except ValueError:
            return False
    
    @staticmethod
    def is_strong_password(password):
        """验证密码强度"""
        if len(password) < 8:
            return False, "密码长度至少8位"
        
        has_upper = bool(re.search(r'[A-Z]', password))
        has_lower = bool(re.search(r'[a-z]', password))
        has_digit = bool(re.search(r'\d', password))
        has_special = bool(re.search(r'[!@#$%^&*(),.?":{}|<>]', password))
        
        if not has_upper:
            return False, "需要包含大写字母"
        if not has_lower:
            return False, "需要包含小写字母"
        if not has_digit:
            return False, "需要包含数字"
        if not has_special:
            return False, "需要包含特殊字符"
        
        return True, "密码强度合格"

# 使用示例
validator = Validator()

test_cases = [
    ('email', 'test@example.com'),
    ('phone', '13812345678'),
    ('url', 'https://www.example.com'),
    ('ip', '192.168.1.1'),
    ('date', '2024-05-01'),
]

for type_name, value in test_cases:
    method = getattr(validator, f'is_valid_{type_name}')
    result = method(value)
    status = "✓" if result else "✗"
    print(f"{status} {type_name}: {value}")

# 密码强度验证
password = "Test@1234"
valid, msg = validator.is_strong_password(password)
print(f"\n密码 '{password}': {msg}")

背诵版

高级正则速查

┌─────────────────────────────────────────────────────────────┐ │ 零宽断言（Lookaround） │ ├─────────────────────────────────────────────────────────────┤ │ (?=...) 正向先行 │ 后面跟着... │ │ (?!...) 负向先行 │ 后面不跟... │ │ (?<=...) 正向后行 │ 前面是... │ │ (?<!...) 负向后行 │ 前面不是... │ ├─────────────────────────────────────────────────────────────┤ │ (?P<name>...) 命名分组 │ │ (?:...) 非捕获分组 │ │ \1, \2 反向引用 │ └─────────────────────────────────────────────────────────────┘

re.sub 替换函数

# 基本替换
re.sub(pattern, replacement, string)

# 替换函数
def replace_func(match):
    return ...  # 返回替换文本

re.sub(pattern, replace_func, string)

# 返回替换次数
re.subn(pattern, replacement, string)  # 返回 (结果, 次数)

考前记忆

面试重点

零宽断言的区别