Tree of Thoughts：让大语言模型像人类一样思考

作者：ToTensor日期：2025/11/23

文章目录

  • 前言
    • 引言
    • 什么是 Tree of Thoughts？
      • 传统方法的局限
        • ToT 的优势
    • Game24：一个完美的例子
    • ToT 的核心工作流程
      • 整体流程图
        • 1. 生成（Generation）
        • 2. 评估（Evaluation）
        • 3. 选择（Selection）
    • 完整流程示例
      • 问题说明
        • 整体流程图
        • 详细步骤说明
          • 步骤 1/4：从初始状态开始
            * 步骤 2/4：对选中的候选继续生成
            * 步骤 3/4：继续搜索
            * 步骤 4/4：生成最终答案
        • 完整路径总结
    • 代码实现
      • 核心函数
        • 生成函数示例
        • 评估函数
        • 评估提示词示例
    • 为什么 ToT 有效？
      • 1. 探索更多可能性
        • 2. 智能评估
        • 3. 可回溯
    • ToT 的缺点
      • 1. 计算成本高
        • 2. 评估质量依赖模型能力
        • 3. 搜索空间可能爆炸
        • 4. 不适合所有任务
    • 总结
      • 核心优势
        • 适用场景总结

前言

通过 Game24 游戏，深入理解 Tree of Thoughts 如何让大语言模型进行多步推理和智能搜索

论文：Tree of Thoughts: Deliberate Problem Solving with Large Language Models

官方代码：https://github.com/princeton-nlp/tree-of-thought-llm

实验代码：https://github.com/seanzhang-zhichen/llm-reasoners

引言

想象一下，当你面对一个复杂的数学问题时，你会怎么做？比如给你四个数字 1 1 4 6，要求用基本运算（+、-、*、/）得到 24。

大多数人不会直接给出答案，而是会：

  1. 生成多个可能的下一步操作（比如 1+1=2、4*6=24、6-1=5 等）
  2. 评估每个操作的前景（哪些更有可能导向正确答案）
  3. 选择最有希望的操作继续（比如选择 1+1=2，因为得到 2 后更容易凑成 24）

这就是 Tree of Thoughts (ToT) 的核心思想：让大语言模型像人类一样，通过生成、评估、选择三个步骤，逐步构建解决方案树，而不是一次性生成答案。

什么是 Tree of Thoughts？

Tree of Thoughts 是 Princeton 大学在 2023 年提出的一种新的提示方法，它解决了传统方法（如 Chain of Thought, CoT）的局限性。

传统方法的局限

标准提示（Standard Prompting）：

  • 直接要求模型给出答案
  • 问题：模型可能给出错误答案，且无法回溯

思维链提示（Chain of Thought, CoT）：

  • 要求模型逐步展示推理过程
  • 问题：仍然是线性思考，一旦走错路就无法纠正

ToT 的优势

ToT 通过构建解决方案树，让模型能够：

  • 探索多条路径：同时考虑多个可能的下一步
  • 评估和选择：智能地选择最有希望的路径
  • 回溯和修正：如果一条路走不通，可以回到上一步选择其他路径

Game24：一个完美的例子

Game24 是一个经典的数学游戏：给定 4 个数字，使用基本运算得到 24。例如：

  • 输入：1 2 3 4
  • 输出：
11 + 2 = 3 (left: 3 3 4)  
23 + 3 = 6 (left: 4 6)  
36 * 4 = 24 (left: 24)  
4Answer: (1 + 2 + 3) * 4 = 24

这个任务非常适合展示 ToT，因为：

  1. 每一步都有多个可能的选择
  2. 需要多步推理（4 个数字 → 3 个数字 → 2 个数字 → 1 个数字）
  3. 容易评估每个选择的前景

ToT 的核心工作流程

Tree of Thoughts 的核心是一个迭代的三步循环：生成 → 评估 → 选择。让我们通过一个具体的例子来理解：

整体流程图

1. 生成（Generation）

在每一步，模型需要生成多个可能的下一步操作。有两种不同的生成策略：

Propose 方法：一次 API 调用，模型输出多个候选

  • 调用方式：只调用 1 次 API（n=1）
  • 提示词要求：明确要求模型"列出多个可能的下一步操作"
  • 模型输出：在一次响应中输出多行文本，每行是一个候选操作
  • 处理方式：通过 split('\n') 将多行输出分割成多个候选

