Scraping Web Python - Guide rapide

Le scraping Web est un processus automatique d'extraction d'informations à partir du Web. Ce chapitre vous donnera une idée approfondie du web scraping, sa comparaison avec l'exploration web et pourquoi vous devriez opter pour le web scraping. Vous découvrirez également les composants et le fonctionnement d'un grattoir Web.

Qu'est-ce que le Web Scraping?

Le sens du dictionnaire du mot «mise au rebut» implique d'obtenir quelque chose sur le Web. Ici, deux questions se posent: ce que nous pouvons obtenir du Web et comment l'obtenir.

La réponse à la première question est ‘data’. Les données sont indispensables pour tout programmeur et l'exigence de base de tout projet de programmation est la grande quantité de données utiles.

La réponse à la deuxième question est un peu délicate, car il existe de nombreuses façons d'obtenir des données. En général, nous pouvons obtenir des données à partir d'une base de données ou d'un fichier de données et d'autres sources. Mais que faire si nous avons besoin d'une grande quantité de données disponibles en ligne? Une façon d'obtenir ce type de données consiste à rechercher manuellement (en cliquant dans un navigateur Web) et à enregistrer (copier-coller dans une feuille de calcul ou un fichier) les données requises. Cette méthode est assez fastidieuse et prend du temps. Une autre façon d'obtenir de telles données consiste à utiliserweb scraping.

Web scraping, aussi appelé web data mining ou web harvesting, est le processus de construction d'un agent capable d'extraire, d'analyser, de télécharger et d'organiser automatiquement des informations utiles du Web. En d'autres termes, nous pouvons dire qu'au lieu de sauvegarder manuellement les données des sites Web, le logiciel de scraping Web chargera et extraira automatiquement les données de plusieurs sites Web selon nos besoins.

Origine du Web Scraping

L'origine du scraping Web est la mise au rebut d'écran, qui a été utilisée pour intégrer des applications non basées sur le Web ou des applications Windows natives. À l'origine, le grattage d'écran était utilisé avant la large utilisation du World Wide Web (WWW), mais il ne pouvait pas étendre le WWW. Cela a rendu nécessaire l'automatisation de l'approche du grattage d'écran et de la technique appelée‘Web Scraping’ est venu au monde.

Analyse Web v / s Web Scraping

Les termes Web Crawling et Scraping sont souvent utilisés de manière interchangeable car leur concept de base est d'extraire des données. Cependant, ils sont différents les uns des autres. Nous pouvons comprendre la différence fondamentale de leurs définitions.

L'exploration Web est essentiellement utilisée pour indexer les informations sur la page à l'aide de robots aka crawlers. Il est également appeléindexing. D'autre part, le web scraping est un moyen automatisé d'extraire les informations à l'aide de bots aka scrapers. Il est également appelédata extraction.

Pour comprendre la différence entre ces deux termes, regardons le tableau de comparaison ci-dessous -

Exploration Web	Grattage Web
Désigne le téléchargement et le stockage du contenu d'un grand nombre de sites Web.	Se réfère à l'extraction d'éléments de données individuels du site Web à l'aide d'une structure spécifique au site.
Fait principalement à grande échelle.	Peut être mis en œuvre à n'importe quelle échelle.
Donne des informations génériques.	Donne des informations spécifiques.
Utilisé par les principaux moteurs de recherche comme Google, Bing, Yahoo. Googlebot est un exemple de robot d'exploration Web.	Les informations extraites à l'aide du web scraping peuvent être utilisées pour se répliquer dans un autre site Web ou peuvent être utilisées pour effectuer une analyse de données. Par exemple, les éléments de données peuvent être des noms, une adresse, un prix, etc.

Utilisations du Web Scraping

Les utilisations et les raisons d'utiliser le web scraping sont aussi infinies que les utilisations du World Wide Web. Les racleurs Web peuvent faire n'importe quoi comme commander de la nourriture en ligne, scanner un site Web d'achat en ligne pour vous et acheter un billet pour un match au moment où ils sont disponibles, etc. Certaines des utilisations importantes du web scraping sont discutées ici -

• E-commerce Websites - Les web scrapers peuvent collecter les données spécialement liées au prix d'un produit spécifique à partir de divers sites de commerce électronique pour leur comparaison.

• Content Aggregators - Le scraping Web est largement utilisé par les agrégateurs de contenu tels que les agrégateurs de nouvelles et les agrégateurs d'emplois pour fournir des données mises à jour à leurs utilisateurs.

• Marketing and Sales Campaigns - Les web scrapers peuvent être utilisés pour obtenir des données telles que des e-mails, un numéro de téléphone, etc. pour les campagnes de vente et de marketing.

• Search Engine Optimization (SEO) - Le scraping Web est largement utilisé par les outils de référencement comme SEMRush, Majestic, etc. pour indiquer aux entreprises comment elles se classent pour les mots-clés de recherche qui leur importent.

• Data for Machine Learning Projects - La récupération des données pour les projets d'apprentissage automatique dépend du web scraping.

Data for Research - Les chercheurs peuvent collecter des données utiles aux fins de leurs travaux de recherche en économisant leur temps grâce à ce processus automatisé.

Composants d'un Web Scraper

Un racleur de bande se compose des composants suivants -

Module de robot d'exploration Web

Un composant très nécessaire de Web Scraper, le module de robot d'exploration Web, est utilisé pour naviguer sur le site Web cible en faisant une requête HTTP ou HTTPS aux URL. Le robot télécharge les données non structurées (contenu HTML) et les transmet à l'extracteur, le module suivant.

Extracteur

L'extracteur traite le contenu HTML récupéré et extrait les données dans un format semi-structuré. Ceci est également appelé module d'analyseur et utilise différentes techniques d'analyse telles que l'expression régulière, l'analyse HTML, l'analyse DOM ou l'intelligence artificielle pour son fonctionnement.

Module de transformation et de nettoyage des données

Les données extraites ci-dessus ne conviennent pas pour une utilisation immédiate. Il doit passer par un module de nettoyage pour que nous puissions l'utiliser. Les méthodes telles que la manipulation de chaînes ou l'expression régulière peuvent être utilisées à cette fin. Notez que l'extraction et la transformation peuvent également être effectuées en une seule étape.

Module de stockage

Après avoir extrait les données, nous devons les stocker selon nos besoins. Le module de stockage sortira les données dans un format standard qui peut être stocké dans une base de données ou au format JSON ou CSV.

Fonctionnement d'un Web Scraper

Web Scraper peut être défini comme un logiciel ou un script utilisé pour télécharger le contenu de plusieurs pages Web et en extraire des données.

Nous pouvons comprendre le fonctionnement d'un grattoir Web en étapes simples, comme indiqué dans le diagramme ci-dessus.

Étape 1: Téléchargement de contenu à partir de pages Web

Dans cette étape, un racleur Web téléchargera le contenu demandé à partir de plusieurs pages Web.

Étape 2: extraction des données

Les données sur les sites Web sont en HTML et pour la plupart non structurées. Par conséquent, dans cette étape, Web Scraper analysera et extraira les données structurées du contenu téléchargé.

Étape 3: stockage des données

Ici, un racleur Web stockera et enregistrera les données extraites dans l'un des formats tels que CSV, JSON ou dans une base de données.

Étape 4: Analyse des données

Une fois toutes ces étapes effectuées avec succès, le racleur de bande analysera les données ainsi obtenues.

Dans le premier chapitre, nous avons appris ce qu'est le web scraping. Dans ce chapitre, voyons comment implémenter le web scraping à l'aide de Python.

Pourquoi Python pour le Web Scraping?

Python est un outil populaire pour implémenter le web scraping. Le langage de programmation Python est également utilisé pour d'autres projets utiles liés à la cybersécurité, aux tests de pénétration ainsi qu'aux applications médico-légales numériques. En utilisant la programmation de base de Python, le web scraping peut être effectué sans utiliser aucun autre outil tiers.

Le langage de programmation Python gagne en popularité et les raisons qui font de Python un bon choix pour les projets de scraping Web sont les suivantes:

Simplicité de la syntaxe

Python a la structure la plus simple par rapport aux autres langages de programmation. Cette fonctionnalité de Python facilite les tests et un développeur peut se concentrer davantage sur la programmation.

Modules intégrés

Une autre raison d'utiliser Python pour le scraping Web est les bibliothèques utiles intégrées et externes qu'il possède. Nous pouvons effectuer de nombreuses implémentations liées au web scraping en utilisant Python comme base de programmation.

Langage de programmation Open Source

Python bénéficie d'un énorme soutien de la communauté car c'est un langage de programmation open source.

Large gamme d'applications

Python peut être utilisé pour diverses tâches de programmation allant des petits scripts shell aux applications Web d'entreprise.

Installation de Python

La distribution Python est disponible pour des plates-formes telles que Windows, MAC et Unix / Linux. Nous devons télécharger uniquement le code binaire applicable à notre plate-forme pour installer Python. Mais dans le cas où le code binaire de notre plateforme n'est pas disponible, nous devons avoir un compilateur C pour que le code source puisse être compilé manuellement.

Nous pouvons installer Python sur différentes plates-formes comme suit -

Installer Python sous Unix et Linux

Vous devez suivre les étapes ci-dessous pour installer Python sur des machines Unix / Linux -

Step 1 - Aller sur le lien https://www.python.org/downloads/

Step 2 - Téléchargez le code source compressé disponible pour Unix / Linux sur le lien ci-dessus.

Step 3 - Extrayez les fichiers sur votre ordinateur.

Step 4 - Utilisez les commandes suivantes pour terminer l'installation -

run ./configure script
make
make install

Vous pouvez trouver Python installé à l'emplacement standard /usr/local/bin et ses bibliothèques à /usr/local/lib/pythonXX, où XX est la version de Python.

Installer Python sur Windows

Vous devez suivre les étapes ci-dessous pour installer Python sur les machines Windows -

Step 1 - Aller sur le lien https://www.python.org/downloads/

Step 2 - Téléchargez le programme d'installation de Windows python-XYZ.msi fichier, où XYZ est la version que nous devons installer.

Step 3 - Maintenant, enregistrez le fichier d'installation sur votre machine locale et exécutez le fichier MSI.

Step 4 - Enfin, exécutez le fichier téléchargé pour afficher l'assistant d'installation de Python.

Installer Python sur Macintosh

Il faut utiliser Homebrew pour installer Python 3 sur Mac OS X. Homebrew est facile à installer et constitue un excellent programme d'installation.

Homebrew peut également être installé à l'aide de la commande suivante -

$ ruby -e "$(curl -fsSL
https://raw.githubusercontent.com/Homebrew/install/master/install)"

Pour mettre à jour le gestionnaire de paquets, nous pouvons utiliser la commande suivante -

$ brew update

Avec l'aide de la commande suivante, nous pouvons installer Python3 sur notre machine MAC -

$ brew install python3

Configurer le PATH

Vous pouvez utiliser les instructions suivantes pour configurer le chemin sur divers environnements -

Configuration du chemin sous Unix / Linux

Utilisez les commandes suivantes pour configurer les chemins à l'aide de divers shells de commande -

Pour shell csh

setenv PATH "$PATH:/usr/local/bin/python".

Pour bash shell (Linux)

ATH="$PATH:/usr/local/bin/python".

Pour sh ou ksh shell

PATH="$PATH:/usr/local/bin/python".

Configuration du chemin sous Windows

Pour définir le chemin sur Windows, nous pouvons utiliser le chemin %path%;C:\Python à l'invite de commande, puis appuyez sur Entrée.

Exécuter Python

Nous pouvons démarrer Python en utilisant l'une des trois méthodes suivantes -

Interprète interactif

Un système d'exploitation tel que UNIX et DOS qui fournit un interpréteur de ligne de commande ou un shell peut être utilisé pour démarrer Python.

Nous pouvons commencer à coder dans l'interpréteur interactif comme suit -

Step 1 - Entrez python sur la ligne de commande.

Step 2 - Ensuite, nous pouvons commencer à coder tout de suite dans l'interpréteur interactif.

