1. 项目概述：为什么我们需要精细的鼠标操作？

在自动化测试和网页数据抓取的世界里，我们常常满足于“点击一下按钮”或“输入一段文字”。但当你面对一个复杂的网页应用时，比如一个在线设计工具、一个游戏化的数据看板，或者一个拖拽式表单构建器，你会发现简单的 click() 和 type() 远远不够。这时，精细的鼠标操作就成了决定成败的关键。

我最近在为一个客户构建一个仪表盘自动化流程时，就遇到了一个典型场景：需要将一个图表组件从一个面板拖拽到另一个面板的特定区域，并且要求拖拽轨迹平滑，不能是瞬间“闪现”过去，否则前端的状态监听器会失效。这就是一个典型的、需要超越基础点击的“精细鼠标操作”场景。Playwright for Python 在这方面提供了强大的底层控制能力，让你能模拟出几乎任何人类可以做出的鼠标动作。

简单来说，Playwright 的鼠标事件 API 让你能控制光标的移动轨迹、按下/释放的时机、滚轮的滚动幅度，甚至模拟鼠标悬停时触发的复杂事件链。这对于测试富交互应用、实现精准的网页自动化，乃至开发一些辅助工具都至关重要。无论你是测试工程师、爬虫开发者，还是RPA流程的设计者，掌握这套工具都能让你的脚本从“能用”升级到“好用且可靠”。

2. 核心鼠标事件API深度解析

Playwright 的鼠标操作主要依赖于 Page 和 Locator 对象的 mouse 属性，它提供了一系列方法来模拟完整的鼠标交互。理解每个方法的含义和适用场景，是进行精细控制的第一步。

2.1 基础动作：点击、双击与右键

最基础的操作莫过于点击。Playwright 提供了 click 方法，但它内部已经封装了移动、按下、释放等一系列事件。对于精细控制，我们需要拆解它。

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=False)
    page = browser.new_page()
    page.goto('https://example.com')

    # 基础点击 - 内部完成了 move, down, up
    page.click('button#submit')

    # 拆解点击：精细控制每一步
    button = page.locator('button#submit')
    # 1. 移动光标到元素中心（默认）
    button.hover()
    # 2. 按下鼠标左键
    page.mouse.down()
    # 3. 释放鼠标左键
    page.mouse.up()

为什么需要拆解？ 在某些场景下，比如你需要测试“按下但未释放”时元素的样式变化（例如一个被按下的按钮状态），或者需要在按下后移动到别处再释放（实现拖拽的起始），拆解操作就变得必要。 click() 方法是一个原子操作，无法插入中间状态。

双击 ( dblclick ) 和右键点击 ( click with button=‘right’ ) 同理。右键点击常用于测试上下文菜单。

# 右键点击
page.click('button#menu', button='right')
# 或者使用 mouse API
page.locator('button#menu').hover()
page.mouse.down(button='right')
page.mouse.up(button='right')

2.2 光标移动：从瞬间闪现到轨迹模拟

mouse.move(x, y) 是控制光标的基石。这里的 x 和 y 是相对于页面视口左上角的像素坐标。直接移动是瞬间完成的，但我们可以通过组合多次 move 来模拟轨迹。

import time

# 获取目标元素的边界框
target_box = page.locator('.drop-zone').bounding_box()
target_x = target_box['x'] + target_box['width'] / 2
target_y = target_box['y'] + target_box['height'] / 2

# 模拟一个简单的线性移动轨迹
steps = 10
start_x, start_y = 100, 100 # 起始坐标
for i in range(steps + 1):
    x = start_x + (target_x - start_x) * (i / steps)
    y = start_y + (target_y - start_y) * (i / steps)
    page.mouse.move(x, y)
    time.sleep(0.05) # 添加微小延迟，模拟人类操作速度

实操心得：轨迹生成的技巧 在实际项目中，瞬间移动（ hover() ）和轨迹移动各有用途。对于简单的悬停触发工具提示，用 hover() 最方便。但对于拖拽操作或需要触发某些基于 mousemove 事件频率的动画，就必须使用轨迹模拟。一个常见的坑是轨迹点太稀疏，导致前端判定为“跳跃”而非“拖动”。我的经验是，对于跨越大半个屏幕的拖拽，至少需要15-20个中间点，并且每个点之间加入10-50毫秒的延迟，这样看起来才自然，也能可靠地触发相关事件。

