Automatyzacja przeglądarki w Pythonie: Playwright, Selenium i inne

Porównanie automatyzacji przeglądarki w Pythonie i testowania E2E.

Page content

Wybór odpowiedniego stosu automatyzacji przeglądarki w Pythonie wpływa na szybkość, stabilność i utrzymanie.
Ten przegląd porównuje
Playwright vs Selenium vs Puppeteer vs LambdaTest vs ZenRows vs Gauge –
z naciskiem na Pythona, przy jednoczesnym zauważeniu, gdzie JavaScript lub inne języki pasują.

Playwright trace viewer Oto zrzut ekranu z Playwright trace viewer

Kiedy używać którego

Playwright (Python)
Playwright to open-source biblioteka automatyzacji przeglądarki stworzona przez Microsoft. Komunikuje się z Chromium, Firefox i WebKit przez Chrome DevTools Protocol (CDP) lub WebSocket, dzięki czemu otrzymujesz jedną API dla wszystkich trzech silników. Wchodzi w skład auto-oczekiwanie: przed każdą akcją (kliknięcie, wypełnienie itp.) oczekuje, aż element będzie widoczny, stabilny i aktywny, co zmniejsza niepewność i potrzebę ręcznego sleep lub WebDriverWait. Instalacja jest minimalna (pip install playwright następnie playwright install), a Python API jest pierwszorzędne (synchroniczne i asynchroniczne). Użyj go do nowych testów E2E, skryptowania lub automatyzacji (np. budowania serwerów MCP w Pythonie które sterują przeglądarką). Aby uzyskać pełny przewodnik z przykładami w Pythonie, JavaScript i TypeScript, zobacz Playwright: Web Scraping & Testing. Połącz go z testami jednostkowymi w Pythonie dla reszty aplikacji i użyj Playwright tylko do warstwy przeglądarki. Wady: nowszy niż Selenium, więc mniej integracji trzecich stron i mniej materiałów z przeszłości; brak oficjalnej obsługi bardzo starych przeglądarek.