$python # Unix/Linux
or
python% # Unix/Linux
or
C:> python # Windows/DOS

Script depuis la ligne de commande

Nous pouvons exécuter un script Python en ligne de commande en appelant l'interpréteur. Il peut être compris comme suit -

$python script.py # Unix/Linux
or
python% script.py # Unix/Linux
or
C: >python script.py # Windows/DOS

Environnement de développement intégré

Nous pouvons également exécuter Python à partir d'un environnement GUI si le système dispose d'une application GUI prenant en charge Python. Certains IDE prenant en charge Python sur différentes plates-formes sont indiqués ci-dessous -

IDE for UNIX - UNIX, pour Python, a IDLE IDE.

IDE for Windows - Windows a PythonWin IDE qui a également une interface graphique.

IDE for Macintosh - Macintosh a IDLE IDE qui est téléchargeable sous forme de fichiers MacBinary ou BinHex'd depuis le site Web principal.

Dans ce chapitre, apprenons divers modules Python que nous pouvons utiliser pour le web scraping.

Environnements de développement Python utilisant virtualenv

Virtualenv est un outil pour créer des environnements Python isolés. Avec l'aide de virtualenv, nous pouvons créer un dossier contenant tous les exécutables nécessaires pour utiliser les packages requis par notre projet Python. Cela nous permet également d'ajouter et de modifier des modules Python sans accéder à l'installation globale.

Vous pouvez utiliser la commande suivante pour installer virtualenv -

(base) D:\ProgramData>pip install virtualenv
Collecting virtualenv
   Downloading
https://files.pythonhosted.org/packages/b6/30/96a02b2287098b23b875bc8c2f58071c3
5d2efe84f747b64d523721dc2b5/virtualenv-16.0.0-py2.py3-none-any.whl
(1.9MB)
   100% |¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦| 1.9MB 86kB/s
Installing collected packages: virtualenv
Successfully installed virtualenv-16.0.0

Maintenant, nous devons créer un répertoire qui représentera le projet à l'aide de la commande suivante -

(base) D:\ProgramData>mkdir webscrap

Maintenant, entrez dans ce répertoire à l'aide de cette commande suivante -

(base) D:\ProgramData>cd webscrap

Maintenant, nous devons initialiser le dossier d'environnement virtuel de notre choix comme suit -

(base) D:\ProgramData\webscrap>virtualenv websc
Using base prefix 'd:\\programdata'
New python executable in D:\ProgramData\webscrap\websc\Scripts\python.exe
Installing setuptools, pip, wheel...done.

Maintenant, activez l'environnement virtuel avec la commande donnée ci-dessous. Une fois activé avec succès, vous verrez le nom de celui-ci sur le côté gauche entre parenthèses.

(base) D:\ProgramData\webscrap>websc\scripts\activate

Nous pouvons installer n'importe quel module dans cet environnement comme suit -

(websc) (base) D:\ProgramData\webscrap>pip install requests
Collecting requests
   Downloading
https://files.pythonhosted.org/packages/65/47/7e02164a2a3db50ed6d8a6ab1d6d60b69
c4c3fdf57a284257925dfc12bda/requests-2.19.1-py2.py3-none-any.whl (9
1kB)
   100% |¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦| 92kB 148kB/s
Collecting chardet<3.1.0,>=3.0.2 (from requests)
   Downloading
https://files.pythonhosted.org/packages/bc/a9/01ffebfb562e4274b6487b4bb1ddec7ca
55ec7510b22e4c51f14098443b8/chardet-3.0.4-py2.py3-none-any.whl (133
kB)
   100% |¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦| 143kB 369kB/s
Collecting certifi>=2017.4.17 (from requests)
   Downloading
https://files.pythonhosted.org/packages/df/f7/04fee6ac349e915b82171f8e23cee6364
4d83663b34c539f7a09aed18f9e/certifi-2018.8.24-py2.py3-none-any.whl
(147kB)
   100% |¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦| 153kB 527kB/s
Collecting urllib3<1.24,>=1.21.1 (from requests)
   Downloading
https://files.pythonhosted.org/packages/bd/c9/6fdd990019071a4a32a5e7cb78a1d92c5
3851ef4f56f62a3486e6a7d8ffb/urllib3-1.23-py2.py3-none-any.whl (133k
B)
   100% |¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦| 143kB 517kB/s
Collecting idna<2.8,>=2.5 (from requests)
   Downloading
https://files.pythonhosted.org/packages/4b/2a/0276479a4b3caeb8a8c1af2f8e4355746
a97fab05a372e4a2c6a6b876165/idna-2.7-py2.py3-none-any.whl (58kB)
   100% |¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦| 61kB 339kB/s
Installing collected packages: chardet, certifi, urllib3, idna, requests
Successfully installed certifi-2018.8.24 chardet-3.0.4 idna-2.7 requests-2.19.1
urllib3-1.23

Pour désactiver l'environnement virtuel, nous pouvons utiliser la commande suivante -

(websc) (base) D:\ProgramData\webscrap>deactivate
(base) D:\ProgramData\webscrap>

Vous pouvez voir que (websc) a été désactivé.

Modules Python pour le Web Scraping

Le scraping Web est le processus de construction d'un agent capable d'extraire, d'analyser, de télécharger et d'organiser automatiquement des informations utiles du Web. En d'autres termes, au lieu d'enregistrer manuellement les données des sites Web, le logiciel de scraping Web chargera et extraira automatiquement les données de plusieurs sites Web conformément à nos exigences.

Dans cette section, nous allons discuter des bibliothèques Python utiles pour le scraping Web.

Demandes

Il s'agit d'une simple bibliothèque de scraping Web python. Il s'agit d'une bibliothèque HTTP efficace utilisée pour accéder aux pages Web. Avec l'aide deRequests, nous pouvons obtenir le code HTML brut des pages Web qui peut ensuite être analysé pour récupérer les données. Avant d'utiliserrequests, laissez-nous comprendre son installation.

Installation des demandes

Nous pouvons l'installer soit sur notre environnement virtuel, soit sur l'installation globale. Avec l'aide depip commande, nous pouvons facilement l'installer comme suit -

(base) D:\ProgramData> pip install requests
Collecting requests
Using cached
https://files.pythonhosted.org/packages/65/47/7e02164a2a3db50ed6d8a6ab1d6d60b69
c4c3fdf57a284257925dfc12bda/requests-2.19.1-py2.py3-none-any.whl
Requirement already satisfied: idna<2.8,>=2.5 in d:\programdata\lib\sitepackages
(from requests) (2.6)
Requirement already satisfied: urllib3<1.24,>=1.21.1 in
d:\programdata\lib\site-packages (from requests) (1.22)
Requirement already satisfied: certifi>=2017.4.17 in d:\programdata\lib\sitepackages
(from requests) (2018.1.18)
Requirement already satisfied: chardet<3.1.0,>=3.0.2 in
d:\programdata\lib\site-packages (from requests) (3.0.4)
Installing collected packages: requests
Successfully installed requests-2.19.1

Exemple

Dans cet exemple, nous effectuons une requête GET HTTP pour une page Web. Pour cela, nous devons d'abord importer la bibliothèque de requêtes comme suit -

In [1]: import requests

Dans cette ligne de code suivante, nous utilisons des requêtes pour effectuer des requêtes HTTP GET pour l'url: https://authoraditiagarwal.com/ en effectuant une demande GET.

In [2]: r = requests.get('https://authoraditiagarwal.com/')

Nous pouvons maintenant récupérer le contenu en utilisant .text propriété comme suit -

In [5]: r.text[:200]

Observez que dans la sortie suivante, nous avons obtenu les 200 premiers caractères.

Out[5]: '<!DOCTYPE html>\n<html lang="en-US"\n\titemscope
\n\titemtype="http://schema.org/WebSite" \n\tprefix="og: http://ogp.me/ns#"
>\n<head>\n\t<meta charset
="UTF-8" />\n\t<meta http-equiv="X-UA-Compatible" content="IE'

Urllib3

C'est une autre bibliothèque Python qui peut être utilisée pour récupérer des données à partir d'URL similaires au requestsbibliothèque. Vous pouvez en savoir plus à ce sujet dans sa documentation technique à l'adressehttps://urllib3.readthedocs.io/en/latest/.

Installation d'Urllib3

En utilisant le pip commande, nous pouvons installer urllib3 soit dans notre environnement virtuel, soit en installation globale.

(base) D:\ProgramData>pip install urllib3
Collecting urllib3
Using cached
https://files.pythonhosted.org/packages/bd/c9/6fdd990019071a4a32a5e7cb78a1d92c5
3851ef4f56f62a3486e6a7d8ffb/urllib3-1.23-py2.py3-none-any.whl
Installing collected packages: urllib3
Successfully installed urllib3-1.23

Exemple: Scraping avec Urllib3 et BeautifulSoup

Dans l'exemple suivant, nous grattons la page Web en utilisant Urllib3 et BeautifulSoup. Nous utilisonsUrllib3à la place de la bibliothèque de requêtes pour obtenir les données brutes (HTML) de la page Web. Ensuite, nous utilisonsBeautifulSoup pour analyser ces données HTML.

import urllib3
from bs4 import BeautifulSoup
http = urllib3.PoolManager()
r = http.request('GET', 'https://authoraditiagarwal.com')
soup = BeautifulSoup(r.data, 'lxml')
print (soup.title)
print (soup.title.text)

C'est la sortie que vous observerez lorsque vous exécuterez ce code -

<title>Learn and Grow with Aditi Agarwal</title>
Learn and Grow with Aditi Agarwal

Sélénium

Il s'agit d'une suite de tests automatisés open source pour les applications Web sur différents navigateurs et plates-formes. Ce n'est pas un outil unique mais une suite de logiciels. Nous avons des liaisons de sélénium pour Python, Java, C #, Ruby et JavaScript. Ici, nous allons effectuer du web scraping en utilisant le sélénium et ses liaisons Python. Vous pouvez en savoir plus sur Selenium avec Java sur le lien Selenium .

Les liaisons Selenium Python fournissent une API pratique pour accéder à Selenium WebDrivers comme Firefox, IE, Chrome, Remote, etc. Les versions actuelles de Python prises en charge sont 2.7, 3.5 et supérieures.

Installation de sélénium

En utilisant le pip commande, nous pouvons installer urllib3 soit dans notre environnement virtuel, soit en installation globale.

pip install selenium

Comme le sélénium nécessite un pilote pour s'interfacer avec le navigateur choisi, nous devons le télécharger. Le tableau suivant montre différents navigateurs et leurs liens pour les télécharger.

Chrome	https://sites.google.com/a/chromium.org/
Edge	https://developer.microsoft.com/
Firefox	https://github.com/
Safari	https://webkit.org/

Exemple

Cet exemple montre le scraping Web à l'aide de sélénium. Il peut également être utilisé pour des tests appelés tests de sélénium.

Après avoir téléchargé le pilote particulier pour la version spécifiée du navigateur, nous devons faire de la programmation en Python.

Tout d'abord, vous devez importer webdriver à partir du sélénium comme suit -

from selenium import webdriver

Maintenant, fournissez le chemin du pilote Web que nous avons téléchargé selon nos besoins -

path = r'C:\\Users\\gaurav\\Desktop\\Chromedriver'
browser = webdriver.Chrome(executable_path = path)

Maintenant, fournissez l'url que nous voulons ouvrir dans ce navigateur Web maintenant contrôlé par notre script Python.

browser.get('https://authoraditiagarwal.com/leadershipmanagement')

Nous pouvons également gratter un élément particulier en fournissant le xpath comme fourni dans lxml.

browser.find_element_by_xpath('/html/body').click()

Vous pouvez vérifier le navigateur, contrôlé par le script Python, pour la sortie.

Scrapy

Scrapy est un framework d'exploration Web rapide et open-source écrit en Python, utilisé pour extraire les données de la page Web à l'aide de sélecteurs basés sur XPath. Scrapy a été publié pour la première fois le 26 juin 2008 sous licence BSD, avec un jalon 1.0 publié en juin 2015. Il nous fournit tous les outils dont nous avons besoin pour extraire, traiter et structurer les données des sites Web.

