Come eseguire Playwright nei quaderni Jupyter: una guida dettagliata per i raschiatori

Ehilà!

Quindi vuoi utilizzare Playwright per eseguire l'automazione del browser e il web scraping direttamente nei notebook Jupyter?

Sei arrivato nel posto giusto amico mio!

In qualità di veterano del web scraping che ha progettato oltre 100 scraper, ti spiegherò esattamente come configurare e utilizzare Playwright nei notebook per i tuoi progetti di estrazione dei dati web.

Condividerò alcuni suggerimenti che ho imparato nel modo più duro in modo da poter evitare frustrazioni comuni ed essere subito produttivi.

Iniziamo!

Perché drammaturgo e taccuini sono potenti

Innanzitutto, discutiamo del motivo per cui i taccuini Playwright e Jupyter costituiscono uno straordinario kit di strumenti per lo scraping del web:

Playwright è oggi la libreria di automazione del browser più solida – controlla Chromium, Firefox e Webkit tramite un'unica API. Gli sviluppatori di Playwright dedicano centinaia di ore di progettazione allo strumento.

I notebook forniscono un ambiente di codifica interattivo – puoi costruire raschiatori in modo iterativo e vedere i risultati mentre procedi. Molto meglio del ciclo modifica-esecuzione-debug con script Python standard.

Visualizzazioni, parametrizzazione, controllo versione integrati – i notebook semplificano la rappresentazione grafica dei dati, la riesecuzione degli scraper e la collaborazione utilizzando Git.

Sperimentazione rapida – puoi testare i selettori e provare la logica dello scraping con solo poche righe di codice. Molto più veloce degli script autonomi.

Ho scoperto che combinare Playwright e taccuini mi aiuta a creare raschiatori 3-4 volte più velocemente rispetto agli script Selenium della vecchia scuola. Le possibilità sono infinite!

Ma ci sono alcuni trucchi a cui prestare attenzione affinché tutto funzioni correttamente. Approfondiamo…

Asincrono e sincronizzato: perché l'API Playwright è importante

Quando ho provato per la prima volta a utilizzare Playwright nei notebook, continuavo a riscontrare errori come:

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

Non è il messaggio più utile se sei nuovo alla programmazione asincrona!

Ecco cosa sta succedendo:

I notebook Jupyter utilizzano Python asyncio libreria nascosta per eseguire il codice in modo asincrono.

Il drammaturgo fornisce sia a sincrono ed asincrono API per controllare i browser.

L'API sincrona utilizza chiamate di blocco come:

browser = playwright.start() # blocks

Ma i notebook Jupyter prevedono operazioni asincrone e non bloccanti:

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

Quindi l'API sincrona si scontra con l'architettura asincrona del notebook.

La soluzione è utilizzare l'API asincrona di Playwright, progettata per ambienti asincroni come Jupyter.

Una volta appreso questo, gli errori sono scomparsi e ho finalmente potuto utilizzare correttamente Playwright!

Avvio dei browser in modo asincrono

Per far funzionare Playwright senza problemi, importa prima il pacchetto asincrono:

from playwright.async_api import async_playwright

Quindi avvia il browser all'interno di un file async funzione:

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

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

Le principali differenze rispetto al codice sincrono:

• I playwright.start() ed browser.launch() le chiamate sono awaited
• Anche tutte le operazioni sulla pagina sono asincrone – await page.goto(), await page.click(), ecc.
• Il nostro codice di automazione del browser si trova all'interno di un file async function

Questo stile funziona bene con l'architettura asincrona di Jupyter.

Secondo il Sondaggio 2020 sugli sviluppatori Python, circa il 30% degli sviluppatori utilizza i notebook Jupyter in qualche modo. Ma molti riscontrano problemi utilizzando librerie come Playwright a causa di conflitti asincroni/sincronizzazione.

Seguire questo modello asincrono ti farà risparmiare molti mal di testa!

Spegnimento pulito al riavvio del kernel

Una volta che Playwright funzionava senza intoppi, il problema successivo che ho riscontrato è stato il blocco dei browser dopo aver riavviato il kernel di Notebook.

Ciò spreca risorse e impedisce l'avvio pulito dell'automazione.

La soluzione è chiudere automaticamente i browser allo spegnimento del kernel utilizzando un hook di spegnimento:

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)

Questa funzione si attiverà quando il kernel si ferma o il notebook viene chiuso, spegnendo correttamente Playwright.

Secondo piattaforma di automazione del browser LambdaTest, il 37% dei propri utenti ha riscontrato problemi con i browser che si bloccavano in modo imprevisto.

Con un gancio di spegnimento puoi evitare questo problema e mantenere pulito il tuo ambiente.

Esempio di prova di raschiatura

Ora che abbiamo trattato le nozioni di base, esaminiamo un esempio completo di web scraping in un taccuino utilizzando 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)

Questo script:

• Avvia il browser Playwright in modalità headless
• Raschia collegamenti e titoli di prodotti
• Memorizza i dati in un Pandas DataFrame
• Stampa l'output di DataFrame

Possiamo espandere questo argomento a:

• Elimina campi aggiuntivi come i prezzi
• Segui i collegamenti alle pagine dei prodotti
• Aggiungi funzionalità di ricerca
• Visualizza i dati
• Parametrizzare il notebook

Con poche righe di codice extra, puoi creare scraper completi!

Secondo i dati di Apifica, oltre il 70% dei clienti utilizza i notebook per la prototipazione di scraper prima della conversione in script autonomi.