示例：

1提示词: "Input: 1 1 4 6\nPossible next steps:"
2模型输出（一次响应）:
31 + 1 = 2 (left: 2 4 6)
41 * 1 = 1 (left: 1 4 6)
54 * 6 = 24 (left: 1 1 24)
66 - 1 = 5 (left: 1 4 5)
74 + 6 = 10 (left: 1 1 10)
8...
9
10结果: 分割成 5+ 个候选
11

Sample 方法：多次 API 调用，每次生成一个候选

  • 调用方式：调用 n_generate_sample 次 API（例如 n=10 就调用 10 次）
  • 提示词要求：要求模型生成一个完整的解决方案（或部分推理路径）
  • 模型输出：每次 API 调用生成一个完整的解决方案
  • 处理方式：每次调用的输出作为一个独立的候选

示例：

1提示词: "Use numbers and basic arithmetic operations to obtain 24.\nInput: 1 1 4 6"
2API 调用 1: "1 + 1 = 2 (left: 2 4 6)\n4 * 6 = 24 (left: 2 24)\n..."
3API 调用 2: "4 * 6 = 24 (left: 1 1 24)\n24 / 1 = 24 (left: 1 24)\n..."
4API 调用 3: "6 - 1 = 5 (left: 1 4 5)\n5 * 4 = 20 (left: 1 20)\n..."
5...
6
7结果: 10 次调用得到 10 个候选
8

2. 评估（Evaluation）

对每个生成的候选，评估它到达正确答案的可能性。

Value 方法：单独评估每个候选的价值

模型会输出：

  • sure（20 分）：非常有可能达到 24
  • likely（1 分）：有可能达到 24
  • impossible（0.001 分）：不可能达到 24

例如：

1候选: 1 + 1 = 2 (left: 2 4 6)
2评估: sure  # 因为 2, 4, 6 很容易得到 24（4*6=24，然后 24*1=24）
3价值分数: 20.0
4
5候选: 1 * 1 = 1 (left: 1 4 6)
6评估: likely  # 可能，但不如上面的好
7价值分数: 1.0
8

Vote 方法：将所有候选一起展示，让模型投票选择最好的

3. 选择（Selection）

根据评估分数，选择最有希望的候选进入下一步。

下面的流程图展示了每一步内部的详细流程：

Greedy 方法：贪心选择，直接选择价值分数最高的前 N 个

  • 实现方式：对候选按价值分数降序排序，选择前 n_select_sample 个
  • 优点：简单直接，总是选择最有希望的候选
  • 缺点：可能陷入局部最优，缺乏探索性
1# 代码实现（来自 bfs_method.py）
2if args.method_select == 'greedy':
3    # 按价值分数降序排序，选择前 n_select_sample 个
4    select_ids = sorted(ids, key=lambda x: values[x], reverse=True)[:args.n_select_sample]
5
6# 示例：假设有 10 个候选，价值分数为：
7values = [20.0, 1.0, 0.001, 20.0, 1.0, 0.001, 20.0, 1.0, 0.001, 0.001]
8# 选择前 5 个（n_select_sample=5）
9select_ids = [0, 3, 6, 1, 4]  # 选择价值最高的 5 个（索引 0, 3, 6, 1, 4）
10

Sample 方法：按价值分数作为概率进行采样

  • 实现方式：将价值分数归一化为概率分布，按概率随机采样
  • 优点：增加多样性，可能发现更好的路径
  • 缺点：可能选择次优解，增加搜索成本
1# 代码实现（来自 bfs_method.py）
2if args.method_select == 'sample':
3    # 将价值分数归一化为概率分布
4    ps = np.array(values) / sum(values)
5    # 按概率采样 n_select_sample 个候选
6    select_ids = np.random.choice(ids, size=args.n_select_sample, p=ps).tolist()
7
8# 示例：假设有 3 个候选，价值分数为：
9values = [20.0, 1.0, 0.001]
10# 归一化为概率：[20.0/21.001, 1.0/21.001, 0.001/21.001] ≈ [0.952, 0.048, 0.000]
11# 按这个概率分布采样，价值高的候选被选中的概率更大
12

完整流程示例