Installation de Scrapy

En utilisant le pip commande, nous pouvons installer urllib3 soit dans notre environnement virtuel, soit en installation globale.

pip install scrapy

Pour une étude plus détaillée de Scrapy vous pouvez aller sur le lien Scrapy

Avec Python, nous pouvons gratter n'importe quel site Web ou des éléments particuliers d'une page Web, mais avez-vous une idée si c'est légal ou non? Avant de gratter un site Web, nous devons connaître la légalité du scraping Web. Ce chapitre expliquera les concepts liés à la légalité du web scraping.

introduction

En règle générale, si vous prévoyez d'utiliser les données récupérées à des fins personnelles, il se peut qu'il n'y ait pas de problème. Mais si vous prévoyez de republier ces données, avant de faire de même, vous devez faire une demande de téléchargement au propriétaire ou faire des recherches de base sur les politiques ainsi que sur les données que vous allez collecter.

Recherche requise avant le grattage

Si vous ciblez un site Web pour en extraire des données, nous devons comprendre son échelle et sa structure. Voici quelques-uns des fichiers que nous devons analyser avant de commencer le scraping Web.

Analyse du fichier robots.txt

En fait, la plupart des éditeurs permettent aux programmeurs d'explorer leurs sites Web dans une certaine mesure. En d'autres termes, les éditeurs souhaitent que des parties spécifiques des sites Web soient explorées. Pour définir cela, les sites Web doivent mettre des règles pour indiquer quelles parties peuvent être explorées et lesquelles ne peuvent pas l'être. Ces règles sont définies dans un fichier appelérobots.txt.

robots.txtest un fichier lisible par l'homme utilisé pour identifier les parties du site Web que les robots d'exploration sont autorisés ou non à extraire. Il n'y a pas de format standard de fichier robots.txt et les éditeurs de site Web peuvent effectuer des modifications selon leurs besoins. Nous pouvons vérifier le fichier robots.txt pour un site Web particulier en fournissant une barre oblique et robots.txt après l'URL de ce site Web. Par exemple, si nous voulons le vérifier pour Google.com, nous devons taperhttps://www.google.com/robots.txt et nous obtiendrons quelque chose comme suit -

User-agent: *
Disallow: /search
Allow: /search/about
Allow: /search/static
Allow: /search/howsearchworks
Disallow: /sdch
Disallow: /groups
Disallow: /index.html?
Disallow: /?
Allow: /?hl=
Disallow: /?hl=*&
Allow: /?hl=*&gws_rd=ssl$
and so on……..

Certaines des règles les plus courantes définies dans le fichier robots.txt d'un site Web sont les suivantes:

User-agent: BadCrawler
Disallow: /

La règle ci-dessus signifie que le fichier robots.txt demande à un robot avec BadCrawler l'agent utilisateur de ne pas explorer son site Web.

User-agent: *
Crawl-delay: 5
Disallow: /trap

La règle ci-dessus signifie que le fichier robots.txt retarde un robot d'exploration de 5 secondes entre les demandes de téléchargement de tous les user-agents pour éviter de surcharger le serveur. le/traplink essaiera de bloquer les robots malveillants qui suivent des liens non autorisés. Il existe de nombreuses autres règles qui peuvent être définies par l'éditeur du site Web selon leurs besoins. Certains d'entre eux sont discutés ici -

Analyse des fichiers Sitemap

Que devez-vous faire si vous souhaitez explorer un site Web pour obtenir des informations à jour? Vous explorerez chaque page Web pour obtenir ces informations mises à jour, mais cela augmentera le trafic du serveur de ce site Web particulier. C'est pourquoi les sites Web fournissent des fichiers de plan du site pour aider les robots d'exploration à localiser le contenu mis à jour sans avoir à explorer chaque page Web. La norme Sitemap est définie àhttp://www.sitemaps.org/protocol.html.

Contenu du fichier Sitemap

Ce qui suit est le contenu du fichier plan du site de https://www.microsoft.com/robots.txt qui est découvert dans le fichier robot.txt -

Sitemap: https://www.microsoft.com/en-us/explore/msft_sitemap_index.xml
Sitemap: https://www.microsoft.com/learning/sitemap.xml
Sitemap: https://www.microsoft.com/en-us/licensing/sitemap.xml
Sitemap: https://www.microsoft.com/en-us/legal/sitemap.xml
Sitemap: https://www.microsoft.com/filedata/sitemaps/RW5xN8
Sitemap: https://www.microsoft.com/store/collections.xml
Sitemap: https://www.microsoft.com/store/productdetailpages.index.xml
Sitemap: https://www.microsoft.com/en-us/store/locations/store-locationssitemap.xml

Le contenu ci-dessus montre que le plan du site répertorie les URL sur le site Web et permet en outre à un webmaster de spécifier des informations supplémentaires telles que la date de la dernière mise à jour, le changement de contenu, l'importance de l'URL par rapport aux autres, etc. sur chaque URL.

Quelle est la taille du site Web?

La taille d'un site Web, c'est-à-dire le nombre de pages Web d'un site Web, affecte-t-elle la façon dont nous explorons? Oui, certainement. Parce que si nous avons moins de pages Web à explorer, l'efficacité ne serait pas un problème sérieux, mais supposons que si notre site Web comporte des millions de pages Web, par exemple Microsoft.com, le téléchargement de chaque page Web de manière séquentielle prendrait plusieurs mois et alors l'efficacité serait un problème sérieux.

Vérification de la taille du site Web

En vérifiant la taille du résultat du robot d'exploration de Google, nous pouvons avoir une estimation de la taille d'un site Web. Notre résultat peut être filtré en utilisant le mot-clésitetout en effectuant la recherche Google. Par exemple, estimer la taille dehttps://authoraditiagarwal.com/ est donné ci-dessous -

Vous pouvez voir qu'il y a environ 60 résultats, ce qui signifie que ce n'est pas un gros site Web et que l'exploration ne poserait pas de problème d'efficacité.

Quelle technologie est utilisée par le site Web?

Une autre question importante est de savoir si la technologie utilisée par le site Web affecte la façon dont nous explorons? Oui, cela affecte. Mais comment vérifier la technologie utilisée par un site Web? Il existe une bibliothèque Python nomméebuiltwith avec l'aide de laquelle nous pouvons découvrir la technologie utilisée par un site Web.

Exemple

Dans cet exemple, nous allons vérifier la technologie utilisée par le site Web https://authoraditiagarwal.com avec l'aide de la bibliothèque Python builtwith. Mais avant d'utiliser cette bibliothèque, nous devons l'installer comme suit -

(base) D:\ProgramData>pip install builtwith
Collecting builtwith
   Downloading
https://files.pythonhosted.org/packages/9b/b8/4a320be83bb3c9c1b3ac3f9469a5d66e0
2918e20d226aa97a3e86bddd130/builtwith-1.3.3.tar.gz
Requirement already satisfied: six in d:\programdata\lib\site-packages (from
builtwith) (1.10.0)
Building wheels for collected packages: builtwith
   Running setup.py bdist_wheel for builtwith ... done
   Stored in directory:
C:\Users\gaurav\AppData\Local\pip\Cache\wheels\2b\00\c2\a96241e7fe520e75093898b
f926764a924873e0304f10b2524
Successfully built builtwith
Installing collected packages: builtwith
Successfully installed builtwith-1.3.3

Maintenant, en suivant une simple ligne de codes, nous pouvons vérifier la technologie utilisée par un site Web particulier -

In [1]: import builtwith
In [2]: builtwith.parse('http://authoraditiagarwal.com')
Out[2]:
{'blogs': ['PHP', 'WordPress'],
   'cms': ['WordPress'],
   'ecommerce': ['WooCommerce'],
   'font-scripts': ['Font Awesome'],
   'javascript-frameworks': ['jQuery'],
   'programming-languages': ['PHP'],
   'web-servers': ['Apache']}

Qui est le propriétaire du site Web?

Le propriétaire du site Web est également important, car si le propriétaire est connu pour avoir bloqué les robots d'exploration, les robots d'exploration doivent faire attention lorsqu'ils récupèrent les données du site Web. Il existe un protocole nomméWhois avec l'aide duquel nous pouvons nous renseigner sur le propriétaire du site Web.

Exemple

Dans cet exemple, nous allons vérifier le propriétaire du site Web, disons microsoft.com à l'aide de Whois. Mais avant d'utiliser cette bibliothèque, nous devons l'installer comme suit -

(base) D:\ProgramData>pip install python-whois
Collecting python-whois
   Downloading
https://files.pythonhosted.org/packages/63/8a/8ed58b8b28b6200ce1cdfe4e4f3bbc8b8
5a79eef2aa615ec2fef511b3d68/python-whois-0.7.0.tar.gz (82kB)
   100% |¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦| 92kB 164kB/s
Requirement already satisfied: future in d:\programdata\lib\site-packages (from
python-whois) (0.16.0)
Building wheels for collected packages: python-whois
   Running setup.py bdist_wheel for python-whois ... done
   Stored in directory:
C:\Users\gaurav\AppData\Local\pip\Cache\wheels\06\cb\7d\33704632b0e1bb64460dc2b
4dcc81ab212a3d5e52ab32dc531
Successfully built python-whois
Installing collected packages: python-whois
Successfully installed python-whois-0.7.0

Maintenant, en suivant une simple ligne de codes, nous pouvons vérifier la technologie utilisée par un site Web particulier -

In [1]: import whois
In [2]: print (whois.whois('microsoft.com'))
{
   "domain_name": [
      "MICROSOFT.COM",
      "microsoft.com"
   ],
   -------
   "name_servers": [
      "NS1.MSFT.NET",
      "NS2.MSFT.NET",
      "NS3.MSFT.NET",
      "NS4.MSFT.NET",
      "ns3.msft.net",
      "ns1.msft.net",
      "ns4.msft.net",
      "ns2.msft.net"
   ],
   "emails": [
      "[email protected]",
      "[email protected]",
      "[email protected]",
      "[email protected]"
   ],
}

Analyser une page Web signifie comprendre sa structure. Maintenant, la question se pose de savoir pourquoi il est important pour le web scraping? Dans ce chapitre, comprenons cela en détail.

Analyse de page Web

L'analyse de page Web est importante car sans analyse, nous ne sommes pas en mesure de savoir sous quelle forme nous allons recevoir les données (structurées ou non) de cette page Web après l'extraction. Nous pouvons effectuer une analyse de page Web de la manière suivante -

Affichage de la source de la page

C'est un moyen de comprendre comment une page Web est structurée en examinant son code source. Pour mettre en œuvre cela, nous devons faire un clic droit sur la page, puis sélectionner leView page sourceoption. Ensuite, nous obtiendrons les données qui nous intéressent à partir de cette page Web sous forme de HTML. Mais la principale préoccupation concerne les espaces et le formatage qui nous est difficile à formater.

Inspection de la source de la page en cliquant sur l'option Inspecter l'élément

C'est une autre façon d'analyser la page Web. Mais la différence est que cela résoudra le problème du formatage et des espaces dans le code source de la page Web. Vous pouvez l'implémenter en cliquant avec le bouton droit de la souris, puis en sélectionnant leInspect ou Inspect elementoption du menu. Il fournira des informations sur une zone ou un élément particulier de cette page Web.

Différentes façons d'extraire des données d'une page Web

Les méthodes suivantes sont principalement utilisées pour extraire des données d'une page Web -

Expression régulière

Il s'agit d'un langage de programmation hautement spécialisé intégré à Python. Nous pouvons l'utiliser à traversremodule de Python. Il est également appelé RE ou regexes ou modèles regex. À l'aide d'expressions régulières, nous pouvons spécifier certaines règles pour l'ensemble possible de chaînes que nous voulons faire correspondre à partir des données.

