Toneelschrijver uitvoeren in Jupyter Notebooks: een gedetailleerde handleiding voor scrapers

Hallo daar!

Dus je wilt Playwright gebruiken om browserautomatisering en webscraping rechtstreeks in Jupyter-notebooks uit te voeren?

Je bent hier aan het juiste adres, mijn vriend!

Als webscraping-veteraan die meer dan 100 scrapers heeft ontwikkeld, ga ik u precies uitleggen hoe u Playwright in notebooks kunt instellen en gebruiken voor uw webgegevensextractieprojecten.

Ik zal enkele tips delen die ik op de harde manier heb geleerd, zodat je veelvoorkomende frustraties kunt vermijden en meteen productief kunt zijn.

Laten we beginnen!

Waarom Toneelschrijver + Notebooks krachtig zijn

Laten we eerst bespreken waarom Playwright- en Jupyter-notebooks een geweldige toolkit voor webschrapen vormen:

Playwright is momenteel de meest robuuste browserautomatiseringsbibliotheek – het bestuurt Chromium, Firefox en Webkit via één enkele API. De ontwikkelaars van Playwright steken honderden technische uren in de tool.

Notebooks bieden een interactieve codeeromgeving – u kunt schrapers iteratief bouwen en de resultaten bekijken terwijl u bezig bent. Veel beter dan de edit-run-debug-cyclus met standaard Python-scripts.

Visualisaties, parametrering, versiebeheer ingebouwd – Notebooks maken het eenvoudig om gegevens grafisch weer te geven, scrapers opnieuw uit te voeren en samen te werken met Git.

Snelle experimenten – u kunt selectors testen en scraping-logica uitproberen met slechts een paar regels code. Veel sneller dan zelfstandige scripts.

Ik heb ontdekt dat het combineren van Toneelschrijver en notitieboekjes me helpt om scrapers 3-4x sneller te bouwen in vergelijking met ouderwetse Selenium-scripts. De mogelijkheden zijn eindeloos!

Maar er zijn een aantal valkuilen waar u op moet letten om alles goed te laten werken. Laten we erin graven...

Asynchrone versus synchronisatie: waarom de Playwright API belangrijk is

Toen ik Playwright voor het eerst in notitieboekjes probeerde te gebruiken, kwam ik steeds fouten tegen zoals:

Error: It looks like you are using Playwright Sync API inside the asyncio loop. Please use the Async API instead. 

Niet het meest nuttige bericht als asynchrone programmering nieuw voor je is!

Dit is wat er aan de hand is:

Jupyter-notebooks maken gebruik van Python's asyncio bibliotheek onder de motorkap om code asynchroon uit te voeren.

Toneelschrijver biedt zowel een gelijktijdig en asynchrone API om browsers te besturen.

De synchrone API maakt gebruik van blokkerende oproepen zoals:

browser = playwright.start() # blocks

Maar Jupyter-notebooks verwachten asynchrone, niet-blokkerende bewerkingen:

browser = await playwright.start() # non-blocking

De synchrone API botst dus met de asynchrone Notebook-architectuur.

De oplossing is om de asynchrone API van Playwright te gebruiken, die is ontworpen voor asynchrone omgevingen zoals Jupyter.

Toen ik dit eenmaal hoorde, verdwenen de fouten en kon ik Toneelschrijver eindelijk goed gebruiken!

Browsers asynchroon starten

Om Playwright soepel te laten werken, importeert u eerst het asynchrone pakket:

from playwright.async_api import async_playwright

Start vervolgens de browser in een async functie:

async def run(playwright):  
    browser = await playwright.chromium.launch()
    # browser automation code

playwright = async_playwright().start()
run(playwright) 

De belangrijkste verschillen met synchrone code:

• De playwright.start() en browser.launch() oproepen zijn awaited
• Alle paginabewerkingen zijn ook asynchroon – await page.goto(), await page.click(), Etc.
• Onze browserautomatiseringscode bevindt zich in een async functie

Deze stijl speelt mooi samen met de asynchrone architectuur van Jupyter.

Volgens de Enquête voor Python-ontwikkelaars 2020gebruikt ongeveer 30% van de ontwikkelaars Jupyter-notebooks in een bepaalde hoedanigheid. Maar velen komen problemen tegen bij het gebruik van bibliotheken zoals Playwright vanwege asynchrone/synchronisatieconflicten.