让我们通过一个具体的例子，详细展示 ToT 如何逐步解决 Game24 问题：用 1 1 4 6 得到 24。

问题说明

  • 输入：1 1 4 6
  • 目标：使用基本运算（+、-、*、/）得到 24
  • 约束：必须使用所有 4 个数字，每个数字只能用一次
  • 方法：ToT (propose + value + greedy)，每步选择前 5 个最有希望的候选

整体流程图

下面的流程图展示了 ToT 如何逐步解决这个问题：

详细步骤说明

让我们逐步看看每个阶段发生了什么：

步骤 1/4：从初始状态开始

当前状态：1 1 4 6（4 个数字）

1.1 生成阶段（Generation）

使用 propose 方法，模型被要求列出所有可能的下一步操作。模型一次性生成了 52 个候选，包括：

1- 1 + 1 = 2 (left: 2 4 6)
2- 1 * 1 = 1 (left: 1 4 6)
3- 4 * 6 = 24 (left: 1 1 24)
4- 6 - 1 = 5 (left: 1 4 5)
5- 4 + 6 = 10 (left: 1 1 10)
6- 1 - 1 = 0 (left: 0 4 6)
7- 6 / 1 = 6 (left: 1 4 6)
8... (共 52 个候选)
9

1.2 评估阶段（Evaluation）

使用 value 方法，对每个候选进行评估。模型会判断每个候选到达 24 的可能性：

  • sure（20 分）：非常有可能达到 24
  • likely（1 分）：有可能达到 24
  • impossible（0.001 分）：不可能达到 24

评估结果示例：

1候选: 1 + 1 = 2 (left: 2 4 6)
2评估: sure (20.0)  # 因为 2, 4, 6 很容易得到 24（4*6=24，然后 24*1=24）
3
4候选: 4 * 6 = 24 (left: 1 1 24)
5评估: sure (20.0)  # 已经得到 24，只需要用 1 和 1 保持 24
6
7候选: 6 - 1 = 5 (left: 1 4 5)
8评估: likely (1.0)  # 可能，但不如上面的好
9
10候选: 1 * 1 = 1 (left: 1 4 6)
11评估: likely (1.0)  # 可能，但不如上面的好
12
13候选: 4 + 6 = 10 (left: 1 1 10)
14评估: impossible (0.001)  # 很难从 1, 1, 10 得到 24
15

1.3 选择阶段（Selection）

使用 greedy 方法，选择价值分数最高的前 5 个候选：

1✓ 1 + 1 = 2 (left: 2 4 6) [价值: 20.0]
2✓ 4 * 6 = 24 (left: 1 1 24) [价值: 20.0]
3✓ 6 - 1 = 5 (left: 1 4 5) [价值: 1.0]
4✓ 1 * 1 = 1 (left: 1 4 6) [价值: 1.0]
5✓ 4 + 6 = 10 (left: 1 1 10) [价值: 0.001]
6

这 5 个候选将进入下一步。

步骤 2/4：对选中的候选继续生成

现在有 5 个候选，需要对每个候选继续生成下一步。让我们看两个最有希望的路径：

路径 A：从 1 + 1 = 2 (left: 2 4 6) 继续

2.1 生成阶段：从状态 2 4 6 生成可能的操作

1- 2 * 4 = 8 (left: 8 6)
2- 4 * 6 = 24 (left: 2 24)
3- 2 + 4 = 6 (left: 6 6)
4- 2 + 6 = 8 (left: 4 8)
5...
6

2.2 评估阶段：

1候选: 4 * 6 = 24 (left: 2 24)
2评估: sure (20.0)  # 已经得到 24，只需要用 2 保持 24
3
4候选: 2 * 4 = 8 (left: 8 6)
5评估: likely (1.0)  # 可能，但不如上面的好
6

2.3 选择阶段：选择 4 * 6 = 24 (left: 2 24) [价值: 20.0]

路径 B：从 4 * 6 = 24 (left: 1 1 24) 继续

2.1 生成阶段：从状态 1 1 24 生成可能的操作

1- 24 / 1 = 24 (left: 1 24)
2- 24 * 1 = 24 (left: 1 24)
3- 1 + 1 = 2 (left: 2 24)
4- 1 * 1 = 1 (left: 1 24)
5...
6

2.2 评估阶段：

