Browserautomatisering i Python: Playwright, Selenium & Mer

Jämförelse mellan Python-baserad webbläsarautomatisering och E2E-testning.

Sidinnehåll

Välj rätt webbläsarautomatiseringsstack i Python påverkar hastighet, stabilitet och underhåll. Den här översikten jämför Playwright vs Selenium vs Puppeteer vs LambdaTest vs ZenRows vs Gauge - med fokus på Python, medan det noteras var Node.js eller andra språk passar in.

Playwright trace viewer Här har vi en skärmbild av Playwright trace viewer

När att använda vilken

Playwright (Python)
Playwright är en öppen källkodswebbläsarautomatiseringsbibliotek från Microsoft. Den kommunicerar med Chromium, Firefox och WebKit via Chrome DevTools Protocol (CDP) eller WebSocket, så du får en API över alla tre motorerna. Den kommer med auto-väntande: innan varje åtgärd (klicka, fyll i osv.) väntar den på att elementet är synligt, stabilt och åtgärdsbar, vilket minskar osäkerhet och behovet av manuell sleep eller WebDriverWait. Inställning är minimal (pip install playwright sedan playwright install), och den Python API är första klass (synkron och asynkron). Använd den för nya E2E-testuppsättningar, skript eller automatisering (t.ex. bygga MCP-servrar i Python som driver en webbläsare). För en komplett genomgång med Python, JavaScript och TypeScript-exempel, se Playwright: Web Scraping & Testing. Kombinera den med enhets-testning i Python för resten av din app och använd Playwright endast för webbläsarlager. Nackdelar: nyare än Selenium, så färre tredjepartsintegreringar och mindre äldre material; ingen officiell stöd för mycket gamla webbläsare.