2.3 按下与释放：控制交互状态

mouse.down() 和 mouse.up() 分别模拟鼠标按键按下和释放。它们可以指定按键（ left , right , middle ）。

# 模拟鼠标中键点击（常用于打开新标签页）
page.locator('a.link').hover()
page.mouse.down(button='middle')
page.mouse.up(button='middle')

这两个方法的核心价值在于创建“持续按下”的状态。最常见的应用就是拖拽：

  1. mouse.move() 到元素A上。
  2. mouse.down() 按下。
  3. mouse.move() 移动光标到元素B（期间鼠标保持按下状态）。
  4. mouse.up() 在元素B上释放。

这样就完成了一次拖放（Drag and Drop）。Playwright 虽然也提供了 drag_to 方法，但在复杂场景（如需要自定义轨迹、在特定坐标释放）下，手动控制 down 、 move 、 up 是更灵活的选择。

2.4 滚轮滚动：精准控制页面视图

mouse.wheel(delta_x, delta_y) 用于模拟滚轮滚动。 delta_x 控制水平滚动， delta_y 控制垂直滚动（正值向下，负值向上）。这个操作不是瞬间跳转，而是触发一个滚动事件。

# 向下滚动300像素
page.mouse.wheel(0, 300)
# 向上滚动150像素
page.mouse.wheel(0, -150)
# 水平向右滚动（适用于有横向滚动条的页面）
page.mouse.wheel(100, 0)

注意事项：滚动与视口 wheel 滚动的是当前光标位置所在的可滚动区域。如果光标在一个 div 滚动框内，则滚动该 div ；否则滚动整个页面。因此，为了确保滚动页面，最好先将光标移动到页面主体区域（如坐标 (10,10) ）。另外，一些网站使用了自定义的滚动监听（如无限加载），直接滚动视口可能不触发加载，这时可能需要通过 page.evaluate() 执行JavaScript来滚动特定元素。

3. 高级组合应用与实战场景

掌握了基础API后，我们可以将它们组合起来，解决实际的复杂交互问题。

3.1 实现复杂的拖拽操作

这是精细鼠标操作的王牌应用。假设我们要将一个元素拖入一个嵌套的、需要展开的文件夹中。

def drag_file_to_nested_folder(page, file_selector, folder_selector):
    """将文件拖拽到需要悬停展开的嵌套文件夹"""
    file = page.locator(file_selector)
    folder = page.locator(folder_selector)

    # 获取元素位置
    file_box = file.bounding_box()
    folder_box = folder.bounding_box()

    # 1. 移动到文件上并按下
    page.mouse.move(file_box['x'] + 10, file_box['y'] + 10) # 偏移10像素，更符合实际点击
    page.mouse.down()

    # 2. 缓慢移动到文件夹所在区域
    move_with_trajectory(page, file_box, folder_box)

    # 3. 关键步骤：在文件夹上悬停一段时间，触发其展开动画或状态
    page.mouse.move(folder_box['x'], folder_box['y'])
    page.wait_for_timeout(500) # 等待500ms，让前端完成展开逻辑

    # 4. 可能需要再次微调位置，移动到展开后的子文件夹区域
    # 这里假设子文件夹出现在下方50像素处
    sub_folder_y = folder_box['y'] + folder_box['height'] + 50
    page.mouse.move(folder_box['x'], sub_folder_y)

    # 5. 释放鼠标完成拖放
    page.mouse.up()

    print("拖拽操作完成。")

def move_with_trajectory(page, start_box, end_box):
    """生成并执行一条贝塞尔曲线轨迹（简化版线性模拟）"""
    start_x = start_box['x'] + start_box['width']/2
    start_y = start_box['y'] + start_box['height']/2
    end_x = end_box['x'] + end_box['width']/2
    end_y = end_box['y'] + end_box['height']/2

    steps = 20
    for i in range(steps + 1):
        ratio = i / steps
        # 简单的线性插值，更逼真可以用贝塞尔曲线计算
        x = start_x + (end_x - start_x) * ratio
        y = start_y + (end_y - start_y) * ratio
        page.mouse.move(x, y)
        page.wait_for_timeout(30) # 控制移动速度

场景解析 ：这个例子模拟了操作系统文件管理器中的常见交互。难点在于“悬停展开”这个中间状态。如果直接用 drag_to 方法，光标会直接穿过文件夹元素，没有停留，无法触发悬停事件。手动控制移动和等待，完美解决了这个问题。