1候选: 24 / 1 = 24 (left: 1 24)
2评估: sure (20.0)  # 已经得到 24，只需要用最后一个 1 保持 24
3
4候选: 1 + 1 = 2 (left: 2 24)
5评估: likely (1.0)  # 可能，但不如上面的好
6

2.3 选择阶段：选择 24 / 1 = 24 (left: 1 24) [价值: 20.0]

步骤 3/4：继续搜索

路径 A：从 2 24 继续

3.1 生成阶段：从状态 2 24 生成可能的操作

1- 24 / 2 = 12 (left: 12)
2- 2 * 24 = 48 (left: 48)
3- 24 - 2 = 22 (left: 22)
4...
5

3.2 评估阶段：这些操作都无法得到 24，价值分数都很低（0.001）

路径 B：从 1 24 继续 ✅

3.1 生成阶段：从状态 1 24 生成可能的操作

1- 24 * 1 = 24 (left: 24)
2- 24 / 1 = 24 (left: 24)
3...
4

3.2 评估阶段：

1候选: 24 * 1 = 24 (left: 24)
2评估: sure (20.0)  # 完美！已经得到 24，且使用了所有数字
3

3.3 选择阶段：选择 24 * 1 = 24 (left: 24) ✅

步骤 4/4：生成最终答案

当前状态：24（只剩下一个数字，且等于 24）

4.1 生成阶段：模型需要生成完整的答案表达式

4.2 最终答案：

1Steps:
21 + 1 = 2 (left: 2 4 6)
34 * 6 = 24 (left: 2 24)
424 / 2 = 12 (left: 12)  # 注意：这个路径实际上没有成功
5

但实际上，从路径 B 得到的正确答案是：

1Steps:
24 * 6 = 24 (left: 1 1 24)
324 / 1 = 24 (left: 1 24)
424 * 1 = 24 (left: 24)
5Answer: (6 * 4) * 1 * 1 = 24
6

或者更简洁的答案：

1Answer: (6 * 4) / 1 * 1 = 24
2

下面的树状图展示了 ToT 从初始状态到最终答案的完整搜索过程，每个节点表示当前剩余的数字：

1                             1 1 4 6
2                                / \
3                              /     \
4                            /         \
5                          /             \
6                        /                 \
7                      /                     \
8                    /                         \
9                  /                             \
10           1 1 24                               2 4 6
11          (4*6=24)                             (1+1=2)
12            / \                                   / \
13          /     \                               /     \
14        /         \                           /         \
15      /             \                       /             \
16   1 24           2 24                   2 24           8 6
17  (24/1)        (1+1=2)                (4*6=24)        (2*4=8)
18    |              |                      |              |
19    |              └──→ ❌                └──→ ❌        └──→ ❌
20    |
21    └──→ 24 ✅
22      (24*1=24)
23

完整路径总结

成功路径：

1初始: 1 1 4 6
2  ↓
3步骤1: 4 * 6 = 24 (left: 1 1 24) [价值: 20.0] ✓
4  ↓
5步骤2: 24 / 1 = 24 (left: 1 24) [价值: 20.0] ✓
6  ↓
7步骤3: 24 * 1 = 24 (left: 24) [价值: 20.0] ✓
8  ↓
9最终答案: (6 * 4) / 1 * 1 = 24 ✅
10

代码实现

核心函数

让我们看看 ToT 的核心实现：