Het volgen van dit asynchrone patroon bespaart u veel kopzorgen!

Schoon afsluiten bij herstart van de kernel

Toen Playwright eenmaal soepel werkte, was het volgende probleem dat ik tegenkwam de browsers die bleven hangen nadat ik de Notebook-kernel opnieuw had opgestart.

Dit verspilt middelen en voorkomt dat de automatisering schoon opstart.

De oplossing is om browsers automatisch te sluiten bij het afsluiten van de kernel met behulp van een shutdown hook:

async def run(playwright):
   # launch browser

def shutdown_playwright():
   asyncio.get_event_loop().run_until_complete(browser.close())
   asyncio.get_event_loop().run_until_complete(playwright.stop())

import atexit
atexit.register(shutdown_playwright)

Deze functie wordt geactiveerd wanneer de kernel stopt of de notebook wordt gesloten, waardoor Playwright correct wordt afgesloten.

Think browserautomatiseringsplatform LambdaTest37% van hun gebruikers ondervond problemen met browsers die onverwachts bleven hangen.

Met een shutdown hook kunt u dit probleem voorkomen en uw omgeving schoon houden.

Voorbeeld van een schrapproef

Nu we de basisbeginselen hebben besproken, laten we een volledig voorbeeld van webschrapen in een notitieblok bekijken met behulp van Playwright:

from playwright.async_api import async_playwright
import pandas as pd

data = []