3.2 绘制与签名模拟

在一些在线白板或签名应用中，需要模拟手绘路径。这本质上是一系列快速的 mouse.move 事件，且中间鼠标始终保持按下状态。

def simulate_drawing(page, canvas_selector, path_points):
    """在画布上模拟绘制路径
    path_points: 列表，包含多个 (x, y) 元组，坐标相对于画布
    """
    canvas = page.locator(canvas_selector)
    canvas_box = canvas.bounding_box()

    # 移动到画布并按下鼠标（开始绘画）
    page.mouse.move(canvas_box['x'] + path_points[0][0], canvas_box['y'] + path_points[0][1])
    page.mouse.down()

    # 依次连接路径点
    for point in path_points[1:]:
        absolute_x = canvas_box['x'] + point[0]
        absolute_y = canvas_box['y'] + point[1]
        page.mouse.move(absolute_x, absolute_y)
        # 点与点之间极短的延迟，模拟连续绘制
        page.wait_for_timeout(20)

    # 抬起鼠标（结束绘画）
    page.mouse.up()

核心要点 ：绘制模拟的质量取决于路径点的密度和移动延迟。点越密，延迟越小，线条越平滑。你可以从真实的鼠标事件记录中获取路径点，或者使用算法（如贝塞尔曲线）生成平滑路径。

3.3 处理鼠标悬停触发的动态内容

很多网站的菜单、工具提示是在鼠标悬停（ hover ）时动态加载和显示的。测试这类功能需要精确控制悬停时机和断言动态内容。

# 使用 locator.hover() 是最简单的方式
tooltip_trigger = page.locator('.info-icon')
tooltip_trigger.hover()
# 等待工具提示内容出现
tooltip = page.locator('.tooltip-content')
tooltip.wait_for(state='visible')
assert tooltip.inner_text() == '这是提示信息'

# 更精细的控制：使用 mouse.move 并停留在元素上
box = tooltip_trigger.bounding_box()
center_x = box['x'] + box['width'] / 2
center_y = box['y'] + box['height'] / 2
page.mouse.move(center_x, center_y)
# 等待网络请求或DOM更新（如果悬停触发异步加载）
page.wait_for_timeout(1000) # 或使用 page.wait_for_response/selector

避坑指南 ： locator.hover() 内部会确保元素滚动到视口并移动到元素中心。但在某些极端复杂的页面布局下，它可能失效。如果遇到 hover() 不触发动态内容的情况，回退方案是使用 mouse.move() 并计算一个精确的坐标，同时结合 page.wait_for_function 来等待特定的前端状态变化。

4. 坐标计算与元素定位的精准之道

所有精细鼠标操作都依赖于准确的坐标。Playwright 提供了多种获取坐标的方式，选择哪一种取决于你的具体需求。

4.1 获取元素位置： bounding_box() 与 evaluate()

locator.bounding_box() 是最常用的方法，它返回一个字典，包含元素相对于页面的 x , y 坐标以及 width , height 。

element = page.locator('#myElement')
box = element.bounding_box()
if box: # 元素可能隐藏，返回None
    center_x = box['x'] + box['width'] / 2
    center_y = box['y'] + box['height'] / 2
    top_left = (box['x'], box['y'])
    bottom_right = (box['x'] + box['width'], box['y'] + box['height'])

注意事项 ： bounding_box() 获取的是元素整体的边界框。如果元素形状不规则（如一个带三角形的对话框），或者你想点击某个特定子区域（如图标内的某个像素），就需要更精细的计算。这时可以结合 evaluate() 方法，使用浏览器内的 JavaScript 来获取更精确的几何信息。

# 获取元素内某个特定子元素的位置
icon_position = page.locator('#myElement .inner-icon').evaluate('(el) => {
    const rect = el.getBoundingClientRect();
    return {x: rect.x, y: rect.y, width: rect.width, height: rect.height};
}')
# 注意：evaluate返回的坐标是相对于视口的，需要加上页面滚动偏移量
scroll_x = page.evaluate('window.scrollX')
scroll_y = page.evaluate('window.scrollY')
absolute_x = icon_position['x'] + scroll_x
absolute_y = icon_position['y'] + scroll_y

4.2 相对坐标与偏移量计算

我们很少直接点击元素的绝对中心。比如点击一个复选框，通常是点击其左上角的小方框；点击一个可拖拽元素的拖拽手柄，而不是中心。