Selenium (Python)
Selenium to długofalowy standard automatyzacji przeglądarki. Selenium Project (open source, wspierany przez OpenJS Foundation) dostarcza API WebDriver: wysyłasz polecenia do konkretnego sterownika przeglądarki (ChromeDriver, GeckoDriver itp.), który komunikuje się z rzeczywistą przeglądarką. Selenium obsługuje wiele języków (Python, Java, C#, JavaScript itp.) i najszerszy zakres przeglądarek, w tym starszych. Selenium 4+ zawiera Selenium Manager, więc nie musisz ręcznie pobierać ani ustawiać ścieżki do binarów sterownika – klient pobiera odpowiedni sterownik dla Ciebie. API nie ma auto-oczekiwań; zazwyczaj korzystasz z WebDriverWait i oczekiwanych warunków, aby uniknąć niepewnych testów. Użyj Selenium, jeśli utrzymujesz istniejące zestawy WebDriver, potrzebujesz najszerszej ekosystemu i wsparcia językowego lub musisz obsługiwać stare przeglądarki. Pasuje do wzorców projektowych Pythona dla czystej architektury, jeśli zapakujesz sterownik za pomocą małego adaptera. Wady: ogólnie wolniejszy i bardziej delikatny niż Playwright bez starannego strategii oczekiwania; więcej kodu szkieletowego.

Puppeteer
Puppeteer to biblioteka Node.js firmy Google do kontroli bezgłównej Chrome/Chromium (i Chromium-based Edge). Używa bezpośrednio Chrome DevTools Protocol i jest domyślnym wyborem dla zespołów JavaScript/TypeScript wykonyjących tylko automatyzację Chrome, generację PDF lub scrapowanie w Node. Nie ma oficjalnego powiązania Pythona; API jest tylko dla Node.js. Jeśli Twój stos to Python, użyj Playwright (ten sam pomysł „kontroli CDP” z pierwszorzędnym Pythonem) lub Selenium. Jeśli jesteś w Node.js i potrzebujesz tylko Chromium, Puppeteer to silna, dobrze udokumentowana opcja. Wady: tylko Chrome/Chromium; brak Firefox i WebKit; brak Pythona.

LambdaTest
LambdaTest to komercyjna platforma testowania w chmurze. Nadal piszesz te same skrypty Selenium lub Playwright (lub Cypress itp.) lokalnie, ale zamiast uruchamiać lokalną przeglądarkę, łączy się z siatką LambdaTest. Zapewnia rzeczywiste przeglądarki i rzeczywiste urządzenia (w tym mobilne) w chmurze, więc możesz uruchamiać testy równolegle w wielu kombinacjach systemu operacyjnego/przeglądarki/wersji bez konieczności utrzymywania własnej laboratorium. Otrzymujesz pulpit nawigacyjny dla wyników, filmów i logów. Użyj go, gdy potrzebujesz pokrycia wielu przeglądarek, skalowalnej równoległej pracy, emulacji mobilnej i nie chcesz hostować infrastruktury. Wspiera również Gauge: uruchamiasz swoje specyfikacje Gauge na ich siatce Selenium. Wady: płatny (z darmowymi warstwami); testy są uruchamiane przez sieć, więc opóźnienia i dostępność zależą od ich usługi.

ZenRows
ZenRows to komercyjna usługa scrapowania i unikania wykrywania. Scraping Browser to chmurowa przeglądarka, którą kontrolujesz za pomocą Playwright (lub innych narzędzi kompatybilnych z CDP): łączy się Twój skrypt z punktem końcowym WebSocket i przeglądarka działa po stronie ZenRows z proxy mieszkalnymi, rotacją IP, unikaniem botów (np. Cloudflare, DataDome) i opcjonalnym obsługą CAPTCHA. Nie zmieniasz logiki Playwright – tylko punkt końcowy przeglądarki. Użyj go, gdy Twoim celem jest scrapowanie i napotykasz blokady lub limity przepustowości; dla zwykłych testów E2E na własnej aplikacji lokalny Playwright lub Selenium są zazwyczaj wystarczające. Wady: płatny; skierowany do scrapowania, a nie do ogólnego celu testowania jak LambdaTest.

Gauge
Gauge to otwarty framework testowy od Thoughtworks. Skupia się na specyfikacjach i raportowaniu: piszesz specyfikacje w Markdown (lub innych formatach) z scenariuszami i krokami, a implementujesz kroki w Pythonie (lub Java, JavaScript itp.) za pomocą Selenium (lub innego sterownika), aby sterować przeglądarką. Gauge nie zastępuje Selenium ani Playwright; znajduje się nad nimi i dodaje strukturę, ponowne użycie i czytelne raporty. Użyj go, gdy chcesz specyfikacje stylu BDD, dokumentację i jasne raporty testów na podstawie istniejącego zestawu Selenium (lub podobnego). LambdaTest wspiera uruchamianie testów Gauge na ich siatce. Wady: dodatkowy warstwa do nauki i utrzymania; nadal musisz wybrać i skonfigurować sterownik automatyzacji przeglądarki (np. Selenium).

Gdzie działają

  • Playwright: Lokalnie lub w CI; Python 3.8+; Windows, macOS, Linux. Działa również z przeglądarkami w chmurze (np. ZenRows, LambdaTest), łącząc się z punktem końcowym WebSocket lub CDP.
  • Selenium: Lokalnie lub w CI; dowolny język z klientem WebDriver; Selenium Grid lub dostawca takim jak LambdaTest do skalowania.
  • Puppeteer: Tylko w Node.js; zazwyczaj Chrome/Chromium na maszynie lub w Dockerze.
  • LambdaTest: Tylko w chmurze; uruchamiasz Selenium/Playwright (lub Gauge przez Selenium) przeciwko ich siatce.
  • ZenRows: Chmurowa przeglądarka Scraping Browser; sterujesz nią z Pythona (np. Playwright) lub innych narzędzi kompatybilnych z CDP.
  • Gauge: Działa na Twojej maszynie lub w CI; używa Selenium (lub innego sterownika) w tle; może celować w siatkę LambdaTest.

Aby uzyskać szybki przewodnik po trendach w ekosystemie Pythona, zobacz najpopularniejsze projekty Pythona na GitHubie; wiele narzędzi automatyzacji i testowania pojawia się tam.

Jak je używać w Pythonie

Playwright (Python)

Pakiet Pythona Playwright oferuje zarówno synchroniczne, jak i asynchroniczne API. Przeglądarki są instalowane osobno, więc biblioteka pozostaje mała, a możesz wybrać tylko silniki, które potrzebujesz (Chromium, Firefox, WebKit). Zainstaluj i zainstaluj przeglądarki:

pip install playwright
playwright install

Przykład synchroniczny (przejście, kliknięcie, odczyt tekstu – Playwright automatycznie oczekuje na elementy):

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())
    # Kliknij link, a następnie sprawdź nagłówek (wbudowane oczekiwanie)
    page.get_by_role("link", name="More information...").click()
    heading = page.get_by_role("heading", name="Example Domain").text_content()
    print(heading)
    browser.close()

Asynchroniczne jest zalecane dla współbieżności i pasuje do przepływów pracy z wyjściem strukturalnym LLM lub skryptów, które wykonują I/O, podczas gdy przeglądarka działa:

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())

Aby mieć cheatsheet Pythona i odniesienie do składni, warto mieć lokalny dokument.

Selenium (Python)

Klient Pythona używa protokołu W3C WebDriver. Selenium 4+ używa Selenium Manager do automatycznego pobierania i zarządzania odpowiednim sterownikiem (ChromeDriver, GeckoDriver itp.), więc nie musisz ręcznie pobierać sterowników:

pip install selenium

Podstawowy przykład z jawnym oczekiwaniem (Selenium nie oczekuje automatycznie; użyj WebDriverWait lub oczekiwanych warunków):

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")
# Oczekuj, aż pojawi się element body, a następnie pobierz tytuł
WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.TAG_NAME, "body")))
print(driver.title)
driver.quit()

