如何在Python Playwright中同时定位元素并根据先找到的元素执行后续操作？

当然可以实现啦！Playwright虽然默认的定位器是阻塞式的，但我们可以通过并发等待的方式，让程序同时监听两个元素，哪个先出现就触发对应的操作。下面分异步和同步两种常用场景给你具体讲讲：

一、异步模式（推荐，效率更高） #

异步模式下我们可以借助Python的asyncio库来并发等待两个元素的出现，哪个先完成就先处理哪个，代码示例如下：

import asyncio
from playwright.async_api import async_playwright

async def main():
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=False)
        page = await browser.new_page()
        await page.goto("你的目标网址")
        
        # 定义需要监听的两个元素选择器
        target_selector1 = "#element-one"
        target_selector2 = ".element-two-class"
        
        # 为两个元素分别创建等待任务
        wait_task1 = page.locator(target_selector1).wait_for()
        wait_task2 = page.locator(target_selector2).wait_for()
        
        # 等待第一个完成的任务，忽略未完成的
        done_tasks, pending_tasks = await asyncio.wait(
            [wait_task1, wait_task2],
            return_when=asyncio.FIRST_COMPLETED
        )
        
        # 取消未完成的任务，避免资源占用
        for task in pending_tasks:
            task.cancel()
        
        # 根据完成的任务判断哪个元素先出现，执行对应操作
        if wait_task1 in done_tasks:
            print("第一个元素先出现啦！执行对应操作")
            await page.locator(target_selector1).click()
            # 这里可以添加更多针对该元素的操作
        elif wait_task2 in done_tasks:
            print("第二个元素先出现啦！执行对应操作")
            await page.locator(target_selector2).fill("需要输入的内容")
            # 这里可以添加更多针对该元素的操作
        
        await browser.close()

asyncio.run(main())

这个方法是真正的并发等待，不会浪费时间在轮询上，效率最高，推荐在异步项目中使用。

二、同步模式（适合习惯同步编程的场景） #

如果你的项目用的是Playwright的同步API，我们可以通过短超时轮询的方式来模拟“同时监听”的效果，代码示例如下：

from playwright.sync_api import sync_playwright, TimeoutError

def main():
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()
        page.goto("你的目标网址")
        
        target_selector1 = "#element-one"
        target_selector2 = ".element-two-class"
        found_selector = None
        # 设置总等待超时时间，比如10秒
        total_wait_timeout = 10000
        start_time = page.evaluate("Date.now()")
        
        # 循环轮询两个元素，直到找到其中一个或超时
        while page.evaluate("Date.now()") - start_time < total_wait_timeout:
            try:
                # 尝试等待第一个元素，超时时间设短一点（比如500毫秒）
                page.locator(target_selector1).wait_for(timeout=500)
                found_selector = target_selector1
                break
            except TimeoutError:
                pass
            
            try:
                # 尝试等待第二个元素，同样用短超时
                page.locator(target_selector2).wait_for(timeout=500)
                found_selector = target_selector2
                break
            except TimeoutError:
                pass
        
        # 根据找到的元素执行对应操作
        if found_selector == target_selector1:
            print("第一个元素先出现，执行操作")
            page.locator(target_selector1).click()
        elif found_selector == target_selector2:
            print("第二个元素先出现，执行操作")
            page.locator(target_selector2).fill("需要输入的内容")
        else:
            print("超时啦，两个元素都没找到")
        
        browser.close()

main()

这种方式是通过不断短时间尝试等待两个元素来模拟并发，虽然效率比异步模式稍低，但能完美适配同步编程的场景。

一些注意事项 #

• 不管用哪种方式，都要合理设置总超时时间，避免程序无限期等待
• 异步模式下一定要记得取消未完成的任务，避免不必要的资源占用
• 选择器要尽量精准，避免出现误匹配的情况

内容来源于stack exchange