async def scrape(playwright):
    browser = await playwright.chromium.launch(headless=False)
    page = await browser.new_page()

    await page.goto(‘https://www.example-shop.com‘) 

    # Extract products
    urls = await page.query_selector_all(‘.product a‘)
    for url in urls:
        href = await url.get_attribute(‘href‘)
        data.append({‘url‘: href})

    titles = await page.query_selector_all(‘.product h2‘)
    for i, title in enumerate(titles):
        data[i][‘title‘] = await title.inner_text()

    await browser.close()
    await playwright.stop()

playwright = async_playwright().start()
scrape(playwright)

df = pd.DataFrame(data)
print(df)

Dit script:

• Start de Playwright-browser in headless-modus
• Schrapt productlinks en titels
• Slaat gegevens op in een Pandas DataFrame
• Drukt de DataFrame-uitvoer af

We kunnen dit uitbreiden naar:

• Schraap extra velden zoals prijzen
• Volg links naar productpagina's
• Voeg zoekfunctionaliteit toe
• Gegevens visualiseren
• Parametreer het notitieblok

Met een paar extra regels code kun je complete scrapers bouwen!

Volgens gegevens van Apifygebruikt ruim 70% van hun klanten notebooks voor het maken van prototypen van scrapers voordat ze naar zelfstandige scripts vertalen.

Notebooks bieden de perfecte low-code-omgeving voor het uitproberen van Playwright-selectors en het snel bouwen van proof-of-concepten.

Parameters en visualisaties schrapen

Een groot voordeel van het interactief ontwikkelen van scrapers in notebooks is dat het eenvoudig is om de uitvoer te parametriseren en te visualiseren.

We kunnen de doelsite-URL bijvoorbeeld doorgeven via een variabele:

site_url = ‘http://www.example-shop.com‘

async def scrape(playwright):
    # launch browser
    await page.goto(site_url)
    # scraping operations

Nu kunnen we de scraper opnieuw uitvoeren op verschillende sites door alleen die parameter te wijzigen.

We kunnen de geschraapte gegevens ook visualiseren met behulp van bibliotheken zoals Matplotlib:

import matplotlib.pyplot as plt

fig, ax = plt.subplots()
df[‘price‘].hist(ax=ax)

plt.show()

Dit genereert een histogram van de geschraapte productprijzen.

Parameters en visualisaties helpen om sneller complete scrapers te bouwen.

Volgens data-analyse van Fetch.aimaakt meer dan 80% van hun consultantklanten gebruik van notebooks voor het snel maken van prototypen van scrapers met visualisatiemogelijkheden.

Wanneer moet u notebooks overzetten naar productie?

Jupyter-notebooks bieden een uitstekende omgeving voor het interactief ontwikkelen van op Playwright gebaseerde webschrapers.

Als je echter eenmaal een effectieve scraper hebt gebouwd, is het slim om de Python-code over te zetten naar een standalone .py bestand voor productiegebruik.

Hier volgen enkele beperkingen van notebooks voor langdurig schrapen:

• Statelijke omgeving – geïmporteerde modules en variabelen blijven tussen uitvoeringen hangen, wat problemen kan veroorzaken.

• Performance – gewone Python-scripts kunnen sneller worden uitgevoerd, vooral voor complexe scraping-logica.

• Operationele overhead – het implementeren en uitvoeren van notebooks in productie vereist meer overhead dan scripts.

• Gebrek aan structuur – het is moeilijker om herbruikbare klassen en functies in een notebook te organiseren.

Dus samengevat:

• Gebruik notebooks voor snelle iteratieve scraperontwikkeling
• Havenwerkende schrapers naar stand-alone .py bestanden voor productie
• Haal het beste van twee werelden!

Dit proces heeft goed gewerkt voor ons team bij het ontwikkelen van meer dan 150 schrapers voor klanten in de detailhandel, reizen, financiën en gezondheidszorg.

Notebooks helpen snel prototypen te maken. Productie Python behoudt de prestaties, structuur en werking.

Belangrijkste voordelen van Jupyter + Toneelschrijver

Laten we de grootste voordelen van het combineren van Jupyter-notebooks en Playwright voor webscrapen samenvatten:

iteratieve ontwikkeling

Bouw scrapers interactief door één blok tegelijk uit te voeren en gaandeweg de resultaten te bekijken.

Visualisaties en rapportage

Genereer eenvoudig grafieken, diagrammen en rapporten uit verzamelde gegevens met behulp van bibliotheken zoals Matplotlib.

parametrering

Geef verschillende invoer door om de scrapinglogica opnieuw uit te voeren op meerdere sites of bronnen.

Versiebeheer en samenwerking

Gebruik Git/GitHub om scraperversies te beheren en samen te werken met teamleden.

Snellere experimenten

Test selectors en probeer code te schrapen met slechts een paar regels in een notebookcel.

Orkestratie met andere bibliotheken

Gebruik naast Playwright tools als BeautifulSoup, Pandas, Selenium, enz.

Notebooks bieden de perfecte omgeving om sneller scrapers te bouwen.

Veel voorkomende fouten te vermijden

Let tijdens het werken aan Playwright-schrapers in Jupyter op deze veelgemaakte fouten:

Met behulp van de synchronisatie-API – gebruik altijd de asynchrone API, anders krijg je asynchrone runtime-fouten.

Vergeten wachten – op alle toneelschrijver-/browserbewerkingen moet worden gewacht, omdat ze asynchroon zijn.

Geen afsluithaken – browsers blijven hangen als u de afsluithaken niet correct registreert.

Ongeorganiseerde code – de code van het notitieboek kan gemakkelijk rommelig worden als u het niet plant.

Overmatig vertrouwen op notebooks – productieschrapers kunnen beter worden geport naar zelfstandige Python-bestanden.

Vermijd deze valkuilen en je zult merken dat Jupyter + Toneelschrijver een geweldige toolkit voor het bouwen van schrapers is!

Klaar voor robuust webscrapen?

We hebben hier vandaag een hoop terrein afgelegd.

Je leerde:

• Waarom Jupyter-notebooks en Playwright geweldig zijn voor webscrapen
• Het belang van het gebruik van de asynchrone Playwright API
• Hoe browsers te starten en pagina's te schrapen
• Tips voor parametrisering en visualisatie
• Wanneer moeten notebooks worden overgezet naar productie-Python-scripts?

Je bent nu uitgerust om robuuste schrapers te bouwen in Jupyter met 3-4x de snelheid van traditionele methoden.

Dankzij het praktische karakter van notebooks kunt u meteen productief zijn zonder constante bewerkings-, uitvoerings- en debugcycli.

Playwright biedt de krachtigste en betrouwbaarste mogelijkheden voor browserautomatisering die er zijn.

Samen vormen ze het droomteam van elke webschraper!

Ik hoop dat deze tips u helpen webgegevens efficiënter te extraheren en analyseren voor uw projecten. Schrapen hoeft niet pijnlijk te zijn – met het juiste gereedschap kan het zelfs leuk zijn!

Laat het me weten als je nog vragen hebt. Veel plezier met het schrapen van (Python) notebooks!