Bonjour!
Vous souhaitez donc utiliser Playwright pour effectuer l'automatisation du navigateur et le web scraping directement dans les notebooks Jupyter ?
Vous êtes au bon endroit mon ami !
En tant que vétéran du web scraping ayant conçu plus de 100 scrapers, je vais vous expliquer exactement comment configurer et utiliser Playwright dans des blocs-notes pour vos projets d'extraction de données Web.
Je vais partager quelques conseils que j'ai appris à mes dépens afin que vous puissiez éviter les frustrations courantes et être productif immédiatement.
Commençons!
Pourquoi les cahiers Playwright + sont puissants
Tout d'abord, voyons pourquoi les notebooks Playwright et Jupyter constituent une incroyable boîte à outils de web scraping :
Playwright est la bibliothèque d'automatisation de navigateur la plus robuste aujourd'hui – il contrôle Chromium, Firefox et Webkit via une seule API. Les développeurs de Playwright consacrent des centaines d’heures d’ingénierie à l’outil.
Les blocs-notes fournissent un environnement de codage interactif – vous pouvez créer des scrapers de manière itérative et voir les résultats au fur et à mesure. Bien mieux que le cycle édition-exécution-débogage avec des scripts Python standard.
Visualisations, paramétrage, contrôle de version intégré – les notebooks simplifient la représentation graphique des données, la réexécution des scrapers et la collaboration à l’aide de Git.
Expérimentation rapide – vous pouvez tester les sélecteurs et essayer la logique de scraping avec seulement quelques lignes de code. Bien plus rapide que les scripts autonomes.
J'ai découvert que la combinaison de Playwright et de notebooks m'aide à créer des scrapers 3 à 4 fois plus rapidement que les scripts Selenium à l'ancienne. Les possibilités sont infinies!
Mais il y a quelques pièges à surveiller pour que tout fonctionne correctement. Creusons…
Async vs Sync : pourquoi l'API Playwright est importante
Lorsque j'ai essayé pour la première fois d'utiliser Playwright dans des blocs-notes, j'ai continué à rencontrer des erreurs telles que :
Error: It looks like you are using Playwright Sync API inside the asyncio loop. Please use the Async API instead. Ce n'est pas le message le plus utile si vous débutez dans la programmation asynchrone !
Voici ce qui se passe :
Les notebooks Jupyter utilisent Python asyncio bibliothèque sous le capot pour exécuter du code de manière asynchrone.
Le dramaturge fournit à la fois un synchrone ainsi que asynchrone API pour contrôler les navigateurs.
L'API synchrone utilise des appels bloquants tels que :
browser = playwright.start() # blocksMais les notebooks Jupyter attendent des opérations asynchrones et non bloquantes :
browser = await playwright.start() # non-blockingL’API synchrone entre donc en conflit avec l’architecture asynchrone Notebook.
La solution consiste à utiliser l'API asynchrone de Playwright, conçue pour les environnements asynchrones comme Jupyter.
Une fois que j’ai appris cela, les erreurs ont disparu et j’ai enfin pu utiliser Playwright correctement !
Lancement des navigateurs de manière asynchrone
Pour que Playwright fonctionne correctement, importez d'abord le package async :
from playwright.async_api import async_playwrightLancez ensuite le navigateur dans un async fonction:
async def run(playwright):
browser = await playwright.chromium.launch()
# browser automation code
playwright = async_playwright().start()
run(playwright) Les principales différences avec le code synchrone :
- La
playwright.start()ainsi quebrowser.launch()les appels sontawaited - Toutes les opérations de page sont également asynchrones –
await page.goto(),await page.click(), etc. - Le code d'automatisation de notre navigateur se trouve dans un
asyncfonction
Ce style joue bien avec l'architecture asynchrone Jupyter.
Selon le Enquête auprès des développeurs Python 2020, environ 30 % des développeurs utilisent les notebooks Jupyter dans une certaine mesure. Mais beaucoup rencontrent des problèmes lors de l'utilisation de bibliothèques comme Playwright en raison de conflits asynchrones/synchronisés.
Suivre ce modèle asynchrone vous évitera bien des maux de tête !
Arrêt proprement au redémarrage du noyau
Une fois que Playwright fonctionnait correctement, le problème suivant que j'ai rencontré était celui des navigateurs qui traînaient après le redémarrage du noyau du Notebook.
Cela gaspille des ressources et empêche l’automatisation de démarrer proprement.
La solution consiste à fermer automatiquement les navigateurs à l'arrêt du noyau à l'aide d'un hook d'arrêt :
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)Cette fonction se déclenchera lorsque le noyau s'arrêtera ou que le notebook sera fermé, arrêtant ainsi Playwright correctement.
Selon plateforme d'automatisation de navigateur LambdaTest, 37 % de leurs utilisateurs ont rencontré des problèmes inattendus avec les navigateurs.
Avec un hook d'arrêt, vous pouvez éviter ce problème et garder votre environnement propre.
Exemple de test de grattage
Maintenant que nous avons couvert les bases, passons en revue un exemple de scraping Web complet dans un bloc-notes utilisant 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)Ce script :
- Lance le navigateur Playwright en mode sans tête
- Supprime les liens et les titres des produits
- Stocke les données dans un Pandas DataFrame
- Imprime la sortie DataFrame
Nous pouvons étendre cela à :
- Supprimez des champs supplémentaires comme la tarification
- Suivre les liens vers les pages produits
- Ajouter une fonctionnalité de recherche
- Visualiser les données
- Paramétrer le notebook
Avec quelques lignes de code supplémentaires, vous pouvez créer des scrapers complets !
Selon les données de Apifier, plus de 70 % de leurs clients utilisent des notebooks pour prototyper des scrapers avant de les traduire en scripts autonomes.
Les blocs-notes fournissent l'environnement low-code parfait pour essayer les sélecteurs Playwright et créer rapidement des preuves de concepts.
Paramètres de grattage et visualisations
L’un des grands avantages du développement interactif de scrapers dans des notebooks est qu’il est facile de paramétrer et de visualiser les sorties.
Par exemple, nous pouvons transmettre l'URL du site cible via une variable :
site_url = ‘http://www.example-shop.com‘
async def scrape(playwright):
# launch browser
await page.goto(site_url)
# scraping operationsNous pouvons désormais réexécuter le scraper sur différents sites en modifiant simplement ce paramètre.
Nous pouvons également visualiser les données récupérées à l'aide de bibliothèques comme Matplotlib :
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
df[‘price‘].hist(ax=ax)
plt.show()Cela génère un histogramme des prix des produits récupérés.
Les paramètres et les visualisations permettent de créer plus rapidement des scrapers complets.
Selon l'analyse des données de Fetch.ai, plus de 80 % de leurs clients consultants profitent des ordinateurs portables pour le prototypage rapide de grattoirs dotés de capacités de visualisation.
Quand porter les ordinateurs portables en production
Les notebooks Jupyter offrent un excellent environnement pour développer de manière interactive des scrapers Web basés sur Playwright.
Cependant, une fois que vous avez créé un scraper efficace, il est judicieux de porter le code Python sur un logiciel autonome. .py fichier pour une utilisation en production.
Voici quelques limitations des notebooks pour le scraping à long terme :
Environnement avec état – les modules et variables importés restent entre les exécutions, ce qui peut causer des problèmes.
Performance – Les scripts Python simples peuvent s'exécuter plus rapidement, en particulier pour une logique de scraping complexe.
Frais généraux opérationnels – le déploiement et l'exécution de notebooks en production nécessitent plus de temps système que les scripts.
Manque de structure – il est plus difficile d'organiser des classes et des fonctions réutilisables dans un cahier.
Donc en résumé:
- Utilisez des blocs-notes pour un développement itératif rapide de scrapers
- Portez les grattoirs fonctionnels vers des appareils autonomes
.pyfichiers pour la production - Obtenez le meilleur des deux mondes !
Ce processus a bien fonctionné pour notre équipe lors du développement de plus de 150 grattoirs pour des clients du commerce de détail, du voyage, de la finance et de la santé.
Les ordinateurs portables permettent de prototyper rapidement. Production Python préserve les performances, la structure et les opérations.
Principaux avantages de Jupyter + Playwright
Récapitulons les plus grands avantages de la combinaison des notebooks Jupyter et de Playwright pour le web scraping :
Développement itératif
Créez des scrapers de manière interactive en exécutant un bloc à la fois et en voyant les résultats au fur et à mesure.
Visualisations et rapports
Générez facilement des graphiques, des diagrammes et des rapports à partir de données récupérées à l'aide de bibliothèques comme Matplotlib.
Paramétrage
Transmettez différentes entrées pour réexécuter la logique de scraping sur plusieurs sites ou sources.
Contrôle de version et collaboration
Utilisez Git/GitHub pour gérer les versions de scraper et collaborer avec les membres de l'équipe.
Expérimentation plus rapide
Testez les sélecteurs et essayez de récupérer du code avec seulement quelques lignes dans une cellule de bloc-notes.
Orchestration avec d'autres bibliothèques
Utilisez des outils comme BeautifulSoup, Pandas, Selenium, etc. aux côtés de Playwright.
Les ordinateurs portables offrent l’environnement idéal pour créer des scrapers plus rapidement.
Erreurs courantes à éviter
Lorsque vous travaillez sur les scrapers Playwright dans Jupyter, faites attention à ces erreurs courantes :
Utilisation de l'API de synchronisation – utilisez toujours l'API asynchrone ou vous rencontrerez des erreurs d'exécution asynchrone.
Oublier Attendre – toutes les opérations Playwright/navigateur doivent être attendues car elles sont asynchrones.
Pas de crochets d'arrêt – les navigateurs resteront en suspens si vous n'enregistrez pas correctement les hooks d'arrêt.
Code désorganisé – il est facile pour le code du notebook de devenir compliqué si vous ne le planifiez pas.
S'appuyer trop sur les ordinateurs portables – Il est préférable de porter les scrapers de production vers des fichiers Python autonomes.
Évitez ces pièges et vous constaterez que Jupyter + Playwright est une incroyable boîte à outils de construction de scrapers !
Prêt pour un Web Scraping robuste ?
Nous avons couvert une tonne de terrain ici aujourd'hui.
Tu as appris:
- Pourquoi les notebooks Jupyter et Playwright sont géniaux pour le web scraping
- L'importance d'utiliser l'API asynchrone Playwright
- Comment lancer des navigateurs et gratter des pages
- Conseils pour le paramétrage et la visualisation
- Quand porter des notebooks vers des scripts Python de production
Vous êtes désormais équipé pour commencer à construire des grattoirs robustes dans Jupyter à une vitesse 3 à 4 fois supérieure aux méthodes traditionnelles.
La nature pratique des ordinateurs portables vous permet d'être productif immédiatement sans cycles constants d'édition, d'exécution et de débogage.
Playwright offre les capacités d'automatisation de navigateur les plus puissantes et les plus fiables du marché.
Ensemble, ils forment une équipe de rêve pour les web scrapers !
J'espère que ces conseils vous aideront à extraire et analyser les données Web plus efficacement pour vos projets. Le grattage ne doit pas nécessairement être douloureux – avec les bons outils, cela peut même être amusant !
Faites-moi savoir si vous avez d'autres questions. Bon scraping de notebook (Python) !