def click_checkbox_corner(page, checkbox_selector):
    """点击复选框的左上角区域（大约偏移5像素）"""
    box = page.locator(checkbox_selector).bounding_box()
    if box:
        offset_x = 5
        offset_y = 5
        target_x = box['x'] + offset_x
        target_y = box['y'] + offset_y
        page.mouse.move(target_x, target_y)
        page.mouse.down()
        page.mouse.up()

def drag_by_handle(page, item_selector, handle_selector):
    """通过拖拽手柄移动元素"""
    item = page.locator(item_selector)
    handle = page.locator(handle_selector)

    handle_box = handle.bounding_box()
    item_box = item.bounding_box()

    # 计算手柄相对于物品的偏移（通常在物品内部）
    # 这里假设手柄在物品顶部中央
    handle_offset_x = handle_box['x'] - item_box['x'] + handle_box['width']/2
    handle_offset_y = handle_box['y'] - item_box['y'] + 5 # 向下偏移5像素

    # 在手柄位置按下
    page.mouse.move(item_box['x'] + handle_offset_x, item_box['y'] + handle_offset_y)
    page.mouse.down()

    # 移动整个物品（计算目标位置时，需考虑手柄偏移）
    target_x = 500
    target_y = 300
    page.mouse.move(target_x - handle_offset_x, target_y - handle_offset_y)
    page.mouse.up()

计算逻辑 ：这段代码的精髓在于 handle_offset_x/y 。它记录了拖拽点（手柄）相对于被拖拽元素左上角的位置。在移动时，我们需要用目标坐标减去这个偏移量，才能保证拖拽过程中，鼠标相对于元素的位置保持不变，模拟出真实的物理拖拽感。这是实现完美拖拽体验的关键。

5. 调试技巧与常见问题排查实录

即使理论清晰，在实际编码中依然会遇到各种诡异的问题。下面是我在多个项目中总结的常见坑点和排查方法。

5.1 问题一：鼠标事件没有触发前端响应

这是最令人头疼的问题。现象是脚本执行了 move 、 click ，但页面上毫无反应。

排查步骤：

  1. 确认元素状态 ：首先，确保目标元素是可见、可交互的。使用 locator.wait_for(state=‘visible’) 或 locator.is_visible() 。注意， visible 在 Playwright 中意味着元素有非零面积且未被CSS隐藏。但元素可能被其他层（如遮罩）覆盖。
  2. 检查元素覆盖 ：使用开发者工具检查目标元素上方是否有透明的 div 或其他元素遮挡。Playwright 的点击默认会检查可操作性（hit-test）。你可以通过 force=True 参数强制点击，但这可能绕过前端逻辑，需谨慎。 
    page.click('button', force=True) # 强制点击，不进行可操作性检查
  3. 验证坐标准确性 ：在非无头模式下运行脚本 ( headless=False )，观察鼠标光标是否真的移动到了预期位置。可能因为页面缩放、动态布局导致坐标计算错误。
  4. 监听前端事件 ：在浏览器开发者工具的 Console 中，手动执行一段监听代码，看事件是否被触发。 
    // 在浏览器Console执行
document.querySelector('button').addEventListener('mousedown', (e) => console.log('mousedown at', e.clientX, e.clientY));
document.querySelector('button').addEventListener('click', () => console.log('click fired'));
    然后运行你的Playwright脚本，观察Console是否有输出。如果没有，说明事件根本没派发到那个元素上。
  5. 尝试不同的触发方式 ：有些前端框架（如React）可能依赖特定的事件序列或属性。尝试用 page.evaluate() 直接执行元素的 click() 方法。 
    page.evaluate('document.querySelector("button").click()')
    如果这样能成功，说明是模拟事件与框架期望的事件细节有差异。

5.2 问题二：拖拽操作不流畅或中途失效

表现为元素拖到一半就掉了，或者根本没开始拖。

