给定一个 m x n 的矩阵，如果一个元素为 0，则将其所在行和列的所有元素都设为 0。请使用原地算法。
m x n 的整数矩阵 matrix
原地修改矩阵，将包含 0 的行和列全部置零
m == matrix.lengthn == matrix[0].length1 <= m, n <= 200-2^31 <= matrix[i][j] <= 2^31 - 1一个直观的解决方案是使用 $O(mn)$ 的额外空间，但这并不是一个好的解决方案。一个简单的改进方案是使用 $O(m + n)$ 的额外空间，但这仍然不是最好的解决方案。你能想出一个仅使用常量空间的解决方案吗？
输入：matrix = [[1,1,1],[1,0,1],[1,1,1]]
输出：[[1,0,1],[0,0,0],[1,0,1]]
输入：matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
输出：[[0,0,0,0],[0,4,5,0],[0,3,1,0]]
这道题的难点在于一个"连锁反应"陷阱：你不能在遍历过程中直接把行和列置零，因为那些被置零的位置会在后续遍历中被误判为"原本就是 0"，从而错误地波及更多行和列——最终整个矩阵可能全变成 0。
💡 核心直觉：我们需要一种方式来"记住"哪些行和列需要被置零，而不是在遍历过程中立即执行。就像在纸质表格上做标记——先用铅笔圈出哪些行和列有 0，全部圈完后再统一擦除。
最朴素的想法：深拷贝一份矩阵，遍历拷贝来找 0，在原矩阵上执行置零：
class Solution:
def setZeroes(self, matrix: List[List[int]]) -> None:
m, n = len(matrix), len(matrix[0])
copy = [row[:] for row in matrix]
for i in range(m):
for j in range(n):
if copy[i][j] == 0:
for k in range(n):
matrix[i][k] = 0 # 整行置零
for k in range(m):
matrix[k][j] = 0 # 整列置零
显然不可接受。
不复制矩阵，用两个布尔数组分别记录哪些行、哪些列包含 0：
class Solution:
def setZeroes(self, matrix: List[List[int]]) -> None:
m, n = len(matrix), len(matrix[0])
zero_rows = [False] * m
zero_cols = [False] * n
# 第一遍：记录
for i in range(m):
for j in range(n):
if matrix[i][j] == 0:
zero_rows[i] = True
zero_cols[j] = True
# 第二遍：执行
for i in range(m):
for j in range(n):
if zero_rows[i] or zero_cols[j]:
matrix[i][j] = 0
已经很好了，但题目进阶要求是 $O(1)$ 空间。数组本身有 $m \times n$ 个位置——能不能借用矩阵自己的一部分来充当标记数组？
关键的洞察：只要 $m+n$ 个布尔标记位就够了。矩阵的第一行（$n$ 个元素）加上第一列（$m$ 个元素）刚好够用！
🧠 直觉理解：把第一行当作"列标记牌"——
matrix[0][j] = 0表示"第 j 列需要清零"。把第一列当作"行标记牌"——matrix[i][0] = 0表示"第 i 行需要清零"。剩下的[1,m) × [1,n)区域是真正的"工作区"，我们遍历它、发现 0、在标记牌上记录。
但有个麻烦事：第一行和第一列既要是"标记牌"，自己本身也可能是数据——如果第一行原本就有 0，它在标记牌上的 0 到底代表"第一行需要清零"还是"某列需要清零"？
所以我们需要两个独立变量 r 和 c，提前记录第一行和第一列是否原本就含 0。
第一步：检查第一行和第一列
m, n = len(matrix), len(matrix[0])
r = c = False
for i in range(n):
if matrix[0][i] == 0:
r = True # 第一行需要归零
for i in range(m):
if matrix[i][0] == 0:
c = True # 第一列需要归零
⚠️ 注意：
matrix[0][0]同时属于第一行和第一列。如果它是 0，r和c都会变成True，这是正确的——第一行和第一列都得清零。
第二步：遍历工作区，在标记牌上记录
遍历 [1, m) × [1, n)，遇到 0 就在第一行和第一列打标记：
for i in range(1, m):
for j in range(1, n):
if matrix[i][j] == 0:
matrix[i][0] = 0 # 第 i 行需要清零 → 刻在第一列
matrix[0][j] = 0 # 第 j 列需要清零 → 刻在第一行
第三步：根据标记牌，在工作区执行置零
再次遍历 [1, m) × [1, n)，看一行或一列是否被标记：
for i in range(1, m):
for j in range(1, n):
if matrix[i][0] == 0 or matrix[0][j] == 0:
matrix[i][j] = 0
💡 这里有一个巧妙的"自动继承"：如果第一行原本的某个
matrix[0][j]就是 0（比如示例 2 中的matrix[0][3]=0），它不需要我们在第二步额外标记，在第三步中会自然地让第 j 列的工作区被置零——因为matrix[0][j]这个位置本身就同时是数据也是标记。
第四步：处理第一行和第一列自己
最后才处理第一行和第一列——这必须在最后做，否则标记信息就丢了：
if r:
for i in range(n):
matrix[0][i] = 0
if c:
for i in range(m):
matrix[i][0] = 0
以示例 1 matrix = [[1,1,1],[1,0,1],[1,1,1]] 为例：
步骤 1：检查首行首列
[1,1,1]，无 0 → r = False[1,1,1]，无 0 → c = False步骤 2：打标记（遍历 i=1,2 和 j=1,2）
i |
j |
matrix[i][j] |
操作 | 矩阵变化 |
|---|---|---|---|---|
| 1 | 1 | 0 | matrix[1][0]=0, matrix[0][1]=0 |
[[1,**0**,1],[**0**,0,1],[1,1,1]] |
| 1 | 2 | 1 | 无操作 | 不变 |
| 2 | 1 | 1 | 无操作 | 不变 |
| 2 | 2 | 1 | 无操作 | 不变 |
标记完成后的矩阵：[[1,0,1],[0,0,1],[1,1,1]]
步骤 3：根据标记执行（遍历 i=1,2 和 j=1,2）
i |
j |
matrix[i][0] |
matrix[0][j] |
条件满足？ | 操作 | 矩阵变化 |
|---|---|---|---|---|---|---|
| 1 | 1 | 0 |
0 |
是 | 置零 | 已经是 0 |
| 1 | 2 | 0 |
1 |
是（matrix[1][0]=0） |
置零 | matrix[1][2]=0 |
| 2 | 1 | 1 |
0 |
是（matrix[0][1]=0） |
置零 | matrix[2][1]=0 |
| 2 | 2 | 1 |
1 |
否 | 不变 | 不变 |
步骤 4：处理首行首列
r = False → 不动第一行c = False → 不动第一列最终结果：[[1,0,1],[0,0,0],[1,0,1]] ✅
再看示例 2 matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]（$m=3, n=4$）：
步骤 1：检查首行首列
[0,1,2,0]，有 0 → r = True[0,3,1]，有 0 → c = True步骤 2：打标记（遍历 i=1,2 和 j=1,2,3）
所有元素都非 0，不写入新标记。但注意——matrix[0][3] 原本就是 0，它作为"列 3 的标记"已经存在了！
步骤 3：根据标记执行（遍历 i=1,2 和 j=1,2,3）
i |
j |
matrix[i][0] |
matrix[0][j] |
条件满足？ | 操作 |
|---|---|---|---|---|---|
| 1 | 1 | 3 |
1 |
否 | 不变 |
| 1 | 2 | 3 |
2 |
否 | 不变 |
| 1 | 3 | 3 |
0 |
是 | matrix[1][3]=0 |
| 2 | 1 | 1 |
1 |
否 | 不变 |
| 2 | 2 | 1 |
2 |
否 | 不变 |
| 2 | 3 | 1 |
0 |
是 | matrix[2][3]=0 |
步骤 4：处理首行首列
r = True → 第一行全置零c = True → 第一列全置零最终结果：[[0,0,0,0],[0,4,5,0],[0,3,1,0]] ✅
💡 示例 2 中，
matrix[0][3]=0从未被步骤 2 刻意标记过——它天生就是标记。在步骤 3 中，任何工作区元素只要列号 j=3，就会发现matrix[0][3]=0，从而被正确置零。第一行中不在第一列的 0，天然充当了该列的标记——这也是为什么步骤 1 要先检查第一行并记录r：因为第一行自己的 0 既承担"这一列要清零"的标记职责，又承担"整行自身也需要清零"的数据职责。
r 和 c。class Solution:
def setZeroes(self, matrix: List[List[int]]) -> None:
"""
Do not return anything, modify matrix in-place instead.
"""
m, n = len(matrix), len(matrix[0])
r = c = False
for i in range(n):
if matrix[0][i] == 0:
r = True
for i in range(m):
if matrix[i][0] == 0:
c = True
for i in range(1, m):
for j in range(1, n):
if matrix[i][j] == 0:
matrix[i][0] = matrix[0][j] = 0
for i in range(1, m):
for j in range(1, n):
if matrix[i][0] == 0 or matrix[0][j] == 0:
matrix[i][j] = 0
if r:
for i in range(n):
matrix[0][i] = 0
if c:
for i in range(m):
matrix[i][0] = 0
逐行解读：
r = c = False：两个布尔哨兵，记录第一行和第一列的"身世"——它们自己是否包含 0。matrix[0][i]，只要有一个 0，r 就为 True。c。[1,m) × [1,n)，matrix[i][0] = matrix[0][j] = 0 利用 Python 的链式赋值，一步将行标记和列标记同时写入。r 为真，将整行清空。c 为真，将整列清空。⚠️ 顺序至关重要：步骤 6 和 7 必须在步骤 4-5 之后。如果先清零第一行/列，标记信息就丢失了，工作区将无法正确判断哪些行列需要置零。
「矩阵置零」教会我们一个经典的空间优化技巧：用输入数据的"边缘"做标记区。
🧠 核心收获：当需要 $O(m+n)$ 的标记空间而只有 $O(mn)$ 的矩阵可用时，考虑把矩阵的第一行和第一列"征收"为标记数组。代价是额外用两个变量保存第一行和第一列自身的原始信息。这种"借用输入数据做辅助存储"的思路在算法设计中反复出现——当你被要求 $O(1)$ 空间却需要"记忆"某些信息时，问问自己：输入数组的某些位置能不能被复用？
同类题目推荐：
]]>给你一个整数数组 nums，返回数组 answer，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。
题目数据保证数组 nums 之中任意元素的全部前缀元素和后缀元素的乘积都在 32 位整数范围内。
请勿使用除法，且在 $O(n)$ 时间复杂度内完成此题。
整数数组 nums
数组 answer，其中 answer[i] 等于除 nums[i] 外其余元素的乘积
2 <= nums.length <= 10^5-30 <= nums[i] <= 30nums 之中任意元素的全部前缀元素和后缀元素的乘积都在 32 位整数范围内你可以在 $O(1)$ 的额外空间复杂度内完成这个题目吗？（出于对空间复杂度分析的目的，输出数组不被视为额外空间。）
输入：nums = [1,2,3,4]
输出：[24,12,8,6]
输入：nums = [-1,1,0,-3,3]
输出：[0,0,9,0,0]
题目要求计算「除自己以外所有元素的乘积」——直观来想，对于位置 i，我们需要知道左边所有元素的乘积和右边所有元素的乘积，然后把它们乘起来。
💡 核心直觉：
answer[i] = (nums[0] × ... × nums[i-1]) × (nums[i+1] × ... × nums[n-1])，即「前缀积 × 后缀积」。如果我们能高效地获取每个位置的左乘积和右乘积，问题就迎刃而解了。
最直接的做法：对于每个位置 i，遍历整个数组计算乘积，跳过自身：
class Solution:
def productExceptSelf(self, nums: List[int]) -> List[int]:
n = len(nums)
ans = [1] * n
for i in range(n):
for j in range(n):
if i != j:
ans[i] *= nums[j]
return ans
瓶颈分析：时间复杂度 $O(n^2)$，当 $n \le 10^5$ 时，$10^{10}$ 次操作远超时间限制。而且内部循环做了大量重复计算——对于相邻的位置 i 和 i+1，它们共享了大量乘数，但暴力法每次都从头乘起。
优化方向：能否复用已经算过的乘积？如果我们提前算好每个位置的「左边所有数的乘积」和「右边所有数的乘积」，那么每个位置的结果就是两者相乘，只需 $O(1)$ 即可得到。
正如上文分析，我们可以用两个数组分别记录前缀积和后缀积：
left[i]：nums[0] 到 nums[i-1] 的乘积（不含 nums[i]）right[i]：nums[i+1] 到 nums[n-1] 的乘积（不含 nums[i]）那么 answer[i] = left[i] * right[i]。
class Solution:
def productExceptSelf(self, nums: List[int]) -> List[int]:
n = len(nums)
left = [1] * n
right = [1] * n
ans = [1] * n
# 从左到右计算前缀积
for i in range(1, n):
left[i] = left[i - 1] * nums[i - 1]
# 从右到左计算后缀积
for i in range(n - 2, -1, -1):
right[i] = right[i + 1] * nums[i + 1]
# 合并
for i in range(n):
ans[i] = left[i] * right[i]
return ans
left 和 right 两个额外数组虽然时间已经最优，但题目进阶要求提出：能否只用 $O(1)$ 额外空间？
观察上述代码，left 和 ans 计算时机可以合并——我们先用 ans 数组存储前缀积，然后在从右向左遍历时，用一个变量 r 跟踪后缀积，边乘边更新：
class Solution:
def productExceptSelf(self, nums: List[int]) -> List[int]:
n = len(nums)
ans = [1] * n
# 第一遍：ans[i] 存储 i 左边所有元素的乘积
for i in range(1, n):
ans[i] = ans[i - 1] * nums[i - 1]
# 第二遍：从右向左，用 r 跟踪右边乘积，直接乘入 ans
r = 1
for i in range(n - 1, -1, -1):
ans[i] *= r
r *= nums[i]
return ans
💡 关键优化：
ans数组一开始存放前缀积，然后从右向左遍历时「就地」乘上后缀积，一举两得。由于输出数组不计入额外空间，我们实现了 $O(1)$ 额外空间。
上面的解法需要两次独立的遍历。有没有办法在一次遍历中同时完成前后缀积的累积？
答案是可以的。我们维护两个变量 l 和 r，分别记录从左到右和从右到左的累积乘积。在每次迭代中，l 代表当前位置 i 的「左边乘积」，r 代表对称位置 n-i-1 的「右边乘积」——两边同时推进，互不干扰：
class Solution:
def productExceptSelf(self, nums: List[int]) -> List[int]:
n = len(nums)
l = r = 1
res = [1] * n
for i, x in enumerate(nums):
res[i] *= l
res[n - i - 1] *= r
l *= x
r *= nums[n - i - 1]
return res
逐行解读这段代码的执行逻辑：
l = r = 1，分别代表「从左到右」和「从右到左」的累积乘积。res 全为 1 作为初始值。res[i] *= l：将 i 位置乘上它左边所有元素的累积积res[n - i - 1] *= r：将对称位置 n-i-1 乘上它右边所有元素的累积积l *= x：把当前元素 x 纳入左边的累积r *= nums[n - i - 1]：把对称位置的元素纳入右边的累积res[i] 恰好被乘上了「左边累积 × 右边累积」，即除自身之外的乘积。🧠 直觉理解：想象你从数组两端同时出发。
l是你从左边一路捡起的元素的乘积，每到一个新位置，先把这个位置的结果乘上l（这是「我左边的东西」），然后再把当前元素「装进」l给后面的位置用。r从右边做同样的事。两个方向在一次循环中交错推进，互不干扰，因为它们操作的是数组的两个不同位置。
以 nums = [1, 2, 3, 4] 为例，追踪 l、r 和 res 的变化：
i |
x |
n-i-1 |
操作前 res |
l (操作前) |
r (操作前) |
操作后 res |
l (操作后) |
r (操作后) |
|---|---|---|---|---|---|---|---|---|
| — | — | — | [1, 1, 1, 1] |
1 |
1 |
— | — | — |
| 0 | 1 |
3 | [1, 1, 1, 1] |
1 |
1 |
[1, 1, 1, 1] |
1 |
4 |
| 1 | 2 |
2 | [1, 1, 1, 1] |
1 |
4 |
[1, 1, 4, 1] |
2 |
12 |
| 2 | 3 |
1 | [1, 1, 4, 1] |
2 |
12 |
[1, 12, 8, 1] |
6 |
24 |
| 3 | 4 |
0 | [1, 12, 8, 1] |
6 |
24 |
[24, 12, 8, 6] |
24 |
24 |
最终 res = [24, 12, 8, 6]，正是答案。
⚠️ 注意：
l在当前位置被用来更新res[i]之后才乘上x。这个顺序很关键——确保l始终代表「不含当前元素的左边乘积」。r同理。
对于位置 i，在循环的某一轮中：
i 作为「左指针」被处理时，l 包含了 nums[0..i-1] 的乘积，所以 res[i] 被正确地乘上了左边部分n-i-1 等于 i（即左右指针相遇），r 包含了 nums[i+1..n-1] 的乘积，所以 res[i] 被正确地乘上了右边部分因此，当循环结束时，每个 res[i] 都恰好被乘上了它左边和右边的所有元素——不多不少。
l、r 两个变量。$O(n)$ 时间已是最优——因为输出结果需要为 $n$ 个位置分别计算，至少需要遍历一次数组。
| 对比项 | 左右数组法 | 两次遍历法 | 单次双指针法 |
|---|---|---|---|
| 遍历次数 | 3 次 | 2 次 | 1 次 |
| 额外空间 | $O(n)$ | $O(1)$ | $O(1)$ |
| 代码行数 | ~12 行 | ~11 行 | ~9 行 |
| 可读性 | ⭐⭐⭐⭐⭐（最直观） | ⭐⭐⭐⭐ | ⭐⭐⭐（需理解双指针交错逻辑） |
| 推荐场景 | 面试中先展示思路 | 面试中优化后的标准解 | 追求极简和 Pythonic |
三种写法的时间复杂度均为 $O(n)$，差异在于常数因子和代码风格。面试中建议从「左右数组法」讲起，展示清晰的思维递进过程，最后落地到「两次遍历法」或「单次双指针法」。
💡 面试建议：面试官更看重你的思维过程而非最终代码。先说「我们需要前缀积和后缀积」，用左右数组法写出第一版，再逐步优化——这个过程本身就能展现你的问题分解和优化能力。
nums 中可能包含 0（如示例2 [-1, 1, 0, -3, 3]），但上述算法天然能正确处理——因为前缀积会正常累积 0，后缀积同理。唯一需要注意的是：如果题目不保证乘积在 32 位范围内（本题保证了），可能需要考虑溢出问题。
「除自身以外数组的乘积」的核心在于将问题拆解为两个独立维度——前缀积和后缀积——然后合并。这个思维模式在数组问题中非常经典：
🧠 核心收获：当你遇到「除了某个元素之外的所有元素」这种问题时，第一反应就应该是——把这个元素从中间"挖掉"，然后分别看它的左边和右边。前缀 + 后缀的组合模式能帮你把看似需要 $O(n^2)$ 的问题降到 $O(n)$。
解决本题后，推荐挑战以下延伸题目——它们都涉及「前缀 + 后缀」或「预处理 + 合并」的思想：
给你一个未排序的整数数组 nums，请你找出其中没有出现的最小的正整数。
请你实现时间复杂度为 $O(n)$ 并且只使用常数级别额外空间的解决方案。
未排序的整数数组 nums
没有出现的最小正整数
1 <= nums.length <= 10^5-2^31 <= nums[i] <= 2^31 - 1实现时间复杂度 $O(n)$ 且空间复杂度 $O(1)$ 的解法。
输入：nums = [1,2,0]
输出：3
解释：范围 [1,2] 中的数字都在数组中，因此缺失的最小正整数是 3。
输入：nums = [3,4,-1,1]
输出：2
解释：1 在数组中，但 2 缺失，因此答案是 2。
输入：nums = [7,8,9,11,12]
输出：1
解释：最小的正整数 1 缺失，因此答案是 1。
题目要求找「缺失的第一个正整数」——对于长度为 $n$ 的数组，答案一定在 $[1, n+1]$ 这个范围内。为什么？因为：
💡 核心直觉：我们只需要关心 $[1, n]$ 范围内的数。如果能把每一个 $x \in [1, n]$ "放到它该在的位置"（即下标 $x-1$ 处），那么第一个"位置不对"的索引就揭示了缺失的正整数。
最朴素的想法：从 $1$ 开始逐个检查每个正整数是否在数组中：
class Solution:
def firstMissingPositive(self, nums: List[int]) -> int:
s = set(nums)
x = 1
while x in s:
x += 1
return x
虽然时间复杂度已是最优，但空间复杂度为 $O(n)$，不满足进阶要求。有没有办法把空间降到 $O(1)$？
瓶颈分析：暴力法额外建了一个哈希集合来支持快速查找。如果能原地利用数组本身作为"哈希表"，就不需要额外空间了。
关键的洞察是：数组的下标天然就是连续的整数 $0, 1, 2, \dots, n-1$。如果我们能让数组满足 nums[i] = i + 1（即下标 i 处存放值 i+1），那么数组本身就隐含了一个"集合"——要判断 $x$ 是否出现，只需要看 nums[x-1] 是否等于 $x$。
🧠 直觉理解：想象你在整理一排有编号的储物柜。你有一堆写着号码的包裹，你希望每个包裹
x被放进编号为x的柜子里。如果你按照这个规则逐个整理包裹，那么最终"柜子是空的"或"柜子里放的号码不对"的位置，就告诉你哪个正整数缺席了。
具体来说，分两步走：
第一步：重新摆放（交换）
遍历数组，对于每个位置 i，如果 nums[i] 在 $[1, n]$ 范围内，并且它不在"正确的"位置上（即 nums[i] != nums[nums[i] - 1]），就把它和它"该去的位置"上的元素交换。重复这个过程直到当前位置无法再交换为止。
这里用 while 而不是 if 很关键——交换过来的新元素可能也在 $[1, n]$ 范围内，需要继续为它寻找正确位置：
for i in range(n):
while 1 <= nums[i] <= n and nums[i] != nums[nums[i] - 1]:
nums[nums[i] - 1], nums[i] = nums[i], nums[nums[i] - 1]
第二步：寻找缺失
交换完成后，再遍历一次数组。第一个不满足 nums[i] == i + 1 的位置就对应着缺失的正整数：
for i in range(n):
if nums[i] != i + 1:
return i + 1
return n + 1
以 nums = [3, 4, -1, 1]（$n=4$）为例，追踪交换过程：
| 轮次 | i |
交换前数组 | nums[i] |
目标位置 | 交换后数组 | 说明 |
|---|---|---|---|---|---|---|
| — | — | — | — | — | [3, 4, -1, 1] |
初始状态 |
| 1 | 0 | [3, 4, -1, 1] |
3 |
nums[2] |
[-1, 4, 3, 1] |
3 和 nums[2] = -1 交换 |
| 1 | 0 | [-1, 4, 3, 1] |
-1 |
— | 不变 | -1 不在 [1,4] 内，停止 |
| 2 | 1 | [-1, 4, 3, 1] |
4 |
nums[3] |
[-1, 1, 3, 4] |
4 和 nums[3] = 1 交换 |
| 2 | 1 | [-1, 1, 3, 4] |
1 |
nums[0] |
[1, -1, 3, 4] |
1 和 nums[0] = -1 交换 |
| 2 | 1 | [1, -1, 3, 4] |
-1 |
— | 不变 | -1 不在 [1,4] 内，停止 |
| 3 | 2 | [1, -1, 3, 4] |
3 |
nums[2] |
不变 | nums[2] 已经是 3，跳过 |
| 4 | 3 | [1, -1, 3, 4] |
4 |
nums[3] |
不变 | nums[3] 已经是 4，跳过 |
交换结束后，数组变为 [1, -1, 3, 4]。遍历检查：
i=0: nums[0]=1 ✅i=1: nums[1]=-1 ≠ 2 ❌ → 返回 2答案正是 2。
⚠️ 注意：交换条件中
nums[i] != nums[nums[i] - 1]不能写成nums[i] != i + 1。考虑[1, 1]这种情况——nums[0]=1已经在正确位置，但nums[1]=1与nums[1-1]=nums[0]=1相同，如果只用nums[i] != i + 1作为条件会陷入死循环（一直在原地交换相同的两个 1）。
while 循环，但每个数最多被交换一次到正确位置，总交换次数不超过 $n$ 次。💡 为什么时间复杂度不是 $O(n^2)$？ 外层循环 $n$ 次，内层的
while看似可以多轮交换，但每次交换至少让一个数去到它的最终位置。每个数一旦"落户"就不会再被移动（因为后续nums[i] != nums[nums[i]-1]条件不成立）。因此总交换操作 ≤ $n$ 次，整个算法仍是线性的。这种分析方法叫做均摊分析。
除了交换法，还有一种原地哈希的实现——用正负号做标记。
核心思想：第一遍遍历，对于每个 $x \in [1, n]$，将 nums[x-1] 标记为负数，表示"$x$ 出现过"。第二遍遍历，第一个正数的位置就对应缺失的正整数。
class Solution:
def firstMissingPositive(self, nums: List[int]) -> int:
n = len(nums)
# 第一步：将非正数设为 n+1（不影响后续标记）
for i in range(n):
if nums[i] <= 0:
nums[i] = n + 1
# 第二步：用负号做标记
for i in range(n):
x = abs(nums[i])
if 1 <= x <= n and nums[x - 1] > 0:
nums[x - 1] = -nums[x - 1]
# 第三步：找第一个正数
for i in range(n):
if nums[i] > 0:
return i + 1
return n + 1
这个方法同样满足 $O(n)$ 时间和 $O(1)$ 空间，但它修改了数组中元素的符号，且需要恢复或接受破坏。相比而言，交换法更直观——数组的最终状态就是"整理好的柜子"，不需要额外的"负号"语义。
| 对比项 | 交换法 | 标记法 |
|---|---|---|
| 核心操作 | 交换元素到正确位置 | 用负号标记出现过的数 |
| 数组最终状态 | 部分有序（nums[i]=i+1 或不在范围内的数） |
元素可能被取反，需要 abs() 恢复 |
| 可读性 | ⭐⭐⭐⭐ | ⭐⭐⭐ |
| 稳定性 | 不改变元素绝对值 | 改变了元素符号 |
class Solution:
def firstMissingPositive(self, nums: List[int]) -> int:
n = len(nums)
for i in range(n):
while 1 <= nums[i] <= n and nums[i] != nums[nums[i] - 1]:
nums[nums[i] - 1], nums[i] = nums[i], nums[nums[i] - 1]
for i in range(n):
if nums[i] != i + 1:
return i + 1
return n + 1
逐行解读：
n = len(nums)：数组长度。答案的范围锁定在 $[1, n+1]$。for i in range(n)：遍历每个位置，尝试让该位置存放正确的数。while 1 <= nums[i] <= n and nums[i] != nums[nums[i] - 1]：
1 <= nums[i] <= n：只关心 $[1, n]$ 范围内的数，非正数和大于 $n$ 的数可以留在原地nums[i] != nums[nums[i] - 1]：当前数不在它该在的位置上（避免重复交换导致死循环）nums[nums[i] - 1], nums[i] = nums[i], nums[nums[i] - 1]——Python 的元组解包一次性完成交换，不需要临时变量nums[i] != i + 1 的位置，说明 i+1 缺失，直接返回return n + 1：所有位置都正确，说明 $[1, n]$ 全部出现，返回 $n+1$⚠️ 交换语句的顺序要留意：
nums[nums[i] - 1], nums[i] = nums[i], nums[nums[i] - 1]是正确的。如果写成nums[i], nums[nums[i] - 1] = nums[nums[i] - 1], nums[i]，Python 会先计算右侧，再从左到右赋值——这时nums[i]先被修改，后续nums[nums[i] - 1]中的nums[i]已经变了，导致赋值到错误的位置。所以务必把nums[nums[i] - 1]放在赋值语句的左侧第一位。
「缺失的第一个正数」教会我们一个重要的思维：将数组的索引视为哈希表的键。
🧠 核心收获：当你需要在 $O(1)$ 空间内做「存在性检查」时，考虑原地哈希——把数组本身当哈希表用。前提是你能建立「元素值 → 数组下标」的映射关系。本题中映射关系是 $x \to x-1$，恰到好处。
这个技巧在很多题目中都有类似的应用：
给你一个 $m \times n$ 的二维二进制数组 grid 和一个整数 health。
你从左上角 $(0, 0)$ 出发，目标是到达右下角 $(m-1, n-1)$。每次可以向上、下、左、右四个方向之一移动。
grid[i][j] = 0 的格子是安全的，不消耗健康值；grid[i][j] = 1 的格子是危险的，消耗 1 点健康值。返回是否能在健康值始终为正（即到达终点时健康值 $\ge 1$）的前提下到达终点。
grid：$m \times n$ 的二进制矩阵（元素值为 0 或 1）health：初始健康值（整数）bool：能否安全到达终点m == grid.lengthn == grid[i].length1 <= m, n <= 502 <= m * n1 <= health <= m + ngrid[i][j] 为 0 或 1输入: grid = [[0,1,0,0,0],[0,1,0,1,0],[0,0,0,1,0]], health = 1
输出: true
解释：可以沿着如下路径（沿值为 0 的格子）安全到达终点，不消耗任何健康值，终点时健康值仍为 1。
输入: grid = [[0,1,1,0,0,0],[1,0,1,0,0,0],[0,1,1,1,0,1],[0,0,1,0,1,0]], health = 3
输出: false
解释：从起点到终点至少需要消耗 4 点健康值，初始 health = 3 不足以到达。
输入: grid = [[1,1,1],[1,0,1],[1,1,1]], health = 5
输出: true
解释：经过中间的安全格子 (1, 1)，累计消耗为 4，终点时健康值为 5 - 4 = 1，满足条件。
问题本质是：在网格中寻找一条从起点到终点的路径，使得路径上所有格子的值之和（总消耗）严格小于初始健康值。这是一个典型的最短路径问题——每条边的权重就是目标格子的值（0 或 1），我们要找累计权重最小的路径。
🧠 直觉理解：把
grid想象成一片沼泽地——值为0的格子是硬路面（不费体力），值为1的格子是泥潭（每踩一脚耗 1 点体力）。问题等价于：从左上走到右下，能否在体力耗尽前到达？
最直接的想法：用 DFS 枚举所有可能的路径，沿途累加消耗，到达终点时检查是否小于 health：
class Solution:
def findSafeWalk(self, grid: List[List[int]], health: int) -> bool:
m, n = len(grid), len(grid[0])
visited = [[False] * n for _ in range(m)]
def dfs(x: int, y: int, cost: int) -> bool:
if x == m - 1 and y == n - 1:
return cost < health
visited[x][y] = True
for a, b in (x, y + 1), (x, y - 1), (x + 1, y), (x - 1, y):
if 0 <= a < m and 0 <= b < n and not visited[a][b]:
new_cost = cost + grid[a][b]
if new_cost < health: # 剪枝：已经超过 health 就不必继续
if dfs(a, b, new_cost):
return True
visited[x][y] = False
return False
return dfs(0, 0, grid[0][0])
这种做法的时间复杂度是指数级的——每个格子都可能被多次访问，最坏情况下需要遍历所有 $4^{mn}$ 条可能的路径。在 $m, n \le 50$ 时完全不可行。但暴力解揭示了一件重要的事：我们只关心到达每个格子的「最小累计消耗」，而不是路径本身。
将每个格子视为图中的节点，相邻格子的移动视为有向边，边的权重等于目标格子的值 grid[a][b]。那么「到达终点的最小健康消耗」就是从起点 $(0, 0)$ 到终点 $(m-1, n-1)$ 的最短路径权重。
因为边权只有 0（安全格子）和 1（危险格子）两种，经典的 0-1 BFS 正好适用。
💡 小贴士：0-1 BFS 是 Dijkstra 算法在边权仅为 0 或 1 时的特化版本——用双端队列（deque）代替优先队列，将时间复杂度从 $O(V \log V)$ 优化到 $O(V)$。核心技巧：遇到权重
0的边，将新节点插入队首（优先处理）；遇到权重1的边，插入队尾。
维护一个距离矩阵 d[i][j]，表示从起点 $(0, 0)$ 到 $(i, j)$ 的最小累计消耗，初始化为无穷大，起点处 d[0][0] = grid[0][0]。
每次从 deque 前端取出一个格子 $(x, y)$，检查它的四个邻居 $(a, b)$：
grid[a][b] == 0（零消耗边），插入队首 → 下轮优先处理，确保同等消耗的格子被连续探索grid[a][b] == 1（单位消耗边），插入队尾 → 等当前消耗层级处理完后再处理⚠️ 注意：0-1 BFS 要求从 deque 前端取出节点（
popleft），因为appendleft会打乱 BFS 层级顺序。这个细节决定了算法正确性——如果错误地从后端取出，就退化成了普通队列 BFS，无法保证最优。
以示例 1 的网格为例追踪算法执行（health = 1）：
grid:
[0, 1, 0, 0, 0]
[0, 1, 0, 1, 0]
[0, 0, 0, 1, 0]
| 步骤 | 出队 (x,y) |
d[x][y] |
更新的邻居 | 新 d 值 |
入队位置 |
|---|---|---|---|---|---|
| 0 | — | — | 初始化 | d[0][0]=0 |
队尾 (0,0) |
| 1 | (0,0) |
0 | (1,0) cost=0 |
d[1][0]=0 |
队首 |
(0,1) cost=1 |
d[0][1]=1 |
队尾 | |||
| 2 | (1,0) |
0 | (2,0) cost=0 |
d[2][0]=0 |
队首 |
| 3 | (2,0) |
0 | (2,1) cost=0 |
d[2][1]=0 |
队首 |
| 4 | (2,1) |
0 | (2,2) cost=0 |
d[2][2]=0 |
队首 |
(1,1) cost=1 |
d[1][1]=1 |
队尾 | |||
| 5 | (2,2) |
0 | (2,3) cost=1 |
d[2][3]=1 |
队尾 |
(1,2) cost=0 |
d[1][2]=0 |
队首 | |||
| 6 | (1,2) |
0 | (0,2) cost=0 |
d[0][2]=0 |
队首 |
| 7 | (0,2) |
0 | (0,3) cost=0 |
d[0][3]=0 |
队首 |
| 8 | (0,3) |
0 | (0,4) cost=0 |
d[0][4]=0 |
队首 |
| 9 | (0,4) |
0 | (1,4) cost=0 |
d[1][4]=0 |
队首 |
| 10 | (1,4) |
0 | (2,4) cost=0 |
d[2][4]=0 |
队首 |
最终 d[2][4] = 0 < health = 1，返回 True。整个过程队列始终优先处理 cost=0 的邻居，确保找到的路径是最优的。
d 值的范围极小——每个格子只会被更新 $O(1)$ 次）d 和 deque 的最大长度from collections import deque
from math import inf
from typing import List
class Solution:
def findSafeWalk(self, grid: List[List[int]], health: int) -> bool:
m, n = len(grid), len(grid[0])
d = [[inf] * n for _ in range(m)]
d[0][0] = grid[0][0]
q = deque([(0, 0)])
while q:
x, y = q.popleft()
for a, b in (x, y + 1), (x, y - 1), (x + 1, y), (x - 1, y):
if 0 <= a < m and 0 <= b < n:
if d[x][y] + grid[a][b] < d[a][b]:
d[a][b] = d[x][y] + grid[a][b]
if not grid[a][b]:
q.appendleft((a, b))
else:
q.append((a, b))
return d[-1][-1] < health
代码的几个关键点：
d[i][j] 初始化为 inf，确保任何真实路径都能首次更新它d[0][0] = grid[0][0]：起点的格子值也算入消耗grid[a][b] 为 0 时 appendleft（优先处理），为 1 时 append（延后处理）d[-1][-1] < health：消耗必须严格小于初始健康值，因为到达终点时健康值需 $\ge 1$如果网格中的值不是仅限 0/1 而是任意非负整数，0-1 BFS 就无法直接使用了。此时需要用通用的 Dijkstra 算法——用小顶堆（优先队列）维护「当前已知的到各格子的最短距离」，每次取出距离最小的节点进行松弛。
from heapq import heappop, heappush
from math import inf
class Solution:
def findSafeWalk(self, grid: List[List[int]], health: int) -> bool:
m, n = len(grid), len(grid[0])
d = [[inf] * n for _ in range(m)]
d[0][0] = grid[0][0]
pq = [(d[0][0], 0, 0)] # (cost, x, y)
while pq:
cost, x, y = heappop(pq)
if cost > d[x][y]:
continue # 过期数据，跳过
if x == m - 1 and y == n - 1:
return cost < health
for a, b in (x, y + 1), (x, y - 1), (x + 1, y), (x - 1, y):
if 0 <= a < m and 0 <= b < n:
new_cost = cost + grid[a][b]
if new_cost < d[a][b]:
d[a][b] = new_cost
heappush(pq, (new_cost, a, b))
return False
| 对比项 | 0-1 BFS | Dijkstra |
|---|---|---|
| 时间 | $O(mn)$ | $O(mn \log(mn))$ |
| 空间 | $O(mn)$ | $O(mn)$ |
| 数据结构 | 双端队列 deque |
小顶堆 heapq |
| 适用场景 | 边权仅 $0$ 或 $1$ | 边权为任意非负整数 |
| 代码简洁度 | 稍简洁 | 也较简洁 |
本题 grid 的值只有 0 和 1，0-1 BFS 是最优选择。Dijkstra 也能过（$50 \times 50 = 2500$ 个节点，$\log$ 开销很小），但面试中展示 0-1 BFS 能体现对边权特殊性质的洞察。
0-1 BFS 已经是本题的最优算法，以下聚焦于工程细节。
一旦从 deque 中取出的节点是终点 (m-1, n-1)，d[m-1][n-1] 已经是最小消耗——因为 0-1 BFS 保证节点首次出队时 d 值即为最短距离（类似 Dijkstra）。可以直接返回而不必跑完整个 BFS：
while q:
x, y = q.popleft()
if x == m - 1 and y == n - 1:
return d[x][y] < health
for a, b in (x, y + 1), (x, y - 1), (x + 1, y), (x - 1, y):
...
将四个方向的偏移量提取为常量，减少 for 循环中的元组构造开销（微优化，但对竞赛场景有意义）：
DIRS = [(0, 1), (0, -1), (1, 0), (-1, 0)]
...
for dx, dy in DIRS:
a, b = x + dx, y + dy
...
from collections import deque
from math import inf
class Solution:
def findSafeWalk(self, grid: List[List[int]], health: int) -> bool:
m, n = len(grid), len(grid[0])
d = [[inf] * n for _ in range(m)]
d[0][0] = grid[0][0]
q = deque([(0, 0)])
DIRS = [(0, 1), (0, -1), (1, 0), (-1, 0)]
while q:
x, y = q.popleft()
if x == m - 1 and y == n - 1:
return d[x][y] < health
for dx, dy in DIRS:
a, b = x + dx, y + dy
if 0 <= a < m and 0 <= b < n:
nd = d[x][y] + grid[a][b]
if nd < d[a][b]:
d[a][b] = nd
if grid[a][b]:
q.append((a, b))
else:
q.appendleft((a, b))
return False
| 写法 | 优点 | 场景 |
|---|---|---|
| 原版（全遍历后判断） | 最简洁，逻辑直白 | 日常刷题、不追求极致性能 |
| 提前返回版 | 大多数情况能提前结束 | 网格较大、终点附近安全格子多时 |
| 方向数组版 | 常数优化，扩展性好 | 竞赛、八方向变体等扩展场景 |
本题 $m, n \le 50$，三种写法的实际运行时间差异在毫秒级，选择自己最熟悉的即可。
]]>以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [start_i, end_i]。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。
二维整数数组 intervals，每个元素是 [start_i, end_i] 表示一个区间
合并重叠后的区间数组
1 <= intervals.length <= 10^4intervals[i].length == 20 <= start_i <= end_i <= 10^4输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠，将它们合并为 [1,6]。
输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 在端点 4 处相接，视为重叠区间，合并为 [1,5]。
这道题的核心是判断两个区间是否重叠，以及如何高效地将重叠的区间合并。两个区间 $[a, b]$ 和 $[c, d]$ 重叠的充要条件是：
$$a \le d \quad \text{且} \quad c \le b$$
换句话说——只要一个区间的起点不超过另一个区间的终点，它们就有交集。合并后的区间就是 $[\min(a,c),\ \max(b,d)]$。
💡 一句话概括：把区间按起点排序，然后从左到右扫描——当前区间能和上一个合并就合并，不能就"封存"上一个，开始一个新的。
最朴素的想法是：反复扫描所有区间对，发现重叠就合并，合并后重新扫描，直到没有任何区间可以合并为止：
class Solution:
def merge(self, intervals: List[List[int]]) -> List[List[int]]:
if not intervals:
return []
res = []
used = [False] * len(intervals)
for i in range(len(intervals)):
if used[i]:
continue
l, r = intervals[i]
# 反复扫描，不断扩展当前区间，直到无法再扩展
changed = True
while changed:
changed = False
for j in range(len(intervals)):
if used[j]:
continue
a, b = intervals[j]
if a <= r and l <= b: # 发现重叠
l = min(l, a)
r = max(r, b)
used[j] = True
changed = True
res.append([l, r])
return res
以每个未合并区间为起点，反复扫描剩余区间并不断吞并重叠者。最坏情况下（区间呈"链式重叠"，每次只合并一个），复杂度达到 $O(n^2)$。
瓶颈分析：暴力法花了大量时间在"寻找与当前区间重叠的下一个区间"上——区间是无序的，每次都要全量扫描。如果能让区间按某种顺序排列，使得可能重叠的区间彼此相邻，一次从左到右的扫描就能完成所有合并。
🧠 直觉理解：想象你面前有一堆纸条，每张纸条写着起止时间，散乱地摊在桌上。暴力法是你随手拿起一张，然后翻遍全桌找能和它接上的——找到一张接一张，接不上了再换下一张。如果先把纸条按起始时间从左到右排好，你会发现——能合并的纸条一定彼此相邻，从左到右一趟就能全部处理完。
将所有区间按起点升序排序后，一个关键性质浮出水面：
性质：排序后，如果当前区间 $[x, y]$ 不能与前面正在合并的区间 $[l, r]$ 合并（即 $x > r$），那么后面所有的区间也不可能与 $[l, r]$ 合并——因为后面的起点只会更大。
这意味着我们可以用"甩手掌柜"的方式处理：维护一个"当前正在合并"的区间 $[l, r]$，从左到右扫描每个区间——
扫描结束后，别忘了把最后一个 $[l, r]$ 也存进去。
class Solution:
def merge(self, intervals: List[List[int]]) -> List[List[int]]:
intervals.sort() # 按起点排序
res = []
l, r = intervals[0] # 当前正在合并的区间
for x, y in intervals:
if x <= r: # 重叠：扩展右边界
r = max(r, y)
else: # 不重叠：封存当前区间，开启新区间
res.append([l, r])
l, r = x, y
res.append([l, r]) # 封存最后一个区间
return res
⚠️ 注意：
intervals.sort()对二元列表默认按第一个元素排序，第一个相同时按第二个元素排序。这里我们只需要按起点排序，intervals.sort()刚好满足。如果面试官要求显式表达，可以写成intervals.sort(key=lambda x: x[0])。
以 intervals = [[1,3],[2,6],[8,10],[15,18]] 为例（排序后不变）：
| 步骤 | 当前 [x,y] |
l |
r |
判断 | 操作 | res |
|---|---|---|---|---|---|---|
| 初始 | — | 1 | 3 | — | — | [] |
| 1 | [1,3] |
1 | 3 | 1 ≤ 3 |
r = max(3, 3) = 3（无变化） |
[] |
| 2 | [2,6] |
1 | 3 | 2 ≤ 3 |
r = max(3, 6) = 6 |
[] |
| 3 | [8,10] |
1 | 6 | 8 > 6 |
保存 [1, 6]，新 l=8, r=10 |
[[1,6]] |
| 4 | [15,18] |
8 | 10 | 15 > 10 |
保存 [8,10]，新 l=15, r=18 |
[[1,6],[8,10]] |
| 结束 | — | 15 | 18 | — | 保存 [15,18] |
[[1,6],[8,10],[15,18]] |
💡 小贴士：注意步骤 1——
l, r由intervals[0]初始化，然后for循环再次遍历到了intervals[0]。此时x = l且y = r，所以x ≤ r恒成立，r = max(r, y)不改变任何值，属于一次"空操作"。这一步看似多余，但它让循环逻辑保持统一——所有区间（包括第一个）都经过同一套判断逻辑，代码更简洁，且 $O(1)$ 的额外开销完全可以忽略。
再来看示例 2 [[1,4],[4,5]]，端点相接的情况：
| 步骤 | 当前 [x,y] |
l |
r |
判断 | 操作 |
|---|---|---|---|---|---|
| 初始 | — | 1 | 4 | — | — |
| 1 | [1,4] |
1 | 4 | 1 ≤ 4 |
r = max(4, 4) = 4 |
| 2 | [4,5] |
1 | 4 | 4 ≤ 4 |
r = max(4, 5) = 5 |
| 结束 | — | 1 | 5 | — | 保存 [1,5] |
关键在步骤 2：判断条件 x ≤ r 即 4 ≤ 4 成立，因此 [4,5] 被视为与 [1,4] 重叠。这正是题目要求的——端点相接也算重叠。
排序后从左到右扫描，每次遇到不重叠的区间就"封存"当前——为什么这样不会错过更优的合并方式？
🧠 直觉理解：排序保证了区间的起点是单调递增的。假设当前合并区间 $[l, r]$ 与某个后面的区间 $[x, y]$ 不重叠（即 $x > r$），那 $[x, y]$ 之后的所有区间起点 $\ge x > r$，更不可能与 $[l, r]$ 重叠。所以此时"封存"$[l, r]$ 一定是安全的——它已经"长到最大了"，不会再被任何后续区间扩展。
res），或 $O(n)$（计入输出）。仅使用了 l、r 两个额外变量。$O(n \log n)$ 已是理论最优——因为区间合并问题至少需要排序，而比较排序的下界就是 $O(n \log n)$。如果输入本身已按起点有序（如某些变体题目的设定），则可做到 $O(n)$。
⚠️ 注意：Python 的
list.sort()是原地排序，空间复杂度为 $O(1)$（TimSort 的临时空间为 $O(n)$ 但通常不计入）。如果你不希望修改输入数组，可以sorted(intervals)代替，但空间变为 $O(n)$。
l, r vs res[-1]上面使用了 l, r 两个变量追踪正在合并的区间。另一种常见写法是直接在结果数组的最后一个区间上操作：
class Solution:
def merge(self, intervals: List[List[int]]) -> List[List[int]]:
intervals.sort()
res = [intervals[0]]
for x, y in intervals[1:]:
if x <= res[-1][1]:
res[-1][1] = max(res[-1][1], y)
else:
res.append([x, y])
return res
两种写法的对比：
| 对比项 | l, r 变量 |
res[-1] 操作 |
|---|---|---|
| 可读性 | ⭐⭐⭐⭐ 变量名直观 | ⭐⭐⭐ [-1] 需要一点适应 |
| 简洁度 | ⭐⭐⭐ 需要尾部 append |
⭐⭐⭐⭐⭐ 循环结束即完成 |
| 避免浅拷贝问题 | ✅ 直接用 l, r |
⚠️ 修改 res[-1][1] 是原地修改，恰好安全 |
| 适用场景 | 适合讲解、教学 | 适合生产、竞赛 |
l, r 版本的好处是思路更清晰——"我正在合并一个区间，还没想好要不要放进结果"。res[-1] 版本的好处是代码更紧凑——边界处理被 res 初始化吃掉，循环从 intervals[1:] 开始，省去了尾部的那句 res.append([l, r])。
💡 小贴士：在面试中建议先写出
l, r版本，把思路讲清楚；如果面试官要求更简洁，再优化到res[-1]版本。一上来就甩出res[-1]可能会让面试官觉得你在背模板。
intervals.sort() vs intervals.sort(key=lambda x: x[0])两种写法在本题中完全等价——因为 Python 的列表比较是按元素顺序逐个比较的：
[1, 3] < [2, 6] 先比第一个元素 1 < 2，结果为 True，不再比第二个[1, 3] < [1, 4] 第一个相等 1 == 1，比第二个 3 < 4这意味着 intervals.sort() 等价于 "按起点排序，起点相同时按终点排序"。而题目只需要按起点排序——起点相同时按终点排不排都不影响正确性，但恰好也能正常工作。
显式写成 key=lambda x: x[0] 的好处是意图表达更明确，但性能上反而略慢（多了 lambda 调用开销）。两种写法都可以，看个人偏好。
虽然约束条件保证 n >= 1，但在工程实践中防御式编程不会错：
class Solution:
def merge(self, intervals: List[List[int]]) -> List[List[int]]:
if not intervals:
return []
# ...
如果约束真的可能为 0，intervals[0] 会在初始化 l, r 时抛出 IndexError。
「合并区间」是贪心算法的经典入门题。它的核心技巧只有三步：
这个"排序 + 一次扫描"的模式广泛适用于一大类区间问题。掌握了它，下面这些题目你会觉得似曾相识：
]]>🧠 核心收获：区间问题八成从排序入手，排序后重叠的区间会"挤在一起"，剩下的就是设计贪心扫描逻辑。别被题面吓到，先问自己——"如果区间已经排好序了，怎么做？"
给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
整数数组 nums 和非负整数 k
原地修改 nums，将其向右轮转 k 步
1 <= nums.length <= 10^5-2^31 <= nums[i] <= 2^31 - 10 <= k <= 10^5输入：nums = [1,2,3,4,5,6,7], k = 3
输出：[5,6,7,1,2,3,4]
解释：
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]
输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释：
向右轮转 1 步: [99,-1,-100,3]
向右轮转 2 步: [3,99,-1,-100]
向右轮转 k 步，本质上是把数组末尾的 k 个元素"搬"到数组开头。最直接的想法是——创建一个新数组，把每个元素放到它该去的位置。
💡 一句话概括：轮转数组有三种经典解法——额外数组（最直观）、环状替换（最巧妙）、三次反转（最优雅）。其中三次反转法代码最短、最容易写对，是面试的首选。
最简单的思路：创建一个新数组 ans，将 nums[i] 放到 ans[(i + k) % n] 的位置，最后把新数组拷贝回 nums：
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
n = len(nums)
k %= n # 处理 k >= n 的情况
ans = [0] * n
for i in range(n):
ans[(i + k) % n] = nums[i]
nums[:] = ans # 拷贝回原数组
⚠️ 注意：
k %= n这一行很关键。当k >= n时（如k = 10, n = 7），轮转k步等价于轮转k % n = 3步。虽然不取模的话(i + k) % n也能算出正确位置，但轮转超过一整圈纯属浪费。
这里用 nums[:] = ans 而不是 nums = ans——前者修改列表的内容（原地替换），后者只是让局部变量 nums 指向新列表（不会影响函数外部的原数组）。
瓶颈分析：这个方法需要 $O(n)$ 的额外空间。$n \le 10^5$ 时，$10^5$ 个整数的数组大约占 800KB——可以通过，但进阶要求挑战 $O(1)$ 空间。
🧠 直觉理解：创建新数组就像搬家时先把所有家具搬到临时仓库，再按新布局搬回去——稳，但需要两倍的空间。能不能直接在原地"挪"家具？
这是本题最优雅的解法。将 nums 向右轮转 k 步，等价于以下三步：
k 个元素跑到开头（此时是逆序的），开头的 n-k 个元素跑到末尾（同样逆序）k 个元素——恢复它们原本的顺序n-k 个元素——恢复它们原本的顺序用数学语言描述：设原数组为 $A$，目标是将 $A$ 变为 $A[n-k:] + A[:n-k]$。注意到：
$$\text{reverse}(A)[:k] = \text{reverse}(A[n-k:])$$ $$\text{reverse}(A)[k:] = \text{reverse}(A[:n-k])$$
因此 $\text{reverse}(\text{reverse}(A)[:k]) + \text{reverse}(\text{reverse}(A)[k:]) = A[n-k:] + A[:n-k]$，恰好是目标结果。
以 nums = [1, 2, 3, 4, 5, 6, 7], k = 3 为例：
| 步骤 | 操作 | 数组状态 |
|---|---|---|
| 初始 | — | [1, 2, 3, 4, 5, 6, 7] |
| 1 | nums.reverse() —— 反转整个数组 |
[7, 6, 5, 4, 3, 2, 1] |
| 2 | 反转前 k=3 个元素 [7, 6, 5] |
[5, 6, 7, 4, 3, 2, 1] |
| 3 | 反转后 n-k=4 个元素 [4, 3, 2, 1] |
[5, 6, 7, 1, 2, 3, 4] ✅ |
步骤 1 之后发生了什么？原本在末尾的 [5, 6, 7] 被翻到了开头（变成 [7, 6, 5]），原本在开头的 [1, 2, 3, 4] 被翻到了末尾（变成 [4, 3, 2, 1]）。此时两段的位置已经正确了，只是各自内部是逆序的——于是步骤 2 和 3 各翻转一次，恢复原序。
🧠 直觉理解：想象你手里有一叠牌，要把最上面的 3 张挪到最下面。三次反转法就是——① 整叠牌翻个面 ② 前 3 张翻回来 ③ 剩下的翻回来。每张牌经过两次翻转，方向最终还是正的，但整体顺序已经发生了变化。
再以 nums = [-1, -100, 3, 99], k = 2 为例：
| 步骤 | 操作 | 数组状态 |
|---|---|---|
| 初始 | — | [-1, -100, 3, 99] |
| 1 | 反转整个数组 | [99, 3, -100, -1] |
| 2 | 反转前 k=2 个元素 [99, 3] |
[3, 99, -100, -1] |
| 3 | 反转后 n-k=2 个元素 [-100, -1] |
[3, 99, -1, -100] ✅ |
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
k %= len(nums)
nums.reverse()
nums[:] = nums[:k][::-1] + nums[k:][::-1]
逐行解释：
k %= len(nums)：处理 k >= n 的情况。当 k = n 时，轮转后数组不变；当 k > n 时，每 n 步回到原位，只需轮转 k % n 步。
nums.reverse()：反转整个数组。这是 Python 列表的原地方法，将数组首尾颠倒。
nums[:k][::-1]：取前 k 个元素（即原数组末尾 k 个元素的逆序），再 [::-1] 反转一次——恢复成原本的顺序。
nums[k:][::-1]：取后 n-k 个元素（即原数组开头 n-k 个元素的逆序），同样反转恢复原序。
nums[:] = ...：用全切片赋值，确保原地修改列表内容，而非创建新列表。
从索引的角度推导：设 $n = \text{len(nums)}$。原数组中位置 i 的元素，经过第一次整体反转后到了位置 $n - 1 - i$。然后：
k 个中），它会在步骤 2 中被再次翻转，最终位置是 $k - 1 - (n - 1 - i) = i + k - n$n-k 个中），它会在步骤 3 中被再次翻转，最终位置是 $(n - 1) - (n - 1 - i - k) = i + k$两种情况恰好对应了轮转 k 步后每个元素应有的位置。
💡 小贴士：索引推导虽然严谨，但不如画图直观。建议用纸笔跑一遍示例，比公式更容易理解。
nums.reverse() 是原地操作。nums[:k][::-1] 会创建 $O(k)$ 的临时列表，nums[k:][::-1] 会创建 $O(n-k)$ 的临时列表，但这些临时对象在赋值完成后立即被 GC 回收。若面试官要求严格的 $O(1)$，见下方"代码优化"章节的手动反转版本。除三次反转外，另一种 $O(1)$ 空间的原地算法是环状替换。思路是：从位置 0 开始，将 nums[0] 移到 nums[(0 + k) % n]，再将被挤走的元素移到它的目标位置，如此往复，直到回到起点。如果一轮环结束后还有元素未处理，从下一个位置开启新环。
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
n = len(nums)
k %= n
count = 0 # 已移动的元素个数
for start in range(n):
if count >= n: # 所有元素都已就位
break
cur = start
prev = nums[start]
while True:
nxt = (cur + k) % n
prev, nums[nxt] = nums[nxt], prev
cur = nxt
count += 1
if cur == start: # 回到起点，本轮环结束
break
外层循环 for start 恰好执行 $\gcd(n, k)$ 次——每个独立的环包含 $n / \gcd(n, k)$ 个元素。
💡 小贴士：环状替换的思路非常精妙，体现了置换群中"轮换分解"的思想。但实现时容易出错的点很多——何时停止、
prev的更新顺序、start的推进条件……相比之下，三次反转法几乎不会写错。
三种方法的对比：
| 对比项 | 额外数组 | 环状替换 | 三次反转 |
|---|---|---|---|
| 时间复杂度 | $O(n)$ | $O(n)$ | $O(n)$ |
| 空间复杂度 | $O(n)$ | $O(1)$ | $O(1)$ |
| 代码简洁度 | ⭐⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐⭐⭐ |
| 思维难度 | ⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐ |
| 容易写对 | ✅ | ⚠️ 容易出错 | ✅ |
🧠 面试建议：三种方法都值得了解，但如果只记一种——记三次反转。它代码最短、最不容易出错，且能自然扩展到"向左轮转"（先反转前
k个和后n-k个，再整体反转）。
用户代码中 nums[:k][::-1] 虽然简洁，但切片 [::-1] 会创建临时列表。如果面试官追问空间复杂度，可以手动实现区间反转：
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
n = len(nums)
k %= n
def reverse(l: int, r: int) -> None:
"""反转 nums[l:r]（左闭右开）"""
r -= 1
while l < r:
nums[l], nums[r] = nums[r], nums[l]
l += 1
r -= 1
reverse(0, n) # 反转整个数组
reverse(0, k) # 反转前 k 个
reverse(k, n) # 反转后 n-k 个
这个版本没有任何额外数组分配，空间复杂度严格为 $O(1)$。reverse 函数使用双指针交换，每对元素交换一次，总共 $n$ 次交换。
| 对比项 | nums[:k][::-1] |
reverse(0, k) |
|---|---|---|
| 空间复杂度 | $O(k)$（创建临时列表） | $O(1)$ |
| 代码行数 | 1 行 | 需要辅助函数 |
| Pythonic | ✅ 非常 Pythonic | ⭐ 更偏底层 |
| 适合场景 | 日常刷题、快速通过 | 面试官要求严格 $O(1)$ |
两种写法都是正确的，选择取决于场景。日常刷题用第一种（够简洁），面试建议先写第一种，然后主动提一句"如果需要严格 $O(1)$，可以手动实现子区间反转"——这会让面试官觉得你对细节有掌控力。
如果题目改为向左轮转 k 步，只需调整反转顺序：
# 向右轮转 k 步：整体反转 → 反转前 k → 反转后 n-k
reverse(0, n)
reverse(0, k)
reverse(k, n)
# 向左轮转 k 步：反转前 k → 反转后 n-k → 整体反转
reverse(0, k)
reverse(k, n)
reverse(0, n)
💡 小贴士：想不通为什么？"向右轮转 $k$ 步"等价于"向左轮转 $n-k$ 步"，把 $k$ 换成 $n-k$ 代入向右轮转的公式就清楚了。
「轮转数组」是数组操作的经典题目，它的核心在于理解"轮转"的等价变换——将末尾元素移到开头。
三种解法各有千秋：
🧠 核心收获：数组轮转 = 三次反转。这个技巧不仅适用于本题，在「反转字符串中的单词」（LeetCode 151）、「左旋转字符串」（剑指 Offer 58-II）等题目中也有类似的思路——先整体反转，再局部修正。
解决本题后，可以挑战以下延伸题目：
Kadane 算法是解决最大子数组和问题的经典算法，由 Jay Kadane 于 1984 年提出。它能在 $O(n)$ 时间、$O(1)$ 空间内找到数组中的最大连续子数组和。
它的核心代码极为简短：
def max_subarray(nums):
ans = float('-inf')
pre = 0
for x in nums:
pre = max(pre, 0) + x
ans = max(ans, pre)
return ans
寥寥几行，却浓缩了动态规划和贪心两种思想的精髓。接下来我们逐步拆解它背后的原理。
想象你是一个股民，每天都有盈亏。你需要在某一天买入、之后某一天卖出，获得最大收益——这就是著名的最大利润问题，本质上就是最大子数组和。
Kadane 算法的核心直觉可以浓缩为一句话：
💡 核心直觉：在遍历数组时，我们始终面临一个选择——是延续之前的累加（pre + x），还是重新开始（x）。做这个选择的依据很简单：如果之前的累加是正数，它对我们有帮助，保留它；如果之前的累加是负数或零，它只会拖后腿，丢弃它。
🧠 换个角度：一个负数的前缀，就像背着一个越来越重的包袱爬山——越早扔掉它，越早轻装上阵。Kadane 算法的
max(pre, 0)就是这个"扔包袱"的动作。
这是理解 Kadane 算法最关键的一步。定义：
$$dp[i] = \text{以 } nums[i] \text{ 结尾的最大子数组和}$$
为什么强调"以 $i$ 结尾"？因为这个限制让子问题之间可以递推——如果我知道以 $i-1$ 结尾的最优解，我就能推导出以 $i$ 结尾的最优解。
💡 设计 DP 的通用技巧：当问题问"任意区间的最优值"时，一个常见的套路是强制让状态以当前位置结尾，然后在所有 $dp[i]$ 中取最大值。这让我们获得了"前一个状态 + 当前元素"的递推关系。类似的设计在「最大乘积子数组」「最长上升子序列」等题目中反复出现。
对于位置 $i$，我们只有两种选择：
选择一：自成一派。 从 $nums[i]$ 开始一个全新的子数组。此时子数组和为 $nums[i]$。
选择二：延续前朝。 把 $nums[i]$ 接到以 $nums[i-1]$ 结尾的最大子数组后面。此时和为 $dp[i-1] + nums[i]$。
取两者中的较大值：
$$dp[i] = \max(nums[i],\ dp[i-1] + nums[i])$$
最终答案就是 $\max\limits_{0 \le i < n} dp[i]$。
🧠 直觉验证：假设你在位置 3，前面的最大子数组和是 5，当前元素是 -2。延续得到 3，自成一派得到 -2。显然 3 > -2，所以延续。如果当前元素是 -10 呢？延续得到 -5，自成一派得到 -10。还是延续。只有当前面的和本身就是负数时，自成一派才更优——因为负前缀只会让当前元素更小。
观察转移方程：$dp[i]$ 仅依赖于 $dp[i-1]$，我们不需要维护整个 dp 数组。用一个变量 pre 代替 $dp[i-1]$：
pre = max(x, pre + x)
这已经是 $O(1)$ 空间了。但我们还能再进一步——
注意到：当 $pre \le 0$ 时，$\max(x, pre + x) = x$（因为一个非正数加上 $x$ 不可能大于 $x$）。所以我们可以将条件前置：
$$pre = \max(pre, 0) + x$$
这就是 Kadane 算法的最终形态。语义变成了「如果之前和是正的，加上当前值；如果是负的，丢弃，从当前值重新开始」。
pre = max(pre, 0) + x
两种写法完全等价，但后者更直观地体现了"丢弃负前缀"的贪心决策。
换个视角，Kadane 算法也可以看作一种在线贪心：
🧠 贪心视角：我们一边扫描数组，一边维护"当前正在考虑的子数组"。每遇到一个新元素，我们就问自己——这个元素加入后，子数组和是变大了还是变小了？如果变小了（前缀和为负），说明前面的元素全是累赘，"咔嚓"一刀切断，从当前元素重新开始。
这里的贪心选择是局部最优的——在每一步，我们都选择"使当前子数组和最大"的决策。但这之所以能找到全局最优，是因为任何全局最大子数组不可能包含一个和为负的前缀（否则去掉这个前缀会得到一个更大的子数组）。
💡 贪心安全性的证明：假设全局最大子数组是 $nums[L..R]$，其中 $L$ 之前有一个和为负的前缀 $nums[k..L-1]$。那么 $nums[L..R]$ 的和一定大于 $nums[k..R]$ 的和（因为负前缀拉低了总和）。因此 Kadane 算法在 $L$ 位置"丢弃"前一个负前缀的决策，恰好保留了真正的最优解。
这不是巧合。很多优秀的算法都跨越了多种设计范式：
| 维度 | DP 视角 | 贪心视角 |
|---|---|---|
| 决策依据 | $dp[i] = \max(x, pre + x)$ | 如果 $pre > 0$ 则保留，否则丢弃 |
| 状态 | 以 $i$ 结尾的最大子数组和 | 当前的累积和 |
| 正确性来源 | 最优子结构 | 贪心选择性质 |
| 典型问法 | "什么是以 i 结尾的最优解？" | "这个前缀对我有没有帮助？" |
Kadane 算法之所以能被两种范式同时解释，是因为它的贪心选择恰好也是 DP 的最优子结构——"丢弃负前缀"这个贪心动作，在 DP 的转移方程中被验证为总是最优的。
💡 什么时候贪心和 DP 重合？ 当 DP 的状态转移只涉及"取或不取"的二元选择，且其中一种选择总是被另一种支配时（如"加负数前缀"总是被"丢弃它重新开始"支配），DP 就退化为了贪心。Kadane 正是这类"DP 退化为贪心"的经典案例。
以 nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4] 为例，追踪 Kadane 算法的每一步决策：
i |
x |
前一步 pre |
决策 | 新 pre |
ans |
|---|---|---|---|---|---|
| — | — | — | — | 0 | -∞ |
| 0 | -2 |
0 (≤0) | 丢弃，0 + (-2) = -2 |
-2 |
-2 |
| 1 | 1 |
-2 (≤0) | 丢弃，0 + 1 = 1 |
1 |
1 |
| 2 | -3 |
1 (>0) | 保留，1 + (-3) = -2 |
-2 |
1 |
| 3 | 4 |
-2 (≤0) | 丢弃，0 + 4 = 4 |
4 |
4 |
| 4 | -1 |
4 (>0) | 保留，4 + (-1) = 3 |
3 |
4 |
| 5 | 2 |
3 (>0) | 保留，3 + 2 = 5 |
5 |
5 |
| 6 | 1 |
5 (>0) | 保留，5 + 1 = 6 |
6 |
6 ✅ |
| 7 | -5 |
6 (>0) | 保留，6 + (-5) = 1 |
1 |
6 |
| 8 | 4 |
1 (>0) | 保留，1 + 4 = 5 |
5 |
6 |
注意 $i = 0, 1, 3$ 三个位置都触发了"丢弃"：
-2。pre = -2，是负数，丢弃前面的 [-2]，从 1 重新开始。pre = -2，是负数，丢弃前面的 [1, -3]，从 4 重新开始。而 $i=4$ 到 $i=6$ 连续保留，构建出最优解 $[4, -1, 2, 1]$（和为 6）。💡 这个表揭示了 Kadane 算法的运作规律："丢弃"多发生在遇到负数前缀或数组开头的地方。一旦
pre转正，算法就会贪婪地一直累加（即使遇到负数也加，因为正前缀总体上还是赚的），直到前缀和再次归零或转负。
如果不仅要求和，还要返回具体的子数组怎么办？只需追踪起止索引：
def max_subarray_with_indices(nums):
ans = float('-inf')
pre = 0
start = end = 0 # 最优子数组的起止位置
cur_start = 0 # 当前 pre 的起点
for i, x in enumerate(nums):
if pre <= 0:
pre = x
cur_start = i # 丢弃前缀，重新标记起点
else:
pre += x
if pre > ans:
ans = pre
start = cur_start
end = i
return nums[start:end + 1], ans
💡 技巧：每次
pre <= 0触发"丢弃"时，同步更新cur_start为当前位置。当pre刷新历史最高记录时，将cur_start封存到start。这样在 $O(1)$ 额外空间内就能追踪子数组边界。
将加法换成乘法后，负数的存在让问题变得更有趣——两个负数相乘会变成正数，所以当前的负数可能是未来的宝藏。这个变体需要同时维护"以 $i$ 结尾的最大乘积"和"以 $i$ 结尾的最小乘积"两个状态。详见 乘积最大子数组题解。
如果数组是环形的（首尾相连），最大子数组可能跨越数组两端。诀窍在于：环形最大 = max(普通最大, 总和 - 普通最小)。因为跨越两端的子数组，等价于"挖掉中间一段最小的"。详见 环形子数组的最大和。
当数组需要频繁修改，并且每次修改后要快速回答"整个数组的最大子段和是多少"时，Kadane 的 $O(n)$ 单次查询就不够用了。这时需要线段树来维护区间信息——而线段树节点的合并操作，正是 Kadane 算法分治视角的推广。
Kadane 算法虽然只有短短几行代码，但它身上凝聚了几个非常重要的算法设计思想：
💡 推荐练习顺序：最大子数组和（本题）→ 乘积最大子数组 → 环形子数组的最大和 → 线段树区间最大子段和。这个序列将 Kadane 算法的思想逐步泛化，覆盖了 DP、贪心、分治、线段树四个领域。
掌握了 Kadane 算法，你掌握的不仅仅是一道题，而是一整套处理"子数组最值"问题的思维框架。
]]>给你一个字符串 s，它只包含三种字符 'a'、'b' 和 'c'。
请你返回 s 中至少包含 'a'、'b' 和 'c' 各至少一个的子字符串数目。
只包含字符 'a'、'b'、'c' 的字符串 s
满足条件的子字符串数目（整数）
3 <= s.length <= 5 * 10^4s 仅由 'a'、'b' 和 'c' 组成input: s = "abcabc"
output: 10
解释：满足条件的子字符串有："abc", "abca", "abcab", "abcabc", "bca", "bcab", "bcabc", "cab", "cabc" 以及再次出现的 "abc"（起始位置不同）。
input: s = "aaacb"
output: 3
解释：满足条件的子字符串有："aaacb"、"aacb" 和 "acb"。
input: s = "abc"
output: 1
题目要求统计至少包含 'a'、'b'、'c' 各一个的子字符串数量。字符串仅由这三种字符构成，这意味着一旦某个子串"集齐"了三种字符，继续向右扩展永远不会失去它们——字符只会增多，不会消失。这个单调性是后续优化的关键。
最直接的想法：枚举所有可能的起点 i 和终点 j，逐一检查子串 s[i:j+1] 是否包含全部三种字符，若包含则计数器加一：
class Solution:
def numberOfSubstrings(self, s: str) -> int:
n = len(s)
ans = 0
for i in range(n):
cnt = {'a': 0, 'b': 0, 'c': 0}
for j in range(i, n):
cnt[s[j]] += 1
if cnt['a'] and cnt['b'] and cnt['c']:
ans += 1
return ans
这种做法时间复杂度 $O(n^2)$，在 $n$ 可达 $5 \times 10^4$ 时会超时。但暴力解揭示了一个重要性质：对固定的起点 i，一旦在某个位置 j 首次集齐三种字符，那么 j 之后的所有位置也都集齐了。
对于固定的左边界 j，设第一个使 [j, i] 满足条件的最小右边界为 i。由于字符串只含 'a'、'b'、'c'，窗口内的字符计数只增不减（或者说，向右扩展时已经拥有的字符不会丢失），因此对于任意 k >= i，子串 [j, k] 也一定满足条件。
也就是说，只要找到了最小的 i，右边界可以是 i, i+1, ..., n-1，一共有 $n - i$ 个合法子串。我们不必逐个枚举它们，直接累加即可。
剩下的问题是：如何高效地找到每个 j 对应的最小 i？
用两个指针维护一个窗口 [j, i]：
i：右边界，逐字符向右扩展，将 s[i] 加入计数j：左边界，当窗口内三种字符的计数都 $\ge 1$ 时，说明找到了最小 i（对当前 j 而言）当窗口满足条件时，做两件事：
j 配上 i 到 $n-1$ 的任意右边界都合法）s[j]，j += 1，尝试用更短的窗口看看是否仍满足条件——这相当于为下一个 j 寻找它的最小 ifrom collections import defaultdict
class Solution:
def numberOfSubstrings(self, s: str) -> int:
n = len(s)
ans = j = 0
d = defaultdict(int)
for i, c in enumerate(s):
d[c] += 1
while d['a'] and d['b'] and d['c']:
ans += n - i
d[s[j]] -= 1
j += 1
return ans
以 s = "abcabc" 为例跟踪执行过程：
i |
c |
窗口内计数 {a,b,c} |
满足条件？ | 操作 | ans 变化 |
|---|---|---|---|---|---|
| 0 | a |
{1,0,0} | ❌ | — | 0 |
| 1 | b |
{1,1,0} | ❌ | — | 0 |
| 2 | c |
{1,1,1} | ✅ | ans += 6-2=4, 移除 s[0]=a, j=1 |
4 |
| {0,1,1} | ❌ | 退出 while | 4 | ||
| 3 | a |
{1,1,1} | ✅ | ans += 6-3=3, 移除 s[1]=b, j=2 |
7 |
| {1,0,1} | ❌ | 退出 while | 7 | ||
| 4 | b |
{1,1,1} | ✅ | ans += 6-4=2, 移除 s[2]=c, j=3 |
9 |
| {0,1,1} | ❌ | 退出 while | 9 | ||
| 5 | c |
{1,1,1} | ✅ | ans += 6-5=1, 移除 s[3]=a, j=4 |
10 |
| {0,1,1} | ❌ | 退出 while | 10 |
最终答案为 10，与预期一致。
表中可以观察到：i 从未回退，j 也只增不减——每个字符最多被 i 加入一次、被 j 移出一次，因此内层 while 的总执行次数也是 $O(n)$。
滑动窗口的核心思路是"对每个 j 找最小 i"。换个角度，我们可以对每个 i 找最大的 j。
维护三个变量 last_a、last_b、last_c，分别记录字符 'a'、'b'、'c' 最近一次出现的下标（初始为 -1）。
当遍历到位置 i 时，以 i 为右端点的合法子串，其左端点 $j$ 必须满足：$j \le \min(last_a, last_b, last_c)$——因为 $(j, i]$ 需要包含三种字符，左端点必须不晚于三种字符中最早出现者的位置。
由于 $j$ 可以从 $0$ 取到 $\min(last_a, last_b, last_c)$，共有 $\min(last_a, last_b, last_c) + 1$ 个（+1 是因为 $j=0$ 也算一个）。
class Solution:
def numberOfSubstrings(self, s: str) -> int:
ans = 0
last = {'a': -1, 'b': -1, 'c': -1}
for i, c in enumerate(s):
last[c] = i
ans += min(last['a'], last['b'], last['c']) + 1
return ans
以 s = "abcabc" 跟踪：
i |
c |
last |
min(last)+1 |
ans |
|---|---|---|---|---|
| 0 | a |
{a:0, b:-1, c:-1} | 0 | 0 |
| 1 | b |
{a:0, b:1, c:-1} | 0 | 0 |
| 2 | c |
{a:0, b:1, c:2} | 1 | 1 |
| 3 | a |
{a:3, b:1, c:2} | 2 | 3 |
| 4 | b |
{a:3, b:4, c:2} | 3 | 6 |
| 5 | c |
{a:3, b:4, c:5} | 4 | 10 |
同样得到 10。
这个写法的代码极简，但思维跳跃较大——需要理解"以 i 结尾的子串数量 = 最早出现位置 + 1"这个关系。面试中建议两种都掌握，滑动窗口更直观，最近位置更优雅。
| 对比项 | 滑动窗口 (ans += n - i) |
最近位置 (ans += min(last) + 1) |
|---|---|---|
| 时间 | $O(n)$ | $O(n)$ |
| 空间 | $O(1)$ | $O(1)$ |
| 代码行数 | 13 行 | 7 行 |
| 直观程度 | 较直观 | 需要一点推导 |
| 适合场景 | 需要明确维护窗口时 | 追求极简代码时 |
两种 $O(n)$ 算法都已经是最优——至少需要遍历一次字符串。以下优化聚焦于代码细节。
defaultdict本题只需三个键 'a'、'b'、'c'，初始化时直接给出初始值可以省去 collections 导入：
class Solution:
def numberOfSubstrings(self, s: str) -> int:
n = len(s)
ans = j = 0
d = {'a': 0, 'b': 0, 'c': 0}
for i, c in enumerate(s):
d[c] += 1
while d['a'] and d['b'] and d['c']:
ans += n - i
d[s[j]] -= 1
j += 1
return ans
写法和 defaultdict 完全等价，但减少了一次 import。
min(last['a'], last['b'], last['c']) 每次都要做三次字典查找和两次 min 比较。用三个独立整型变量可以减少字典开销（虽然在这个数据规模下差异微乎其微）：
class Solution:
def numberOfSubstrings(self, s: str) -> int:
ans = 0
last_a = last_b = last_c = -1
for i, c in enumerate(s):
if c == 'a':
last_a = i
elif c == 'b':
last_b = i
else:
last_c = i
ans += min(last_a, last_b, last_c) + 1
return ans
用 if/elif/else 取代字典赋值，常数更小；min 三个独立变量也比字典取值略快。在算法竞赛或极致性能场景下可选用此写法，但日常使用中字典版本的可读性更好。
给你一个字符串 s、一个字符串 t。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 ""。
注意：
t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。s 中存在这样的子串，我们保证它是唯一的答案。字符串 s 和 t
s 中涵盖 t 所有字符的最小子串；若不存在则返回 ""
m == s.lengthn == t.length1 <= m, n <= 10^5s 和 t 由英文字母组成（大小写均可）你能设计一个在 $O(m + n)$ 时间内解决此问题的算法吗？
输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。
输入：s = "a", t = "a"
输出："a"
解释：整个字符串 s 就是最小覆盖子串。
输入：s = "a", t = "aa"
输出：""
解释：t 中两个字符 'a' 均应包含在 s 的子串中，因此没有符合条件的子字符串，返回空字符串。
题目要求在 s 中找一个最短的连续子串，使得该子串包含 t 中的所有字符，且每个字符的出现次数不少于 t 中的次数。这与之前做过的「找到字符串中所有字母异位词」有相似之处——都是在滑动窗口中维护字符频次。但这里 t 的字符可以在子串中分散出现（中间夹着无关字符），且窗口长度不固定，我们需要找到最短的合法窗口。
核心思路：右指针 i 不断扩展窗口，每当窗口内的字符频次满足 t 的要求时，尝试从左边收缩窗口以找到当前右边界下的最短合法窗口，同时更新全局最优解。
最朴素的做法：枚举 s 的所有子串（$O(m^2)$ 个），对每个子串检查是否包含 t 的所有字符（$O(m)$），总体 $O(m^3)$。对于 $m \le 10^5$ 的数据规模，这显然不可行。
稍作优化：枚举起点 i 后，向右扩展终点，同时维护窗口内各字符的计数。当计数满足 t 的要求时，记录当前子串长度，然后尝试下一个起点。这样减少到 $O(m^2)$，但仍然不够快：
from collections import Counter
class Solution:
def minWindow(self, s: str, t: str) -> str:
ct = Counter(t)
res = ''
for i in range(len(s)):
cs = Counter()
for j in range(i, len(s)):
cs[s[j]] += 1
# 检查当前窗口是否覆盖 t
ok = True
for ch in ct:
if cs[ch] < ct[ch]:
ok = False
break
if ok and (res == '' or j - i + 1 < len(res)):
res = s[i:j + 1]
return res
瓶颈：每个起点都重新建一个 Counter 并从零开始累加，相邻起点之间的窗口信息完全没有复用。能否让左右边界各自只向前移动，不重复计算？
cnt 计数 + 超频左缩回顾「无重复字符的最长子串」和「找到字符串中所有字母异位词」中的滑动窗口套路：右指针扩展、左指针在条件不合法时收缩。本题可以延续这一思路，关键在于如何高效判断「当前窗口是否覆盖了 t」。
维护以下状态：
ct = Counter(t)：t 中各字符的目标频次。cs = defaultdict(int)：当前窗口内各字符的实际频次。cnt：当前窗口内有多少种字符的频次已经达到目标值（注意：一个字符达到目标后，即使再多出现，cnt 也不会增加，因为该字符已经"达标"）。j：窗口左边界。算法流程：
i 遍历 s，将 s[i] 加入窗口：
cs[c] < ct[c]，说明这个字符的加入让我们朝着目标前进了一步，cnt += 1。cs[c] += 1。t 中的要求。此时不断右移左指针 j，将 cs[s[j]] -= 1，直到 cs[s[j]] 不再超过 ct[s[j]]。cnt == len(t) 时（所有字符类型都已达标），当前窗口是一个合法覆盖。检查窗口长度是否比已有最优解更短，若是则更新 res。from collections import Counter, defaultdict
class Solution:
def minWindow(self, s: str, t: str) -> str:
cs = defaultdict(int)
ct = Counter(t)
cnt = j = 0
res = ''
for i, c in enumerate(s):
if cs[c] < ct[c]:
cnt += 1
cs[c] += 1
while j < i and cs[s[j]] > ct[s[j]]:
cs[s[j]] -= 1
j += 1
if cnt == len(t) and (res == '' or i - j + 1 < len(res)):
res = s[j: i + 1]
return res
为什么用 cnt 而不是直接比较两个字典？
每次检查 cs 是否覆盖 ct 需要遍历 ct 的所有键，最坏 $O(|\Sigma|)$（字符集大小）。虽然对英文字母来说是常数，但有了 cnt，判断合法性变成 $O(1)$——只需检查 cnt == len(t)。cnt 的维护也非常轻量：只在新字符"从不足到达标"的瞬间 +1，之后该字符再多出现也不会重复计数。
while 循环为什么是 cs[s[j]] > ct[s[j]]？
当左侧字符在窗口中的出现次数超过目标次数时，把它丢掉不会影响窗口的合法性——因为丢掉之后该字符的计数仍然 ≥ 目标值。但如果 cs[s[j]] == ct[s[j]]，丢掉它就会让该字符从达标变成不达标，窗口不再合法。因此 while 只在"多了"的时候收缩，保留恰好达标的左边界。
cnt == len(t) 的含义
cnt 记录的是「窗口中有多少个字符对覆盖 t 做出了贡献」。对于 t = "ABC"，需要 3 个字符各贡献一次，cnt 达到 3 即表示三个字符均已出现。如果 t = "AAB"，len(t) = 3，cnt 的累积过程为：第一个 A 使 cnt=1，第二个 A 使 cnt=2，B 使 cnt=3。此时 cnt == len(t)，表示 t 中的每一个字符都在窗口中被匹配上了。
以 s = "ADOBECODEBANC"，t = "ABC" 为例，追踪算法的关键步骤：
i |
c |
cnt 变化 |
cs（关键变化） |
while 收缩 |
j |
窗口 [j,i] |
cnt==3? |
res 更新 |
|---|---|---|---|---|---|---|---|---|
| 0 | A |
0→1 |
A:1 |
— | 0 | [0,0]="A" |
否 | — |
| 1 | D |
— | D:1 |
— | 0 | [0,1]="AD" |
否 | — |
| 2 | O |
— | O:1 |
— | 0 | [0,2]="ADO" |
否 | — |
| 3 | B |
1→2 |
B:1 |
— | 0 | [0,3]="ADOB" |
否 | — |
| 4 | E |
— | E:1 |
— | 0 | [0,4]="ADOBE" |
否 | — |
| 5 | C |
2→3 |
C:1 |
— | 0 | [0,5]="ADOBEC" |
是 | "ADOBEC" (len=6) |
| 6 | O |
— | O:2 |
— | 0 | [0,6] |
是 | — (len=7) |
| 7 | D |
— | D:2 |
— | 0 | [0,7] |
是 | — (len=8) |
| 8 | E |
— | E:2 |
— | 0 | [0,8] |
是 | — (len=9) |
| 9 | B |
— | B:2 |
— | 0 | [0,9] |
是 | — (len=10) |
| 10 | A |
— | A:2 |
A:2→1, D:2→1, O:2→1, B:2→1, E:2→1, j 到 5 |
5 | [5,10]="CODEBA" |
是 | — (len=6) |
| 11 | N |
— | N:1 |
— | 5 | [5,11] |
是 | — (len=7) |
| 12 | C |
— | C:2 |
C:2→1, O:1→0, D:1→0, E:1→0, j 到 9 |
9 | [9,12]="BANC" |
是 | "BANC" (len=4) |
最终答案为 "BANC"，长度 4。
表中的关键转折点在 i=10：第二个 A 进入窗口后，cs['A']=2 > ct['A']=1 触发了 while 循环，左指针 j 连续收缩，将前面累积的多余字符全部清除，窗口从 [0,10] 缩至 [5,10]。类似地，i=12 时第二个 C 入窗，再次触发批量收缩，左指针从 5 一路跳到 9，找到了更短的合法窗口 "BANC"。
为什么左指针能一口气跳过这么多字符？ 因为在 j=0~4 的位置，每个字符的窗口计数都超过了目标计数（如 D、O、E 根本不在 t 中，计数永远是超的），所以 while 循环会连续执行，直到碰到一个"刚好达标"的字符才停下。这让窗口始终保持在恰好覆盖 t 的最小左边界。
i 遍历一次 s，左指针 j 每个字符最多被丢弃一次，每个字符入窗出窗各 $O(1)$。cs 和 ct 哈希表最多存储字符集大小的键值对。本题字符集为大小写英文字母，共 52 个，可视为 $O(1)$。need 计数法）上一节用 cnt 统计「达标的字符贡献数」。另一种常见的实现是用 need 变量统计「还需要多少个字符才算覆盖」。思路对称，但收缩条件略有不同：
维护 need = len(t) 表示窗口还需要多少个有效字符。右扩时，若 cs[c] < ct[c]，说明这个字符是"有效"的，need -= 1。当 need == 0 时窗口合法，此时从左侧收缩：只有把左侧字符丢掉之后窗口仍然合法（即 cs[s[j]] > ct[s[j]]），才允许收缩。尝试收缩到不能再缩为止，记录结果，然后强制左移一位以寻找下一个合法窗口。
from collections import Counter, defaultdict
class Solution:
def minWindow(self, s: str, t: str) -> str:
cs = defaultdict(int)
ct = Counter(t)
need = len(t)
j = 0
res = ''
for i, c in enumerate(s):
cs[c] += 1
if cs[c] <= ct[c]:
need -= 1
while need == 0:
if res == '' or i - j + 1 < len(res):
res = s[j: i + 1]
# 尝试收缩左侧
cs[s[j]] -= 1
if cs[s[j]] < ct[s[j]]:
need += 1
j += 1
return res
两种写法的差异：
| 对比项 | cnt 计数法 |
need 计数法 |
|---|---|---|
| 计数方向 | 从 0 递增到 len(t) |
从 len(t) 递减到 0 |
while 条件 |
cs[s[j]] > ct[s[j]]（超频才缩） |
need == 0（合法就缩） |
| 收缩粒度 | 只缩多余字符，窗口自动维持在"恰好覆盖"的最小左边界 | 缩到刚好不合法，需要手动回退 |
更新 res 时机 |
收缩完成后检查 | 收缩循环内每步检查 |
| 可读性 | 逻辑更集中，适合滑动窗口初学者 | 更接近"最小覆盖"的直觉 |
两种写法时间复杂度均为 $O(m)$，选择哪种取决于个人偏好。cnt 计数法的优势在于 while 条件简单（只判断一次字符超频），且更新 res 只在外层循环的一个位置；need 计数法在 while 循环内更新 res，但不需要在外层循环再判断。
算法层面 $O(m)$ 已是最优——至少需要遍历 s 一次才能知道哪些字符出现。以下优化聚焦于常数因子和代码简洁度。
题目保证 s 和 t 仅由英文字母组成（大小写均可），共 52 个可能字符。可以申请长度 128 的数组（覆盖 ASCII 英文字母范围），用 ord(c) 做下标，比 defaultdict 的哈希查找更快：
class Solution:
def minWindow(self, s: str, t: str) -> str:
cs = [0] * 128
ct = [0] * 128
for c in t:
ct[ord(c)] += 1
cnt = j = 0
res = ''
target = len(t)
for i, c in enumerate(s):
idx = ord(c)
if cs[idx] < ct[idx]:
cnt += 1
cs[idx] += 1
while j < i and cs[ord(s[j])] > ct[ord(s[j])]:
cs[ord(s[j])] -= 1
j += 1
if cnt == target and (res == '' or i - j + 1 < len(res)):
res = s[j: i + 1]
return res
数组访问比哈希表快（省去哈希计算和冲突解决），空间固定为 $O(128)$。如果确定只有小写字母（如某些变体题目），可缩至 26。
如果右指针 i 已经遍历到末尾，且当前窗口已不可能比已有最优解更短，可以提前 break。但由于滑动窗口本身就保证每个字符只访问常数次，这个优化的实际收益不大，反而增加代码复杂度——可作为思路提及。
添加两个快速返回判断：
if len(s) < len(t):
return ""
if s == t:
return s
这些判断在主算法之前执行，能在极端输入下省去不必要的滑动窗口过程。
「最小覆盖子串」是滑动窗口的经典题型，也是面试中的高频题目。相比「无重复字符的最长子串」（找最长合法窗口）和「找到字符串中所有字母异位词」（找固定长度合法窗口），本题要求找最短合法窗口，是「可变长度 + 最优解追踪」的组合：
cnt。掌握本题的 cnt 计数法后，类似的「覆盖」「包含」类滑动窗口题目（如至多包含 $k$ 个不同字符的最长子串、包含所有给定字符的最短子串等）都可以用同一套模板解决——只需调整 cnt 的判断条件和 while 的收缩条件即可。
给你一个整数数组 nums，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组 是数组中的一个连续部分。
整数数组 nums
最大子数组和
1 <= nums.length <= 10^5-10^4 <= nums[i] <= 10^4如果你已经实现复杂度为 $O(n)$ 的解法，尝试使用更为精妙的分治法求解。
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6。
输入：nums = [1]
输出：1
输入：nums = [5,4,-1,7,8]
输出：23
这是一道经典的最大子数组和问题，也是 Kadane 算法的代表性题目。数组中的元素可能为负数，因此不能简单地从第一个正数开始一直累加——负数的出现会让累加和"缩水"，但有时为了连接后面的正数段，我们又必须"忍耐"中间的负数。
💡 一句话概括：在遍历数组时，我们始终面临一个选择——是延续前面的累加，还是重新开始。如果前面的累加是正的，保留它；如果是负的，丢弃它。
🔗 延伸阅读：Kadane 算法的完整原理推导（DP 视角 + 贪心视角）、变体扩展和线段树推广，详见 Kadane 算法详解（知识点专题文章）。
核心问题可以归结为：当遍历到某个位置时，我该延续前面的子数组，还是从这里重新开始？
最直接的做法是枚举所有子数组并计算和：
class Solution:
def maxSubArray(self, nums: List[int]) -> int:
n = len(nums)
ans = float('-inf')
for i in range(n):
cur = 0
for j in range(i, n):
cur += nums[j]
ans = max(ans, cur)
return ans
这段代码枚举了所有可能的起点 i 和终点 j，在 $O(n^2)$ 时间内计算出最大子数组和。
瓶颈分析：当 $n \le 10^5$ 时，$O(n^2) = 10^{10}$ 次操作，远超时间限制。而且内部循环做了大量重复计算——以子数组 [1,3] 和 [2,3] 为例，它们的求和区间高度重叠，但暴力法每次都是从 i 重新累加，完全没有复用前一次的信息。
优化方向：能否只遍历一次数组，在遍历过程中动态地做决策？
定义 $dp[i]$ 为以 $\text{nums}[i]$ 结尾的最大子数组和。注意这里的关键限制是"必须以 $\text{nums}[i]$ 结尾"——这让我们可以从子问题递推。
💡 DP 设计技巧：当问题问"任意区间的最优值"，常见的套路是强制状态以当前位置结尾，然后在所有 $dp[i]$ 中取最大值。这让我们获得了"前一个状态 + 当前元素"的递推关系。
对于位置 $i$，我们有两种选择：
取两者中的较大值，得到状态转移方程：
$$dp[i] = \max(\text{nums}[i],\ dp[i-1] + \text{nums}[i])$$
最终答案就是 $\max\limits_{0 \le i < n} dp[i]$。
观察转移方程：$dp[i]$ 仅依赖于 $dp[i-1]$，我们不需要维护整个 dp 数组，只需一个变量 pre 记录 $dp[i-1]$ 即可。
同时注意到，$dp[i-1]$ 只有在 > 0 时才对 $dp[i]$ 有正向贡献——如果 $dp[i-1] \le 0$，那么 $\max(\text{nums}[i], dp[i-1] + \text{nums}[i]) = \text{nums}[i]$，等价于「丢弃之前的所有累加」。
因此代码可以简化为：
class Solution:
def maxSubArray(self, nums: List[int]) -> int:
ans = float('-inf')
pre = 0
for x in nums:
pre = max(pre, 0) + x
ans = max(ans, pre)
return ans
关键一行 pre = max(pre, 0) + x 的语义：
pre > 0，说明前面的累积对当前元素有正向贡献 → 累加上 xpre \le 0，说明前面的累积只会拖累当前元素 → 丢弃，从 x 重新开始🧠 直觉理解：想象你是一个股民，每天都有盈亏。
pre就是你当前的累计收益，max(pre, 0)就是在问自己——"我之前是赚了还是亏了？"亏了就清仓从头开始，赚了就继续持有。
这正是 Kadane 算法最优雅的写法——将 DP 状态转移与贪心决策融为一体。
以 nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4] 为例，追踪 pre 和 ans 的变化：
i |
x |
决策 | pre |
ans |
|---|---|---|---|---|
| — | — | — | 0 | -∞ |
| 0 | -2 |
pre ≤ 0，丢弃，0 + (-2) |
-2 |
-2 |
| 1 | 1 |
pre ≤ 0，丢弃，0 + 1 |
1 |
1 |
| 2 | -3 |
pre > 0，保留，1 + (-3) |
-2 |
1 |
| 3 | 4 |
pre ≤ 0，丢弃，0 + 4 |
4 |
4 |
| 4 | -1 |
pre > 0，保留，4 + (-1) |
3 |
4 |
| 5 | 2 |
pre > 0，保留，3 + 2 |
5 |
5 |
| 6 | 1 |
pre > 0，保留，5 + 1 |
6 |
6 ✅ |
| 7 | -5 |
pre > 0，保留，6 + (-5) |
1 |
6 |
| 8 | 4 |
pre > 0，保留，1 + 4 |
5 |
6 |
最终 ans = 6，对应子数组 [4, -1, 2, 1]。
可以观察到，pre 在位置 i=0, 1, 3 处 ≤ 0 时被"重置"——这恰好对应了"切断负数前缀，重新开始"的贪心决策。最终的最大值 6 出现在 i=6。
pre 和 ans 两个变量。$O(n)$ 已是最优——因为输出结果至少需要遍历一次数组才能确定。
除了 DP，题目的进阶要求也提示我们尝试分治法。分治法的思路是将数组从中间分成左右两半，那么最大子数组有三种可能的位置：
| 情况 | 描述 | 求解方式 |
|---|---|---|
| ① 完全在左半 | 最大子数组的左右端点均 ≤ mid |
递归左半 |
| ② 完全在右半 | 最大子数组的左右端点均 > mid |
递归右半 |
| ③ 跨越中点 | 左端点在左半，右端点在右半 | 从中点向两侧扫描 |
前两种情况直接递归求解，第三种情况需要额外处理——从中点向左扫描求最大后缀和，从中点+1 向右扫描求最大前缀和，两者相加：
class Solution:
def maxSubArray(self, nums: List[int]) -> int:
def divide(l: int, r: int) -> int:
if l == r:
return nums[l]
mid = (l + r) // 2
# 递归求解左右
left_max = divide(l, mid)
right_max = divide(mid + 1, r)
# 跨越中点的最大和
cur = 0
left_cross = float('-inf')
for i in range(mid, l - 1, -1):
cur += nums[i]
left_cross = max(left_cross, cur)
cur = 0
right_cross = float('-inf')
for i in range(mid + 1, r + 1):
cur += nums[i]
right_cross = max(right_cross, cur)
cross_max = left_cross + right_cross
return max(left_max, right_max, cross_max)
return divide(0, len(nums) - 1)
💡 为什么学分治法？ 虽然复杂度不如 Kadane，但分治法中"合并区间"的操作，正是线段树维护区间最大子段和的核心——当需要支持动态修改数组元素并快速查询任意区间答案时，分治 + 线段树是唯一选择。Kadane 做不到这一点。
两种方法的对比：
| 对比项 | Kadane（DP） | 分治法 |
|---|---|---|
| 时间复杂度 | $O(n)$ | $O(n \log n)$ |
| 空间复杂度 | $O(1)$ | $O(\log n)$ |
| 代码简洁度 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ |
| 思维难度 | 需理解 DP 状态定义 | 结构清晰，但跨越中点处理稍繁琐 |
| 扩展性 | 仅适合静态最大子数组和 | 可扩展为线段树维护区间信息 |
max(pre, 0) + x 与 max(x, pre + x) 的等价性# 写法 1：强调"丢弃负前缀"（更直观）
pre = max(pre, 0) + x
# 写法 2：强调"取或不取"（更贴近 DP 方程）
pre = max(x, pre + x)
写法 1 更直观地体现了贪心决策——「之前和为正则保留，为负则丢弃」。写法 2 更贴近标准 DP 状态转移方程。两种写法完全等价，按个人偏好选择。
ans = float('-inf') # 正确处理全负数数组
pre = 0
⚠️ 注意：
ans初始化为float('-inf')而非0，确保全负数数组（如nums = [-3, -2, -1]）也能正确返回-1。若用0则会错误地返回0（空子数组在本题中是不允许的）。
等价的初始化方式：ans = nums[0]（题目保证 nums.length >= 1），两种写法都是安全的。
如果题目要求返回最大子数组而不仅是最大值，可以在维持 pre 的同时追踪子数组的左右端点：
class Solution:
def maxSubArray(self, nums: List[int]) -> List[int]:
ans = float('-inf')
pre = 0
start = end = 0
cur_start = 0
for i, x in enumerate(nums):
if pre <= 0:
pre = x
cur_start = i # 丢弃前缀，重新标记起点
else:
pre += x
if pre > ans:
ans = pre
start = cur_start
end = i
return nums[start:end + 1]
💡 技巧：每次
pre <= 0触发"丢弃"时，同步更新cur_start为当前位置；当pre刷新历史记录时，将cur_start封存到start。$O(1)$ 额外空间即可追踪子数组边界。
「最大子数组和」是动态规划的入门经典，它的核心在于定义以每个位置结尾的最优状态，通过一个精妙的转移方程将问题降维到 $O(n)$。
解决本题后，推荐按以下顺序挑战延伸题目——这条路径将 Kadane 的思想逐步泛化，覆盖 DP、贪心、分治、线段树四个领域：
]]>🧠 核心收获：掌握了"以某位置结尾的最优状态"这一 DP 设计技巧，你就能从容应对一大类子数组问题。这不是一道题的技巧，而是一类题的思维框架。
给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
整数数组 height
能接的雨水总量（整数）
n == height.length1 <= n <= 2 * 10^40 <= height[i] <= 10^5input: height = [0,1,0,2,1,0,1,3,2,1,2,1]
output: 6
解释：蓝色部分为接住的雨水，共 6 个单位。
input: height = [4,2,0,3,2,5]
output: 9
题目本质是：对每个位置，求它上方能「兜住」多少水。某一格的水位由左侧最高柱和右侧最高柱中的较小值决定，再减去自身高度：
$$\text{water}[i] = \max\bigl(0,\ \min(\text{leftMax}[i],\ \text{rightMax}[i]) - \text{height}[i]\bigr)$$
最直观的做法是：对每个位置 i，分别向左、向右扫描，求出左侧最大值和右侧最大值，再按上式累加：
class Solution:
def trap(self, height: List[int]) -> int:
ans = 0
n = len(height)
for i in range(n):
left_max = max(height[:i + 1])
right_max = max(height[i:])
ans += min(left_max, right_max) - height[i]
return ans
思路正确，但每个位置都要左右各扫一遍，时间复杂度 $O(n^2)$，在 $n$ 可达 $2 \times 10^4$ 时会超时。瓶颈在于重复计算左右最大值——能否预处理出来？
定义两个数组：
pre[i]：下标 0 到 i（含）中的最大高度，即位置 i 左侧（含自身）的最高柱suf[i]：下标 i 到 n-1（含）中的最大高度，即位置 i 右侧（含自身）的最高柱一次从左到右、一次从右到左即可 $O(n)$ 预处理，再逐位累加：
class Solution:
def trap(self, height: List[int]) -> int:
n = len(height)
pre = [0] * n
suf = [0] * n
pre[0] = height[0]
for i in range(1, n):
pre[i] = max(pre[i - 1], height[i])
suf[-1] = height[-1]
for i in range(n - 2, -1, -1):
suf[i] = max(suf[i + 1], height[i])
return sum(min(pre[i], suf[i]) - height[i] for i in range(n))
时间 $O(n)$，但用了 $O(n)$ 额外数组。进阶约束要求 $O(1)$ 空间——能否在遍历过程中动态维护左右最大值，而不显式存下整个数组？
用两个指针 l、r 分别从数组首尾向中间移动，同时维护：
pre：已处理过的左半部分的最大高度（不含当前 l 即将纳入的那一格之前的含义，代码里是先更新再累加）suf：已处理过的右半部分的最大高度核心观察：当 height[l] < height[r] 时，右侧至少有一根高度为 height[r] 的柱子，它不低于 height[l]。因此对当前位置 l 而言，决定水位的「短板」一定在左侧——水位由 pre（左半已扫描部分的最大值）决定，与右侧更高细节无关。
反之，当 height[l] >= height[r] 时，左侧已有足够高的墙，当前位置 r 的水位由 suf 决定。
以 height = [0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1] 为例，前几步如下：
l |
r |
height[l] |
height[r] |
移动侧 | pre / suf |
本次积水 | ans |
|---|---|---|---|---|---|---|---|
| 0 | 11 | 0 | 1 | 左（更矮） | pre=0 |
0 | 0 |
| 1 | 11 | 1 | 1 | 右（相等移右） | suf=1 |
0 | 0 |
| 1 | 10 | 1 | 2 | 左（更矮） | pre=1 |
0 | 0 |
| 2 | 10 | 0 | 2 | 左（更矮） | pre=1 |
1 | 1 |
| 3 | 10 | 2 | 2 | 右 | suf=2 |
0 | 1 |
| 3 | 9 | 2 | 1 | 右（更矮） | suf=2 |
1 | 2 |
每次移动较短（或相等时移动右）一侧，用该侧已维护的最大值减去当前高度，累加到答案。两侧指针最终相遇，所有位置的积水都算完。
为什么不会漏算？每当处理 l 时，右侧存在 height[r] 作为「可靠高墙」，左侧最大值 pre 就是该位置真实的 leftMax；对称地，处理 r 时左侧 height[l] 保证了 suf 的有效性。
class Solution:
def trap(self, height: List[int]) -> int:
l, r = 0, len(height) - 1
ans = 0
pre = suf = 0
while l < r:
if height[l] < height[r]:
pre = max(pre, height[l])
ans += pre - height[l]
l += 1
else:
suf = max(suf, height[r])
ans += suf - height[r]
r -= 1
return ans
双指针是按列逐格累加积水；另一种视角是按层横向「填水」——当遇到一根比栈顶更高的柱子时，之前凹下去的区域可以被填满一层。
维护一个单调递减栈 st，存下标，栈底到栈顶对应的高度单调不增。遍历到位置 i、高度 h 时：
h 不大于栈顶高度，说明还没形成新的「盆」，将 i 入栈h 大于栈顶高度，说明右侧出现了更高的墙，可以兜住水：
bottombreakh（右侧墙）共同夹住一层水i - st[-1] - 1，高度为 min(左墙, 右墙) - bottom以 height = [0, 1, 0, 2, 1, 0, 1, 3] 为例，当 i = 7、h = 3 时，栈中依次为下标 1(高1)、2(高0)、5(高0)、6(高1)。连续弹出后，会在 (1, 3) 之间、(6, 3) 之间等位置分别算出一层积水。
这种写法把「凹槽」拆成若干横向矩形累加，与双指针的纵向切片殊途同归。
class Solution:
def trap(self, height: List[int]) -> int:
st = []
ans = 0
for i, h in enumerate(height):
while st and height[st[-1]] < h:
bottom = height[st.pop()]
if not st: break
ans += (min(height[st[-1]], h) - bottom) * (i - st[-1] - 1)
st.append(i)
return ans
| 对比项 | 双指针 | 单调栈 |
|---|---|---|
| 时间 | $O(n)$ | $O(n)$ |
| 空间 | $O(1)$ | $O(n)$ |
| 视角 | 逐列：每格水位由左右最大值决定 | 逐层：弹出盆底后横向填水 |
| 适用 | 本题最优解，代码短 | 便于扩展到接雨水 II 等二维变形 |
面试和竞赛中更推荐双指针：空间更优、实现更短；单调栈则适合需要横向分层或推广到矩阵接水的场景。
本题在算法层面，$O(n)$ 时间已是下界（至少要看一遍数组），$O(1)$ 空间的双指针也是最优之一。因此优化空间主要在代码简洁度与常数细节。
pre 与 suf 为单一变量同一时刻只有较短一侧在被处理，另一侧的最大值变量本轮不会用到。可以只保留一个 mx，在左右分支里分别更新，语义不变：
class Solution:
def trap(self, height: List[int]) -> int:
l, r = 0, len(height) - 1
ans = mx = 0
while l < r:
if height[l] < height[r]:
mx = max(mx, height[l])
ans += mx - height[l]
l += 1
else:
mx = max(mx, height[r])
ans += mx - height[r]
r -= 1
return ans
注意：两侧交替处理时 mx 的含义会随分支切换，但每次累加前它代表的正是当前侧所需的「已扫描最大值」，与分开维护 pre、suf 等价。若更看重可读性，保留 pre、suf 两个变量更清晰。
内层 while 中多次访问 height[st[-1]]，可先取出栈顶下标与高度，减少重复下标计算：
class Solution:
def trap(self, height: List[int]) -> int:
st = []
ans = 0
for i, h in enumerate(height):
while st:
top = st[-1]
if height[top] >= h:
break
bottom = height[st.pop()]
if not st:
break
ans += (min(height[st[-1]], h) - bottom) * (i - st[-1] - 1)
st.append(i)
return ans
逻辑与原版相同，将 height[st[-1]] < h 的判断改为显式 break，对部分读者更易跟进循环出口。
给定一个字符串 s，请你找出其中不含有重复字符的最长子串的长度。
字符串 s
最长无重复子串的长度（整数）
0 <= s.length <= 5 * 10^4s 由英文字母、数字、符号和空格组成input: s = "abcabcbb"
output: 3
解释：最长无重复子串为 "abc"，长度为 3。
input: s = "bbbbb"
output: 1
解释：最长无重复子串为 "b"，长度为 1。
input: s = "pwwkew"
output: 3
解释：最长无重复子串为 "wke"，长度为 3。注意 "pwke" 是子序列而非子串。
题目要求找连续子串，且子串内每个字符最多出现一次。暴力枚举所有子串再逐个判重，在 $n$ 可达 $5 \times 10^4$ 时会超时——能否在扩展子串的同时，动态维护「当前窗口是否合法」？
最直观的做法：枚举所有起点 i 和终点 j，检查 s[i:j+1] 是否有重复字符：
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
ans = 0
n = len(s)
for i in range(n):
seen = set()
for j in range(i, n):
if s[j] in seen:
break
seen.add(s[j])
ans = max(ans, j - i + 1)
return ans
内层遇到重复就 break，每个起点最多扫到第一次冲突为止。最坏情况（如全不重复）时间复杂度 $O(n^2)$，仍可能超时。瓶颈在于：不同起点之间大量重复扫描——能否让左右边界只各移动一次？
用两个指针维护一个窗口 [j, i]（闭区间）：
i：右边界，逐字符向右扩展j：左边界，当窗口内出现重复时向右收缩再用一个集合 seen 记录窗口内有哪些字符。i 每右移一步，若 s[i] 不在集合中则加入并更新答案；若已存在，则不断将 s[j] 从集合移除并 j += 1，直到可以安全放入 s[i]：
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
ans = j = 0
seen = set()
for i, c in enumerate(s):
while c in seen:
seen.remove(s[j])
j += 1
seen.add(c)
ans = max(ans, i - j + 1)
return ans
以 s = "pwwkew" 为例：
i |
c |
窗口 [j, i] |
操作 | ans |
|---|---|---|---|---|
| 0 | p |
[0,0] |
加入 p |
1 |
| 1 | w |
[0,1] |
加入 w |
2 |
| 2 | w |
— | w 重复，移除 p、w（j 到 2） |
2 |
| 2 | w |
[2,2] |
加入 w |
2 |
| 3 | k |
[2,3] |
加入 k |
2 |
| 4 | e |
[2,4] |
加入 e |
3 |
| 5 | w |
— | w 重复，移除 w（j 到 3） |
3 |
| 5 | w |
[3,5] |
加入 w |
3 |
最终答案为 3（"wke"）。
j 只增不减，每个字符最多入窗、出窗各一次，时间复杂度 $O(n)$。
集合的 c in seen 等价于「该字符出现次数 $\ge 1$」。改用哈希表 d 统计窗口内各字符出现次数，逻辑可以写得更统一：
i 每步将 s[i] 的计数 +1while 从左侧逐个减计数并右移 j，直到该字符计数回到 1i - j + 1 更新答案from collections import defaultdict
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
ans = j = 0
d = defaultdict(int)
for i, c in enumerate(s):
d[c] += 1
while d[c] > 1:
d[s[j]] -= 1
j += 1
ans = max(ans, i - j + 1)
return ans
以 s = "abcabcbb" 为例，当 i = 3、c = 'a' 时：
| 步骤 | d['a'] |
j |
窗口 | ans |
|---|---|---|---|---|
加入 a（i=3） |
2 | 0 | 非法 | 3 |
d[s[0]]-=1，j=1 |
1 | 1 | [1,3] = "bca" |
3 |
此时 'a' 计数恢复为 1，窗口合法，长度为 3。
与集合写法相比，计数写法把「是否存在」推广为「出现几次」，后续遇到允许字符出现 $k$ 次的滑动窗口变形题时可以直接复用同一套框架。
i 与 j 各最多移动 $n$ 次计数写法中，while d[c] > 1 会逐字符收缩左边界。其实重复发生时，左边界不必慢慢挪——只需跳到上一次该字符出现位置的下一格。
维护 last[c] 为字符 c 最近一次出现的下标。当在位置 i 再次遇到 c 时，若 last[c] >= j（说明 c 仍在当前窗口内），则直接令 j = last[c] + 1；否则 j 不动（旧位置已被之前的收缩甩在窗口外）。然后更新 last[c] = i 并刷新答案：
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
last = {}
ans = j = 0
for i, c in enumerate(s):
if c in last and last[c] >= j:
j = last[c] + 1
last[c] = i
ans = max(ans, i - j + 1)
return ans
以 s = "abba" 为例：当 i = 3、c = 'a' 时，last['a'] = 0 且 0 >= j，直接 j = 1，窗口变为 "ba"，无需经过 "bba" 的中间状态。
两种写法时间均为 $O(n)$，但跳转写法每次循环只做常数操作，没有内层 while，常数更小，代码也更短。
| 对比项 | 计数 + 逐位收缩 | 记录下标 + 直接跳转 |
|---|---|---|
| 时间 | $O(n)$ | $O(n)$ |
| 内层循环 | 有 while |
无 |
| 扩展性 | 易改为「最多出现 $k$ 次」 | 需额外维护次数 |
| 适用 | 通用滑动窗口模板 | 本题「至多 1 次」特化 |
面试中若强调通用模板，推荐计数写法；若只求本题最简实现，记录下标跳转更利落。
算法层面两种 $O(n)$ 思路都已最优（至少需读一遍字符串）。以下优化侧重代码简洁度与常数细节。
defaultdict本题只需「先加再减」，完全可以用 dict.get(key, 0) 或 d[c] = d.get(c, 0) + 1，少一个 collections 依赖：
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
ans = j = 0
d = {}
for i, c in enumerate(s):
d[c] = d.get(c, 0) + 1
while d[c] > 1:
d[s[j]] -= 1
j += 1
ans = max(ans, i - j + 1)
return ans
语义与 defaultdict(int) 完全一致。
记录下标版本中，last[c] = i 可以放在判断之前，用 max 一行完成边界跳转，减少分支嵌套：
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
last = {}
ans = j = 0
for i, c in enumerate(s):
j = max(j, last.get(c, -1) + 1)
last[c] = i
ans = max(ans, i - j + 1)
return ans
last.get(c, -1) + 1 在 c 首次出现时等于 0，与 j 取 max 后仍保持 j 不变，等价于原来的 if c in last and last[c] >= j 判断。
给定两个字符串 s 和 p，找到 s 中所有 p 的字母异位词的子串，返回这些子串的起始索引。不考虑答案输出的顺序。
字母异位词指字母相同，但排列不同的字符串。
字符串 s 和 p
所有异位词子串在 s 中的起始下标列表
1 <= s.length, p.length <= 3 * 10^4s 和 p 仅包含小写英文字母input: s = "cbaebabacd", p = "abc"
output: [0, 6]
解释：起始下标 0 的子串是 "cba"，下标 6 的子串是 "bac"，二者都是 "abc" 的字母异位词。
input: s = "abab", p = "ab"
output: [0, 1, 2]
解释：起始下标 0 的子串是 "ab"，下标 1 的子串是 "ba"，下标 2 的子串是 "ab"。
题目要求找 s 中所有连续子串，使其与 p 互为字母异位词——即长度相同、各字符出现次数完全一致。暴力枚举每个起点再排序或逐字符比对，在 $n$ 可达 $3 \times 10^4$ 时会超时。能否在向右扩展子串的同时，动态维护「当前窗口的字符频次是否合法」？
最直观的做法：枚举每个起点 i，取长度为 len(p) 的子串，判断它是否与 p 互为异位词。判断方式可以是排序后比较，或用 Counter 比较频次：
from collections import Counter
class Solution:
def findAnagrams(self, s: str, p: str) -> List[int]:
res = []
m = len(p)
cp = Counter(p)
for i in range(len(s) - m + 1):
if Counter(s[i:i + m]) == cp:
res.append(i)
return res
每个起点都要构造一次子串频次，时间复杂度 $O(n \cdot m)$，数据规模下会超时。瓶颈在于相邻起点的大量重复计算——窗口右移一位时，只是去掉最左字符、加入最右字符，频次可以增量更新。能否让左右边界只各移动一次？
用 [j, i] 维护一个窗口。右指针 i 每步将 s[i] 的计数 +1；当窗口长度超过 len(p) 时，将 s[j] 的计数 -1 并 j += 1，保持窗口长度恰好为 len(p)。每次窗口就位后，比较窗口频次与 p 的频次是否相等：
from collections import Counter, defaultdict
class Solution:
def findAnagrams(self, s: str, p: str) -> List[int]:
m = len(p)
cp = Counter(p)
cs = defaultdict(int)
res = []
j = 0
for i, c in enumerate(s):
cs[c] += 1
if i - j + 1 > m:
cs[s[j]] -= 1
j += 1
if i - j + 1 == m and cs == cp:
res.append(j)
return res
每次比较两个字典是 $O(|\Sigma|)$，$|\Sigma| = 26$ 视为常数，总时间 $O(n)$。但每次都要做完整字典相等判断，常数偏大——能否只在不合法时收缩，而不是每步都全量比较？
思路与「无重复字符的最长子串」的计数写法一脉相承：右指针 i 每步将 s[i] 计数 +1；若某字符在窗口内的出现次数超过了 p 中该字符的次数（cs[c] > cp[c]），说明当前窗口不可能成为异位词，用 while 从左侧逐个减计数并右移 j，直到该字符不再超频。收缩完毕后，若窗口长度恰好等于 len(p)，则各字符频次必然与 p 完全一致（总数相同且无人超频），记录起点 j：
from collections import Counter, defaultdict
class Solution:
def findAnagrams(self, s: str, p: str) -> List[int]:
j = 0
cs = defaultdict(int)
cp = Counter(p)
res = []
for i, c in enumerate(s):
cs[c] += 1
while cs[c] > cp[c]:
cs[s[j]] -= 1
j += 1
if i - j + 1 == len(p):
res.append(j)
return res
以 s = "cbaebabacd"、p = "abc" 为例：
i |
c |
操作 | 窗口 [j, i] |
是否记录 |
|---|---|---|---|---|
| 0 | c |
加入 c |
[0,0] 长度 1 |
— |
| 1 | b |
加入 b |
[0,1] 长度 2 |
— |
| 2 | a |
加入 a |
[0,2] = "cba" 长度 3 |
记录 0 |
| 3 | e |
e 不在 p 中，cs['e']=1 > cp['e']=0，左缩至 j=4 |
长度 0 | — |
| 4 | b |
加入 b |
[4,4] 长度 1 |
— |
| 5 | a |
加入 a |
[4,5] = "ba" 长度 2 |
— |
| 6 | b |
cs['b']=2 > cp['b']=1，左缩至 j=5 |
[5,6] = "ab" 长度 2 |
— |
| 7 | a |
cs['a']=2 > cp['a']=1，左缩至 j=6 |
[6,7] = "ba" 长度 2 |
— |
| 8 | c |
加入 c |
[6,8] = "bac" 长度 3 |
记录 6 |
最终答案为 [0, 6]。
j 只增不减，每个字符最多入窗、出窗各一次，时间复杂度 $O(n)$。
i 与 j 各最多移动 $n$ 次上一节的「超频则左缩」是变长窗口：只有出现非法字符时才收缩，逻辑简洁，且与「至多出现 $k$ 次」类题目共用同一模板。本题还有一个常见写法：固定窗口长度始终为 len(p)，用「匹配度」代替字典全量比较。
维护 need = Counter(p) 记录 p 中各字符的目标频次，window 记录当前窗口频次，再用 valid 统计「有多少种字符的窗口计数恰好等于目标计数」。右扩时若某字符计数从小于变为等于目标，valid += 1；若从等于变为大于目标，valid -= 1。窗口超长时左缩一位，对离开窗口的字符做对称更新。当 valid == len(need)（所有出现过的字符类型都匹配），当前起点即为异位词：
from collections import Counter, defaultdict
class Solution:
def findAnagrams(self, s: str, p: str) -> List[int]:
if len(s) < len(p):
return []
need = Counter(p)
window = defaultdict(int)
valid = 0
res = []
j = 0
m = len(p)
for i, c in enumerate(s):
window[c] += 1
if c in need:
if window[c] == need[c]:
valid += 1
elif window[c] == need[c] + 1:
valid -= 1
if i - j + 1 > m:
left = s[j]
if left in need:
if window[left] == need[left]:
valid -= 1
elif window[left] == need[left] + 1:
valid += 1
window[left] -= 1
j += 1
if valid == len(need):
res.append(j)
return res
两种写法时间均为 $O(n)$，但侧重点不同：
| 对比项 | 超频则左缩（变长窗口） | 匹配计数（固定窗口） |
|---|---|---|
| 时间 | $O(n)$ | $O(n)$ |
| 内层循环 | 有 while |
无 |
| 合法性判断 | 任一字符超频即收缩 | valid 达标即合法 |
| 扩展性 | 易改为「至多 / 至少 $k$ 次」 | 适合「频次恰好相等」类题 |
面试中若强调通用模板，推荐匹配计数写法；若刚学完「无重复字符的最长子串」，超频左缩写法更连贯。
算法层面两种 $O(n)$ 思路都已最优（至少需读一遍 s）。以下优化侧重常数因子与代码简洁度。
Counter题目保证只有小写字母，频次用 ord(c) - ord('a') 映射到下标 0~25，比 Counter / defaultdict 更省开销：
class Solution:
def findAnagrams(self, s: str, p: str) -> List[int]:
m = len(p)
if len(s) < m:
return []
cp = [0] * 26
cs = [0] * 26
for c in p:
cp[ord(c) - 97] += 1
res = []
j = 0
for i, c in enumerate(s):
idx = ord(c) - 97
cs[idx] += 1
while cs[idx] > cp[idx]:
cs[ord(s[j]) - 97] -= 1
j += 1
if i - j + 1 == m:
res.append(j)
return res
语义与原写法完全一致，访问数组比哈希表更快，空间也固定为 $O(26)$。
diff 数组判断全匹配固定窗口写法中，不必维护 valid 变量——用一个 diff[26] 记录「窗口计数与目标计数的差」，窗口就位后检查 diff 是否全零即可：
class Solution:
def findAnagrams(self, s: str, p: str) -> List[int]:
m = len(p)
n = len(s)
if n < m:
return []
diff = [0] * 26
for c in p:
diff[ord(c) - 97] += 1
res = []
for i, c in enumerate(s):
diff[ord(c) - 97] -= 1
if i >= m:
diff[ord(s[i - m]) - 97] += 1
if i >= m - 1 and not any(diff):
res.append(i - m + 1)
return res
any(diff) 最坏 $O(26)$，仍是 $O(n)$。若追求极致常数，可像 valid 写法一样增量维护「差值为零的字符种类数」，避免每步扫描 26 个位置。
给定一个整数数组 nums 和一个整数 k，请你统计并返回该数组中和为 k 的连续子数组的个数。
整数数组 nums，整数 k
和为 k 的连续子数组个数
1 <= nums.length <= 2 * 10^4-1000 <= nums[i] <= 1000-10^7 <= k <= 10^7input: nums = [1,1,1], k = 2
output: 2
解释：和为 2 的子数组有 [1,1]（下标 0~1）与 [1,1]（下标 1~2），共 2 个。
input: nums = [1,2,3], k = 3
output: 2
解释：和为 3 的子数组有 [1,2]（下标 0~1）与 [3]（下标 2），共 2 个。
题目要求统计连续子数组中和恰好等于 k 的个数。暴力枚举所有子区间再逐个求和，在 $n$ 可达 $2 \times 10^4$ 时会超时。能否把「区间求和」转化为某种可复用的前缀信息，并在一次扫描中完成统计？
最直观的做法：枚举每个起点 i 和终点 j，计算 nums[i:j+1] 的和，等于 k 则计数：
class Solution:
def subarraySum(self, nums: List[int], k: int) -> int:
ans = 0
n = len(nums)
for i in range(n):
s = 0
for j in range(i, n):
s += nums[j]
if s == k:
ans += 1
return ans
内层循环从 i 向右累加，避免重复计算区间和，时间复杂度 $O(n^2)$，仍会超时。瓶颈在于：对每个终点 j，我们要知道有多少个起点 i，使得 nums[i:j+1] 的和为 k——能否不逐个枚举 i？
设 prefix[j] 为 nums[0..j] 的前缀和，则子数组 nums[i+1..j] 的和为：
$$ \text{prefix}[j] - \text{prefix}[i] = k \quad \Leftrightarrow \quad \text{prefix}[i] = \text{prefix}[j] - k $$
对每个终点 j，问题转化为：在 j 之前，有多少个前缀和恰好等于 prefix[j] - k？若用哈希表记录「每个前缀和出现了几次」，查询就是 $O(1)$ 的。
从左到右扫描，维护当前前缀和 Sum，并用字典 d 记录已出现过的前缀和及其频次：
d[0] = 1：空前缀的和为 0，出现 1 次。这样当某个子数组本身（从下标 0 开始）的和恰好为 k 时，Sum - k = 0 也能被正确计数。nums[i]：Sum += x，当前前缀和更新。ans += d[Sum - k]，即统计此前有多少个前缀和等于 Sum - k，每个都对应一段和为 k 的子数组。d[Sum] += 1，把当前前缀和记入哈希表，供后续位置查询。以 nums = [1, 2, 3]、k = 3 为例：
i |
x |
Sum |
Sum - k |
d[Sum-k] |
ans |
d（更新后） |
|---|---|---|---|---|---|---|
| 0 | 1 | 1 | -2 | 0 | 0 | {0:1, 1:1} |
| 1 | 2 | 3 | 0 | 1 | 1 | {0:1, 1:1, 3:1} |
| 2 | 3 | 6 | 3 | 1 | 2 | {0:1, 1:1, 3:1, 6:1} |
i = 1 时：Sum = 3，d[0] = 1 表示存在空前缀，对应子数组 [1, 2]（下标 0~1）。i = 2 时：Sum = 6，d[3] = 1 表示此前前缀和 3 出现一次（在 i = 1），对应子数组 [3]（下标 2）。最终答案为 2。
以 nums = [1, 1, 1]、k = 2 为例：
i |
x |
Sum |
Sum - k |
d[Sum-k] |
ans |
|---|---|---|---|---|---|
| 0 | 1 | 1 | -1 | 0 | 0 |
| 1 | 1 | 2 | 0 | 1 | 1 |
| 2 | 1 | 3 | 1 | 1 | 2 |
i = 1 时命中空前缀，得到 [1, 1]（下标 0~1）；i = 2 时命中前缀和 1，得到 [1, 1]（下标 1~2）。注意相同数值的子数组因起点不同要分别计数，哈希表用「频次」而非「是否出现」正是为此服务。
若数组元素全为正数，可用滑动窗口：右扩累加和，和超过 k 则左缩，和等于 k 时计数。但本题 nums[i] 可为负数——左缩一位后区间和可能变小，也可能变大，无法保证单调性，滑动窗口会漏解或重复计数。前缀和 + 哈希表不依赖单调性，是此题的通用正解。
from collections import defaultdict
class Solution:
def subarraySum(self, nums: List[int], k: int) -> int:
d = defaultdict(int)
d[0] = 1
Sum = ans = 0
for i, x in enumerate(nums):
Sum += x
ans += d[Sum - k]
d[Sum] += 1
return ans
算法层面前缀和 + 哈希表已达 $O(n)$ 最优（至少需读一遍数组），无法再降时间复杂度。以下优化侧重代码规范与可读性。
dict.getSum 按 PEP 8 宜改为 prefix_sum 或 s；若不想引入 defaultdict，普通字典配合 .get(key, 0) 语义等价，依赖更少：
class Solution:
def subarraySum(self, nums: List[int], k: int) -> int:
cnt = {0: 1}
prefix_sum = ans = 0
for x in nums:
prefix_sum += x
ans += cnt.get(prefix_sum - k, 0)
cnt[prefix_sum] = cnt.get(prefix_sum, 0) + 1
return ans
Counter 表达「频次统计」若更习惯「计数」语义，可将 d 换为 Counter，逻辑不变：
from collections import Counter
class Solution:
def subarraySum(self, nums: List[int], k: int) -> int:
cnt = Counter({0: 1})
prefix_sum = ans = 0
for x in nums:
prefix_sum += x
ans += cnt[prefix_sum - k]
cnt[prefix_sum] += 1
return ans
Counter 对缺失键默认返回 0，与 defaultdict(int) 行为一致。三种写法时间、空间均为 $O(n)$，按团队风格择一即可。
给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到最右侧。你只可以看到在滑动窗口内的 k 个数字，滑动窗口每次只向右移动一位。
返回滑动窗口中的最大值组成的数组。
整数数组 nums，整数 k
长度为 n - k + 1 的整数数组，每个元素为对应窗口内的最大值
1 <= nums.length <= 10^5-10^4 <= nums[i] <= 10^41 <= k <= nums.lengthinput: nums = [1,3,-1,-3,5,3,6,7], k = 3
output: [3,3,5,5,6,7]
解释：窗口位置与最大值如下：
| 窗口位置 | 窗口内元素 | 最大值 |
|---|---|---|
[1 3 -1] |
1, 3, -1 |
3 |
[3 -1 -3] |
3, -1, -3 |
3 |
[-1 -3 5] |
-1, -3, 5 |
5 |
[-3 5 3] |
-3, 5, 3 |
5 |
[5 3 6] |
5, 3, 6 |
6 |
[3 6 7] |
3, 6, 7 |
7 |
input: nums = [1], k = 1
output: [1]
题目要求对每个长度为 k 的连续子数组求最大值。暴力枚举每个窗口再逐个比较，在 $n$ 可达 $10^5$、$k$ 也可能很大时会超时。能否在窗口右移时复用已算过的信息，而不是每次都重新扫一遍？
最直观的做法：枚举每个窗口起点 i，在 nums[i:i+k] 内找最大值：
class Solution:
def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
res = []
n = len(nums)
for i in range(n - k + 1):
res.append(max(nums[i:i + k]))
return res
每个窗口调用 max 扫 $k$ 个元素，时间复杂度 $O(nk)$。当 $k$ 接近 $n$ 时接近 $O(n^2)$，会超时。瓶颈在于：相邻两个窗口有大量重叠元素，却每次都从零开始比较——能否记住「谁还有资格当最大值」？
用大根堆存窗口内的 (值, 下标)，每次右移：
(nums[i], i) 入堆下标 <= i - k），则弹出import heapq
class Solution:
def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
heap = []
res = []
for i, x in enumerate(nums):
heapq.heappush(heap, (-x, i))
if i >= k - 1:
while heap[0][1] <= i - k:
heapq.heappop(heap)
res.append(-heap[0][0])
return res
堆中最多 $k$ 个元素，每次入堆、出堆 $O(\log k)$，总时间 $O(n \log k)$，比暴力优，但每个元素仍可能被多次入堆（旧的大值暂时留在堆里需惰性删除），常数也不小。能否让每个下标最多进出数据结构一次？
维护一个队列 q，存的是下标（不是值本身），并保证对应数值从队首到队尾单调递减——队首 q[0] 永远是当前窗口最大值的下标。
对每个新元素 nums[i]：
nums[q[-1]] <= nums[i]，则 q[-1] 对应的元素比 i 更旧且更小，在之后任何包含 i 的窗口里都不可能成为最大值，持续 pop 直到队尾更大或队空。i 追加到队尾。i - q[0] >= k，说明 q[0] 已不在窗口 [i-k+1, i] 内，pop 队首。i >= k - 1 时，窗口成形，答案为 nums[q[0]]。以 nums = [1, 3, -1, -3, 5, 3, 6, 7]、k = 3 为例：
i |
x |
队尾淘汰 | q（下标） |
对应值 | 滑出淘汰 | res |
|---|---|---|---|---|---|---|
| 0 | 1 | — | [0] |
[1] |
— | — |
| 1 | 3 | 弹出 0（1≤3） |
[1] |
[3] |
— | — |
| 2 | -1 | — | [1,2] |
[3,-1] |
— | [3] |
| 3 | -3 | — | [1,2,3] |
[3,-1,-3] |
— | [3,3] |
| 4 | 5 | 弹出 3,2,1 |
[4] |
[5] |
— | [3,3,5] |
| 5 | 3 | — | [4,5] |
[5,3] |
— | [3,3,5,5] |
| 6 | 6 | 弹出 5,4 |
[6] |
[6] |
— | [3,3,5,5,6] |
| 7 | 7 | 弹出 6 |
[7] |
[7] |
— | [3,3,5,5,6,7] |
关键观察：
class Solution:
def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
q = []
res = []
for i, x in enumerate(nums):
while q and nums[q[-1]] <= x: q.pop()
q.append(i)
if i - q[0] >= k: q.pop(0)
if i >= k - 1: res.append(nums[q[0]])
return res
上面已给出两种非暴力思路，对比如下：
| 对比项 | 大根堆 + 惰性删除 | 单调递减队列 |
|---|---|---|
| 时间 | $O(n \log k)$ | $O(n)$ |
| 每个下标进出次数 | 可能多次入堆 | 最多各一次 |
| 思路难度 | 较低，堆是常见工具 | 需理解「单调性」与「淘汰」 |
| 适用 | $k$ 很小时足够快 | 本题最优解 |
若面试时一时想不出单调队列，堆是可靠的 $O(n \log k)$ 备选；若要求 $O(n)$ 或 $k$ 很大，单调队列是标准正解。两者都利用了「窗口右移时淘汰过期信息」，但单调队列通过按值单调直接扔掉永远不可能胜出的候选，避免了堆的重复存储与惰性删除。
算法层面单调队列已达 $O(n)$ 最优（至少需读一遍数组）。以下优化侧重实现细节：列表 pop(0) 会整体前移元素，单次 $O(k)$，最坏总复杂度退化为 $O(nk)$；改用双端队列可使队首删除变为 $O(1)$。
deque 替代列表作队列collections.deque 的 popleft() 为 $O(1)$，语义与 pop(0) 相同，整体保证 $O(n)$：
from collections import deque
class Solution:
def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
q = deque()
res = []
for i, x in enumerate(nums):
while q and nums[q[-1]] <= x:
q.pop()
q.append(i)
if i - q[0] >= k:
q.popleft()
if i >= k - 1:
res.append(nums[q[0]])
return res
窗口滑出判断可与答案记录写在同一逻辑块，用早期 continue 跳过未成形的窗口，主流程更清晰：
from collections import deque
class Solution:
def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
q = deque()
res = []
for i, x in enumerate(nums):
while q and nums[q[-1]] <= x:
q.pop()
q.append(i)
if i < k - 1:
continue
if q[0] <= i - k:
q.popleft()
res.append(nums[q[0]])
return res
注意此处先判断 i >= k - 1 再淘汰队首，与原版「先淘汰再取答案」等价：当 i = k - 1 时，队首下标最小为 0，0 <= i - k 不成立，不会误删。两种写法时间均为 $O(n)$，推荐 deque + 适当换行以兼顾性能与可读性。
给你三个整数 n、l 和 r。
长度为 n 的锯齿形数组定义如下：
[l, r]；返回满足条件的锯齿形数组的总数。由于答案可能很大，请将结果对 $10^9 + 7$ 取余数。
严格递增：每个元素都严格大于它的前一个元素（如果存在）。
严格递减：每个元素都严格小于它的前一个元素（如果存在）。
三个整数 n、l、r
满足条件的锯齿形数组总数（对 $10^9 + 7$ 取余）
3 <= n <= 20001 <= l < r <= 2000input: n = 3, l = 4, r = 5
output: 2
解释：取值范围 [4, 5] 内，长度为 3 的锯齿形数组只有 [4, 5, 4] 和 [5, 4, 5] 两种。
input: n = 3, l = 1, r = 3
output: 10
解释：取值范围 [1, 3] 内，长度为 3 的锯齿形数组共有 10 种，例如 [1, 2, 1]、[2, 1, 3]、[3, 2, 3] 等，均满足锯齿形条件。
题目要求统计长度为 n、元素在 [l, r] 内、且满足「相邻不等」与「不能有三连单调」的数组总数。n 和取值范围均可达 2000，暴力枚举所有数组显然不可行，需要动态规划。
最容易想到的是：逐位填数，每填一个新元素时检查「是否与前一数不同」以及「最近三个数是否单调」。这是标准的 DFS / 回溯思路，但状态空间约为 $O(k^n)$（$k = r - l + 1$），在 $n = 2000$ 时完全无法接受。
换一个角度：锯齿形的核心约束其实落在相邻两数的大小关系上——
因此，只要知道最后两个数的大小关系（递增还是递减），就能判断下一个数该往哪边放，而无需记录更长的历史。
将取值 [l, r] 映射为相对下标 0, 1, …, k-1（$k = r - l + 1$），定义：
f0[i][j]：长度为 i、第 i 个数为 l + j，且最后两个数严格递增的方案数；f1[i][j]：长度为 i、第 i 个数为 l + j，且最后两个数严格递减的方案数。长度为 1 的数组还没有「最后两个数」，初始化时每个取值各 1 种方案。
要从长度 i - 1 扩展到长度 i，在位置 j 填上新元素 l + j：
转移到 f0[i][j]（末尾递增，即 $a_{i-1} < a_i$）
上一个状态必须是「末尾递减」的 f1[i-1][k]，且要求 $l + k < l + j$，即 $k < j$：
$$f0[i][j] = \sum_{k=0}^{j-1} f1[i-1][k]$$
转移到 f1[i][j]（末尾递减，即 $a_{i-1} > a_i$）
上一个状态必须是「末尾递增」的 f0[i-1][k]，且要求 $l + k > l + j$，即 $k > j$：
$$f1[i][j] = \sum_{k=j+1}^{k-1} f0[i-1][k]$$
直接双重循环转移是 $O(k^2)$ 每层，总复杂度 $O(n \cdot k^2)$，在 $n, k \le 2000$ 时会超时。观察转移式：一个是前缀和，一个是后缀和。
对 f1[i-1] 做前缀和 pre，则 $f0[i][j] = pre[j-1]$（$j = 0$ 时为 0）。
对 f0[i-1] 做后缀和 suf，则 $f1[i][j] = suf[j+1]$（$j = k-1$ 时为 0）。
每层更新降为 $O(k)$，总时间 $O(n \cdot k)$。
f0 和 f1 交替依赖，可以用同一个数组原地滚动：
u % 2 == 0）：当前数组视为 f0，做后缀和得到新的 f1；u % 2 == 1）：当前数组视为 f1，做前缀和得到新的 f0。以 n = 3, l = 4, r = 5（$k = 2$）为例：
轮次 u |
操作 | 数组 f |
含义 |
|---|---|---|---|
| 初始 | — | [1, 1] |
长度 1，每个取值 1 种 |
| 0 | 后缀和 | [1, 0] |
长度 2，末尾递减 |
| 1 | 前缀和 | [0, 1] |
长度 3，末尾递增 |
sum(f) = 1，最终答案 1 × 2 = 2，与示例一致。
经过 n - 1 轮转移后，数组里只保留了一种末尾方向的状态（n 为奇数时对应 f0，n 为偶数时对应 f1）。
但合法的锯齿形数组在结尾处可以是「末尾递增」或「末尾递减」两种，且由于前缀和与后缀和的对称性，两种方向的方案总数相等：
$$\sum_j f0[n][j] = \sum_j f1[n][j]$$
因此最终答案为 sum(f) * 2。
class Solution:
def zigZagArrays(self, n: int, l: int, r: int) -> int:
"""
f0[i][j]: 包含 i 个数，第 i 个数是 j，且后两个数递增的方案数
f1[i][j]: 包含 i 个数，第 i 个数是 j，且后两个数递减的方案数
f0[i][j] = sum(f1[i - 1][k], k in [0, j - 1])
f1[i][j] = sum(f0[i - 1][k], k in [j + 1, k - 1])
"""
mod = 1_000_000_007
k = r - l + 1
f = [1] * k
for u in range(n - 1):
if u % 2:
pre = 0
for i, v in enumerate(f):
f[i] = pre % mod
pre += v
else:
suf = 0
for i in range(k - 1, -1, -1):
v = f[i]
f[i] = suf % mod
suf += v
return sum(f) * 2 % mod
上一节用「末尾递增 / 末尾递减」描述状态，与力扣官方提示的 dp[i][dir][x] 本质相同，只是 dir 的编码方式不同。若从下一步该往哪边走来理解，转移会更直观。
定义 dp[i][dir][x]：长度为 i、以值 x 结尾、且下一个元素相对 x 必须：
dir = 1（上升）：下一个数 $> x$；dir = 0（下降）：下一个数 $< x$。这与上一节的对应关系为：
| 上一节 | 本节 | 含义 |
|---|---|---|
f0[i][j] 末尾递增 |
dp[i][0][j] |
刚经历了上升，下一步必须下降 |
f1[i][j] 末尾递减 |
dp[i][1][j] |
刚经历了下降，下一步必须上升 |
「不能三连单调」正是强制方向交替：每次填数后，下一步的方向与上一步相反。
若当前要求上升（dir = 1），可从所有「上一步要求下降、且值小于 y」的状态转移而来：
$$dp[i+1][0][y] \mathrel{+}= \sum_{x < y} dp[i][1][x]$$
若当前要求下降（dir = 0），则从所有「上一步要求上升、且值大于 y」的状态转移：
$$dp[i+1][1][y] \mathrel{+}= \sum_{x > y} dp[i][0][x]$$
这与上一节的 f0 / f1 转移完全等价，同样可用前缀和 / 后缀和优化到 $O(n \cdot k)$。
dir当题目要求输出以特定方向结尾的方案数，或需要区分「第一个元素比第二个大 / 小」时，应同时维护 dp[i][0] 和 dp[i][1] 两个数组，而不能在结尾用 × 2 合并。
本题只统计总数，且两种结尾方向的方案数对称相等，故压缩为一个滚动数组并在最后 × 2 是合理的。
上一节的实现已经是时间最优的 $O(n \cdot k)$ 写法。以下从可读性和语义清晰度两方面给出优化建议。
将两种末尾方向拆成两个数组，逻辑更直白，也省去结尾 × 2 的对称性说明：
class Solution:
def zigZagArrays(self, n: int, l: int, r: int) -> int:
mod = 1_000_000_007
k = r - l + 1
f0 = f1 = [1] * k # 长度 1 时两种方向尚未区分，各自为 1
for _ in range(n - 1):
# f0[i][j] = prefix_sum(f1[i-1])[j]
pre = 0
new_f0 = [0] * k
for j in range(k):
new_f0[j] = pre % mod
pre = (pre + f1[j]) % mod
# f1[i][j] = suffix_sum(f0[i-1])[j]
suf = 0
new_f1 = [0] * k
for j in range(k - 1, -1, -1):
new_f1[j] = suf % mod
suf = (suf + f0[j]) % mod
f0, f1 = new_f0, new_f1
return (sum(f0) + sum(f1)) % mod
注意：长度 1 时 f0 与 f1 同为 [1,…,1] 会在第一次转移时各自统计到所有合法的长度 2 序列，不会重复计数。渐近复杂度不变，空间为 $O(k)$（两个数组可进一步优化为交替复用）。
原实现用 u % 2 在两种更新间切换，极为紧凑。若更在意可读性，可将「前缀和原地变换」和「后缀和原地变换」写成两个独立的小循环，避免读者反复推断奇偶轮的含义：
def to_prefix(f: list[int], mod: int) -> None:
pre = 0
for i, v in enumerate(f):
f[i] = pre % mod
pre = (pre + v) % mod
def to_suffix(f: list[int], mod: int) -> None:
suf = 0
for i in range(len(f) - 1, -1, -1):
v = f[i]
f[i] = suf % mod
suf = (suf + v) % mod
主循环中按轮次调用 to_suffix / to_prefix 即可，行为与原代码完全一致。
| 写法 | 优点 | 适用场景 |
|---|---|---|
单数组 + 奇偶切换 + × 2 |
最省空间、代码最短 | 竞赛、已理解对称性时 |
双数组 f0 / f1 |
语义清晰、无需 × 2 |
初学 DP、需要调试中间状态 |
| 抽取前缀 / 后缀函数 | 可读性好、便于复用 | 团队代码、题解讲解 |
本题 $n, k \le 2000$，三种写法的时间均为 $O(n \cdot k)$，空间均为 $O(k)$，性能差距极小。日常刷题推荐原版的单数组写法；若需要向他人讲解，双数组版本更易于逐步验证。
]]>给你一个字符串 text，你可以使用其中的字符来组成尽可能多的单词 "balloon"。
给你一个字符串 text，计算并返回能够拼成 "balloon" 的最大数量。
字符串 text
能拼出的 "balloon" 最大数量
1 <= text.length <= 10^4text 仅由小写英文字母组成input: text = "nlaebolko"
output: 1
解释：用 text 中的字符可以拼出一个 "balloon"。
input: text = "loonbalxballpoon"
output: 2
解释：可以拼出两个 "balloon"，剩余字符无法继续拼出第三个。
input: text = "leetcode"
output: 0
解释：text 中没有字母 b，无法拼出任何 "balloon"。
题目要求用 text 中的字符拼出尽可能多的 "balloon"。每个字符只能使用一次，且拼出的单词必须恰好是 "balloon"。
最容易想到的是：在 text 里反复「找齐」一组 b-a-l-l-o-o-n，凑齐就 ans += 1，直到再也凑不齐为止。但每凑一组都要在剩余字符里重新扫描、匹配，实现繁琐，也容易在重复字母上出错。
换一个角度：与其模拟「一组一组地拼」，不如先问——拼一个 "balloon" 到底需要哪些字母、各要几个？ 答案一旦固定，整道题就变成了「资源够不够」的问题。
把 "balloon" 的字母拆开统计：
| 字母 | b |
a |
l |
o |
n |
|---|---|---|---|---|---|
| 出现次数 | 1 | 1 | 2 | 2 | 1 |
也就是说，每拼出 1 个 "balloon"，就要消耗 1 个 b、1 个 a、2 个 l、2 个 o、1 个 n。
因此第一步很直接：遍历 text，统计每个字母出现了多少次。Python 里用 Counter(text) 一行即可完成。
以 text = "loonbalxballpoon" 为例，统计结果为：
| 字母 | b |
a |
l |
o |
n |
其他 |
|---|---|---|---|---|---|---|
| 频次 | 2 | 2 | 4 | 4 | 2 | x: 1, p: 1 |
有了各字母的存量，能拼几个 "balloon" 取决于最紧缺的那类字母——就像木桶能装多少水，取决于最短的那块板。
每种字母能「支撑」的 balloon 数量如下：
b：每个 balloon 用 1 个 → 最多 cnt['b'] 个a：每个 balloon 用 1 个 → 最多 cnt['a'] 个l：每个 balloon 用 2 个 → 最多 cnt['l'] // 2 个o：每个 balloon 用 2 个 → 最多 cnt['o'] // 2 个n：每个 balloon 用 1 个 → 最多 cnt['n'] 个最终答案就是上述五个值中的最小值：
$$\text{ans} = \min\big(\text{cnt['b']},\ \text{cnt['a']},\ \text{cnt['l']} // 2,\ \text{cnt['o']} // 2,\ \text{cnt['n']}\big)$$
继续以上面的例子：min(2, 2, 4//2, 4//2, 2) = min(2, 2, 2, 2, 2) = 2，与示例输出一致。
Counter 对不存在的键会返回 0（例如 text = "leetcode" 中没有 b，cnt['b'] 为 0），因此 min 自然得到 0，无需额外判空。
text 长度，统计字母频次需遍历一次from collections import Counter
class Solution:
def maxNumberOfBalloons(self, text: str) -> int:
cnt = Counter(text)
return min(cnt['b'], cnt['a'], cnt['l'] // 2, cnt['o'] // 2, cnt['n'])
上一节用 Counter(text) 统计了 text 中所有字母的频次。但拼 "balloon" 只会用到 b、a、l、o、n 这五个字母——text 里其余的字符（如示例中的 x、p）对答案没有任何贡献。
拼单词时，多出来的字母既不能被「存起来」给下次用，也不会参与任何一次 "balloon" 的组成。因此统计阶段只需关心这五个目标字母，其余字符完全可以跳过。
这样做的好处是：
text 很长、字母种类很多时）。维护一个长度为 5 的计数器（或用字典映射），遍历 text 时，若当前字符属于 {b, a, l, o, n} 才累加，否则直接跳过。遍历结束后，同样用木桶原理取 min 即可。
以 text = "leetcode" 为例，五个相关字母的计数全为 0，min 结果为 0；以 text = "nlaebolko" 为例，统计得 b=1, a=1, l=2, o=2, n=1，min(1, 1, 1, 1, 1) = 1。
逻辑与上一节完全一致，区别仅在于「统计谁」——从「全体字母」收窄为「目标字母」。
Counter 写法已经足够简洁正确。若希望在代码层面进一步精简或避免依赖 collections，可以从以下方向优化。
min把每种字母的需求写进字典，用循环统一计算「该字母最多能支撑几个 balloon」，避免在 return 里重复写五个参数：
class Solution:
def maxNumberOfBalloons(self, text: str) -> int:
need = {'b': 1, 'a': 1, 'l': 2, 'o': 2, 'n': 1}
cnt = {c: 0 for c in need}
for c in text:
if c in cnt:
cnt[c] += 1
return min(cnt[c] // need[c] for c in need)
字母种类固定为 5，循环开销可忽略；若日后单词变化，只需改 need 字典，扩展性更好。
字母均为小写，ord(c) - ord('a') 可作下标，用整型数组计数，访问比字典略快：
class Solution:
def maxNumberOfBalloons(self, text: str) -> int:
cnt = [0] * 26
for c in text:
cnt[ord(c) - ord('a')] += 1
return min(cnt[ord(c) - ord('a')] // need
for c, need in [('b', 1), ('a', 1), ('l', 2), ('o', 2), ('n', 1)])
渐近复杂度仍为 $O(n)$ 时间、$O(1)$ 空间，适合对常数敏感的场景。
| 写法 | 优点 | 适用场景 |
|---|---|---|
Counter + 手写 min |
最短、最易读 | 日常刷题、面试快速作答 |
| 需求表 + 循环 | 易扩展、逻辑集中 | 单词组成可能变化时 |
| 数组计数 | 常数更小 | 对性能有要求的实现 |
本题数据规模 $n \le 10^4$，三种写法差距极小；首选 Counter 版本即可，其余作为代码风格与扩展性的备选。
夏日炎炎，小男孩 Tony 想买一些雪糕消消暑。
商店中新到 n 支雪糕，用长度为 n 的数组 costs 表示雪糕的定价，其中 costs[i] 表示第 i 支雪糕的现金价格。Tony 一共有 coins 现金可以用于消费，他想要买尽可能多的雪糕。
注意： Tony 可以按任意顺序购买雪糕。
给你价格数组 costs 和现金量 coins，请你计算并返回 Tony 用 coins 现金能够买到的雪糕的最大数量。
整数数组 costs，整数 coins
能买到的雪糕最大数量
1 <= costs.length == n <= 10^51 <= costs[i] <= 10^51 <= coins <= 10^8input: costs = [1,3,2,4,1], coins = 7
output: 4
解释：Tony 可以买下标为 0、1、2、4 的雪糕，总价为 1 + 3 + 2 + 1 = 7。
input: costs = [10,6,8,7,7,8], coins = 5
output: 0
解释：Tony 没有足够的钱买任何一支雪糕。
input: costs = [1,6,3,1,2,5], coins = 20
output: 6
解释：Tony 可以买下所有的雪糕，总价为 1 + 6 + 3 + 1 + 2 + 5 = 18。
题目只要求数量最多，且 Tony 可以按任意顺序购买。在总花费不超过 coins 的前提下，怎样选才能买到最多支雪糕？
最容易想到的是：枚举所有子集或排列，找出花费不超过 coins 且数量最大的那一组。但 n 可达 10^5，子集规模是指数级，显然不可行。
换一个角度：每支雪糕的价格不同，而目标只是「多买几支」。在钱有限时，直觉上应该优先买便宜的——同样的钱，买便宜的能多换几支。
形式化地说：若存在两支雪糕，价格分别为 a < b，而当前方案先买了价格为 b 的那支、却跳过了价格为 a 的，那么把这次购买换成 a，会省下 b - a 的现金，后续至少不会比原来更差（多出来的钱还能继续买别的）。因此，最优方案里一定不会出现「放着更便宜的没买，却买了更贵的」这种情况。
结论：按价格从低到高依次购买，能买到的就买，买不到就停——这就是贪心策略。
要实现「从便宜到贵」，先把 costs 升序排序，再从左到右遍历：若当前剩余现金 coins 够付这支雪糕的价格 x，就买下来（ans += 1，coins -= x）；否则后面的价格只会更高，直接结束。
以 costs = [1,3,2,4,1], coins = 7 为例，排序后 costs = [1,1,2,3,4]：
价格 x |
coins（买前） |
能否购买 | ans |
coins（买后） |
|---|---|---|---|---|
| 1 | 7 | 是 | 1 | 6 |
| 1 | 6 | 是 | 2 | 5 |
| 2 | 5 | 是 | 3 | 3 |
| 3 | 3 | 是 | 4 | 0 |
| 4 | 0 | 否 | 4 | 0 |
最终 ans = 4，与示例输出一致。
class Solution:
def maxIceCream(self, costs: List[int], coins: int) -> int:
costs.sort()
ans = 0
for i, x in enumerate(costs):
if coins >= x:
ans += 1
coins -= x
return ans
上一节用内置 sort 完成排序，复杂度 $O(n \log n)$。观察约束：costs[i] 取值范围为 $[1, 10^5]$，是一个有界整数——此时可以用计数排序在 $O(n + V)$ 时间内完成「按价格分组」，其中 $V$ 为价格上界。
比较排序的下界是 $O(n \log n)$，与元素取值范围无关。当 $V = \max(\text{costs}) \le 10^5$ 且 $n$ 也约为 $10^5$ 时，$O(n + V)$ 与 $O(n \log n)$ 同阶，但常数更小；若 $V \ll n$（价格种类少），计数排序优势更明显。
力扣本题也提示「必须使用计数排序」，核心思想正是：价格范围有限，不必对 $n$ 个元素做通用比较排序。
先统计每个价格 p 出现了多少次 cnt[p]，再从 p = 1 到 max(costs) 枚举：
p 的雪糕只需 p * cnt[p]，且 coins 够付，则全部买下；coins // p 支，买完即停。价格高于 coins 的桶无需再看（买一支都不够），枚举上界可截断为 min(max(costs), coins)。
以 costs = [1,3,2,4,1], coins = 7 为例，计数后 cnt[1]=2, cnt[2]=1, cnt[3]=1, cnt[4]=1：
价格 p |
cnt[p] |
全买花费 | coins（买前） |
操作 | ans |
coins（买后） |
|---|---|---|---|---|---|---|
| 1 | 2 | 2 | 7 | 全买 2 支 | 2 | 5 |
| 2 | 1 | 2 | 5 | 买 1 支 | 3 | 3 |
| 3 | 1 | 3 | 3 | 买 1 支 | 4 | 0 |
| 4 | 1 | 4 | 0 | 买不起，停止 | 4 | 0 |
答案仍为 4。贪心逻辑与排序扫描完全一致，只是把「逐支遍历」换成了「按价格桶批量处理」。
排序贪心已是正确且简洁的写法，优化空间主要在提前终止、写法精简，以及结合计数数组做批量购买。
break排序后价格单调不降，一旦 coins < x，后面的雪糕一定也买不起，无需继续循环：
class Solution:
def maxIceCream(self, costs: List[int], coins: int) -> int:
costs.sort()
ans = 0
for x in costs:
if coins < x:
break
ans += 1
coins -= x
return ans
enumerate循环中并未使用下标 i，直接 for x in costs 更干净，语义也更贴近「按价格从低到高依次尝试」。
当同一价格出现多次时，逐支扣款会产生多余循环。用计数数组按桶处理，每轮用 min(cnt[p], coins // p) 一次算清能买几支：
class Solution:
def maxIceCream(self, costs: List[int], coins: int) -> int:
mx = max(costs)
cnt = [0] * (mx + 1)
for x in costs:
cnt[x] += 1
ans = 0
for p in range(1, min(mx, coins) + 1):
if cnt[p] == 0:
continue
take = min(cnt[p], coins // p)
ans += take
coins -= take * p
if coins == 0:
break
return ans
与排序版贪心等价，在价格重复较多时循环次数更少；渐近复杂度为 $O(n + \min(V, \text{coins}))$，是本题在思路层面更贴合数据范围的写法。
]]>在一座城市里，你需要建 n 栋新的建筑，编号从 1 到 n 排成一列。城市有如下规定：
1 栋建筑的高度必须是 0；1。此外，部分建筑还有额外的高度上限。restrictions[i] = [idi, maxHeighti] 表示建筑 idi 的高度不能超过 maxHeighti。题目保证每个 idi 唯一，且建筑 1 不会出现在 restrictions 中。
请你返回所有建筑中最高的那栋能达到的最大高度。
整数 n，二维整数数组 restrictions
最高建筑能达到的最大高度
2 <= n <= 10^90 <= restrictions.length <= min(n - 1, 10^5)2 <= idi <= n，idi 互不相同0 <= maxHeighti <= 10^9input: n = 5, restrictions = [[2,1],[4,1]]
output: 2
解释：可使建筑高度为 [0,1,2,1,2]，最高建筑高度为 2。
input: n = 6, restrictions = []
output: 5
解释：无额外限制时，高度可依次为 [0,1,2,3,4,5]，最高为 5。
input: n = 10, restrictions = [[5,3],[2,5],[7,4],[10,3]]
output: 5
解释：可使建筑高度为 [0,1,2,3,3,4,4,5,4,3]，最高为 5。
题目同时施加了三类约束：起点为 0、相邻高度差不超过 1、部分位置有高度上限。n 可达 10^9，无法逐栋枚举，需要找到少量「关键位置」集中处理。
最容易想到的是：对每一栋建筑 i，从左侧（建筑 1 高度 0）和右侧（建筑 n 无上限）分别推算它能达到的最大高度，再取两者较小值。但关键建筑有 10^5 个、总栋数有 10^9 个，逐栋计算显然不可行。
观察示例可以发现：高度上限只出现在 restrictions 给出的位置，其余建筑的高度由相邻关系和这些「卡点」共同决定。因此真正需要关心的，只有有限个关键位置——起点、终点，以及所有受限建筑。
任意合法高度序列中，全局最高点要么落在某个关键位置上，要么落在两个关键位置之间的某栋建筑上。
考虑相邻关键位置 $x_i$ 与 $x_{i+1}$，其间距离为 $d = x_{i+1} - x_i$。若位置 $x_i$ 处高度上界为 $h_i$，$x_{i+1}$ 处为 $h_{i+1}$，则这段区间内能抬起的最高「山峰」高度为：
$$ \text{peak} = \left\lfloor \frac{h_i + h_{i+1} + d}{2} \right\rfloor $$
直觉上：从左侧以不超过 $h_i$ 的高度出发，以每步最多 $+1$ 的斜率向中间爬升，同时从右侧以不超过 $h_{i+1}$ 的高度以每步最多 $+1$ 向中间爬升，两坡在中点相遇时即得峰值。最终答案就是所有区间 peak 的最大值。
因此问题归结为两步：
restrictions 中不含建筑 1 和建筑 n，但它们是天然的关键点。补入边界后统一排序：
[1, 0]：建筑 1 高度固定为 0；[n, inf]：建筑 n 无高度上限（用 inf 表示）。restrictions += [[1, 0], [n, inf]]
restrictions.sort()
以示例 1（n = 5, restrictions = [[2,1],[4,1]]）为例，排序后得到：
下标 i |
位置 x |
限制 limit |
|---|---|---|
| 0 | 1 | 0 |
| 1 | 2 | 1 |
| 2 | 4 | 1 |
| 3 | 5 | ∞ |
从左向右，假设在位置 $x_{i-1}$ 处高度最多为 $h[i-1]$，则走到 $x_i$（距离 $x_i - x_{i-1}$）时，理论上限为 $h[i-1] + (x_i - x_{i-1})$，再与该位置的显式限制取小：
$$ h[i] = \min\bigl(h[i-1] + x_i - x_{i-1},\ \text{limit}_i\bigr) $$
示例 1 正向扫描：
i |
x |
计算 | h[i] |
|---|---|---|---|
| 0 | 1 | 起点 | 0 |
| 1 | 2 | min(0+1, 1) |
1 |
| 2 | 4 | min(1+2, 1) |
1 |
| 3 | 5 | min(1+1, ∞) |
2 |
此时 h[3]=2 只考虑了从左而来的约束，尚未被右侧限制收紧。
再从右向左，用对称逻辑收紧上界。在位置 $x_{i+1}$ 处高度最多为 $h[i+1]$，则位置 $x_i$ 处来自右侧的上界为 $h[i+1] + (x_{i+1} - x_i)$，与当前值取小：
$$ h[i] = \min\bigl(h[i],\ h[i+1] + x_{i+1} - x_i\bigr) $$
示例 1 反向扫描：
i |
计算 | h[i] |
|---|---|---|
| 2 | min(1, 2+1) |
1 |
| 1 | min(1, 1+2) |
1 |
| 0 | min(0, 1+1) |
0 |
两轮扫描后，$h[i]$ 即为位置 $x_i$ 在全部约束下的高度上界。
最后枚举每对相邻关键位置，套用峰值公式：
max((x[i+1] - x[i] + h[i] + h[i+1]) // 2 for i in range(m - 1))
示例 1 各段：
| 区间 | d |
h[i] |
h[i+1] |
peak |
|---|---|---|---|---|
| 1 → 2 | 1 | 0 | 1 | (1+0+1)//2 = 1 |
| 2 → 4 | 2 | 1 | 1 | (2+1+1)//2 = 2 |
| 4 → 5 | 1 | 1 | 2 | (1+1+2)//2 = 2 |
最大值为 2，与示例输出一致。
restrictions.length + 2），排序 dominatesfrom math import inf
class Solution:
def maxBuilding(self, n: int, restrictions: List[List[int]]) -> int:
restrictions += [[1, 0], [n, inf]]
restrictions.sort()
m = len(restrictions)
h = [0] * m
for i in range(1, m):
h[i] = min(h[i - 1] + restrictions[i][0] - restrictions[i - 1][0], restrictions[i][1])
for i in range(m - 2, -1, -1):
h[i] = min(h[i], h[i + 1] + restrictions[i + 1][0] - restrictions[i][0])
return max(restrictions[i + 1][0] - restrictions[i][0] + h[i] + h[i + 1] for i in range(m - 1)) // 2
上一节的正向/反向扫描可以换一个更几何化的角度理解，有助于记住峰值公式从何而来。
相邻建筑高度差不超过 $1$，意味着高度曲线沿编号方向的斜率绝对值不超过 $1$——只能以每步 $\pm 1$ 的坡度升降。每个关键位置 $x_i$ 给出一个「天花板」$h[i]$，合法高度曲线必须始终位于这些天花板之下。
在区间 $[x_i, x_{i+1}]$ 上，曲线从左侧天花板 $h[i]$ 出发、以最大斜率 $+1$ 向中间爬升，同时从右侧天花板 $h[i+1]$ 以最大斜率 $+1$（等价于从左看是 $-1$）向中间爬升。两坡在中点相遇时达到最高，该点高度正是：
$$ \left\lfloor \frac{h[i] + h[i+1] + (x_{i+1} - x_i)}{2} \right\rfloor $$
正向扫描等价于「只保留左坡天花板」，反向扫描等价于「再叠加右坡天花板取交集」。这与力扣相似题 找到带限制序列的最大值 的「双向松弛」本质相同，只是本题将松弛后的上界用于段内峰值而非直接输出某一点的值。
从渐近复杂度看，$O(m \log m)$ 已是最优——关键位置数 $m \le 10^5 + 2$，无法再降；也不存在比直接计算峰值更优的算法范式（例如二分答案会引入额外的 $\log H$ 因子，反而更慢）。
本题时间复杂度已达最优，优化空间主要在边界处理与代码可读性。
n 的重复条目若 restrictions 中已包含 [n, maxHeight]，补入 [n, inf] 后排序会出现两个位置为 n 的条目。正确性不受影响（第二趟正向扫描距离为 0，h 不变），但可以在排序后合并：同一位置取 limit 的较小值。
restrictions += [[1, 0], [n, inf]]
restrictions.sort()
merged = [restrictions[0]]
for x, lim in restrictions[1:]:
if merged[-1][0] == x:
merged[-1][1] = min(merged[-1][1], lim)
else:
merged.append([x, lim])
restrictions = merged
将 restrictions 拆为 xs 与 limits 两个数组，循环体更紧凑，也避免反复写 restrictions[i][0]：
from math import inf
class Solution:
def maxBuilding(self, n: int, restrictions: List[List[int]]) -> int:
restrictions += [[1, 0], [n, inf]]
restrictions.sort()
xs = [x for x, _ in restrictions]
limits = [lim for _, lim in restrictions]
m = len(xs)
h = [0] * m
for i in range(1, m):
h[i] = min(h[i - 1] + xs[i] - xs[i - 1], limits[i])
for i in range(m - 2, -1, -1):
h[i] = min(h[i], h[i + 1] + xs[i + 1] - xs[i])
return max(xs[i + 1] - xs[i] + h[i] + h[i + 1] for i in range(m - 1)) // 2
语义与原写法完全一致，仅将「关键位置」与「高度上限」解耦，便于阅读与调试。
]]>有一个自行车手打算进行一场公路骑行，这条路线总共由 n + 1 个不同海拔的点组成。自行车手从海拔为 0 的点 0 开始骑行。
给你一个长度为 n 的整数数组 gain，其中 gain[i] 是点 i 和点 i + 1 的净海拔增益（可能为负）。请你返回自行车手在骑行过程中达到的最高海拔。
整数数组 gain
骑行过程中达到的最高海拔
1 <= gain.length <= 100-100 <= gain[i] <= 100input: gain = [-5,1,5,0,-7]
output: 1
解释：海拔依次为 0, -5, -4, 1, 1, -6，最高海拔为 1。
input: gain = [-4,-3,-2,-1,4,3,2]
output: 0
解释：全程海拔始终不高于起点 0。
题目给出了相邻两点之间的海拔变化量，起点海拔固定为 0。因此，每经过一个路段，当前海拔就是在原有基础上加上对应的 gain[i]——本质上是在做前缀和。
最自然的想法是：从海拔 0 出发，依次走过每一段路，记录途中出现过的最大海拔。
以 gain = [-5, 1, 5, 0, -7] 为例，逐段累加后各点的海拔为：
| 路段 | gain[i] |
当前海拔 |
|---|---|---|
| 起点 | — | 0 |
| 第 1 段 | -5 | -5 |
| 第 2 段 | 1 | -4 |
| 第 3 段 | 5 | 1 |
| 第 4 段 | 0 | 1 |
| 第 5 段 | -7 | -6 |
最高海拔出现在第 3 段之后，为 1。
accumulate 一次求出各点海拔「逐段累加」若把每一步的结果都记下来，就得到了 gain 的前缀和序列——第 i 项表示走完前 i 段路后的海拔。
Python 标准库 itertools.accumulate 正好做这件事：它按顺序把 gain 累加，生成每一步的当前海拔。题目要求的是这些海拔（连同起点 0）中的最大值，因此：
$$ \text{ans} = \max\bigl(0,\ \text{accumulate}(\text{gain})\bigr) $$
外层再与 0 取最大，是因为起点海拔 0 本身也可能就是答案（如示例 2 全程不升反降）。
gain 一次accumulate 返回迭代器，max 边读边比较，不额外存储整个前缀和数组from itertools import accumulate
class Solution:
def largestAltitude(self, gain: List[int]) -> int:
return max(max(accumulate(gain)), 0)
前缀和视角需要先「算出每一步的海拔」，再取最大。换一个角度：我们其实不必保存所有中间海拔，只需在遍历过程中维护两个量——当前海拔 alt 和历史最大 ans。
每读入一个 gain[i]，更新 alt += gain[i]，再用 ans = max(ans, alt) 刷新答案。起点 0 可作为 ans 的初始值，逻辑与上一节完全等价，只是把「先累加、再取 max」合并成了一次扫描。
以 gain = [-5, 1, 5, 0, -7] 为例：
gain[i] |
alt |
ans |
|---|---|---|
| — | 0 | 0 |
| -5 | -5 | 0 |
| 1 | -4 | 0 |
| 5 | 1 | 1 |
| 0 | 1 | 1 |
| -7 | -6 | 1 |
最终 ans = 1。时间、空间复杂度仍为 $O(n)$ 和 $O(1)$，适合在不方便使用 itertools 的环境（如部分 OJ）中手写。
本题时间复杂度已是 $O(n)$，不存在渐近意义上的更优算法。优化空间主要在表达简洁度与可读性。
maxmax(max(accumulate(gain)), 0) 需要读完整个迭代器才能得出内层最大值，再与 0 比较。利用 max 支持多参数的特性，把起点 0 一并传入更直观：
return max(0, *accumulate(gain))
语义不变：在起点 0 与所有前缀和之间取最大。
itertools）若更偏好「一眼能看懂在干什么」的写法，单次遍历同样紧凑：
class Solution:
def largestAltitude(self, gain: List[int]) -> int:
alt = ans = 0
for g in gain:
alt += g
ans = max(ans, alt)
return ans
与 accumulate 版本相比，少了标准库依赖，循环体也直接对应「逐段骑行、随时更新最高海拔」的题意——可按场景与个人习惯选择。
给你两个数 hour 和 minutes。请你返回在时钟上，由给定时间的时针和分针组成的较小角的角度（60 单位制，即一圈 360°）。
整数 hour，整数 minutes
时针与分针之间的较小夹角（浮点数）
1 <= hour <= 120 <= minutes <= 5910^-5 以内的结果都被视为正确结果input: hour = 12, minutes = 30
output: 165
input: hour = 3, minutes = 30
output: 75
input: hour = 3, minutes = 15
output: 7.5
input: hour = 4, minutes = 50
output: 155
input: hour = 12, minutes = 0
output: 0
题目要的是时针与分针之间的较小夹角，而不是有向角或较大那个角。核心在于：先把两根指针各自转过的角度算出来，再求它们之间的差，最后取「锐角/钝角中较小的那个」。
标准时钟一圈 360°，均匀分成 12 个大格、60 个小格：
因此给定 minutes 和 hour 后，两根指针相对于 12 点方向（顺时针）的角度分别为：
$$ m = 6 \times \text{minutes}, \quad h = \text{hour} \times 30 + \frac{\text{minutes}}{2} $$
以示例 3（hour = 3, minutes = 15）为例：
| 指针 | 计算 | 角度 |
|---|---|---|
| 分针 | $6 \times 15$ | $90°$ |
| 时针 | $3 \times 30 + 15/2$ | $97.5°$ |
两根指针几乎重合，夹角应为 $7.5°$。
有了 $h$ 和 $m$，两针的夹角就是它们角度之差的绝对值。但直接写 abs(h - m) 在 $h < m$ 时虽然仍正确，用「补角」形式可以统一处理，避免显式分支：
$$ \text{ans} = (h + 360 - m) \bmod 360 $$
这相当于把 $h - m$ 归一化到 $[0, 360)$：若 $h \ge m$，结果就是 $h - m$；若 $h < m$，则加上 360 再取模，等价于从分针沿顺时针方向走到时针的角度。
仍以示例 3 验证：$\text{ans} = (97.5 + 360 - 90) \bmod 360 = 7.5$。
表盘上两个方向的角度之和恒为 360°，题目要的是较小的那个，因此：
$$ \text{result} = \min(\text{ans},\ 360 - \text{ans}) $$
示例 1（hour = 12, minutes = 30）：$m = 180°$，$h = 12 \times 30 + 15 = 375°$，$\text{ans} = (375 + 360 - 180) \bmod 360 = 195°$，较小角为 $\min(195, 165) = 165°$。
示例 5（hour = 12, minutes = 0）：$m = 0°$，$h = 360°$，$\text{ans} = 0°$，两针重合，返回 $0$。
class Solution:
def angleClock(self, hour: int, minutes: int) -> float:
m = 6 * minutes
h = hour * 30 + minutes / 2
ans = (h + 360 - m) % 360
return min(ans, 360 - ans)
上面的做法先分别求出两根指针的绝对角度，再作差。换一个视角：只关心两针之间的相对位移，可以跳过「各自归位到 12 点」这一步。
分针每分钟转 $6°$，时针每分钟转 $0.5°$，相对角速度为 $6 - 0.5 = 5.5°$/分钟。因此，从整点出发，分钟带来的「追赶量」是 $5.5 \times \text{minutes}$；小时刻度带来的初始差距是 $\text{hour} \times 30°$（hour = 12 时等价于 0）。
两针夹角的绝对差可直接写为：
$$ \left| \text{hour} \times 30 - \text{minutes} \times 5.5 \right| $$
再同样取 $\min(\text{diff},\ 360 - \text{diff})$ 即可。思路与上一节等价，只是把「分针角度」和「时针因分钟产生的偏移」合并成了一项 $5.5 \times \text{minutes}$，心算时更紧凑。
本题时间复杂度已是 $O(1)$，不存在算法层面的更优渐近复杂度。优化空间主要在代码简洁性与边界表达的清晰度。
hour % 12 处理 12 点hour = 12 在表盘上与 0 点重合。当前写法中 $h = 12 \times 30 = 360°$，取模后结果仍正确，但语义上 12 点应视为第 0 格。写成 hour % 12 更直观，也避免 $h$ 出现 360、390 这类「绕了一圈」的数值：
h = hour % 12 * 30 + minutes / 2
若更在意代码紧凑，可将相对角速度公式与取较小角合并（需配合 hour % 12）：
class Solution:
def angleClock(self, hour: int, minutes: int) -> float:
diff = abs(hour % 12 * 30 - minutes * 5.5)
return min(diff, 360 - diff)
与原写法相比，变量更少、一行出结果；代价是 (h + 360 - m) % 360 那种「不用 abs、统一归一化到 $[0, 360)$」的写法在可读性上略胜一筹——可按个人偏好选择。
给你一个字符串 s，由小写英文字母和特殊字符 *、# 和 % 组成。
同时给你一个整数 k。
请根据以下规则从左到右处理 s 中的字符，构造一个新的字符串 result：
result 中。'*' 会删除 result 中的最后一个字符（如果存在）。'#' 会复制当前的 result 并追加到其自身后面。'%' 会反转当前的 result。返回最终字符串 result 中第 k 个字符（下标从 0 开始）。如果 k 超出 result 的下标索引范围，则返回 '.'。
字符串 s，整数 k
result[k]，若越界则返回 '.'
1 <= s.length <= 10^5s 只包含小写英文字母和特殊字符 *、# 和 %0 <= k <= 10^15s 后得到的 result 的长度不超过 10^15input: s = "a#b%*", k = 1
output: "a"
解释：依次得到 "a" → "aa" → "aab" → "baa" → "ba"，下标 k = 1 的字符是 'a'
input: s = "cd%#*#", k = 3
output: "d"
解释：依次得到 "c" → "cd" → "dc" → "dcdc" → "dcd" → "dcddcd"，下标 k = 3 的字符是 'd'
input: s = "z*#", k = 0
output: "."
解释：依次得到 "z" → "" → ""，result 为空串，k = 0 越界，返回 '.'
这题与 用特殊操作处理字符串Ⅰ 的处理规则完全相同，区别在于：Ⅰ 要求返回完整的 result，Ⅱ 只要求返回下标 k 处的一个字符。
Ⅰ 的做法很直接——用列表维护 result，从左到右模拟四种操作即可。若把同样思路搬到这里，在 s 较短时确实能过：
class Solution:
def processStr(self, s: str, k: int) -> str:
res = []
for c in s:
if c == '*':
if res: res.pop()
elif c == '#': res += res
elif c == '%': res.reverse()
else: res.append(c)
return res[k] if k < len(res) else '.'
但本题 result 的长度可达 $10^{15}$，'#' 每次会把长度翻倍，字符串根本无法在内存中构造出来，模拟这条路走不通。
不过我们并不需要整个 result——只要第 k 个字符。能否在不展开字符串的前提下，把 k 映射回某个原始字母呢？
构造完整字符串做不到，但追踪长度可以。从左到右扫一遍 s，用变量 sz 表示当前 result 的长度：
sz += 1'*'：删除末尾，sz = max(sz - 1, 0)'#'：复制并拼接，sz += sz（长度翻倍）'%'：反转不改变长度，跳过扫完后 sz 就是最终 result 的长度。若 k >= sz，直接返回 '.'。
以示例 1 为例，"a#b%*" 的长度变化为 $1 \to 2 \to 3 \to 3 \to 2$，最终 sz = 2，k = 1 合法。
正向知道了「最终有多长」，接下来从右往左逆推每个操作对下标 k 的影响，同时维护「当前这一步操作之后 result 的长度」sz（从最终长度出发，逐步还原到操作前的长度）。
逆推时，四种操作的「撤销」规则如下：
'*'（撤销删除）
正向删除使长度减 1，撤销则 sz += 1。
'#'（撤销复制）
正向把长度为 sz/2 的串复制成 sz，撤销先 sz //= 2。复制后 result = 前半 + 后半，若 k 落在后半段（k >= sz），则 k -= sz，映射到前半段对应位置。
'%'（撤销反转）
反转不改变长度，但下标镜像：k = sz - k - 1。
普通字母
正向追加使长度加 1，撤销则 sz -= 1。若此时 k == sz，说明目标字符就是当前这个字母，直接返回。
以示例 1 演示逆推过程。最终 sz = 2，k = 1，从右往左处理 s：
| 字符 | 操作 | 变化后 sz |
变化后 k |
|---|---|---|---|
'*' |
撤销删除 | 3 | 1 |
'%' |
撤销反转 | 3 | $3-1-1=1$ |
'b' |
撤销追加 | 2 | 1（不等于 2，继续） |
'#' |
撤销复制 | 1 | $1-1=0$（$k \ge sz$，减去前半段长度） |
'a' |
撤销追加 | 0 | $k=0=sz$，返回 'a' |
示例 2 中 s = "cd%#*#"，正向得 sz = 6，k = 3。逆推时遇到 '#' 会将 k 从 3 调整为 0，再经 '%' 镜像为 1，最终在字母 'd' 处命中。
正向、反向各遍历 s 一次，时间复杂度 $O(n)$，空间复杂度 $O(1)$。
class Solution:
def processStr(self, s: str, k: int) -> str:
sz = 0
for c in s:
if c == '*':
sz = max(sz - 1, 0)
elif c == '#':
sz += sz
elif c == '%': continue
else: sz += 1
if k >= sz: return '.'
for c in reversed(s):
if c == '*': sz += 1
elif c == '#':
sz //= 2
if k >= sz: k -= sz
elif c == '%':
k = sz - k - 1
else:
sz -= 1
if k == sz: return c
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意，必须在不复制数组的情况下原地对数组进行操作。
整数数组 nums
无返回值，原地修改 nums
1 <= nums.length <= 10^4-2^31 <= nums[i] <= 2^31 - 1input: nums = [0,1,0,3,12]
output: [1,3,12,0,0]
input: nums = [0]
output: [0]
题目要求把数组中的 0 全部挪到末尾，同时非零元素之间的相对顺序不能变，并且必须原地修改，不能另开数组。
最容易想到的是：先统计 0 的个数，再把非零元素按顺序填到前面，最后把剩余位置全部填 0。思路没问题，但通常需要额外数组或两次遍历，不够简洁。
另一种想法是：从左到右扫描，每遇到一个非零元素，就把它「写」到当前应该存放的位置。非零元素按扫描顺序依次写入，空出来的位置自然就是 0 了——这正是双指针能做的事。
用两个指针 i 和 j，初始都为 0：
i：从左到右扫描整个数组j：指向下一个非零元素应该写入的位置遍历过程中，若 nums[i] 非零，就把它交换到 nums[j]，然后 j 加一；若 nums[i] 为零，则什么都不做，继续让 i 往后走。
以 nums = [0, 1, 0, 3, 12] 为例：
i |
nums[i] |
操作 | nums |
j |
|---|---|---|---|---|
| 0 | 0 | 跳过 | [0,1,0,3,12] |
0 |
| 1 | 1 | 交换 nums[1] 与 nums[0] |
[1,0,0,3,12] |
1 |
| 2 | 0 | 跳过 | [1,0,0,3,12] |
1 |
| 3 | 3 | 交换 nums[3] 与 nums[1] |
[1,3,0,0,12] |
2 |
| 4 | 12 | 交换 nums[4] 与 nums[2] |
[1,3,12,0,0] |
3 |
遍历结束后，j 之后的元素本来就是 0 或被交换过来的 0，上表最后一行即为最终结果。
当 i == j 时交换等于没交换，因此非零元素在「前面没有零」的情况下不会被多余地移动，相对顺序也始终得以保持。
class Solution:
def moveZeroes(self, nums: List[int]) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
i = j = 0
for i in range(len(nums)):
if nums[i]:
nums[i], nums[j] = nums[j], nums[i]
j += 1
给定一个长度为 n 的整数数组 height。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i])。
找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
返回容器可以储存的最大水量。
说明： 你不能倾斜容器。
整数数组 height
容器可以储存的最大水量（整数）
n == height.length2 <= n <= 10^50 <= height[i] <= 10^4input: height = [1,8,6,2,5,4,8,3,7]
output: 49
解释：选择下标 1 和 8 的两条线，高度为 8 和 7，宽度为 7，面积为 min(8, 7) × 7 = 49。
input: height = [1,1]
output: 1
题目本质是：在数组中选两个下标 i < j，以它们为左右边界、以 min(height[i], height[j]) 为「短板」高度，计算容器面积 min(height[i], height[j]) × (j - i)，求最大值。
最直观的做法是枚举所有 (i, j) 配对，逐一计算面积并取最大值：
class Solution:
def maxArea(self, height: List[int]) -> int:
ans = 0
n = len(height)
for i in range(n):
for j in range(i + 1, n):
ans = max(ans, min(height[i], height[j]) * (j - i))
return ans
思路正确，但时间复杂度为 $O(n^2)$，在 $n$ 可达 $10^5$ 时会超时。我们需要找到一种能跳过大量无效配对的方法。
面积由两个因素决定：
(j - i)：两指针越靠近，宽度越小min(height[i], height[j])：由较短的那条边决定（木桶效应）若固定左右边界后向内收缩，宽度必然减小。此时若想面积变大，只能指望高度增加——但高度受短板限制，移动较高的一边只会让宽度变小，而高度仍被原来的短板卡住，面积一定变小，可以直接排除。
反过来，移动较短的一边虽然宽度也减小了，但有机会遇到更高的线，从而抬高短板，面积仍有可能变大。
基于上述观察，用两个指针 l 和 r 分别指向数组首尾，初始时宽度最大：
min(height[l], height[r]) × (r - l)，更新答案height[l] 与 height[r]，将较短一侧的指针向内移动一步l >= r以 height = [1, 8, 6, 2, 5, 4, 8, 3, 7] 为例，前几步如下：
l |
r |
height[l] |
height[r] |
面积 | 移动 |
|---|---|---|---|---|---|
| 0 | 8 | 1 | 7 | 1 × 8 = 8 | l 右移（左侧更短） |
| 1 | 8 | 8 | 7 | 7 × 7 = 49 | r 左移（右侧更短） |
| 1 | 7 | 8 | 3 | 3 × 6 = 18 | r 左移 |
| 1 | 6 | 8 | 8 | 8 × 5 = 40 | 相等，移动 l 或 r 均可 |
遍历过程中记录到的最大面积即为 49。
为什么这样不会漏掉最优解？假设最优配对为 (i, j)，当指针尚未到达它们时，若较短边在外侧，双指针会不断将其向内推；一旦某一侧指针越过 i 或 j，说明所有以该外侧边为短板的更宽配对都已检查完毕。每个指针最多移动 $n - 1$ 次，因此总共 $O(n)$ 步。
class Solution:
def maxArea(self, height: List[int]) -> int:
ans = 0
l, r = 0, len(height) - 1
while l < r:
ans = max(ans, min(height[l], height[r]) * (r - l))
if height[l] < height[r]: l += 1
else: r -= 1
return ans
本题在算法层面，双指针 $O(n)$ 已是时间最优——不存在比线性更低的下界（至少要看一遍数组）。因此优化空间主要在代码层面。
当 height[l] == height[r] 时，移动左指针或右指针效果等价：宽度都减 1，且两侧高度相同，新面积不可能超过当前。将条件改为 <= 可统一写法，避免 if-else 两路分支：
class Solution:
def maxArea(self, height: List[int]) -> int:
ans = 0
l, r = 0, len(height) - 1
while l < r:
ans = max(ans, min(height[l], height[r]) * (r - l))
if height[l] <= height[r]:
l += 1
else:
r -= 1
return ans
在循环较密集时，可将两侧高度先存入局部变量，避免多次通过下标读取数组（对 Python 而言提升有限，但意图更清晰）：
class Solution:
def maxArea(self, height: List[int]) -> int:
ans = 0
l, r = 0, len(height) - 1
while l < r:
hl, hr = height[l], height[r]
ans = max(ans, min(hl, hr) * (r - l))
if hl <= hr:
l += 1
else:
r -= 1
return ans
给你一个整数数组 nums，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k，同时还满足 nums[i] + nums[j] + nums[k] == 0。请你返回所有和为 0 且不重复的三元组。
注意： 答案中不可以包含重复的三元组。
整数数组 nums
所有和为 0 且不重复的三元组列表
3 <= nums.length <= 3000-10^5 <= nums[i] <= 10^5input: nums = [-1,0,1,2,-1,-4]
output: [[-1,-1,2],[-1,0,1]]
解释：和为 0 的三元组有 [-1, 0, 1] 与 [-1, -1, 2]，输出顺序不限。
input: nums = [0,1,1]
output: []
input: nums = [0,0,0]
output: [[0,0,0]]
题目本质是：在数组中找出所有不重复的三元组，使其元素之和为 0。难点不在于「找不找得到」，而在于去重——同一个三元组可能对应多组下标，答案里只能出现一次。
最直观的做法是三层循环，枚举所有 (i, j, k) 组合，检查三数之和是否为 0：
class Solution:
def threeSum(self, nums: list[int]) -> list[list[int]]:
res = []
n = len(nums)
for i in range(n):
for j in range(i + 1, n):
for k in range(j + 1, n):
if nums[i] + nums[j] + nums[k] == 0:
res.append(sorted([nums[i], nums[j], nums[k]]))
return list({tuple(t) for t in res}) # 借助 set 去重
思路正确，但时间复杂度为 $O(n^3)$，在 $n$ 可达 $3000$ 时会超时；末尾还要额外去重，写法也繁琐。我们需要减少枚举量，并更优雅地处理重复。
若固定第一个数 nums[i]，问题就退化为：在剩余元素中找两个数，使三数之和为 0，即找 nums[j] + nums[k] = -nums[i]——这正是经典的两数之和。
两数之和可以用哈希表 $O(n)$ 求解，但本题要返回全部不重复三元组，哈希法去重较麻烦。更自然的做法是：先排序，再用双指针在有序数组上 $O(n)$ 找一对数。
对 nums 排序后有两个好处：
nums.sort()
用下标 i 枚举三元组的第一个元素，范围是 [0, n - 3]（后面至少还要留两个位置给 j 和 k）。
nums[i]若 nums[i] 与 nums[i - 1] 相同，以它为第一个数得到的三元组必然重复，直接 continue：
if i and nums[i] == nums[i - 1]:
continue
数组已有序，可以利用边界值快速判断当前 i 是否还有希望：
nums[i] + nums[i+1] + nums[i+2] > 0：最小的三个数之和已大于 0，后面 i 更大只会更糟，直接 breaknums[i] + nums[-1] + nums[-2] < 0：即使配上最大的两个数仍小于 0，当前 i 不可能有解，continue 换下一个 i[i+1, n-1] 上找两数之和设 j = i + 1、k = n - 1，在 j < k 时计算 cnt = nums[i] + nums[j] + nums[k]：
| 情况 | 操作 |
|---|---|
cnt < 0 |
和太小，j 右移，尝试更大的 nums[j] |
cnt > 0 |
和太大，k 左移，尝试更小的 nums[k] |
cnt == 0 |
找到一组解，记录后 j、k 同时向内移动 |
以 nums = [-4, -1, -1, 0, 1, 2]（排序后）为例，当 i = 1（nums[i] = -1）时：
j |
k |
cnt |
操作 |
|---|---|---|---|
| 2 | 5 | -1 + (-1) + 2 = 0 | 记录 [-1, -1, 2]，j、k 内移并去重 |
| 3 | 4 | -1 + 0 + 1 = 0 | 记录 [-1, 0, 1]，j、k 内移 |
j、k命中一组解后，j 和 k 各自跳过与当前值相同的元素，避免重复三元组：
while j < k and nums[j] == nums[j - 1]:
j += 1
while j < k and nums[k] == nums[k + 1]:
k -= 1
i 遍历 $O(n)$，内层双指针总共移动 $O(n)$ 次class Solution:
def threeSum(self, nums: list[int]) -> list[list[int]]:
nums.sort()
res = []
n = len(nums)
for i in range(n - 2):
if i and nums[i] == nums[i - 1]: continue
if nums[i] + nums[i + 1] + nums[i + 2] > 0: break
if nums[i] + nums[-1] + nums[-2] < 0: continue
j, k = i + 1, n - 1
while j < k:
cnt = nums[i] + nums[j] + nums[k]
if cnt < 0: j += 1
elif cnt > 0: k -= 1
else:
res.append([nums[i], nums[j], nums[k]])
j += 1
while j < k and nums[j] == nums[j - 1]: j += 1
k -= 1
while j < k and nums[k] == nums[k + 1]: k -= 1
return res
排序 + 双指针已是本题的主流最优解，时间 $O(n^2)$、空间 $O(1)$。另一种常见思路是不排序，用哈希表做两数之和：
nums[i]seen 记录已遍历过的 nums[j]j，目标值为 target = -nums[i] - nums[j]；若 target in seen，说明之前某处出现过补数，可组成三元组nums[j] 加入 seen去重策略：对外层 i 跳过重复值；命中解后将三元组排序后存入 set，最后转回列表。
class Solution:
def threeSum(self, nums: list[int]) -> list[list[int]]:
res = set()
n = len(nums)
for i in range(n - 2):
if i and nums[i] == nums[i - 1]:
continue
seen = set()
for j in range(i + 1, n):
complement = -nums[i] - nums[j]
if complement in seen:
res.add(tuple(sorted((nums[i], complement, nums[j]))))
seen.add(nums[j])
return [list(t) for t in res]
| 对比项 | 排序 + 双指针 | 哈希表 |
|---|---|---|
| 时间 | $O(n^2)$ | $O(n^2)$ |
| 空间 | $O(1)$ | $O(n)$ |
| 去重 | 利用有序性，逻辑清晰 | 需借助 set + 排序元组 |
| 剪枝 | 边界剪枝效果好 | 较难做同类剪枝 |
面试和竞赛中更推荐排序 + 双指针：空间更优、去重更自然，也便于扩展到「三数之和最接近」「四数之和」等变形题。
本题在算法层面，$O(n^2)$ 已接近最优——最坏情况下合法三元组数量可达 $O(n^2)$，输出本身就需要 $O(n^2)$ 时间。因此优化空间主要在剪枝与代码可读性。
nums[i]，减少重复下标访问外层循环中多次用到 nums[i]，可先存入局部变量：
for i in range(n - 2):
x = nums[i]
if i and x == nums[i - 1]:
continue
if x + nums[i + 1] + nums[i + 2] > 0:
break
if x + nums[-1] + nums[-2] < 0:
continue
# 内层用 x 代替 nums[i]
找到解后 j、k 的去重逻辑对称，可先各自前进一步再统一跳过：
else:
res.append([nums[i], nums[j], nums[k]])
j += 1
k -= 1
while j < k and nums[j] == nums[j - 1]:
j += 1
while j < k and nums[k] == nums[k + 1]:
k -= 1
这与原写法等价，但将「记录解」与「移动指针」和「去重」三步分开，阅读时层次更清楚。
cnt == 0 时 j += 1 与 k -= 1 必须都执行——无论 nums[j] 与 nums[k] 是否相等，当前这对 (j, k) 已被消费，只移动一侧会重复枚举同一对。原代码在 j += 1 后做 j 去重、再 k -= 1 后做 k 去重，顺序正确，是常见写法。
给你一个字符串 s，它由小写英文字母和特殊字符 *、# 和 % 组成。
请根据以下规则从左到右处理 s 中的字符，构造一个新的字符串 result：
result 中。'*' 会删除 result 中的最后一个字符（如果存在）。'#' 会复制当前的 result 并追加到其自身后面。'%' 会反转当前的 result。在处理完 s 中的所有字符后，返回最终的字符串 result。
字符串 s
按规则处理后的字符串 result
1 <= s.length <= 20s 只包含小写英文字母和特殊字符 *、# 和 %input: s = "a#b%*"
output: "ba"
解释：依次得到 "a" → "aa" → "aab" → "baa" → "ba"
input: s = "z*#"
output: ""
解释：依次得到 "z" → "" → ""
题目要求从左到右依次处理每个字符，并根据当前字符对 result 做追加、删除、复制或反转。这类题没有更巧妙的数学转化，核心就是按题意模拟。
模拟时需要维护一个可变的中间结果。若直接用字符串拼接，遇到 '*' 删除末尾、'%' 反转时都要频繁切片或重建，写法繁琐。更自然的做法是使用列表 res 作为当前 result 的字符容器：
append，等价于追加到末尾。'*'：若 res 非空则 pop()，删除最后一个字符。'#'：res += res，将当前内容整体复制一份拼到后面。'%'：res.reverse()，原地反转。遍历结束后 ''.join(res) 即为答案。列表尾部增删是 $O(1)$，复制和反转与当前结果长度有关；在题目给定的数据规模下完全足够。
class Solution:
def processStr(self, s: str) -> str:
res = []
for c in s:
if c == '*':
if res: res.pop()
elif c == '#': res += res
elif c == '%': res.reverse()
else: res.append(c)
return ''.join(res)
一个未排序的整数数组 nums
数字连续的最长序列的长度（不要求序列元素在原数组中连续）
0 <= nums.length <= 10^5-10^9 <= nums[i] <= 10^9input: nums = [100,4,200,1,3,2]
output: 4
解释：最长数字连续序列是 [1, 2, 3, 4]，长度为 4。
input: nums = [0,3,7,2,5,8,4,6,0,1]
output: 9
解释：最长数字连续序列是 [0, 1, 2, 3, 4, 5, 6, 7, 8]，长度为 9。
input: nums = [1,0,1,2]
output: 3
解释：最长数字连续序列是 [0, 1, 2]，长度为 3。
题目要求找出数组中数值连续的最长序列长度，这里的"连续"指的是数字本身相差 1，并不要求它们在原数组中下标相邻。
很容易想到先排序再从头扫描统计连续段长度，比如 [100,4,200,1,3,2] 排序后变成 [1,2,3,4,100,200]，扫一遍就能数出最长段。但排序至少需要 $O(n \log n)$，题目明确要求 $O(n)$，此路不通。
既然不能排序，又要快速判断某个数是否在集合中，我们在前两题学过的哈希集合就派上用场了——set 的查询是 $O(1)$ 的，还能顺便去重。
一个自然的想法是：把 nums 转成 set，对每个数 x 不断检查 x+1、x+2……是否在集合里，统计长度。但这样会有大量重复计算——比如序列 [1,2,3,4]，从 1 往上数一遍，从 2 又往上数一遍，最坏会退化到 $O(n^2)$。
怎么避免重复？关键思路是：每条连续序列只需要统计一次。常见做法是从序列的左端点入手——若 x - 1 在集合中，说明 x 不是开头，直接跳过；否则从 x 向右扩展统计长度。
我们的做法是对称的：从序列的右端点入手。遍历集合中的每个 x，若 x + 1 还在集合里，说明 x 不是某段连续序列的最大值，跳过；只有当 x + 1 不存在时，x 才是一段连续序列的右端点。
确认 x 是右端点后，向左"顺藤摸瓜"：令 t = x，不断 t -= 1，直到 t 不在集合中为止。此时 t 恰好落在连续段左端点的左边一位，因此这段序列的长度就是 x - t。
以 nums = [100,4,200,1,3,2] 为例，去重后集合为 {1,2,3,4,100,200}：
1、2、3 的右邻 +1 都在集合中，跳过4：5 不在集合中，向左走 4→3→2→1→0，t 停在 0，长度 4 - 0 = 4100、200 各自成段，长度均为 1每条连续序列只在处理其最大值时统计一次，每个数最多被向左访问一次，总时间复杂度 $O(n)$，空间复杂度 $O(n)$。
class Solution:
def longestConsecutive(self, nums: List[int]) -> int:
nums = set(nums)
ans = 0
for x in nums:
if x + 1 in nums: continue
t = x
while t in nums: t -= 1
ans = max(ans, x - t)
return ans
给你一个链表的头节点 head，删除链表的中间节点，并返回修改后的链表的头节点 head。
长度为 n 链表的中间节点是从头数起第 ⌊n / 2⌋ 个节点（下标从 0 开始），其中 ⌊x⌋ 表示小于或等于 x 的最大整数。
n = 1、2、3、4 和 5 的情况，中间节点的下标分别是 0、1、1、2 和 2。[1, 10^5] 内1 <= Node.val <= 10^5input: head = [1,3,4,7,1,2,6]
output: [1,3,4,1,2,6]
解释：n = 7，下标为 3 的节点（值为 7）是中间节点，删除后返回新链表。
input: head = [1,2,3,4]
output: [1,2,4]
解释：n = 4，下标为 2 的节点（值为 3）是中间节点。
input: head = [2,1]
output: [2]
解释：n = 2，下标为 1 的节点（值为 1）是中间节点，删除后只剩节点 0。
这题和 876. 链表的中间结点 很像，区别在于那题只需要找到中间节点，而这题需要删除它。删除操作需要拿到中间节点的前驱，因此不能直接把慢指针停在中间节点上。
最直观的做法：先遍历一遍统计链表长度 n，再从头走到第 ⌊n / 2⌋ 个节点的前一个位置，执行 prev.next = prev.next.next 即可。为了统一处理删除头节点（n = 1）的情况，可以在链表头部加一个哑节点 dummy：
class Solution:
def deleteMiddle(self, head: Optional[ListNode]) -> Optional[ListNode]:
n = 0
cur = head
while cur:
n += 1
cur = cur.next
dummy = ListNode(0, head)
cur = dummy
for _ in range(n // 2):
cur = cur.next
cur.next = cur.next.next
return dummy.next
时间复杂度 $O(n)$，空间复杂度 $O(1)$，但需要遍历链表两次。
能否只遍历一次？可以。快慢指针的经典结论是：快指针每次走两步、慢指针每次走一步，当快指针到达末尾时，慢指针恰好停在中间节点。但删除需要的是中间节点的前驱，因此让慢指针比快指针晚出发一步——具体做法是用 dummy 节点作为慢指针起点，快指针从 head 出发，循环条件为 fast.next and fast.next.next：
dummy -> 1 -> 3 -> 4 -> 7 -> 1 -> 2 -> 6
slow^ fast^
快指针每次跳两步，慢指针每次跟一步。当 fast.next.next 不存在时停止，此时 slow 指向中间节点的前驱，直接跳过下一个节点即可完成删除。
以 n = 7 为例，三轮循环后 slow 停在值为 4 的节点，slow.next 即为待删的中间节点 7。
$O(n)$，只需遍历链表一次；空间复杂度 $O(1)$。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def deleteMiddle(self, head: Optional[ListNode]) -> Optional[ListNode]:
dummy = ListNode(0, head)
slow = fast = dummy
while fast.next and fast.next.next:
slow = slow.next
fast = fast.next.next
slow.next = slow.next.next
return dummy.next
一个字符串数组 strs
将字母异位词组合在一起，按任意顺序返回结果列表
1 <= strs.length <= 10^40 <= strs[i].length <= 100strs[i] 仅包含小写字母input: strs = ["eat","tea","tan","ate","nat","bat"]
output: [["bat"],["nat","tan"],["ate","eat","tea"]]
解释："nat" 和 "tan" 互为字母异位词；"ate"、"eat"、"tea" 互为字母异位词；"bat" 单独成组。
input: strs = [""]
output: [[""]]
input: strs = ["a"]
output: [["a"]]
题目要求把字母异位词分到同一组。所谓字母异位词，就是两个字符串包含的字符种类和数量完全相同，只是排列顺序不同，比如 "eat" 和 "tea"。
很容易想到对每个字符串去和其他字符串逐一比较，判断是否为异位词，相同则划入同一组。但外层要对 n 个字符串两两配对，整体复杂度约为 $O(n^2 \cdot k)$（k 为字符串最大长度），在 strs.length 达到 $10^4$ 时不够快，此路不通。
不过我们依旧可以想想：判断两个字符串是否为异位词，有一个很简单的办法——排序后比较。"eat" 和 "tea" 排序后都是 "aet"，而 "bat" 排序后是 "abt"，彼此不同。这就给了我们一个思路：我们并不需要真的去两两"比较"，只需要为每个字符串生成一个分组标识，凡是异位词，标识必须相同；非异位词，标识必须不同。
什么可以作为分组标识？既然异位词排序后结果一样，把每个字符串排序，再拼回字符串，就可以当作 key：
"eat" -> "aet"
"tea" -> "aet"
"tan" -> "ant"
接下来就是把字符串按标识归类。什么结构适合"按某个 key 分组存放"呢？显然哈希表可以，且它的存取都是 $O(1)$ 的。这题每个 key 对应的是一组字符串，value 需要是一个列表，直接用 python 中的 defaultdict(list) 即可——遇到新 key 时自动创建空列表，省去手动判断 key 是否存在的步骤。
遍历 strs 时，对当前字符串 s 计算 ''.join(sorted(s)) 作为 key，把 s 本身 append 进 d[key]。注意存的是原字符串，不是排序后的结果，题目要返回的是分组后的原始字符串。
全部遍历结束后，哈希表里每个 value 就是一组异位词。题目要求返回 List[List[str]]，而 d.values() 拿到的是字典值的视图，用列表推导 [v for v in d.values()] 收集成列表返回即可。
时间复杂度 $O(n \cdot k \log k)$，其中 n 为字符串个数，k 为字符串最大长度（排序开销）；空间复杂度 $O(n \cdot k)$。
class Solution:
def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
d = defaultdict(list)
for s in strs:
d[''.join(sorted(s))].append(s)
return [v for v in d.values()]
在一个大小为n且n为偶数的链表中，第1个节点和第n个节点为一对孪生节点，第2对与第n-1对为一对孪生节点，依此类推...
孪生和为一个节点和它的孪生节点两者之和
给一个长度为n的链表head，要求返回链表的最大孪生和
input: head=[5， 4， 2， 1]
output: 6
解释：5 + 1 = 6， 4 + 2 = 6，最大孪生和为6
input: head=[4， 2， 2， 3]
output: 7
解释： 4 + 3 = 7
如果是在数组上做这道题，那么题目将会非常简单，只需要按顺序求arr[0] + arr[n-1], ... , arr[n // 2 - 1] + arr[n // 2]的最大值即可，但是这题是在链表中，无法随机存取，因此想要从后往前推需要办一些手续。
我们正常遍历链表一定是从左往右，那么如何能让它遍历的顺序从右往左呢？仅需要考虑遍历的话，我们可以使用DFS，因为它从左往右走完一遍后必定还要从右往左回来一趟，我们可以考虑仅利用它的后半程，在此期间再运用一个从左往右遍历的指针即可计算孪生和并取最大值。
$O(n)$，n为链表元素个数
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def pairSum(self, head: Optional[ListNode]) -> int:
ans = 0
l = head
def dfs(r: Optional[ListNode]):
if r.next: dfs(r.next)
nonlocal ans, l
ans = max(ans, l.val + r.val)
l = l.next
dfs(head)
return ans
一个整数数组nums
一个整数目标值target
两个数组下标，数组中这两个下标的值的和为target
input: nums = [2,7,11,15], target = 9
output: [0,1]
解释： nums[0] = 2, nums[1] = 7, 2 + 7 = 9
input: nums = [3,2,4], target = 6
output: [1,2]
input: nums = [3,3], target = 6
output: [0,1]
题目很好理解，从数组中找出两个值，和为target即可，然后返回这两个值的下标就行。
很容易想到使用双循环来完成这题，没什么思考难度，不多赘述。但是进阶约束中需要我们的时间复杂度小于$O(n^2)$，这显然就是为了卡双循环，因此此路不通。不过我们依旧可以先将这个暴力解法的代码写出来，看看能不能优化：
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
n = len(nums)
for i in range(n - 1):
for j in range(i + 1, n):
if nums[i] + nums[j] == target:
return [i, j]
从暴力的第二层循环来看，它并不在乎以前的值，因为以前的值在第一层循环中已经经历过了，比如当i = 2, j = 3时，i = 1的情况在第一层循环中已经结束了，因此返过来，对于第二层循环来说，都是每个nums[j]值在前面已经遍历过的数中找和为target的配对，从这个角度上看，第一层循环就成为了非必要的循环，只要我们能找到一种方法，能够直接将以前遍历过的数存起来就行了。
什么方法能直接存以前遍历过的数值呢？显然哈希表是可以的，且它的存取都是$O(1)$的，这不需要自己动手造轮子，直接使用python中的defaultdict类即可。
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
hh = defaultdict(int)
for i, x in enumerate(nums):
if target - x in hh: return [hh[target - x], i]
hh[x] = i
Streamlit 是一个开源 Python 框架，可以用很少的代码快速把数据分析、机器学习模型或脚本做成交互式 Web 应用，无需掌握前端基础。
pip install streamlitimport streamlit as ststreamlit run xxx.pyimport streamlit as st
st.title("我的第一个Streamlit应用")
st.header("这是一个header")
st.subheader("这是一个subheader")
运行后会在浏览器打开如下页面：
数据容器是一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素都可以是任意类型的数据，如：字符串、数字、布尔等。
在Python中，主要有以下5种数据容器：
当我们需要存储多个相关数据时，如果使用单个变量会非常繁琐：
# 单个变量存储多个成绩
score1 = 695
score2 = 558
score3 = 622
score4 = 589
score5 = 645
# ... 更多变量
使用数据容器可以让代码更加简洁优雅：
# 列表存储多个成绩
score_list = [695, 558, 622, 589, 645, 607, 577, 552, 475, 602]
| 特性 | 字符串（str） | 列表（list） | 元组（tuple） | 集合（set） | 字典（dict） |
|---|---|---|---|---|---|
| 有序性 | 有序 | 有序 | 有序 | 无序 | 有序(3.7+) |
| 重复元素 | 允许 | 允许 | 允许 | 不允许 | key不允许 |
| 可变性 | 不可变 | 可变 | 不可变 | 可变 | 可变 |
| 索引访问 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 切片操作 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 使用场景 | 文本处理 | 有序可重复数据集合 | 固定数据记录 | 去重数据集合 | 键值对 |
列表是数据容器中的一类，是一次性可以存储多个数据（元素）的。
特点：
# 定义列表
列表名称 = [元素1, 元素2, 元素3, 元素4, 元素5...]
# 示例
score_list = [695, 558, 622, 589, 645]
mixed_list = [100, "Python", True, 3.14]
列表中的每一个元素都有其对应的下标（索引），通过元素对应的索引，就可以获取到对应的元素。
s = [54, 15, 75, 108, 23, 78, 75]
# 正向索引
print(s[0]) # 输出: 54
print(s[1]) # 输出: 15
print(s[6]) # 输出: 75
# 反向索引
print(s[-1]) # 输出: 75
print(s[-2]) # 输出: 78
print(s[-7]) # 输出: 54
注意： 如果指定的索引值超出范围，将会报错。
# 查看元素
print(score_list[0])
# 修改元素
score_list[0] = 700
print(score_list) # 输出: [700, 558, 622, 589, 645]
# 删除元素
del score_list[3]
print(score_list) # 输出: [700, 558, 622, 645]
切片是指对操作的数据截取其中一部分的操作。列表、字符串、元组都支持切片操作。
序列数据[开始索引:结束索引:步长]
特点：
s = ["A", "B", "C", "E", "D", "E", "G"]
# 基本切片
print(s[0:5:1]) # 输出: ["A", "B", "C", "E", "D"]
print(s[0:5:2]) # 输出: ["A", "C", "D"]
# 省略步长
print(s[0:5]) # 输出: ["A", "B", "C", "E", "D"]
# 省略开始索引
print(s[:5]) # 输出: ["A", "B", "C", "E", "D"]
# 省略结束索引
print(s[2:]) # 输出: ["C", "E", "D", "E", "G"]
# 反向切片
print(s[::-1]) # 输出: ["G", "E", "D", "E", "C", "B", "A"]
列表的常用方法就是指列表这种数据类型内置的常见功能（添加元素、删除元素、排序等）。
| 方法 | 作用 | 样例 |
|---|---|---|
append() |
在列表的尾部追加元素 | s.append(10086) |
insert() |
在指定索引之前，插入该元素 | s.insert(0, 92) |
remove() |
移除列表中第一个匹配到的值 | s.remove(75) |
pop() |
删除列表中指定索引位置的元素（如果未指定索引，默认删最后一个） | s.pop(2) / s.pop() |
sort() |
对列表进行排序（列表元素的数据类型一致，才可以进行排序） | s.sort() |
reverse() |
反转列表元素 | s.reverse() |
# 尾部追加元素
score_list = [695, 558, 622]
score_list.append(589)
print(score_list) # 输出: [695, 558, 622, 589]
# 指定位置插入元素
score_list.insert(1, 645)
print(score_list) # 输出: [695, 645, 558, 622, 589]
# 删除指定值的第一个元素
score_list = [695, 558, 622, 558, 645]
score_list.remove(558)
print(score_list) # 输出: [695, 622, 558, 645]
# 删除指定索引的元素
score_list.pop(2)
print(score_list) # 输出: [695, 622, 645]
# 删除最后一个元素
score_list.pop()
print(score_list) # 输出: [695, 622]
# 排序
num_list = [54, 15, 75, 108, 23, 78]
num_list.sort()
print(num_list) # 输出: [15, 23, 54, 75, 78, 108]
# 降序排序
num_list.sort(reverse=True)
print(num_list) # 输出: [108, 78, 75, 54, 23, 15]
# 反转列表
num_list.reverse()
print(num_list) # 输出: [15, 23, 54, 75, 78, 108]
# 使用+运算符合并
num_list1 = [19, 23, 54, 64, 875]
num_list2 = [55, 80, 72, 35, 60]
merged_list = num_list1 + num_list2
print(merged_list) # 输出: [19, 23, 54, 64, 875, 55, 80, 72, 35, 60]
# 使用*解包操作
merged_list = [*num_list1, *num_list2]
print(merged_list) # 输出: [19, 23, 54, 64, 875, 55, 80, 72, 35, 60]
num_list = [19, 23, 54, 64, 875]
print(23 in num_list) # 输出: True
print(100 in num_list) # 输出: False
print(100 not in num_list) # 输出: True
Python中提供了一些用于数据统计的内置函数：
| 函数 | 作用 |
|---|---|
min() |
获取最小值 |
max() |
获取最大值 |
sum() |
求和 |
len() |
获取元素的个数 |
score_list = [695, 558, 622, 589, 645]
print(min(score_list)) # 输出: 558
print(max(score_list)) # 输出: 695
print(sum(score_list)) # 输出: 3109
print(len(score_list)) # 输出: 5
列表推导式就是按照一定规则快速生成一个列表的方法。
# 格式1：基本格式
列表名称 = [要插入列表的数据 for i in 列表]
# 格式2：带条件格式
列表名称 = [要插入列表的数据 for i in 列表 if 条件]
# 生成1-20的平方列表
square_list = [i ** 2 for i in range(1, 21)]
print(square_list)
# 从数字列表中提取所有偶数，并计算其平方
num_list = [19, 23, 54, 64, 87, 20, 109, 232, 123, 43, 26, 55, 72]
even_square_list = [i ** 2 for i in num_list if i % 2 == 0]
print(even_square_list)
需求：将用户输入的10个数字，存储到一个列表中，并将列表中的数字进行排序，输出其中的最小值、最大值和平均值。
# 存储用户输入的成绩
scores = []
# 循环输入10个成绩
for i in range(10):
score = int(input(f"请输入第{i+1}个成绩: "))
scores.append(score)
# 排序
scores.sort()
print("排序后的成绩:", scores)
# 计算统计值
min_score = min(scores)
max_score = max(scores)
avg_score = sum(scores) / len(scores)
print(f"最小值: {min_score}")
print(f"最大值: {max_score}")
print(f"平均值: {avg_score:.2f}")
需求：合并两个列表中的元素，并对合并的结果进行去重处理。
# 定义列表
num_list1 = [19, 23, 54, 64, 875, 20, 109, 232, 123, 54]
num_list2 = [55, 80, 72, 35, 60, 123, 54, 29, 91]
# 合并列表
merged_list = num_list1 + num_list2
# 去重
unique_list = []
for num in merged_list:
if num not in unique_list:
unique_list.append(num)
print("合并后的列表:", merged_list)
print("去重后的列表:", unique_list)
字符串是字符的容器，一个字符串中可以存放任意数量的字符。
特点：
# 单引号定义
s1 = 'Python'
# 双引号定义
s2 = "Python"
# 三引号定义（支持多行）
s3 = """Python
是一门
编程语言"""
字符串中的每一个字符元素都有其对应的下标（索引），通过元素对应的索引，就可以获取到对应的元素。
s = "Python"
# 正向索引
print(s[0]) # 输出: P
print(s[1]) # 输出: y
print(s[5]) # 输出: n
# 反向索引
print(s[-1]) # 输出: n
print(s[-2]) # 输出: o
print(s[-6]) # 输出: P
字符串也支持切片操作，语法与列表切片相同。
s = "Python"
# 基本切片
print(s[0:5:1]) # 输出: Pytho
print(s[0:5:2]) # 输出: Pto
# 反向切片
print(s[::-1]) # 输出: nohtyP
| 方法 | 作用 | 样例 |
|---|---|---|
find() |
在字符串中查找子串，返回第一次出现的索引位置，找不到返回-1 | s.find('Python') |
count() |
统计子串在字符串中出现的次数 | s.count('H') |
upper() |
将字符串中的所有字母转换为大写 | s.upper() |
lower() |
将字符串中的所有字母转换为小写 | s.lower() |
split() |
将字符串按指定分隔符分割成列表 | s.split(' ') |
strip() |
去除字符串两端的空白字符或指定字符 | s.strip() / s.strip('*') |
replace() |
将字符串中的指定子串替换为新的子串 | s.replace('H','C') |
startswith() |
检查字符串是否以指定子串开头，返回布尔值 | s.startswith('P') |
s = "Hello World, Hello Python"
# 查找子串
print(s.find("Hello")) # 输出: 0
print(s.find("Python")) # 输出: 13
print(s.find("Java")) # 输出: -1
# 统计子串出现次数
print(s.count("Hello")) # 输出: 2
print(s.count("o")) # 输出: 4
s = "Hello World"
# 转换为大写
print(s.upper()) # 输出: HELLO WORLD
# 转换为小写
print(s.lower()) # 输出: hello world
# 分割字符串
s = "apple,banana,orange"
fruit_list = s.split(",")
print(fruit_list) # 输出: ['apple', 'banana', 'orange']
# 连接字符串
fruit_str = "-".join(fruit_list)
print(fruit_str) # 输出: apple-banana-orange
s = " Hello World "
print(s.strip()) # 输出: Hello World
print(s.lstrip()) # 输出: Hello World
print(s.rstrip()) # 输出: Hello World
s = "Hello World"
new_s = s.replace("World", "Python")
print(new_s) # 输出: Hello Python
s = "Hello World"
print("Hello" in s) # 输出: True
print("Python" in s) # 输出: False
# 使用+运算符拼接
s1 = "Hello"
s2 = "World"
s3 = s1 + " " + s2
print(s3) # 输出: Hello World
# 使用f-string格式化
name = "Tom"
age = 18
s = f"我叫{name}，今年{age}岁"
print(s) # 输出: 我叫Tom，今年18岁
需求：用户输入一个邮箱，验证邮箱格式是否正确（包含一个@和至少一个.），如果输入正确，输出"邮箱格式正确"，否则输出"邮箱格式错误"。
email = input("请输入邮箱地址: ")
if "@" in email and "." in email:
print("邮箱格式正确")
else:
print("邮箱格式错误")
需求：输入一个字符串，判断该字符串是否是回文（两边对称）。
s = input("请输入一个字符串: ")
# 去除空格并转换为小写
s = s.replace(" ", "").lower()
# 判断是否是回文
if s == s[::-1]:
print("是回文串")
else:
print("不是回文串")
元组是不可变的序列，类似于列表，但创建后不能修改。
特点：
# 定义元组
元组名称 = (元素1, 元素2, ...)
# 定义空元组
元组名称 = ()
元组名称 = tuple()
# 示例
t1 = (5, 7, 9, 1, 2, 3)
t2 = ("Python", 3.14, True)
t3 = ()
t4 = tuple()
注意： 定义单元素元组时，需要在结尾加上逗号。
# 错误写法（这不是元组，而是一个整数）
t = (5)
print(type(t)) # 输出: <class 'int'>
# 正确写法
t = (5,)
print(type(t)) # 输出: <class 'tuple'>
由于元组是不可变的，所以它的方法主要是查询方法：
| 方法 | 作用 |
|---|---|
count() |
统计某元素在元组中出现的次数 |
index() |
查找某个元素在元组中的索引位置（第一次出现的位置） |
t1 = (5, 7, 9, 1, 2, 3, 10, 6, 4, 8, 12, 7, 5)
# 统计元素出现次数
print(t1.count(7)) # 输出: 2
print(t1.count(5)) # 输出: 2
# 查找元素索引
print(t1.index(9)) # 输出: 2
print(t1.index(12)) # 输出: 10
# 组包
t1 = (5, 7, 9, 1)
t2 = 5, 7, 9, 1 # 省略括号也是元组
print(type(t1)) # 输出: <class 'tuple'>
print(type(t2)) # 输出: <class 'tuple'>
t1 = (5, 7, 9, 1)
# 基础解包
a, b, c, d = t1
print(a) # 输出: 5
print(b) # 输出: 7
print(c) # 输出: 9
print(d) # 输出: 1
在元组解包时，* 表示收集剩余的所有元素，允许我们处理不确定数量的元素（生成列表）。
t2 = (5, 7, 9, 1)
# 扩展解包
x, *y, z = t2
print(x) # 输出: 5
print(y) # 输出: [7, 9]
print(z) # 输出: 1
s, *o = t2
print(s) # 输出: 5
print(o) # 输出: [7, 9, 1]
*o, e = t2
print(o) # 输出: [5, 7, 9]
print(e) # 输出: 1
需求：现有两个变量，分别为：a = 10，b = 20，现需要将这两个变量值交换，然后输出到控制台。
a = 10
b = 20
# 传统方法
temp = a
a = b
b = temp
print(a, b) # 输出: 20 10
# 使用元组解包
a = 10
b = 20
a, b = b, a
print(a, b) # 输出: 20 10
需求：现有三个变量，分别为：a = 100，b = 200，c = 300，现需要将这三个变量值进行交换，将a,b,c的值分别赋值给c,a,b，并将其输出到控制台。
a = 100
b = 200
c = 300
# 使用元组解包
a, b, c = b, c, a
print(a, b, c) # 输出: 200 300 100
集合（set）是一种无序的、不可重复、可修改的数据容器。
特点：
# 定义集合
s1 = {"C", "D", "X", "T", "O", "U"}
# 定义空集合
s2 = set()
# 错误写法（这是空字典，不是空集合）
s3 = {}
注意： 空集合的定义不可以使用{}，{}表示的是空字典。
| 操作 | 含义 | 样例 |
|---|---|---|
add(..) |
添加元素到集合中 | s1.add('t') |
remove(..) |
移除集合中的指定元素（指定元素不存在将报错） | s1.remove('t') |
pop() |
随机删除集合中的元素并返回 | e = s1.pop() |
clear() |
清空集合 | s1.clear() |
difference() |
求取两个集合的差集（包含在第一个集合但不包含在第二个集合的元素） | s1.difference(s2) |
union() |
求取两个集合的并集 | s1.union(s2) |
intersection() |
求取两个集合的交集 | s1.intersection(s2) |
s = {"A", "B", "C"}
s.add("D")
print(s) # 输出: {'A', 'B', 'C', 'D'}
s = {"A", "B", "C", "D"}
# 删除指定元素
s.remove("B")
print(s) # 输出: {'A', 'C', 'D'}
# 随机删除一个元素
e = s.pop()
print(e)
print(s)
# 清空集合
s.clear()
print(s) # 输出: set()
s1 = {1, 2, 3, 4, 5}
s2 = {4, 5, 6, 7, 8}
# 交集
print(s1.intersection(s2)) # 输出: {4, 5}
print(s1 & s2) # 输出: {4, 5}
# 并集
print(s1.union(s2)) # 输出: {1, 2, 3, 4, 5, 6, 7, 8}
print(s1 | s2) # 输出: {1, 2, 3, 4, 5, 6, 7, 8}
# 差集
print(s1.difference(s2)) # 输出: {1, 2, 3}
print(s1 - s2) # 输出: {1, 2, 3}
集合也支持推导式写法：
# 基本格式
变量名称 = {i表达式 for i in 列表}
# 带条件格式
变量名称 = {i表达式 for i in 列表 if 条件}
# 生成1-10的平方集合
square_set = {i ** 2 for i in range(1, 11)}
print(square_set)
# 从列表中提取所有偶数
num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_set = {i for i in num_list if i % 2 == 0}
print(even_set)
需求：根据提供的班级学生的选课情况，完成如下需求：
# 选修足球学生名单
football_set = {"王林", "曾牛", "徐立国", "遁天", "天运子", "韩立", "厉飞雨", "乌丑", "紫灵"}
# 选修篮球学生名单
basketball_set = {"张铁", "墨居仁","王林", "姜老道", "曾牛", "王蝉", "韩立", "天运子", "李化元", "厉飞雨", "云露"}
# 选修法语学生名单
french_set = {"许木", "王卓", "十三", "虎咆", "姜老道", "天运子", "红蝶", "厉飞雨", "韩立", "曾牛"}
# 选修艺术学生名单
art_set = {"遁天", "天运子", "韩立", "虎咆", "姜老道", "紫灵"}
# 1. 同时选修了法语和艺术的学生
both_french_art = french_set & art_set
print("同时选修了法语和艺术的学生:", both_french_art)
# 2. 同时选修了所有四门课程的学生
all_courses = football_set & basketball_set & french_set & art_set
print("同时选修了所有四门课程的学生:", all_courses)
# 3. 选修了足球，但是没有选修篮球的学生
football_not_basketball = football_set - basketball_set
print("选修了足球，但是没有选修篮球的学生:", football_not_basketball)
# 4. 统计每一个学生选修的课程数量
all_students = football_set | basketball_set | french_set | art_set
for student in all_students:
count = 0
if student in football_set:
count += 1
if student in basketball_set:
count += 1
if student in french_set:
count += 1
if student in art_set:
count += 1
print(f"{student} 选修了 {count} 门课程")
Python中的字典（dict），里面存储的是键值对（key: value）类型的数据，可以根据键（key）找到对应的值（value）。
特点：
# 定义字典
字典名称 = {key: value, key: value, key: value …}
# 定义空字典
字典名称 = {}
字典名称 = dict()
# 示例
dict1 = {"王林": 670, "韩立": 556, "李慕婉": 582, "紫灵": 435, "许立国": 608}
dict2 = {}
dict3 = dict()
注意：
dict1 = {"王林": 670, "韩立": 556, "李慕婉": 582}
# 根据key获取value
score = dict1["王林"]
print(score) # 输出: 670
# 如果key不存在，会报错
# score = dict1["张三"] # KeyError: '张三'
| 类型 | 操作 | 含义 | 样例 |
|---|---|---|---|
| 添加 | 字典名称[key] = value |
往指定字典中添加key-value键值对 | dict1["涛哥"] = 688 |
| 删除 | 字典名称.pop(key) |
删除字典中指定的key，并返回该key对应的value | score = dict1.pop("涛哥") |
del 字典名称[key] |
删除字典中指定的键值对 | del dict1["涛哥"] |
|
| 修改 | 字典名称[key] = value |
修改字典中指定的key对应的值 | dict1["小智"] = 658 |
| 查询 | 字典名称[key] |
根据key获取value | dict1["涛哥"] |
字典名称.get(key) |
根据key获取value | dict1.get("涛哥") |
|
字典名称.keys() |
获取所有的key | dict1.keys() |
|
字典名称.values() |
获取所有的value | dict1.values() |
|
字典名称.items() |
获取所有的key-value键值对 | dict1.items() |
dict1 = {"小智": 675, "李思": 608, "李琪": 478}
# 添加元素
dict1["小黑"] = 545
print(dict1) # 输出: {'小智': 675, '李思': 608, '李琪': 478, '小黑': 545}
# 修改元素
dict1["李思"] = 650
print(dict1) # 输出: {'小智': 675, '李思': 650, '李琪': 478, '小黑': 545}
dict1 = {"小智": 675, "李思": 608, "李琪": 478, "小黑": 545}
# 删除指定key
del dict1["李琪"]
print(dict1) # 输出: {'小智': 675, '李思': 608, '小黑': 545}
# 删除指定key并返回value
score = dict1.pop("小黑")
print(score) # 输出: 545
print(dict1) # 输出: {'小智': 675, '李思': 608}
dict1 = {"小智": 675, "李思": 608, "李琪": 478}
# 根据key获取value
print(dict1["小智"]) # 输出: 675
# 使用get方法获取value（key不存在时返回None）
print(dict1.get("李思")) # 输出: 608
print(dict1.get("张三")) # 输出: None
# 获取所有key
print(dict1.keys()) # 输出: dict_keys(['小智', '李思', '李琪'])
# 获取所有value
print(dict1.values()) # 输出: dict_values([675, 608, 478])
# 获取所有键值对
print(dict1.items()) # 输出: dict_items([('小智', 675), ('李思', 608), ('李琪', 478)])
字典支持for循环遍历：
dict1 = {"小智": 675, "李思": 608, "李琪": 478}
# 遍历key
for key in dict1:
print(key, dict1[key])
# 遍历key（推荐写法）
for key in dict1.keys():
print(key, dict1[key])
# 遍历value
for value in dict1.values():
print(value)
# 遍历键值对
for key, value in dict1.items():
print(key, value)
需求：开发一个购物车管理系统，实现商品信息的添加、修改、删除、查询功能。系统使用字典结构存储商品数据，通过控制台菜单与用户交互。
# 购物车字典，key是商品名称，value是包含价格和数量的字典
shopping_cart = {}
while True:
print("=" * 30)
print("欢迎使用购物车系统")
print("1. 添加购物车")
print("2. 修改购物车")
print("3. 删除购物车")
print("4. 查询购物车")
print("5. 退出购物车")
print("=" * 30)
choice = input("请选择要执行的操作(1-5): ")
if choice == "1":
# 添加购物车
name = input("请输入商品名称: ")
price = float(input("请输入商品价格: "))
num = int(input("请输入商品数量: "))
shopping_cart[name] = {"price": price, "num": num}
print("商品添加成功！")
elif choice == "2":
# 修改购物车
name = input("请输入要修改的商品名称: ")
if name in shopping_cart:
price = float(input("请输入新的商品价格: "))
num = int(input("请输入新的商品数量: "))
shopping_cart[name] = {"price": price, "num": num}
print("商品修改成功！")
else:
print("商品不存在！")
elif choice == "3":
# 删除购物车
name = input("请输入要删除的商品名称: ")
if name in shopping_cart:
del shopping_cart[name]
print("商品删除成功！")
else:
print("商品不存在！")
elif choice == "4":
# 查询购物车
if not shopping_cart:
print("购物车为空！")
else:
print("购物车商品列表:")
total_price = 0
for name, info in shopping_cart.items():
price = info["price"]
num = info["num"]
item_total = price * num
total_price += item_total
print(f"商品名称: {name}, 商品价格: {price}, 商品数量: {num}, 小计: {item_total}")
print(f"购物车总价: {total_price}")
elif choice == "5":
# 退出购物车
print("感谢使用购物车系统，再见！")
break
else:
print("输入错误，请重新选择！")
[开始索引:结束索引:步长]。append()和insert()，集合使用add()，字典使用字典[key] = value。remove()和pop()，集合使用remove()和pop()，字典使用del和pop()。keys()、values()和items()遍历。函数是组织好的、可重复使用的、用来实现特定功能的代码片段。
在前面的学习中，我们已经使用过一些 Python 内置函数，例如：
| 函数 | 作用 |
|---|---|
input() |
获取键盘输入 |
print() |
输出内容到控制台 |
max() |
获取最大值 |
min() |
获取最小值 |
len() |
获取长度 |
sum() |
求和 |
这些函数都是 Python 提前定义好的，可以直接调用、重复使用，并完成特定功能。
定义函数使用 def 关键字，基本格式如下：
# 定义函数
def 函数名(参数列表):
函数体
......
return 返回值
# 调用函数
函数名(参数)
其中，参数列表和返回值不是必须的，需要根据实际需求决定。
# 定义函数
def out_line():
print("---------------------------")
# 调用函数
out_line()
输出结果：
---------------------------
在定义函数时，可以根据业务需求设置参数和返回值。
基本格式如下：
def 函数名(参数列表):
函数体
return 返回值
示例：计算圆的面积。
def circle_area(r):
area = 3.14 * r * r
return area
c_area = circle_area(10)
print(c_area)
输出结果：
314.0
说明：
r 是函数的参数，表示圆的半径。return area 表示将计算结果返回。print(c_area) 才会把结果输出到控制台。示例：计算长方形面积。
def rectangle_area(l, w):
area = l * w
return area
r_area = rectangle_area(20, 10)
print(r_area)
输出结果：
200
注意：多个参数之间使用英文逗号 , 分隔。
| 名称 | 含义 |
|---|---|
| 形参 | 函数定义时括号中的参数，只能在函数内部使用 |
| 实参 | 函数调用时实际传入的数据 |
示例：
def circle_area(r):
return 3.14 * r * r
print(circle_area(10))
其中：
r 是形参。10 是实参。Python 函数可以返回多个值，多个返回值会被封装成元组。
def calc(a, b):
return a + b, a - b, a * b
result = calc(10, 5)
print(result)
输出结果：
(15, 5, 50)
也可以通过元组解包接收多个返回值：
x, y, z = calc(10, 5)
print(x)
print(y)
print(z)
输出结果：
15
5
50
return 只是把结果返回给函数调用处，并不会直接输出内容。
如果想在控制台看到结果，需要结合 print() 使用。
def add(a, b):
return a + b
result = add(10, 20)
print(result)
输出结果：
30
函数说明文档，也叫 Docstring，是写在函数开头、用三引号包裹的字符串。
它通常用于说明：
良好的函数说明文档可以让代码更容易理解、使用和维护。
def circle_area_len(r):
"""
该函数用于根据圆的半径，计算圆的面积和圆的周长
:param r: 圆的半径
:return: 圆的面积，圆的周长
"""
return 3.14 * r * r, 2 * 3.14 * r
al = circle_area_len(10)
print(al)
输出结果：
(314.0, 62.800000000000004)
可以使用 help() 函数查看函数说明文档：
help(circle_area_len)
在开发工具中，也可以将鼠标悬浮在函数上查看文档说明。
函数嵌套调用指的是：在一个函数中调用另一个函数。
函数调用遵循栈结构，特点是：
最后被调用的函数最先返回。
也就是 LIFO：
Last In First Out，后进先出。
示例代码：
def function_a():
print("a ... before")
function_b()
print("a ... after")
def function_b():
print("b ... before")
function_c()
print("b ... after")
def function_c():
print("c ...")
function_a()
输出结果：
a ... before
b ... before
c ...
b ... after
a ... after
调用过程如下：
function_a() 开始
│
├─ 打印 "a ... before"
│
├─ 调用 function_b()
│ │
│ ├─ 打印 "b ... before"
│ │
│ ├─ 调用 function_c()
│ │ │
│ │ └─ 打印 "c ..."
│ │
│ ├─ 打印 "b ... after"
│ │
│ └─ function_b() 返回
│
├─ 打印 "a ... after"
│
└─ function_a() 返回
需求：定义一个函数，根据传入的底和高计算三角形面积。
三角形面积公式：
面积 = 底 * 高 / 2
代码实现：
def triangle_area(b, h):
"""
该函数用于根据底和高计算三角形的面积
:param b: 三角形的底
:param h: 三角形的高
:return: 三角形的面积
"""
return (b * h) / 2
print(triangle_area(10, 20))
输出结果：
100.0
需求：定义一个函数，计算传入字符串中元音字母的个数。
元音字母包括：
aeiouAEIOU
代码实现：
def count_vowel(s):
"""
该函数用于统计指定字符串中元音字母的个数
:param s: 需要统计的字符串
:return: 元音字母的个数
"""
count = 0
for i in s:
if i in "aeiouAEIOU":
count += 1
return count
print(count_vowel("hello world"))
输出结果：
3
需求：定义一个函数，计算传入成绩列表中的最高分、最低分和平均分，并返回。
def calc_score(scores):
"""
该函数用于计算班级学员成绩列表中的最高分、最低分和平均分
:param scores: 成绩列表
:return: 最高分、最低分、平均分
"""
max_score = max(scores)
min_score = min(scores)
avg_score = sum(scores) / len(scores)
avg_score = round(avg_score, 1)
return max_score, min_score, avg_score
print(calc_score([672, 435, 544, 567, 705, 668, 634, 527, 540, 525, 645, 621, 589, 612]))
输出结果：
(705, 435, 591.7)
规则如下：
| 分数范围 | 等级 |
|---|---|
| 分数 >= 90 | A |
| 分数 >= 75 | B |
| 分数 >= 60 | C |
| 分数 < 60 | D |
代码实现：
def calc_grade(score):
if score >= 90:
return "A"
elif score >= 75:
return "B"
elif score >= 60:
return "C"
else:
return "D"
print(calc_grade(100))
print(calc_grade(50))
print(calc_grade(70))
输出结果：
A
D
C
回文串指正着读和反着读都一样的字符串。
例如：
level
radar
黄山落叶松叶落山黄
代码实现：
def is_palindrome(s):
return s == s[::-1]
print(is_palindrome("level"))
print(is_palindrome("hello"))
输出结果：
True
False
需求：定义一个函数，将传入的秒数转换为小时、分钟、秒。
def time_change(total_seconds):
"""
该函数用于时间转换，将秒转换为小时、分钟、秒
:param total_seconds: 总秒数
:return: 小时，分钟，秒
"""
hours = total_seconds // 3600
minutes = (total_seconds - hours * 3600) // 60
seconds = total_seconds - hours * 3600 - minutes * 60
return hours, minutes, seconds
print(time_change(10000))
h, m, s = time_change(10000)
print(f"10000秒转换为{h}小时{m}分{s}秒")
输出结果：
(2, 46, 40)
10000秒转换为2小时46分40秒
需求：根据传入的三角形三条边，判断三角形类型。
类型包括：
代码实现：
def triangle_type(a, b, c):
if a + b <= c or a + c <= b or b + c <= a:
return "不能构成三角形"
elif a == b == c:
return "等边三角形"
elif a == b or a == c or b == c:
return "等腰三角形"
else:
return "普通三角形"
print(triangle_type(3, 3, 3))
print(triangle_type(3, 3, 5))
print(triangle_type(3, 4, 5))
print(triangle_type(1, 2, 3))
变量作用域指的是变量的作用范围，也就是变量在哪里可以使用，在哪里不可以使用。
变量可以分为：
| 类型 | 定义位置 | 作用范围 |
|---|---|---|
| 全局变量 | 函数外部 | 整个文件中都可以使用 |
| 局部变量 | 函数内部 | 只能在函数内部使用 |
num = 100
def circle_area(r):
pi = 3.14
area = pi * r * r
return area
count = 0
c_area = circle_area(10)
print(c_area)
说明：
num 和 count 是全局变量。pi 和 area 是局部变量。global 关键字用于在函数内部声明使用全局变量。
不使用 global 的情况：
num1 = 1
def fun1():
num1 = 100
print(num1)
fun1()
print(num1)
输出结果：
100
1
说明：函数内部的 num1 是局部变量，不会影响外部的全局变量。
使用 global 的情况：
num1 = 1
def fun1():
global num1
num1 = 100
print(num1)
fun1()
print(num1)
输出结果：
100
100
说明：使用 global num1 后，函数内部修改的是全局变量 num1。
global 时，要先声明，再使用。global 常用于程序状态、配置和计数器等场景。传参方式指的是：调用函数时，传递实参的方式。
常见传参方式包括：
位置参数指的是：调用函数时，按照函数定义时参数的位置顺序传递数据。
def reg_stu(name, age, gender, city):
print(f"注册成功,姓名:{name}, 年龄:{age}, 性别:{gender}, 城市:{city}")
return {"name": name, "age": age, "gender": gender, "city": city}
stu = reg_stu("张三", 18, "男", "北京")
print(stu)
输出结果：
注册成功,姓名:张三, 年龄:18, 性别:男, 城市:北京
{'name': '张三', 'age': 18, 'gender': '男', 'city': '北京'}
位置参数的特点：
关键字参数指的是：调用函数时，通过 形参名=值 的方式传递参数。
def reg_stu(name, age, gender, city):
print(f"注册成功,姓名:{name}, 年龄:{age}, 性别:{gender}, 城市:{city}")
return {"name": name, "age": age, "gender": gender, "city": city}
stu = reg_stu(name="张三", age=18, gender="男", city="北京")
print(stu)
stu2 = reg_stu(gender="男", name="王五", city="上海", age=22)
print(stu2)
关键字参数的特点：
位置参数和关键字参数可以混用，但必须满足：
位置参数在前，关键字参数在后。
正确写法：
stu = reg_stu("赵四", 28, gender="男", city="上海")
print(stu)
错误写法：
# 错误：位置参数不能放在关键字参数后面
stu = reg_stu(name="赵四", 28, gender="男", city="上海")
| 传参方式 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| 位置参数 | 简洁 | 可读性较差，容易出错 | 参数较少，且顺序自然 |
| 关键字参数 | 可读性强，易维护 | 代码略繁琐 | 参数较多，或容易混淆的场景 |
建议：
如果半年后回头看今天写的代码，不能一眼看出每个参数的含义，就应该使用关键字参数。
默认参数也叫缺省参数，用于在定义函数时为参数提供默认值。
调用函数时：
示例：
def reg_stu(name, age, gender, city="北京"):
print(f"注册成功,姓名:{name}, 年龄:{age}, 性别:{gender}, 城市:{city}")
return {"name": name, "age": age, "gender": gender, "city": city}
stu = reg_stu("张三", 18, "男")
print(stu)
stu = reg_stu("赵四", 22, "男", "深圳")
print(stu)
输出结果：
注册成功,姓名:张三, 年龄:18, 性别:男, 城市:北京
{'name': '张三', 'age': 18, 'gender': '男', 'city': '北京'}
注册成功,姓名:赵四, 年龄:22, 性别:男, 城市:深圳
{'name': '赵四', 'age': 22, 'gender': '男', 'city': '深圳'}
默认参数注意事项：
错误写法：
# 错误：默认参数不能放在普通参数前面
def reg_stu(city="北京", name, age):
pass
正确写法：
def reg_stu(name, age, city="北京"):
pass
不定长参数也叫可变参数，用于函数定义和调用时参数个数不确定的场景。
不定长参数分为两类：
| 类型 | 写法 | 接收数据类型 | 作用 |
|---|---|---|---|
| 不定长位置参数 | *args |
元组 | 接收多个位置参数 |
| 不定长关键字参数 | **kwargs |
字典 | 接收多个关键字参数 |
*args 会接收所有匹配的位置参数，并封装成一个元组。
def calc_data(*args):
min_data = min(args)
max_data = max(args)
avg_data = sum(args) / len(args)
return min_data, max_data, round(avg_data, 1)
data = calc_data(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
print(data)
data = calc_data(100, 200, 300, 400, 500)
print(data)
输出结果：
(10, 100, 55.0)
(100, 500, 300.0)
注意：
args 是元组类型。args 只是约定俗成的变量名，不是关键字。*data，但一般推荐使用 *args。**kwargs 会接收所有关键字参数，并封装成一个字典。
def calc_data(*args, **kwargs):
min_data = min(args)
max_data = max(args)
avg_data = sum(args) / len(args)
if kwargs.get("round"):
avg_data = round(avg_data, kwargs.get("round"))
return min_data, max_data, avg_data
data = calc_data(100, 200, 300, 400, round=2, count=0)
print(data)
data = calc_data(33, 11, 28, 91, 32, 75, 49)
print(data)
输出结果：
(100, 400, 250.0)
(11, 91, 45.57142857142857)
注意：
kwargs 是字典类型。kwargs 只是约定俗成的变量名，不是关键字。**options，但一般推荐使用 **kwargs。| 参数类型 | 适用场景 |
|---|---|
*args |
处理数量不确定的数据 |
**kwargs |
处理数量不确定的选项或配置参数 |
函数的参数可以是普通数据，也可以是函数。
普通参数包括：
示例1：数字作为参数。
def circle_area(r):
area = 3.14 * r ** 2
return area
area = circle_area(10)
print(area)
示例2：列表作为参数。
def calc_score(score_list):
max_s = max(score_list)
min_s = min(score_list)
avg_s = round(sum(score_list) / len(score_list), 1)
return max_s, min_s, avg_s
s_list = [589, 609, 605, 643, 677, 455, 477, 489, 503]
max_score, min_score, avg_score = calc_score(s_list)
print(max_score, min_score, avg_score)
函数本身也可以作为另一个函数的参数。
这种写法常用于把“要执行的逻辑”传递给函数。
def add(x, y):
return x + y
def subtract(x, y):
return x - y
def calc(x, y, oper):
return oper(x, y)
result = calc(10, 20, add)
print(result)
输出结果：
30
说明：
x 和 y 传递的是实际要计算的数据。oper 传递的是函数中封装的计算逻辑。匿名函数指没有名称的函数，需要通过 lambda 表达式声明。
匿名函数适合逻辑简单、只在一个地方使用的场景。
lambda 参数列表: 函数体
注意：
return，表达式的结果就是返回值。def out_line():
print("-------------------------")
def add(x, y):
return x + y
out_line()
print(add(10, 20))
out_line = lambda: print("-------------------------")
add = lambda x, y: x + y
out_line()
print(add(100, 200))
输出结果：
-------------------------
300
| 函数类型 | 适用场景 |
|---|---|
| 命名函数 | 逻辑复杂、需要多步操作、需要重复使用、需要写说明文档 |
| 匿名函数 | 逻辑简单、只在一个地方使用、常作为高阶函数参数 |
建议：
代码的可读性和可维护性比简洁性更重要。
需求：定义一个函数，根据传入的数字，计算该数字的阶乘。
阶乘示例：
8! = 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1
7! = 7 * 6 * 5 * 4 * 3 * 2 * 1
6! = 6 * 5 * 4 * 3 * 2 * 1
递归公式：
f(n) = n * f(n - 1)
f(1) = 1
代码实现：
def factorial(n):
if n == 1:
return 1
return n * factorial(n - 1)
print(factorial(8))
输出结果：
40320
需求：根据输入的班级名称，以及班级中各个学员的考试总分，统计班级平均分、高于平均分的人数和低于平均分的人数。
def calc_grade(class_name, *args):
"""
根据输入的班级名称，以及班级中各个学员的考试总分，
统计班级平均分、高于平均分的人数和低于平均分的人数
:param class_name: 班级名称
:param args: 班级学员分数，元组类型
:return: 平均分，高于平均分的人数，低于平均分的人数
"""
total_score = sum(args)
avg_score = total_score / len(args)
above_avg_count = sum(1 for score in args if score > avg_score)
below_avg_count = sum(1 for score in args if score < avg_score)
return avg_score, above_avg_count, below_avg_count
avg_score, above_avg_count, below_avg_count = calc_grade(
"六年级一班",
650, 683, 706, 593, 623, 634, 712, 588, 562, 470, 611
)
print(f"班级【六年级一班】的平均分是 {avg_score:.2f}, 高于平均分的人数有 {above_avg_count} 人, 低于平均分的人数有 {below_avg_count} 人")
需求：定义一个函数，根据传入的一批商品信息、优惠信息和运费信息，计算订单总金额。
商品信息格式：
("商品名", 价格, 数量)
规则：
基础代码示例：
def calc_cart_total_price(*goods, coupon_price=0, point_deduction=0, express_price=0):
"""
根据商品信息、优惠券、积分抵扣和运费计算购物车总金额
:param goods: 商品信息
:param coupon_price: 优惠券金额
:param point_deduction: 积分抵扣金额
:param express_price: 运费金额
:return: 购物车总金额
"""
total_price = sum(good[1] * good[2] for good in goods)
if total_price > 5000:
total_price -= coupon_price
if total_price > 8000:
total_price -= point_deduction
return total_price + express_price
print(calc_cart_total_price(
("鼠标", 100, 2),
("键盘", 200, 3),
coupon_price=500,
point_deduction=1000,
express_price=50
))
列表推导式的写法：
[要插入的值 for i in 数据集 if 条件]
示例：
nums = [i for i in range(10) if i % 2 == 0]
print(nums)
输出结果：
[0, 2, 4, 6, 8]
特点：
适用场景：
生成器表达式的写法：
(要插入的值 for i in 数据集 if 条件)
示例：
nums = (i for i in range(10) if i % 2 == 0)
print(nums)
for num in nums:
print(num)
特点：
适用场景：
sum()、max()、min() 等函数的参数。示例：
total = sum(i for i in range(1000000))
print(total)
类型注解是 Python 中的一种语法特性，用于明确标识变量、函数参数和返回值的数据类型。
使用类型注解的好处：
注意：
Python 是动态类型语言，类型注解只是提示，不是强制约束。
不使用类型注解：
a = 695
score = 98.5
hobby = "Python"
flag = True
pic = None
names = ["A", "C", "E"]
phones = {"13309091111", "15209109121"}
options = {"count": 0, "total": 0}
goods = ("手机", 5999, 1)
使用类型注解：
a: int = 695
score: float = 98.5
hobby: str = "Python"
flag: bool = True
pic: None = None
names: list[str] = ["A", "C", "E"]
phones: set[str] = {"13309091111", "15209109121"}
options: dict[str, int] = {"count": 0, "total": 0}
goods: tuple[str, int, int] = ("手机", 5999, 1)
| 数据类型 | 写法 |
|---|---|
| 整数 | int |
| 浮点数 | float |
| 布尔 | bool |
| 字符串 | str |
| 空值 | None |
| 列表 | list[int]、list[str] |
| 集合 | set[str] |
| 元组 | tuple[str, int, int] |
| 字典 | dict[str, int] |
| 多种类型 | `str |
类型推断指的是 Python 解释器自动推断变量、表达式或函数返回值数据类型的能力。
a = 695
score = 98.5
hobby = "Python"
flag = True
pic = None
在变量直接赋值、变量运算、容器推导等场景中，解释器可以自动推断类型。
类型注解的写法：
变量名: 数据类型 = 值
例如：
name: str = "Tom"
age: int = 18
score: float = 98.5
类型注解的核心作用不是限制代码运行，而是提升代码的可读性、可维护性和编辑器提示效果。
为函数添加类型注解，主要是给函数参数和返回值添加类型说明。
基本语法：
def 函数名(参数名: 参数类型) -> 返回值类型:
函数体
def calc(scores: list[int]) -> float:
return sum(scores) / len(scores)
说明：
scores: list[int] 表示参数 scores 是一个整数列表。-> float 表示函数返回值是浮点数。def calc_data(scores: list[int]) -> tuple[int, int, float]:
max_v = max(scores)
min_v = min(scores)
avg_v = sum(scores) / len(scores)
return max_v, min_v, avg_v
说明：
tuple[int, int, float]。def calc_cart_total_price(
*goods: tuple[str, float, int],
coupon_price: int = 0,
point_deduction: int = 0,
express_price: float = 0
) -> float:
"""
定义一个用于根据商品信息、优惠券、积分抵扣、运费信息计算购物车总金额的函数
:param goods: 商品信息
:param coupon_price: 优惠券金额
:param point_deduction: 积分抵扣积分数
:param express_price: 运费金额
:return: 购物车总金额
"""
total_price = sum(good[1] * good[2] for good in goods)
if total_price > 5000 and coupon_price <= total_price:
total_price -= coupon_price
if total_price > 5000 and point_deduction // 100 <= total_price:
total_price -= point_deduction // 100
return total_price + express_price
print(calc_cart_total_price(
("鼠标", 88.5, 2),
("键盘", 168.9, 3),
coupon_price=500,
point_deduction=1000,
express_price=8.5
))
函数中类型注解的语法：
def calc_data(scores: list[int]) -> tuple[int, int, float]:
max_v = max(scores)
min_v = min(scores)
avg_v = sum(scores) / len(scores)
return max_v, min_v, avg_v
其中：
scores: list[int] 表示参数类型。-> tuple[int, int, float] 表示返回值类型。对于需要团队协作开发和长期维护的项目，推荐使用类型注解。
def 定义函数。return 只负责返回结果，不负责输出。print()。global 可以在函数内部声明使用全局变量。形参名=值 传递。*args 用于接收多个位置参数。**kwargs 用于接收多个关键字参数。lambda 定义。Python 模块（module）指的是一个 .py 文件。
一个模块中可以包含：
简单来说：
一个 Python 文件就是一个模块，模块是 Python 程序的基本组织单位。
例如，定义一个 circle_fun.py 文件：
# 根据半径计算圆的面积
def circle_area(r):
pi = 3.14
area = pi * r * r
return area
# 根据半径计算圆的周长
def circle_perimeter(r):
pi = 3.14
perimeter = 2 * pi * r
return perimeter
这个 circle_fun.py 文件就可以看作一个模块。
当代码量比较少时，可以把所有代码写在一个文件中。
但是随着项目变复杂，如果所有代码都写在一个文件中，会出现以下问题：
使用模块可以把不同功能拆分到不同文件中，从而让代码结构更加清晰。
模块的主要作用如下：
| 作用 | 说明 |
|---|---|
| 提高代码复用性 | 一个模块中的函数可以被多个文件重复使用 |
| 降低开发门槛 | 常用功能可以直接导入别人写好的模块 |
| 避免命名冲突 | 不同模块中可以有相同名称的函数或变量 |
| 便于维护管理 | 不同功能拆分到不同文件中，结构更清晰 |
Python 提供了很多常用的内置模块，例如：
| 模块 | 作用 |
|---|---|
math |
数学计算 |
os |
操作系统相关操作 |
datetime |
日期时间处理 |
re |
正则表达式 |
random |
随机数相关操作 |
sys |
系统参数相关操作 |
time |
时间访问与处理 |
csv |
CSV 文件操作 |
例如，使用 random 模块实现随机点名：
import random
names = [
"王林", "李慕婉",
"许立国", "韩立",
"涛哥", "莫厉海",
"十三", "虎咆",
"红蝶", "天运子"
]
print(random.choice(names))
其中：
import random 表示导入 random 模块。random.choice(names) 表示从列表中随机选择一个元素。在使用模块中提供的功能之前，必须先导入模块。
也就是：
先导入，再使用。
模块导入语句一般写在 .py 文件的开头。
第一种方式是直接导入模块。
语法：
import 模块名
示例：
import random
num = random.randint(10, 100)
print(num)
说明：
import random 表示导入 random 模块。模块名.功能名 的形式。random.randint(10, 100) 表示生成 10 到 100 之间的随机整数。也可以一次导入多个模块：
import random, os
print(random.randint(1, 10))
print(os.getcwd())
不过在实际开发中，更推荐分多行导入，代码更清晰：
import random
import os
如果模块名比较长，或者想让代码更简洁，可以给模块起别名。
语法：
import 模块名 as 别名
示例：
import random as rd
num = rd.randint(10, 100)
print(num)
说明：
rd 是 random 模块的别名。rd.randint()，不能再写 random.randint()。如果只想使用模块中的某几个功能，可以只导入指定功能。
语法：
from 模块名 import 功能名
示例：
from random import randint, choice
num = randint(10, 100)
print(num)
names = ["张三", "李四", "王五"]
print(choice(names))
说明：
from random import randint, choice 表示从 random 模块中导入 randint 和 choice。random.。也可以给导入的某个功能起别名。
语法：
from 模块名 import 功能名 as 别名
示例：
from random import randint as rint
num = rint(10, 100)
print(num)
说明：
rint 是 randint 的别名。rint() 即可。* 表示导入模块中的所有功能。
语法：
from 模块名 import *
示例：
from random import *
num = randint(10, 100)
print(num)
names = ["张三", "李四", "王五"]
print(choice(names))
这种写法虽然简洁，但是不推荐在大型项目中大量使用。
原因是：
| 导入形式 | 代码样例 | 调用方式 |
|---|---|---|
import 模块名 |
import random |
random.randint(10, 100) |
import 模块名 as 别名 |
import random as rd |
rd.randint(10, 100) |
from 模块名 import 功能名 |
from random import randint |
randint(10, 100) |
from 模块名 import 功能名 as 别名 |
from random import randint as rint |
rint(10, 100) |
from 模块名 import * |
from random import * |
randint(10, 100) |
常用语法可以概括为：
import 模块名 [as 别名]
from 模块名 import 功能名 [as 别名]
from 模块名 import *
自定义模块就是程序员自己创建的 .py 文件。
在实际开发中，当项目比较复杂时，为了让代码结构更清晰、更便于维护和复用，通常会把一个项目拆分为多个模块。
例如，一个完整的项目中可能包含：
config.py
session.py
ai_partner.py
其中：
| 文件 | 作用 |
|---|---|
config.py |
保存项目配置 |
session.py |
处理会话相关功能 |
ai_partner.py |
项目主程序入口 |
注意：
每一个 Python 文件都可以作为一个模块，模块名就是文件名。
例如：
circle_fun.py
这个模块的模块名就是：
circle_fun
导入时不要写 .py 后缀：
import circle_fun
自定义模块的文件名建议遵守 Python 标识符命名规范：
推荐写法：
circle_fun.py
data_query.py
web_service.py
my_config.py
不推荐写法：
CircleFun.py
2test.py
my-module.py
class.py
假设有一个 circle_fun.py 文件，内容如下：
# 根据半径计算圆的面积
def circle_area(r):
pi = 3.14
area = pi * r * r
return area
# 根据半径计算圆的周长
def circle_perimeter(r):
pi = 3.14
perimeter = 2 * pi * r
return perimeter
然后在 main.py 中导入并使用：
import circle_fun
area = circle_fun.circle_area(10)
perimeter = circle_fun.circle_perimeter(10)
print(area)
print(perimeter)
输出结果：
314.0
62.800000000000004
也可以只导入指定功能：
from circle_fun import circle_area, circle_perimeter
area = circle_area(10)
perimeter = circle_perimeter(10)
print(area)
print(perimeter)
假设我们要开发一个“AI树洞”项目，如果把所有代码都写在一个文件中，代码会非常混乱。
可以把不同功能拆分到不同模块中。
用于存放基础配置项：
PAGE_TITLE = "AI树洞"
PAGE_ICON = "🤖"
LAYOUT = "wide"
INITIAL_SIDEBAR_STATE = "expanded"
HELP_URL = "https://www.extremelycoolapp.com/help"
SESSION_LOCATION = "sessions/"
用于处理会话相关功能：
import os
def load_sessions():
sessions = []
if os.path.exists("sessions"):
for filename in os.listdir("sessions"):
if filename.endswith(".json"):
sessions.append(filename[:-5])
return sorted(sessions, reverse=True)
def save_session(session_name):
if session_name:
# 这里省略保存会话的具体逻辑
pass
作为主程序文件，导入并使用其他模块中的功能：
from session import load_sessions, save_session
# 新建会话按钮
if st.button("新建会话", icon="✏️", use_container_width=True):
if st.session_state.current_session:
save_session(st.session_state.current_session)
new_session_name = generate_new_session_name()
st.session_state.current_session = new_session_name
st.session_state.messages = []
save_session(new_session_name)
st.session_state.sessions = load_sessions()
st.rerun()
通过这种拆分方式，可以让每个文件只负责一类功能，项目结构更加清晰。
__all__ 是一个模块级别的特殊变量。
它的作用是：
控制
from 模块名 import *时会导入哪些功能。
例如，创建一个 my.py 文件：
__all__ = ["log_separator1", "log_separator3", "PI"]
PI = 3.1415926
NAME = "黑马☆涛哥"
def log_separator1():
print("- " * 30)
def log_separator2():
print("+ " * 30)
def log_separator3():
print("# " * 30)
def log_separator4():
print("* " * 30)
然后在 test.py 中使用：
from my import *
log_separator1()
log_separator3()
print(PI)
此时可以使用：
log_separator1
log_separator3
PI
但是不能直接使用：
log_separator2
log_separator4
NAME
因为它们没有写在 __all__ 中。
__all__ 只控制这种导入方式：
from 模块名 import *
它不会影响直接导入指定功能。
例如，即使 NAME 没有写入 __all__，下面这种写法仍然可以使用：
from my import NAME
print(NAME)
所以，__all__ 的作用并不是彻底隐藏模块中的功能，而是控制 import * 时通配导入的范围。
__name__ 是 Python 中非常重要的内置变量，表示当前模块的名称。
它有两种常见情况：
| 运行方式 | __name__ 的值 |
|---|---|
| 当前模块被直接运行 | "__main__" |
| 当前模块被其他文件导入 | 模块名，也就是文件名去掉 .py 后缀 |
例如，创建一个 my.py 文件：
def test():
print("这是测试代码")
print(__name__)
如果直接运行 my.py，输出结果是：
__main__
如果在其他文件中导入 my.py：
import my
此时 my.py 中的 __name__ 输出结果是：
my
在自定义模块中，经常会看到下面这种写法：
if __name__ == "__main__":
# 测试代码
pass
它的作用是：
只有当前文件被直接运行时，下面的代码才会执行；如果当前文件被其他模块导入，下面的代码不会执行。
示例：
def circle_area(r):
return 3.14 * r * r
def circle_perimeter(r):
return 2 * 3.14 * r
if __name__ == "__main__":
print(circle_area(10))
print(circle_perimeter(10))
这样写的好处是：
自定义模块的核心要点如下：
.py 文件就是一个模块。.py 后缀。__all__ 用于控制 from 模块名 import * 时导入哪些功能。__name__ 用于判断模块是被直接运行，还是被其他模块导入。当项目规模变大时，模块文件会越来越多。
例如，一个项目中可能有很多模块：
data_query.py
data_handle.py
data_model.py
data_analysis.py
web_routes.py
web_auth.py
helpers.py
file.py
format.py
token.py
log.py
web_service.py
如果所有模块都放在同一个目录下，就容易造成混乱，不方便管理和维护。
这时就可以使用软件包（package）来组织模块。
包的本质是一个文件夹。
这个文件夹中可以包含多个 Python 模块，也就是多个 .py 文件。
同时，包文件夹下通常还会包含一个特殊文件：
__init__.py
因此，可以简单理解为：
包就是用来管理多个模块的文件夹。
例如：
utils/
__init__.py
my_var.py
my_config.py
my_fun.py
其中：
| 文件或目录 | 说明 |
|---|---|
utils/ |
包名 |
__init__.py |
标识当前文件夹是一个包 |
my_var.py |
包中的模块 |
my_config.py |
包中的模块 |
my_fun.py |
包中的模块 |
包的主要作用是：
例如，可以按照功能把模块放入不同包中：
project/
data/
__init__.py
data_query.py
data_handle.py
data_model.py
web/
__init__.py
web_routes.py
web_auth.py
web_service.py
utils/
__init__.py
file.py
format.py
log.py
这样就能清楚地区分数据处理、网页服务和工具函数等不同功能。
__init__.py 是包中的特殊文件。
它的主要作用包括：
__all__ 控制 from 包名 import * 时允许导入的模块列表。例如，在 utils/__init__.py 中写入：
__all__ = ["my_fun", "my_var"]
表示当执行下面代码时：
from utils import *
只会导入：
my_fun
my_var
不会导入其他未写入 __all__ 的模块。
语法：
import 包名.模块名
示例：
import utils.my_fun
utils.my_fun.log_separator1()
说明：
utils 是包名。my_fun 是包中的模块名。包名.模块名.功能名。语法：
from 包名 import 模块名
示例：
from utils import my_fun
my_fun.log_separator1()
说明：
utils 包中导入 my_fun 模块。模块名.功能名。语法：
from 包名 import *
示例：
from utils import *
my_fun.log_separator1()
注意：
使用
from 包名 import *时，需要在包的__init__.py文件中添加__all__，控制允许导入的模块列表。
例如：
__all__ = ["my_fun", "my_var"]
语法：
from 包名.模块名 import 功能名
示例：
from utils.my_fun import log_separator1
log_separator1()
说明：
语法：
from 包名.模块名 import *
示例：
from utils.my_fun import *
log_separator1()
说明：
__all__，则只导入 __all__ 中指定的功能。| 导入形式 | 代码样例 | 调用方式 |
|---|---|---|
import 包名.模块名 |
import utils.my_fun |
utils.my_fun.log_separator1() |
from 包名 import 模块名 |
from utils import my_fun |
my_fun.log_separator1() |
from 包名 import * |
from utils import * |
my_fun.log_separator1() |
from 包名.模块名 import 功能名 |
from utils.my_fun import log_separator1 |
log_separator1() |
from 包名.模块名 import * |
from utils.my_fun import * |
log_separator1() |
关于包，需要掌握以下内容：
__init__.py 文件。__init__.py 可以标识这是一个包，而不是普通文件夹。from 包名 import * 时，可以通过 __init__.py 中的 __all__ 控制导入范围。.py 文件就是一个模块。常见模块导入方式如下：
import 模块名
import 模块名 as 别名
from 模块名 import 功能名
from 模块名 import 功能名 as 别名
from 模块名 import *
其中：
import 模块名 需要通过 模块名.功能名 使用。import 模块名 as 别名 需要通过 别名.功能名 使用。from 模块名 import 功能名 可以直接使用功能名。from 模块名 import * 会导入模块中允许导入的全部功能，但大型项目中不建议滥用。.py 文件。.py 后缀。__all__ 可以控制 from 模块名 import * 的导入范围。__name__ 可以判断模块是直接运行还是被导入。if __name__ == "__main__" 常用于编写模块测试代码。__init__.py 文件。常见包导入方式如下：
import 包名.模块名
from 包名 import 模块名
from 包名 import *
from 包名.模块名 import 功能名
from 包名.模块名 import *
使用建议：
import *，避免命名冲突。核心思想：把一个需求分解成一系列要执行的步骤，然后按照步骤依次执行这些任务（关注的是流程、步骤）。
适用场景：面向过程编程非常直接，适合简单、线性的任务。
例如，盖房子的面向过程思路：
核心思想：把一个人/物的特征和功能打包到一起，关注的是"谁来帮我做这件事儿"。
对象：可以理解为现实中具体的人/物在程序中的数字化身（万物皆对象）。
每个对象都包含两部分：
例如，盖房子的面向对象思路：
类：描述的是一组具有相同属性（特征）和方法（功能/行为）的模板。
对象：对象是类的实例，是基于类创建出来的（实例对象）。
类与对象的关系：
就像月饼模具和月饼的关系：
# 定义类
class 类名:
pass
# 创建对象
对象名 = 类名()
命名规范：类名遵循大驼峰命名法，每个单词的首字母都是大写，单词之间没有分隔符，例如：UserInfo、UserAccount、Car。
创建对象后，可以动态地为对象添加属性：
# 定义类
class Car:
pass
# 创建对象
c1 = Car()
# 动态添加属性
c1.brand = "BMW"
c1.name = "X5"
c1.price = 500000
# 查看对象的所有属性
print(c1.__dict__) # 输出: {'brand': 'BMW', 'name': 'X5', 'price': 500000}
说明：__dict__是Python中用户自定义类实例的一个特殊属性，用于以字典形式存储对象的属性。
__init____init__方法介绍__init__是初始化方法，对象创建后自动调用，主要用于设置对象的初始状态（设置对象属性）。
__init__方法语法# 定义类
class 类名:
def __init__(self, 参数列表):
self.属性名 = 参数值
self.属性名 = 参数值
# 创建对象
对象名 = 类名(参数列表)
self参数介绍self是类中定义的方法的第一个参数，表示当前创建的实例对象。
在方法内部，通过self.属性名可以访问和修改对象的属性。
# 定义类
class Car:
def __init__(self, c_brand, c_name, c_price):
self.brand = c_brand
self.name = c_name
self.price = c_price
# 创建对象
c1 = Car("BMW", "X5", 500000)
# 查看对象的所有属性
print(c1.__dict__) # 输出: {'brand': 'BMW', 'name': 'X5', 'price': 500000}
# 访问对象属性
print(c1.brand) # 输出: BMW
print(c1.name) # 输出: X5
print(c1.price) # 输出: 500000
推荐：在定义类时，尽量使用__init__方法来初始化对象的属性，而不是动态添加属性。
__init__是初始化方法，对象创建时自动调用，主要用于设置对象的初始状态。self是类中定义的方法的第一个参数，表示当前创建的实例对象。定义在类中的函数称之为方法，实例方法是属于每个实例对象的方法。
# 定义类
class 类名:
def __init__(self, 形参列表):
self.属性名 = 参数值
self.属性名 = 参数值
def 方法名(self, 形参列表):
方法体
对象名.方法名(实参)
注意：调用实例方法时，不需要传递self参数，Python会自动将当前对象传递给self。
class Car:
def __init__(self, brand, name, price):
self.brand = brand
self.name = name
self.price = price
def running(self):
"""汽车行驶方法"""
print(f"{self.brand} {self.name} 正在高速行驶...")
def total_cost(self, discount, rate):
"""计算提车总价"""
return self.price * discount + self.price * rate
# 创建对象
c1 = Car("BMW", "X5", 500000)
# 调用实例方法
c1.running() # 输出: BMW X5 正在高速行驶...
total_price = c1.total_cost(0.9, 0.1)
print(f"提车总价为: {total_price:.0f}") # 输出: 提车总价为: 500000
魔法方法是指Python中提供的以双下划线开头和结尾的特殊方法，用于定义类的特殊行为。
特点：魔法方法不需要我们手动调用，Python会在合适的时机自动调用。
| 魔法方法 | 描述 |
|---|---|
__init__ |
初始化方法，对象创建时自动调用 |
__str__ |
字符串表示方法，使用print()打印对象时自动调用 |
__eq__ |
相等比较方法，使用==比较两个对象时自动调用 |
__lt__ |
小于比较方法，使用<比较两个对象时自动调用 |
__le__ |
小于等于比较方法，使用<=比较两个对象时自动调用 |
__gt__ |
大于比较方法，使用>比较两个对象时自动调用 |
__ge__ |
大于等于比较方法，使用>=比较两个对象时自动调用 |
__str__方法默认情况下，打印对象会输出对象的内存地址。通过重写__str__方法，可以自定义对象的字符串表示。
class Car:
def __init__(self, brand, name, price):
self.brand = brand
self.name = name
self.price = price
def __str__(self):
return f"{self.brand} {self.name} 价格: {self.price}元"
c1 = Car("BMW", "X5", 500000)
print(c1) # 输出: BMW X5 价格: 500000元
__eq__方法默认情况下，使用==比较两个对象会比较它们的内存地址。通过重写__eq__方法，可以自定义对象的相等比较逻辑。
class Car:
def __init__(self, brand, name, price):
self.brand = brand
self.name = name
self.price = price
def __eq__(self, other):
# 当品牌、名称和价格都相同时，认为两个对象相等
return (self.price == other.price
and self.brand == other.brand
and self.name == other.name)
c1 = Car("BMW", "X5", 500000)
c2 = Car("BMW", "X5", 500000)
c3 = Car("Audi", "Q7", 600000)
print(c1 == c2) # 输出: True
print(c1 == c3) # 输出: False
__lt__方法默认情况下，自定义对象之间不能进行大小比较。通过重写__lt__方法，可以自定义对象的小于比较逻辑。
class Car:
def __init__(self, brand, name, price):
self.brand = brand
self.name = name
self.price = price
def __lt__(self, other):
# 按价格比较大小
return self.price < other.price
c1 = Car("BMW", "X5", 500000)
c2 = Car("Audi", "Q7", 600000)
print(c1 < c2) # 输出: True
print(c1 > c2) # 输出: False
class Car:
def __init__(self, brand, name, price):
self.brand = brand
self.name = name
self.price = price
def running(self):
print(f"{self.brand} {self.name} 正在高速行驶...")
def __str__(self):
return f"{self.brand} {self.name} {self.price}"
def __eq__(self, other):
return self.price == other.price and self.brand == other.brand and self.name == other.name
def __lt__(self, other):
return self.price < other.price
c1 = Car("BMW", "X5", 500000)
print(c1) # 输出: BMW X5 500000
c2 = Car("BMW", "X5", 500000)
print(c2) # 输出: BMW X5 500000
print(c1 == c2) # 输出: True
print(c1 < c2) # 输出: False
__xxx__形式的特殊方法。__init__：初始化对象__str__：自定义对象的字符串表示__eq__：自定义对象的相等比较逻辑__lt__、__le__、__gt__、__ge__：自定义对象的大小比较逻辑属性分为两类：
实例属性在__init__方法中定义，通过self.属性名访问。
每个对象的实例属性都是独立的，修改一个对象的实例属性不会影响其他对象。
类属性在类的内部、方法的外部定义，通过类名.属性名访问。
所有对象共享类属性，修改类属性会影响所有对象。
class Car:
# 类属性
wheel = 4 # 轮胎数量
tax_rate = 0.1 # 购置税税率
def __init__(self, c_brand, c_name, c_price):
# 实例属性
self.brand = c_brand
self.name = c_name
self.price = c_price
def running(self):
print(f"{self.brand} {self.name} 正在高速行驶...")
def total_cost(self):
"""计算提车总价"""
return self.price + self.price * Car.tax_rate
# 创建两个对象
c1 = Car("BYD", "汉", 180000)
c2 = Car("Tesla", "Model Y", 260000)
# 访问实例属性
print(c1.brand) # 输出: BYD
print(c2.brand) # 输出: Tesla
# 访问类属性
print(Car.wheel) # 输出: 4
print(c1.wheel) # 输出: 4
print(c2.wheel) # 输出: 4
# 修改类属性
Car.tax_rate = 0.08
# 所有对象都会受到影响
print(c1.total_cost()) # 输出: 194400.0
print(c2.total_cost()) # 输出: 280800.0
说明：通过实例查找属性时，会先查找实例属性，实例属性不存在时，再查找类属性。
采用面向对象的编程思想，完成教务管理系统的开发。教务管理系统可以管理在校学生的成绩信息，通过控制台菜单与用户交互，具体功能如下：
Student类：表示学生，包含学生的姓名、语文成绩、数学成绩、英语成绩等属性，以及计算总分、平均分等方法EduManagement类：表示教务管理系统，包含学生列表属性，以及添加、修改、删除、查询、展示学生成绩等方法class Student:
"""学生类"""
def __init__(self, name, chinese, math, english):
self.name = name
self.chinese = chinese
self.math = math
self.english = english
def total_score(self):
"""计算总分"""
return self.chinese + self.math + self.english
def avg_score(self):
"""计算平均分"""
return self.total_score() / 3
def __str__(self):
return (f"姓名: {self.name}, 语文: {self.chinese}, 数学: {self.math}, "
f"英语: {self.english}, 总分: {self.total_score()}, 平均分: {self.avg_score():.1f}")
class EduManagement:
"""教务管理系统类"""
def __init__(self):
self.students = {} # 学生字典，key是学生姓名，value是Student对象
def add_student(self, student):
"""添加学生"""
if student.name in self.students:
print(f"学生{student.name}已存在！")
return False
self.students[student.name] = student
print(f"学生{student.name}添加成功！")
return True
def update_student(self, name, chinese, math, english):
"""修改学生成绩"""
if name not in self.students:
print(f"学生{name}不存在！")
return False
student = self.students[name]
student.chinese = chinese
student.math = math
student.english = english
print(f"学生{name}成绩修改成功！")
return True
def delete_student(self, name):
"""删除学生"""
if name not in self.students:
print(f"学生{name}不存在！")
return False
del self.students[name]
print(f"学生{name}删除成功！")
return True
def query_student(self, name):
"""查询学生成绩"""
if name not in self.students:
print(f"学生{name}不存在！")
return None
return self.students[name]
def show_all_students(self):
"""展示所有学生成绩"""
if not self.students:
print("系统中没有学生信息！")
return
print("=" * 70)
print("所有学生成绩信息：")
print("-" * 70)
for student in self.students.values():
print(student)
print("=" * 70)
def main():
"""主函数"""
edu_system = EduManagement()
while True:
print("\n" + "=" * 30)
print("欢迎使用教务管理系统")
print("1. 添加学生成绩")
print("2. 修改学生成绩")
print("3. 删除学生成绩")
print("4. 查询指定学生成绩")
print("5. 展示全部学生成绩")
print("6. 退出系统")
print("=" * 30)
choice = input("请选择要执行的操作(1-6): ")
if choice == "1":
# 添加学生成绩
name = input("请输入学生姓名: ")
try:
chinese = int(input("请输入语文成绩: "))
math = int(input("请输入数学成绩: "))
english = int(input("请输入英语成绩: "))
except ValueError:
print("成绩必须是数字！")
continue
student = Student(name, chinese, math, english)
edu_system.add_student(student)
elif choice == "2":
# 修改学生成绩
name = input("请输入要修改的学生姓名: ")
try:
chinese = int(input("请输入新的语文成绩: "))
math = int(input("请输入新的数学成绩: "))
english = int(input("请输入新的英语成绩: "))
except ValueError:
print("成绩必须是数字！")
continue
edu_system.update_student(name, chinese, math, english)
elif choice == "3":
# 删除学生成绩
name = input("请输入要删除的学生姓名: ")
edu_system.delete_student(name)
elif choice == "4":
# 查询指定学生成绩
name = input("请输入要查询的学生姓名: ")
student = edu_system.query_student(name)
if student:
print("-" * 50)
print(student)
print("-" * 50)
elif choice == "5":
# 展示全部学生成绩
edu_system.show_all_students()
elif choice == "6":
# 退出系统
print("感谢使用教务管理系统，再见！")
break
else:
print("输入错误，请重新选择！")
if __name__ == "__main__":
main()
异常（也称为Bug）就是程序运行过程中出现的错误，它会中断程序的正常执行流程。
常见异常类型：
NameError：变量未定义TypeError：类型错误IndexError：索引超出范围KeyError：字典中不存在指定的keyValueError：值错误异常的作用：
注意：异常不是坏东西，而是编写健壮程序的重要工具。
程序运行过程中出现异常，有两种处理方案：
try:
可能出现异常的业务代码1
可能出现异常的业务代码2
...
except [异常类型 as 变量名]:
出现异常时的预案
[finally:
不管是否出现异常，都会执行的代码]
try:
print("=" * 30)
print(my_name) # my_name未定义，会抛出NameError
print("=" * 30)
except NameError as e:
print("程序运行报错，错误信息: ", e)
finally:
print("释放资源 ~")
输出结果：
==============================
程序运行报错，错误信息: name 'my_name' is not defined
释放资源 ~
try:
num = int(input("请输入一个数字: "))
result = 10 / num
print(f"10 / {num} = {result}")
except ValueError as e:
print("输入错误，必须输入数字！")
except ZeroDivisionError as e:
print("除数不能为0！")
except Exception as e:
print("未知错误，具体信息: ", e)
finally:
print("程序执行完毕")
异常传递就是异常在函数调用中层层上报的过程，直到有人处理它，或者程序崩溃。
def fun1():
print("fun1 ... running ...")
fun2()
def fun2():
print("fun2 ... running ...")
fun3()
def fun3():
print("fun3 ... running ...")
print(my_color) # my_color未定义，会抛出NameError
if __name__ == '__main__':
try:
fun1()
except NameError as e:
print("捕获到异常: ", e)
输出结果：
fun1 ... running ...
fun2 ... running ...
fun3 ... running ...
捕获到异常: name 'my_color' is not defined
说明：异常从fun3抛出，传递到fun2，再传递到fun1，最后在主函数中被捕获处理。
class关键字定义类，类名遵循大驼峰命名法。__init__方法是初始化方法，对象创建时自动调用，用于设置对象的初始属性。self参数表示当前实例对象，在方法内部通过self访问对象的属性和方法。self参数，Python会自动传递。__xxx__形式的特殊方法。__init__、__str__、__eq__、__lt__等。try-except-finally语句捕获和处理异常。在Python中，代码默认是从上往下逐行执行的。但在实际场景中，我们经常需要根据不同的条件来决定是否执行某段代码，这就需要用到条件判断语句。
if 语句用于条件判断：只有满足指定条件（判断结果为 True），才会执行对应的代码逻辑。
if 要判断的条件:
条件成立时，要执行对应的操作1
条件成立时，要执行对应的操作2
if 语句里面的代码块，需要在前方缩进空格（建议4个空格），通过缩进来描述代码的层级关系（归属）。# 定义变量
score = 695
# 条件判断
if score > 680:
print("欢迎你, 来清华读书")
如果条件成立执行操作1，否则执行操作2。
if 要判断的条件:
条件成立时，执行对应的操作1
else:
条件不成立时，执行的操作2
else 是不需要条件判断的，当 if 条件不成立时，else 就执行了。else 代码块，也需要使用空格缩进（建议4个空格）。account = input("请输入B站账号：")
password = input("请输入B站密码：")
if account == "18888888888" and password == "666888":
print("登录成功 ~")
print("进入B站首页 ~")
else:
print("登录失败 !")
print("用户名或密码错误 !")
if...elif...else 语句的作用是可以完成多个条件的判断(多分支判断)。
if 要判断的条件1:
条件成立时，执行对应的操作1
elif 要判断的条件2:
条件成立时，执行对应的操作2
else:
条件不成立时，执行的操作3
elif 可以写多个。else 可有可无，如果有必须放在最后。num = int(input("请输入数字："))
if num > 0:
print(f"{num} 是 正数")
elif num < 0:
print(f"{num} 是 负数")
else:
print(f"{num} 是 0")
三角形类型判断：根据输入的三个边的边长(正整数)，判定是等边三角形、等腰三角形、普通三角形，还是不能构成三角形。
构成三角形的条件：两边之和大于第三边
三角形判定规则：
a, b, c = list(map(int, input().split()))
if a + b <= c or a + c <= b or b + c <= a:
print("无法构成三角形")
else: # 可以构成三角形
if a == b == c:
print("等边三角形")
elif a == b or b == c or a == c:
print("等腰三角形")
else:
print("一般三角形")
结构模式匹配就是用一个清晰的模板去精准的匹配数据的结构和内容，匹配成功则执行响应的操作。基于某个变量的多个固定值进行分支判断时，可以使用match模式匹配。这是3.10版本中的新语法。
match 表达式:
case 值1:
操作1
case 值2 if 条件表达式:
操作2
case 值3 | 值4 :
操作4
case _:
默认操作
| 表示或的关系，匹配多个模式中的任意一个。case _ 匹配其他所有情况。match 指定的表达式的值。case 后面的值进行匹配，匹配正确，就执行对应语句。case 都没有匹配上，就会执行默认的 case _。循环就是重复的执行某件事情。分为 while 循环和 for 循环。
while 循环是通过条件表达式，来控制是否要进行下一次循环。
while 条件表达式:
循环体语句1
...
else:
条件为False,循环正常结束时执行
while 循环用于在某个条件满足时一直循环，循环的次数通常是未知的。而 for 循环本质是一种轮询遍历机制，对一批内容进行逐个处理。用于对一个已知的数据集进行遍历或已知次数的循环。
for 元素 in 待处理数据集:
循环体代码(对元素进行处理)
else:
循环结束时, 执行的代码
range 语句作用是生成指定规则的数字序列。
| 用法 | 说明 | 示例 |
|---|---|---|
range(end) |
获取一个从0开始，到end结束的数字序列（不含end本身） | range(5) 获取的数据就是 0,1,2,3,4 |
range(start, end) |
获取一个从start开始，到end结束的数字序列（不含end本身） | range(2,8) 获取的数据就是 2,3,4,5,6,7 |
range(start, end, step) |
获取一个从start开始，到end结束的数字序列，step步长（不含end本身） | range(0,10,2) 获取的数据就是 0,2,4,6,8 |
嵌套循环语法格式为在外层循环结构内包含内层循环结构。
break 关键字：不能够单独书写，只能出现循环中，表示结束、跳出的意思。continue 关键字：不能够单独书写，只能出现循环中，表示中断本次循环，直接进入下一次循环。将1-1000之间（含1000）所有的5的倍数的数字累加起来。
cnt = 0
for i in range(0, 1001, 5):
cnt += i
print(cnt) # 输出： 100500
统计字符串 "akiwksjakdiklowiqaamnvbamvaxnsjdsjkaaxkjd" 字符串中有多少个a和k。
s = "akiwksjakdiklowiqaamnvbamvaxnsjdsjkaaxkjd"
cnt = 0
for c in s:
if c == 'a' or c == 'k':
cnt += 1
print(cnt) # 输出：14
程序中，直接书写的固定值（数据），称为字面量。
如：18，"Hello World"等。
| 类型 | 说明 | 示例 |
|---|---|---|
| 数字类型 | 整数(int) | 10 18 -5 0 |
| 数字类型 | 浮点数/小数(float) | 8.5 3.14 1.0 -3.5 |
| 布尔(bool) | 表达现实生活中的逻辑，真或假 | True False |
| 字符串(str) | 描述文本的一种数据类型 | "人生苦短，我用Python" |
| 空值(NoneType) | 表示空或无值，仅包含一个值 None | None |
| 数据容器 | 存储多项数据的容器 | 列表/元组/集合/字典（后面详细讲解） |
其中，bool类型本质就是数字类型，bool转数字时，True=1,False=0，数字转bool时，0=False，其它=True
程序中，用来存储单个数据的容器（经常会发生改变的数据），称为变量。
如，num=1中的num是变量名，1为变量值，之后num=2也是可以的，num作为存储容器，里面存储的内容可以不一样。
变量主要用于输出打印、参与计算、记录数据，是编程过程中必不可少的元素。
程序员在代码中为变量、函数、类等元素所起的名字，称为标识符。
现有两个变量，分别为：a = 10， b = 20，现需要将这两个变量值交换，然后输出到控制台。
a, b = 10, 20 # 变量名赋值
a, b = b, a # 变量名交换
print(a, b) # 输出交换后的a, b
a, b = 10, 20 # 变量名赋值
# 通过中间变量来交换变量名
c = a
a = b
b = c
print(a, b) # 输出交换后的变量值
现有三个变量，分别为：a = 100，b = 200，c = 300，现需要将这三个变量值进行交换，将a,b,c的值分别赋值给c,a,b，并将其输出到控制台。
a, b, c = 100, 200, 300
a, b, c = c, a, b
print(a, b, c)
| 标准名称 | 描述 | 说明 |
|---|---|---|
int |
整数 | 数字类型，存放整数，如：10 -5 |
float |
浮点数 | 数字类型，存放小数，如：8.5 3.14 1.0 -3.5 |
str |
字符串 | 用引号引起来的都是字符串，如："Python" |
bool |
布尔 | 布尔类型，描述真和假，如：True False |
NoneType |
空值 | 表示空或无值，仅包含一个值 None |
我们可以通过type()来获取数据的类型
print(type(1))
输出:
<class 'int'>
意思是1属于整型类，同理可以试试3.14, "hello"等数据的类型。
我们可以通过isinstance()来检查某个数据是否是我们指定的数据类型。
print(isinstance(1, int))
print(isinstance(1, float))
输出：
True
False
意思是1属于整形类，1不属于浮点型。
字符串，顾名思义，就是由一系列字符组成的数据类型。在编程中，我们常用它来表示名字、短语、句子等文本内容。
在 Python 中，字符串不仅能存储单个字母，还可以包含数字、符号，甚至是空格。字符串是编程中最常用、最基础的数据类型之一。
在Python中，字符串可以用单引号（'）、双引号（"）、或三引号（''' 或 """）括起来。字符串中的每一个字符都有其对应的索引。
例如：
s1 = 'hello'
s2 = "world"
s3 = """多行字符串
可以换行
"""
print(s1)
print(s2)
print(s3)
输出：
hello
world
多行字符串
可以换行
字符串中有一些特殊字符，常用的有\n(换行)、\t(制表符)、\\(反斜杠)、\"(双引号)、\'(单引号)等。
例如：
s = "Hello\nPython"
print(s)
s2 = "Hello\tPython"
print(s2)
s3 = "他说：\"你好，Python!\""
print(s3)
输出：
Hello
Python
Hello Python
他说："你好，Python!"
有时我们不希望字符串中的\被当作特殊字符处理，可以在字符串前面加上r，变为原始字符串（raw string）。
path = "C:\\Users\\Python"
print(path)
raw_path = r"C:\Users\Python"
print(raw_path)
输出：
C:\Users\Python
C:\Users\Python
原始字符串常用于正则表达式、Windows路径等场景。
可以使用+号拼接两个字符串，也可以用*重复字符串。
a = "Hello"
b = "Python"
c = a + " " + b
d = a * 3
print(c) # 输出: Hello Python
print(d) # 输出: HelloHelloHello
使用len()函数可以获取字符串的长度。
msg = "Python"
print(len(msg)) # 输出: 6
通过索引获取字符串中的某个字符，索引从0开始。通过切片可以获取一部分字符串。
s = "abcdef"
print(s[0]) # 输出: a
print(s[-1]) # 输出: f
print(s[2:5]) # 输出: cde
print(s[:3]) # 输出: abc
upper()：转换成大写lower()：转换成小写strip()：去除首尾空白replace(a, b)：替换字符串中的a为bsplit(sep)：按照分隔符分割为列表text = " Python,Hello "
print(text.upper()) # 输出: PYTHON,HELLO
print(text.lower()) # 输出: python,hello
print(text.strip()) # 输出: Python,Hello
print(text.replace("Hello", "World")) # 输出: Python,World
print(text.split(",")) # 输出: [' Python', 'Hello ']
可以用f''格式化字符串或者用format()方法。
name = "Tom"
age = 18
print(f"My name is {name}, age is {age}") # 推荐
print("My name is {}, age is {}".format(name, age))
输出：
My name is Tom, age is 18
My name is Tom, age is 18
根据自己的实际情况，输出个人的详细信息，具体结构如下：
"大家好，我是Hygen，今年18岁，学习的专业是软件工程，爱好Python、C++"
name = "Hygen"
age = 18
pro = "软件工程"
hobby = "Python, C++"
print(f"大家好，我是{name}, 今年{age}岁，学习的专业是{pro}，爱好{hobby}")
input函数可以获取键盘输入的数据，用法为s = input(提示信息)，它的返回值是一个字符串
print函数可以将数据输出到控制台，用法为print(需要输出的数据)
小智的银行卡中有10000元，现在到ATM进行取钱操作，请根据输入的金额执行取钱操作，取钱完毕后，展示其银行卡余额。
# ATM取钱案例代码
money = 10000
draw = int(input("请输入要取款的金额："))
money -= draw
print(f"取钱成功，您的银行卡余额为：{money}")
示例输出
请输入要取款的金额：2000
取钱成功，您的银行卡余额为：8000
根据用户输入的两个数字，计算两个数之和，并将其输出到控制台。
# 获取输入
a, b = [int(x) for x in input().split()]
# 输出和
print(a + b)
示例输入
3 4
示例输出
7
用于进行数学运算的符号，比如加减乘除等。
| 运算符 | 含义 | 示例 | 结果 |
|---|---|---|---|
+ |
加法 | 5 + 2 |
7 |
- |
减法 | 5 - 2 |
3 |
* |
乘法 | 5 * 2 |
10 |
/ |
除法（得到浮点数） | 5 / 2 |
2.5 |
// |
整除 | 5 // 2 |
2 |
% |
取余（取模） | 5 % 2 |
1 |
** |
幂运算 | 5 ** 2 |
25 |
a = 9
b = 4
print(a + b) # 13
print(a - b) # 5
print(a * b) # 36
print(a / b) # 2.25
print(a // b) # 2
print(a % b) # 1
print(a ** b) # 6561
用于给变量赋值，也可以与算术运算结合（复合赋值运算符）。
| 运算符 | 含义 | 示例 | 结果 |
|---|---|---|---|
= |
赋值 | a = 5 |
a为5 |
+= |
加法赋值 | a += 2 |
等价于a = a + 2 |
-= |
减法赋值 | a -= 1 |
等价于a = a - 1 |
*= |
乘法赋值 | a *= 3 |
等价于a = a * 3 |
/= |
除法赋值 | a /= 2 |
等价于a = a / 2 |
//= |
整除赋值 | a //= 2 |
等价于a = a // 2 |
%= |
取余赋值 | a %= 2 |
等价于a = a % 2 |
**= |
幂赋值 | a **= 2 |
等价于a = a ** 2 |
a = 10
a += 5 # 变成15
a //= 3 # 15整除3，变成5
a **= 2 # 5的平方，变成25
print(a) # 25
用于比较两个值，结果是布尔类型True或False。
| 运算符 | 含义 | 示例 | 结果 |
|---|---|---|---|
== |
等于 | 3 == 5 |
False |
!= |
不等于 | 3 != 5 |
True |
> |
大于 | 3 > 5 |
False |
< |
小于 | 3 < 5 |
True |
>= |
大于等于 | 3 >= 3 |
True |
<= |
小于等于 | 3 <= 2 |
False |
a = 8
b = 6
print(a == b) # False
print(a != b) # True
print(a > b) # True
print(a < b) # False
print(a >= 8) # True
print(a <= 5) # False
用于多个条件的组合判断。
| 运算符 | 含义 | 示例 | 结果 |
|---|---|---|---|
and |
而且（并且） | True and False |
False |
or |
或（两个中有一个为真就为真） | True or False |
True |
not |
取反 | not True |
False |
age = 20
score = 85
print(age > 18 and score >= 80) # True
print(age < 18 or score >= 80) # True
print(not (age == 20)) # False
常用于条件语句、循环控制等。
]]>FastAPI 是高性能的 Python Web 框架，专门用于构建 API（应用程序接口）。它基于标准的 Python 类型提示（type hints），是 Python 领域最受欢迎的 Web 框架之一。
高性能：可大量处理并发请求高效率：类型检查，减少人为错误，开发速度可提升200%~300%交互式：自动生成Swagger UI文档(/docs)和ReDoc文档准备虚拟环境
此处使用uv来进行包管理。
uv init fastapi-demo来初始化一个fastapi项目，进入项目文件夹fastapi库：uv add fastapi uvicorn[standard]在main.py中输入如下代码：
from fastapi import FastAPI
# 注册FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hello, FastAPI!"}
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = "query"):
return {"item_id": item_id, "q": q}
在命令行中输入uv run uvicorn main:app --reload来运行第一个项目，在浏览器中输入http://127.0.0.1:8000/来访问这个项目，出现如下内容说明已经成功运行：
要访问api文档只需要在链接后面添加/docs就好了，完整链接：http://127.0.0.1:8000/docs，内容如下：
路由简单来说就是URL地址和处理函数之间的映射关系，它决定了用户访问某个网址时，服务器应该执行哪段代码返回结果。
需求：当访问路径
/user/hello时，服务器的响应结果是{"msg":"Hello, Zako"}
main.py
@app.get("/user/hello")
def hello():
return {"message": "Hello, Zako!"}
运行结果和上面类似，不再贴出
参数就是客户端发送请求时额外附带的信息和指令
参数的作用是让同一个接口能根据不同的输入，返回不同的输出，实现动态交互
参数分为三类，路径参数, 查询参数, 请求体
需求：以用户id为路径参数设计URL，要求响应结果包含用户id和名称（yusu+id）
样例：
URL： /user/114514
响应结果：{id: 114514, name: yusu114514}
main.py
@app.get("/user/{id}")
def get_user(id: int):
return {"id": id, "name": f"yusu{id}"}
需求： 定义两个接口，携带路径参数，并使用 Path 来实现类型注解
具体如下：
接口1： 以新闻分类id为参数设计URL，id范围为1~100
接口2： 以新闻分类名称为参数设计URL，分类名称长度为2~10
main.py
@app.get("/news/{id}")
def get_news(id: int = Path(..., ge=1, le=100)):
return {"id": id, "title": f"news{id}"}
@app.get("/news/{name}")
def get_name(name: str = Path(..., min_length=2, max_length=10)):
return {"name": name}
需求：设计接口查询图书，要求携带两个查询参数：图书分类和价格
参数具体要求：
图书分类：默认值为 Python开发，长度限制5 ~ 255
价格：限制大小范围 50 ~ 100
main.py
@app.get("/books")
def get_books(category: str = Query(default="Python开发", min_length=5, max_length=255), price: float = Query(ge=50, le=100)):
return {"category": category, "price": price}
需求：设计接口新增图书，图书信息包含：书名、作者、出版社、售价
main.py
class Book(BaseModel):
title: str
author: str
publisher: str
price: float
@app.post("/books")
def create_book(book: Book):
return {"book": book}
需求：设计接口新增图书，图书信息包含：书名、作者、出版社、售价
具体要求如下：
书名：不能为空；长度 2 ~ 20
作者：长度 2 ~ 10
出版社：默认值“黑马出版社”
售价：不能为空；价格大于0元
main.py
class Books(BaseModel):
title: str = Field(..., min_length=2, max_length=20)
author: str = Field(..., min_length=2, max_length=10)
publisher: str = Field(default="黑马出版社")
price: float = Field(..., gt=0)
@app.post("/book")
def create_book(book: Books):
return {"book": book}
既然用户对服务器有请求，那么服务器自然需要有响应。
FastAPI 默认会将你路径操作函数返回的任何数据自动转换为 JSON，并使用JSONResponse作为默认响应。同时FastAPI也提供了丰富的响应类型和自定义的返回类型来返回不同的数据。
| 响应类型 | 用途 | 示例 |
|---|---|---|
| JSONResponse | 默认响应，返回JSON数据 | return {"key": "value"} |
| HTMLResponse | 返回HTML内容 | return HTMLResponse(html_content) |
| PlainTextResponse | 返回纯文本 | return PlainTextResponse("text") |
| FileResponse | 返回文件下载 | return FileResponse(path) |
| StreamingResponse | 流式响应 | 生成器函数返回数据 |
| RedirectResponse | 重定向 | return RedirectResponse(url) |
其中最常用的是JSON、HTML、File格式。可以通过声明response_class参数或直接返回一个Response对象来覆盖默认行为，定制自己想要的响应类型。 |
response_model是路径操作装饰器（如 @app.get或 @app.post）的关键参数，它通过一个Pydantic模型来严格定义和约束 API 端
点的输出格式。这一机制在提供自动数据验证和序列化的同时，更是保障数据安全性的第一道防线。
from pydantic import BaseModel
class News(BaseModel):
id: int
title: str
content: str
@app.get("/news/{id}", response_model=News)
async def get_news(id: int):
return {
"id": id,
"title": f"这是第{id}本书",
"content": "这是一本好书"
}
对于客户端引发的错误（4xx，如资源未找到、认证失败），应使用fastapi.HTTPException来中断正常处理流程，
并返回标准错误响应 。
from fastapi import FastAPI, HTTPException
@app.get('/news/{id}')
async def get_news(id: int):
id_list = [1, 2, 3, 4, 5, 6]
if id not in id_list:
raise HTTPException(status_code=404, detail="当前id不存在")
return {"id": id}
中间件（Middleware）是一个在每次请求进入 FastAPI 应用时都会被执行的函数。它在请求到达实际的路径操作（路由处理函数）之前运行，并且在响应返回给客户端之前再运行一次。
中间件可以为每个请求添加统一的处理逻辑，常见应用场景包括：
在函数的顶部使用装饰器 @app.middleware("http") 来定义中间件。
@app.middleware("http")
async def middleware(request, call_next):
print('中间件开始处理 -- start')
response = await call_next(request)
print('中间件处理完成 -- end')
return response
多个中间件的执行顺序是自下而上，即后定义的中间件先执行。
依赖注入（Dependency Injection）是 FastAPI 的核心特性之一，用于共享通用逻辑，减少代码重复。
使用依赖注入的步骤：
Depends需求：多个接口都需要分页逻辑，使用依赖注入来共享分页参数处理
main.py
from fastapi import FastAPI, Depends, Query
app = FastAPI()
async def common_parameters(
skip: int = Query(0, ge=0),
limit: int = Query(10, le=60)
):
return {"skip": skip, "limit": limit}
@app.get("/news/news_list")
async def get_news_list(commons = Depends(common_parameters)):
return {"list": "新闻列表", **commons}
@app.get("/users/user_list")
async def get_user_list(commons = Depends(common_parameters)):
return {"users": "用户列表", **commons}
ORM（Object-Relational Mapping，对象关系映射）是一种编程技术，用于在面向对象的编程语言和关系型数据库之间建立映射关系。它允许开发者使用面向对象的方式操作数据库，而不需要直接编写 SQL 语句。
SQLAlchemy 是 Python 中最流行的 ORM 框架，也是企业应用最多、社区最活跃的 ORM 库。
uv add sqlalchemy[asyncio] aiomysql
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker
# 创建异步引擎
engine = create_async_engine(
"mysql+aiomysql://user:password@localhost/dbname",
echo=True
)
# 创建会话工厂
async_session = sessionmaker(
engine, class_=AsyncSession, expire_on_commit=False
)
# 依赖项：获取数据库会话
async def get_database():
async with async_session() as session:
yield session
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
pass
from sqlalchemy import Column, Integer, String, Float
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
pass
class Book(Base):
__tablename__ = "books"
id = Column(Integer, primary_key=True, index=True)
bookname = Column(String(100), nullable=False)
author = Column(String(50))
price = Column(Float)
from sqlalchemy import run_sync
# 创建所有表
async def init_db():
async with engine.begin() as conn:
await run_sync(Base.metadata.create_all, conn)
from sqlalchemy import select
@app.get("/book/get_books")
async def get_book_list(db: AsyncSession = Depends(get_database)):
stmt = select(Book)
result = await db.execute(stmt)
books = result.scalars().all()
return {"books": books}
# 方式1：使用 get 方法（根据主键）
book = await db.get(Book, book_id)
# 方式2：使用 select + first
stmt = select(Book).where(Book.id == book_id)
result = await db.execute(stmt)
book = result.scalars().first()
# 方式3：使用 scalar_one_or_none（确保只有一条或没有）
book = result.scalars().one_or_none()
@app.get("/book/get_books")
async def get_book_list(
page: int = 1,
page_size: int = 3,
db: AsyncSession = Depends(get_database)
):
skip = (page - 1) * page_size
stmt = select(Book).offset(skip).limit(page_size)
result = await db.execute(stmt)
books = result.scalars().all()
return {"books": books}
核心步骤：定义 ORM 对象 → 添加对象到事务：add(对象) → commit 提交到数据库
from pydantic import BaseModel
class BookBase(BaseModel):
bookname: str
author: str
price: float
@app.post("/book/add_book")
async def add_book(book: BookBase, db: AsyncSession = Depends(get_database)):
# 创建图书对象（**book.dict() 返回 book 对象的属性字典）
book_obj = Book(**book.dict())
db.add(book_obj)
await db.commit()
return book
核心步骤：查询 get → 属性重新赋值 → commit 提交到数据库
from pydantic import BaseModel
from fastapi import HTTPException
class BookUpdate(BaseModel):
bookname: str
author: str
price: float
@app.put("/book/update_book/{book_id}")
async def update_book(
book_id: int,
data: BookUpdate,
db: AsyncSession = Depends(get_database)
):
# 1. 查询
book = await db.get(Book, book_id)
if book is None:
raise HTTPException(status_code=404, detail="Book not found")
# 2. 修改属性(重新赋值)
book.bookname = data.bookname
book.author = data.author
book.price = data.price
# 3. 提交
await db.commit()
return book
核心步骤：查询 get → delete 删除 → commit 提交到数据库
@app.delete("/book/delete_book/{book_id}")
async def delete_book(
book_id: int,
db: AsyncSession = Depends(get_database)
):
db_book = await db.get(Book, book_id)
if db_book is None:
raise HTTPException(status_code=404, detail="Book not found")
await db.delete(db_book)
await db.commit()
return {"message": "Book deleted"}
select() → db.execute() → 从 ORM 对象获取数据 → 响应结果db.get(模型类, 主键值)scalars().all()scalars().first()：提取第一个数据scalar_one_or_none()：提取一个或 nullscalar()：提取标量值（配合聚合查询使用）sqlalchemy[asyncio]aiomysql（异步数据库驱动）create_async_engine 创建异步引擎DeclarativeBase）和模型类run_sync(Base.metadata.create_all) 建表Dependsselect()add()delete()git，如果没有的话需要先去git官网下载，并配置，还要先了解基础的clone,add,commit,push,pull等基本操作
github中有一个开源项目是专门用于让初学者学习如何参与开源项目的，链接如下：
这个开源项目的README文档中有具体的参与教程，这里直接根据这个开源项目的教程来学习如何参与开源项目
在进入上面的网页中后，点击右上角的Fork，后面的确认信息直接保持默认即可
在得到自己的仓库后，选择将自己的库克隆到本地，注意是自己的仓库而不是原仓库
在本地找个文件夹右键打开git bash，然后在命令行中输入以下内容
git clone [复制的内容]
随后在git bash中进入仓库，并创建新的代码分支，分支名可以是add-newbranch，也可以是add-hygen，可以是任意名字，但是最好有add-表示添加分支
cd first-contributions
git switch -c add-newbranch
由于这是开源教程，所以没有实质性的代码修改内容，打开Contributions.md这个文件，在最后加上自己的名字即可
将修改提交上去前可以用git status先看看都有哪些修改
之后提交修改，如果要提交所有修改，就选择git add .，这里选择精确提交修改，commit处将yourname部分改成自己的名字即可
git add Contributions.md
git commit -m "Add <yourname> to Contributions list"
使用git push推送代码，后面同样将内容替换为自己修改的新分支名称即可
git push origin <new-branch-name>
example：
git push origin add-hygen
前往自己的仓库，有Compare & pull request按钮，点击即可
关于正式开始后有哪些注意事项，请参考b站up主码农高天的这期视频
]]>简单来说就是给定一个输入k, m, n
k表示聚类的数量m表示样本的数量n表示训练轮数样本的特征维度固定是4
接下来m行输入每个样本的值，每行包含4个浮点数，每个浮点数表示一个特征
要求直接选择前k个样本作为初始化质心
训练结束条件为训练次数达到n轮或新簇和旧簇的距离<1e-8，后者意为如果训练前后两个簇位置没变，则说明已经稳定
输入保证所有数据都合法且已归一化
输出：
要输出k个值，表示这k个聚类中每个簇有几个样本，按从小到大的顺序排列
3 20 1000
0.11 0.79 0.68 0.97
1.0 0.8 0.13 0.33
0.27 0.02 0.5 0.46
0.83 0.29 0.23 0.75
0.97 0.08 0.84 0.55
0.29 0.71 0.17 0.83
0.03 0.6 0.88 0.28
0.24 0.26 0.82 0.03
0.96 0.12 0.82 0.36
0.13 0.12 0.86 0.44
0.23 0.7 0.35 0.06
0.42 0.49 0.67 0.84
0.8 0.49 0.47 0.7
0.68 0.03 0.11 0.07
0.77 0.19 0.95 0.44
0.25 0.12 0.98 0.04
0.7 0.11 0.53 0.3
0.73 0.67 0.46 0.96
0.11 0.31 0.91 0.57
0.43 0.61 0.13 0.1
表示将20个样本分为3个簇，训练1000轮
4 6 10
表示分为的三个簇中第一个簇有4个样本，第二个簇有6个样本，第三个簇有10个样本
K-means 是一种经典的无监督聚类算法，其目标是将 $m$ 个样本划分为 $k$ 个簇，使得同一簇内的样本相似度高，不同簇之间的样本相似度低。
算法的核心思想是：
根据题意，直接选择前 $k$ 个样本作为初始聚类中心。
def _init_centroids(self, data):
self.centroids = data[: self.n_clusters]
对于每个样本，计算其到所有 $k$ 个聚类中心的欧氏距离。使用 NumPy 的广播机制高效计算，并将结果存储在 self.distances 中：
def _distance(self, data):
self.distances = np.sqrt(((data[:, np.newaxis] - self.centroids) ** 2).sum(axis=2))
📖 补充知识：关于
np.newaxis、np.sqrt、np.sum和axis=2的详细说明，请参考 距离计算相关函数
使用 argmin 找到每个样本距离最近的聚类中心索引。该方法直接使用 self.distances 中存储的距离矩阵：
def _min_distance(self):
return np.argmin(self.distances, axis=1)
📖 补充知识：关于
np.argmin和axis=1的详细说明，请参考 argmin 函数详解
对于每个簇，计算簇内所有样本的均值作为新的聚类中心。使用列表推导式高效计算，并返回新旧聚类中心的欧氏范数（用于判断收敛）：
def _update_centroids(self, data):
old = self.centroids
self.centroids = np.array([data[self.labels == i].mean(axis=0) for i in range(self.n_clusters)])
return np.linalg.norm(old - self.centroids)
📖 补充知识：关于
np.mean、axis=0和np.linalg.norm的详细说明，请参考 更新聚类中心相关函数 和 范数计算函数
重复执行分配和更新步骤，直到满足以下条件之一：
def fit(self, data):
self._init_centroids(data)
for _ in range(self.max_iter):
self._distance(data)
self.labels = self._min_distance()
if self._update_centroids(data) < self.tolerance:
break
📖 补充知识：关于
np.linalg.norm的详细说明，请参考 范数计算函数
训练完成后，统计每个簇的样本数量，并按从小到大排序输出：
cnt = np.bincount(kmeans.labels, minlength=k)
cnt.sort()
print(*cnt)
📖 补充知识：关于
np.bincount、np.array和reshape的详细说明，请参考 数据统计相关函数
距离计算优化：使用 NumPy 的广播机制一次性计算所有样本到所有聚类中心的距离，避免嵌套循环，提高效率。距离矩阵存储在 self.distances 中，供后续使用。
代码结构优化：
_update_centroids 方法使用列表推导式简化代码，并直接返回收敛度_min_distance 方法直接使用 self.distances，无需传递参数收敛判断：_update_centroids 方法直接返回新旧聚类中心的欧氏范数，在 fit 方法中判断是否小于阈值 $10^{-8}$ 来决定是否提前终止迭代。
import numpy as np
import sys
class Kmeans:
def __init__(self, n_clusters, max_iter):
self.n_clusters = n_clusters
self.max_iter = max_iter
self.centroids = None
self.labels = None
self.distances = None
self.tolerance = 1e-8
def _init_centroids(self, data):
self.centroids = data[: self.n_clusters]
def _distance(self, data):
self.distances = np.sqrt(((data[:, np.newaxis] - self.centroids) ** 2).sum(axis=2))
def _min_distance(self):
return np.argmin(self.distances, axis=1)
def _update_centroids(self, data):
old = self.centroids
self.centroids = np.array([data[self.labels == i].mean(axis=0) for i in range(self.n_clusters)])
return np.linalg.norm(old - self.centroids)
def fit(self, data):
self._init_centroids(data)
for _ in range(self.max_iter):
self._distance(data)
self.labels = self._min_distance()
if self._update_centroids(data) < self.tolerance:
break
def main():
data = sys.stdin.read().split()
idx = 0
k, m, n = [int(x) for x in data[idx:idx+3]]
idx += 3
X = np.array(data[idx:idx+4*m], dtype=np.float64).reshape(m, 4)
kmeans = Kmeans(n_clusters=k, max_iter=n)
kmeans.fit(X)
cnt = np.bincount(kmeans.labels, minlength=k)
cnt.sort()
print(*cnt)
if __name__ == '__main__':
main()
np.newaxis定义：np.newaxis 是 None 的别名，用于数组索引时增加维度。
示例：
arr = np.array([1, 2, 3]) # shape: (3,)
arr_new = arr[:, np.newaxis] # shape: (3, 1)
# 结果: [[1], [2], [3]]
np.sqrt定义：对数组中的每个元素计算平方根。
示例：
arr = np.array([4, 9, 16])
result = np.sqrt(arr) # [2.0, 3.0, 4.0]
np.sum定义：np.sum(a, axis=None) 计算数组元素的和，axis 指定沿哪个轴求和。
示例：
arr = np.array([[1, 2], [3, 4]]) # shape: (2, 2)
np.sum(arr, axis=0) # 沿第0轴（行）求和: [4, 6]
np.sum(arr, axis=1) # 沿第1轴（列）求和: [3, 7]
np.sum(arr) # 所有元素求和: 10
形状变换：
X 的形状为 $(m, 4)$，表示 $m$ 个样本，每个样本有 4 个特征X[:, np.newaxis] 将形状变为 $(m, 1, 4)$，增加了一个维度self.centroids 的形状为 $(k, 4)$，表示 $k$ 个聚类中心广播运算：
X[:, np.newaxis] - self.centroids 通过广播机制，将 $(m, 1, 4)$ 和 $(k, 4)$ 进行运算self.centroids 扩展为 $(1, k, 4)$，然后与 $(m, 1, 4)$ 运算平方、求和和开方：
** 2 对差值进行平方，形状仍为 $(m, k, 4)$.sum(axis=2) 沿第 2 轴（特征维度）求和，将 4 个特征维度的平方差相加np.sqrt(...) 对整个求和结果开方，得到最终的欧氏距离矩阵((...).sum(axis=2)) 确保了先对平方差求和，然后再对结果开方，这是正确的欧氏距离计算公式为什么使用 axis=2？
axis=2 表示沿特征维度（第 3 个维度，索引为 2）求和axis=0 或 axis=1，会沿错误的方向求和，无法得到正确的距离运算顺序说明：
代码 np.sqrt(((data[:, np.newaxis] - self.centroids) ** 2).sum(axis=2)) 的执行顺序是：
(data[:, np.newaxis] - self.centroids) ** 2 → 形状 $(m, k, 4)$.sum(axis=2) → 形状 $(m, k)$，得到平方距离np.sqrt(...) → 形状 $(m, k)$，得到欧氏距离外层括号 ((...).sum(axis=2)) 确保了求和操作在开方之前完成，这符合欧氏距离的数学定义：$\sqrt{\sum_{i=1}^{d}(x_i - y_i)^2}$，即先对各个维度的平方差求和，再对总和开方。
np.argmin定义：np.argmin(a, axis=None) 返回沿指定轴的最小值的索引。
示例：
arr = np.array([[3, 1, 4], [2, 5, 1]]) # shape: (2, 3)
np.argmin(arr, axis=0) # 沿第0轴找最小值索引: [1, 0, 1]
np.argmin(arr, axis=1) # 沿第1轴找最小值索引: [1, 2]
np.argmin(arr) # 全局最小值索引（扁平化后）: 1
axis=1？dts 的形状为 $(m, k)$，表示 $m$ 个样本到 $k$ 个聚类中心的距离axis=1 表示沿第 1 轴（聚类中心维度）查找最小值示例说明：
# 假设 dts = [[2.5, 1.2, 3.1], # 样本0到3个聚类中心的距离
# [1.8, 2.3, 0.9], # 样本1到3个聚类中心的距离
# [3.2, 2.1, 1.5]] # 样本2到3个聚类中心的距离
# np.argmin(dts, axis=1) 返回: [1, 2, 2]
# 表示：样本0最近的是聚类中心1，样本1最近的是聚类中心2，样本2最近的是聚类中心2
np.mean定义：np.mean(a, axis=None) 计算数组元素的平均值，axis 指定沿哪个轴计算。
示例：
arr = np.array([[1, 2, 3], [4, 5, 6]]) # shape: (2, 3)
np.mean(arr, axis=0) # 沿第0轴（行）求均值: [2.5, 3.5, 4.5]
np.mean(arr, axis=1) # 沿第1轴（列）求均值: [2.0, 5.0]
np.mean(arr) # 所有元素的均值: 3.5
优化后的代码使用列表推导式简化了实现：
提取每个簇的样本并计算均值：
data[self.labels == i] 使用布尔索引提取属于第 $i$ 个簇的所有样本.mean(axis=0) 沿第 0 轴（样本维度）求均值构建新的聚类中心数组：
np.array([...]) 将列表推导式的结果转换为数组self.centroids 的形状为 $(k, 4)$，每行代表一个聚类中心计算收敛度：
old = self.centroids 保存更新前的聚类中心np.linalg.norm(old - self.centroids) 计算新旧聚类中心的欧氏范数fit 方法中判断是否收敛为什么使用 axis=0？
samples 的形状为 $(n_i, 4)$，包含 $n_i$ 个样本，每个样本有 4 个特征axis=0 表示沿样本维度（第 0 轴）进行聚合操作axis=1，会沿特征维度求均值，得到每个样本的平均特征值，这是错误的示例说明：
# 假设第0个簇有3个样本
samples = np.array([[1.0, 2.0, 3.0, 4.0], # 样本1
[1.5, 2.5, 3.5, 4.5], # 样本2
[2.0, 3.0, 4.0, 5.0]]) # 样本3
# shape: (3, 4)
# np.mean(samples, axis=0) 对每列（特征）求均值
# 结果: [1.5, 2.5, 3.5, 4.5] # 4个特征的平均值
# 如果使用 axis=1，会对每行（样本）求均值
# np.mean(samples, axis=1) 结果: [2.5, 3.0, 3.5] # 每个样本的平均特征值（错误）
np.linalg.norm定义：np.linalg.norm(x, ord=None, axis=None) 计算数组的范数，默认计算欧氏范数（L2 范数）。
示例：
vec = np.array([3, 4])
np.linalg.norm(vec) # 欧氏范数: 5.0 (sqrt(3^2 + 4^2))
matrix = np.array([[1, 2], [3, 4]])
np.linalg.norm(matrix) # 矩阵的Frobenius范数: 5.477...
np.linalg.norm(matrix, axis=0) # 沿第0轴计算: [3.162..., 4.472...]
收敛判断说明：
self.centroids - old 计算新旧聚类中心的差值，形状为 $(k, 4)$np.linalg.norm() 计算所有差值的欧氏范数，得到一个标量值np.bincount定义：np.bincount(x, weights=None, minlength=0) 返回一个数组，索引 i 处的值表示 i 在输入数组中出现的次数。
示例：
labels = np.array([0, 1, 1, 0, 2, 1])
cnt = np.bincount(labels) # [2, 3, 1] 表示0出现2次，1出现3次，2出现1次
cnt = np.bincount(labels, minlength=5) # [2, 3, 1, 0, 0] 保证输出长度至少为5
统计过程说明：
kmeans.labels 是一个长度为 $m$ 的一维数组，每个元素表示对应样本所属的簇索引（0 到 $k-1$）np.bincount(kmeans.labels, minlength=k) 统计每个簇索引出现的次数minlength=k 确保输出数组长度至少为 $k$，即使某些簇没有样本也会输出 0cnt 是一个长度为 $k$ 的数组，cnt[i] 表示第 $i$ 个簇的样本数量cnt.sort() 对数组进行原地排序，从小到大排列print(*cnt) 使用解包操作打印数组元素，用空格分隔np.array定义：从列表或其他数组创建 NumPy 数组。
示例：
data = ['1.0', '2.0', '3.0', '4.0']
arr = np.array(data, dtype=np.float64) # [1.0, 2.0, 3.0, 4.0]
reshape定义：改变数组的形状而不改变数据。
示例：
arr = np.array([1, 2, 3, 4, 5, 6])
arr.reshape(2, 3) # [[1, 2, 3], [4, 5, 6]]
arr.reshape(3, 2) # [[1, 2], [3, 4], [5, 6]]
数据读取说明：
np.array(data[idx:idx+4*m], dtype=np.float64) 将字符串列表转换为 NumPy 数组data[idx:idx+4*m] 提取从索引 idx 开始的 $4m$ 个元素（Python 切片是左闭右开区间）.reshape(m, 4) 将一维数组重塑为 $(m, 4)$ 的二维数组，每行代表一个样本Tool Calling Agent（工具调用代理）是LangGraph支持的第二种AI Agent代理架构。这个代理架构是在Router Agent的基础上，大模型可以自主选择并使用多种工具来完成某个条件分支中的任务。
工具调用大家应该非常熟悉了，当我们希望代理与外部系统交互时，工具就非常有用。外部系统（例如API）通常需要特定的输入模式，而不是自然语言。例如，当我们绑定 API 作为工具时，我们赋予大模型对所需输入模式的感知，大模型就能根据用户的自然语言输入选择调用工具，并将返回符合该工具架构的输出。
<div align=center><img src="https://muyu001.oss-cn-beijing.aliyuncs.com/img/image-20241024112245580.png" width=100%></div>
Tool Calling Agent的本质原理是：让大模型根据用户的输入，自动的去判断应该使用哪个函数，并实际的执行，最后结合工具的响应结果 + 用户的原始问题作为完整的Prompt生成最终的问题。即如下图所示：
<div align=center><img src="https://muyu001.oss-cn-beijing.aliyuncs.com/img/image-20241025120544561.png" width=100%></div>
在LangGraph框架中，可以直接使用预构建ToolNode进行工具调用，其内部实现原理和我们之前介绍的手动实现的Function Calling流程思路基本一致，即：
tools_by_name = {tool.name: tool for tool in tools}
def tool_node(state: dict):
result = []
for tool_call in state["messages"][-1].tool_calls:
tool = tools_by_name[tool_call["name"]]
observation = tool.invoke(tool_call["args"])
result.append(ToolMessage(content=observation, tool_call_id=tool_call["id"]))
return {"messages": result}
经过ToolNode工具后，其返回的是一个LangChain Runnable对象，会将图形状态（带有消息列表）作为输入并输出状态更新以及工具调用的结果，通过这种设计去适配LangGraph中其他的功能组件。
对于ToolNode的使用，有三个必要的点需要满足：
先尝试一下联网功能
import requests
import json
def fetch_real_time_info(query):
"""Get real-time Internet information"""
url = "https://google.serper.dev/search"
payload = json.dumps({
"q": query,
"num": 1,
})
headers = {
'X-API-KEY': 'xxx', # 填写自己的serper-key, 可以进入 url 的网址中注册账号获取
'Content-Type': 'application/json'
}
response = requests.post(url, headers=headers, data=payload, timeout=10)
data = json.loads(response.text)
if 'organic' in data:
return json.dumps(data['organic'], ensure_ascii=False) # 返回'organic'部分的JSON字符串
else:
return json.dumps({"error": "No organic results found"}, ensure_ascii=False) # 如果没有'organic'键，返回错误信息
print(fetch_real_time_info("DeepSeek的最新新闻"))
实验结果：
[{"title": "更新日志", "link": "https://api-docs.deepseek.com/zh-cn/updates", "snippet": "新闻. DeepSeek-V3.2-Exp 发布2025/09/29 · DeepSeek V3.1 更新2025/09/22 · DeepSeek V3.1 发布2025/08/21 · DeepSeek-R1-0528 发布2025/05/28 · DeepSeek-V3-0324 发布 ...", "position": 1}]
如果想要将普通的函数变成ToolNode可以应用的外部函数，只需要在函数定义时添加@tool装饰器。
from langchain_core.tools import tool
import requests
import json
@tool
def fetch_real_time_info(query):
"""Get real-time Internet information"""
url = "https://google.serper.dev/search"
payload = json.dumps({
"q": query,
"num": 1,
})
headers = {
'X-API-KEY': 'xxx', # 使用自己的api-key
'Content-Type': 'application/json'
}
response = requests.post(url, headers=headers, data=payload, timeout=10)
data = json.loads(response.text)
if 'organic' in data:
return json.dumps(data['organic'], ensure_ascii=False) # 返回'organic'部分的JSON字符串
else:
return json.dumps({"error": "No organic results found"}, ensure_ascii=False) # 如果没有'organic'键，返回错误信息
print(f"""name: {fetch_real_time_info.name}
description: {fetch_real_time_info.description}
arguments: {fetch_real_time_info.args}""")
实验结果
name: fetch_real_time_info
description: Get real-time Internet information
arguments: {'query': {'title': 'Query'}}
使用@tool装饰器后，函数会自动获得以下属性：
name: 工具名称description: 工具描述（从函数文档字符串中提取）args: 工具参数定义使用ToolNode对函数进行实例化：
from langgraph.prebuilt import ToolNode
tools = [fetch_real_time_info]
tool_node = ToolNode(tools)
print(tool_node)
实验结果
tools(tags=None, recurse=True, explode_args=False, func_accepts_config=True, func_accepts={'store': ('__pregel_store', None)}, tools_by_name={'fetch_real_time_info': StructuredTool(name='fetch_real_time_info', description='Get real-time Internet information', args_schema=<class 'langchain_core.utils.pydantic.fetch_real_time_info'>, func=<function fetch_real_time_info at 0x00000238629AD1C0>)}, tool_to_state_args={'fetch_real_time_info': {}}, tool_to_store_arg={'fetch_real_time_info': None}, handle_tool_errors=True, messages_key='messages')
ToolNode使用消息列表对图状态进行操作。所以它要求消息列表中的最后一条消息是带有tool_calls参数的AIMessage。
from langchain_core.messages import AIMessage
message_with_single_tool_call = AIMessage(
content="",
tool_calls=[
{
"name": "fetch_real_time_info",
"args": {"query": "DeepSeek的最新新闻"},
"id": "tool_call_id",
"type": "tool_call",
}
],
)
print(tool_node.invoke({"messages": [message_with_single_tool_call]}))
实验结果
{'messages': [ToolMessage(content='[{"title": "DeepSeek | 世界新聞網", "link": "https://www.worldjournal.com/search/tagging/8877/DeepSeek", "snippet": "FT：DeepSeek新模型延後問世問題出在華為晶片還是得靠輝達 · 2025-08-14 03:00 ; OpenAI最新模型GPT-5發布傳DeepSeek將推R2 · 2025-08-14 02:04 ; 受惠DeepSeek-R2將發表中國AI ...", "position": 1}]', name='fetch_real_time_info', tool_call_id='tool_call_id')]}
如果将多个工具调用同时传递给AIMessage的tool_calls参数，仍然可以使用ToolNode进行并行工具调用：
@tool
def get_weather(location):
"""Call to get the current weather."""
if location.lower() in ["beijing"]:
return "北京的温度是16度，天气晴朗。"
elif location.lower() in ["shanghai"]:
return "上海的温度是20度，部分多云。"
else:
return "不好意思，并未查询到具体的天气信息。"
tools = [fetch_real_time_info, get_weather]
tool_node = ToolNode(tools)
print(tool_node)
实验结果
tools(tags=None, recurse=True, explode_args=False, func_accepts_config=True, func_accepts={'store': ('__pregel_store', None)}, tools_by_name={'fetch_real_time_info': StructuredTool(name='fetch_real_time_info', description='Get real-time Internet information', args_schema=<class 'langchain_core.utils.pydantic.fetch_real_time_info'>, func=<function fetch_real_time_info at 0x00000178B4F7D580>), 'get_weather': StructuredTool(name='get_weather', description='Get the weather of a location', args_schema=<class 'langchain_core.utils.pydantic.get_weather'>, func=<function get_weather at 0x00000178B4F71120>)}, tool_to_state_args={'fetch_real_time_info': {}, 'get_weather': {}}, tool_to_store_arg={'fetch_real_time_info': None, 'get_weather': None}, handle_tool_errors=True, messages_key='messages')
message_with_multiple_tool_calls = AIMessage(
content="",
tool_calls=[
{
"name": "fetch_real_time_info",
"args": {"query": "DeepSeek的最新新闻"},
"id": "tool_call_id",
"type": "tool_call",
},
{
"name": "get_weather",
"args": {"location": "beijing"},
"id": "tool_call_id_2",
"type": "tool_call",
},
],
)
print(tool_node.invoke({"messages": [message_with_multiple_tool_calls]}))
实验结果
{'messages': [ToolMessage(content='[{"title": "DeepSeek-V3.2-Exp 发布，训练推理提效，API 同步降价", "link": "https://api-docs.deepseek.com/zh-cn/news/news250929", "snippet": "在新的价格政策下，开发者调用DeepSeek API 的成本将降低50% 以上。 目前API 的模型版本为DeepSeek-V3.2-Exp，访问方式保持
不变。 欢迎用户使用DeepSeek 官方的API 服务。", "position": 1}]', name='fetch_real_time_info', tool_call_id='tool_call_id'), ToolMessage(content='北京的温度是16度，天气晴朗。', name='get_weather', tool_call_id='tool_call_id_2')]}
通过bind_tools函数可以将工具绑定到大模型，让大模型知道有哪些工具可以使用：
from langchain_openai import ChatOpenAI
import os
os.environ["OPENAI_API_KEY"] = "sk-xxx" # 自己的api-key
llm = ChatOpenAI(
base_url="https://api.deepseek.com/v1",
model="deepseek-chat",
temperature=0
)
model_with_tools = llm.bind_tools(tools)
print(model_with_tools)
实验结果
bound=ChatOpenAI(client=<openai.resources.chat.completions.completions.Completions object at 0x000001D4A259DAF0>, async_client=<openai.resources.chat.completions.completions.AsyncCompletions object at 0x000001D4A2502E10>, root_client=<openai.OpenAI object at 0x000001D4A10CA570>, root_async_client=<openai.AsyncOpenAI object at 0x000001D4A259DF70>, model_name='deepseek-chat', temperature=0.0, model_kwargs={}, openai_api_key=SecretStr('**********'), openai_api_base='https://api.deepseek.com/v1') kwargs={'tools': [{'type': 'function', 'function': {'name': 'fetch_real_time_info', 'description': 'Get real-time Internet information', 'parameters': {'properties': {'query': {}}, 'required': ['query'], 'type': 'object'}}}, {'type': 'function', 'function': {'name': 'get_weather', 'description': 'Get the weather of a location', 'parameters': {'properties': {'location': {}}, 'required': ['location'], 'type': 'object'}}}]} config={} config_factories=[]
绑定后，大模型可以根据用户的自然语言输入，自动生成tool_calls信息：
# 大模型会自动判断需要调用哪个工具
response = model_with_tools.invoke("DeepSeek的最新新闻")
print(response.tool_calls) # 输出工具调用信息
# 可以直接传递给ToolNode执行
print(tool_node.invoke({"messages": [response]}))
实验结果
[{'name': 'fetch_real_time_info', 'args': {'query': 'DeepSeek最新新闻'}, 'id': 'call_00_LmIQTb8iSy0BHM7iuQPoZV9N', 'type': 'tool_call'}]
{'messages': [ToolMessage(content='[{"title": "DeepSeek解决AI有无问题，灵光攻克AI好用难题", "link": "https://t.cj.sina.cn/articles/view/6328613060/m17936f8c403301lueq?from=tech&vt=4", "snippet": "如果说DeepSeek解决了AI“有没有”的问题，那么灵光则解决了AI“好不好用”的难题. 打开App看更多精彩内容. 分享文章到.", "date": "19 hours ago", "position": 1}]', name='fetch_real_time_info', tool_call_id='call_00_LmIQTb8iSy0BHM7iuQPoZV9N')]}
对Router Agent实现的图做进一步的升级，即用户输入问题后，如果不需要外部工具的信息，则直接生成回复，否则，则进入一个工具库中，选择最合适的工具执行，并返回最终的响应。
首先定义多个工具，使用Pydantic模型来定义工具的参数结构：
import json
from tokenize import String
from langchain_core.tools import tool
from pydantic import Field, BaseModel
import requests
from langgraph.prebuilt import ToolNode
from typing import Optional
from sqlalchemy import Column, Integer, String, create_engine, text
from sqlalchemy.orm import declarative_base, sessionmaker
# 定义搜索查询模型
class SearchQuery(BaseModel):
query: str = Field(description="Questions for networking queries")
@tool(args_schema=SearchQuery)
def fetch_real_time_info(query):
"""Get real-time Internet information"""
url = "https://google.serper.dev/search"
payload = json.dumps({"q": query, "num": 1})
headers = {
'X-API-KEY': 'xxx', # 你的api-key
'Content-Type': 'application/json'
}
response = requests.post(url, headers=headers, data=payload)
data = json.loads(response.text)
if 'organic' in data:
return json.dumps(data['organic'], ensure_ascii=False)
else:
return json.dumps({"error": "No organic results found"}, ensure_ascii=False)
class WeatherLoc(BaseModel):
location: str = Field(description="The location name of the city")
# 定义获取天气工具
@tool(args_schema=WeatherLoc)
def get_weather(location):
"""Get the weather of a location"""
if location.lower() in ["beijing"]:
return "北京的温度是16度，天气晴朗。"
elif location.lower() in ["shanghai"]:
return "上海的温度是20度，部分多云。"
else:
return "不好意思，并未查询到具体的天气信息。"
# 创建基类
Base = declarative_base()
# 定义 UserInfo 模型
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String(50))
age = Column(Integer)
email = Column(String(100))
phone = Column(String(15))
class UserInfo(BaseModel):
"""Extracted user information, such as name, age, email, and phone number, if relevant."""
name: str = Field(description="The name of the user")
age: Optional[int] = Field(description="The age of the user")
email: str = Field(description="The email address of the user")
phone: Optional[str] = Field(description="The phone number of the user")
# MySQL 连接信息（不包含数据库名，用于创建数据库）
MYSQL_USER = 'root'
MYSQL_PASSWORD = '123456'
MYSQL_HOST = 'localhost'
MYSQL_PORT = '3306'
DATABASE_NAME = 'langgraph_agent'
# 先连接到 MySQL 服务器（不指定数据库），用于创建数据库
server_uri = f'mysql+pymysql://{MYSQL_USER}:{MYSQL_PASSWORD}@{MYSQL_HOST}:{MYSQL_PORT}?charset=utf8mb4'
server_engine = create_engine(server_uri, echo=False)
# 创建数据库（如果不存在）
with server_engine.connect() as conn:
conn.execute(text(f"CREATE DATABASE IF NOT EXISTS `{DATABASE_NAME}` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci"))
conn.commit()
# 连接到指定的数据库
DATABASE_URI = f'mysql+pymysql://{MYSQL_USER}:{MYSQL_PASSWORD}@{MYSQL_HOST}:{MYSQL_PORT}/{DATABASE_NAME}?charset=utf8mb4'
engine = create_engine(DATABASE_URI, echo=True)
# 如果表不存在，则创建表
Base.metadata.create_all(engine)
# 创建会话
Session = sessionmaker(bind=engine)
session = Session()
# 定义插入数据库工具
@tool(args_schema=UserInfo)
def insert_db(name, age, email, phone):
"""Insert user information into the database, The required parameters are name, age, email, phone"""
session = Session()
try:
user = User(name=name, age=age, email=email, phone=phone)
session.add(user)
session.commit()
return "用户信息已成功插入数据库。"
except Exception as e:
session.rollback()
return f"用户信息插入失败: {e}"
finally:
session.close()
在三个工具定义完毕后，将其传递给tool_node，并将其实例化
tools = [fetch_real_time_info, get_weather, insert_db]
tool_node = ToolNode(tools)
print(tool_node)
实验结果
tools(tags=None, recurse=True, explode_args=False, func_accepts_config=True, func_accepts={'store': ('__pregel_store', None)}, tools_by_name={'fetch_real_time_info': StructuredTool(name='fetch_real_time_info', description='Get real-time Internet information', args_schema=<class '__main__.SearchQuery'>, func=<function fetch_real_time_info at 0x00000239B8965300>), 'get_weather': StructuredTool(name='get_weather', description='Get the weather of a location', args_schema=<class '__main__.WeatherLoc'>, func=<function get_weather at 0x00000239B89B9580>), 'insert_db': StructuredTool(name='insert_db', description='Insert user information into the database, The required parameters are name, age, email, phone', args_schema=<class '__main__.UserInfo'>, func=<function insert_db at 0x00000239B8BCDC60>)}, tool_to_state_args={'fetch_real_time_info': {}, 'get_weather': {}, 'insert_db': {}}, tool_to_store_arg={'fetch_real_time_info': None, 'get_weather': None, 'insert_db': None}, handle_tool_errors=True, messages_key='messages')
from langchain_openai import ChatOpenAI
import os
os.environ["OPENAI_API_KEY"] = "your-openai-api-key-here" # 占位符：请换成你自己的密钥，切勿把真实密钥写进文章或仓库
llm = ChatOpenAI(
base_url="https://api.deepseek.com/v1",
model="deepseek-chat",
temperature=0
)
model_with_tools = llm.bind_tools(tools)
使用Pydantic来做结构化输出，帮助Router Function来选择路径分支：
from typing import Union
# 定义正常响应模型，可以是用户信息或一般响应
class ConversationalResponse(BaseModel):
"""Respond to the user's query in a conversational manner. Be kind and helpful."""
response: str = Field(description="A conversational response to the user's query")
# 定义最终响应模型，可以是用户信息或一般响应
class FinalResponse(BaseModel):
final_output: Union[ConversationalResponse, SearchQuery, WeatherLoc, UserInfo]
定义三个节点函数：
def chat_with_model(state):
"""generate structured output"""
print(state)
print("-----------------")
messages = state['messages']
structured_llm = llm.with_structured_output(FinalResponse, method="function_calling")
response = structured_llm.invoke(messages)
return {"messages": [response]}
def final_answer(state):
"""generate natural language responses"""
print(state)
print("-----------------")
messages = state['messages'][-1]
response = messages.final_output.response
return {"messages": [response]}
def execute_function(state):
"""execute tool calling"""
print(state)
print("-----------------")
final_output = state['messages'][-1].final_output
# 将结构化输出转换为 AIMessage，包含工具调用
from langchain_core.messages import AIMessage
# 根据不同的输出类型构建工具调用
tool_calls = []
if isinstance(final_output, SearchQuery):
tool_calls.append({
"name": "fetch_real_time_info",
"args": {"query": final_output.query},
"id": "tool_call_search",
"type": "tool_call",
})
elif isinstance(final_output, WeatherLoc):
tool_calls.append({
"name": "get_weather",
"args": {"location": final_output.location},
"id": "tool_call_weather",
"type": "tool_call",
})
elif isinstance(final_output, UserInfo):
tool_calls.append({
"name": "insert_db",
"args": {
"name": final_output.name,
"age": final_output.age,
"email": final_output.email,
"phone": final_output.phone
},
"id": "tool_call_db",
"type": "tool_call",
})
# 创建包含工具调用的 AIMessage
ai_message = AIMessage(content="", tool_calls=tool_calls)
# 调用工具节点
tool_response = tool_node.invoke({"messages": [ai_message]})
# 提取工具执行结果
if tool_response.get("messages") and len(tool_response["messages"]) > 0:
# ToolMessage 的内容就是工具的执行结果
result = tool_response["messages"][0].content
else:
result = "工具执行失败：未返回结果"
print("工具执行结果:", result)
return {"messages": [result]}
from typing import TypedDict, Annotated
import operator
from langchain_core.messages import AnyMessage
class AgentState(TypedDict):
messages: Annotated[list[AnyMessage], operator.add]
定义generate_branch函数作为Router Function，根据经过chat_with_model节点后产生的不同Pydantic对象，选择连接不同的节点：
def generate_branch(state: AgentState):
result = state['messages'][-1]
output = result.final_output
if isinstance(output, ConversationalResponse):
return False # 不需要工具调用
else:
return True # 需要工具调用
构建完整的图结构：
# 构建图结构
from langgraph.graph import StateGraph
graph = StateGraph(AgentState)
graph.add_node("chat_with_model", chat_with_model)
graph.add_node("final_answer", final_answer)
graph.add_node("execute_function", execute_function)
graph.set_entry_point("chat_with_model")
graph.add_conditional_edges(
"chat_with_model",
generate_branch,
{True: "execute_function", False: "final_answer"}
)
graph.set_finish_point("final_answer")
graph.set_finish_point("execute_function")
graph = graph.compile()
完成图的编译后，可以开始进行功能测试：
from langchain_core.messages import HumanMessage
# 测试1: 普通对话（不需要工具）
query = "你好，请你介绍一下你自己"
input_message = {"messages": [HumanMessage(content=query)]}
result = graph.invoke(input_message)
print("-----------------")
print(result)
print("-----------------")
print(result["messages"][-1])
# 测试2: 网络搜索（需要工具）
query = "帮我查一下DeepSeek的最新新闻"
input_message = {"messages": [HumanMessage(content=query)]}
result = graph.invoke(input_message)
print("-----------------")
print(result)
print("-----------------")
print(result["messages"][-1])
# 测试3: 天气查询（需要工具）
query = "Beijing的天气怎么样？"
input_message = {"messages": [HumanMessage(content=query)]}
result = graph.invoke(input_message)
print("-----------------")
print(result)
print("-----------------")
print(result["messages"][-1])
# 测试4: 数据库插入（需要工具）
query = "我是Hygen，今年18，电话号是01000721，邮箱是ciallo@qq.com"
input_message = {"messages": [HumanMessage(content=query)]}
result = graph.invoke(input_message)
print("-----------------")
print(result)
print("-----------------")
print(result["messages"][-1])
实验结果
{'messages': [HumanMessage(content='你好，请你介绍一下你自己', additional_kwargs={}, response_metadata={})]}
-----------------
{'messages': [HumanMessage(content='你好，请你介绍一下你自己', additional_kwargs={}, response_metadata={}), FinalResponse(final_output=ConversationalResponse(response='你好！我是一个AI助手，很高兴认识你！我可以帮助你回答各种问题、提供信息、协助解决问题，或者只是和你聊天。我具备多种能力，包
括搜索信息、处理文本、分析数据等。\n\n我的特点是：\n- 能够理解和回应中文\n- 可以处理各种类型的问题\n- 提供准确和有用的信息\n- 保持友好和专业的交流方式\n\n如果你有任何问题或需要帮助，请随时告诉我！你想了解什么具体内容，或者有什么我可以为你做的吗？'))]}
-----------------
-----------------
{'messages': [HumanMessage(content='你好，请你介绍一下你自己', additional_kwargs={}, response_metadata={}), FinalResponse(final_output=ConversationalResponse(response='你好！我是一个AI助手，很高兴认识你！我可以帮助你回答各种问题、提供信息、协助解决问题，或者只是和你聊天。我具备多种能力，包 括搜索信息、处理文本、分析数据等。\n\n我的特点是：\n- 能够理解和回应中文\n- 可以处理各种类型的问题\n- 提供准确和有用的信息\n- 保持友好和专业的交流方式\n\n如果你有任何问题或需要帮助，请随时告诉我！你想了解什么具体内容，或者有什么我可以为你做的吗？')), '你好！我是一个AI助手，很高兴认识你！我 可以帮助你回答各种问题、提供信息、协助解决问题，或者只是和你聊天。我具备多种能力，包括搜索信息、处理文本、分析数据等。\n\n我的特点是：\n- 能够理解和回应中文\n- 可以处理各种类型的问题\n- 提供准确和有用的信息\n- 保持友好和专业的交流方式\n\n如果你有任何问题或需要帮助，请随时告诉我！你想了解什 么具体内容，或者有什么我可以为你做的吗？']}
-----------------
你好！我是一个AI助手，很高兴认识你！我可以帮助你回答各种问题、提供信息、协助解决问题，或者只是和你聊天。我具备多种能力，包括搜索信息、处理文本、分析数据等。
我的特点是：
- 能够理解和回应中文
- 可以处理各种类型的问题
- 提供准确和有用的信息
- 保持友好和专业的交流方式
如果你有任何问题或需要帮助，请随时告诉我！你想了解什么具体内容，或者有什么我可以为你做的吗？
{'messages': [HumanMessage(content='帮我查一下DeepSeek的最新新闻', additional_kwargs={}, response_metadata={})]}
-----------------
{'messages': [HumanMessage(content='帮我查一下DeepSeek的最新新闻', additional_kwargs={}, response_metadata={}), FinalResponse(final_output=SearchQuery(query='DeepSeek最新新闻'))]}
-----------------
工具执行结果: [{"title": "DeepSeek等中製AI模型操弄資訊、洩個資國安局", "link": "https://www.cna.com.tw/news/aipl/202511160037.aspx", "snippet": "國安局今天表示，依法抽驗包括DeepSeek等5款中製「生成式AI語言模型」後，所生成內容出現中共官宣、歷史偏差、資訊操弄等嚴重偏頗與不實資訊， ...", "date": "3 days ago", "position": 1}]
-----------------
{'messages': [HumanMessage(content='帮我查一下DeepSeek的最新新闻', additional_kwargs={}, response_metadata={}), FinalResponse(final_output=SearchQuery(query='DeepSeek最新新闻')), '[{"title": "DeepSeek等中製AI模型操弄資訊、洩個資國安局", "link": "https://www.cna.com.tw/news/aipl/202511160037.aspx", "snippet": "國安局今天表示，依法抽驗包括DeepSeek等5款中製「生成式AI語言模型」後，所生成內容出現中共官宣、歷史偏差、資訊操弄等嚴重偏頗與不實資訊， ...", "date": "3 days ago", "position": 1}]']}
-----------------
[{"title": "DeepSeek等中製AI模型操弄資訊、洩個資國安局", "link": "https://www.cna.com.tw/news/aipl/202511160037.aspx", "snippet": "國安局今天表示，依法抽驗包括DeepSeek等5款中製「生成式AI語言模型」後，所生成內容出現中共官宣、歷史偏差、資訊操弄等嚴重偏頗與不實資訊， ...", "date": "3 days ago", "position": 1}]
{'messages': [HumanMessage(content='Beijing的天气怎么样？', additional_kwargs={}, response_metadata={})]}
-----------------
{'messages': [HumanMessage(content='Beijing的天气怎么样？', additional_kwargs={}, response_metadata={}), FinalResponse(final_output=WeatherLoc(location='Beijing'))]}
-----------------
工具执行结果: 北京的温度是16度，天气晴朗。
-----------------
{'messages': [HumanMessage(content='Beijing的天气怎么样？', additional_kwargs={}, response_metadata={}), FinalResponse(final_output=WeatherLoc(location='Beijing')), '北京的温度是16度，天气晴朗。']}
-----------------
北京的温度是16度，天气晴朗。
{'messages': [HumanMessage(content='我是Hygen，今年18，电话号是01000721，邮箱是ciallo@qq.com', additional_kwargs={}, response_metadata={})]}
-----------------
{'messages': [HumanMessage(content='我是Hygen，今年18，电话号是01000721，邮箱是ciallo@qq.com', additional_kwargs={}, response_metadata={}), FinalResponse(final_output=UserInfo(name='Hygen', age=18, email='ciallo@qq.com', phone='01000721'))]}
-----------------
2025-11-19 13:04:06,678 INFO sqlalchemy.engine.Engine BEGIN (implicit)
2025-11-19 13:04:06,681 INFO sqlalchemy.engine.Engine INSERT INTO users (name, age, email, phone) VALUES (%(name)s, %(age)s, %(email)s, %(phone)s)
2025-11-19 13:04:06,681 INFO sqlalchemy.engine.Engine [generated in 0.00024s] {'name': 'Hygen', 'age': 18, 'email': 'ciallo@qq.com', 'phone': '01000721'}
2025-11-19 13:04:06,696 INFO sqlalchemy.engine.Engine COMMIT
工具执行结果: 用户信息已成功插入数据库。
-----------------
{'messages': [HumanMessage(content='我是Hygen，今年18，电话号是01000721，邮箱是ciallo@qq.com', additional_kwargs={}, response_metadata={}), FinalResponse(final_output=UserInfo(name='Hygen', age=18, email='ciallo@qq.com', phone='01000721')), '用户信息已成功插入数据库。']}
-----------------
用户信息已成功插入数据库。
当然，工具调用的过程也可以手动进行实现，我们只需要进行适当的逻辑修改即可。
前面的部分复用上面的代码即可，这里就不重复编写了
from langchain_core.messages import ToolMessage
from langchain_openai import ChatOpenAI
import os
os.environ["OPENAI_API_KEY"] = "your-openai-api-key-here" # 占位符：请换成你自己的密钥，切勿把真实密钥写进文章或仓库
llm = ChatOpenAI(
base_url="https://api.deepseek.com/v1",
model="deepseek-chat",
temperature=0
)
def chat_with_model(state):
"""generate structured output"""
messages = state['messages']
response = llm.invoke(messages)
return {"messages": [response]}
def execute_function(state):
"""execute tool calling"""
tool_calls = state['messages'][-1].tool_calls
results = []
tools = [fetch_real_time_info, get_weather, insert_db]
tools = {t.name: t for t in tools}
for t in tool_calls:
if not t['name'] in tools:
result = "bad tool name, retry"
else:
result = tools[t['name']].invoke(t['args'])
results.append(ToolMessage(tool_call_id=t['id'], name=t['name'], content=str(result)))
return {"messages": results}
定义路由函数来判断是否需要工具调用：
def exists_function_calling(state: AgentState):
result = state['messages'][-1]
return len(result.tool_calls) > 0
在工具调用后，添加一个节点来生成最终的自然语言响应：
SYSTEM_PROMPT = """
Please summarize the information obtained so far and generate a professional response. Note, please reply in Chinese.
"""
from langchain_core.messages import SystemMessage, HumanMessage
def natural_response(state):
"""generate final language responses"""
messages = state['messages'][-1]
messages = [SystemMessage(content=SYSTEM_PROMPT)] + [HumanMessage(content=messages.content)]
response = llm.invoke(messages)
return {"messages": [response]}
from typing import TypedDict, Annotated
import operator
from langchain_core.messages import AnyMessage
from langgraph.graph import StateGraph
class AgentState(TypedDict):
messages: Annotated[list[AnyMessage], operator.add]
graph = StateGraph(AgentState)
graph.add_node("chat_with_model", chat_with_model)
graph.add_node("execute_function", execute_function)
graph.add_node("final_answer", final_answer)
graph.add_node("natural_response", natural_response)
graph.set_entry_point("chat_with_model")
graph.add_conditional_edges(
"chat_with_model",
exists_function_calling,
{True: "execute_function", False: "final_answer"}
)
graph.add_edge("execute_function", "natural_response")
graph.add_edge("final_answer", "natural_response")
graph.set_finish_point("natural_response")
graph = graph.compile()
确保大模型绑定了工具：
tools = [insert_db, fetch_real_time_info, get_weather]
llm = llm.bind_tools(tools)
# 测试1: 普通对话（不需要工具）
query = "你好，请你介绍一下你自己"
input_message = {"messages": [HumanMessage(content=query)]}
result = graph.invoke(input_message)
print("-----------------")
print(result)
# 测试2: 网络搜索（需要工具）
query = "帮我查一下DeepSeek的最新新闻"
input_message = {"messages": [HumanMessage(content=query)]}
result = graph.invoke(input_message)
print("-----------------")
print(result)
# 测试3: 天气查询（需要工具）
query = "Beijing的天气怎么样？"
input_message = {"messages": [HumanMessage(content=query)]}
result = graph.invoke(input_message)
print("-----------------")
print(result)
# 测试4: 数据库插入（需要工具）
query = "我是Hygen，今年28，电话号是01000721，邮箱是ciallo@qq.com"
input_message = {"messages": [HumanMessage(content=query)]}
result = graph.invoke(input_message)
print("-----------------")
print(result)
实验结果
-----------------
{'messages': [HumanMessage(content='你好，请你介绍一下你自己', additional_kwargs={}, response_metadata={}), AIMessage(content='你好！我是一个AI助手，很高兴认识你！我可以帮助你处理各种任务，包括：\n\n- 获取实时网络信息\n- 查询天气情况\n- 管理用户信息（存储到数据库中）\n\n我可以通过工具来获取最新的网络信息、查询特定城市的天气，以及将用户信息（姓名、年龄、邮箱、电话）保存到数据库中。\n\n请告诉我你需要什么帮助，我会尽力为你提供支持！', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 84, 'prompt_tokens': 368, 'total_tokens': 452, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cached_tokens': 320}, 'prompt_cache_hit_tokens': 320, 'prompt_cache_miss_tokens': 48}, 'model_name': 'deepseek-chat', 'system_fingerprint': 'fp_ffc7281d48_prod0820_fp8_kvcache', 'id': '94aaa2f7-b65e-458c-b369-a70d841f105e', 'service_tier': None, 'finish_reason': 'stop', 'logprobs': None}, id='run--ee81ac9d-e4f0-492c-95db-1928d9c54202-0', usage_metadata={'input_tokens': 368, 'output_tokens': 84, 'total_tokens': 452, 'input_token_details': {'cache_read': 320}, 'output_token_details': {}}), AIMessage(content='你好！我是一个AI助手，很高兴认识你！我可以帮助你处理各种任务，包括：\n\n- 获取实时网络信息\n- 查询天气情况\n- 管理用户信息（存储到数据库中）\n\n我可以通过工具来获取最新的网络信息、查询特定城市的天气，以及将用户信息（姓名、年龄、邮箱、电话）保存到数据库中。\n\n请告诉我你需要什么帮助 ，我会尽力为你提供支持！', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 84, 'prompt_tokens': 368, 'total_tokens': 452, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cached_tokens': 320}, 'prompt_cache_hit_tokens': 320, 'prompt_cache_miss_tokens': 48}, 'model_name': 'deepseek-chat', 'system_fingerprint': 'fp_ffc7281d48_prod0820_fp8_kvcache', 'id': '94aaa2f7-b65e-458c-b369-a70d841f105e', 'service_tier': None, 'finish_reason': 'stop', 'logprobs': None}, id='run--ee81ac9d-e4f0-492c-95db-1928d9c54202-0', usage_metadata={'input_tokens': 368, 'output_tokens': 84, 'total_tokens': 452, 'input_token_details': {'cache_read': 320}, 'output_token_details': {}}), AIMessage(content='你好！很高兴认识你！感谢你详细介绍你的功能和服务范围。\n\n根据你的描述，你确实具备以下强大的能力：\n\n**主要功能：**\n1. **实时网络信息查询** - 可以获取最新的网络资讯和信息\n2. **天气查询** - 能够查询特定城市的天气情况\n3. **用户信息管理** - 可以将用户信息（姓名、年龄、邮箱、电话）存储到数据库中\n\n**使用方式：**\n- 如果你需要查询任何实时信息，我可以帮你搜索网络\n- 如果你想知道某个城市的天气，告诉 我城市名即可\n- 如果你需要保存用户信息，请提供姓名、年龄、邮箱和电话\n\n我现在已经准备好为你提供帮助了！请告诉我你需要什么服务，或者有什么具体的问题需要解决？我会根据你的需求选择最合适的工具来协助你。', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 170, 'prompt_tokens': 468, 'total_tokens': 638, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cached_tokens': 0}, 'prompt_cache_hit_tokens': 0, 'prompt_cache_miss_tokens': 468}, 'model_name': 'deepseek-chat', 'system_fingerprint': 'fp_ffc7281d48_prod0820_fp8_kvcache', 'id': '8f3dbeff-b403-4aef-a685-1bc425d6c62a', 'service_tier': None, 'finish_reason': 'stop', 'logprobs': None}, id='run--092e834b-2c6c-4d8a-a5ea-b4fb2df4f761-0', usage_metadata={'input_tokens': 468, 'output_tokens': 170, 'total_tokens': 638, 'input_token_details': {'cache_read': 0}, 'output_token_details': {}})]}
-----------------
{'messages': [HumanMessage(content='帮我查一下DeepSeek的最新新闻', additional_kwargs={}, response_metadata={}), AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_00_EM6RKCZJbx09rIEDrVA0Re0L', 'function': {'arguments': '{"query": "DeepSeek最新新闻"}', 'name': 'fetch_real_time_info'}, 'type': 'function', 'index': 0}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 19, 'prompt_tokens': 371, 'total_tokens': 390, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cached_tokens': 320}, 'prompt_cache_hit_tokens': 320, 'prompt_cache_miss_tokens': 51}, 'model_name': 'deepseek-chat', 'system_fingerprint': 'fp_ffc7281d48_prod0820_fp8_kvcache', 'id': 'a1826f70-cfa1-4fab-8412-09bc3f901a06', 'service_tier': None, 'finish_reason': 'tool_calls', 'logprobs': None}, id='run--a95bf745-8601-4fe5-bc77-4e2014e508cf-0', tool_calls=[{'name': 'fetch_real_time_info', 'args': {'query': 'DeepSeek最新新闻'}, 'id': 'call_00_EM6RKCZJbx09rIEDrVA0Re0L', 'type': 'tool_call'}], usage_metadata={'input_tokens': 371, 'output_tokens': 19, 'total_tokens': 390, 'input_token_details': {'cache_read': 320}, 'output_token_details': {}}), ToolMessage(content='[{"title": "DeepSeek | 世界新聞網", "link": "https://www.worldjournal.com/search/tagging/8877/DeepSeek", "snippet": "FT：DeepSeek新模型延後問世問題出在華為晶片還是得靠輝達 · 2025-08-14 03:00 ; OpenAI最新模型GPT-5發布傳DeepSeek將推R2 · 2025-08-14 02:04 ; 受惠DeepSeek-R2將發表中國AI ...", "position": 1}]', name='fetch_real_time_info', tool_call_id='call_00_EM6RKCZJbx09rIEDrVA0Re0L'), AIMessage(content='根据您提供的信息，我看到了关于DeepSeek的一些最新新闻摘要。这些信息主要来自世界新聞網，涉及以下几个要点：\n\n1. **DeepSeek新模型延后问世** - 有报道讨论其延迟原因是否与华为芯片相关还是需要依赖辉达（NVIDIA）\n\n2. **OpenAI GPT-5发布** - 同时有传闻DeepSeek将推出R2模型\n\n3. **中国AI受益** - 提到受惠于DeepSeek-R2即将发表\n\n不过，这些信息相对有限，主要是新闻标题和简短摘要。如果您需要更详细、更全面的DeepSeek相关信息，我可以 帮您搜索最新的实时信息来获取更完整的报道内容。\n\n您希望我为您搜索更多关于DeepSeek的详细资讯吗？', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 162, 'prompt_tokens': 509, 'total_tokens': 671, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cached_tokens': 320}, 'prompt_cache_hit_tokens': 320, 'prompt_cache_miss_tokens': 189}, 'model_name': 'deepseek-chat', 'system_fingerprint': 'fp_ffc7281d48_prod0820_fp8_kvcache', 'id': '0f5dd1f4-4b97-41a8-bd61-81943a5da6bb', 'service_tier': None, 'finish_reason': 'stop', 'logprobs': None}, id='run--19b47710-a7fb-4d37-9d7d-07b58c48f4e5-0', usage_metadata={'input_tokens': 509, 'output_tokens': 162, 'total_tokens': 671, 'input_token_details': {'cache_read': 320}, 'output_token_details': {}})]}
-----------------
{'messages': [HumanMessage(content='Beijing的天气怎么样？', additional_kwargs={}, response_metadata={}), AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_00_QxjiQuICuIOKzOOgQaJCAcGo', 'function': {'arguments': '{"location": "Beijing"}', 'name': 'get_weather'}, 'type': 'function', 'index': 0}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 14, 'prompt_tokens': 368, 'total_tokens': 382, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cached_tokens': 320}, 'prompt_cache_hit_tokens': 320, 'prompt_cache_miss_tokens': 48}, 'model_name': 'deepseek-chat', 'system_fingerprint': 'fp_ffc7281d48_prod0820_fp8_kvcache', 'id': '16c53fc1-d392-4626-8268-e6104fab5bae', 'service_tier': None, 'finish_reason': 'tool_calls', 'logprobs': None}, id='run--76f8f809-a413-48fb-8a30-9401700c3fd3-0', tool_calls=[{'name': 'get_weather', 'args': {'location': 'Beijing'}, 'id': 'call_00_QxjiQuICuIOKzOOgQaJCAcGo', 'type': 'tool_call'}], usage_metadata={'input_tokens': 368, 'output_tokens': 14, 'total_tokens': 382, 'input_token_details': {'cache_read': 320}, 'output_token_details': {}}), ToolMessage(content='北京的温度是16度，天气晴朗。', name='get_weather', tool_call_id='call_00_QxjiQuICuIOKzOOgQaJCAcGo'), AIMessage(content='根据您提供的信息，北京当前的温度是16度，天气晴朗。这是一个非常宜人的天气状况，适合户外活动和出行。\n\n如果您需要获取更详细的天气信息，比如湿度、风速、空气质量指 数等，我可以帮您查询最新的实时天气数据。您是否需要我为您获取更全面的北京天气信息？', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 64, 'prompt_tokens': 393, 'total_tokens': 457, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cached_tokens': 320}, 'prompt_cache_hit_tokens': 320, 'prompt_cache_miss_tokens': 73}, 'model_name': 'deepseek-chat', 'system_fingerprint': 'fp_ffc7281d48_prod0820_fp8_kvcache', 'id': 'bfd56895-dda9-4e7e-9a48-99e105c185e1', 'service_tier': None, 'finish_reason': 'stop', 'logprobs': None}, id='run--bc232be5-2b56-44f5-801c-454435c722ab-0', usage_metadata={'input_tokens': 393, 'output_tokens': 64, 'total_tokens': 457, 'input_token_details': {'cache_read': 320}, 'output_token_details': {}})]}
2025-11-19 13:27:10,184 INFO sqlalchemy.engine.Engine BEGIN (implicit)
2025-11-19 13:27:10,187 INFO sqlalchemy.engine.Engine INSERT INTO users (name, age, email, phone) VALUES (%(name)s, %(age)s, %(email)s, %(phone)s)
2025-11-19 13:27:10,189 INFO sqlalchemy.engine.Engine [generated in 0.00027s] {'name': 'Hygen', 'age': 28, 'email': 'ciallo@qq.com', 'phone': '01000721'}
2025-11-19 13:27:10,191 INFO sqlalchemy.engine.Engine COMMIT
-----------------
{'messages': [HumanMessage(content='我是Hygen，今年28，电话号是01000721，邮箱是ciallo@qq.com', additional_kwargs={}, response_metadata={}), AIMessage(content='您好Hygen！我已经收到了您的个人信息：\n- 姓名：Hygen\n- 年龄：28岁\n- 电话：01000721\n- 邮箱：ciallo@qq.com\n\n现在我将把这些信息保 存到数据库中。', additional_kwargs={'tool_calls': [{'id': 'call_00_svoG4YILmEjp7UVtyhHAm7CL', 'function': {'arguments': '{"name": "Hygen", "age": 28, "email": "ciallo@qq.com", "phone": "01000721"}', 'name': 'insert_db'}, 'type': 'function', 'index': 0}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 87, 'prompt_tokens': 384, 'total_tokens': 471, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cached_tokens': 320}, 'prompt_cache_hit_tokens': 320, 'prompt_cache_miss_tokens': 64}, 'model_name': 'deepseek-chat', 'system_fingerprint': 'fp_ffc7281d48_prod0820_fp8_kvcache', 'id': '2b5d2240-b1eb-4cff-8ea6-642647c7980c', 'service_tier': None, 'finish_reason': 'tool_calls', 'logprobs': None}, id='run--625e59b0-ec90-455b-94b3-d210c882e61a-0', tool_calls=[{'name': 'insert_db', 'args': {'name': 'Hygen', 'age': 28, 'email': 'ciallo@qq.com', 'phone': '01000721'}, 'id': 'call_00_svoG4YILmEjp7UVtyhHAm7CL', 'type': 'tool_call'}], usage_metadata={'input_tokens': 384, 'output_tokens': 87, 'total_tokens': 471, 'input_token_details': {'cache_read': 320}, 'output_token_details': {}}), ToolMessage(content='用户信息已成功插入数据库。', name='insert_db', tool_call_id='call_00_svoG4YILmEjp7UVtyhHAm7CL'), AIMessage(content='根据您提供的信息，用户数据已成功保存到数据库中。这是一个标准的确认信息，表明：\n\n**操作结果：成功**\n- 用户信息已完整录入数据库系统\n- 数据存储过程顺利完成\n- 系统已确认保存 操作\n\n如果您需要：\n- 查询已保存的用户信息\n- 进行其他数据库操作\n- 获取更多关于数据管理的帮助\n\n请随时告知，我将为您提供相应的支持。', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 88, 'prompt_tokens': 391, 'total_tokens': 479, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cached_tokens': 320}, 'prompt_cache_hit_tokens': 320, 'prompt_cache_miss_tokens': 71}, 'model_name': 'deepseek-chat', 'system_fingerprint': 'fp_ffc7281d48_prod0820_fp8_kvcache', 'id': '2d284b4f-9eec-49e1-91d2-8e51fb3f94da', 'service_tier': None, 'finish_reason': 'stop', 'logprobs': None}, id='run--ceaa01d6-396c-4bf6-8cf4-4644f265ffa6-0', usage_metadata={'input_tokens': 391, 'output_tokens': 88, 'total_tokens': 479, 'input_token_details': {'cache_read': 320}, 'output_token_details': {}})]}
@tool装饰器Pydantic模型，可以实现结构化的工具参数定义tool_calls的AIMessageTool Calling Agent是在Router Agent基础上的扩展：
这种设计使得Tool Calling Agent具有更高的控制级别，能够处理更复杂的任务场景。
对于工具调用而言，因为调用工具的参数是由大模型根据用户输入的自然语言生成的，所以一定会存在以下边缘情况：
这些情况会直接导致整个图的运行中断。需要在后续的学习中关注错误处理和重试机制的实现。
]]>在LangGraph中，我们可以利用"条件边"这一概念来指导或约束大模型在处理特定任务时的逻辑流程。这种机制允许大模型在达到某一环节并满足预设条件时，根据不同的条件输出或数据，选择性地执行不同的逻辑路径。
为了管理这样复杂的图结构，LangGraph使用的是一个类似于 if-else语句的结构组件，称为Router（路由）。这个组件允许大模型从一组预设的选项中选择合适的步骤来进行执行。
对于简单的直接从节点A到节点B，我们一直使用的是add_edge方法：
from langgraph.graph import START, StateGraph, END
def node_a(state):
return {"x": state["x"] + 1}
def node_b(state):
return {"x": state["x"] - 2}
builder = StateGraph(dict)
builder.add_node("node_a", node_a)
builder.add_node("node_b", node_b)
# 构建节点之间的边
builder.add_edge(START, "node_a")
builder.add_edge("node_a", "node_b")
builder.add_edge("node_b", END)
graph = builder.compile()
如果想选择性地路由到 1 个或多个边，则需要使用add_conditional_edges方法。该方法在Graph的基类中进行了定义：
def add_conditional_edges(
self,
source: str, # 起始节点
path: Union[ # 这是一个可调用对象，其返回值决定接下来执行的节点
Callable[..., Union[Hashable, list[Hashable]]],
Callable[..., Awaitable[Union[Hashable, list[Hashable]]]],
Runnable[Any, Union[Hashable, list[Hashable]]],
],
path_map: Optional[Union[dict[Hashable, str], list[str]]] = None, # 路径到节点名称的可选映射
then: Optional[str] = None, # 在path选择的节点之后执行的节点的名称
) -> Self:
路由函数routing_function接受图的当前state并返回一个值，根据返回值的不同，来决定路由到哪个节点：
def routing_function(state):
if state["x"] == 10:
return "node_b"
else:
return "node_c"
builder.add_conditional_edges("node_a", routing_function)
默认情况下，routing_function路由函数的返回值用作将状态发送到下一个节点的名称。除此之外，还可以使用path_map参数，通过一个字典的数据结构将routing_function的输出映射到下一个节点的名称：
def routing_function(state):
if state["x"] == 10:
return True
else:
return False
builder.add_conditional_edges(
"node_a",
routing_function,
{True: "node_b", False: "node_c"}
)
一般来说，Agent是可以接收各种形式的输入，并通过预设的路由逻辑来确定执行的具体操作。如图所示，Agent的开始节点（Start）接收输入数据，这些输入可以是查询请求（例如"name: muyu, age: 18, phone: 123"或"Hello"）。根据输入的不同，流程通过Router函数进行决策，将不同的输入引导到正确的处理流程。
这里的核心是Router function，它根据输入数据的结构和内容，动态地决定下一步应该执行的节点。例如，对于具体的查询请求，Router决定需要访问数据库（Mysql节点），而对于简单的问候（如"Hello"），则直接返回一个响应（Response节点）。
关键要点：
Agent时，Router function的定义才是最关键且最重要的Router就很好的利用到了这个特性，通过结构化输出的特性来控制接下来的分支路径在LangGraph中，实现结构化输出可以通过以下三种有效方式完成：
直接通过提示工程让大模型生成特定格式的输出：
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o-mini")
prompt = ChatPromptTemplate.from_messages(
[
(
"system",
"Answer the user query. Wrap the output in `json`",
),
("human", "{query}"),
]
)
chain = prompt | llm
ans = chain.invoke({"query": "我叫Hygen，今年18岁，邮箱地址是ciallo@gmial.com，电话是01000721"})
直接通过提示工程让大模型生成特定格式的输出虽然是可行的，但这种方法在复杂的Agent构建流程中非常并不稳定。
引入后处理步骤，通过输出解析器来格式化大模型生成的响应，可以提高输出的准确性和一致性：
from langchain_core.messages import AIMessage
import json
import re
from typing import List
def extract_json(message: AIMessage) -> List[dict]:
"""Extracts JSON content from a string where JSON is embedded between ```json and ``` tags."""
text = message.content
pattern = r"\`\`\`json(.*?)\`\`\`"
matches = re.findall(pattern, text, re.DOTALL)
try:
return [json.loads(match.strip()) for match in matches]
except Exception:
raise ValueError(f"Failed to parse: {message}")
chain = prompt | llm | extract_json
ans = chain.invoke({"query": "我叫Hygen，今年18岁，邮箱地址是ciallo@gmial.com，电话是01000721"})
在LangGraph中我们更常用的，且效果更好的是，直接使用其内置的工具方法：.with_structured_output()。
这个方法通过接受一个定义了所需输出属性的名称、类型和描述的模式作为输入，进而生成一个类似模型的 Runnable。不同于常规模型输出字符串或消息，这个 Runnable 输出一个与输入模式相匹配的对象。
可以通过几种方式指定这种架构，包括 TypedDict 类、JSON Schema 或 Pydantic 类。如果采用 TypedDict 或 JSON Schema，Runnable 将输出一个字典；若使用 Pydantic 类，则输出一个 Pydantic 对象。
使用Pydantic去限定输出格式，可以确保所有通过此模型处理的数据都会符合指定的结构和数据类型，从而减少数据处理中的错误并增加代码的健壮性。此外，Pydantic的验证系统还会自动确保所有字段都符合预定义的格式，如果输入数据不符合预期，则会抛出错误。
from typing import Optional
from pydantic import BaseModel, Field
# 定义 Pydantic 模型
class UserInfo(BaseModel):
"""Extracted user information, such as name, age, email, and phone number, if relevant."""
name: str = Field(description="The name of the user")
age: Optional[int] = Field(description="The age of the user")
email: str = Field(description="The email address of the user")
phone: Optional[str] = Field(description="The phone number of the user")
在这个UserInfo模型中：
name（必需）: 存储用户的名字age（可选）: 存储用户的年龄，这是一个可选字段email（必需）: 存储用户的电子邮件地址phone（可选）: 存储用户的电话号码，这也是一个可选字段对于.with_structured_output()方法，如果我们希望模型返回一个 Pydantic 对象，只需要传入所需的 Pydantic 类即可：
import os
from langchain_openai import ChatOpenAI
os.environ["OPENAI_API_KEY"] = "sk-xxx" # 更换为自己的api-key
llm = ChatOpenAI(
base_url="https://api.deepseek.com/v1",
model="deepseek-chat",
temperature=0
)
# 使用 function_calling 方法，兼容更多模型
structured_llm = llm.with_structured_output(UserInfo, method="function_calling")
extracted_user_info = structured_llm.invoke("我叫Hygen，今年18岁，邮箱地址是ciallo@gmial.com，电话是01000721")
print(extracted_user_info)
运行结果：
name='Hygen' age=18 email='ciallo@gmial.com' phone='01000721'
它返回的是一个UserInfo的Pydantic对象，每个字段中则填充了在原始非结构化文本中提取出来的结构化信息。
经过这样的格式化输出，对于Router function中，我们就可以通过类似这样的伪代码去继续路由分支的选择：
if isinstance(extracted_user_info, UserInfo):
print("执行节点A的逻辑")
else:
print("执行节点B的逻辑")
这就是结构化输出对于LangGraph中路由函数逻辑判断的意义所在。
如果不想使用 Pydantic去明确地验证输出参数，则可以使用 TypedDict 类定义结构化输出的模式。这就可以使用特殊Annotated语法，添加对指定字段的默认值和描述：
from typing import Optional
from typing_extensions import Annotated, TypedDict
# 定义 TypedDict 模型
class UserInfo(TypedDict):
"""Extracted user information from text"""
name: Annotated[str, ..., "The user's name"]
age: Annotated[Optional[int], None, "The user's age"]
email: Annotated[str, ..., "The user's email address"]
phone: Annotated[Optional[str], None, "The user's phone number"]
structured_llm = llm.with_structured_output(UserInfo, method="function_calling")
extracted_user_info = structured_llm.invoke("我叫Hygen，今年18岁，邮箱地址是ciallo@gmial.com，电话是01000721")
使用 TypedDict 创建的"对象"实际上是一个字典。它没有Pydantic模型那样的方法和属性，因此功能相对简单。TypedDict 主要用于静态类型检查，但它不会在运行时进行类型检查，但搭配着LangGraph中已实现的基本验证机制，也是一种不错的方法。
对于Json Schema格式大家应该最为熟悉，不需要导入或类，可以直接通过字典的形式清楚地准确记录每个参数，但代价是代码会更加冗长：
# 定义 JSON Schema
json_schema = {
"title": "user_info",
"description": "Extracted user information",
"type": "object",
"properties": {
"name": {
"type": "string",
"description": "The user's name",
},
"age": {
"type": "integer",
"description": "The user's age",
"default": None,
},
"email": {
"type": "string",
"description": "The user's email address",
},
"phone": {
"type": "string",
"description": "The user's phone number",
"default": None,
},
},
"required": ["name", "email"],
}
structured_llm = llm.with_structured_output(UserInfo, method="function_calling")
extracted_user_info = structured_llm.invoke("我叫Hygen，今年18岁，邮箱地址是ciallo@gmial.com，电话是01000721")
三种不同的结构化输出方法，我们更常使用的是用Pydantic来处理路由决策。在这种策略下，我们可以通过定义一个包含Union类型属性的父模型来灵活地从多种模式中选择适当的路由分支。
例如，如果我们想根据输出决定是查询数据库还是直接回答问题，可以创建一个统一的模型来封装可能的输出类型：
from typing import Union, Optional
from pydantic import BaseModel, Field
# 定义数据库插入的用户信息模型
class UserInfo(BaseModel):
"""Extracted user information, such as name, age, email, and phone number, if relevant."""
name: str = Field(description="The name of the user")
age: Optional[int] = Field(description="The age of the user")
email: str = Field(description="The email address of the user")
phone: Optional[str] = Field(description="The phone number of the user")
# 定义正常生成模型回复的模型
class ConversationalResponse(BaseModel):
"""Respond to the user's query in a conversational manner. Be kind and helpful."""
response: str = Field(description="A conversational response to the user's query")
# 定义最终响应模型，可以是用户信息或一般响应
class FinalResponse(BaseModel):
final_output: Union[UserInfo, ConversationalResponse]
这个扩展后的代码将用于提取和存储用户的基本信息的UserInfo模型与用于生成面向用户的交流响应的ConversationalResponse模型统一的放在了FinalResponse模型中，使用Union类型来支持灵活的输出选项。
首先，定义Pydantic模型以及用于生成格式化输出的大模型实例：
import os
from langchain_openai import ChatOpenAI
os.environ["OPENAI_API_KEY"] = "sk-xxx" # 输入自己的api-key
llm = ChatOpenAI(
base_url="https://api.deepseek.com/v1",
model="deepseek-chat",
temperature=0
)
定义路由节点函数，将用户输入的文本转化成格式化输出：
def chat_with_model(state):
"""generate structured output"""
messages = state['messages']
structured_llm = llm.with_structured_output(FinalResponse, method="function_calling")
response = structured_llm.invoke(messages)
return {"messages": [response]}
连接数据库并创建表
from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, text
from sqlalchemy.orm import declarative_base, sessionmaker
# 创建基类
Base = declarative_base()
# 定义 UserInfo 模型
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String(50))
age = Column(Integer)
email = Column(String(100))
phone = Column(String(15))
# 数据库连接配置
# 格式：mysql+pymysql://用户名:密码@主机:端口/数据库名?charset=utf8mb4
# 本地连接说明：
# - 用户名：你的 MySQL 用户名（默认通常是 root）
# - 密码：你的 MySQL 密码
# - 主机：localhost 或 127.0.0.1（本地连接）
# - 端口：3306（MySQL 默认端口，如果使用默认端口可以省略）
# - 数据库名：要连接的数据库名称
# - charset=utf8mb4：设置字符集为 utf8mb4，支持更广泛的 Unicode 字符
# MySQL 连接信息（不包含数据库名，用于创建数据库）
MYSQL_USER = 'root'
MYSQL_PASSWORD = '123456'
MYSQL_HOST = 'localhost'
MYSQL_PORT = '3306'
DATABASE_NAME = 'langgraph_agent'
# 先连接到 MySQL 服务器（不指定数据库），用于创建数据库
server_uri = f'mysql+pymysql://{MYSQL_USER}:{MYSQL_PASSWORD}@{MYSQL_HOST}:{MYSQL_PORT}?charset=utf8mb4'
server_engine = create_engine(server_uri, echo=False)
# 创建数据库（如果不存在）
with server_engine.connect() as conn:
conn.execute(text(f"CREATE DATABASE IF NOT EXISTS `{DATABASE_NAME}` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci"))
conn.commit()
# 连接到指定的数据库
DATABASE_URI = f'mysql+pymysql://{MYSQL_USER}:{MYSQL_PASSWORD}@{MYSQL_HOST}:{MYSQL_PORT}/{DATABASE_NAME}?charset=utf8mb4'
engine = create_engine(DATABASE_URI, echo=True)
# 如果表不存在，则创建表
Base.metadata.create_all(engine)
# 创建会话
Session = sessionmaker(bind=engine)
session = Session()
然后分别定义两个分支节点，其中final_answer用于直接生成响应，而insert_db用于执行数据库插入操作：
def final_answer(state):
"""generate natural language responses"""
messages = state['messages'][-1]
response = messages.final_output.response
return {"messages": [response]}
def insert_db(state):
"""Insert user information into the database"""
session = Session() # 确保为每次操作创建新的会话
try:
result = state['messages'][-1]
output = result.final_output
user = User(name=output.name, age=output.age, email=output.email, phone=output.phone)
session.add(user)
session.commit()
return {"messages": [f"数据已成功存储至Mysql数据库。"]}
except Exception as e:
session.rollback() # 出错时回滚
return {"messages": [f"数据存储失败，错误原因：{e}"]}
finally:
session.close() # 关闭会话
定义generate_branch函数作为Router Function，根据经过chat_with_model节点后产生的不同Pydantic对象，选择连接不同的节点：
from langchain_core.messages import AnyMessage
from typing_extensions import TypedDict, Annotated
import operator
class AgentState(TypedDict):
messages: Annotated[list[AnyMessage], operator.add]
def generate_branch(state: AgentState):
result = state['messages'][-1]
output = result.final_output
if isinstance(output, UserInfo):
return True
elif isinstance(output, ConversationalResponse):
return False
构建图并使用条件边来生成Router：
from langgraph.graph import StateGraph
graph = StateGraph(AgentState)
graph.add_node("chat_with_model", chat_with_model)
graph.add_node("final_answer", final_answer)
graph.add_node("insert_db", insert_db)
graph.set_entry_point("chat_with_model")
graph.add_conditional_edges(
"chat_with_model",
generate_branch,
{True: "insert_db", False: "final_answer"}
)
graph.set_finish_point("final_answer")
graph.set_finish_point("insert_db")
graph = graph.compile()
测试执行插入数据库的条件分支：
from langchain_core.messages import HumanMessage
query = "我叫Hygen，今年18岁，邮箱地址是ciallo@gmial.com，电话是01000721"
input_message = {"messages": [HumanMessage(content=query)]}
result = graph.invoke(input_message)
print(result)
运行结果：
{'messages': [HumanMessage(content='我叫Hygen，今年18岁，邮箱地址是ciallo@gmial.com，电话是01000721', additional_kwargs={}, response_metadata={}), FinalResponse(final_output=UserInfo(name='Hygen', age=18, email='ciallo@gmial.com', phone='01000721')), '数据已成功存储至Mysql数据库。']}
去查看本地数据库可以看到确实有新的数据插入：
而如果正常的问答，则会经过final_answer直接生成响应：
query = "你好，请你介绍一下你自己"
input_message = {"messages": [HumanMessage(content=query)]}
result = graph.invoke(input_message)
print(result)
运行结果：
{'messages': [HumanMessage(content='你好，请你介绍一下你自己', additional_kwargs={}, response_metadata={}), FinalResponse(final_output=ConversationalResponse(response='你好！我是一个AI助手，专门设计来帮助用户处理各种任务和回答问题。我可以协助您进行信息查询、文本处理、数据分析等
多种工作。如果您有任何需要帮助的地方，请随时告诉我，我会尽力为您提供支持！')), '你好！我是一个AI助手，专门设计来帮助用户处理各种任务和回答问题。我可以协助您进行信息查询、文本处理、数据分析等多种工作。如果您有任何需要帮助的地方，请随时告诉我，我会尽力为您提供支持！']}
Router Agent（路由代理）的优势就是可以精准的控制程序链路中的每一个细节，通过预定义的分支结构，可以根据用户的输入请求灵活适配不同的场景。
在这个过程中，结构化输出对于路由至关重要，因为它们确保系统可以可靠地解释大模型的决定并采取行动。
同时，这也表现出来了这是一种相对有限的控制级别的代理架构，因为大模型通常只能控制单个决策。
想象一下上面的场景中，如果我们希望定义的insert_db不仅仅只是包含插入数据库，而是有一堆各式各样的工具，比如网络搜索，RAG等等，应该如何进一步的扩展呢？难道要做对每一个工具在insert_db节点下再通过Router Function做分支判断吗？虽然可行，但总归并不是高效的做法。
由此，我们接下来进一步介绍Tool Calling Agent（工具调用代理）来高效的解决这一问题。
LangGraph使用add_conditional_edges方法实现条件路由.with_structured_output()）.with_structured_output()方法，效果最好且最稳定add_conditional_edges添加条件边通过本节的学习，需要掌握：
add_conditional_edges方法的使用注意：Router是LangGraph中实现智能路由决策的核心机制，结构化输出是Router Function实现的关键技术。掌握这些内容，是构建复杂AI Agent应用的重要基础。
]]>NLP(Normal Language Process)即常见的自然语言处理，它是目前AI最热门的领域之一，旨在让计算机能够理解、解释和生成人类语言。
用更简单的话来说，NLP就是教计算机读懂、听懂并说人话的技术。
自然语言理解：让计算机理解人类语言的含义。
自然语言生成：让计算机根据信息生成通顺的人类语言文本。
NLP技术已经深入我们生活的方方面面，例如智能语音助手、智能客服机器人、机器翻译等。
在Transformer出现之前，NLP领域的主流是基于RNN/LSTM的序列模型。它们虽然强大，但其顺序处理的天性导致了并行化能力差和长程依赖建模能力不足这两个核心瓶颈。
正是为了突破这些瓶颈，Transformer模型应运而生。 它通过自注意力机制和完全并行化的架构，一举解决了以上所有问题，成为了NLP领域真正的游戏规则改变者。
基石模型：Transformer 不仅是众多最先进NLP模型的基础架构，更是整个 “大语言模型时代”的基石。没有Transformer，就没有今天的GPT、BERT、T5等系列模型。
技术范式的革命：它通过 “自注意力机制” 完全取代了过去的RNN和CNN在序列建模中的核心地位，解决了长程依赖和并行化困难两大瓶颈。
领域的统一者：Transformer的出现，使得NLP领域几乎所有任务（翻译、摘要、问答等）都可以使用同一种核心架构来解决，只是输入输出和微调方式不同，实现了技术路线的统一。
边界的拓展者：其影响力已远超NLP，在计算机视觉、语音识别、生物信息学等领域都取得了巨大成功，成为了跨模态的通用 backbone 架构。
timeline
title Transformer 发展历程
2017 : 原始Transformer诞生<br>开创自注意力机制
2018 : GPT-1 & BERT登场<br>开启预训练-微调范式
2019-2020 : 规模竞赛开始<br>GPT-3引发范式革命
2021-2022 : 多模态与<br>ChatGPT破圈
2023至今 : 生成式AI爆发<br>AGI之路开启
2017：诞生——《Attention is All You Need》
2018：崛起——预训练模型的黎明
2019-2020： scaling law（规模扩展）与能力涌现
2021-2022： 多模态与“破圈”应用
2023至今： 生成式AI的爆发与AGI的探索
序列数据是一种按照特定顺序排列的数据，如股票价格的历史记录、WiFi毫米波信号等。序列数据有着样本与样本相关联的特点，对时间序列数据而言，每个样本代表一个时间点，样本与样本之间的关联就是时间点与时间点之间的关联。而对于文本序列而言，每个字或词的语义信息就是关联的内容，要理解一个句子的含义，就必须理解样本与样本之间的关系。
序列算法的根本诉求是要建立样本与样本之间的关联，并借助这种关联提炼出对序列数据的理解。
要理解Transformer模型的本质，首先我们要回归到序列数据、序列模型这些基本概念上来。序列数据是一种按照特定顺序排列的数据，它在现实世界中无处不在，例如股票价格的历史记录、语音信号、文本数据、视频数据等等，主要是按照某种特定顺序排列、且该顺序不能轻易被打乱的数据都被称之为是序列数据。序列数据有着“样本与样本有关联”的特点；对时间序列数据而言，每个样本就是一个时间点，因此样本与样本之间的关联就是时间点与时间点之间的关联。对文字数据而言，每个样本就是一个字/一个词，因此样本与样本之间的关联就是字与字之间、词与词之间的语义关联。很显然，要理解一个时间序列的规律、要理解一个完整的句子所表达的含义，就必须要理解样本与样本之间的关系。
对于一般表格类数据，我们一般重点研究特征与标签之间的关联，但在序列数据中，众多的本质规律与底层逻辑都隐藏在其样本与样本之间的关联中，这让序列数据无法适用于一般的机器学习与深度学习算法。这是我们要创造专门处理序列数据的算法的根本原因。在深度学习与机器学习的世界中，序列算法的根本诉求是要建立样本与样本之间的关联，并借助这种关联提炼出对序列数据的理解。唯有找出样本与样本之间的关联、建立起样本与样本之间的根本联系，序列模型才能够对序列数据实现分析、理解和预测。
在机器学习和深度学习的世界当中，存在众多经典且有效的序列模型。这些模型通过如下的方式来建立样本与样本之间的关联
过去影响未来，因此未来的值由过去的值加权求和而成，以此构建样本与样本之间的关联。
$$AR模型：y_t = c + w_1 y_{t-1} + w_2 y_{t-2} + \dots + w_p y_{t-p} + \varepsilon_t$$
遍历时间点/样本点，将过去的时间上的信息传递存储在中间变量中，传递给下一个时间点，以此构建样本和样本之间的关联。
$$RNN模型：h_t = W_{xh}\cdot x_t + W_{hh}\cdot h_{t-1}$$
$$LSTM模型：\tilde{C}t = tanh(W{xi} \cdot x_t + W_{hi} \cdot h_{t-1} + b_i)$$
使用卷积核扫描时间点/样本点，将上下文信息通过卷积计算整合到一起，以此构建样本和样本之间的关联。如下图所示，蓝绿色方框中携带权重$w$，权重与样本值对应位置元素相乘相加后生成标量，这是一个加权求和过程。
总结这些序列算法的经验，可以发现它们都是在用加权求和的方式来建立样本与样本之间的关联，因此在序列算法的发展过程中，核心问题已经由如何建立样本之间的关联转变成了如何合理对样本进行加权求和，即权重计算方式，在这个问题上，正如首次提出Transformer的论文名称——Attention is All You Need，目前最佳的权重注意力计算方式就是 注意力机制。
LangGraph的底层图算法采用消息传递机制来定义和执行图中的交互流程，其中State组件扮演着关键的载体角色，负责在图的各个节点间传递信息。
简单过一下图中的流程：
初始状态: { "x": "10" }
↓
Node 1 处理: 对 x 进行操作
↓
中间状态: { "x": "10" }, { "x": "11" }
↓
Node 2 处理: 基于 x 创建 y
↓
最终状态: { "x": "10" }, { "x": "11" }, { "y": "9" }
关键特性如下：
接下来用代码复现上图的状态设计流程
将图的状态设计为一个字典，用于在不同的节点之间共享和修改数据，然后用StateGraph实例化
from langgraph.graph import StateGraph
# 创建图，使用字典作为状态模式
builder = StateGraph(dict)
这里需要定义两个节点
addition：加法逻辑，接收当前状态并将字典中的值+1subtraction：减法逻辑，接收当前状态并将字典中的值-2# 定义节点
def addition(state):
print(state)
return {"x": state["x"] + 1}
def subtraction(state):
print(state)
return {"x": state["x"] - 2}
接下来添加节点并设置边
from langgraph.graph import START, END
# 添加节点
builder.add_node("addition", addition)
builder.add_node("subtraction", subtraction)
# 添加边
builder.add_edge(START, "addition")
builder.add_edge("addition", "subtraction")
builder.add_edge("subtraction", END)
# 编译图
graph = builder.compile()
# 定义初始状态
initial_state = {"x": 10}
# 执行图
result = graph.invoke(initial_state)
print(result)
{'x': 10}
{'x': 11}
{'x': 9}
节点函数只需要返回更新的部分：每个节点的函数内部逻辑中，需要使用和更新哪些State中的参数，只需要在return的时候指定即可，不必担心未在当前节点处理的State中的其他值会丢失。
状态隔离性：状态在任何给定时间只包含来自一个节点的更新信息。这意味着当节点处理状态时，它只能访问与其特定操作直接相关的数据。
字典类型的灵活性：使用字典作为状态模式非常简单，由于缺乏预定义的模式，节点可以在没有严格类型约束的情况下自由地读取和写入状态。
注意事项：如果在任何节点中尝试访问State中不存在的键，会直接中断整个图的运行状态。
LangGraph的内部原理是：State中每一个key都有自己独立的Reducer函数，通过指定的reducer函数应用于状态值的更新
Reducer函数用来根据当前的状态（state）和一个操作（action）来计算并返回新的状态。它是一种设计模式，用于将业务逻辑与状态变更解耦，使得状态的变更预测性更强并且容易追踪。
简单来说，Reducer就是根据给定的输入(当前状态和操作)生成新的状态。
若没有显式指定，则对该键的所有更新都执行的是覆盖操作。这也解释了为什么上面的执行结果与消息流转过程的内容不一样
接下来请看两段代码，这边把上面的dict换回TypeDict，TypeDict允许我们明确指定每个键的类型，这有助于防止在状态管理过程中出现类型错误。
from langgraph.graph import StateGraph, START, END
from typing_extensions import TypedDict
class State(TypedDict):
x: int
y: int
builder = StateGraph(State)
def addition(state):
print(state)
return {"x": state["x"] + 1}
def subtraction(state):
print(state)
return {"y": state["x"] - 2}
builder.add_node("addition", addition)
builder.add_node("subtraction", subtraction)
builder.add_edge(START, "addition")
builder.add_edge("addition", "subtraction")
builder.add_edge("subtraction", END)
graph = builder.compile()
initial_state = {"x": 10}
result = graph.invoke(initial_state)
print(result)
执行结果：
{'x': 10}
{'x': 11}
{'x': 11, 'y': 9}
当我们需要对状态进行更复杂的操作时，可以使用Annotated来指定Reducer函数：
from langgraph.graph import StateGraph, START, END
from typing_extensions import TypedDict, Annotated, List
import operator
class State(TypedDict):
# 消息列表，使用operator.add作为reducer函数， 意为在列表后面添加元素
messages: Annotated[List[str], operator.add]
def addition(state):
print(state)
msg = state['messages'][-1] # 取最新的状态
response = {"x": msg["x"] + 1}
return {"messages": [response]}
def subtraction(state):
print(state)
msg = state['messages'][-1] # 取最新的状态
response = {"x": msg["x"] - 2}
return {"messages": [response]}
builder = StateGraph(State)
builder.add_node("addition", addition)
builder.add_node("subtraction", subtraction)
builder.add_edge(START, "addition")
builder.add_edge("addition", "subtraction")
builder.add_edge("subtraction", END)
graph = builder.compile()
initial_state = {"messages": [{"x": 10}]}
result = graph.invoke(initial_state)
print(result)
执行结果：
{'messages': [{'x': 10}]}
{'messages': [{'x': 10}, {'x': 11}]}
{'messages': [{'x': 10}, {'x': 11}, {'x': 9}]}
说明：Annotated是Python的一个类型提示工具，属于typing模块。它被用来添加额外的信息或元数据到类型提示上。
当定义状态模式的结构发生了变化以后，在节点函数中的读取和存储逻辑也要发生相应的变化：
Reducers的目的：在LangGraph框架中的状态管理系统中，允许更灵活地定义状态如何根据各种操作更新。通过指定不同的reducer函数，我们可以控制状态的每个部分应如何响应特定的更新。
Reducer机制的一个现实意义是：我们可以基于这种方式去构建历史对话记录。因为目前大多数大模型应用都是接受消息列表作为输入。就像LangChain中的Chat Model，需要接收Message对象列表作为输入。
下面这个示例，我们进一步将大模型接入到LangGraph工作流程中，并允许动态消息处理以及与模型的交互：
import os
from langchain_core.messages import SystemMessage, HumanMessage
from typing_extensions import TypedDict, Annotated, List
import operator
from langgraph.graph import StateGraph
from langchain_openai import ChatOpenAI
os.environ["OPENAI_API_KEY"] = "sk-xxx" # 填入自己的api_key
llm = ChatOpenAI(
base_url="https://api.deepseek.com/v1",
model='deepseek-chat',
temperature=0
)
class State(TypedDict):
messages: Annotated[List[str], operator.add]
builder = StateGraph(State)
def chat_with_model(state):
print(state)
print("-----------------")
messages = state['messages']
response = llm.invoke(messages)
return {"messages": [response]}
def convert_messages(state):
EXTRACTION_PROMPT = """
You are a data extraction specialist tasked with retrieving key information from a text.
Extract such information for the provided text and output it in JSON format. Outline the key data points extracted.
"""
print(state)
print("-----------------")
messages = [
SystemMessage(content=EXTRACTION_PROMPT),
HumanMessage(content=state['messages'][-1].content)
]
response = llm.invoke(messages)
return {"messages": [response]}
builder.add_node("chat_with_model", chat_with_model)
builder.add_node("convert_messages", convert_messages)
builder.set_entry_point("chat_with_model")
builder.add_edge("chat_with_model", "convert_messages")
builder.set_finish_point("convert_messages")
graph = builder.compile()
query = "你好，请你详细的介绍一下你自己"
result = graph.invoke({"messages": [HumanMessage(content=query)]})
print(result)
运行结果：
{'messages': [HumanMessage(content='你好，请你详细的介绍一下你自己', additional_kwargs={}, response_metadata={})]}
-----------------
{'messages': [HumanMessage(content='你好，请你详细的介绍一下你自己', additional_kwargs={}, response_metadata={}), AIMessage(content='你好！很高兴认识你！😊\n\n让我详细介绍一下自己：\n\n## 基本信息\n我是**DeepSeek**，由深度求索公司创造的AI助手。我是目前DeepSeek的最新版本模型，专
门设计来帮助用户解决各种问题和需求。\n\n## 核心能力\n- **文本处理**：我专注于文本的生成、理解和分析，可以帮你写作、翻译、总结、分析等\n- **知识问答**：我的知识截止到2024年7月，涵盖广泛领域，可以回答各种问题\n- **逻辑推理**：我擅长逻辑分析、数学计算、编程等问题\n- **创意写作**： 可以帮助创作故事、诗歌、文案等\n\n## 特色功能\n- **文件上传**：支持上传图像、txt、pdf、ppt、word、excel等文件，我可以读取其中的文字信息进行处理\n- **长文本处理**：拥有128K的上下文长度，可以处理很长的对话和文档\n- **联网搜索**：支持联网搜索功能（需要你在Web/App中手动开启）\n\n## 使用方式\n- **完全免费**：目前没有任何收费计划，你可以放心使用\n- **多平台**：可以通过官方应用商店下载App，或在网页端使用\n- **对话风格**：我力求回应热情、细腻，希望给你带来愉快的交流体验\n\n## 我的局限\n- 我是纯文本模型，不支持多模态识别（但可以读取上传文件中的文字）\n- 没有语 音功能\n- 知识更新到2024年7月\n\n有什么具体的问题或任务需要我帮助吗？我很乐意为你提供详细的协助！✨', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 336, 'prompt_tokens': 10, 'total_tokens': 346, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cached_tokens': 0}, 'prompt_cache_hit_tokens': 0, 'prompt_cache_miss_tokens': 10}, 'model_name': 'deepseek-chat', 'system_fingerprint': 'fp_ffc7281d48_prod0820_fp8_kvcache', 'id': '1a853218-8f68-4e85-b4f5-d5dfb6a2341c', 'service_tier': None, 'finish_reason': 'stop', 'logprobs': None}, id='run--b712c9cc-90f6-4dbd-87a1-61ada1edc8d4-0', usage_metadata={'input_tokens': 10, 'output_tokens': 336, 'total_tokens': 346, 'input_token_details': {'cache_read': 0}, 'output_token_details': {}})]}
-----------------
{'messages': [HumanMessage(content='你好，请你详细的介绍一下你自己', additional_kwargs={}, response_metadata={}), AIMessage(content='你好！很高兴认识你！😊\n\n让我详细介绍一下自己：\n\n## 基本信息\n我是**DeepSeek**，由深度求索公司创造的AI助手。我是目前DeepSeek的最新版本模型，专 门设计来帮助用户解决各种问题和需求。\n\n## 核心能力\n- **文本处理**：我专注于文本的生成、理解和分析，可以帮你写作、翻译、总结、分析等\n- **知识问答**：我的知识截止到2024年7月，涵盖广泛领域，可以回答各种问题\n- **逻辑推理**：我擅长逻辑分析、数学计算、编程等问题\n- **创意写作**： 可以帮助创作故事、诗歌、文案等\n\n## 特色功能\n- **文件上传**：支持上传图像、txt、pdf、ppt、word、excel等文件，我可以读取其中的文字信息进行处理\n- **长文本处理**：拥有128K的上下文长度，可以处理很长的对话和文档\n- **联网搜索**：支持联网搜索功能（需要你在Web/App中手动开启）\n\n## 使用方式\n- **完全免费**：目前没有任何收费计划，你可以放心使用\n- **多平台**：可以通过官方应用商店下载App，或在网页端使用\n- **对话风格**：我力求回应热情、细腻，希望给你带来愉快的交流体验\n\n## 我的局限\n- 我是纯文本模型，不支持多模态识别（但可以读取上传文件中的文字）\n- 没有语 音功能\n- 知识更新到2024年7月\n\n有什么具体的问题或任务需要我帮助吗？我很乐意为你提供详细的协助！✨', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 336, 'prompt_tokens': 10, 'total_tokens': 346, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cached_tokens': 0}, 'prompt_cache_hit_tokens': 0, 'prompt_cache_miss_tokens': 10}, 'model_name': 'deepseek-chat', 'system_fingerprint': 'fp_ffc7281d48_prod0820_fp8_kvcache', 'id': '1a853218-8f68-4e85-b4f5-d5dfb6a2341c', 'service_tier': None, 'finish_reason': 'stop', 'logprobs': None}, id='run--b712c9cc-90f6-4dbd-87a1-61ada1edc8d4-0', usage_metadata={'input_tokens': 10, 'output_tokens': 336, 'total_tokens': 346, 'input_token_details': {'cache_read': 0}, 'output_token_details': {}}), AIMessage(content='{\n "name": "DeepSeek",\n "creator": "深度求索公司",\n "model_type": "AI助手",\n "version_status": "最新版本",\n "core_capabilities": [\n "文本处理（生成、理解、分析）",\n "知识问答",\n "逻辑推理",\n "创意写作"\n ],\n "special_features": [\n "文件上传（图像、txt、pdf、ppt、word、excel）",\n "长文本处理（128K上下文长度）",\n "联网搜索（需手动开启）"\n ],\n "usage_details": {\n "cost": "完全免费",\n "platforms": ["官方应用商店App", "网页端"],\n "interaction_style": "热情、细腻"\n },\n "limitations": [\n "纯文本模型 ，不支持多模态识别",\n "无语音功能",\n "知识截止日期：2024年7月"\n ]\n}\n\n**提取的关键数据点**:\n- 名称和创建者\n- 模型类型和版本状态\n- 核心能力分类\n- 特色功能列表\n- 使用方式详情（成本、平台、交互风格）\n- 已知局限性', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 256, 'prompt_tokens': 380, 'total_tokens': 636, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cached_tokens': 0}, 'prompt_cache_hit_tokens': 0, 'prompt_cache_miss_tokens': 380}, 'model_name': 'deepseek-chat', 'system_fingerprint': 'fp_ffc7281d48_prod0820_fp8_kvcache', 'id': '468b4734-91c2-4b7c-bb44-c81f83c97db2', 'service_tier': None, 'finish_reason': 'stop', 'logprobs': None}, id='run--7aaaca20-87e9-455f-8e2c-88b2766062d9-0', usage_metadata={'input_tokens': 380, 'output_tokens': 256, 'total_tokens': 636, 'input_token_details': {'cache_read': 0}, 'output_token_details': {}})]}
这个内容可以自己复制到python文件中print一下，再复制到markdown文件中渲染一下
这里需要注意的是，SystemMessage的内容是不会返回的，所以不要误以为是bug。
MessageGraph是StateGraph的一个子类，使用了Annotated[list[AnyMessage], add_messages]来初始化其基类StateGraph。
class MessageGraph(StateGraph):
def __init__(self, state_schema) -> None:
super().__init__(Annotated[List[list[AnyMessage]], add_messages])
MessageGraph中的每个节点都将消息列表作为输入，并返回零个或多个消息作为输出add_messages函数用于将每个节点的输出消息合并进图的状态中已存在的消息列表MessageGraph通过使用单个仅附加消息列表作为其整个状态来管理状态，特别适合对话式应用程序核心逻辑： add_messages整体的核心逻辑是合并两个消息列表，按ID更新现有消息。默认情况下，状态为"仅附加"，当新消息与现有消息具有相同的ID时，进行更新。
参数说明：
left(Messages) - 消息的基本列表right(Messages) - 要合并到基本列表中的消息列表(或单个消息)返回值：一个消息列表，其中的合并逻辑是：如果right的消息与left的消息具有相同的ID，则right的消息将替换left的消息，否则作为一条新的消息进行追加。
from langchain_core.messages import HumanMessage, AIMessage
from langgraph.graph.message import add_messages
msgs1 = [HumanMessage(content="你好。", id="1")]
msgs2 = [AIMessage(content="你好，很高兴认识你。", id="2")]
print(add_messages(msgs1, msgs2))
msgs1 = [HumanMessage(content="你好。", id="1")]
msgs2 = [HumanMessage(content="你好，很高兴认识你。", id="1")]
print(add_messages(msgs1, msgs2))
运行结果：
[HumanMessage(content='你好。', additional_kwargs={}, response_metadata={}, id='1'), AIMessage(content='你好，很高兴认识你。', additional_kwargs={}, response_metadata={}, id='2')]
[HumanMessage(content='你好，很高兴认识你。', additional_kwargs={}, response_metadata={}, id='1')]
从这里显然可以看出id相同会覆盖，id不同则会连接
MessageGraph：专门用于以消息为中心的工作流程StateGraph：更通用，适用于更广泛的应用程序，允许更复杂的状态结构，其中状态可以是任何Python类型（如TypedDict或Pydantic模型）import os
from typing_extensions import Annotated
from langchain_openai import ChatOpenAI
from langgraph.graph.message import add_messages
from typing_extensions import TypedDict
from langgraph.graph import StateGraph
from langchain_core.messages import HumanMessage
os.environ["OPENAI_API_KEY"] = "sk-xxx" # 使用自己的api-key
class State(TypedDict):
messages: Annotated[list, add_messages]
llm = ChatOpenAI(
base_url="https://api.deepseek.com/v1",
model="deepseek-chat",
temperature=0
)
def chatbot(state):
return {"messages": [llm.invoke(state["messages"])]}
graph_builder = StateGraph(State)
graph_builder.add_node("chatbot", chatbot)
graph_builder.set_entry_point("chatbot")
graph_builder.set_finish_point("chatbot")
graph = graph_builder.compile()
def stream_graph_updates(user_input: str):
for event in graph.stream({"messages": [HumanMessage(content=user_input)]}):
for value in event.values():
print("模型回复:", value["messages"][-1].content)
while True:
try:
user_input = input("用户提问: ")
if user_input.lower() in ["exit"]:
print("下次再见！")
break
stream_graph_updates(user_input)
except:
break
运行结果：
用户提问: 请用一句话介绍你自己
模型回复: 你好，我是DeepSeek，一个由深度求索公司创造的AI助手，热爱学习新知识，也乐于用我的能力为你提供各种帮助！😊
有什么我可以帮你的吗？
用户提问: exit
下次再见！
本博客内容主要介绍如何将大模型集成到LangGraph框架中，构建一个有应用价值的问答流程。通过学习，我们可以：
LangGraph中集成大语言模型LangGraph对目前主流的在线或开源模型均支持接入，包括：
可以通过以下方式将大模型集成到LangGraph中：
LangChain提供的接口（如ChatOpenAI）接入Ollama、vLLM等推理加速库实现高效集成参考文档：
- LangChain Chat集成：https://python.langchain.com/docs/integrations/chat/
- LangChain LLM集成：https://python.langchain.com/docs/integrations/llms/
首先需要定义图的状态模式，包括输入状态、输出状态和整体状态：
from langgraph.graph import StateGraph
from typing_extensions import TypedDict
from langgraph.graph import START, END
# 定义输入的模式
class InputState(TypedDict):
question: str
# 定义输出的模式
class OutputState(TypedDict):
answer: str
# 将 InputState 和 OutputState 这两个 TypedDict 类型合并成一个更全面的字典类型
class OverallState(InputState, OutputState):
pass
关键点说明：
InputState：定义用户输入的格式，包含question字段OutputState：定义系统输出的格式，包含answer字段OverallState：通过多重继承合并输入和输出状态，形成完整的状态定义创建一个节点函数，用于接收用户问题并调用大模型生成回答：
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
import getpass
import os
# 设置API密钥
if not os.environ.get("OPENAI_API_KEY"):
os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter your OpenAI API key: ")
def llm_node(state: InputState):
messages = [
("system", "你是一位乐于助人的智能小助理"),
("human", state["question"])
]
llm = ChatOpenAI(model="gpt-4o", temperature=0)
response = llm.invoke(messages)
return {"answer": response.content}
节点函数特点：
state: InputState作为第一个位置参数ChatOpenAI调用GPT-4o模型answer字段的字典，更新图状态将节点添加到图中，并建立节点间的连接关系：
# 明确指定它的输入和输出数据的结构或模式
builder = StateGraph(OverallState, input=InputState, output=OutputState)
# 添加节点
builder.add_node("llm_node", llm_node)
# 添加边
builder.add_edge(START, "llm_node")
builder.add_edge("llm_node", END)
# 编译图
graph = builder.compile()
图结构说明：
StateGraph初始化时指定了状态模式、输入模式和输出模式add_node方法添加节点，第一个参数是节点名称，第二个参数是节点函数add_edge方法添加边，连接START → llm_node → ENDcompile方法编译图，验证图结构的合法性使用invoke方法调用图，传入用户问题：
# 基础测试
result = graph.invoke({"question": "你好，我用来测试"})
print(result["answer"])
# 详细问题测试
result = graph.invoke({"question": "你好，请你详细的介绍一下你自己"})
print(result["answer"])
执行流程：
START节点进入图llm_node节点接收问题，调用大模型生成回答END节点返回给用户为了支持多节点间的数据传递，需要扩展状态定义：
from typing_extensions import TypedDict, Optional
# 定义输入的模式
class InputState(TypedDict):
question: str
llm_answer: Optional[str] # 表示 llm_answer 可以是 str 类型，也可以是 None
# 定义输出的模式
class OutputState(TypedDict):
answer: str
# 将 InputState 和 OutputState 这两个 TypedDict 类型合并成一个更全面的字典类型
class OverallState(InputState, OutputState):
pass
关键变化：
llm_answer字段，用于存储中间节点的输出结果Optional[str]表示该字段可以为None，提供灵活性定义两个节点：一个用于生成回答，另一个用于翻译：
def llm_node(state: InputState):
messages = [
("system", "你是一位乐于助人的智能小助理"),
("human", state["question"])
]
llm = ChatOpenAI(model="gpt-4o", temperature=0)
response = llm.invoke(messages)
return {"llm_answer": response.content}
def action_node(state: InputState):
messages = [
("system", "无论你接收到什么语言的文本，请翻译成法语"),
("human", state["llm_answer"])
]
llm = ChatOpenAI(model="gpt-4o", temperature=0)
response = llm.invoke(messages)
return {"answer": response.content}
节点功能说明：
llm_node：接收用户问题，生成中文回答，并将结果存储在llm_answer字段action_node：接收llm_answer，将其翻译成法语，并将结果存储在answer字段将两个节点添加到图中，并建立连接：
# 明确指定它的输入和输出数据的结构或模式
builder = StateGraph(OverallState, input=InputState, output=OutputState)
# 添加节点
builder.add_node("llm_node", llm_node)
builder.add_node("action_node", action_node)
# 添加边
builder.add_edge(START, "llm_node")
builder.add_edge("llm_node", "action_node")
builder.add_edge("action_node", END)
# 编译图
graph = builder.compile()
图结构流程：
START → llm_node → action_node → END
执行流程：
START进入llm_nodellm_node生成中文回答，更新llm_answer字段action_node读取llm_answer，翻译成法语，更新answer字段END返回# 测试自我介绍翻译
result = graph.invoke({"question": "你好，请你详细的介绍一下你自己"})
print(result["answer"])
# 测试知识问答翻译
result = graph.invoke({"question": "请问什么是人工智能？"})
print(result["answer"])
from langgraph.graph import StateGraph
from typing_extensions import TypedDict
from langgraph.graph import START, END
# 1. 创建图模式
# 为什么参数是TypedDict？
# TypedDict是Python中的一个类型，用于定义字典的类型。
# 它可以帮助我们定义字典的键和值的类型，从而避免在运行时出现类型错误。
class InputState(TypedDict):
question: str
class OutputState(TypedDict):
answer: str
# pass 和 ... 的区别
# pass 是一个占位符，表示什么也不做。
# ... 表示一个空字典。
class OverallState(InputState, OutputState):
pass
# 2. 创建节点函数
# 获取api key
import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import SystemMessage, HumanMessage
# 设置api key，这边直接配置了key，要科学保密可以使用dotenv来进行配置
os.environ["OPENAI_API_KEY"] = "sk-xxx" # 填自己的api-key
def llm_node(state: OverallState) -> OverallState:
messages = [
SystemMessage(content="你是一位乐于助人的智能小助理"),
HumanMessage(content=state["question"])
]
llm = ChatOpenAI(
model="deepseek-chat",
temperature=0,
base_url="https://api.deepseek.com/v1"
)
response = llm.invoke(messages)
return {"answer": response.content}
# 3. 创建图结构
builder = StateGraph(OverallState, input_schema=InputState, output_schema=OutputState)
builder.add_node("llm_node", llm_node)
builder.add_edge(START, "llm_node")
builder.add_edge("llm_node", END)
# 4. 编译图
graph = builder.compile()
# 5. 执行图
result = graph.invoke({"question": "你好，我用来测试"})
print(result["answer"])
运行截图：
import os
from typing import Optional
from typing_extensions import TypedDict
from langchain_openai import ChatOpenAI
from langchain_core.messages import SystemMessage, HumanMessage
from langgraph.graph import StateGraph, START, END
class InputState(TypedDict):
question: str
llm_answer: Optional[str]
class OutputState(TypedDict):
answer: str
class OverallState(InputState, OutputState):
pass
os.environ["OPENAI_API_KEY"] = "sk-xxx" # 修改为自己的api-key
def llm_node(state: OverallState) -> OverallState:
messages = [
SystemMessage(content="你是一位乐于助人的智能小助理"),
HumanMessage(content=state["question"])
]
llm = ChatOpenAI(
model="deepseek-chat",
temperature=0,
base_url="https://api.deepseek.com/v1"
)
response = llm.invoke(messages)
return {"llm_answer": response.content}
def action_node(state: OverallState) -> OverallState:
messages = [
SystemMessage(content="请将你接收到的文本翻译为用英文"),
HumanMessage(content=state["llm_answer"])
]
llm = ChatOpenAI(
model="deepseek-chat",
temperature=0,
base_url="https://api.deepseek.com/v1"
)
response = llm.invoke(messages)
return {"answer": response.content}
builder = StateGraph(OverallState, input_schema=InputState, output_schema=OutputState)
builder.add_node("llm_node", llm_node)
builder.add_node("action_node", action_node)
builder.add_edge(START, "llm_node")
builder.add_edge("llm_node", "action_node")
builder.add_edge("action_node", END)
graph = builder.compile()
result = graph.invoke({"question": "你好，请你详细的介绍一下你自己"})
print(result["answer"])
运行截图：
节点函数自主性：
LangChain框架状态管理：
TypedDict确保类型安全图结构扩展性：
LangGraph基于LangChain的表达式语言构建LangChain，但完全可以脱离LangChain独立运行LangChain接口，也可以使用原生APITypedDict的作用和状态传递机制通过本节的学习，需要掌握：
LangGraph中定义图的状态模式掌握了基础的问答流程构建后，可以进一步学习：
注意：本节示例虽然不复杂，但涉及的知识点和细节较多。建议亲自尝试和体验，打好扎实的基础，才能更好地开展后续复杂循环图的学习。
]]>给定一个经过编码的字符串，返回它的解码字符串。
编码规则为：k[encoded_string]，表示方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。
k。例如，不会出现像 3a 或 2[4] 这样的输入。10^5。输入： s = "3[a]2[bc]"
输出： "aaabcbc"
解释： 3[a] 解码为 aaa。2[bc] 解码为 bcbc。将它们连接起来得到 aaabcbc。
输入： s = "3[a2[c]]"
输出： "accaccacc"
解释： 这个例子展示了嵌套编码。首先，内层括号中的 2[c] 解码为 cc。所以 a2[c] 变成 acc。然后，3[acc] 解码为 accaccacc。
输入： s = "2[abc]3[cd]ef"
输出： "abcabccdcdcdef"
解释： 2[abc] 解码为 abcabc。3[cd] 解码为 cdcdcd。ef 保持不变。将这些部分连接起来得到 abcabccdcdcdef。
输入： s = "abc3[cd]xyz"
输出： "abccdcdcdxyz"
解释： abc 保持不变。3[cd] 解码为 cdcdcd。xyz 保持不变。将这些部分连接起来得到 abccdcdcdxyz。
1 <= s.length <= 30s 由小写英文字母、数字（0-9）和方括号 '[' 和 ']' 组成s 保证是一个有效的输入s 中所有整数的取值范围为 [1, 300]根据提示中的内容，可以知道我们接收到的输入只有四种情况：
[]这是一个典型的栈应用问题。由于编码字符串可能包含嵌套结构（如示例 2 中的 3[a2[c]]），我们需要使用栈来保存外层的信息，以便在处理完内层后能够正确恢复。
使用栈存储上下文：栈中存储 (重复次数, 前缀字符串) 的元组，用于保存遇到 [ 之前的状态。
遍历字符串，根据不同字符类型进行处理：
[...] 的重复次数。[：遇到 [ 时，说明即将开始一个新的编码块。此时将当前的重复次数和已构建的字符串压入栈中保存，然后重置当前状态（重复次数设为 0，字符串清空），准备处理内层内容。]：遇到 ] 时，说明当前编码块结束。从栈中弹出之前保存的状态 (pre_num, pre_str)，将当前字符串重复 pre_num 次，然后拼接到 pre_str 后面，作为新的当前字符串。返回结果：遍历完成后，当前字符串即为解码后的结果。
以 "3[a2[c]]" 为例，演示算法执行过程：
3：cur_num = 3[：将 (3, "") 压入栈，重置 cur_num = 0, cur_str = []a：cur_str = ['a']2：cur_num = 2[：将 (2, "a") 压入栈，重置 cur_num = 0, cur_str = []c：cur_str = ['c']]：弹出 (2, "a")，cur_str = ["a" + 2 * "c"] = ["acc"]]：弹出 (3, "")，cur_str = ["" + 3 * "acc"] = ["accaccacc"]"accaccacc"class Solution:
def decodeString(self, s: str) -> str:
stk: List[Tuple[int, str]] = []
cur_num = 0
cur_str = []
i = 0
while i < len(s):
c = s[i]
if c.isdigit():
res = ''
while s[i].isdigit():
res += s[i]
i += 1
cur_num = int(res)
i -= 1
elif c == '[':
stk.append((cur_num, ''.join(cur_str)))
cur_num = 0
cur_str = []
elif c == ']':
pre_num, pre_str = stk.pop()
cur_str = [pre_str + pre_num * ''.join(cur_str)]
else:
cur_str.append(c)
i += 1
return ''.join(cur_str)
给定三个正整数 n、m、h（均小于 100），构造如下数据并计算结果。
数据构造规则：
输出要求： 求矩阵 Y 所有元素的和，四舍五入到整数后输出
时间限制： C/C++ 1秒，其他语言 2秒
空间限制： C/C++ 256M，其他语言 512M
输入描述：
输出描述：
示例1
输入例子：5 4 3
输出例子：30
例子说明：h≤m，单行和为 1+2+3=6；总和=n×6=5×6=30
本题是一个模拟题，它有数学推理后$O(1)$的解法，但是在此不多做讨论，我们主要讨论$O(nm)$的解法。，也就是模拟的做法
其实题目已经将要做什么告诉我们了，我们只需要按照题目的要求一步一步来即可，直接看代码实现即可
import numpy as np
# 输入n, m, h
n, m, h = map(int, input().split())
# 构造X
X = np.ones((n, m))
# 构造W
W = np.triu(np.ones((m, h)))
Q = X @ W
K = X @ W
V = X @ W
S = (Q @ K.T) / np.sqrt(h)
row_sums = S.sum(axis=1, keepdims=True)
softmax_S = S / row_sums
Y = softmax_S @ V
print(int(round(np.sum(Y))))
语法知识补充：
np.ones((n, m))：生成一个 n×m 的全 1 矩阵np.triu(np.ones((m, h)))：生成一个 m×h 的上三角全 1 矩阵@：矩阵乘法运算符np.sqrt(h)：计算 h 的平方根np.sum(S, axis=1, keepdims=True)：计算 S 按行求和，并保持维度np.round(Y)：四舍五入 Y 的每个元素官方文档：点此跳转
正如数据结构中的链表和图的关系，传统的AI工作流为链式调用，这就好比一个链表，它很直观易懂，但是局限性太强，如果想要基于某个条件选择不同的Agent进行工作，链式工作流就捉襟见肘了，如果当我在某处触发某个条件需要回溯到先前的节点，链式工作流更是无法实现。
而LangGraph提供了一种图结构，将各个节点以图的形式组织起来，从而实现更灵活的调用方式。
与图类似的，LangGraph也有节点(Node)和边(Edge)两个概念，节点不一定是Agent，也可以是任意对象，如LLM、工作流、以及可运行的如函数等，边则表示两个节点组成了一个工作流，注意边是有向边，即有明确的调用顺序。
与图不同的是，LangGraph还有几个新概念，Action和Router,严格来说，Action和Router都是节点，但是它们有特殊的含义，Action表示一个可运行的函数，Router表示一个选择器，它根据某些条件选择下一个节点。
简单来说，Action表示的是一个节点的业务逻辑，Router则是一个特殊的节点，它包含的是路由逻辑而非业务逻辑，用炒菜来举个例子，假设我们有一个炒菜的Agent，它需要调用不同的工具和食材，那么这些工具和食材就是节点，而炒菜的过程就是边，而Action就是具体的炒菜步骤，Router就是选择食材和工具的步骤。
在LangGraph框架中，Router使用if...else的形式来决定路径，主要通过以下三种方式实现：
在此我使用uv来进行python的包管理。
uv init test
cd test
uv add langgraph
如果是pip，运行pip install langgraph即可
💡 通俗理解：这个文件就像是 LangGraph 的"大脑"，它定义了如何构建和执行一个工作流图。想象一下，你有一个复杂的任务需要多个步骤完成，每个步骤（节点）都需要从共享的"工作台"（状态）上读取信息，处理完后把结果放回工作台。这个文件就是定义这个工作台和工作流程的规则。
from __future__ import annotations
# 启用延迟类型注解评估，允许在类型提示中使用前向引用
import inspect
# 用于检查函数签名和参数信息
import logging
# 用于日志记录
import typing
# 用于类型检查和类型操作
import warnings
# 用于发出警告信息
from collections import defaultdict
# 提供默认值字典，用于自动创建缺失的键
from collections.abc import Awaitable, Hashable, Sequence
# 抽象基类：Awaitable(可等待对象)、Hashable(可哈希对象)、Sequence(序列)
from functools import partial
# 用于创建偏函数（部分应用函数）
from inspect import isclass, isfunction, ismethod, signature
# isclass: 检查是否为类
# isfunction: 检查是否为函数
# ismethod: 检查是否为方法
# signature: 获取函数签名
from types import FunctionType
# 函数类型
from typing import (
Any, # 任意类型
Callable, # 可调用对象类型
Generic, # 泛型基类
Literal, # 字面量类型
NamedTuple, # 命名元组
Protocol, # 协议类型（结构子类型）
Union, # 联合类型
cast, # 类型转换函数
get_args, # 获取泛型参数
get_origin, # 获取泛型原始类型
get_type_hints, # 获取类型提示
overload, # 函数重载装饰器
)
from langchain_core.runnables import Runnable, RunnableConfig
# Runnable: 可运行对象接口
# RunnableConfig: 运行配置对象
from pydantic import BaseModel, TypeAdapter
# BaseModel: Pydantic 基础模型类
# TypeAdapter: 类型适配器，用于类型转换和验证
from typing_extensions import Self, TypeAlias, Unpack, is_typeddict
# Self: 表示当前类自身的类型
# TypeAlias: 类型别名
# Unpack: 解包操作符
# is_typeddict: 检查是否为 TypedDict
from langgraph._typing import UNSET, DeprecatedKwargs
# UNSET: 未设置值的标记
# DeprecatedKwargs: 已弃用的关键字参数类型
from langgraph.cache.base import BaseCache
# 缓存基类
from langgraph.channels.base import BaseChannel
# 通道基类，用于节点间通信
# 💡 通俗理解：通道就像是一个"共享邮箱"，节点可以把数据放进去，其他节点可以从里面读取。每个状态字段都有自己的"邮箱"（通道）。
from langgraph.channels.binop import BinaryOperatorAggregate
# 二元操作符聚合通道
from langgraph.channels.ephemeral_value import EphemeralValue
# 临时值通道
from langgraph.channels.last_value import LastValue, LastValueAfterFinish
# LastValue: 最后值通道
# LastValueAfterFinish: 完成后最后值通道
# 💡 通俗理解：LastValue 就像是一个"黑板"，每次写入都会覆盖之前的内容，只保留最新的值。LastValueAfterFinish 则是等所有节点都完成后才更新。
from langgraph.channels.named_barrier_value import (
NamedBarrierValue,
NamedBarrierValueAfterFinish,
)
# NamedBarrierValue: 命名屏障值通道（用于等待多个节点完成）
# NamedBarrierValueAfterFinish: 完成后命名屏障值通道
# 💡 通俗理解：这就像是一个"集合点"，多个节点必须都到达这里，才能继续执行下一个节点。就像团队开会，必须所有人都到齐才能开始。
from langgraph.checkpoint.base import Checkpoint
# 检查点基类，用于保存和恢复图执行状态
# 💡 通俗理解：检查点就像游戏存档，可以保存当前进度，如果出错了可以回到之前的状态继续执行，不用从头开始。
from langgraph.constants import (
EMPTY_SEQ, # 空序列常量
END, # 结束节点标识
INTERRUPT, # 中断标识
MISSING, # 缺失值标识
NS_END, # 命名空间结束符
NS_SEP, # 命名空间分隔符
START, # 开始节点标识
TAG_HIDDEN, # 隐藏标签
TASKS, # 任务标识
)
from langgraph.errors import (
ErrorCode, # 错误代码
InvalidUpdateError, # 无效更新错误
ParentCommand, # 父命令异常
create_error_message, # 创建错误消息
)
from langgraph.graph.branch import Branch
# 分支类，用于条件边
from langgraph.managed.base import (
ManagedValueSpec, # 托管值规范
is_managed_value, # 检查是否为托管值
)
from langgraph.pregel import Pregel
# Pregel 图执行引擎基类
# 💡 通俗理解：Pregel 是 Google 提出的图计算模型，LangGraph 用它来实际执行图。就像是一个"调度器"，负责决定哪个节点什么时候执行，如何传递数据。
from langgraph.pregel.read import ChannelRead, PregelNode
# ChannelRead: 通道读取器
# PregelNode: Pregel 节点
from langgraph.pregel.write import (
ChannelWrite, # 通道写入器
ChannelWriteEntry, # 通道写入条目
ChannelWriteTupleEntry, # 通道写入元组条目
)
from langgraph.store.base import BaseStore
# 存储基类
from langgraph.types import (
All, # 全部标识
CachePolicy, # 缓存策略
Checkpointer, # 检查点器
Command, # 命令类型
RetryPolicy, # 重试策略
Send, # 发送操作
StreamWriter, # 流写入器
)
from langgraph.typing import InputT, OutputT, StateT, StateT_contra
# InputT: 输入类型变量
# OutputT: 输出类型变量
# StateT: 状态类型变量
# StateT_contra: 状态类型逆变变量
from langgraph.utils.fields import (
get_cached_annotated_keys, # 获取缓存的注解键
get_field_default, # 获取字段默认值
get_update_as_tuples, # 获取更新元组
)
from langgraph.utils.pydantic import create_model
# 创建 Pydantic 模型
from langgraph.utils.runnable import coerce_to_runnable
# 强制转换为可运行对象
from langgraph.warnings import LangGraphDeprecatedSinceV05
# LangGraph 弃用警告
logger = logging.getLogger(__name__)
# 创建日志记录器
_warn_invalid_state_schemadef _warn_invalid_state_schema(schema: type[Any] | Any) -> None:
"""
警告无效的状态模式。
如果模式不是类型，且没有泛型参数，则发出警告。
这有助于用户发现状态模式定义错误。
"""
if isinstance(schema, type):
# 如果是类型，直接返回（有效）
return
if typing.get_args(schema):
# 如果有泛型参数（如 Annotated），也认为是有效的
return
# 否则发出警告
warnings.warn(
f"Invalid state_schema: {schema}. Expected a type or Annotated[type, reducer]. "
"Please provide a valid schema to ensure correct updates.\n"
" See: https://langchain-ai.github.io/langgraph/reference/graphs/#stategraph"
)
这些协议定义了节点函数的不同签名变体，支持不同的参数组合：
💡 通俗理解：协议就像是一份"合同"，规定了节点函数可以有哪些不同的"签名"（参数组合）。有些节点只需要状态，有些还需要配置、写入器或存储。就像不同的工作岗位有不同的职责要求一样。
_StateNodeclass _StateNode(Protocol[StateT_contra]):
"""最基本的节点协议：只接受状态参数"""
def __call__(self, state: StateT_contra) -> Any: ...
_NodeWithConfigclass _NodeWithConfig(Protocol[StateT_contra]):
"""带配置的节点协议：接受状态和配置参数"""
def __call__(self, state: StateT_contra, config: RunnableConfig) -> Any: ...
_NodeWithWriterclass _NodeWithWriter(Protocol[StateT_contra]):
"""带写入器的节点协议：接受状态和流写入器"""
def __call__(self, state: StateT_contra, *, writer: StreamWriter) -> Any: ...
_NodeWithStoreclass _NodeWithStore(Protocol[StateT_contra]):
"""带存储的节点协议：接受状态和存储对象"""
def __call__(self, state: StateT_contra, *, store: BaseStore) -> Any: ...
_NodeWithWriterStoreclass _NodeWithWriterStore(Protocol[StateT_contra]):
"""带写入器和存储的节点协议"""
def __call__(
self, state: StateT_contra, *, writer: StreamWriter, store: BaseStore
) -> Any: ...
_NodeWithConfigWriterclass _NodeWithConfigWriter(Protocol[StateT_contra]):
"""带配置和写入器的节点协议"""
def __call__(
self, state: StateT_contra, *, config: RunnableConfig, writer: StreamWriter
) -> Any: ...
_NodeWithConfigStoreclass _NodeWithConfigStore(Protocol[StateT_contra]):
"""带配置和存储的节点协议"""
def __call__(
self, state: StateT_contra, *, config: RunnableConfig, store: BaseStore
) -> Any: ...
_NodeWithConfigWriterStoreclass _NodeWithConfigWriterStore(Protocol[StateT_contra]):
"""带配置、写入器和存储的节点协议（最完整的签名）"""
def __call__(
self,
state: StateT_contra,
*,
config: RunnableConfig,
writer: StreamWriter,
store: BaseStore,
) -> Any: ...
StateNode 类型别名StateNode: TypeAlias = Union[
_StateNode[StateT_contra], # 基础节点
_NodeWithConfig[StateT_contra], # 带配置
_NodeWithWriter[StateT_contra], # 带写入器
_NodeWithStore[StateT_contra], # 带存储
_NodeWithWriterStore[StateT_contra], # 带写入器和存储
_NodeWithConfigWriter[StateT_contra], # 带配置和写入器
_NodeWithConfigStore[StateT_contra], # 带配置和存储
_NodeWithConfigWriterStore[StateT_contra], # 带所有参数
Runnable[StateT_contra, Any], # 可运行对象
]
说明：StateNode 是所有支持的节点类型的联合类型，允许节点函数有不同的签名。
💡 通俗理解：
StateNode就像是一个"万能接口"，不管你写节点函数时用了哪些参数（只要符合其中一种协议），都可以被 LangGraph 识别和使用。这给了开发者很大的灵活性。
_get_node_name 函数def _get_node_name(node: StateNode) -> str:
"""
获取节点名称。
尝试从节点的 __name__ 属性获取，如果没有则使用类名。
如果都获取不到，抛出类型错误。
"""
try:
return getattr(node, "__name__", node.__class__.__name__)
except AttributeError:
raise TypeError(f"Unsupported node type: {type(node)}")
💡 通俗理解：
StateNodeSpec就像是节点的"身份证"，记录了节点的所有信息：它是什么（runnable）、需要什么输入（input）、失败后怎么办（retry_policy）、结果可以缓存吗（cache_policy）、执行完后可以去哪里（ends）等等。
class StateNodeSpec(NamedTuple):
"""
节点规范，存储节点的所有配置信息。
字段说明：
- runnable: 节点可运行对象（函数或 Runnable）
- metadata: 节点元数据字典（可选）
- input: 节点输入模式类型
- retry_policy: 重试策略（可选，可以是单个策略或策略序列）
- cache_policy: 缓存策略（可选）
- ends: 节点可以路由到的目标节点（可选）
可以是元组（节点名列表）或字典（节点名到标签的映射）
- defer: 是否延迟执行（直到运行即将结束时才执行）
"""
runnable: StateNode
metadata: dict[str, Any] | None
input: type[Any]
retry_policy: RetryPolicy | Sequence[RetryPolicy] | None
cache_policy: CachePolicy | None
ends: tuple[str, ...] | dict[str, str] | None = EMPTY_SEQ
defer: bool = False
StateGraph 是 LangGraph 的核心类，用于构建基于状态的有向图。
💡 通俗理解：
StateGraph就像是一个"建筑图纸"，你用它来设计工作流程。你可以添加节点（工作步骤）、连接边（执行顺序）、设置条件分支（根据情况选择路径）。设计完成后，调用compile()方法把它"建造"成可以实际运行的图。
edges: set[tuple[str, str]]
# 边的集合，每个边是 (起始节点, 结束节点) 的元组
nodes: dict[str, StateNodeSpec]
# 节点字典，键是节点名，值是节点规范
branches: defaultdict[str, dict[str, Branch]]
# 分支字典，键是源节点名，值是条件名到分支对象的映射
channels: dict[str, BaseChannel]
# 通道字典，键是状态键名，值是通道对象
# 💡 通俗理解：每个状态字段都有自己的"通道"（邮箱），节点通过通道读写数据
managed: dict[str, ManagedValueSpec]
# 托管值字典，键是状态键名，值是托管值规范
schemas: dict[type[Any], dict[str, BaseChannel | ManagedValueSpec]]
# 模式字典，键是模式类型，值是键到通道或托管值的映射
waiting_edges: set[tuple[tuple[str, ...], str]]
# 等待边集合，用于多源节点到单目标节点的边
# 💡 通俗理解：就像"等所有人到齐再出发"，多个节点必须都完成，才能执行下一个节点
compiled: bool
# 是否已编译的标志
state_schema: type[StateT]
# 状态模式类型
input_schema: type[InputT]
# 输入模式类型
output_schema: type[OutputT]
# 输出模式类型
__init__ 方法def __init__(
self,
state_schema: type[StateT], # 状态模式（必需）
config_schema: type[Any] | None = None, # 配置模式（可选）
*,
input_schema: type[InputT] | None = None, # 输入模式（可选）
output_schema: type[OutputT] | None = None, # 输出模式（可选）
**kwargs: Unpack[DeprecatedKwargs], # 已弃用的关键字参数
) -> None:
"""
初始化状态图。
处理已弃用的参数（input/output），然后初始化所有数据结构。
最后添加状态、输入和输出模式。
"""
> 💡 **通俗理解**：初始化就像准备一个空的工作台，设置好工作台的规格（状态模式），准备好各种"邮箱"（通道）。之后你就可以往上面添加工作步骤（节点）了。
# 处理已弃用的 input 参数
if (input_ := kwargs.get("input", UNSET)) is not UNSET:
warnings.warn(
"`input` is deprecated and will be removed. Please use `input_schema` instead.",
category=LangGraphDeprecatedSinceV05,
stacklevel=2,
)
if input_schema is None:
input_schema = cast(Union[type[InputT], None], input_)
# 处理已弃用的 output 参数
if (output := kwargs.get("output", UNSET)) is not UNSET:
warnings.warn(
"`output` is deprecated and will be removed. Please use `output_schema` instead.",
category=LangGraphDeprecatedSinceV05,
stacklevel=2,
)
if output_schema is None:
output_schema = cast(Union[type[OutputT], None], output)
# 初始化数据结构
self.nodes = {}
self.edges = set()
self.branches = defaultdict(dict)
self.schemas = {}
self.channels = {}
self.managed = {}
self.compiled = False
self.waiting_edges = set()
# 设置模式
self.state_schema = state_schema
self.input_schema = cast(type[InputT], input_schema or state_schema)
self.output_schema = cast(type[OutputT], output_schema or state_schema)
self.config_schema = config_schema
# 添加模式（这会解析模式并创建通道）
self._add_schema(self.state_schema)
self._add_schema(self.input_schema, allow_managed=False)
self._add_schema(self.output_schema, allow_managed=False)
_all_edges 属性@property
def _all_edges(self) -> set[tuple[str, str]]:
"""
获取所有边的集合（包括普通边和等待边）。
等待边会被展开为多个普通边。
"""
return self.edges | {
(start, end) for starts, end in self.waiting_edges for start in starts
}
_add_schema 方法def _add_schema(self, schema: type[Any], /, allow_managed: bool = True) -> None:
"""
添加模式到图中。
解析模式中的字段，创建相应的通道和托管值。
如果模式已存在，则跳过。
参数：
- schema: 要添加的模式类型
- allow_managed: 是否允许托管值（输入/输出模式不允许）
"""
> 💡 **通俗理解**：模式就像是一个"表格模板"，定义了状态有哪些字段、每个字段是什么类型。这个方法会为每个字段创建一个"邮箱"（通道），节点可以通过这些邮箱传递数据。`allow_managed=False` 的意思是：输入/输出模式不允许使用"托管值"（一种特殊的通道类型，由系统自动管理）。
if schema not in self.schemas:
# 警告无效的模式
_warn_invalid_state_schema(schema)
# 获取通道、托管值和类型提示
channels, managed, type_hints = _get_channels(schema)
# 检查托管值是否允许
if managed and not allow_managed:
names = ", ".join(managed)
schema_name = getattr(schema, "__name__", "")
raise ValueError(
f"Invalid managed channels detected in {schema_name}: {names}."
" Managed channels are not permitted in Input/Output schema."
)
# 保存模式信息
self.schemas[schema] = {**channels, **managed}
# 添加通道
for key, channel in channels.items():
if key in self.channels:
if self.channels[key] != channel:
# 如果通道类型不同，且不是 LastValue，则报错
if isinstance(channel, LastValue):
pass # LastValue 可以兼容
else:
raise ValueError(
f"Channel '{key}' already exists with a different type"
)
else:
self.channels[key] = channel
# 添加托管值
for key, managed in managed.items():
if key in self.managed:
if self.managed[key] != managed:
raise ValueError(
f"Managed value '{key}' already exists with a different type"
)
else:
self.managed[key] = managed
add_node 方法add_node 方法有两个重载版本和一个实现版本：
@overload
def add_node(
self,
node: StateNode[StateT], # 节点函数或可运行对象
*,
defer: bool = False,
metadata: dict[str, Any] | None = None,
input_schema: type[Any] | None = None,
retry_policy: RetryPolicy | Sequence[RetryPolicy] | None = None,
cache_policy: CachePolicy | None = None,
destinations: dict[str, str] | tuple[str, ...] | None = None,
**kwargs: Unpack[DeprecatedKwargs],
) -> Self:
"""添加节点，节点名从函数/可运行对象名称推断"""
...
@overload
def add_node(
self,
node: str, # 节点名称
action: StateNode[StateT], # 节点函数或可运行对象
*,
defer: bool = False,
metadata: dict[str, Any] | None = None,
input_schema: type[Any] | None = None,
retry_policy: RetryPolicy | Sequence[RetryPolicy] | None = None,
cache_policy: CachePolicy | None = None,
destinations: dict[str, str] | tuple[str, ...] | None = None,
**kwargs: Unpack[DeprecatedKwargs],
) -> Self:
"""添加节点，显式指定节点名"""
...
def add_node(
self,
node: str | StateNode[StateT],
action: StateNode[StateT] | None = None,
*,
defer: bool = False,
metadata: dict[str, Any] | None = None,
input_schema: type[Any] | None = None,
retry_policy: RetryPolicy | Sequence[RetryPolicy] | None = None,
cache_policy: CachePolicy | None = None,
destinations: dict[str, str] | tuple[str, ...] | None = None,
**kwargs: Unpack[DeprecatedKwargs],
) -> Self:
"""
添加节点到图中。
主要步骤：
1. 处理已弃用的参数
2. 确定节点名称和动作
3. 验证节点名称
4. 推断输入模式和目标节点（从类型提示）
5. 创建节点规范并添加到图中
"""
> 💡 **通俗理解**：添加节点就像是在工作流程中添加一个工作步骤。这个方法会：
> - 检查节点名是否合法（不能是保留字，不能重复）
> - 自动识别节点函数的类型提示，推断它需要什么输入、可以输出到哪里
> - 创建一个"身份证"（StateNodeSpec）记录这个节点的所有信息
> - 把节点添加到图中
# 处理已弃用的 retry 参数
if (retry := kwargs.get("retry", UNSET)) is not UNSET:
warnings.warn(
"`retry` is deprecated and will be removed. Please use `retry_policy` instead.",
category=LangGraphDeprecatedSinceV05,
)
if retry_policy is None:
retry_policy = retry
# 处理已弃用的 input 参数
if (input_ := kwargs.get("input", UNSET)) is not UNSET:
warnings.warn(
"`input` is deprecated and will be removed. Please use `input_schema` instead.",
category=LangGraphDeprecatedSinceV05,
)
if input_schema is None:
input_schema = cast(Union[type[InputT], None], input_)
# 确定节点名称和动作
if not isinstance(node, str):
action = node
if isinstance(action, Runnable):
node = action.get_name()
else:
node = getattr(action, "__name__", action.__class__.__name__)
if node is None:
raise ValueError(
"Node name must be provided if action is not a function"
)
# 如果图已编译，发出警告
if self.compiled:
logger.warning(
"Adding a node to a graph that has already been compiled. This will "
"not be reflected in the compiled graph."
)
# 再次检查节点名称（处理边界情况）
if not isinstance(node, str):
action = node
node = cast(str, getattr(action, "name", getattr(action, "__name__", None)))
if node is None:
raise ValueError(
"Node name must be provided if action is not a function"
)
# 验证动作存在
if action is None:
raise RuntimeError
# 验证节点名唯一性
if node in self.nodes:
raise ValueError(f"Node `{node}` already present.")
# 验证节点名不是保留字
if node == END or node == START:
raise ValueError(f"Node `{node}` is reserved.")
# 验证节点名不包含保留字符
for character in (NS_SEP, NS_END):
if character in node:
raise ValueError(
f"'{character}' is a reserved character and is not allowed in the node names."
)
# 尝试从类型提示推断目标节点
ends: tuple[str, ...] | dict[str, str] = EMPTY_SEQ
try:
if (
isfunction(action)
or ismethod(action)
or ismethod(getattr(action, "__call__", None))
) and (
hints := get_type_hints(getattr(action, "__call__"))
or get_type_hints(action)
):
# 推断输入模式
if input_schema is None:
first_parameter_name = next(
iter(
inspect.signature(
cast(FunctionType, action)
).parameters.keys()
)
)
if input_hint := hints.get(first_parameter_name):
if isinstance(input_hint, type) and get_type_hints(input_hint):
input_schema = input_hint
# 推断返回类型中的目标节点
if rtn := hints.get("return"):
# 处理 Union 类型
rtn_origin = get_origin(rtn)
if rtn_origin is Union:
rtn_args = get_args(rtn)
# 查找 Command 类型
for arg in rtn_args:
arg_origin = get_origin(arg)
if arg_origin is Command:
rtn = arg
rtn_origin = arg_origin
break
# 检查是否为 Command 类型
if (
rtn_origin is Command
and (rargs := get_args(rtn))
and get_origin(rargs[0]) is Literal
and (vals := get_args(rargs[0]))
):
ends = vals
except (NameError, TypeError, StopIteration):
pass
# 如果提供了 destinations，使用它
if destinations is not None:
ends = destinations
# 添加输入模式（如果指定）
if input_schema is not None:
self._add_schema(input_schema)
# 创建节点规范并添加到图中
self.nodes[node] = StateNodeSpec(
coerce_to_runnable(action, name=node, trace=False),
metadata,
input=input_schema or self.state_schema,
retry_policy=retry_policy,
cache_policy=cache_policy,
ends=ends,
defer=defer,
)
return self
add_edge 方法def add_edge(self, start_key: str | list[str], end_key: str) -> Self:
"""
添加有向边到图中。
支持两种模式：
1. 单源到单目标：start_key 是字符串
2. 多源到单目标：start_key 是字符串列表（等待所有源节点完成）
参数：
- start_key: 起始节点（或节点列表）
- end_key: 结束节点
返回：
- Self: 允许方法链式调用
"""
> 💡 **通俗理解**：添加边就像是在工作流程中画箭头，表示"先做这个，再做那个"。
> - 单源边：A → B（A 完成后执行 B）
> - 多源边：[A, B, C] → D（A、B、C 都完成后才执行 D，就像等所有同事都到齐再开会）
if self.compiled:
logger.warning(
"Adding an edge to a graph that has already been compiled. This will "
"not be reflected in the compiled graph."
)
# 处理单源情况
if isinstance(start_key, str):
if start_key == END:
raise ValueError("END cannot be a start node")
if end_key == START:
raise ValueError("START cannot be an end node")
# 验证（仅对非 StateGraph 图）
if not hasattr(self, "channels") and start_key in set(
start for start, _ in self.edges
):
raise ValueError(
f"Already found path for node '{start_key}'.\n"
"For multiple edges, use StateGraph with an Annotated state key."
)
self.edges.add((start_key, end_key))
return self
# 处理多源情况
for start in start_key:
if start == END:
raise ValueError("END cannot be a start node")
if start not in self.nodes:
raise ValueError(f"Need to add_node `{start}` first")
if end_key == START:
raise ValueError("START cannot be an end node")
if end_key != END and end_key not in self.nodes:
raise ValueError(f"Need to add_node `{end_key}` first")
# 添加到等待边集合
self.waiting_edges.add((tuple(start_key), end_key))
return self
add_conditional_edges 方法def add_conditional_edges(
self,
source: str, # 源节点
path: Callable[..., Hashable | list[Hashable]]
| Callable[..., Awaitable[Hashable | list[Hashable]]]
| Runnable[Any, Hashable | list[Hashable]], # 路径函数
path_map: dict[Hashable, str] | list[str] | None = None, # 路径映射
) -> Self:
"""
添加条件边。
条件边允许根据状态动态选择下一个节点。
参数：
- source: 源节点名
- path: 路径函数，根据状态返回下一个节点名（或节点名列表）
- path_map: 可选的路径映射，将路径函数的返回值映射到节点名
返回：
- Self: 允许方法链式调用
"""
> 💡 **通俗理解**：条件边就像是一个"智能路口"，根据当前情况（状态）决定走哪条路。
> - `path` 函数就像是一个"导航员"，查看当前状态后决定下一步去哪里
> - `path_map` 就像一个"翻译表"，把导航员的决定（可能是数字、字符串）翻译成实际的节点名
> - 例如：如果用户输入是问题，就去"回答节点"；如果是命令，就去"执行节点"
if self.compiled:
logger.warning(
"Adding an edge to a graph that has already been compiled. This will "
"not be reflected in the compiled graph."
)
# 将路径函数转换为可运行对象
path = coerce_to_runnable(path, name=None, trace=True)
name = path.name or "condition"
# 验证条件名唯一性
if name in self.branches[source]:
raise ValueError(
f"Branch with name `{path.name}` already exists for node `{source}`"
)
# 创建分支并保存
self.branches[source][name] = Branch.from_path(path, path_map, True)
# 如果分支有输入模式，添加它
if schema := self.branches[source][name].input_schema:
self._add_schema(schema)
return self
add_sequence 方法def add_sequence(
self,
nodes: Sequence[StateNode[StateT] | tuple[str, StateNode[StateT]]],
) -> Self:
"""
添加节点序列。
按顺序添加多个节点，并在它们之间创建边。
参数：
- nodes: 节点序列，可以是 StateNode 或 (名称, StateNode) 元组
返回：
- Self: 允许方法链式调用
"""
if len(nodes) < 1:
raise ValueError("Sequence requires at least one node.")
previous_name: str | None = None
for node in nodes:
# 确定节点名称
if isinstance(node, tuple) and len(node) == 2:
name, node = node
else:
name = _get_node_name(node)
# 验证节点名唯一性
if name in self.nodes:
raise ValueError(
f"Node names must be unique: node with the name '{name}' already exists. "
"If you need to use two different runnables/callables with the same name (for example, using `lambda`), please provide them as tuples (name, runnable/callable)."
)
# 添加节点
self.add_node(name, node)
# 如果不是第一个节点，添加边
if previous_name is not None:
self.add_edge(previous_name, name)
previous_name = name
return self
set_entry_point 方法def set_entry_point(self, key: str) -> Self:
"""
设置图的入口点。
等价于调用 add_edge(START, key)。
参数：
- key: 入口节点名
返回：
- Self: 允许方法链式调用
"""
return self.add_edge(START, key)
set_conditional_entry_point 方法def set_conditional_entry_point(
self,
path: Callable[..., Hashable | list[Hashable]]
| Callable[..., Awaitable[Hashable | list[Hashable]]]
| Runnable[Any, Hashable | list[Hashable]],
path_map: dict[Hashable, str] | list[str] | None = None,
) -> Self:
"""
设置条件入口点。
允许根据输入动态选择第一个节点。
参数：
- path: 路径函数
- path_map: 路径映射
返回：
- Self: 允许方法链式调用
"""
return self.add_conditional_edges(START, path, path_map)
set_finish_point 方法def set_finish_point(self, key: str) -> Self:
"""
设置图的结束点。
等价于调用 add_edge(key, END)。
参数：
- key: 结束节点名
返回：
- Self: 允许方法链式调用
"""
return self.add_edge(key, END)
validate 方法def validate(self, interrupt: Sequence[str] | None = None) -> Self:
"""
验证图的结构。
检查：
1. 所有边的源节点都存在
2. 图有入口点
3. 所有边的目标节点都存在
4. 中断节点存在
参数：
- interrupt: 中断节点列表（可选）
返回：
- Self: 允许方法链式调用
副作用：
- 设置 self.compiled = True
"""
> 💡 **通俗理解**：验证就像是在"施工前检查图纸"，确保：
> - 所有箭头都指向存在的节点（不能指向空）
> - 有起点（不能没有入口）
> - 所有目标节点都存在（不能指向不存在的节点）
> - 如果设置了中断点，这些节点必须存在
> 如果检查通过，就标记为"已验证"，可以编译了。
# 收集所有源节点
all_sources = {src for src, _ in self._all_edges}
for start, branches in self.branches.items():
all_sources.add(start)
for name, spec in self.nodes.items():
if spec.ends:
all_sources.add(name)
# 验证源节点
for source in all_sources:
if source not in self.nodes and source != START:
raise ValueError(f"Found edge starting at unknown node '{source}'")
# 验证有入口点
if START not in all_sources:
raise ValueError(
"Graph must have an entrypoint: add at least one edge from START to another node"
)
# 收集所有目标节点
all_targets = {end for _, end in self._all_edges}
for start, branches in self.branches.items():
for cond, branch in branches.items():
if branch.ends is not None:
for end in branch.ends.values():
if end not in self.nodes and end != END:
raise ValueError(
f"At '{start}' node, '{cond}' branch found unknown target '{end}'"
)
all_targets.add(end)
else:
# 如果没有指定目标，可能路由到任何节点
all_targets.add(END)
for node in self.nodes:
if node != start:
all_targets.add(node)
for name, spec in self.nodes.items():
if spec.ends:
all_targets.update(spec.ends)
# 验证目标节点
for target in all_targets:
if target not in self.nodes and target != END:
raise ValueError(f"Found edge ending at unknown node `{target}`")
# 验证中断节点
if interrupt:
for node in interrupt:
if node not in self.nodes:
raise ValueError(f"Interrupt node `{node}` not found")
self.compiled = True
return self
compile 方法def compile(
self,
checkpointer: Checkpointer = None, # 检查点器
*,
cache: BaseCache | None = None, # 缓存
store: BaseStore | None = None, # 存储
interrupt_before: All | list[str] | None = None, # 执行前中断的节点
interrupt_after: All | list[str] | None = None, # 执行后中断的节点
debug: bool = False, # 调试模式
name: str | None = None, # 图名称
) -> CompiledStateGraph[StateT, InputT, OutputT]:
"""
编译状态图为 CompiledStateGraph。
编译后的图实现了 Runnable 接口，可以调用、流式传输、批处理和异步运行。
主要步骤：
1. 验证图结构
2. 准备输出通道和流通道
3. 创建 CompiledStateGraph 实例
4. 附加所有节点、边和分支
返回：
- CompiledStateGraph: 编译后的状态图
"""
> 💡 **通俗理解**：编译就像把"设计图纸"变成"实际可运行的机器"。
> - 先检查图纸有没有问题（validate）
> - 准备好输出接口（output_channels）和流式接口（stream_channels）
> - 创建一个"执行引擎"（CompiledStateGraph）
> - 把所有节点、边、分支都"安装"到引擎上
> 编译完成后，你就可以调用 `invoke()` 或 `stream()` 来运行这个图了！
# 设置默认值
interrupt_before = interrupt_before or []
interrupt_after = interrupt_after or []
# 验证图
self.validate(
interrupt=(
(interrupt_before if interrupt_before != "*" else []) + interrupt_after
if interrupt_after != "*"
else []
)
)
# 准备输出通道
output_channels = (
"__root__"
if len(self.schemas[self.output_schema]) == 1
and "__root__" in self.schemas[self.output_schema]
else [
key
for key, val in self.schemas[self.output_schema].items()
if not is_managed_value(val)
]
)
# 准备流通道
stream_channels = (
"__root__"
if len(self.channels) == 1 and "__root__" in self.channels
else [
key for key, val in self.channels.items() if not is_managed_value(val)
]
)
# 创建编译后的图
compiled = CompiledStateGraph[StateT, InputT, OutputT](
builder=self,
schema_to_mapper={},
config_type=self.config_schema,
nodes={},
channels={
**self.channels,
**self.managed,
START: EphemeralValue(self.input_schema),
},
input_channels=START,
stream_mode="updates",
output_channels=output_channels,
stream_channels=stream_channels,
checkpointer=checkpointer,
interrupt_before_nodes=interrupt_before,
interrupt_after_nodes=interrupt_after,
auto_validate=False,
debug=debug,
store=store,
cache=cache,
name=name or "LangGraph",
)
# 附加 START 节点
compiled.attach_node(START, None)
# 附加所有节点
for key, node in self.nodes.items():
compiled.attach_node(key, node)
# 附加所有边
for start, end in self.edges:
compiled.attach_edge(start, end)
# 附加所有等待边
for starts, end in self.waiting_edges:
compiled.attach_edge(starts, end)
# 附加所有分支
for start, branches in self.branches.items():
for name, branch in branches.items():
compiled.attach_branch(start, name, branch)
return compiled.validate()
CompiledStateGraph 是编译后的状态图，继承自 Pregel，实现了实际的图执行逻辑。
💡 通俗理解：
CompiledStateGraph就是"实际运行的机器"，而StateGraph只是"设计图纸"。
StateGraph：你用它来设计工作流程（添加节点、边等）CompiledStateGraph：编译后得到的可执行对象，你可以调用它来实际运行工作流程 就像写代码和运行代码的区别一样。
class CompiledStateGraph(
Pregel[StateT, InputT, OutputT], Generic[StateT, InputT, OutputT]
):
"""
编译后的状态图。
继承自 Pregel，实现了图的执行逻辑。
"""
builder: StateGraph[StateT, InputT, OutputT]
# 构建器引用，保存原始的状态图定义
schema_to_mapper: dict[type[Any], Callable[[Any], Any] | None]
# 模式到映射函数的字典，用于将状态字典转换为模式对象
__init__ 方法def __init__(
self,
*,
builder: StateGraph[StateT, InputT, OutputT],
schema_to_mapper: dict[type[Any], Callable[[Any], Any] | None],
**kwargs: Any,
) -> None:
"""
初始化编译后的状态图。
调用父类 Pregel 的初始化方法，然后保存构建器和模式映射器。
"""
super().__init__(**kwargs)
self.builder = builder
self.schema_to_mapper = schema_to_mapper
get_input_jsonschema 方法def get_input_jsonschema(
self, config: RunnableConfig | None = None
) -> dict[str, Any]:
"""
获取输入的 JSON Schema。
用于 API 文档生成和验证。
"""
return _get_json_schema(
typ=self.builder.input_schema,
schemas=self.builder.schemas,
channels=self.builder.channels,
name=self.get_name("Input"),
)
get_output_jsonschema 方法def get_output_jsonschema(
self, config: RunnableConfig | None = None
) -> dict[str, Any]:
"""
获取输出的 JSON Schema。
用于 API 文档生成和验证。
"""
return _get_json_schema(
typ=self.builder.output_schema,
schemas=self.builder.schemas,
channels=self.builder.channels,
name=self.get_name("Output"),
)
attach_node 方法def attach_node(self, key: str, node: StateNodeSpec | None) -> None:
"""
将节点附加到编译后的图中。
这是编译过程的关键步骤，将 StateGraph 的节点转换为 Pregel 节点。
主要工作：
1. 确定输出键
2. 创建更新函数（处理节点返回值）
3. 创建写入条目（状态更新和分支控制）
4. 创建 PregelNode 并添加到图中
参数：
- key: 节点键（START 或节点名）
- node: 节点规范（START 节点为 None）
"""
> 💡 **通俗理解**：这个方法把"设计图纸上的节点"转换成"实际可执行的节点"。
> - 确定节点可以更新哪些状态字段（output_keys）
> - 创建一个"转换器"（_get_updates），把节点的返回值转换成状态更新
> - 创建"写入器"（write_entries），负责把更新写入状态，并控制下一步去哪里
> - 最后创建一个 PregelNode（实际执行单元）并添加到图中
> 就像把"工作步骤说明"转换成"实际的工作指令"。
# 确定输出键
if key == START:
# START 节点输出输入模式的所有键
output_keys = [
k
for k, v in self.builder.schemas[self.builder.input_schema].items()
if not is_managed_value(v)
]
else:
# 普通节点输出所有通道和托管值
output_keys = list(self.builder.channels) + [
k for k, v in self.builder.managed.items()
]
def _get_updates(
input: None | dict | Any,
) -> Sequence[tuple[str, Any]] | None:
"""
将节点返回值转换为更新元组列表。
处理多种返回类型：
- None: 无更新
- dict: 字典键值对
- Command: 命令对象
- list/tuple: 命令列表
- 带注解的对象: 使用 get_update_as_tuples
"""
if input is None:
return None
elif isinstance(input, dict):
return [(k, v) for k, v in input.items() if k in output_keys]
elif isinstance(input, Command):
if input.graph == Command.PARENT:
return None
return [
(k, v) for k, v in input._update_as_tuples() if k in output_keys
]
elif (
isinstance(input, (list, tuple))
and input
and any(isinstance(i, Command) for i in input)
):
updates: list[tuple[str, Any]] = []
for i in input:
if isinstance(i, Command):
if i.graph == Command.PARENT:
continue
updates.extend(
(k, v) for k, v in i._update_as_tuples() if k in output_keys
)
else:
updates.extend(_get_updates(i) or ())
return updates
elif (t := type(input)) and get_cached_annotated_keys(t):
return get_update_as_tuples(input, output_keys)
else:
msg = create_error_message(
message=f"Expected dict, got {input}",
error_code=ErrorCode.INVALID_GRAPH_NODE_RETURN_VALUE,
)
raise InvalidUpdateError(msg)
# 创建写入条目
write_entries: tuple[ChannelWriteEntry | ChannelWriteTupleEntry, ...] = (
ChannelWriteTupleEntry(
mapper=_get_root if output_keys == ["__root__"] else _get_updates
),
ChannelWriteTupleEntry(
mapper=_control_branch,
static=_control_static(node.ends)
if node is not None and node.ends is not None
else None,
),
)
# 添加节点
if key == START:
# START 节点
self.nodes[key] = PregelNode(
tags=[TAG_HIDDEN],
triggers=[START],
channels=START,
writers=[ChannelWrite(write_entries)],
)
elif node is not None:
# 普通节点
input_schema = node.input if node else self.builder.state_schema
input_channels = list(self.builder.schemas[input_schema])
is_single_input = len(input_channels) == 1 and "__root__" in input_channels
# 获取或创建映射器
if input_schema in self.schema_to_mapper:
mapper = self.schema_to_mapper[input_schema]
else:
mapper = _pick_mapper(input_channels, input_schema)
self.schema_to_mapper[input_schema] = mapper
# 创建分支通道
branch_channel = CHANNEL_BRANCH_TO.format(key)
self.channels[branch_channel] = (
LastValueAfterFinish(Any)
if node.defer
else EphemeralValue(Any, guard=False)
)
# 创建 PregelNode
self.nodes[key] = PregelNode(
triggers=[branch_channel],
channels=("__root__" if is_single_input else input_channels),
mapper=mapper,
writers=[ChannelWrite(write_entries)],
metadata=node.metadata,
retry_policy=node.retry_policy,
cache_policy=node.cache_policy,
bound=node.runnable,
)
else:
raise RuntimeError
attach_edge 方法def attach_edge(self, starts: str | Sequence[str], end: str) -> None:
"""
将边附加到编译后的图中。
处理两种类型的边：
1. 单源边：直接写入目标节点的分支通道
2. 多源边：使用命名屏障值通道等待所有源节点完成
参数：
- starts: 起始节点（或节点列表）
- end: 结束节点
"""
> 💡 **通俗理解**：这个方法把"设计图纸上的箭头"转换成"实际的执行路径"。
> - 单源边：A → B，直接在 A 的写入器中添加"完成后通知 B"
> - 多源边：[A, B, C] → D，创建一个"集合点通道"，A、B、C 都完成后才通知 D
> 就像把"流程图上的箭头"转换成"实际的信号传递机制"。
if isinstance(starts, str):
# 单源边：直接写入目标节点的分支通道
if end != END:
self.nodes[starts].writers.append(
ChannelWrite(
(ChannelWriteEntry(CHANNEL_BRANCH_TO.format(end), None),)
)
)
elif end != END:
# 多源边：创建命名屏障值通道
channel_name = f"join:{'+'.join(starts)}:{end}"
# 注册通道
if self.builder.nodes[end].defer:
# 如果目标节点延迟执行，使用 AfterFinish 版本
self.channels[channel_name] = NamedBarrierValueAfterFinish(
str, set(starts)
)
else:
self.channels[channel_name] = NamedBarrierValue(str, set(starts))
# 订阅通道（目标节点等待）
self.nodes[end].triggers.append(channel_name)
# 发布到通道（源节点写入）
for start in starts:
self.nodes[start].writers.append(
ChannelWrite((ChannelWriteEntry(channel_name, start),))
)
attach_branch 方法def attach_branch(
self, start: str, name: str, branch: Branch, *, with_reader: bool = True
) -> None:
"""
将分支附加到编译后的图中。
分支用于条件边，根据状态动态选择下一个节点。
参数：
- start: 源节点名
- name: 分支名
- branch: 分支对象
- with_reader: 是否创建读取器（用于读取状态）
"""
> 💡 **通俗理解**：这个方法把"条件判断逻辑"转换成"实际的路由机制"。
> - 创建一个"读取器"（reader）来读取当前状态
> - 创建一个"写入器"（get_writes）来把分支决策转换成"通知哪个节点"
> - 把分支逻辑附加到源节点上
> 就像把"如果...就..."的逻辑转换成"实际的信号路由"。
def get_writes(
packets: Sequence[str | Send], static: bool = False
) -> Sequence[ChannelWriteEntry | Send]:
"""
将分支返回的包转换为写入条目。
参数：
- packets: 包列表（节点名或 Send 对象）
- static: 是否为静态分支
返回：
- 写入条目列表
"""
writes = [
(
ChannelWriteEntry(
p if p == END else CHANNEL_BRANCH_TO.format(p), None
)
if not isinstance(p, Send)
else p
)
for p in packets
if (True if static else p != END)
]
if not writes:
return []
return writes
if with_reader:
# 获取模式
schema = branch.input_schema or (
self.builder.nodes[start].input
if start in self.builder.nodes
else self.builder.state_schema
)
channels = list(self.builder.schemas[schema])
# 获取映射器
if schema in self.schema_to_mapper:
mapper = self.schema_to_mapper[schema]
else:
mapper = _pick_mapper(channels, schema)
self.schema_to_mapper[schema] = mapper
# 创建读取器
reader: Callable[[RunnableConfig], Any] | None = partial(
ChannelRead.do_read,
select=channels[0] if channels == ["__root__"] else channels,
fresh=True,
mapper=mapper,
)
else:
reader = None
# 附加分支发布器
self.nodes[start].writers.append(branch.run(get_writes, reader))
_migrate_checkpoint 方法def _migrate_checkpoint(self, checkpoint: Checkpoint) -> None:
"""
迁移检查点到新的通道布局。
当图的内部结构改变时（如通道命名方式改变），需要迁移旧的检查点。
迁移规则：
1. start:node -> branch:to:node
2. branch:source:condition:node -> branch:to:node
3. node -> branch:to:node（对于所有目标节点）
参数：
- checkpoint: 要迁移的检查点
"""
> 💡 **通俗理解**：这个方法就像"游戏版本更新时的存档迁移"。
> - LangGraph 的内部实现可能会改变（比如通道的命名方式）
> - 但旧的检查点（存档）还在用旧的命名方式
> - 这个方法会自动把旧的命名转换成新的命名，让旧存档可以在新版本中使用
> 就像游戏更新后，旧存档还能继续使用一样。
super()._migrate_checkpoint(checkpoint)
values = checkpoint["channel_values"]
versions = checkpoint["channel_versions"]
seen = checkpoint["versions_seen"]
# 空检查点不需要迁移
if not versions:
return
# 当前版本（v3+）不需要迁移
if checkpoint["v"] >= 3:
return
# 迁移 1: start:node -> branch:to:node
for k in list(versions):
if k.startswith("start:"):
node = k.split(":")[1]
if node not in self.nodes:
continue
new_k = f"branch:to:{node}"
new_v = (
max(versions[new_k], versions.pop(k))
if new_k in versions
else versions.pop(k)
)
# 更新 seen
for ss in (seen.get(node, {}), seen.get(INTERRUPT, {})):
if k in ss:
s = ss.pop(k)
if new_k in ss:
ss[new_k] = max(s, ss[new_k])
else:
ss[new_k] = s
# 更新值
if new_k not in values and k in values:
values[new_k] = values.pop(k)
# 更新版本
versions[new_k] = new_v
# 迁移 2: branch:source:condition:node -> branch:to:node
for k in list(versions):
if k.startswith("branch:") and k.count(":") == 3:
node = k.split(":")[-1]
if node not in self.nodes:
continue
new_k = f"branch:to:{node}"
new_v = (
max(versions[new_k], versions.pop(k))
if new_k in versions
else versions.pop(k)
)
# 更新 seen
for ss in (seen.get(node, {}), seen.get(INTERRUPT, {})):
if k in ss:
s = ss.pop(k)
if new_k in ss:
ss[new_k] = max(s, ss[new_k])
else:
ss[new_k] = s
# 更新值
if new_k not in values and k in values:
values[new_k] = values.pop(k)
# 更新版本
versions[new_k] = new_v
# 迁移 3: node -> branch:to:node（对于所有目标节点）
if not set(self.nodes).isdisjoint(versions):
source_to_target = defaultdict(list)
for start, end in self.builder.edges:
if start != START and end != END:
source_to_target[start].append(end)
for k in list(versions):
if k == START:
continue
if k in self.nodes:
v = versions.pop(k)
c = values.pop(k, MISSING)
for end in source_to_target[k]:
new_k = f"branch:to:{end}"
new_v = max(versions[new_k], v) if new_k in versions else v
# 更新 seen
for ss in (seen.get(end, {}), seen.get(INTERRUPT, {})):
if k in ss:
s = ss.pop(k)
if new_k in ss:
ss[new_k] = max(s, ss[new_k])
else:
ss[new_k] = s
# 更新值
if new_k not in values and c is not MISSING:
values[new_k] = c
# 更新版本
versions[new_k] = new_v
# 弹出中断 seen
if INTERRUPT in seen:
seen[INTERRUPT].pop(k, MISSING)
_pick_mapper 函数def _pick_mapper(
state_keys: Sequence[str], schema: type[Any]
) -> Callable[[Any], Any] | None:
"""
选择状态映射函数。
如果状态键是 __root__ 或模式是字典类型，返回 None（不需要映射）。
否则返回一个将字典转换为模式对象的函数。
"""
if state_keys == ["__root__"]:
return None
if isclass(schema) and issubclass(schema, dict):
return None
return partial(_coerce_state, schema)
_coerce_state 函数def _coerce_state(schema: type[Any], input: dict[str, Any]) -> dict[str, Any]:
"""
将字典强制转换为模式对象。
使用模式类的构造函数创建实例。
"""
return schema(**input)
_control_branch 函数def _control_branch(value: Any) -> Sequence[tuple[str, Any]]:
"""
处理分支控制值。
将 Command 对象或 Send 对象转换为写入条目。
参数：
- value: 控制值（Command、Send 或列表）
返回：
- 写入条目列表
"""
if isinstance(value, Send):
return ((TASKS, value),)
commands: list[Command] = []
if isinstance(value, Command):
commands.append(value)
elif isinstance(value, (list, tuple)):
for cmd in value:
if isinstance(cmd, Command):
commands.append(cmd)
rtn: list[tuple[str, Any]] = []
for command in commands:
# 如果是父命令，抛出异常
if command.graph == Command.PARENT:
raise ParentCommand(command)
# 获取目标节点
goto_targets = (
[command.goto] if isinstance(command.goto, (Send, str)) else command.goto
)
# 转换为写入条目
for go in goto_targets:
if isinstance(go, Send):
rtn.append((TASKS, go))
elif isinstance(go, str) and go != END:
rtn.append((CHANNEL_BRANCH_TO.format(go), None))
return rtn
_control_static 函数def _control_static(
ends: tuple[str, ...] | dict[str, str],
) -> Sequence[tuple[str, Any, str | None]]:
"""
创建静态分支控制条目。
用于节点规范中指定的目标节点。
参数：
- ends: 目标节点（元组或字典）
返回：
- 写入条目列表（包含标签）
"""
if isinstance(ends, dict):
return [
(k if k == END else CHANNEL_BRANCH_TO.format(k), None, label)
for k, label in ends.items()
]
else:
return [
(e if e == END else CHANNEL_BRANCH_TO.format(e), None, None) for e in ends
]
_get_root 函数def _get_root(input: Any) -> Sequence[tuple[str, Any]] | None:
"""
处理根值更新。
当状态只有一个根键（__root__）时使用。
参数：
- input: 输入值（Command、列表或普通值）
返回：
- 更新元组列表
"""
if isinstance(input, Command):
if input.graph == Command.PARENT:
return ()
return input._update_as_tuples()
elif (
isinstance(input, (list, tuple))
and input
and any(isinstance(i, Command) for i in input)
):
updates: list[tuple[str, Any]] = []
for i in input:
if isinstance(i, Command):
if i.graph == Command.PARENT:
continue
updates.extend(i._update_as_tuples())
else:
updates.append(("__root__", i))
return updates
elif input is not None:
return [("__root__", input)]
_get_channels 函数def _get_channels(
schema: type[dict],
) -> tuple[dict[str, BaseChannel], dict[str, ManagedValueSpec], dict[str, Any]]:
"""
从模式中提取通道和托管值。
参数：
- schema: 模式类型
返回：
- (通道字典, 托管值字典, 类型提示字典)
"""
> 💡 **通俗理解**：这个方法就像"解析表格模板，为每个字段创建邮箱"。
> - 输入：一个状态模式（定义了有哪些字段）
> - 输出：为每个字段创建的通道（邮箱）和托管值（特殊邮箱）
> - 就像你定义了一个表格，系统自动为每列创建一个"数据传递通道"
# 如果没有注解，返回根通道
if not hasattr(schema, "__annotations__"):
return (
{"__root__": _get_channel("__root__", schema, allow_managed=False)},
{},
{},
)
# 获取类型提示（包括额外信息）
type_hints = get_type_hints(schema, include_extras=True)
# 为每个字段创建通道或托管值
all_keys = {
name: _get_channel(name, typ)
for name, typ in type_hints.items()
if name != "__slots__"
}
# 分离通道和托管值
return (
{k: v for k, v in all_keys.items() if isinstance(v, BaseChannel)},
{k: v for k, v in all_keys.items() if is_managed_value(v)},
type_hints,
)
_get_channel 函数@overload
def _get_channel(
name: str, annotation: Any, *, allow_managed: Literal[False]
) -> BaseChannel: ...
@overload
def _get_channel(
name: str, annotation: Any, *, allow_managed: Literal[True] = True
) -> BaseChannel | ManagedValueSpec: ...
def _get_channel(
name: str, annotation: Any, *, allow_managed: bool = True
) -> BaseChannel | ManagedValueSpec:
"""
从类型注解创建通道或托管值。
检查顺序：
1. 是否为托管值
2. 是否为显式通道
3. 是否为二元操作符聚合
4. 默认使用 LastValue
参数：
- name: 字段名
- annotation: 类型注解
- allow_managed: 是否允许托管值
返回：
- 通道或托管值规范
"""
> 💡 **通俗理解**：这个方法就像"根据字段类型选择合适的邮箱类型"。
> - 如果字段标注了"托管值"（系统自动管理），就用托管值通道
> - 如果字段标注了特定通道类型，就用那个类型
> - 如果字段有 reducer（聚合函数），就用聚合通道（可以合并多个值）
> - 否则默认用 LastValue（只保留最新值，覆盖旧值）
> 就像根据不同的需求选择不同的"邮箱类型"：有的邮箱只存最新邮件，有的可以合并多封邮件。
# 检查托管值
if manager := _is_field_managed_value(name, annotation):
if allow_managed:
return manager
else:
raise ValueError(f"This {annotation} not allowed in this position")
# 检查显式通道
elif channel := _is_field_channel(annotation):
channel.key = name
return channel
# 检查二元操作符聚合
elif channel := _is_field_binop(annotation):
channel.key = name
return channel
# 默认使用 LastValue
fallback: LastValue = LastValue(annotation)
fallback.key = name
return fallback
_is_field_channel 函数def _is_field_channel(typ: type[Any]) -> BaseChannel | None:
"""
检查类型注解是否为显式通道。
检查注解的元数据中是否包含 BaseChannel 实例或类。
"""
if hasattr(typ, "__metadata__"):
meta = typ.__metadata__
if len(meta) >= 1 and isinstance(meta[-1], BaseChannel):
return meta[-1]
elif len(meta) >= 1 and isclass(meta[-1]) and issubclass(meta[-1], BaseChannel):
return meta[-1](typ.__origin__ if hasattr(typ, "__origin__") else typ)
return None
_is_field_binop 函数def _is_field_binop(typ: type[Any]) -> BinaryOperatorAggregate | None:
"""
检查类型注解是否为二元操作符聚合（reducer）。
检查注解的元数据中是否包含可调用对象，且签名符合 reducer 要求（两个位置参数）。
"""
if hasattr(typ, "__metadata__"):
meta = typ.__metadata__
if len(meta) >= 1 and callable(meta[-1]):
sig = signature(meta[-1])
params = list(sig.parameters.values())
if (
sum(
p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)
for p in params
)
== 2
):
return BinaryOperatorAggregate(typ, meta[-1])
else:
raise ValueError(
f"Invalid reducer signature. Expected (a, b) -> c. Got {sig}"
)
return None
_is_field_managed_value 函数def _is_field_managed_value(name: str, typ: type[Any]) -> ManagedValueSpec | None:
"""
检查类型注解是否为托管值。
检查注解的元数据中是否包含托管值装饰器。
"""
if hasattr(typ, "__metadata__"):
meta = typ.__metadata__
if len(meta) >= 1:
decoration = get_origin(meta[-1]) or meta[-1]
if is_managed_value(decoration):
return decoration
return None
_get_json_schema 函数def _get_json_schema(
typ: type,
schemas: dict,
channels: dict,
name: str,
) -> dict[str, Any]:
"""
生成类型的 JSON Schema。
用于 API 文档和验证。
参数：
- typ: 类型
- schemas: 模式字典
- channels: 通道字典
- name: Schema 名称
返回：
- JSON Schema 字典
"""
# Pydantic 模型
if isclass(typ) and issubclass(typ, BaseModel):
return typ.model_json_schema()
# TypedDict
elif is_typeddict(typ):
return TypeAdapter(typ).json_schema()
# 其他类型
else:
keys = list(schemas[typ].keys())
# 单根键
if len(keys) == 1 and keys[0] == "__root__":
return create_model(
name,
root=(channels[keys[0]].UpdateType, None),
).model_json_schema()
# 多键
else:
return create_model(
name,
field_definitions={
k: (
channels[k].UpdateType,
(
get_field_default(
k,
channels[k].UpdateType,
typ,
)
),
)
for k in schemas[typ]
if k in channels and isinstance(channels[k], BaseChannel)
},
).model_json_schema()
CHANNEL_BRANCH_TO = "branch:to:{}"
# 分支通道名称格式模板
# 用于创建节点分支通道的名称，例如 "branch:to:node_name"
state.py 文件实现了 LangGraph 的核心状态图功能：
关键概念：
这个文件是 LangGraph 框架的核心，理解它有助于深入理解整个框架的工作原理。
StateGraph（设计阶段）：
CompiledStateGraph（运行阶段）：
通道系统：
LastValue：只保留最新值（覆盖旧值）NamedBarrierValue：等待多个节点都完成（集合点）BinaryOperatorAggregate：用函数合并多个值（如累加、列表合并）执行流程：
graph.invoke(input) 或 graph.stream(input)检查点系统：
StateGraph 只是设计，必须调用 compile() 才能运行希望这些解释能帮助你更好地理解 LangGraph 的工作原理！🚀
]]>