Selenium (Python)
Selenium är det längevarande standarden för webbläsarautomatisering. Selenium Project (öppen källkod, stödd av OpenJS Foundation) ger WebDriver API: du skickar kommandon till en webbläsarspecifikt drivrutin (ChromeDriver, GeckoDriver osv.), som pratar med den verkliga webbläsaren. Selenium stöder många språk (Python, Java, C#, JavaScript osv.) och den bredaste omfattningen av webbläsare, inklusive äldre. Selenium 4+ inkluderar Selenium Manager, så du behöver inte ladda ner eller sökväg för drivrutinbinärer manuellt – klienten hämtar rätt drivrutin för dig. API:n gör inte auto-väntande; du använder vanligtvis WebDriverWait och förväntade villkor för att undvika osäkra tester. Använd Selenium när du underhåller befintliga WebDriver-uppsättningar, behöver den bredaste ekosystemet och språkstöd eller måste stödja äldre webbläsare. Den passar Python designmönster för ren arkitektur när du omgärdar drivrutinen bakom en liten adapter. Nackdelar: generellt långsammare och mer spröd än Playwright utan noggrann väntestrategi; mer upprepning.

Puppeteer
Puppeteer är Googles Node.js-bibliotek för att styra headless Chrome/Chromium (och Chromium-baserad Edge). Den använder Chrome DevTools Protocol direkt och är den de facto valen för JavaScript/TypeScript-teams som gör Chrome-endast automatisering, PDF-generering eller skrapning i Node. Det finns ingen officiell Python-bindning; API:n är endast för Node. Om din stack är Python, använd Playwright (samma “CDP-kontroll” idé med första klass Python) eller Selenium. Om du är i Node.js och endast behöver Chromium, är Puppeteer ett starkt och väl dokumenterat alternativ. Nackdelar: endast Chrome/Chromium; inga Firefox eller WebKit; inget Python.

LambdaTest
LambdaTest är en kommersiell molntestplattform. Du håller på att skriva samma Selenium eller Playwright (eller Cypress osv.) skript lokalt, men istället för att starta en lokal webbläsare ansluter du till LambdaTest:s nätverk. De tillhandahåller verkliga webbläsare och verkliga enheter (inklusive mobil) i molnet, så du kan köra tester parallellt över många OS/webbläsar/versionskombinationer utan att behöva underhålla ditt eget labb. Du får en dashboard för resultat, videor och loggar. Använd den när du behöver tvärvägsöversikt, parallell exekvering på stora skala, eller mobil emulering och inte vill värd infrastrukturen. Den stöder också Gauge: du kör dina Gauge-specifikationer på deras Selenium-nätverk. Nackdelar: betald (med gratisnivåer); tester körs över nätverket så latens och tillgänglighet beror på deras tjänst.

ZenRows
ZenRows är en kommersiell webbskrapning och anti-detection-tjänst. Dess Skrapningswebbläsare är en molnwebbläsare du kontrollerar via Playwright (eller andra CDP-kompatibla verktyg): du ansluter ditt skript till en WebSocket-slutpunkt och webbläsaren körs på ZenRows sida med fastnät, IP-rotation, anti-bot-överföring (t.ex. Cloudflare, DataDome) och valfri CAPTCHA-hantering. Du ändrar inte din Playwright-logik – endast webbläsarens slutpunkt. Använd den när din mål är skrapning och du träffar block eller ratelimit; för enkla E2E-testning på din egen app är lokalt Playwright eller Selenium vanligtvis tillräckligt. Nackdelar: betald; riktad mot skrapning, inte allmän testnätverk som LambdaTest.

Gauge
Gauge är en öppen källkodstestramverk från Thoughtworks. Den fokuserar på specifikationer och rapportering: du skriver specifikationer i Markdown (eller andra format) med scenarier och steg, och implementerar stegen i Python (eller Java, JavaScript osv.) med hjälp av Selenium – eller någon annan drivrutin – för att styra webbläsaren. Gauge ersätter inte Selenium eller Playwright; den sitter ovanpå dem och lägger till struktur, återanvändning och läsbara rapporter. Använd den när du vill ha BDD-stil specifikationer, levande dokumentation och tydliga testrapporter över din befintliga Selenium (eller liknande) konfiguration. LambdaTest stöder att köra Gauge-test på deras nätverk. Nackdelar: extra lager att lära sig och underhålla; du måste fortfarande välja och konfigurera en webbläsarautomatiseringsdrivrutin (t.ex. Selenium).

Var de kör

  • Playwright: Lokalt eller CI; Python 3.8+; Windows, macOS, Linux. Fungerar också med moln/webbläsare (t.ex. ZenRows, LambdaTest) genom att ansluta till en WebSocket eller CDP-slutpunkt.
  • Selenium: Lokalt eller CI; något språk med en WebDriver-klient; Selenium Grid eller en leverantör som LambdaTest för skalning.
  • Puppeteer: Endast Node.js; vanligtvis Chrome/Chromium på maskinen eller i Docker.
  • LambdaTest: Endast moln; du kör Selenium/Playwright (eller Gauge över Selenium) mot deras nätverk.
  • ZenRows: Moln Skrapningswebbläsare; du driver den från Python (t.ex. Playwright) eller andra CDP-kompatibla verktyg.
  • Gauge: Kör på din maskin eller CI; använder Selenium (eller någon annan drivrutin) underifrån; kan rikta mot LambdaTest:s nätverk.

För en snabb referens av Python-ekosystemtrender, se topp 17 populära Python-projekt på GitHub.

Hur du använder dem i Python

Playwright (Python)

Playwrights Python-paket tillhandahåller både synkrona och asynkrona API:er. Webbläsare installeras separat så biblioteket hålls litet och du kan välja endast de motorer du behöver (Chromium, Firefox, WebKit). Installera och installera webbläsare:

pip install playwright
playwright install

Synkron exempel (navigera, klicka, läs text – Playwright auto-väntar på element):

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.goto("https://example.com")
    print(page.title())
    # Klicka länk, sedan kontrollera rubrik (auto-väntar är inbyggt)
    page.get_by_role("link", name="Mer information...").click()
    heading = page.get_by_role("heading", name="Exempeldomän").text_content()
    print(heading)
    browser.close()

Asynkron är rekommenderad för samtid och passar LLM-strukturerad utdataarbetsflöde eller skript som gör I/O medan webbläsaren kör:

from playwright.async_api import async_playwright
import asyncio

async def main():
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page()
        await page.goto("https://example.com")
        print(await page.title())
        await browser.close()

asyncio.run(main())

För en Python cheat sheet och syntaxreferens, ha en lokal dokumentation tillgänglig.

Selenium (Python)

Python-klienten använder W3C WebDriver-protokollet. Selenium 4+ använder Selenium Manager för att ladda ner och hantera rätt drivrutin (ChromeDriver, GeckoDriver osv.) automatiskt, så du behöver inte ladda ner drivrutiner manuellt:

pip install selenium

Basisexempel med explicit vänt (Selenium gör inte auto-vänt; använd WebDriverWait eller förväntade villkor):

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

driver = webdriver.Chrome()
driver.get("https://example.com")
# Vänta på body att vara närvarande, sedan hämta titel
WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.TAG_NAME, "body")))
print(driver.title)
driver.quit()

Klicka och läs text:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

driver = webdriver.Chrome()
driver.get("https://example.com")
link = WebDriverWait(driver, 10).until(
    EC.element_to_be_clickable((By.LINK_TEXT, "Mer information. .."))
)
link.click()
heading = WebDriverWait(driver, 10).until(
    EC.visibility_of_element_located((By.CSS_SELECTOR, "h1"))
)
print(heading.text)
driver.quit()

Puppeteer (Node.js; inget officiellt Python)

Puppeteer är endast för JavaScript/Node.js – Google underhåller ingen Python-API. Om du behöver en Puppeteer-liknande upplevelse i Python, använd Playwright (samma “kontrollera Chrome över CDP” idé, med första klass Python och auto-vänt). Det finns en oofficiell port pyppeteer, men den underhålls inte aktivt; för nya Python-arbete är Playwright ett bättre val. Nedan är det Node.js-exemplet så du kan jämföra API:et:

npm init -y && npm install puppeteer

const puppeteer = require("puppeteer");