排查与解决：

  1. 轨迹速度过快 ：这是最常见的原因。前端可能通过计算 mousemove 事件的时间间隔来判断是否是“有效拖拽”。在 move 步骤之间添加 page.wait_for_timeout(20~50) 。
  2. 缺少中间事件 ：标准的拖拽需要 mousedown -> mousemove (多次) -> mouseup 。确保 mousedown 之后，在移动光标之前，没有意外的 mouseup 或其他中断操作。
  3. 拖拽源或目标限制 ：检查元素是否有 draggable=“true” 属性。对于HTML5原生拖放，可能需要设置这个属性。或者，前端可能监听的是自定义的拖拽类，而非原生事件。
  4. 使用 page.drag_and_drop 作为基线 ：先尝试使用 Playwright 内置的 page.drag_and_drop(source, target) 。如果它能成功，说明你的手动模拟可能在事件细节上有出入。然后以它为基准，对比你手动模拟的事件序列。

5.3 问题三：在iframe或Shadow DOM内的操作

鼠标事件无法直接穿透 iframe 或 Shadow DOM 边界。你必须先定位到正确的上下文。

对于 iframe： 

# 定位iframe元素
frame = page.frame_locator('iframe#myFrame')
# 在iframe的上下文中操作
frame.locator('button').click()
# 鼠标事件也需要在frame上下文中进行？实际上，Playwright的鼠标API是页面全局的。
# 但坐标计算必须基于主页面视口。更安全的方式是使用frame内的locator的hover/click方法。
frame.locator('.drag-item').hover()
page.mouse.down() # 这个mouse是主page的，但事件会发生在当前聚焦的元素上（即iframe内的元素）
# 复杂的操作建议全部使用frame的locator方法

对于 Shadow DOM： 

# 通过 `>>` (即 `:light` 选择器的替代，更推荐) 或 CSS `:shadow` 穿透
# 方法1：使用 `>>` (piercing selector)
page.locator('my-custom-element >> .internal-button').click()

# 方法2：使用 `element_handle.evaluate` 在元素内部执行JS
element_handle = page.locator('my-custom-element').element_handle()
button = element_handle.evaluate_handle('(el) => el.shadowRoot.querySelector(".internal-button")')
button.click() # 注意，这样获取的handle可能无法直接使用Playwright的locator API，可能需要继续用evaluate

在 Shadow DOM 内进行精细鼠标操作非常复杂，通常建议让前端开发为测试暴露一些属性或方法，或者尽量通过公开的组件接口来操作，而非穿透 Shadow DOM。

5.4 实用调试脚本

将以下代码片段融入你的脚本，可以在关键步骤截图并打印坐标，极大提升调试效率。

def debug_mouse_action(page, action_name):
    """调试函数：截图并打印当前鼠标位置"""
    import os
    debug_dir = 'playwright_debug'
    os.makedirs(debug_dir, exist_ok=True)
    # 截图
    screenshot_path = os.path.join(debug_dir, f'{action_name}_{int(time.time())}.png')
    page.screenshot(path=screenshot_path, full_page=True)
    print(f'[Debug] Action: {action_name}. Screenshot saved to {screenshot_path}')
    # 尝试获取鼠标位置（需要通过JS，因为Playwright不直接暴露）
    cursor_pos = page.evaluate('''() => {
        return { x: window.__playwrightMouseX || 0, y: window.__playwrightMouseY || 0 };
    }''')
    print(f'[Debug] Cursor position (approx): {cursor_pos}')

# 在每次关键的 mouse.move 前，可以通过注入JS来记录（近似值）
page.evaluate('''() => {
    document.addEventListener('mousemove', (e) => {
        window.__playwrightMouseX = e.clientX;
        window.__playwrightMouseY = e.clientY;
    });
}''')

# 使用示例
page.mouse.move(100, 100)
debug_mouse_action(page, 'move_to_100_100')

6. 性能优化与最佳实践

当需要执行大量或高频的鼠标操作时，性能和稳定性就成为考量重点。

6.1 减少不必要的操作与等待

  • 批量执行 ：如果一系列操作不依赖中间状态，应尽量减少 wait_for_timeout 的使用。对于纯视觉动画，可以考虑用 page.wait_for_function 等待某个DOM属性变化，而不是固定等待。
  • 避免重复定位 ：将频繁使用的 Locator 对象存储在变量中。 
    # 不佳
page.mouse.move(page.locator('#item1').bounding_box()['x'], ...)
page.locator('#item1').click()
# 更佳
item1 = page.locator('#item1')
box = item1.bounding_box()
page.mouse.move(box['x'], ...)
item1.click()
  • 谨慎使用 force ： force=True 虽然能绕过可操作性检查，但也可能绕过前端的重要业务逻辑（如验证、埋点），导致测试不真实或功能缺陷被掩盖。