Si vous souhaitez en savoir plus sur les expressions régulières en général, accédez au lien https://www.tutorialspoint.com/automata_theory/regular_expressions.htmet si vous souhaitez en savoir plus sur le module re ou l'expression régulière en Python, vous pouvez suivre le lien https://www.tutorialspoint.com/python/python_reg_expressions.htm .

Exemple

Dans l'exemple suivant, nous allons extraire des données sur l'Inde de http://example.webscraping.com après avoir fait correspondre le contenu de <td> à l'aide d'une expression régulière.

import re
import urllib.request
response =
   urllib.request.urlopen('http://example.webscraping.com/places/default/view/India-102')
html = response.read()
text = html.decode()
re.findall('<td class="w2p_fw">(.*?)</td>',text)

Production

La sortie correspondante sera comme indiqué ici -

[
   '<img src="/places/static/images/flags/in.png" />',
   '3,287,590 square kilometres',
   '1,173,108,018',
   'IN',
   'India',
   'New Delhi',
   '<a href="/places/default/continent/AS">AS</a>',
   '.in',
   'INR',
   'Rupee',
   '91',
   '######',
   '^(\\d{6})$',
   'enIN,hi,bn,te,mr,ta,ur,gu,kn,ml,or,pa,as,bh,sat,ks,ne,sd,kok,doi,mni,sit,sa,fr,lus,inc',
   '<div>
      <a href="/places/default/iso/CN">CN </a>
      <a href="/places/default/iso/NP">NP </a>
      <a href="/places/default/iso/MM">MM </a>
      <a href="/places/default/iso/BT">BT </a>
      <a href="/places/default/iso/PK">PK </a>
      <a href="/places/default/iso/BD">BD </a>
   </div>'
]

Notez que dans la sortie ci-dessus, vous pouvez voir les détails sur le pays Inde en utilisant une expression régulière.

Belle soupe

Supposons que nous voulions collecter tous les hyperliens d'une page Web, nous pouvons alors utiliser un analyseur appelé BeautifulSoup qui peut être connu plus en détail à https://www.crummy.com/software/BeautifulSoup/bs4/doc/.En termes simples, BeautifulSoup est une bibliothèque Python permettant d'extraire des données de fichiers HTML et XML. Il peut être utilisé avec des requêtes, car il a besoin d'une entrée (document ou url) pour créer un objet soupe car il ne peut pas récupérer une page Web par lui-même. Vous pouvez utiliser le script Python suivant pour rassembler le titre de la page Web et les hyperliens.

Installer une belle soupe

En utilisant le pip commande, nous pouvons installer beautifulsoup soit dans notre environnement virtuel, soit en installation globale.

(base) D:\ProgramData>pip install bs4
Collecting bs4
   Downloading
https://files.pythonhosted.org/packages/10/ed/7e8b97591f6f456174139ec089c769f89
a94a1a4025fe967691de971f314/bs4-0.0.1.tar.gz
Requirement already satisfied: beautifulsoup4 in d:\programdata\lib\sitepackages
(from bs4) (4.6.0)
Building wheels for collected packages: bs4
   Running setup.py bdist_wheel for bs4 ... done
   Stored in directory:
C:\Users\gaurav\AppData\Local\pip\Cache\wheels\a0\b0\b2\4f80b9456b87abedbc0bf2d
52235414c3467d8889be38dd472
Successfully built bs4
Installing collected packages: bs4
Successfully installed bs4-0.0.1

Exemple

Notez que dans cet exemple, nous étendons l'exemple ci-dessus implémenté avec le module Python de requêtes. nous utilisonsr.text pour créer un objet soupe qui sera ensuite utilisé pour récupérer des détails comme le titre de la page Web.

Tout d'abord, nous devons importer les modules Python nécessaires -

import requests
from bs4 import BeautifulSoup

Dans cette ligne de code suivante, nous utilisons des requêtes pour effectuer des requêtes HTTP GET pour l'url: https://authoraditiagarwal.com/ en effectuant une demande GET.

r = requests.get('https://authoraditiagarwal.com/')

Nous devons maintenant créer un objet Soup comme suit -

soup = BeautifulSoup(r.text, 'lxml')
print (soup.title)
print (soup.title.text)

Production

La sortie correspondante sera comme indiqué ici -

<title>Learn and Grow with Aditi Agarwal</title>
Learn and Grow with Aditi Agarwal

Lxml

Une autre bibliothèque Python dont nous allons discuter pour le web scraping est lxml. Il s'agit d'une bibliothèque d'analyse HTML et XML haute performance. C'est relativement rapide et simple. Vous pouvez en savoir plus surhttps://lxml.de/.

Installation de lxml

En utilisant la commande pip, nous pouvons installer lxml soit dans notre environnement virtuel, soit en installation globale.

(base) D:\ProgramData>pip install lxml
Collecting lxml
   Downloading
https://files.pythonhosted.org/packages/b9/55/bcc78c70e8ba30f51b5495eb0e
3e949aa06e4a2de55b3de53dc9fa9653fa/lxml-4.2.5-cp36-cp36m-win_amd64.whl
(3.
6MB)
   100% |¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦| 3.6MB 64kB/s
Installing collected packages: lxml
Successfully installed lxml-4.2.5

Exemple: extraction de données à l'aide de lxml et de requêtes

Dans l'exemple suivant, nous récupérons un élément particulier de la page Web à partir de authoraditiagarwal.com en utilisant lxml et les requêtes -

Tout d'abord, nous devons importer les requêtes et le code HTML de la bibliothèque lxml comme suit -

import requests
from lxml import html

Nous devons maintenant fournir l'URL de la page Web à supprimer

url = 'https://authoraditiagarwal.com/leadershipmanagement/'

Maintenant, nous devons fournir le chemin (Xpath) à un élément particulier de cette page Web -

path = '//*[@id="panel-836-0-0-1"]/div/div/p[1]'
response = requests.get(url)
byte_string = response.content
source_code = html.fromstring(byte_string)
tree = source_code.xpath(path)
print(tree[0].text_content())

Production

La sortie correspondante sera comme indiqué ici -

The Sprint Burndown or the Iteration Burndown chart is a powerful tool to communicate
daily progress to the stakeholders. It tracks the completion of work for a given sprint
or an iteration. The horizontal axis represents the days within a Sprint. The vertical 
axis represents the hours remaining to complete the committed work.

Dans les chapitres précédents, nous avons appris à extraire les données de pages Web ou à faire du scraping Web par divers modules Python. Dans ce chapitre, examinons différentes techniques pour traiter les données qui ont été grattées.

introduction

Pour traiter les données qui ont été grattées, nous devons stocker les données sur notre machine locale dans un format particulier comme une feuille de calcul (CSV), JSON ou parfois dans des bases de données comme MySQL.

Traitement des données CSV et JSON

Tout d'abord, nous allons écrire les informations, après avoir récupéré une page Web, dans un fichier CSV ou une feuille de calcul. Comprenons d'abord à travers un exemple simple dans lequel nous allons d'abord saisir les informations en utilisantBeautifulSoup module, comme précédemment, puis en utilisant le module Python CSV, nous écrirons ces informations textuelles dans un fichier CSV.

Tout d'abord, nous devons importer les bibliothèques Python nécessaires comme suit -

import requests
from bs4 import BeautifulSoup
import csv

Dans cette ligne de code suivante, nous utilisons des requêtes pour effectuer des requêtes HTTP GET pour l'url: https://authoraditiagarwal.com/ en effectuant une demande GET.

r = requests.get('https://authoraditiagarwal.com/')

Maintenant, nous devons créer un objet Soup comme suit -

soup = BeautifulSoup(r.text, 'lxml')

Maintenant, avec l'aide des prochaines lignes de code, nous allons écrire les données saisies dans un fichier CSV nommé dataprocessing.csv.

f = csv.writer(open(' dataprocessing.csv ','w'))
f.writerow(['Title'])
f.writerow([soup.title.text])

Après avoir exécuté ce script, les informations textuelles ou le titre de la page Web seront enregistrés dans le fichier CSV mentionné ci-dessus sur votre ordinateur local.

De même, nous pouvons enregistrer les informations collectées dans un fichier JSON. Ce qui suit est un script Python facile à comprendre pour faire la même chose dans laquelle nous récupérons les mêmes informations que dans le dernier script Python, mais cette fois, les informations récupérées sont enregistrées dans JSONfile.txt en utilisant le module JSON Python.

import requests
from bs4 import BeautifulSoup
import csv
import json
r = requests.get('https://authoraditiagarwal.com/')
soup = BeautifulSoup(r.text, 'lxml')
y = json.dumps(soup.title.text)
with open('JSONFile.txt', 'wt') as outfile:
   json.dump(y, outfile)

Après avoir exécuté ce script, les informations saisies, c'est-à-dire le titre de la page Web, seront enregistrées dans le fichier texte mentionné ci-dessus sur votre machine locale.

Traitement des données à l'aide d'AWS S3

Parfois, nous souhaitons enregistrer des données récupérées dans notre stockage local à des fins d'archivage. Mais que se passe-t-il si nous devons stocker et analyser ces données à grande échelle? La réponse est un service de stockage cloud nommé Amazon S3 ou AWS S3 (Simple Storage Service). Fondamentalement, AWS S3 est un stockage d'objets conçu pour stocker et récupérer n'importe quelle quantité de données de n'importe où.

Nous pouvons suivre les étapes suivantes pour stocker des données dans AWS S3 -

Step 1- Nous avons d'abord besoin d'un compte AWS qui nous fournira les clés secrètes à utiliser dans notre script Python lors du stockage des données. Cela créera un compartiment S3 dans lequel nous pourrons stocker nos données.

Step 2 - Ensuite, nous devons installer boto3Bibliothèque Python pour accéder au compartiment S3. Il peut être installé à l'aide de la commande suivante -

pip install boto3

Step 3 - Ensuite, nous pouvons utiliser le script Python suivant pour récupérer les données de la page Web et les enregistrer dans le compartiment AWS S3.

Tout d'abord, nous devons importer des bibliothèques Python pour le scraping, ici nous travaillons avec requests, et boto3 enregistrement des données dans le compartiment S3.

import requests
import boto3

Nous pouvons maintenant extraire les données de notre URL.

data = requests.get("Enter the URL").text

Maintenant, pour stocker des données dans le compartiment S3, nous devons créer un client S3 comme suit -

s3 = boto3.client('s3')
bucket_name = "our-content"

La prochaine ligne de code créera le compartiment S3 comme suit -

s3.create_bucket(Bucket = bucket_name, ACL = 'public-read')
s3.put_object(Bucket = bucket_name, Key = '', Body = data, ACL = "public-read")

Vous pouvez maintenant vérifier le bucket avec le nom our-content à partir de votre compte AWS.

Traitement des données avec MySQL

Apprenons à traiter les données avec MySQL. Si vous souhaitez en savoir plus sur MySQL, vous pouvez suivre le lienhttps://www.tutorialspoint.com/mysql/.

À l'aide des étapes suivantes, nous pouvons extraire et traiter les données dans la table MySQL -

Step 1- Tout d'abord, en utilisant MySQL, nous devons créer une base de données et une table dans lesquelles nous voulons enregistrer nos données récupérées. Par exemple, nous créons la table avec la requête suivante -

CREATE TABLE Scrap_pages (id BIGINT(7) NOT NULL AUTO_INCREMENT,
title VARCHAR(200), content VARCHAR(10000),PRIMARY KEY(id));

Step 2- Ensuite, nous devons gérer Unicode. Notez que MySQL ne gère pas l'Unicode par défaut. Nous devons activer cette fonctionnalité à l'aide des commandes suivantes qui changeront le jeu de caractères par défaut pour la base de données, pour la table et pour les deux colonnes -

ALTER DATABASE scrap CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci;
ALTER TABLE Scrap_pages CONVERT TO CHARACTER SET utf8mb4 COLLATE
utf8mb4_unicode_ci;
ALTER TABLE Scrap_pages CHANGE title title VARCHAR(200) CHARACTER SET utf8mb4
COLLATE utf8mb4_unicode_ci;
ALTER TABLE pages CHANGE content content VARCHAR(10000) CHARACTER SET utf8mb4
COLLATE utf8mb4_unicode_ci;