1def solve(args, task, idx, to_print=True):
2    """使用树搜索（Tree of Thoughts）方法解决问题"""
3    x = task.get_input(idx)  # 获取输入，如 "1 1 4 6"
4    ys = ['']  # 初始候选列表（空字符串表示还未开始）
5    
6    for step in range(task.steps):  # game24 需要 4 步
7        # ========== 第一步：生成（Generation）==========
8        # 对当前每个候选，生成新的候选解决方案
9        if args.method_generate == 'propose':
10            # propose 方法：生成下一步可能的操作（多个候选）
11            new_ys = [get_proposals(task, x, y) for y in ys]
12        elif args.method_generate == 'sample':
13            # sample 方法：直接生成完整或部分解决方案
14            new_ys = [get_samples(task, x, y, ...) for y in ys]
15        
16        # 将嵌套列表展平（因为每个 y 可能生成多个 new_ys）
17        new_ys = list(itertools.chain(*new_ys))
18        
19        # ========== 第二步：评估（Evaluation）==========
20        # 对生成的所有候选进行评估，得到价值分数
21        if args.method_evaluate == 'value':
22            # 价值方法：单独评估每个候选的价值
23            values = get_values(task, x, new_ys, ...)
24        elif args.method_evaluate == 'vote':
25            # 投票方法：将所有候选一起展示，让模型投票
26            values = get_votes(task, x, new_ys, ...)
27        
28        # ========== 第三步：选择（Selection）==========
29        # 根据评估分数选择最有希望的候选
30        if args.method_select == 'greedy':
31            # 贪心方法：直接选择价值分数最高的前 N 个
32            select_ids = sorted(range(len(new_ys)), 
33                              key=lambda i: values[i], 
34                              reverse=True)[:args.n_select_sample]
35        elif args.method_select == 'sample':
36            # 采样方法：按价值分数作为概率进行采样
37            ps = np.array(values) / sum(values)
38            select_ids = np.random.choice(range(len(new_ys)), 
39                                        size=args.n_select_sample, 
40                                        p=ps)
41        
42        select_new_ys = [new_ys[i] for i in select_ids]
43        ys = select_new_ys  # 更新候选列表，进入下一步
44    
45    return ys  # 返回最终候选
46

生成函数示例

1def get_proposals(task, x, y):
2    """使用 propose 方法生成下一步的候选操作"""
3    # 生成提议提示词，要求模型生成可能的下一步操作
4    propose_prompt = task.propose_prompt_wrap(x, y)
5    
6    # 调用 GPT 生成提议
7    raw_output = gpt(propose_prompt, n=1, stop=None)[0]
8    # 输出示例：
9    # "1 + 1 = 2 (left: 2 4 6)\n1 * 1 = 1 (left: 1 4 6)\n4 * 6 = 24 (left: 1 1 24)\n..."
10    
11    # 解析输出，每个提议作为一行
12    proposals = raw_output.split('\n')
13    
14    # 将每个提议追加到当前路径后面
15    return [y + prop + '\n' for prop in proposals if prop.strip()]
16

评估函数

1def get_value(task, x, y, n_evaluate_sample, cache_value=True):
2    """评估单个候选的价值分数"""
3    # 生成评估提示词
4    # 例如：评估 "1 + 1 = 2 (left: 2 4 6)" 这个状态
5    value_prompt = task.value_prompt_wrap(x, y)
6    
7    # 调用 GPT 进行评估（生成 n_evaluate_sample 个评估结果）
8    value_outputs = gpt(value_prompt, n=n_evaluate_sample, stop=None)
9    # 输出示例：
10    # ["sure", "sure", "likely"]  # 3 次评估中有 2 次是 "sure"，1 次是 "likely"
11    
12    # 将文本输出转换为数值分数
13    # "sure" → 20, "likely" → 1, "impossible" → 0.001
14    value = task.value_outputs_unwrap(x, y, value_outputs)
15    # 结果：2 * 20 + 1 * 1 = 41.0
16    
17    return value
18

评估提示词示例

评估中间步骤时，模型会看到：

1Evaluate if given numbers can reach 24 (sure/likely/impossible)
22 4 6
32 * 4 = 8
48 * 6 = 48
5(6 - 2) * 4 = 16
6I cannot obtain 24 now, but numbers are within a reasonable range
7likely
8

评估最后一步时，模型会看到：

1Use numbers and basic arithmetic operations (+ - * /) to obtain 24.
2Given an input and an answer, give a judgement (sure/impossible)
3Input: 1 1 4 6
4Answer: (1 + 1) * (6 * 4 / 2) = 24
5Judge: sure
6

为什么 ToT 有效？

1. 探索更多可能性

传统方法只探索一条路径，ToT 同时探索多条路径，大大提高了找到正确答案的概率。

2. 智能评估

通过让模型评估每个候选的前景，ToT 能够优先探索最有希望的路径，而不是盲目搜索。

3. 可回溯

如果一条路径走不通，ToT 可以回到上一步，选择其他候选，这是传统方法无法做到的。

ToT 的缺点

虽然 ToT 在解决复杂问题方面表现出色，但它也有一些明显的缺点：