6.2 编写健壮的操作函数

将通用的精细操作封装成函数，并加入重试和错误处理机制。

from typing import Tuple, Optional
from playwright.sync_api import Page, Locator, TimeoutError

def robust_drag_and_drop(
    page: Page,
    source: Locator,
    target: Locator,
    max_attempts: int = 3,
    source_offset: Tuple[int, int] = (None, None), # (x_offset, y_offset) 相对于源元素中心
    target_offset: Tuple[int, int] = (None, None)  # (x_offset, y_offset) 相对于目标元素中心
) -> bool:
    """
    一个健壮的拖拽函数，支持偏移和自动重试。
    返回是否成功。
    """
    for attempt in range(max_attempts):
        try:
            # 计算源坐标
            source_box = source.bounding_box()
            if not source_box:
                raise ValueError("Source element not found or invisible")
            src_x = source_box['x'] + source_box['width']/2 + (source_offset[0] or 0)
            src_y = source_box['y'] + source_box['height']/2 + (source_offset[1] or 0)

            # 计算目标坐标
            target_box = target.bounding_box()
            if not target_box:
                raise ValueError("Target element not found or invisible")
            tgt_x = target_box['x'] + target_box['width']/2 + (target_offset[0] or 0)
            tgt_y = target_box['y'] + target_box['height']/2 + (target_offset[1] or 0)

            # 执行拖拽
            page.mouse.move(src_x, src_y)
            page.mouse.down()
            # 添加轨迹点
            steps = 15
            for i in range(1, steps + 1):
                ratio = i / steps
                mid_x = src_x + (tgt_x - src_x) * ratio
                mid_y = src_y + (tgt_y - src_y) * ratio
                page.mouse.move(mid_x, mid_y)
                page.wait_for_timeout(20)
            page.mouse.up()

            # 简单的成功验证：等待目标区域出现某种变化（根据实际情况调整）
            page.wait_for_timeout(300)
            # 例如，检查目标元素是否有特定类名
            # if target.get_attribute('class').contains('dropped'):
            #     return True
            return True

        except (TimeoutError, AssertionError, ValueError) as e:
            print(f"拖拽尝试 {attempt + 1} 失败: {e}")
            if attempt == max_attempts - 1:
                return False
            page.wait_for_timeout(500) # 失败后等待一会儿再重试
    return False

这个函数提供了偏移控制、自动重试和基本的错误处理，可以直接应用到项目中，显著提高拖拽相关自动化脚本的稳定性。

6.3 与异步操作和网络请求的协调

鼠标操作常常会触发网络请求（如保存、加载更多）或异步UI更新。必须在关键操作后等待这些副作用完成。

# 不好的做法：点击后立即断言
page.locator('button.save').click()
assert page.locator('.success-message').is_visible() # 可能因网络延迟失败

# 好的做法：等待明确的信号
with page.expect_response('**/api/save') as response_info: # 等待特定网络请求
    page.locator('button.save').click()
response = response_info.value
assert response.ok()

# 或者等待UI状态
page.locator('button.save').click()
page.locator('.success-message').wait_for(state='visible', timeout=10000)

# 对于复杂的、由鼠标移动触发的异步加载（如无限滚动）
last_item_count = page.locator('.list-item').count()
while True:
    # 滚动到列表底部
    page.mouse.wheel(0, 500)
    # 等待可能的新内容加载
    page.wait_for_timeout(1000)
    new_item_count = page.locator('.list-item').count()
    if new_item_count == last_item_count:
        break # 没有新内容加载，停止滚动
    last_item_count = new_item_count

核心原则 ：不要让脚本的运行速度超过前端应用的反应速度。在每次可能改变应用状态的操作（点击、拖拽、滚动）之后，都要等待一个明确的、可观测的结果（元素出现、消失、属性变化、网络请求完成），而不是使用固定的 time.sleep 。

Logo
AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

cover

agent面试必备40-AI Agent 核心架构：会话摘要与压缩（Memory Compression）

avatar AI Agent技术社区
cover

鸿蒙HarmonyOS 多模态输入实战 —— 图片与文档输入智谱/DeepSeek

avatar AI Agent技术社区

SERP API vs Web Search API for AI Agents:选哪个?

背景做 AI agent 时,需要"实时搜索"能力。我做了 4 周实测,对比 5 维度,给 AI agent 选型参考。

avatar AI Agent技术社区