Step 3- Maintenant, intégrez MySQL avec Python. Pour cela, nous aurons besoin de PyMySQL qui peut être installé à l'aide de la commande suivante

pip install PyMySQL

Step 4- Maintenant, notre base de données nommée Scrap, créée plus tôt, est prête à enregistrer les données, après avoir été extraites du Web, dans la table nommée Scrap_pages. Ici, dans notre exemple, nous allons extraire des données de Wikipédia et elles seront enregistrées dans notre base de données.

Tout d'abord, nous devons importer les modules Python requis.

from urllib.request import urlopen
from bs4 import BeautifulSoup
import datetime
import random
import pymysql
import re

Maintenant, établissez une connexion, c'est-à-dire intégrez cela avec Python.

conn = pymysql.connect(host='127.0.0.1',user='root', passwd = None, db = 'mysql',
charset = 'utf8')
cur = conn.cursor()
cur.execute("USE scrap")
random.seed(datetime.datetime.now())
def store(title, content):
   cur.execute('INSERT INTO scrap_pages (title, content) VALUES ''("%s","%s")', (title, content))
   cur.connection.commit()

Maintenant, connectez-vous à Wikipédia et récupérez-en des données.

def getLinks(articleUrl):
   html = urlopen('http://en.wikipedia.org'+articleUrl)
   bs = BeautifulSoup(html, 'html.parser')
   title = bs.find('h1').get_text()
   content = bs.find('div', {'id':'mw-content-text'}).find('p').get_text()
   store(title, content)
   return bs.find('div', {'id':'bodyContent'}).findAll('a',href=re.compile('^(/wiki/)((?!:).)*$'))
links = getLinks('/wiki/Kevin_Bacon')
try:
   while len(links) > 0:
      newArticle = links[random.randint(0, len(links)-1)].attrs['href']
      print(newArticle)
      links = getLinks(newArticle)

Enfin, nous devons fermer le curseur et la connexion.

finally:
   cur.close()
   conn.close()

Cela enregistrera les données recueillies à partir de Wikipedia dans la table nommée scrap_pages. Si vous êtes familier avec MySQL et le web scraping, alors le code ci-dessus ne sera pas difficile à comprendre.

Traitement des données avec PostgreSQL

PostgreSQL, développé par une équipe mondiale de volontaires, est un système de gestion de base de données relationnelle (RDMS) open source. Le processus de traitement des données récupérées à l'aide de PostgreSQL est similaire à celui de MySQL. Il y aurait deux changements: premièrement, les commandes seraient différentes de MySQL et deuxièmement, nous utiliserons icipsycopg2 Bibliothèque Python pour effectuer son intégration avec Python.

Si vous n'êtes pas familier avec PostgreSQL, vous pouvez l'apprendre sur https://www.tutorialspoint.com/postgresql/. Et avec l'aide de la commande suivante, nous pouvons installer la bibliothèque Python psycopg2 -

pip install psycopg2

Le scraping Web implique généralement le téléchargement, le stockage et le traitement du contenu multimédia Web. Dans ce chapitre, voyons comment traiter le contenu téléchargé depuis le Web.

introduction

Le contenu multimédia Web que nous obtenons lors du scraping peut être des images, des fichiers audio et vidéo, sous la forme de pages non Web ainsi que des fichiers de données. Mais, pouvons-nous faire confiance aux données téléchargées en particulier sur l'extension des données que nous allons télécharger et stocker dans la mémoire de notre ordinateur? Il est donc essentiel de connaître le type de données que nous allons stocker localement.

Obtenir du contenu multimédia à partir d'une page Web

Dans cette section, nous allons apprendre comment télécharger du contenu multimédia qui représente correctement le type de support basé sur les informations du serveur Web. Nous pouvons le faire avec l'aide de Pythonrequests module comme nous l'avons fait dans le chapitre précédent.

Tout d'abord, nous devons importer les modules Python nécessaires comme suit -

import requests

Maintenant, fournissez l'URL du contenu multimédia que nous voulons télécharger et stocker localement.

url = "https://authoraditiagarwal.com/wpcontent/uploads/2018/05/MetaSlider_ThinkBig-1080x180.jpg"

Utilisez le code suivant pour créer un objet de réponse HTTP.

r = requests.get(url)

À l'aide de la ligne de code suivante, nous pouvons enregistrer le contenu reçu sous forme de fichier .png.

with open("ThinkBig.png",'wb') as f:
   f.write(r.content)

Après avoir exécuté le script Python ci-dessus, nous obtiendrons un fichier nommé ThinkBig.png, qui contiendrait l'image téléchargée.

Extraction du nom de fichier de l'URL

Après avoir téléchargé le contenu du site Web, nous voulons également l'enregistrer dans un fichier avec un nom de fichier trouvé dans l'URL. Mais nous pouvons également vérifier si des nombres de fragments supplémentaires existent également dans l'URL. Pour cela, nous devons trouver le nom de fichier réel à partir de l'URL.

Avec l'aide du script Python suivant, en utilisant urlparse, nous pouvons extraire le nom de fichier de l'URL -

import urllib3
import os
url = "https://authoraditiagarwal.com/wpcontent/uploads/2018/05/MetaSlider_ThinkBig-1080x180.jpg"
a = urlparse(url)
a.path

Vous pouvez observer la sortie comme indiqué ci-dessous -

'/wp-content/uploads/2018/05/MetaSlider_ThinkBig-1080x180.jpg'
os.path.basename(a.path)

Vous pouvez observer la sortie comme indiqué ci-dessous -

'MetaSlider_ThinkBig-1080x180.jpg'

Une fois que vous exécutez le script ci-dessus, nous obtiendrons le nom de fichier de l'URL.

Informations sur le type de contenu de l'URL

Lors de l'extraction du contenu du serveur Web, sur demande GET, nous pouvons également vérifier ses informations fournies par le serveur Web. À l'aide du script Python suivant, nous pouvons déterminer ce que signifie le serveur Web avec le type de contenu -

Tout d'abord, nous devons importer les modules Python nécessaires comme suit -

import requests

Maintenant, nous devons fournir l'URL du contenu multimédia que nous voulons télécharger et stocker localement.

url = "https://authoraditiagarwal.com/wpcontent/uploads/2018/05/MetaSlider_ThinkBig-1080x180.jpg"

La ligne de code suivante créera un objet de réponse HTTP.

r = requests.get(url, allow_redirects=True)

Maintenant, nous pouvons obtenir quel type d'informations sur le contenu peut être fourni par le serveur Web.

for headers in r.headers: print(headers)

Vous pouvez observer la sortie comme indiqué ci-dessous -

Date
Server
Upgrade
Connection
Last-Modified
Accept-Ranges
Content-Length
Keep-Alive
Content-Type

Avec l'aide de la ligne de code suivante, nous pouvons obtenir des informations particulières sur le type de contenu, disons content-type -

print (r.headers.get('content-type'))

Vous pouvez observer la sortie comme indiqué ci-dessous -

image/jpeg

À l'aide de la ligne de code suivante, nous pouvons obtenir des informations particulières sur le type de contenu, disons EType -

print (r.headers.get('ETag'))

Vous pouvez observer la sortie comme indiqué ci-dessous -

None

Observez la commande suivante -

print (r.headers.get('content-length'))

Vous pouvez observer la sortie comme indiqué ci-dessous -

12636

Avec l'aide de la ligne de code suivante, nous pouvons obtenir des informations particulières sur le type de contenu, disons Serveur -

print (r.headers.get('Server'))

Vous pouvez observer la sortie comme indiqué ci-dessous -

Apache

Génération de vignettes pour les images

La vignette est une très petite description ou représentation. Un utilisateur peut vouloir enregistrer uniquement la vignette d'une grande image ou enregistrer à la fois l'image et la vignette. Dans cette section, nous allons créer une vignette de l'image nomméeThinkBig.png téléchargé dans la section précédente «Obtention de contenu multimédia à partir d'une page Web».

Pour ce script Python, nous devons installer la bibliothèque Python nommée Pillow, un fork de la bibliothèque d'images Python ayant des fonctions utiles pour manipuler les images. Il peut être installé à l'aide de la commande suivante -

pip install pillow

Le script Python suivant créera une vignette de l'image et l'enregistrera dans le répertoire courant en préfixant le fichier vignette avec Th_

import glob
from PIL import Image
for infile in glob.glob("ThinkBig.png"):
   img = Image.open(infile)
   img.thumbnail((128, 128), Image.ANTIALIAS)
   if infile[0:2] != "Th_":
      img.save("Th_" + infile, "png")

Le code ci-dessus est très facile à comprendre et vous pouvez vérifier le fichier de vignettes dans le répertoire actuel.

Capture d'écran du site Web

Dans le scraping Web, une tâche très courante consiste à prendre une capture d'écran d'un site Web. Pour mettre en œuvre cela, nous allons utiliser le sélénium et le webdriver. Le script Python suivant prendra la capture d'écran du site Web et l'enregistrera dans le répertoire actuel.

From selenium import webdriver
path = r'C:\\Users\\gaurav\\Desktop\\Chromedriver'
browser = webdriver.Chrome(executable_path = path)
browser.get('https://tutorialspoint.com/')
screenshot = browser.save_screenshot('screenshot.png')
browser.quit

Vous pouvez observer la sortie comme indiqué ci-dessous -

DevTools listening on ws://127.0.0.1:1456/devtools/browser/488ed704-9f1b-44f0-
a571-892dc4c90eb7
<bound method WebDriver.quit of <selenium.webdriver.chrome.webdriver.WebDriver
(session="37e8e440e2f7807ef41ca7aa20ce7c97")>>

Après avoir exécuté le script, vous pouvez vérifier votre répertoire actuel pour screenshot.png fichier.

Génération de vignettes pour la vidéo

Supposons que nous ayons téléchargé des vidéos à partir du site Web et que nous voulions générer des miniatures pour celles-ci afin qu'une vidéo spécifique, en fonction de sa miniature, puisse être cliquée. Pour générer des vignettes pour les vidéos, nous avons besoin d'un outil simple appeléffmpeg qui peut être téléchargé depuis www.ffmpeg.org. Après le téléchargement, nous devons l'installer selon les spécifications de notre système d'exploitation.

Le script Python suivant générera une vignette de la vidéo et l'enregistrera dans notre répertoire local -