1. 计算成本高

  • API 调用次数多：ToT 需要对每个候选进行生成和评估，导致 API 调用次数大幅增加
    • 例如：Game24 任务中，ToT 方法需要 50-100 次 API 调用，而朴素方法只需 1 次
    • 成本可能增加 50-100 倍
  • 响应时间长：由于需要多轮生成、评估、选择，整体响应时间显著增加
    • 不适合需要实时响应的场景

2. 评估质量依赖模型能力

  • 评估准确性：ToT 的效果很大程度上依赖于模型对候选的评估能力
    • 如果模型评估不准确，可能会选择错误的路径
    • 对于模型不熟悉的任务，评估可能不可靠
  • 评估成本：评估阶段本身也需要调用模型，进一步增加成本

3. 搜索空间可能爆炸

  • 候选数量增长：随着搜索深度增加，候选数量可能呈指数级增长
    • 例如：每步选择 5 个候选，4 步后可能产生 5^4 = 625 个候选
  • 需要剪枝策略：必须通过评估和选择来限制搜索空间，否则计算成本无法承受
  • 可能错过最优解：如果剪枝过于激进，可能会错过最优解

4. 不适合所有任务

  • 简单任务：对于简单的一次性问答，ToT 是过度设计
  • 确定性任务：对于有明确答案的任务（如翻译、摘要），ToT 的优势不明显
  • 实时性要求高的任务：不适合需要毫秒级响应的场景

总结

Tree of Thoughts 通过模拟人类的思考过程——生成多个可能、评估前景、选择最优——让大语言模型能够更好地解决复杂问题。

核心优势

  1. 探索性：同时探索多条路径，而不是只走一条路
  2. 智能性：通过评估选择最有希望的路径
  3. 可回溯：如果一条路走不通，可以回到上一步选择其他路径

适用场景总结

✅ 适合的场景：

  • 需要多步推理的复杂问题（如数学题、逻辑推理）
  • 有多个可能路径的搜索问题（如游戏求解、路径规划）
  • 需要评估和选择的创意任务（如创意写作、代码生成）
  • 需要回溯和修正的问题（如错误修复、计划调整）
  • 对准确性要求高的任务（如关键决策、重要计算）

❌ 不适用场景：

  • 简单的一次性问答（用 ToT 是浪费资源）
  • 对实时性要求高的任务（ToT 响应时间长）
  • 对成本敏感的场景（API 调用次数多，成本高）
  • 确定性任务（如翻译、摘要，ToT 优势不明显）
  • 模型不熟悉的任务（评估可能不准确）
  • 搜索空间过大的问题（计算成本无法承受）

《Tree of Thoughts：让大语言模型像人类一样思考》 是转载文章，点击查看原文。

上一篇：水果识别系统【最新版】Python+TensorFlow+Vue3+Django+人工智能+深度学习+卷积神经网络算法

下一篇：🌐 阿里云 Linux 服务器 Let's Encrypt 免费 SSL 证书完整部署指南

相关推荐

win11上wsl本地安装版本ubuntu25.10
Livingbody2025/11/21

1.安装wsl2 dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart wsl --set-default-version 2 2.下载镜像 从163镜像下载 mi

Lua 的 assert 函数
IMPYLH2025/11/19

Lua 的 assert 函数 是一个内置的错误检查函数，主要用于验证条件并在条件不满足时抛出错误。其语法格式为： assert(condition [, error_message]) 参数说明： condition：要检查的条件表达式error_message（可选）：当条件为假时要显示的错误信息 工作原理： 当 condition 为真时，assert 会返回所有传入的参数；当 condition 为假时，assert 会抛出错误。如果提供了 error_message，则使用该

增强现实与物联网融合在智慧城市交通管理中的智能优化应用探索
while(努力):进步2025/11/18

随着智慧城市建设的推进，交通管理系统面临着车辆数量激增、道路资源有限和实时交通信息复杂多变等挑战。传统交通管理依赖摄像头监控、信号灯定时控制和人工调度，已难以满足现代城市对高效、智能、低碳交通的需求。增强现实（AR）技术与物联网（IoT）设备的深度融合，为城市交通管理提供了新的解决方案。通过实时感知、数据分析和可视化指引，交通系统能够实现智能优化与动态决策。 在这一系统中，AR 用于将交通信息以直观可视化形式呈现给管理者或驾驶者，IoT 设备则提供实时路况、车辆定位、空气质量和交通流量等多维数