Kliknij i odczytaj tekst:

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, "More 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; brak oficjalnego Pythona)

Puppeteer jest tylko dla JavaScript/Node.js – Google nie utrzymuje żadnego API Pythona. Jeśli potrzebujesz doświadczenia podobnego do Puppeteer w Pythonie, użyj Playwright (ten sam pomysł „kontroli Chrome przez CDP”, z pierwszorzędnym Pythonem i automatycznym oczekiwaniem). Istnieje nieficjalna wersja pyppeteer, ale nie jest aktywnie utrzymywana; dla nowej pracy w Pythonie, Playwright to lepszy wybór. Poniżej przykład w Node.js, abyś mógł porównać API:

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)

Używasz tego samego API Selenium; jedyna zmiana to łączenie się z odległym WebDriver hubem LambdaTest zamiast lokalnego sterownika. Ustaw możliwości (przeglądarka, system operacyjny, nazwa budowy itp.) i przekaż swoje dane użytkownika i klucz dostępu z pulpiczka LambdaTest:

from selenium import webdriver

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

lt_caps = {
    "lt:options": {
        "username": "YOUR_LT_USERNAME",
        "accessKey": "YOUR_LT_ACCESS_KEY",
        "build": "Playwright-Selenium-Compare",
        "name": "Selenium on LambdaTest",
    }
}
options.set_capability("lt:options", lt_caps["lt:options"])

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

LambdaTest (Python: Playwright)

Playwright może dołączyć się do odległej przeglądarki przez CDP (Chrome DevTools Protocol). LambdaTest udostępnia punkt końcowy CDP dla każdego testu; łączy się do niego zamiast uruchamiać lokalną przeglądarkę. Zobacz dokumentację LambdaTest na dokładny format URL CDP i uwierzytelnienie:

from playwright.sync_api import sync_playwright

# LambdaTest dostarcza punkt końcowy CDP dla każdego testu; użyj ich dokumentacji, aby go uzyskać
CDP_URL = "wss://cdp.lambdatest.com/playwright?capabilities=..."  # z pulpiczka LT

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)

Przeglądarka Scraping Browser ZenRows jest kompatybilna z CDP, więc używasz connect_over_cdp() Playwright z ich URL WebSocket. Przeglądarka działa w chmurze ZenRows z ich proxy i obsługa antybotów; Twój skrypt pozostaje taki sam, z wyjątkiem sposobu połączenia. Tylko krok uruchomienia zmienia się:

from playwright.sync_api import sync_playwright

ZENROWS_WS = "wss://browser.zenrows.com?apikey=YOUR_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()

Następnie przekaż wynikowy HTML do własnego parsera lub, np. konwertując HTML na Markdown w Pythonie do dalszego przetwarzania.

Gauge + Selenium (Python)

Gauge przechowuje specyfikacje w Markdown (lub innych formatach), a implementacje kroków w Pythonie. Każdy krok może wywoływać Selenium (lub dowolny inny sterownik), aby otworzyć przeglądarkę, przejść i asercję. Przykład układu:

Spec specs/example.spec:

# Przykładowa specyfikacja

## Otwórz stronę i sprawdź tytuł

* Otwórz przeglądarkę i przejdź do "https://example.com"
* Tytuł strony powinien być "Example Domain"

Kroki 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("Otwórz przeglądarkę i przejdź do <url>")
def open_url(url):
    driver.get(url)

@step("Tytuł strony powinien być <title>")
def check_title(title):
    assert driver.title == title, f"Oczekiwano {title}, otrzymano {driver.title}"

Zainstaluj Gauge, Pythona runnera i wtyczkę Selenium; uruchom za pomocą gauge run specs/. Aby uruchomić na LambdaTest, ustaw sterownik Selenium, aby używał odległego URL i możliwości LambdaTest w hooku before_scenario zamiast webdriver.Chrome().

Podsumowanie

Narzędzie Python Rola Najlepszy do
Playwright Tak Automatyzacja przeglądarki Nowe testy E2E, scrapowanie, wielu przeglądarek, szybkość
Selenium Tak Automatyzacja przeglądarki Starsze testy, szeroki ekosystem, wiele przeglądarek
Puppeteer Nie Automatyzacja przeglądarki Projekty Node.js/Chrome-only
LambdaTest N/A Sieć w chmurze Równoległość, wielu przeglądarek, Gauge + Selenium
ZenRows Przez PW Scrapowanie przeglądarki Unikanie botów, proxy, CAPTCHA; używaj z Playwright
Gauge Tak Framework testowy Specyfikacje BDD + Selenium (lub inny sterownik)

Dla nowej pracy w Pythonie, Playwright jest domyślnym wyborem; dodaj LambdaTest lub ZenRows, gdy potrzebujesz skali w chmurze lub odporności na scrapowanie. Utrzymuj Selenium dla istniejących zestawów i Gauge, gdy chcesz projekt testowy z pierwszymi specyfikacjami nad Selenium.

Użyteczne linki

Odnośniki