import subprocess
video_MP4_file = “C:\Users\gaurav\desktop\solar.mp4
thumbnail_image_file = 'thumbnail_solar_video.jpg'
subprocess.call(['ffmpeg', '-i', video_MP4_file, '-ss', '00:00:20.000', '-
   vframes', '1', thumbnail_image_file, "-y"])

Après avoir exécuté le script ci-dessus, nous obtiendrons la vignette nommée thumbnail_solar_video.jpg enregistré dans notre répertoire local.

Extraction d'une vidéo MP4 en MP3

Supposons que vous ayez téléchargé un fichier vidéo à partir d'un site Web, mais que vous n'ayez besoin que de l'audio de ce fichier pour répondre à votre objectif, alors cela peut être fait en Python à l'aide de la bibliothèque Python appelée moviepy qui peut être installé à l'aide de la commande suivante -

pip install moviepy

Maintenant, après avoir installé avec succès moviepy à l'aide du script suivant, nous pouvons convertir et MP4 en MP3.

import moviepy.editor as mp
clip = mp.VideoFileClip(r"C:\Users\gaurav\Desktop\1234.mp4")
clip.audio.write_audiofile("movie_audio.mp3")

Vous pouvez observer la sortie comme indiqué ci-dessous -

[MoviePy] Writing audio in movie_audio.mp3
100%|¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦
¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦| 674/674 [00:01<00:00,
476.30it/s]
[MoviePy] Done.

Le script ci-dessus enregistrera le fichier audio MP3 dans le répertoire local.

Dans le chapitre précédent, nous avons vu comment gérer les vidéos et les images que nous obtenons dans le cadre du contenu de scraping Web. Dans ce chapitre, nous allons traiter de l'analyse de texte en utilisant la bibliothèque Python et nous en apprendrons davantage à ce sujet.

introduction

Vous pouvez effectuer une analyse de texte en utilisant la bibliothèque Python appelée Natural Language Tool Kit (NLTK). Avant de passer aux concepts de NLTK, comprenons la relation entre l'analyse de texte et le web scraping.

L'analyse des mots du texte peut nous amener à savoir quels mots sont importants, quels mots sont inhabituels, comment les mots sont regroupés. Cette analyse facilite la tâche du web scraping.

Premiers pas avec NLTK

La boîte à outils en langage naturel (NLTK) est une collection de bibliothèques Python spécialement conçue pour identifier et baliser des parties de discours trouvées dans le texte d'un langage naturel comme l'anglais.

Installation de NLTK

Vous pouvez utiliser la commande suivante pour installer NLTK en Python -

pip install nltk

Si vous utilisez Anaconda, un package conda pour NLTK peut être généré à l'aide de la commande suivante -

conda install -c anaconda nltk

Téléchargement des données de NLTK

Après avoir installé NLTK, nous devons télécharger des référentiels de texte prédéfinis. Mais avant de télécharger des référentiels de texte prédéfini, nous devons importer NLTK à l'aide deimport commande comme suit -

mport nltk

Maintenant, avec l'aide de la commande suivante, les données NLTK peuvent être téléchargées -

nltk.download()

L'installation de tous les packages disponibles de NLTK prendra un certain temps, mais il est toujours recommandé d'installer tous les packages.

Installation d'autres packages nécessaires

Nous avons également besoin d'autres packages Python comme gensim et pattern pour faire l'analyse de texte ainsi que pour construire des applications de traitement du langage naturel en utilisant NLTK.

gensim- Une bibliothèque de modélisation sémantique robuste, utile pour de nombreuses applications. Il peut être installé par la commande suivante -

pip install gensim

pattern - Utilisé pour faire gensimle package fonctionne correctement. Il peut être installé par la commande suivante -

pip install pattern

Tokenisation

Le processus de décomposition du texte donné, en unités plus petites appelées jetons, est appelé tokenisation. Ces jetons peuvent être des mots, des chiffres ou des signes de ponctuation. Il est également appeléword segmentation.

Exemple

Le module NLTK fournit différents packages pour la tokenisation. Nous pouvons utiliser ces packages selon nos besoins. Certains des packages sont décrits ici -

sent_tokenize package- Ce package divisera le texte d'entrée en phrases. Vous pouvez utiliser la commande suivante pour importer ce package -

from nltk.tokenize import sent_tokenize

word_tokenize package- Ce package divisera le texte d'entrée en mots. Vous pouvez utiliser la commande suivante pour importer ce package -

from nltk.tokenize import word_tokenize

WordPunctTokenizer package- Ce package divisera le texte d'entrée ainsi que les signes de ponctuation en mots. Vous pouvez utiliser la commande suivante pour importer ce package -

from nltk.tokenize import WordPuncttokenizer

Tige

Dans n'importe quelle langue, il existe différentes formes de mots. Une langue comprend de nombreuses variations pour des raisons grammaticales. Par exemple, considérons les motsdemocracy, democratic, et democratization. Pour l'apprentissage automatique ainsi que pour les projets de web scraping, il est important que les machines comprennent que ces différents mots ont la même forme de base. On peut donc dire qu'il peut être utile d'extraire les formes de base des mots lors de l'analyse du texte.

Ceci peut être réalisé par la racine qui peut être définie comme le processus heuristique d'extraction des formes de base des mots en coupant les extrémités des mots.

Le module NLTK fournit différents packages pour la création de racines. Nous pouvons utiliser ces packages selon nos besoins. Certains de ces packages sont décrits ici -

PorterStemmer package- L'algorithme de Porter est utilisé par ce package de dérivation Python pour extraire la forme de base. Vous pouvez utiliser la commande suivante pour importer ce package -

from nltk.stem.porter import PorterStemmer

Par exemple, après avoir donné le mot ‘writing’ comme entrée de cette racine, la sortie serait le mot ‘write’ après la tige.

LancasterStemmer package- L'algorithme de Lancaster est utilisé par ce package de dérivation Python pour extraire la forme de base. Vous pouvez utiliser la commande suivante pour importer ce package -

from nltk.stem.lancaster import LancasterStemmer

Par exemple, après avoir donné le mot ‘writing’ comme entrée de cette racine, la sortie serait le mot ‘writ’ après la tige.

SnowballStemmer package- L'algorithme de Snowball est utilisé par ce package de dérivation Python pour extraire la forme de base. Vous pouvez utiliser la commande suivante pour importer ce package -

from nltk.stem.snowball import SnowballStemmer

Par exemple, après avoir donné le mot «écriture» comme entrée de ce radical, la sortie serait le mot «écriture» après le radical.

Lemmatisation

Une autre façon d'extraire la forme de base des mots est la lemmatisation, visant normalement à supprimer les terminaisons flexionnelles en utilisant le vocabulaire et l'analyse morphologique. La forme de base de tout mot après la lemmatisation est appelée lemme.

Le module NLTK fournit les packages suivants pour la lemmatisation -

WordNetLemmatizer package- Il extraira la forme de base du mot selon qu'il est utilisé comme nom comme verbe. Vous pouvez utiliser la commande suivante pour importer ce package -

from nltk.stem import WordNetLemmatizer

Regrouper

La segmentation, qui consiste à diviser les données en petits morceaux, est l'un des processus importants du traitement du langage naturel pour identifier les parties du discours et les phrases courtes comme les phrases nominales. La segmentation consiste à étiqueter les jetons. Nous pouvons obtenir la structure de la phrase à l'aide d'un processus de segmentation.

Exemple

Dans cet exemple, nous allons implémenter la segmentation Noun-Phrase en utilisant le module NLTK Python. Le segment NP est une catégorie de segmentation qui trouvera les morceaux de phrases nominales dans la phrase.

Étapes de mise en œuvre de la segmentation des phrases nominales

Nous devons suivre les étapes ci-dessous pour implémenter la segmentation des phrases nominales -

Étape 1 - Définition de la grammaire des blocs

Dans un premier temps, nous définirons la grammaire du découpage. Cela comprendrait les règles que nous devons suivre.

Étape 2 - Création de l'analyseur de blocs

Maintenant, nous allons créer un analyseur de blocs. Il analyserait la grammaire et donnerait la sortie.

Étape 3 - La sortie

Dans cette dernière étape, la sortie serait produite dans un format arborescent.

Tout d'abord, nous devons importer le package NLTK comme suit -

import nltk

Ensuite, nous devons définir la phrase. Ici DT: le déterminant, VBP: le verbe, JJ: l'adjectif, IN: la préposition et NN: le nom.

sentence = [("a", "DT"),("clever","JJ"),("fox","NN"),("was","VBP"),("jumping","VBP"),("over","IN"),("the","DT"),("wall","NN")]

Ensuite, nous donnons la grammaire sous forme d'expression régulière.

grammar = "NP:{<DT>?<JJ>*<NN>}"

Maintenant, la prochaine ligne de code définira un analyseur pour analyser la grammaire.

parser_chunking = nltk.RegexpParser(grammar)

Maintenant, l'analyseur analysera la phrase.

parser_chunking.parse(sentence)

Ensuite, nous donnons notre sortie dans la variable.

Output = parser_chunking.parse(sentence)

Avec l'aide du code suivant, nous pouvons dessiner notre sortie sous la forme d'un arbre comme indiqué ci-dessous.

output.draw()

Modèle Bag of Word (BoW) Extraction et conversion du texte sous forme numérique

Bag of Word (BoW), un modèle utile dans le traitement du langage naturel, est essentiellement utilisé pour extraire les fonctionnalités du texte. Après avoir extrait les fonctionnalités du texte, il peut être utilisé dans la modélisation d'algorithmes d'apprentissage automatique car les données brutes ne peuvent pas être utilisées dans les applications ML.

Fonctionnement du modèle BoW

Au départ, le modèle extrait un vocabulaire de tous les mots du document. Plus tard, en utilisant une matrice de termes de document, il construirait un modèle. De cette façon, le modèle BoW représente le document comme un sac de mots uniquement et l'ordre ou la structure est rejeté.

Exemple

Supposons que nous ayons les deux phrases suivantes -

Sentence1 - Ceci est un exemple du modèle Bag of Words.

Sentence2 - Nous pouvons extraire des fonctionnalités en utilisant le modèle Bag of Words.

Maintenant, en considérant ces deux phrases, nous avons les 14 mots distincts suivants -

• This
• is
• an
• example
• bag
• of
• words
• model
• we
• can
• extract
• features
• by
• using

Construire un modèle de sac de mots en NLTK

Examinons le script Python suivant qui construira un modèle BoW en NLTK.

Tout d'abord, importez le package suivant -

from sklearn.feature_extraction.text import CountVectorizer

Ensuite, définissez l'ensemble des phrases -

Sentences=['This is an example of Bag of Words model.', ' We can extract
   features by using Bag of Words model.']
   vector_count = CountVectorizer()
   features_text = vector_count.fit_transform(Sentences).todense()
   print(vector_count.vocabulary_)

Production

Cela montre que nous avons 14 mots distincts dans les deux phrases ci-dessus -

{
   'this': 10, 'is': 7, 'an': 0, 'example': 4, 'of': 9, 
   'bag': 1, 'words': 13, 'model': 8, 'we': 12, 'can': 3, 
   'extract': 5, 'features': 6, 'by': 2, 'using':11
}

Modélisation de sujets: identification des modèles dans les données texte

En général, les documents sont regroupés en sujets et la modélisation de sujets est une technique permettant d'identifier les modèles dans un texte qui correspond à un sujet particulier. En d'autres termes, la modélisation de sujets est utilisée pour découvrir des thèmes abstraits ou une structure cachée dans un ensemble donné de documents.

Vous pouvez utiliser la modélisation de sujets dans les scénarios suivants -

Classification du texte

La classification peut être améliorée par la modélisation de sujets, car elle regroupe des mots similaires plutôt que d'utiliser chaque mot séparément comme fonction.

Systèmes de recommandation

Nous pouvons créer des systèmes de recommandation en utilisant des mesures de similarité.

Algorithmes de modélisation de sujet

Nous pouvons implémenter la modélisation de sujets en utilisant les algorithmes suivants -

Latent Dirichlet Allocation(LDA) - C'est l'un des algorithmes les plus populaires qui utilise les modèles graphiques probabilistes pour implémenter la modélisation thématique.

Latent Semantic Analysis(LDA) or Latent Semantic Indexing(LSI) - Il est basé sur l'algèbre linéaire et utilise le concept de SVD (Singular Value Decomposition) sur la matrice des termes du document.

Non-Negative Matrix Factorization (NMF) - Il est également basé sur l'algèbre linéaire comme LDA.

Les algorithmes mentionnés ci-dessus auraient les éléments suivants -

• Nombre de sujets: Paramètre
• Matrice document-mot: entrée
• WTM (Word Topic Matrix) et TDM (Topic Document Matrix): sortie

introduction

Le scraping Web est une tâche complexe et la complexité se multiplie si le site Web est dynamique. Selon l'audit mondial de l'accessibilité du Web des Nations Unies, plus de 70% des sites Web sont de nature dynamique et s'appuient sur JavaScript pour leurs fonctionnalités.

Exemple de site Web dynamique

Prenons un exemple de site Web dynamique et voyons pourquoi il est difficile de gratter. Ici, nous allons prendre un exemple de recherche à partir d'un site Web nomméhttp://example.webscraping.com/places/default/search.Mais comment dire que ce site Web est de nature dynamique? Il peut être jugé à partir de la sortie du script Python suivant qui tentera de récupérer les données de la page Web mentionnée ci-dessus -

import re
import urllib.request
response = urllib.request.urlopen('http://example.webscraping.com/places/default/search')
html = response.read()
text = html.decode()
re.findall('(.*?)',text)

Production

[ ]

La sortie ci-dessus montre que l'exemple de racleur n'a pas réussi à extraire les informations car l'élément <div> que nous essayons de trouver est vide.

Approches pour la récupération des données à partir de sites Web dynamiques

Nous avons vu que le grattoir ne peut pas extraire les informations d'un site Web dynamique car les données sont chargées dynamiquement avec JavaScript. Dans de tels cas, nous pouvons utiliser les deux techniques suivantes pour récupérer des données à partir de sites Web dynamiques dépendants de JavaScript:

• Ingénierie inverse JavaScript
• Rendu JavaScript

Ingénierie inverse JavaScript

Le processus appelé ingénierie inverse serait utile et nous permet de comprendre comment les données sont chargées dynamiquement par les pages Web.

Pour ce faire, nous devons cliquer sur le inspect elementonglet pour une URL spécifiée. Ensuite, nous allons cliquerNETWORK onglet pour trouver toutes les demandes faites pour cette page Web, y compris search.json avec un chemin de /ajax. Au lieu d'accéder aux données AJAX à partir du navigateur ou via l'onglet RÉSEAU, nous pouvons le faire à l'aide du script Python suivant également -

import requests
url=requests.get('http://example.webscraping.com/ajax/search.json?page=0&page_size=10&search_term=a')
url.json()

Exemple

Le script ci-dessus nous permet d'accéder à la réponse JSON à l'aide de la méthode JSON Python. De même, nous pouvons télécharger la réponse de chaîne brute et en utilisant la méthode json.loads de python, nous pouvons la charger également. Nous faisons cela à l'aide du script Python suivant. Il parcourra essentiellement tous les pays en recherchant la lettre de l'alphabet `` a '', puis en itérant les pages résultantes des réponses JSON.

import requests
import string
PAGE_SIZE = 15
url = 'http://example.webscraping.com/ajax/' + 'search.json?page={}&page_size={}&search_term=a'
countries = set()
for letter in string.ascii_lowercase:
   print('Searching with %s' % letter)
   page = 0
   while True:
   response = requests.get(url.format(page, PAGE_SIZE, letter))
   data = response.json()
   print('adding %d records from the page %d' %(len(data.get('records')),page))
   for record in data.get('records'):countries.add(record['country'])
   page += 1
   if page >= data['num_pages']:
      break
   with open('countries.txt', 'w') as countries_file:
   countries_file.write('n'.join(sorted(countries)))

Après avoir exécuté le script ci-dessus, nous obtiendrons la sortie suivante et les enregistrements seront enregistrés dans le fichier nommé countries.txt.

Production

Searching with a
adding 15 records from the page 0
adding 15 records from the page 1
...

Rendu JavaScript

Dans la section précédente, nous avons effectué une ingénierie inverse sur une page Web expliquant le fonctionnement de l'API et la manière dont nous pouvons l'utiliser pour récupérer les résultats en une seule requête. Cependant, nous pouvons faire face aux difficultés suivantes lors de la rétro-ingénierie -

• Parfois, les sites Web peuvent être très difficiles. Par exemple, si le site Web est créé avec un outil de navigation avancé tel que Google Web Toolkit (GWT), le code JS résultant serait généré par la machine et difficile à comprendre et à effectuer de l'ingénierie inverse.

• Certains cadres de niveau supérieur comme React.js peut rendre la rétro-ingénierie difficile en faisant abstraction d'une logique JavaScript déjà complexe.

La solution aux difficultés ci-dessus consiste à utiliser un moteur de rendu de navigateur qui analyse le HTML, applique le formatage CSS et exécute JavaScript pour afficher une page Web.

Exemple

Dans cet exemple, pour le rendu de Java Script, nous allons utiliser un module Python familier Selenium. Le code Python suivant rendra une page Web à l'aide de Selenium -

Tout d'abord, nous devons importer le pilote Web à partir du sélénium comme suit -

from selenium import webdriver

Maintenant, fournissez le chemin du pilote Web que nous avons téléchargé selon nos besoins -

path = r'C:\\Users\\gaurav\\Desktop\\Chromedriver'
driver = webdriver.Chrome(executable_path = path)

Maintenant, fournissez l'url que nous voulons ouvrir dans ce navigateur Web maintenant contrôlé par notre script Python.

driver.get('http://example.webscraping.com/search')

Maintenant, nous pouvons utiliser l'ID de la boîte à outils de recherche pour définir l'élément à sélectionner.

driver.find_element_by_id('search_term').send_keys('.')

Ensuite, nous pouvons utiliser le script java pour définir le contenu de la boîte de sélection comme suit -

js = "document.getElementById('page_size').options[1].text = '100';"
driver.execute_script(js)

La ligne de code suivante montre que la recherche est prête à être cliquée sur la page Web -

driver.find_element_by_id('search').click()

La ligne de code suivante montre qu'elle attendra 45 secondes pour terminer la requête AJAX.

driver.implicitly_wait(45)

Maintenant, pour sélectionner les liens de pays, nous pouvons utiliser le sélecteur CSS comme suit -

links = driver.find_elements_by_css_selector('#results a')

Maintenant, le texte de chaque lien peut être extrait pour créer la liste des pays -

countries = [link.text for link in links]
print(countries)
driver.close()

Dans le chapitre précédent, nous avons vu gratter des sites Web dynamiques. Dans ce chapitre, laissez-nous comprendre le grattage de sites Web qui fonctionnent sur des entrées basées sur l'utilisateur, c'est-à-dire des sites Web basés sur des formulaires.

introduction

Ces jours-ci, le WWW (World Wide Web) se dirige vers les médias sociaux ainsi que vers les contenus générés par l'utilisateur. La question se pose donc de savoir comment accéder à ce type d'informations qui se trouvent au-delà de l'écran de connexion? Pour cela, nous devons gérer les formulaires et les connexions.

Dans les chapitres précédents, nous avons travaillé avec la méthode HTTP GET pour demander des informations, mais dans ce chapitre, nous travaillerons avec la méthode HTTP POST qui transmet les informations à un serveur Web pour stockage et analyse.

Interagir avec les formulaires de connexion

Lorsque vous travaillez sur Internet, vous devez avoir interagi plusieurs fois avec les formulaires de connexion. Ils peuvent être très simples, comme n'inclure que très peu de champs HTML, un bouton d'envoi et une page d'action ou ils peuvent être compliqués et avoir des champs supplémentaires comme le courrier électronique, laisser un message avec captcha pour des raisons de sécurité.

Dans cette section, nous allons traiter un simple formulaire de soumission à l'aide de la bibliothèque de requêtes Python.

Tout d'abord, nous devons importer la bibliothèque de requêtes comme suit -

import requests

Maintenant, nous devons fournir les informations pour les champs du formulaire de connexion.

parameters = {‘Name’:’Enter your name’, ‘Email-id’:’Your Emailid’,’Message’:’Type your message here’}

Dans la prochaine ligne de code, nous devons fournir l'URL sur laquelle l'action du formulaire se produirait.

r = requests.post(“enter the URL”, data = parameters)
print(r.text)

Après avoir exécuté le script, il renverra le contenu de la page où l'action s'est produite.

Supposons que si vous souhaitez soumettre une image avec le formulaire, alors c'est très facile avec requests.post (). Vous pouvez le comprendre à l'aide du script Python suivant -

import requests
file = {‘Uploadfile’: open(’C:\Usres\desktop\123.png’,‘rb’)}
r = requests.post(“enter the URL”, files = file)
print(r.text)

Chargement des cookies depuis le serveur Web

Un cookie, parfois appelé cookie Web ou cookie Internet, est un petit élément de données envoyé depuis un site Web et notre ordinateur le stocke dans un fichier situé dans notre navigateur Web.

Dans le cadre des transactions avec les formulaires de connexion, les cookies peuvent être de deux types. Un, nous avons traité dans la section précédente, qui nous permet de soumettre des informations à un site Web et le second qui nous permet de rester dans un état permanent «connecté» tout au long de notre visite sur le site. Pour le deuxième type de formulaires, les sites Web utilisent des cookies pour savoir qui est connecté et qui ne l'est pas.

Que font les cookies?

De nos jours, la plupart des sites Web utilisent des cookies pour le suivi. Nous pouvons comprendre le fonctionnement des cookies à l'aide des étapes suivantes -

Step 1- Tout d'abord, le site authentifiera nos identifiants de connexion et les stockera dans le cookie de notre navigateur. Ce cookie contient généralement un toke généré par le serveur, un délai d'expiration et des informations de suivi.

Step 2- Ensuite, le site Web utilisera le cookie comme preuve d'authentification. Cette authentification est toujours affichée chaque fois que nous visitons le site Web.

Les cookies sont très problématiques pour les web scrapers car si les web scrapers ne gardent pas trace des cookies, le formulaire soumis est renvoyé et à la page suivante, il semble qu'ils ne se soient jamais connectés. Il est très facile de suivre les cookies avec l'aide de Python requests bibliothèque, comme indiqué ci-dessous -

import requests
parameters = {‘Name’:’Enter your name’, ‘Email-id’:’Your Emailid’,’Message’:’Type your message here’}
r = requests.post(“enter the URL”, data = parameters)

Dans la ligne de code ci-dessus, l'URL serait la page qui agira en tant que processeur pour le formulaire de connexion.

print(‘The cookie is:’)
print(r.cookies.get_dict())
print(r.text)

Après avoir exécuté le script ci-dessus, nous récupérerons les cookies du résultat de la dernière requête.

Il existe un autre problème avec les cookies: les sites Web modifient parfois fréquemment les cookies sans avertissement. Ce genre de situation peut être traitérequests.Session() comme suit -

import requests
session = requests.Session()
parameters = {‘Name’:’Enter your name’, ‘Email-id’:’Your Emailid’,’Message’:’Type your message here’}
r = session.post(“enter the URL”, data = parameters)

Dans la ligne de code ci-dessus, l'URL serait la page qui agira en tant que processeur pour le formulaire de connexion.

print(‘The cookie is:’)
print(r.cookies.get_dict())
print(r.text)

Notez que vous pouvez facilement comprendre la différence entre un script avec session et sans session.

Automatiser les formulaires avec Python

Dans cette section, nous allons traiter d'un module Python nommé Mechanize qui réduira notre travail et automatisera le processus de remplissage des formulaires.

Module de mécanisation

Le module Mechanize nous fournit une interface de haut niveau pour interagir avec les formulaires. Avant de commencer à l'utiliser, nous devons l'installer avec la commande suivante -

pip install mechanize

Notez que cela ne fonctionnerait qu'en Python 2.x.

Exemple

Dans cet exemple, nous allons automatiser le processus de remplissage d'un formulaire de connexion comportant deux champs à savoir l'email et le mot de passe -

import mechanize
brwsr = mechanize.Browser()
brwsr.open(Enter the URL of login)
brwsr.select_form(nr = 0)
brwsr['email'] = ‘Enter email’
brwsr['password'] = ‘Enter password’
response = brwsr.submit()
brwsr.submit()

Le code ci-dessus est très facile à comprendre. Tout d'abord, nous avons importé le module de mécanisation. Ensuite, un objet navigateur Mechanize a été créé. Ensuite, nous avons accédé à l'URL de connexion et sélectionné le formulaire. Après cela, les noms et les valeurs sont transmis directement à l'objet navigateur.

Dans ce chapitre, nous allons comprendre comment effectuer le scraping Web et le traitement du CAPTCHA qui est utilisé pour tester un utilisateur pour un humain ou un robot.

Qu'est-ce que CAPTCHA?

La forme complète de CAPTCHA est Completely Automated Public Turing test to tell Computers and Humans Apart, ce qui suggère clairement qu'il s'agit d'un test pour déterminer si l'utilisateur est humain ou non.

Un CAPTCHA est une image déformée qui n'est généralement pas facile à détecter par un programme informatique, mais un humain peut d'une manière ou d'une autre réussir à la comprendre. La plupart des sites Web utilisent CAPTCHA pour empêcher les robots d'interagir.

Chargement de CAPTCHA avec Python

Supposons que nous souhaitons vous enregistrer sur un site Web et qu'il existe un formulaire avec CAPTCHA, puis avant de charger l'image CAPTCHA, nous devons connaître les informations spécifiques requises par le formulaire. Avec l'aide du prochain script Python, nous pouvons comprendre les exigences de forme du formulaire d'inscription sur le site Web nomméhttp://example.webscrapping.com.

import lxml.html
import urllib.request as urllib2
import pprint
import http.cookiejar as cookielib
def form_parsing(html):
   tree = lxml.html.fromstring(html)
   data = {}
   for e in tree.cssselect('form input'):
      if e.get('name'):
         data[e.get('name')] = e.get('value')
   return data
REGISTER_URL = '<a target="_blank" rel="nofollow" 
   href="http://example.webscraping.com/user/register">http://example.webscraping.com/user/register'</a>
ckj = cookielib.CookieJar()
browser = urllib2.build_opener(urllib2.HTTPCookieProcessor(ckj))
html = browser.open(
   '<a target="_blank" rel="nofollow" 
      href="http://example.webscraping.com/places/default/user/register?_next">
      http://example.webscraping.com/places/default/user/register?_next</a> = /places/default/index'
).read()
form = form_parsing(html)
pprint.pprint(form)

Dans le script Python ci-dessus, nous avons d'abord défini une fonction qui analysera le formulaire en utilisant le module python lxml, puis il imprimera les exigences du formulaire comme suit -

{
   '_formkey': '5e306d73-5774-4146-a94e-3541f22c95ab',
   '_formname': 'register',
   '_next': '/places/default/index',
   'email': '',
   'first_name': '',
   'last_name': '',
   'password': '',
   'password_two': '',
   'recaptcha_response_field': None
}

Vous pouvez vérifier à partir de la sortie ci-dessus que toutes les informations sauf recpatcha_response_fieldsont compréhensibles et simples. Maintenant, la question se pose de savoir comment nous pouvons gérer ces informations complexes et télécharger CAPTCHA. Cela peut être fait avec l'aide de la bibliothèque oreiller Python comme suit;

Paquet oreiller Python

Pillow est un fork de la bibliothèque d'images Python ayant des fonctions utiles pour manipuler des images. Il peut être installé à l'aide de la commande suivante -

pip install pillow

Dans l'exemple suivant, nous l'utiliserons pour charger le CAPTCHA -

from io import BytesIO
import lxml.html
from PIL import Image
def load_captcha(html):
   tree = lxml.html.fromstring(html)
   img_data = tree.cssselect('div#recaptcha img')[0].get('src')
   img_data = img_data.partition(',')[-1]
   binary_img_data = img_data.decode('base64')
   file_like = BytesIO(binary_img_data)
   img = Image.open(file_like)
   return img

Le script python ci-dessus utilise pillowpaquet python et définition d'une fonction pour charger l'image CAPTCHA. Il doit être utilisé avec la fonction nomméeform_parser()qui est défini dans le script précédent pour obtenir des informations sur le formulaire d'inscription. Ce script enregistrera l'image CAPTCHA dans un format utile qui pourra ensuite être extrait sous forme de chaîne.

OCR: extraction de texte à partir d'une image à l'aide de Python

Après avoir chargé le CAPTCHA dans un format utile, nous pouvons l'extraire à l'aide de la reconnaissance optique de caractères (OCR), un processus d'extraction de texte à partir des images. Pour cela, nous allons utiliser le moteur Open Source Tesseract OCR. Il peut être installé à l'aide de la commande suivante -

pip install pytesseract

Exemple

Ici, nous allons étendre le script Python ci-dessus, qui a chargé le CAPTCHA en utilisant le package Pillow Python, comme suit -

import pytesseract
img = get_captcha(html)
img.save('captcha_original.png')
gray = img.convert('L')
gray.save('captcha_gray.png')
bw = gray.point(lambda x: 0 if x < 1 else 255, '1')
bw.save('captcha_thresholded.png')

Le script Python ci-dessus lira le CAPTCHA en mode noir et blanc qui serait clair et facile à passer à tesseract comme suit -

pytesseract.image_to_string(bw)

Après avoir exécuté le script ci-dessus, nous obtiendrons le CAPTCHA du formulaire d'inscription comme sortie.

Ce chapitre explique comment effectuer des tests à l'aide de web scrapers en Python.

introduction

Dans les grands projets Web, des tests automatisés du backend du site Web sont effectués régulièrement, mais les tests du frontend sont souvent ignorés. La principale raison derrière cela est que la programmation de sites Web est comme un réseau de divers langages de balisage et de programmation. Nous pouvons écrire un test unitaire pour une langue, mais cela devient difficile si l'interaction se fait dans une autre langue. C'est pourquoi nous devons avoir une suite de tests pour nous assurer que notre code fonctionne selon nos attentes.

Test avec Python

Lorsque nous parlons de tests, cela signifie de tests unitaires. Avant de plonger dans les tests avec Python, nous devons connaître les tests unitaires. Voici quelques-unes des caractéristiques des tests unitaires -

• Au moins un aspect de la fonctionnalité d'un composant serait testé dans chaque test unitaire.

• Chaque test unitaire est indépendant et peut également s'exécuter indépendamment.

• Le test unitaire n'interfère pas avec le succès ou l'échec de tout autre test.

• Les tests unitaires peuvent s'exécuter dans n'importe quel ordre et doivent contenir au moins une assertion.

Unittest - Module Python

Le module Python nommé Unittest pour les tests unitaires est livré avec toute l'installation standard de Python. Nous avons juste besoin de l'importer et le reste est la tâche de la classe unittest.TestCase qui fera ce qui suit -

• Les fonctions SetUp et tearDown sont fournies par la classe unittest.TestCase. Ces fonctions peuvent s'exécuter avant et après chaque test unitaire.

• Il fournit également des instructions d'assert pour permettre aux tests de réussir ou d'échouer.

• Il exécute toutes les fonctions qui commencent par test_ comme test unitaire.

Exemple

Dans cet exemple, nous allons combiner le web scraping avec unittest. Nous testerons la page Wikipedia pour rechercher la chaîne 'Python'. Il fera essentiellement deux tests, d'abord si la page de titre est la même que la chaîne de recherche, c'est-à-dire "Python" ou non et le second test s'assure que la page a un contenu div.

Tout d'abord, nous importerons les modules Python requis. Nous utilisons BeautifulSoup pour le web scraping et bien sûr unittest pour les tests.

from urllib.request import urlopen
from bs4 import BeautifulSoup
import unittest

Nous devons maintenant définir une classe qui étendra unittest.TestCase. L'objet global bs serait partagé entre tous les tests. Une fonction spécifiée unittest setUpClass l'accomplira. Ici, nous allons définir deux fonctions, l'une pour tester la page de titre et l'autre pour tester le contenu de la page.

class Test(unittest.TestCase):
   bs = None
   def setUpClass():
      url = '<a target="_blank" rel="nofollow" href="https://en.wikipedia.org/wiki/Python">https://en.wikipedia.org/wiki/Python'</a>
      Test.bs = BeautifulSoup(urlopen(url), 'html.parser')
   def test_titleText(self):
      pageTitle = Test.bs.find('h1').get_text()
      self.assertEqual('Python', pageTitle);
   def test_contentExists(self):
      content = Test.bs.find('div',{'id':'mw-content-text'})
      self.assertIsNotNone(content)
if __name__ == '__main__':
   unittest.main()

Après avoir exécuté le script ci-dessus, nous obtiendrons la sortie suivante -

----------------------------------------------------------------------
Ran 2 tests in 2.773s

OK
An exception has occurred, use %tb to see the full traceback.

SystemExit: False

D:\ProgramData\lib\site-packages\IPython\core\interactiveshell.py:2870:
UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.
 warn("To exit: use 'exit', 'quit', or Ctrl-D.", stacklevel=1)

Test avec du sélénium

Voyons comment utiliser Python Selenium pour les tests. Il est également appelé test de sélénium. Les deux Pythonunittest et Seleniumn'ont pas grand chose en commun. Nous savons que Selenium envoie les commandes Python standard à différents navigateurs, malgré des variations dans la conception de leur navigateur. Rappelons que nous avons déjà installé et travaillé avec Selenium dans les chapitres précédents. Ici, nous allons créer des scripts de test dans Selenium et l'utiliser pour l'automatisation.

Exemple

Avec l'aide du prochain script Python, nous créons un script de test pour l'automatisation de la page de connexion Facebook. Vous pouvez modifier l'exemple pour automatiser d'autres formulaires et connexions de votre choix, mais le concept serait le même.

Tout d'abord pour la connexion au navigateur Web, nous importerons le pilote Web à partir du module sélénium -

from selenium import webdriver

Maintenant, nous devons importer des clés à partir du module sélénium.

from selenium.webdriver.common.keys import Keys

Ensuite, nous devons fournir un nom d'utilisateur et un mot de passe pour nous connecter à notre compte Facebook

user = "[email protected]"
pwd = ""

Ensuite, indiquez le chemin du pilote Web pour Chrome.

path = r'C:\\Users\\gaurav\\Desktop\\Chromedriver'
driver = webdriver.Chrome(executable_path=path)
driver.get("http://www.facebook.com")

Nous allons maintenant vérifier les conditions en utilisant le mot-clé assert.

assert "Facebook" in driver.title

Avec l'aide de la ligne de code suivante, nous envoyons des valeurs à la section e-mail. Ici, nous le recherchons par son identifiant mais nous pouvons le faire en le recherchant par nom commedriver.find_element_by_name("email").

element = driver.find_element_by_id("email")
element.send_keys(user)

Avec l'aide de la ligne de code suivante, nous envoyons des valeurs à la section mot de passe. Ici, nous le recherchons par son identifiant mais nous pouvons le faire en le recherchant par nom commedriver.find_element_by_name("pass").

element = driver.find_element_by_id("pass")
element.send_keys(pwd)

La ligne de code suivante est utilisée pour appuyer sur entrée / connexion après avoir inséré les valeurs dans le champ e-mail et mot de passe.

element.send_keys(Keys.RETURN)

Nous allons maintenant fermer le navigateur.

driver.close()

Après avoir exécuté le script ci-dessus, le navigateur Web Chrome sera ouvert et vous pouvez voir que l'e-mail et le mot de passe sont insérés et cliqué sur le bouton de connexion.

Comparaison: unittest ou Selenium

La comparaison de l'unittest et du sélénium est difficile car si vous souhaitez travailler avec de grandes suites de tests, la rigidité syntaxique des unités est requise. D'un autre côté, si vous voulez tester la flexibilité du site Web, le test Selenium serait notre premier choix. Mais que se passerait-il si nous pouvions combiner les deux. Nous pouvons importer du sélénium dans Python unittest et tirer le meilleur parti des deux. Le sélénium peut être utilisé pour obtenir des informations sur un site Web et unittest peut évaluer si ces informations répondent aux critères de réussite du test ou non.

Par exemple, nous réécrivons le script Python ci-dessus pour l'automatisation de la connexion Facebook en les combinant comme suit -

import unittest
from selenium import webdriver

class InputFormsCheck(unittest.TestCase):
   def setUp(self):
      self.driver = webdriver.Chrome(r'C:\Users\gaurav\Desktop\chromedriver')
      def test_singleInputField(self):
      user = "[email protected]"
      pwd = ""
      pageUrl = "http://www.facebook.com"
      driver=self.driver
      driver.maximize_window()
      driver.get(pageUrl)
      assert "Facebook" in driver.title
      elem = driver.find_element_by_id("email")
      elem.send_keys(user)
      elem = driver.find_element_by_id("pass")
      elem.send_keys(pwd)
      elem.send_keys(Keys.RETURN)
   def tearDown(self):
      self.driver.close()
if __name__ == "__main__":
   unittest.main()