Python 的内置函数 slice
IMPYLH2025/11/17

Python 内建函数列表 > Python 的内置函数 slice Python 的内置函数 slice() 用于创建切片对象，可以应用于序列类型（如列表、字符串、元组）的切片操作。这个函数提供了一种更灵活的方式来定义切片，特别适合在需要动态生成切片参数的情况下使用。 基本语法 slice(stop) slice(start, stop[, step]) 参数说明 start（可选）：切片的起始索引，默认为 None，表示从序列开头开始。stop：切片的结束索引（不包含该索引对应的

linux上gitlab runner部署文档
艾迪王2025/11/16

2025年11月16日 背景 平常使用的CI/CD主要是用Jenkins，git的本地hook，但是对于代码上传后执行差异代码优化这个技术场景流程场景来说： Jenkins流程只会做到全量排查，如果中途遇到问题代码导致失败，得不偿失，且一个仓库可能会有不再维护代码与无关代码，造成资源浪费 git本地hook问题在于，更新时每个组员都需要做，并且git commit的时候可以通过--no-verify 规避本地check，同时如果直接在gitlab上面IDE直接修改，则本地git hook脚本不

Redis（124）Redis在电商系统中的应用有哪些？
Victor3562025/11/15

在电商系统中，Redis 常常被用来实现高性能和高可用性的一些关键功能。以下是 Redis 在电商系统中的一些常见应用场景，并结合 Java 代码示例来详细介绍这些应用。 1. 商品详情缓存 为了提高商品详情页面的响应速度，通常会将商品详情缓存到 Redis 中，从而减少对数据库的直接访问。 示例代码 import redis.clients.jedis.Jedis; public class ProductCacheExample { public static void main(

限时免费！字节 TRAE SOLO 正式上线，无需邀请码！新增 TRAE Coder（附实测体验）
程序员X小鹿2025/11/13

大家好，我是X小鹿。昨天（11.12），字节的 TRAE SOLO 正式版全面开放，不需要邀请码了，人人可用，而且限时免费！ 11.12 ~ 11.15，所有人都可以免费使用 TRAE SOLO。 SOLO 模式这次也全新升级，除了之前上线的 SOLO Builder 外，这次还新上了 SOLO Coder。 两种 SOLO 模式适合不同的场景，下面详细介绍。 除此之外，新升级的 TRAE SOLO 这次还支持「多任务并行」。 也就是说，可以同时运行多个任务了。每个任务，都有自己的模型和上下文

理解编程范式（前端角度）
颜酱2025/11/12

编程范式（Programming Paradigms）是编程的一种风格或方法，它定义了代码的结构和组织方式。编程范式提供了不同的思考和解决问题的角度，影响着程序员如何编写代码。 常见的前端编程范式包括： 命令式编程（Imperative Programming） 声明式编程（Declarative Programming） 函数式编程（Functional Programming） 面向对象编程（Object-Oriented Programming） 命令式编程（Imperative Pr

为什么在 JavaScript 中 NaN !== NaN？背后藏着 40 年的技术故事
冴羽2025/11/10

1. 前言 初学 JavaScript 的时候，经常会遇到一些令人困惑的现象，比如： console.log(NaN === NaN); // false console.log(NaN !== NaN); // true 为什么一个值会不等于它自己呢？ 今天，我们就来深入探究这个问题。 2. NaN 的本质：一个特殊的“数字” NaN 其实是 Not a Number 的缩写，表示它不是一个数字。但 NaN 的类型却是 number console.log(typeof NaN); // "

自定义instanceof运算符行为API: Symbol.hasInstance
桜吹雪2025/11/8

今天翻zod的源码，发现有个之前没见过的，应该也没听说的API：Symbol.hasInstance export /*@__NO_SIDE_EFFECTS__*/ function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>( name: string, initializer: (inst: T, def: D) => void, params?: { Parent?: typeof Class } ): $con

上一篇：水果识别系统【最新版】Python+TensorFlow+Vue3+Django+人工智能+深度学习+卷积神经网络算法

下一篇：🌐 阿里云 Linux 服务器 Let's Encrypt 免费 SSL 证书完整部署指南

首页编辑器站点地图

本站内容在 CC BY-SA 4.0 协议下发布

Copyright © 2025 聚合阅读