(async () => {
  const browser = await puppeteer.launch({ headless: true });
  const page = await browser.newPage();
  await page.goto("https://example.com");
  console.log(await page.title());
  await page.click("a[href='https://www.iana.org/domains/example']");
  const text = await page.$eval("h1", (el) => el.textContent);
  console.log(text);
  await browser.close();
})();

LambdaTest (Python: Selenium)

Du använder samma Selenium API; den enda förändringen är att ansluta till LambdaTest:s fjärrWebDriver-hub istället för en lokal drivrutin. Ställ in inställningar (webbläsare, OS, byggnamn osv.) och skicka ditt användarnamn och åtkomstkod från LambdaTest:s dashboard:

from selenium import webdriver

options = webdriver.ChromeOptions()
options.browser_version = "latest"
options.platform_name = "Windows 11"

lt_caps = {
    "lt:options": {
        "username": "DIN_LT_ANVÄNDARNAMN",
        "accessKey": "DIN_LT_AKCESSNYCKEL",
        "build": "Playwright-Selenium-Jämförelse",
        "name": "Selenium på LambdaTest",
    }
}
options.set_capability("lt:options", lt_caps["lt:options"])

driver = webdriver.Remote(
    command_executor="https://DIN_LT_ANVÄNDARNAMN:DIN_LT_AKCESSNYCKEL@hub.lambdatest.com/wd/hub",
    options=options,
)
driver.get("https://example.com")
print(driver.title)
driver.quit()

LambdaTest (Python: Playwright)

Playwright kan ansluta till en fjärrwebbläsare via CDP (Chrome DevTools Protocol). LambdaTest exponerar en CDP-slutpunkt för varje testkörning; du ansluter till den istället för att starta en lokal webbläsare. Se LambdaTest:s dokumentation för exakt CDP-slutpunktsformat och autentisering:

from playwright.sync_api import sync_playwright

# LambdaTest tillhandahåller en CDP-slutpunkt per körning; använd deras dokumentation för att få den
CDP_URL = "wss://cdp.lambdatest.com/playwright?capabilities=..."  # från LT dashboard

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(CDP_URL)
    page = browser.new_page()
    page.goto("https://example.com")
    print(page.title())
    browser.close()

ZenRows + Playwright (Python)

ZenRows Scraping Browser är CDP-kompatibel, så du använder Playwrights connect_over_cdp() med deras WebSocket-URL. Webbläsaren körs i ZenRows moln med deras proxy och anti-bot-hantering; ditt skript förblir samma utom hur du ansluter. Endast startsteget ändras:

from playwright.sync_api import sync_playwright

ZENROWS_WS = "wss://browser.zenrows.com?apikey=DIN_ZENROWS_API_KEY"

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(ZENROWS_WS)
    page = browser.new_page()
    page.goto("https://example.com")
    html = page.content()
    print(html[:500])
    browser.close()

Sedan skicka det resulterande HTML:t till din egen parser eller, till exempel, konvertera HTML till Markdown med Python för nedströmsbearbetning.

Gauge + Selenium (Python)

Gauge håller specifikationer i Markdown (eller andra format) och stegimplementeringar i Python. Varje steg kan anropa Selenium (eller någon annan drivrutin) för att öppna webbläsaren, navigera och påstå. Exempel på layout:

Spec specs/example.spec:

# Exempelspec

## Öppna webbplats och kontrollera titel

* Öppna webbläsare och gå till "https://example.com"
* Sidtitel bör vara "Exempeldomän"

Steg step_impl/example.py:

from getgauge.python import step, before_scenario
from selenium import webdriver

driver = None

@before_scenario()
def init_driver():
    global driver
    driver = webdriver.Chrome()

@step("Öppna webbläsare och gå till <url>")
def open_url(url):
    driver.get(url)

@step("Sidtitel bör vara <title>")
def check_title(title):
    assert driver.title == title, f"Expected {title}, got {driver.title}"

Installera Gauge, Python-köraren och Selenium-plugin; kör med gauge run specs/. För att köra på LambdaTest, ställ in Selenium-drivrutinen att använda LambdaTest:s fjärr-URL och inställningar i en before_scenario hook istället för webdriver.Chrome().

Sammanfattning

Verktyg Python Roll Bäst för
Playwright Ja Webbläsarautomatisering Nya E2E-test, skrapning, flera webbläsare, hastighet
Selenium Ja Webbläsarautomatisering Äldre tester, bred ekosystem, många webbläsare
Puppeteer Nej Webbläsarautomatisering Node.js/Chrome-endast projekt
LambdaTest N/A Molngrid Parallell, tvärvägsöversikt, Gauge + Selenium
ZenRows Via PW Skrapningswebbläsare Anti-bot, proxy, CAPTCHA; använd med Playwright
Gauge Ja Testramverk BDD-specifikationer + Selenium (eller annan drivrutin)

För nya Python-arbete är Playwright standardvalet; lägg till LambdaTest eller ZenRows när du behöver molnskala eller skrapningsresilien. Behåll Selenium för befintliga uppsättningar och Gauge när du vill ha spec-first testdesign över Selenium.

Några användbara länkar

Referenser