I notebook forniscono l'ambiente low-code perfetto per provare i selezionatori di drammaturghi e creare rapidamente prove di concetti.

Parametri e visualizzazioni di scraping

Un grande vantaggio dello sviluppo interattivo di scraper nei notebook è la facilità di parametrizzare e visualizzare gli output.

Ad esempio, possiamo passare l'URL del sito di destinazione tramite una variabile:

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

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

Ora possiamo eseguire nuovamente lo scraper su siti diversi semplicemente modificando quel parametro.

Possiamo anche visualizzare i dati raschiati utilizzando librerie come Matplotlib:

import matplotlib.pyplot as plt

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

plt.show()

Ciò genera un istogramma dei prezzi dei prodotti raschiati.

I parametri e le visualizzazioni aiutano a creare più velocemente scraper completi di funzionalità.

Secondo l'analisi dei dati di Fetch.ai, oltre l'80% dei clienti consulenti sfrutta i notebook per la prototipazione rapida di raschiatori con funzionalità di visualizzazione.

Quando portare i notebook in produzione

I notebook Jupyter forniscono un ambiente eccellente per lo sviluppo interattivo di web scraper basati su Playwright.

Tuttavia, una volta creato uno scraper efficace, è intelligente trasferire il codice Python su un programma autonomo .py file per uso produttivo.

Ecco alcune limitazioni dei notebook per lo scraping a lungo termine:

• Ambiente statale – I moduli e le variabili importati rimangono tra le esecuzioni e possono causare problemi.

• Prestazione – I semplici script Python possono essere eseguiti più velocemente, soprattutto per la logica di scraping complessa.

• Spese generali operative – la distribuzione e l'esecuzione dei notebook in produzione richiedono un sovraccarico maggiore rispetto agli script.

• Mancanza di struttura – è più difficile organizzare classi e funzioni riutilizzabili in un notebook.

Quindi in sintesi:

• Utilizza i notebook per lo sviluppo rapido e iterativo di scraper
• Porta i raschiatori funzionanti a standalone .py file per la produzione
• Ottieni il meglio da entrambi i mondi!

Questo processo ha funzionato bene per il nostro team durante lo sviluppo di oltre 150 raschiatori per clienti nei settori della vendita al dettaglio, dei viaggi, della finanza e della sanità.

I notebook aiutano a creare rapidamente prototipi. Production Python preserva prestazioni, struttura e operazioni.

Principali vantaggi di Jupyter + Drammaturgo

Ricapitoliamo i maggiori vantaggi della combinazione dei notebook Jupyter e di Playwright per il web scraping:

Sviluppo iterativo

Costruisci raschiatori in modo interattivo eseguendo un blocco alla volta e visualizzando i risultati mentre procedi.

Visualizzazioni e reporting

Genera facilmente grafici, diagrammi e report dai dati recuperati utilizzando librerie come Matplotlib.

Parametrizzazione

Passa input diversi per rieseguire la logica di scraping su più siti o fonti.

Controllo della versione e collaborazione

Utilizza Git/GitHub per gestire le versioni dello scraper e collaborare con i membri del team.

Sperimentazione più rapida

Testa i selettori e prova a eseguire lo scraping del codice con solo poche righe in una cella del notebook.

Orchestrazione con altre biblioteche

Utilizza strumenti come BeautifulSoup, Pandas, Selenium, ecc. insieme a Playwright.

I notebook forniscono l'ambiente perfetto per costruire raschiatori più velocemente.

Errori comuni da evitare

Mentre lavori sugli scraper di Playwright in Jupyter, fai attenzione a questi errori comuni:

Utilizzando l'API di sincronizzazione – utilizza sempre l'API asincrona o riscontrerai errori di runtime asincrono.

L'oblio attende – tutte le operazioni di drammaturgo/browser devono essere attese poiché sono asincrone.

Nessun gancio di spegnimento – I browser si bloccheranno se non si registrano correttamente gli hook di spegnimento.

Codice disorganizzato – è facile che il codice del notebook diventi confuso se non lo pianifichi.

Affidarsi eccessivamente ai notebook – È meglio trasferire gli scraper di produzione su file Python autonomi.

Evita queste insidie ​​e scoprirai che Jupyter + Playwright è un fantastico kit di strumenti per la costruzione di raschietti!

Pronto per un robusto web scraping?

Abbiamo coperto un sacco di strada qui oggi.

Hai imparato:

• Perché i taccuini Jupyter e Playwright sono fantastici per il web scraping
• L'importanza di utilizzare l'API asincrona Playwright
• Come avviare i browser e raschiare le pagine
• Suggerimenti per la parametrizzazione e la visualizzazione
• Quando eseguire il porting dei notebook negli script Python di produzione

Ora sei attrezzato per iniziare a costruire robusti scraper in Jupyter a una velocità 3-4 volte superiore rispetto ai metodi tradizionali.

La natura pratica dei notebook ti consente di essere subito produttivo senza cicli costanti di modifica, esecuzione e debug.

Playwright offre le funzionalità di automazione del browser più potenti e affidabili disponibili.

Insieme, sono la squadra dei sogni di ogni web scraper!

Spero che questi suggerimenti ti aiutino a estrarre e analizzare i dati web in modo più efficiente per i tuoi progetti. Raschiare non deve essere doloroso: con gli strumenti giusti può anche essere divertente!

Fatemi sapere se avete altre domande. Felice raschiamento del taccuino (Python)!