Python Web Scraping - Guida rapida
Il web scraping è un processo automatico di estrazione di informazioni dal web. Questo capitolo ti darà un'idea approfondita del web scraping, del suo confronto con il web crawling e del motivo per cui dovresti optare per il web scraping. Imparerai anche i componenti e il funzionamento di un web scraper.
Cos'è il Web Scraping?
Il significato del dizionario della parola "rottamazione" implica ottenere qualcosa dal web. Qui sorgono due domande: cosa possiamo ottenere dal web e come ottenerlo.
La risposta alla prima domanda è ‘data’. I dati sono indispensabili per qualsiasi programmatore e il requisito fondamentale di ogni progetto di programmazione è la grande quantità di dati utili.
La risposta alla seconda domanda è un po 'complicata, perché ci sono molti modi per ottenere dati. In generale, possiamo ottenere dati da un database o file di dati e altre fonti. Ma cosa succede se abbiamo bisogno di una grande quantità di dati disponibili online? Un modo per ottenere questo tipo di dati è cercare manualmente (facendo clic in un browser web) e salvare (copia-incolla in un foglio di calcolo o in un file) i dati richiesti. Questo metodo è piuttosto noioso e richiede tempo. Un altro modo per ottenere tali dati è usareweb scraping.
Web scraping, chiamato anche web data mining o web harvesting, è il processo di costruzione di un agente in grado di estrarre, analizzare, scaricare e organizzare automaticamente informazioni utili dal web. In altre parole, possiamo dire che invece di salvare manualmente i dati dai siti Web, il software di web scraping caricherà ed estrarrà automaticamente i dati da più siti Web secondo le nostre esigenze.
Origine del Web Scraping
L'origine del web scraping è lo screen scrapping, utilizzato per integrare applicazioni non basate sul web o applicazioni Windows native. Originariamente lo screen scraping era usato prima dell'ampio utilizzo del World Wide Web (WWW), ma non poteva aumentare il WWW espanso. Ciò ha reso necessario automatizzare l'approccio dello screen scraping e la tecnica chiamata‘Web Scraping’ è venuto all'esistenza.
Web Crawling v / s Web Scraping
I termini Web Crawling e Scraping sono spesso usati in modo intercambiabile poiché il loro concetto di base è estrarre i dati. Tuttavia, sono diversi l'uno dall'altro. Possiamo capire la differenza fondamentale dalle loro definizioni.
La scansione del Web è fondamentalmente utilizzata per indicizzare le informazioni sulla pagina utilizzando i bot noti anche come crawler. È anche chiamatoindexing. D'altra parte, il web scraping è un modo automatizzato di estrarre le informazioni utilizzando i bot noti come scraper. È anche chiamatodata extraction.
Per comprendere la differenza tra questi due termini, esaminiamo la tabella di confronto fornita di seguito:
Scansione web | Web scraping |
---|---|
Si riferisce al download e all'archiviazione dei contenuti di un gran numero di siti web. | Si riferisce all'estrazione di singoli elementi di dati dal sito Web utilizzando una struttura specifica del sito. |
Per lo più fatto su larga scala. | Può essere implementato su qualsiasi scala. |
Fornisce informazioni generiche. | Fornisce informazioni specifiche. |
Utilizzato dai principali motori di ricerca come Google, Bing, Yahoo. Googlebot è un esempio di crawler web. | Le informazioni estratte utilizzando il web scraping possono essere utilizzate per replicare in qualche altro sito Web o possono essere utilizzate per eseguire analisi dei dati. Ad esempio, gli elementi dei dati possono essere nomi, indirizzo, prezzo ecc. |
Usi di Web Scraping
Gli usi e le ragioni per utilizzare il web scraping sono infiniti quanto gli usi del World Wide Web. I web scrapers possono fare qualsiasi cosa come ordinare cibo online, scansionare il sito web di shopping online per te e acquistare il biglietto di una partita nel momento in cui sono disponibili, ecc. Proprio come può fare un essere umano. Alcuni degli usi importanti del web scraping sono discussi qui:
E-commerce Websites - I web scrapers possono raccogliere i dati relativi al prezzo di un prodotto specifico da vari siti di e-commerce per il loro confronto.
Content Aggregators - Il web scraping è ampiamente utilizzato dagli aggregatori di contenuti come gli aggregatori di notizie e gli aggregatori di lavoro per fornire dati aggiornati ai propri utenti.
Marketing and Sales Campaigns - I web scrapers possono essere utilizzati per ottenere dati come e-mail, numero di telefono ecc. Per campagne di vendita e marketing.
Search Engine Optimization (SEO) - Il web scraping è ampiamente utilizzato da strumenti SEO come SEMRush, Majestic ecc. Per indicare alle aziende come si posizionano per le parole chiave di ricerca che sono importanti per loro.
Data for Machine Learning Projects - Il recupero dei dati per i progetti di machine learning dipende dal web scraping.
Data for Research - I ricercatori possono raccogliere dati utili ai fini del loro lavoro di ricerca risparmiando tempo grazie a questo processo automatizzato.
Componenti di un Web Scraper
Un raschiatore è costituito dai seguenti componenti:
Modulo web crawler
Un componente molto necessario del web scraper, il modulo web crawler, viene utilizzato per navigare nel sito web di destinazione effettuando richieste HTTP o HTTPS agli URL. Il crawler scarica i dati non strutturati (contenuti HTML) e li passa all'estrattore, il modulo successivo.
Estrattore
L'estrattore elabora il contenuto HTML recuperato ed estrae i dati in un formato semistrutturato. Questo è anche chiamato come modulo parser e utilizza diverse tecniche di analisi come espressione regolare, analisi HTML, analisi DOM o intelligenza artificiale per il suo funzionamento.
Modulo di trasformazione e pulizia dei dati
I dati estratti sopra non sono adatti per un pronto utilizzo. Deve passare attraverso un modulo di pulizia in modo che possiamo usarlo. I metodi come la manipolazione delle stringhe o l'espressione regolare possono essere utilizzati a questo scopo. Notare che anche l'estrazione e la trasformazione possono essere eseguite in un unico passaggio.
Modulo di archiviazione
Dopo aver estratto i dati, dobbiamo archiviarli secondo le nostre esigenze. Il modulo di archiviazione produrrà i dati in un formato standard che può essere archiviato in un database o in formato JSON o CSV.
Lavorazione di un Web Scraper
Il web scraper può essere definito come un software o uno script utilizzato per scaricare il contenuto di più pagine web ed estrarre dati da esso.
Possiamo comprendere il funzionamento di un web scraper in semplici passaggi come mostrato nello schema sopra riportato.
Passaggio 1: download di contenuti dalle pagine Web
In questo passaggio, un web scraper scaricherà i contenuti richiesti da più pagine web.
Passaggio 2: estrazione dei dati
I dati sui siti web sono HTML e per lo più non strutturati. Quindi, in questo passaggio, web scraper analizzerà ed estrarrà i dati strutturati dai contenuti scaricati.
Passaggio 3: archiviazione dei dati
Qui, un web scraper memorizzerà e salverà i dati estratti in qualsiasi formato come CSV, JSON o nel database.
Passaggio 4: analisi dei dati
Dopo che tutti questi passaggi sono stati completati con successo, il web scraper analizzerà i dati così ottenuti.
Nel primo capitolo abbiamo imparato in cosa consiste il web scraping. In questo capitolo, vediamo come implementare il web scraping usando Python.
Perché Python per Web Scraping?
Python è uno strumento popolare per l'implementazione del web scraping. Il linguaggio di programmazione Python viene utilizzato anche per altri progetti utili relativi alla sicurezza informatica, ai test di penetrazione e alle applicazioni forensi digitali. Utilizzando la programmazione di base di Python, il web scraping può essere eseguito senza utilizzare altri strumenti di terze parti.
Il linguaggio di programmazione Python sta guadagnando un'enorme popolarità e le ragioni che rendono Python una buona soluzione per i progetti di web scraping sono le seguenti:
Semplicità della sintassi
Python ha la struttura più semplice rispetto ad altri linguaggi di programmazione. Questa caratteristica di Python semplifica i test e uno sviluppatore può concentrarsi maggiormente sulla programmazione.
Moduli integrati
Un altro motivo per utilizzare Python per il web scraping sono le utili librerie integrate ed esterne che possiede. Possiamo eseguire molte implementazioni relative al web scraping utilizzando Python come base per la programmazione.
Linguaggio di programmazione open source
Python ha un enorme supporto dalla comunità perché è un linguaggio di programmazione open source.
Ampia gamma di applicazioni
Python può essere utilizzato per varie attività di programmazione che vanno da piccoli script di shell alle applicazioni web aziendali.
Installazione di Python
La distribuzione Python è disponibile per piattaforme come Windows, MAC e Unix / Linux. Dobbiamo scaricare solo il codice binario applicabile alla nostra piattaforma per installare Python. Ma nel caso in cui il codice binario per la nostra piattaforma non fosse disponibile, dobbiamo avere un compilatore C in modo che il codice sorgente possa essere compilato manualmente.
Possiamo installare Python su varie piattaforme come segue:
Installazione di Python su Unix e Linux
È necessario seguire i passaggi indicati di seguito per installare Python su macchine Unix / Linux -
Step 1 - Vai al link https://www.python.org/downloads/
Step 2 - Scarica il codice sorgente zippato disponibile per Unix / Linux sul link sopra.
Step 3 - Estrai i file sul tuo computer.
Step 4 - Utilizzare i seguenti comandi per completare l'installazione:
run ./configure script
make
make install
Puoi trovare Python installato nella posizione standard /usr/local/bin e le sue biblioteche all'indirizzo /usr/local/lib/pythonXX, dove XX è la versione di Python.
Installazione di Python su Windows
È necessario seguire i passaggi indicati di seguito per installare Python su macchine Windows -
Step 1 - Vai al link https://www.python.org/downloads/
Step 2 - Scarica il programma di installazione di Windows python-XYZ.msi file, dove XYZ è la versione che dobbiamo installare.
Step 3 - Ora salva il file di installazione sul tuo computer locale ed esegui il file MSI.
Step 4 - Alla fine, esegui il file scaricato per aprire la procedura guidata di installazione di Python.
Installazione di Python su Macintosh
Dobbiamo usare Homebrew per l'installazione di Python 3 su Mac OS X. Homebrew è facile da installare e un ottimo programma di installazione di pacchetti.
Homebrew può essere installato anche utilizzando il seguente comando:
$ ruby -e "$(curl -fsSL
https://raw.githubusercontent.com/Homebrew/install/master/install)"
Per aggiornare il gestore dei pacchetti, possiamo usare il seguente comando:
$ brew update
Con l'aiuto del seguente comando, possiamo installare Python3 sulla nostra macchina MAC -
$ brew install python3
Configurazione del PERCORSO
È possibile utilizzare le seguenti istruzioni per impostare il percorso su vari ambienti:
Impostazione del percorso su Unix / Linux
Utilizzare i seguenti comandi per impostare i percorsi utilizzando varie shell dei comandi:
Per la shell csh
setenv PATH "$PATH:/usr/local/bin/python".
Per bash shell (Linux)
ATH="$PATH:/usr/local/bin/python".
Per sh o ksh shell
PATH="$PATH:/usr/local/bin/python".
Configurazione del percorso su Windows
Per impostare il percorso su Windows, possiamo utilizzare il percorso %path%;C:\Python al prompt dei comandi e quindi premere Invio.
Esecuzione di Python
Possiamo avviare Python utilizzando uno dei seguenti tre modi:
Interprete interattivo
Un sistema operativo come UNIX e DOS che fornisce un interprete della riga di comando o una shell può essere utilizzato per avviare Python.
Possiamo iniziare a codificare nell'interprete interattivo come segue:
Step 1 - Entra python dalla riga di comando.
Step 2 - Quindi, possiamo iniziare subito a scrivere codice nell'interprete interattivo.
$python # Unix/Linux
or
python% # Unix/Linux
or
C:> python # Windows/DOS
Script dalla riga di comando
Possiamo eseguire uno script Python dalla riga di comando invocando l'interprete. Può essere inteso come segue:
$python script.py # Unix/Linux
or
python% script.py # Unix/Linux
or
C: >python script.py # Windows/DOS
Ambiente di sviluppo integrato
Possiamo anche eseguire Python dall'ambiente GUI se il sistema dispone di un'applicazione GUI che supporta Python. Di seguito sono riportati alcuni IDE che supportano Python su varie piattaforme:
IDE for UNIX - UNIX, per Python, ha IDLE IDE.
IDE for Windows - Windows ha PythonWin IDE che ha anche la GUI.
IDE for Macintosh - Macintosh ha IDLE IDE che può essere scaricato come file MacBinary o BinHex dal sito web principale.
In questo capitolo impariamo vari moduli Python che possiamo usare per il web scraping.
Ambienti di sviluppo Python che utilizzano virtualenv
Virtualenv è uno strumento per creare ambienti Python isolati. Con l'aiuto di virtualenv, possiamo creare una cartella che contiene tutti gli eseguibili necessari per utilizzare i pacchetti richiesti dal nostro progetto Python. Ci permette anche di aggiungere e modificare moduli Python senza accesso all'installazione globale.
È possibile utilizzare il seguente comando per installare 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
Ora, dobbiamo creare una directory che rappresenterà il progetto con l'aiuto del seguente comando:
(base) D:\ProgramData>mkdir webscrap
Ora, entra in quella directory con l'aiuto del seguente comando:
(base) D:\ProgramData>cd webscrap
Ora, dobbiamo inizializzare la cartella dell'ambiente virtuale di nostra scelta come segue:
(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.
Ora, attiva l'ambiente virtuale con il comando fornito di seguito. Una volta attivato con successo, ne vedrai il nome sul lato sinistro tra parentesi.
(base) D:\ProgramData\webscrap>websc\scripts\activate
Possiamo installare qualsiasi modulo in questo ambiente come segue:
(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
Per disattivare l'ambiente virtuale, possiamo utilizzare il seguente comando:
(websc) (base) D:\ProgramData\webscrap>deactivate
(base) D:\ProgramData\webscrap>
Puoi vedere che (websc) è stato disattivato.
Moduli Python per Web Scraping
Il web scraping è il processo di costruzione di un agente in grado di estrarre, analizzare, scaricare e organizzare automaticamente informazioni utili dal web. In altre parole, invece di salvare manualmente i dati dai siti Web, il software di web scraping caricherà ed estrarrà automaticamente i dati da più siti Web secondo le nostre esigenze.
In questa sezione, discuteremo di utili librerie Python per il web scraping.
Richieste
È una semplice libreria di scraping web in Python. È un'efficiente libreria HTTP utilizzata per accedere alle pagine web. Con l'aiuto diRequests, possiamo ottenere l'HTML grezzo delle pagine web che possono quindi essere analizzate per recuperare i dati. Prima di usarerequests, cerchiamo di capire la sua installazione.
Richieste di installazione
Possiamo installarlo nel nostro ambiente virtuale o nell'installazione globale. Con l'aiuto dipip comando, possiamo installarlo facilmente come segue:
(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
Esempio
In questo esempio, stiamo effettuando una richiesta GET HTTP per una pagina web. Per questo dobbiamo prima importare la libreria delle richieste come segue:
In [1]: import requests
Nella seguente riga di codice, utilizziamo le richieste per effettuare richieste HTTP GET per l'URL: https://authoraditiagarwal.com/ effettuando una richiesta GET.
In [2]: r = requests.get('https://authoraditiagarwal.com/')
Ora possiamo recuperare il contenuto utilizzando .text proprietà come segue -
In [5]: r.text[:200]
Si noti che nell'output seguente abbiamo i primi 200 caratteri.
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
È un'altra libreria Python che può essere utilizzata per recuperare dati da URL simili a requestsbiblioteca. Puoi leggere di più su questo nella sua documentazione tecnica suhttps://urllib3.readthedocs.io/en/latest/.
Installazione di Urllib3
Usando il pip comando, possiamo installare urllib3 nel nostro ambiente virtuale o nell'installazione 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
Esempio: scraping utilizzando Urllib3 e BeautifulSoup
Nel seguente esempio, stiamo raschiando la pagina web utilizzando Urllib3 e BeautifulSoup. Stiamo usandoUrllib3al posto della libreria delle richieste per ottenere i dati grezzi (HTML) dalla pagina web. Quindi stiamo usandoBeautifulSoup per analizzare i dati 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)
Questo è l'output che osserverai quando esegui questo codice -
<title>Learn and Grow with Aditi Agarwal</title>
Learn and Grow with Aditi Agarwal
Selenio
È una suite di test automatizzati open source per applicazioni web su diversi browser e piattaforme. Non è un singolo strumento ma una suite di software. Abbiamo collegamenti al selenio per Python, Java, C #, Ruby e JavaScript. Qui eseguiremo il web scraping usando il selenio e le sue associazioni Python. Puoi saperne di più su Selenium con Java sul link Selenium .
I collegamenti Selenium Python forniscono una comoda API per accedere a Selenium WebDrivers come Firefox, IE, Chrome, Remote ecc. Le attuali versioni di Python supportate sono 2.7, 3.5 e superiori.
Installazione del selenio
Usando il pip comando, possiamo installare urllib3 nel nostro ambiente virtuale o nell'installazione globale.
pip install selenium
Poiché il selenio richiede un driver per interfacciarsi con il browser scelto, è necessario scaricarlo. La tabella seguente mostra diversi browser e i relativi collegamenti per scaricarli.
Chrome |
https://sites.google.com/a/chromium.org/ |
Edge |
https://developer.microsoft.com/ |
Firefox |
https://github.com/ |
Safari |
https://webkit.org/ |
Esempio
Questo esempio mostra il web scraping utilizzando il selenio. Può anche essere utilizzato per il test che si chiama test del selenio.
Dopo aver scaricato il driver specifico per la versione del browser specificata, dobbiamo programmare in Python.
Innanzitutto, è necessario importare webdriver dal selenio come segue -
from selenium import webdriver
Ora, fornisci il percorso del driver web che abbiamo scaricato secondo il nostro requisito -
path = r'C:\\Users\\gaurav\\Desktop\\Chromedriver'
browser = webdriver.Chrome(executable_path = path)
Ora, fornisci l'URL che vogliamo aprire in quel browser web ora controllato dal nostro script Python.
browser.get('https://authoraditiagarwal.com/leadershipmanagement')
Possiamo anche raschiare un particolare elemento fornendo xpath come fornito in lxml.
browser.find_element_by_xpath('/html/body').click()
È possibile controllare il browser, controllato dallo script Python, per l'output.
Scrapy
Scrapy è un framework di scansione web veloce e open source scritto in Python, utilizzato per estrarre i dati dalla pagina web con l'aiuto di selettori basati su XPath. Scrapy è stato rilasciato per la prima volta il 26 giugno 2008 con licenza BSD, con una milestone 1.0 rilasciata a giugno 2015. Ci fornisce tutti gli strumenti di cui abbiamo bisogno per estrarre, elaborare e strutturare i dati dai siti web.
Installazione di Scrapy
Usando il pip comando, possiamo installare urllib3 nel nostro ambiente virtuale o nell'installazione globale.
pip install scrapy
Per uno studio più dettagliato di Scrapy puoi andare al link Scrapy
Con Python possiamo raschiare qualsiasi sito web o particolari elementi di una pagina web, ma hai idea se sia legale o meno? Prima di eseguire lo scraping di qualsiasi sito Web, è necessario conoscere la legalità del Web scraping. Questo capitolo spiegherà i concetti relativi alla legalità del web scraping.
introduzione
In generale, se intendi utilizzare i dati raschiati per uso personale, potrebbero non esserci problemi. Ma se hai intenzione di ripubblicare quei dati, prima di fare lo stesso dovresti fare la richiesta di download al proprietario o fare qualche ricerca di base anche sulle politiche sui dati che intendi raschiare.
Ricerca richiesta prima della raschiatura
Se stai prendendo di mira un sito web per estrarre dati da esso, dobbiamo comprenderne la scala e la struttura. Di seguito sono riportati alcuni dei file che dobbiamo analizzare prima di iniziare il web scraping.
Analisi del file robots.txt
In realtà la maggior parte degli editori consente ai programmatori di eseguire la scansione dei propri siti Web in una certa misura. In un altro senso, gli editori desiderano che venga eseguita la scansione di parti specifiche dei siti web. Per definirlo, i siti web devono mettere alcune regole per indicare quali parti possono essere sottoposte a scansione e quali no. Tali regole sono definite in un file chiamatorobots.txt.
robots.txtè un file leggibile dall'uomo utilizzato per identificare le parti del sito web che i crawler sono autorizzati e non sono autorizzati a raschiare. Non esiste un formato standard del file robots.txt e gli editori del sito web possono apportare modifiche secondo le loro esigenze. Possiamo controllare il file robots.txt per un particolare sito web fornendo una barra e un file robots.txt dopo l'URL di quel sito web. Ad esempio, se vogliamo controllarlo per Google.com, dobbiamo digitarehttps://www.google.com/robots.txt e otterremo qualcosa come segue:
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……..
Alcune delle regole più comuni definite nel file robots.txt di un sito web sono le seguenti:
User-agent: BadCrawler
Disallow: /
La regola precedente indica che il file robots.txt chiede a un crawler con BadCrawler agente utente di non eseguire la scansione del proprio sito web.
User-agent: *
Crawl-delay: 5
Disallow: /trap
La regola precedente indica che il file robots.txt ritarda un crawler di 5 secondi tra le richieste di download per tutti gli user-agent per evitare il sovraccarico del server. Il/traplink proverà a bloccare i crawler dannosi che seguono i link non consentiti. Ci sono molte altre regole che possono essere definite dall'editore del sito web secondo i loro requisiti. Alcuni di loro sono discussi qui -
Analisi dei file Sitemap
Cosa dovresti fare se desideri eseguire la scansione di un sito Web per informazioni aggiornate? Scansionerai ogni pagina web per ottenere quelle informazioni aggiornate, ma questo aumenterà il traffico del server di quel particolare sito web. Questo è il motivo per cui i siti Web forniscono file di mappa del sito per aiutare i crawler a individuare i contenuti aggiornati senza la necessità di eseguire la scansione di ogni pagina Web. Lo standard della mappa del sito è definito inhttp://www.sitemaps.org/protocol.html.
Contenuto del file Sitemap
Quello che segue è il contenuto del file della mappa del sito di https://www.microsoft.com/robots.txt che viene scoperto nel file 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
Il contenuto di cui sopra mostra che la mappa del sito elenca gli URL sul sito web e consente inoltre a un webmaster di specificare alcune informazioni aggiuntive come la data dell'ultimo aggiornamento, la modifica dei contenuti, l'importanza dell'URL in relazione ad altri ecc. Su ogni URL.
Qual è la dimensione del sito web?
La dimensione di un sito Web, ovvero il numero di pagine Web di un sito Web, influisce sul modo in cui eseguiamo la scansione? Certamente sì. Perché se abbiamo un numero inferiore di pagine Web da sottoporre a scansione, l'efficienza non sarebbe un problema serio, ma supponiamo che se il nostro sito Web ha milioni di pagine Web, ad esempio Microsoft.com, il download di ciascuna pagina Web in sequenza richiederebbe diversi mesi e allora l'efficienza sarebbe una seria preoccupazione.
Controllo delle dimensioni del sito web
Controllando la dimensione del risultato del crawler di Google, possiamo avere una stima delle dimensioni di un sito web. Il nostro risultato può essere filtrato utilizzando la parola chiavesitedurante la ricerca su Google. Ad esempio, stimando la dimensione dihttps://authoraditiagarwal.com/ è dato di seguito -
Puoi vedere che ci sono circa 60 risultati, il che significa che non è un grande sito web e la scansione non porterebbe al problema dell'efficienza.
Quale tecnologia viene utilizzata dal sito web?
Un'altra domanda importante è se la tecnologia utilizzata dal sito web influisce sul modo in cui eseguiamo la scansione? Sì, colpisce. Ma come possiamo verificare la tecnologia utilizzata da un sito web? C'è una libreria Python denominatabuiltwith con l'aiuto del quale possiamo conoscere la tecnologia utilizzata da un sito web.
Esempio
In questo esempio controlleremo la tecnologia utilizzata dal sito web https://authoraditiagarwal.com con l'aiuto della libreria Python builtwith. Ma prima di utilizzare questa libreria, dobbiamo installarla come segue:
(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
Ora, con l'aiuto di una semplice riga di codici, possiamo controllare la tecnologia utilizzata da un determinato sito Web:
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']}
Chi è il proprietario del sito web?
Anche il proprietario del sito Web è importante perché se il proprietario è noto per bloccare i crawler, i crawler devono fare attenzione durante la rimozione dei dati dal sito Web. C'è un protocollo denominatoWhois con l'aiuto del quale possiamo conoscere il proprietario del sito web.
Esempio
In questo esempio controlleremo il proprietario del sito Web, ad esempio microsoft.com, con l'aiuto di Whois. Ma prima di utilizzare questa libreria, dobbiamo installarla come segue:
(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
Ora, con l'aiuto di una semplice riga di codici, possiamo controllare la tecnologia utilizzata da un determinato sito Web:
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]"
],
}
Analizzare una pagina web significa comprenderne la struttura. Ora, sorge la domanda: perché è importante per il web scraping? In questo capitolo, cerchiamo di capirlo in dettaglio.
Analisi della pagina web
L'analisi della pagina Web è importante perché senza analizzare non siamo in grado di sapere in quale forma riceveremo i dati (strutturati o non strutturati) da quella pagina Web dopo l'estrazione. Possiamo eseguire l'analisi della pagina web nei seguenti modi:
Visualizzazione dell'origine della pagina
Questo è un modo per capire come è strutturata una pagina web esaminando il suo codice sorgente. Per implementarlo, dobbiamo fare clic con il pulsante destro del mouse sulla pagina e quindi selezionare il fileView page sourceopzione. Quindi, otterremo i dati di nostro interesse da quella pagina web sotto forma di HTML. Ma la preoccupazione principale riguarda gli spazi bianchi e la formattazione che è difficile da formattare.
Ispezione dell'origine della pagina facendo clic sull'opzione Ispeziona elemento
Questo è un altro modo per analizzare la pagina web. Ma la differenza è che risolverà il problema della formattazione e degli spazi bianchi nel codice sorgente della pagina web. È possibile implementarlo facendo clic con il pulsante destro del mouse e quindi selezionando il fileInspect o Inspect elementopzione dal menu. Fornirà le informazioni su una particolare area o elemento di quella pagina web.
Modi diversi per estrarre i dati dalla pagina Web
I seguenti metodi vengono utilizzati principalmente per estrarre dati da una pagina Web:
Espressione regolare
Sono un linguaggio di programmazione altamente specializzato incorporato in Python. Possiamo usarlo attraversoremodulo di Python. È anche chiamato RE o regex o regex patterns. Con l'aiuto delle espressioni regolari, possiamo specificare alcune regole per il possibile insieme di stringhe che vogliamo far corrispondere dai dati.
Se vuoi saperne di più sulle espressioni regolari in generale, vai al link https://www.tutorialspoint.com/automata_theory/regular_expressions.htme se vuoi saperne di più sul modulo re o sulle espressioni regolari in Python, puoi seguire il link https://www.tutorialspoint.com/python/python_reg_expressions.htm .
Esempio
Nell'esempio seguente, raccoglieremo dati sull'India da http://example.webscraping.com dopo aver confrontato il contenuto di <td> con l'aiuto di espressioni regolari.
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)
Produzione
L'output corrispondente sarà come mostrato qui -
[
'<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>'
]
Osserva che nell'output sopra puoi vedere i dettagli sul paese India utilizzando espressioni regolari.
Bella zuppa
Supponiamo di voler raccogliere tutti i collegamenti ipertestuali da una pagina web, quindi possiamo usare un parser chiamato BeautifulSoup che può essere conosciuto in maggior dettaglio all'indirizzo https://www.crummy.com/software/BeautifulSoup/bs4/doc/.In parole semplici, BeautifulSoup è una libreria Python per estrarre dati da file HTML e XML. Può essere utilizzato con le richieste, perché ha bisogno di un input (documento o URL) per creare un oggetto zuppa poiché non può recuperare una pagina web da solo. È possibile utilizzare il seguente script Python per raccogliere il titolo della pagina Web e i collegamenti ipertestuali.
Installazione di Beautiful Soup
Usando il pip comando, possiamo installare beautifulsoup nel nostro ambiente virtuale o nell'installazione 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
Esempio
Si noti che in questo esempio, stiamo estendendo l'esempio sopra implementato con richieste modulo python. stiamo usandor.text per creare un oggetto zuppa che verrà ulteriormente utilizzato per recuperare dettagli come il titolo della pagina web.
Innanzitutto, dobbiamo importare i moduli Python necessari -
import requests
from bs4 import BeautifulSoup
Nella seguente riga di codice utilizziamo le richieste per effettuare una richiesta HTTP GET per l'URL: https://authoraditiagarwal.com/ effettuando una richiesta GET.
r = requests.get('https://authoraditiagarwal.com/')
Ora dobbiamo creare un oggetto Soup come segue:
soup = BeautifulSoup(r.text, 'lxml')
print (soup.title)
print (soup.title.text)
Produzione
L'output corrispondente sarà come mostrato qui -
<title>Learn and Grow with Aditi Agarwal</title>
Learn and Grow with Aditi Agarwal
Lxml
Un'altra libreria Python di cui parleremo per il web scraping è lxml. Si tratta di una libreria di analisi HTML e XML ad alte prestazioni. È relativamente veloce e semplice. Puoi leggere di più suhttps://lxml.de/.
Installazione di lxml
Usando il comando pip, possiamo installare lxml nel nostro ambiente virtuale o nell'installazione 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
Esempio: estrazione dei dati utilizzando lxml e richieste
Nel seguente esempio, stiamo estraendo un particolare elemento della pagina web da authoraditiagarwal.com utilizzando lxml e richieste -
Innanzitutto, dobbiamo importare le richieste e l'html dalla libreria lxml come segue:
import requests
from lxml import html
Ora dobbiamo fornire l'URL della pagina web da rottamare
url = 'https://authoraditiagarwal.com/leadershipmanagement/'
Ora dobbiamo fornire il percorso (Xpath) a un particolare elemento di quella pagina 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())
Produzione
L'output corrispondente sarà come mostrato qui -
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.
Nei capitoli precedenti, abbiamo appreso come estrarre i dati dalle pagine Web o eseguire lo scraping del Web mediante vari moduli Python. In questo capitolo, esaminiamo varie tecniche per elaborare i dati che sono stati raschiati.
introduzione
Per elaborare i dati che sono stati raschiati, dobbiamo memorizzare i dati sulla nostra macchina locale in un formato particolare come foglio di calcolo (CSV), JSON o talvolta in database come MySQL.
Elaborazione dati CSV e JSON
Innanzitutto, scriveremo le informazioni, dopo averle prese dalla pagina web, in un file CSV o in un foglio di calcolo. Cerchiamo prima di capire attraverso un semplice esempio in cui prima afferreremo le informazioni utilizzandoBeautifulSoup modulo, come fatto in precedenza, quindi utilizzando il modulo CSV di Python scriveremo le informazioni testuali nel file CSV.
Innanzitutto, dobbiamo importare le librerie Python necessarie come segue:
import requests
from bs4 import BeautifulSoup
import csv
Nella seguente riga di codice, utilizziamo le richieste per effettuare richieste HTTP GET per l'URL: https://authoraditiagarwal.com/ effettuando una richiesta GET.
r = requests.get('https://authoraditiagarwal.com/')
Ora, dobbiamo creare un oggetto Soup come segue:
soup = BeautifulSoup(r.text, 'lxml')
Ora, con l'aiuto delle prossime righe di codice, scriveremo i dati acquisiti in un file CSV denominato dataprocessing.csv.
f = csv.writer(open(' dataprocessing.csv ','w'))
f.writerow(['Title'])
f.writerow([soup.title.text])
Dopo aver eseguito questo script, le informazioni testuali o il titolo della pagina web verranno salvati nel file CSV sopra menzionato sul tuo computer locale.
Allo stesso modo, possiamo salvare le informazioni raccolte in un file JSON. Quello che segue è uno script Python facile da capire per fare la stessa cosa in cui stiamo acquisendo le stesse informazioni che abbiamo fatto nell'ultimo script Python, ma questa volta le informazioni acquisite vengono salvate in JSONfile.txt utilizzando il modulo 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)
Dopo aver eseguito questo script, le informazioni raccolte, ad esempio il titolo della pagina web, verranno salvate nel file di testo sopra menzionato sul tuo computer locale.
Elaborazione dei dati tramite AWS S3
A volte potremmo voler salvare i dati raschiati nella nostra memoria locale a scopo di archiviazione. Ma cosa succederebbe se avessimo bisogno di archiviare e analizzare questi dati su vasta scala? La risposta è il servizio di cloud storage denominato Amazon S3 o AWS S3 (Simple Storage Service). Fondamentalmente AWS S3 è uno storage di oggetti creato per archiviare e recuperare qualsiasi quantità di dati da qualsiasi luogo.
Possiamo seguire i seguenti passaggi per l'archiviazione dei dati in AWS S3:
Step 1- Per prima cosa abbiamo bisogno di un account AWS che ci fornirà le chiavi segrete da utilizzare nel nostro script Python durante l'archiviazione dei dati. Creerà un bucket S3 in cui possiamo memorizzare i nostri dati.
Step 2 - Successivamente, dobbiamo installare boto3Libreria Python per l'accesso al bucket S3. Può essere installato con l'aiuto del seguente comando:
pip install boto3
Step 3 - Successivamente, possiamo utilizzare il seguente script Python per estrarre i dati dalla pagina Web e salvarli nel bucket AWS S3.
Innanzitutto, dobbiamo importare le librerie Python per lo scraping, con cui stiamo lavorando requests, e boto3 salvataggio dei dati nel bucket S3.
import requests
import boto3
Ora possiamo raschiare i dati dal nostro URL.
data = requests.get("Enter the URL").text
Ora per archiviare i dati nel bucket S3, dobbiamo creare il client S3 come segue:
s3 = boto3.client('s3')
bucket_name = "our-content"
La prossima riga di codice creerà il bucket S3 come segue:
s3.create_bucket(Bucket = bucket_name, ACL = 'public-read')
s3.put_object(Bucket = bucket_name, Key = '', Body = data, ACL = "public-read")
Ora puoi controllare il bucket con il nome del nostro contenuto dal tuo account AWS.
Elaborazione dei dati tramite MySQL
Impariamo come elaborare i dati utilizzando MySQL. Se vuoi saperne di più su MySQL, puoi seguire il linkhttps://www.tutorialspoint.com/mysql/.
Con l'aiuto dei seguenti passaggi, possiamo raschiare ed elaborare i dati nella tabella MySQL -
Step 1- Per prima cosa, utilizzando MySQL dobbiamo creare un database e una tabella in cui salvare i nostri dati raschiati. Ad esempio, stiamo creando la tabella con la seguente query:
CREATE TABLE Scrap_pages (id BIGINT(7) NOT NULL AUTO_INCREMENT,
title VARCHAR(200), content VARCHAR(10000),PRIMARY KEY(id));
Step 2- Successivamente, dobbiamo occuparci di Unicode. Nota che MySQL non gestisce Unicode per impostazione predefinita. Dobbiamo attivare questa funzione con l'aiuto dei seguenti comandi che cambieranno il set di caratteri predefinito per il database, per la tabella e per entrambe le colonne:
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- Ora integra MySQL con Python. Per questo, avremo bisogno di PyMySQL che può essere installato con l'aiuto del seguente comando
pip install PyMySQL
Step 4- Ora, il nostro database denominato Scrap, creato in precedenza, è pronto per salvare i dati, dopo averli raschiati dal web, nella tabella denominata Scrap_pages. Qui, nel nostro esempio, raccoglieremo i dati da Wikipedia e verranno salvati nel nostro database.
Innanzitutto, dobbiamo importare i moduli Python richiesti.
from urllib.request import urlopen
from bs4 import BeautifulSoup
import datetime
import random
import pymysql
import re
Ora, crea una connessione, ovvero integrala con 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()
Ora connettiti con Wikipedia e ottieni dati da esso.
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)
Infine, dobbiamo chiudere sia il cursore che la connessione.
finally:
cur.close()
conn.close()
Ciò salverà i dati raccolti da Wikipedia nella tabella denominata scrap_pages. Se hai familiarità con MySQL e il web scraping, il codice sopra non sarebbe difficile da capire.
Elaborazione dei dati tramite PostgreSQL
PostgreSQL, sviluppato da un team mondiale di volontari, è un sistema di gestione di database relazionali (RDMS) open source. Il processo di elaborazione dei dati raschiati utilizzando PostgreSQL è simile a quello di MySQL. Ci sarebbero due modifiche: in primo luogo, i comandi sarebbero diversi da MySQL e in secondo luogo, qui useremopsycopg2 Libreria Python per eseguire la sua integrazione con Python.
Se non hai familiarità con PostgreSQL, puoi impararlo su https://www.tutorialspoint.com/postgresql/. E con l'aiuto del seguente comando possiamo installare la libreria Python psycopg2 -
pip install psycopg2
Il Web scraping di solito comporta il download, l'archiviazione e l'elaborazione del contenuto multimediale del Web. In questo capitolo, vediamo come elaborare il contenuto scaricato dal web.
introduzione
I contenuti multimediali web che otteniamo durante lo scraping possono essere file di immagini, audio e video, sotto forma di pagine non web e file di dati. Ma possiamo fidarci dei dati scaricati, specialmente sull'estensione dei dati che scaricheremo e memorizzeremo nella memoria del nostro computer? Ciò rende essenziale conoscere il tipo di dati che memorizzeremo localmente.
Recupero di contenuti multimediali dalla pagina Web
In questa sezione, impareremo come scaricare contenuti multimediali che rappresentano correttamente il tipo di media in base alle informazioni dal server web. Possiamo farlo con l'aiuto di Pythonrequests modulo come abbiamo fatto nel capitolo precedente.
Innanzitutto, dobbiamo importare i moduli Python necessari come segue:
import requests
Ora, fornisci l'URL del contenuto multimediale che vogliamo scaricare e archiviare localmente.
url = "https://authoraditiagarwal.com/wpcontent/uploads/2018/05/MetaSlider_ThinkBig-1080x180.jpg"
Utilizzare il codice seguente per creare l'oggetto risposta HTTP.
r = requests.get(url)
Con l'aiuto della seguente riga di codice, possiamo salvare il contenuto ricevuto come file .png.
with open("ThinkBig.png",'wb') as f:
f.write(r.content)
Dopo aver eseguito lo script Python sopra, otterremo un file denominato ThinkBig.png, che avrebbe l'immagine scaricata.
Estrazione del nome del file dall'URL
Dopo aver scaricato il contenuto dal sito web, vogliamo anche salvarlo in un file con un nome di file trovato nell'URL. Ma possiamo anche verificare se esistono anche numeri di frammenti aggiuntivi nell'URL. Per questo, dobbiamo trovare il nome del file effettivo dall'URL.
Con l'aiuto di seguire lo script Python, usando urlparse, possiamo estrarre il nome del file dall'URL -
import urllib3
import os
url = "https://authoraditiagarwal.com/wpcontent/uploads/2018/05/MetaSlider_ThinkBig-1080x180.jpg"
a = urlparse(url)
a.path
È possibile osservare l'output come mostrato di seguito:
'/wp-content/uploads/2018/05/MetaSlider_ThinkBig-1080x180.jpg'
os.path.basename(a.path)
È possibile osservare l'output come mostrato di seguito:
'MetaSlider_ThinkBig-1080x180.jpg'
Una volta eseguito lo script precedente, otterremo il nome del file dall'URL.
Informazioni sul tipo di contenuto dall'URL
Durante l'estrazione dei contenuti dal web server, su richiesta GET, possiamo anche verificare le sue informazioni fornite dal web server. Con l'aiuto del seguente script Python possiamo determinare cosa significa server web con il tipo di contenuto -
Innanzitutto, dobbiamo importare i moduli Python necessari come segue:
import requests
Ora, dobbiamo fornire l'URL del contenuto multimediale che vogliamo scaricare e archiviare localmente.
url = "https://authoraditiagarwal.com/wpcontent/uploads/2018/05/MetaSlider_ThinkBig-1080x180.jpg"
La seguente riga di codice creerà l'oggetto risposta HTTP.
r = requests.get(url, allow_redirects=True)
Ora possiamo ottenere il tipo di informazioni sui contenuti che possono essere fornite dal server web.
for headers in r.headers: print(headers)
È possibile osservare l'output come mostrato di seguito:
Date
Server
Upgrade
Connection
Last-Modified
Accept-Ranges
Content-Length
Keep-Alive
Content-Type
Con l'aiuto della seguente riga di codice possiamo ottenere le informazioni particolari sul tipo di contenuto, diciamo tipo di contenuto -
print (r.headers.get('content-type'))
È possibile osservare l'output come mostrato di seguito:
image/jpeg
Con l'aiuto della seguente riga di codice, possiamo ottenere le informazioni particolari sul tipo di contenuto, ad esempio EType -
print (r.headers.get('ETag'))
È possibile osservare l'output come mostrato di seguito:
None
Osserva il seguente comando:
print (r.headers.get('content-length'))
È possibile osservare l'output come mostrato di seguito:
12636
Con l'aiuto della seguente riga di codice possiamo ottenere le informazioni particolari sul tipo di contenuto, diciamo Server -
print (r.headers.get('Server'))
È possibile osservare l'output come mostrato di seguito:
Apache
Generazione di miniature per le immagini
La miniatura è una descrizione o una rappresentazione molto piccola. Un utente potrebbe voler salvare solo la miniatura di un'immagine grande o salvare sia l'immagine che la miniatura. In questa sezione creeremo una miniatura dell'immagine denominataThinkBig.png scaricato nella sezione precedente "Acquisizione di contenuti multimediali dalla pagina web".
Per questo script Python, dobbiamo installare la libreria Python denominata Pillow, un fork della libreria Python Image con funzioni utili per la manipolazione delle immagini. Può essere installato con l'aiuto del seguente comando:
pip install pillow
Il seguente script Python creerà una miniatura dell'immagine e la salverà nella directory corrente anteponendo al file di anteprima 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")
Il codice sopra è molto facile da capire e puoi controllare il file di anteprima nella directory corrente.
Screenshot dal sito web
Nel web scraping, un'attività molto comune è acquisire uno screenshot di un sito web. Per implementarlo, useremo selenio e webdriver. Il seguente script Python acquisirà lo screenshot dal sito Web e lo salverà nella directory corrente.
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
È possibile osservare l'output come mostrato di seguito:
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")>>
Dopo aver eseguito lo script, puoi controllare la directory corrente per screenshot.png file.
Generazione di miniature per video
Supponiamo di aver scaricato video dal sito Web e di voler generare le miniature per loro in modo che sia possibile fare clic su un video specifico, in base alla sua miniatura. Per generare miniature per i video abbiamo bisogno di un semplice strumento chiamatoffmpeg che può essere scaricato da www.ffmpeg.org. Dopo il download, dobbiamo installarlo secondo le specifiche del nostro sistema operativo.
Il seguente script Python genererà una miniatura del video e la salverà nella nostra directory locale -
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"])
Dopo aver eseguito lo script precedente, otterremo la miniatura denominata thumbnail_solar_video.jpg salvato nella nostra directory locale.
Copia di un video MP4 in un MP3
Supponi di aver scaricato un file video da un sito Web, ma hai solo bisogno dell'audio da quel file per servire al tuo scopo, quindi può essere fatto in Python con l'aiuto della libreria Python chiamata moviepy che può essere installato con l'aiuto del seguente comando:
pip install moviepy
Ora, dopo aver installato con successo moviepy con l'aiuto del seguente script, possiamo convertire e MP4 in MP3.
import moviepy.editor as mp
clip = mp.VideoFileClip(r"C:\Users\gaurav\Desktop\1234.mp4")
clip.audio.write_audiofile("movie_audio.mp3")
È possibile osservare l'output come mostrato di seguito:
[MoviePy] Writing audio in movie_audio.mp3
100%|¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦
¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦| 674/674 [00:01<00:00,
476.30it/s]
[MoviePy] Done.
Lo script sopra salverà il file audio MP3 nella directory locale.
Nel capitolo precedente abbiamo visto come trattare i video e le immagini che otteniamo come parte del contenuto di web scraping. In questo capitolo ci occuperemo dell'analisi del testo utilizzando la libreria Python e lo impareremo in dettaglio.
introduzione
È possibile eseguire l'analisi del testo utilizzando la libreria Python denominata Natural Language Tool Kit (NLTK). Prima di passare ai concetti di NLTK, comprendiamo la relazione tra analisi del testo e web scraping.
Analizzare le parole nel testo può portarci a sapere quali parole sono importanti, quali parole sono insolite, come le parole sono raggruppate. Questa analisi semplifica l'attività di web scraping.
Iniziare con NLTK
Il Natural language toolkit (NLTK) è una raccolta di librerie Python progettata appositamente per identificare e taggare parti del discorso trovate nel testo del linguaggio naturale come l'inglese.
Installazione di NLTK
È possibile utilizzare il seguente comando per installare NLTK in Python:
pip install nltk
Se stai usando Anaconda, allora un pacchetto conda per NLTK può essere creato usando il seguente comando:
conda install -c anaconda nltk
Download dei dati di NLTK
Dopo aver installato NLTK, dobbiamo scaricare repository di testo preimpostati. Ma prima di scaricare i repository di preset di testo, dobbiamo importare NLTK con l'aiuto diimport comando come segue -
mport nltk
Ora, con l'aiuto del seguente comando, è possibile scaricare i dati NLTK -
nltk.download()
L'installazione di tutti i pacchetti disponibili di NLTK richiederà del tempo, ma si consiglia sempre di installare tutti i pacchetti.
Installazione di altri pacchetti necessari
Abbiamo anche bisogno di altri pacchetti Python come gensim e pattern per eseguire analisi del testo e creare applicazioni per l'elaborazione del linguaggio naturale utilizzando NLTK.
gensim- Una robusta libreria di modelli semantici che è utile per molte applicazioni. Può essere installato con il seguente comando:
pip install gensim
pattern - Usato per fare gensimpacchetto funziona correttamente. Può essere installato con il seguente comando:
pip install pattern
Tokenizzazione
Il processo di scomposizione del testo dato, nelle unità più piccole chiamate token, è chiamato tokenizzazione. Questi gettoni possono essere parole, numeri o segni di punteggiatura. È anche chiamatoword segmentation.
Esempio
Il modulo NLTK fornisce diversi pacchetti per la tokenizzazione. Possiamo utilizzare questi pacchetti secondo il nostro requisito. Alcuni dei pacchetti sono descritti qui -
sent_tokenize package- Questo pacchetto dividerà il testo di input in frasi. È possibile utilizzare il seguente comando per importare questo pacchetto:
from nltk.tokenize import sent_tokenize
word_tokenize package- Questo pacchetto dividerà il testo di input in parole. È possibile utilizzare il seguente comando per importare questo pacchetto:
from nltk.tokenize import word_tokenize
WordPunctTokenizer package- Questo pacchetto dividerà il testo di input così come i segni di punteggiatura in parole. È possibile utilizzare il seguente comando per importare questo pacchetto:
from nltk.tokenize import WordPuncttokenizer
Stemming
In qualsiasi lingua, ci sono diverse forme di parole. Una lingua include molte variazioni dovute ai motivi grammaticali. Ad esempio, considera le paroledemocracy, democratic, e democratization. Per i progetti di machine learning così come per i progetti di web scraping, è importante che le macchine comprendano che queste diverse parole hanno la stessa forma di base. Quindi possiamo dire che può essere utile estrarre le forme base delle parole durante l'analisi del testo.
Ciò può essere ottenuto mediante lo stemming che può essere definito come il processo euristico di estrazione delle forme base delle parole tagliando le estremità delle parole.
Il modulo NLTK fornisce diversi pacchetti per lo stemming. Possiamo utilizzare questi pacchetti secondo il nostro requisito. Alcuni di questi pacchetti sono descritti qui:
PorterStemmer package- L'algoritmo di Porter viene utilizzato da questo pacchetto di stemming Python per estrarre il form di base. È possibile utilizzare il seguente comando per importare questo pacchetto:
from nltk.stem.porter import PorterStemmer
Ad esempio, dopo aver dato la parola ‘writing’ come input per questo stemmer, l'output sarebbe la parola ‘write’ dopo lo stemma.
LancasterStemmer package- L'algoritmo di Lancaster viene utilizzato da questo pacchetto di stemming Python per estrarre il form di base. È possibile utilizzare il seguente comando per importare questo pacchetto:
from nltk.stem.lancaster import LancasterStemmer
Ad esempio, dopo aver dato la parola ‘writing’ come input per questo stemmer, l'output sarebbe la parola ‘writ’ dopo lo stemma.
SnowballStemmer package- L'algoritmo di Snowball viene utilizzato da questo pacchetto di stemming Python per estrarre il modulo di base. È possibile utilizzare il seguente comando per importare questo pacchetto:
from nltk.stem.snowball import SnowballStemmer
Ad esempio, dopo aver fornito la parola "scrittura" come input a questo stemmer, l'output sarebbe la parola "write" dopo lo stemmer.
Lemmatizzazione
Un altro modo per estrarre la forma base delle parole è la lemmatizzazione, che normalmente mira a rimuovere le terminazioni flessive utilizzando il vocabolario e l'analisi morfologica. La forma base di qualsiasi parola dopo la lemmatizzazione è chiamata lemma.
Il modulo NLTK fornisce i seguenti pacchetti per la lemmatizzazione:
WordNetLemmatizer package- Estrarrà la forma base della parola a seconda che sia usata come sostantivo come verbo. È possibile utilizzare il seguente comando per importare questo pacchetto:
from nltk.stem import WordNetLemmatizer
Chunking
Il chunking, che significa dividere i dati in piccoli blocchi, è uno dei processi importanti nell'elaborazione del linguaggio naturale per identificare le parti del discorso e le brevi frasi come le frasi nominali. Chunking è fare l'etichettatura dei token. Possiamo ottenere la struttura della frase con l'aiuto del processo di chunking.
Esempio
In questo esempio, implementeremo il chunking Noun-Phrase utilizzando il modulo NLTK Python. Il chunking NP è una categoria di chunking che troverà i frammenti delle frasi nominali nella frase.
Passaggi per implementare la suddivisione in frasi nominali
Dobbiamo seguire i passaggi indicati di seguito per implementare il chunking di frasi nominali -
Passaggio 1: definizione della grammatica del blocco
Nel primo passaggio definiremo la grammatica per il chunking. Consisterà nelle regole che dobbiamo seguire.
Passaggio 2: creazione di un parser di blocchi
Ora creeremo un parser di blocchi. Analizzerebbe la grammatica e darebbe l'output.
Passaggio 3: l'output
In questo ultimo passaggio, l'output sarebbe prodotto in un formato ad albero.
Innanzitutto, dobbiamo importare il pacchetto NLTK come segue:
import nltk
Successivamente, dobbiamo definire la frase. Qui DT: il determinante, VBP: il verbo, JJ: l'aggettivo, IN: la preposizione e NN: il sostantivo.
sentence = [("a", "DT"),("clever","JJ"),("fox","NN"),("was","VBP"),("jumping","VBP"),("over","IN"),("the","DT"),("wall","NN")]
Successivamente, forniamo la grammatica sotto forma di espressione regolare.
grammar = "NP:{<DT>?<JJ>*<NN>}"
Ora, la prossima riga di codice definirà un parser per analizzare la grammatica.
parser_chunking = nltk.RegexpParser(grammar)
Ora, il parser analizzerà la frase.
parser_chunking.parse(sentence)
Successivamente, forniamo il nostro output nella variabile.
Output = parser_chunking.parse(sentence)
Con l'aiuto del seguente codice, possiamo disegnare il nostro output sotto forma di un albero come mostrato di seguito.
output.draw()
Modello Bag of Word (BoW) Estrazione e conversione del testo in forma numerica
Bag of Word (BoW), un modello utile nell'elaborazione del linguaggio naturale, viene fondamentalmente utilizzato per estrarre le caratteristiche dal testo. Dopo aver estratto le caratteristiche dal testo, può essere utilizzato nella modellazione in algoritmi di apprendimento automatico perché i dati grezzi non possono essere utilizzati nelle applicazioni ML.
Funzionamento del modello BoW
Inizialmente, model estrae un vocabolario da tutte le parole nel documento. Successivamente, utilizzando una matrice dei termini del documento, costruirà un modello. In questo modo, il modello BoW rappresenta il documento solo come un sacchetto di parole e l'ordine o la struttura viene scartato.
Esempio
Supponiamo di avere le seguenti due frasi:
Sentence1 - Questo è un esempio del modello Bag of Words.
Sentence2 - Possiamo estrarre le caratteristiche utilizzando il modello Bag of Words.
Ora, considerando queste due frasi, abbiamo le seguenti 14 parole distinte:
- This
- is
- an
- example
- bag
- of
- words
- model
- we
- can
- extract
- features
- by
- using
Costruire un modello di borsa di parole in NLTK
Esaminiamo il seguente script Python che costruirà un modello BoW in NLTK.
Innanzitutto, importa il seguente pacchetto:
from sklearn.feature_extraction.text import CountVectorizer
Quindi, definisci il set di frasi -
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_)
Produzione
Mostra che abbiamo 14 parole distinte nelle due frasi precedenti:
{
'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
}
Topic Modeling: identificazione di pattern nei dati di testo
Generalmente i documenti sono raggruppati in argomenti e la modellazione di argomenti è una tecnica per identificare i modelli in un testo che corrisponde a un particolare argomento. In altre parole, la modellazione degli argomenti viene utilizzata per scoprire temi astratti o strutture nascoste in un dato insieme di documenti.
È possibile utilizzare la modellazione degli argomenti nei seguenti scenari:
Classificazione del testo
La classificazione può essere migliorata mediante la modellazione dell'argomento perché raggruppa parole simili insieme piuttosto che utilizzare ciascuna parola separatamente come caratteristica.
Sistemi di raccomandazione
Possiamo costruire sistemi di raccomandazione utilizzando misure di somiglianza.
Topic Modeling Algoritmi
Possiamo implementare la modellazione degli argomenti utilizzando i seguenti algoritmi:
Latent Dirichlet Allocation(LDA) - È uno degli algoritmi più popolari che utilizza i modelli grafici probabilistici per l'implementazione della modellazione degli argomenti.
Latent Semantic Analysis(LDA) or Latent Semantic Indexing(LSI) - Si basa sull'algebra lineare e utilizza il concetto di SVD (Singular Value Decomposition) sulla matrice dei termini del documento.
Non-Negative Matrix Factorization (NMF) - Si basa anche sull'algebra lineare come LDA.
Gli algoritmi sopra menzionati avrebbero i seguenti elementi:
- Numero di argomenti: parametro
- Matrice documento-parola: input
- WTM (Word Topic Matrix) e TDM (Topic Document Matrix): output
introduzione
Il web scraping è un compito complesso e la complessità si moltiplica se il sito web è dinamico. Secondo il Global Audit of Web Accessibility delle Nazioni Unite, più del 70% dei siti web sono di natura dinamica e si affidano a JavaScript per le loro funzionalità.
Esempio di sito web dinamico
Diamo un'occhiata a un esempio di un sito Web dinamico e sappiamo perché è difficile da raschiare. Qui prenderemo un esempio di ricerca da un sito web denominatohttp://example.webscraping.com/places/default/search.Ma come possiamo dire che questo sito web sia di natura dinamica? Può essere giudicato dall'output del seguente script Python che proverà a raschiare i dati dalla pagina web sopra menzionata -
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)
Produzione
[ ]
L'output precedente mostra che lo scraper di esempio non è riuscito a estrarre le informazioni perché l'elemento <div> che stiamo cercando di trovare è vuoto.
Approcci per lo scraping dei dati da siti Web dinamici
Abbiamo visto che il raschietto non può raschiare le informazioni da un sito web dinamico perché i dati vengono caricati dinamicamente con JavaScript. In questi casi, possiamo utilizzare le seguenti due tecniche per estrarre dati da siti Web dinamici dipendenti da JavaScript:
- JavaScript di ingegneria inversa
- Rendering JavaScript
JavaScript di ingegneria inversa
Il processo chiamato reverse engineering sarebbe utile e ci permette di capire come i dati vengono caricati dinamicamente dalle pagine web.
Per fare ciò, dobbiamo fare clic su inspect elementscheda per un URL specificato. Successivamente, faremo clic suNETWORK scheda per trovare tutte le richieste fatte per quella pagina web incluso search.json con un percorso di /ajax. Invece di accedere ai dati AJAX dal browser o tramite la scheda RETE, possiamo farlo anche con l'aiuto del seguente script Python -
import requests
url=requests.get('http://example.webscraping.com/ajax/search.json?page=0&page_size=10&search_term=a')
url.json()
Esempio
Lo script sopra ci consente di accedere alla risposta JSON utilizzando il metodo JSON di Python. Allo stesso modo possiamo scaricare la risposta della stringa grezza e usando il metodo json.loads di Python, possiamo anche caricarla. Lo stiamo facendo con l'aiuto del seguente script Python. Fondamentalmente rascherà tutti i paesi cercando la lettera dell'alfabeto "a" e quindi iterando le pagine risultanti delle risposte 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)))
Dopo aver eseguito lo script precedente, otterremo il seguente output e i record verranno salvati nel file denominato countries.txt.
Produzione
Searching with a
adding 15 records from the page 0
adding 15 records from the page 1
...
Rendering JavaScript
Nella sezione precedente, abbiamo eseguito il reverse engineering sulla pagina web di come funzionava l'API e come possiamo usarla per recuperare i risultati in una singola richiesta. Tuttavia, possiamo affrontare le seguenti difficoltà durante il reverse engineering:
A volte i siti web possono essere molto difficili. Ad esempio, se il sito Web è realizzato con uno strumento browser avanzato come Google Web Toolkit (GWT), il codice JS risultante sarebbe generato dalla macchina e difficile da comprendere e da decodificare.
Alcuni framework di livello superiore come React.js può rendere difficile il reverse engineering astrando la logica JavaScript già complessa.
La soluzione alle difficoltà di cui sopra è utilizzare un motore di rendering del browser che analizza l'HTML, applica la formattazione CSS ed esegue JavaScript per visualizzare una pagina web.
Esempio
In questo esempio, per il rendering di Java Script useremo un noto modulo Python Selenium. Il seguente codice Python renderà una pagina web con l'aiuto di Selenium -
Innanzitutto, dobbiamo importare il webdriver dal selenio come segue:
from selenium import webdriver
Ora, fornisci il percorso del driver web che abbiamo scaricato secondo il nostro requisito -
path = r'C:\\Users\\gaurav\\Desktop\\Chromedriver'
driver = webdriver.Chrome(executable_path = path)
Ora, fornisci l'URL che vogliamo aprire in quel browser web ora controllato dal nostro script Python.
driver.get('http://example.webscraping.com/search')
Ora possiamo utilizzare l'ID della casella degli strumenti di ricerca per impostare l'elemento da selezionare.
driver.find_element_by_id('search_term').send_keys('.')
Successivamente, possiamo usare java script per impostare il contenuto della casella di selezione come segue:
js = "document.getElementById('page_size').options[1].text = '100';"
driver.execute_script(js)
La seguente riga di codice mostra che la ricerca è pronta per essere cliccata sulla pagina web -
driver.find_element_by_id('search').click()
La riga di codice successiva mostra che attenderà 45 secondi per completare la richiesta AJAX.
driver.implicitly_wait(45)
Ora, per selezionare i collegamenti nazionali, possiamo utilizzare il selettore CSS come segue:
links = driver.find_elements_by_css_selector('#results a')
Ora il testo di ogni collegamento può essere estratto per creare l'elenco dei paesi -
countries = [link.text for link in links]
print(countries)
driver.close()
Nel capitolo precedente, abbiamo visto raschiare siti Web dinamici. In questo capitolo, comprendiamo lo scraping di siti Web che funzionano su input basati sull'utente, ovvero siti Web basati su form.
introduzione
In questi giorni il WWW (World Wide Web) si sta muovendo verso i social media così come i contenuti generati dagli utenti. Quindi sorge la domanda su come possiamo accedere a questo tipo di informazioni che sono oltre la schermata di accesso? Per questo dobbiamo occuparci di moduli e accessi.
Nei capitoli precedenti, abbiamo lavorato con il metodo HTTP GET per richiedere informazioni, ma in questo capitolo lavoreremo con il metodo HTTP POST che invia le informazioni a un server web per l'archiviazione e l'analisi.
Interagire con i moduli di accesso
Mentre lavori su Internet, devi aver interagito molte volte con i moduli di accesso. Possono essere molto semplici come includere solo pochissimi campi HTML, un pulsante di invio e una pagina di azione oppure possono essere complicati e avere alcuni campi aggiuntivi come e-mail, lasciare un messaggio insieme a captcha per motivi di sicurezza.
In questa sezione, ci occuperemo di un semplice modulo di invio con l'aiuto della libreria di richieste Python.
Innanzitutto, dobbiamo importare la libreria delle richieste come segue:
import requests
Ora, dobbiamo fornire le informazioni per i campi del modulo di accesso.
parameters = {‘Name’:’Enter your name’, ‘Email-id’:’Your Emailid’,’Message’:’Type your message here’}
Nella riga di codice successiva, dobbiamo fornire l'URL su cui avverrebbe l'azione del modulo.
r = requests.post(“enter the URL”, data = parameters)
print(r.text)
Dopo aver eseguito lo script, restituirà il contenuto della pagina in cui è avvenuta l'azione.
Supponi di voler inviare qualsiasi immagine con il modulo, allora è molto semplice con richieste.post (). Puoi capirlo con l'aiuto del seguente script Python -
import requests
file = {‘Uploadfile’: open(’C:\Usres\desktop\123.png’,‘rb’)}
r = requests.post(“enter the URL”, files = file)
print(r.text)
Caricamento dei cookie dal server Web
Un cookie, a volte chiamato cookie web o cookie internet, è una piccola porzione di dati inviati da un sito web e il nostro computer lo memorizza in un file situato all'interno del nostro browser web.
Nell'ambito della gestione dei moduli di login, i cookie possono essere di due tipi. Uno, abbiamo trattato nella sezione precedente, che ci consente di inviare informazioni a un sito Web e il secondo che ci consente di rimanere in uno stato di "accesso" permanente durante la nostra visita al sito Web. Per il secondo tipo di moduli, i siti web utilizzano i cookie per tenere traccia di chi è loggato e chi no.
Cosa fanno i cookies?
Oggigiorno la maggior parte dei siti web utilizza i cookie per il monitoraggio. Possiamo capire il funzionamento dei cookie con l'aiuto dei seguenti passaggi:
Step 1- Innanzitutto, il sito autenticherà le nostre credenziali di accesso e le memorizzerà nel cookie del nostro browser. Questo cookie generalmente contiene un toke generato dal server, un timeout e informazioni di tracciamento.
Step 2- Successivamente, il sito Web utilizzerà il cookie come prova di autenticazione. Questa autenticazione viene sempre mostrata ogni volta che visitiamo il sito web.
I cookie sono molto problematici per i web scrapers perché se i web scrapers non tengono traccia dei cookie, il modulo inviato viene rispedito e alla pagina successiva sembra che non abbiano mai effettuato l'accesso. È molto facile tenere traccia dei cookie con l'aiuto di Pitone requests libreria, come mostrato di seguito -
import requests
parameters = {‘Name’:’Enter your name’, ‘Email-id’:’Your Emailid’,’Message’:’Type your message here’}
r = requests.post(“enter the URL”, data = parameters)
Nella riga di codice sopra, l'URL sarebbe la pagina che fungerà da processore per il modulo di accesso.
print(‘The cookie is:’)
print(r.cookies.get_dict())
print(r.text)
Dopo aver eseguito lo script precedente, recupereremo i cookie dal risultato dell'ultima richiesta.
C'è un altro problema con i cookie che a volte i siti web modificano frequentemente i cookie senza preavviso. Questo tipo di situazione può essere affrontatarequests.Session() come segue -
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)
Nella riga di codice sopra, l'URL sarebbe la pagina che fungerà da processore per il modulo di accesso.
print(‘The cookie is:’)
print(r.cookies.get_dict())
print(r.text)
Osserva che puoi facilmente capire la differenza tra script con sessione e senza sessione.
Automatizzare i moduli con Python
In questa sezione ci occuperemo di un modulo Python chiamato Mechanize che ridurrà il nostro lavoro e automatizzerà il processo di compilazione dei moduli.
Modulo Mechanize
Il modulo Mechanize ci fornisce un'interfaccia di alto livello per interagire con i moduli. Prima di iniziare ad usarlo dobbiamo installarlo con il seguente comando:
pip install mechanize
Nota che funzionerebbe solo in Python 2.x.
Esempio
In questo esempio, automatizzeremo il processo di compilazione di un modulo di accesso con due campi: email e password:
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()
Il codice sopra è molto facile da capire. Innanzitutto, abbiamo importato il modulo di meccanizzazione. Quindi è stato creato un oggetto browser Mechanize. Quindi, siamo passati all'URL di accesso e abbiamo selezionato il modulo. Successivamente, nomi e valori vengono passati direttamente all'oggetto browser.
In questo capitolo, cerchiamo di capire come eseguire il web scraping e l'elaborazione CAPTCHA che viene utilizzato per testare un utente per essere umano o robot.
Cos'è il CAPTCHA?
La forma completa di CAPTCHA è Completely Automated Public Turing test to tell Computers and Humans Apart, il che suggerisce chiaramente che si tratta di un test per determinare se l'utente è umano o meno.
Un CAPTCHA è un'immagine distorta che di solito non è facile da rilevare con un programma per computer, ma un essere umano può in qualche modo riuscire a capirla. La maggior parte dei siti Web utilizza CAPTCHA per impedire l'interazione dei bot.
Caricamento di CAPTCHA con Python
Supponiamo di voler fare la registrazione su un sito web e ci sia un modulo con CAPTCHA, quindi prima di caricare l'immagine CAPTCHA dobbiamo conoscere le informazioni specifiche richieste dal modulo. Con l'aiuto del prossimo script Python possiamo capire i requisiti del modulo del modulo di registrazione sul sito web denominatohttp://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)
Nello script Python sopra, prima abbiamo definito una funzione che analizzerà il modulo utilizzando il modulo python lxml e quindi stamperà i requisiti del modulo come segue:
{
'_formkey': '5e306d73-5774-4146-a94e-3541f22c95ab',
'_formname': 'register',
'_next': '/places/default/index',
'email': '',
'first_name': '',
'last_name': '',
'password': '',
'password_two': '',
'recaptcha_response_field': None
}
È possibile controllare dall'output sopra che tutte le informazioni tranne recpatcha_response_fieldsono comprensibili e semplici. Ora sorge la domanda su come possiamo gestire queste informazioni complesse e scaricare CAPTCHA. Può essere fatto con l'aiuto della libreria pillow Python come segue;
Pacchetto Pillow Python
Pillow è un fork della libreria Python Image con funzioni utili per manipolare le immagini. Può essere installato con l'aiuto del seguente comando:
pip install pillow
Nel prossimo esempio lo useremo per caricare il 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
Lo script python sopra sta usando pillowpacchetto python e definizione di una funzione per il caricamento dell'immagine CAPTCHA. Deve essere utilizzato con la funzione denominataform_parser()definito nello script precedente per ottenere informazioni sul modulo di registrazione. Questo script salverà l'immagine CAPTCHA in un formato utile che può essere ulteriormente estratto come stringa.
OCR: estrazione di testo dall'immagine utilizzando Python
Dopo aver caricato il CAPTCHA in un formato utile, possiamo estrarlo con l'aiuto di Optical Character Recognition (OCR), un processo di estrazione del testo dalle immagini. A tale scopo, utilizzeremo il motore OCR Tesseract open source. Può essere installato con l'aiuto del seguente comando:
pip install pytesseract
Esempio
Qui estenderemo lo script Python sopra, che ha caricato il CAPTCHA utilizzando il pacchetto Pillow Python, come segue:
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')
Lo script Python sopra leggerà il CAPTCHA in modalità bianco e nero che sarebbe chiaro e facile da passare a tesseract come segue:
pytesseract.image_to_string(bw)
Dopo aver eseguito lo script sopra, otterremo il CAPTCHA del modulo di registrazione come output.
Questo capitolo spiega come eseguire test utilizzando web scrapers in Python.
introduzione
Nei grandi progetti web, il test automatizzato del backend del sito web viene eseguito regolarmente, ma il test del frontend viene spesso saltato. Il motivo principale alla base di ciò è che la programmazione dei siti Web è proprio come una rete di vari markup e linguaggi di programmazione. Possiamo scrivere un test unitario per una lingua, ma diventa difficile se l'interazione viene eseguita in un'altra lingua. Questo è il motivo per cui dobbiamo disporre di una suite di test per assicurarci che il nostro codice funzioni secondo le nostre aspettative.
Testare usando Python
Quando parliamo di test, significa test unitario. Prima di immergerci in profondità nei test con Python, dobbiamo conoscere i test unitari. Di seguito sono riportate alcune delle caratteristiche dei test unitari:
Almeno un aspetto della funzionalità di un componente verrebbe testato in ogni unit test.
Ogni unit test è indipendente e può anche essere eseguito indipendentemente.
Il test unitario non interferisce con il successo o il fallimento di qualsiasi altro test.
Gli unit test possono essere eseguiti in qualsiasi ordine e devono contenere almeno un'asserzione.
Unittest - Modulo Python
Il modulo Python chiamato Unittest per unit test viene fornito con tutta l'installazione standard di Python. Dobbiamo solo importarlo e il resto è compito della classe unittest.TestCase che farà quanto segue:
Le funzioni SetUp e tearDown sono fornite dalla classe unittest.TestCase. Queste funzioni possono essere eseguite prima e dopo ogni unit test.
Fornisce inoltre istruzioni di asserzione per consentire il superamento o il fallimento dei test.
Esegue tutte le funzioni che iniziano con test_ come test unitario.
Esempio
In questo esempio combineremo il web scraping con unittest. Testeremo la pagina di Wikipedia per la ricerca della stringa "Python". Fondamentalmente farà due test, primo se la pagina del titolo è uguale alla stringa di ricerca, cioè "Python" o meno, e il secondo test si assicura che la pagina abbia un div di contenuto.
Per prima cosa, importeremo i moduli Python richiesti. Stiamo usando BeautifulSoup per il web scraping e ovviamente unittest per i test.
from urllib.request import urlopen
from bs4 import BeautifulSoup
import unittest
Ora dobbiamo definire una classe che estenderà unittest.TestCase. Gli oggetti globali bs sarebbero condivisi tra tutti i test. Una funzione specificata unittest setUpClass lo realizzerà. Qui definiremo due funzioni, una per testare il frontespizio e l'altra per testare il contenuto della pagina.
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()
Dopo aver eseguito lo script precedente, otterremo il seguente output:
----------------------------------------------------------------------
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 con selenio
Parliamo di come utilizzare Python Selenium per i test. È anche chiamato test del selenio. Entrambi Pythonunittest e Seleniumnon hanno molto in comune. Sappiamo che Selenium invia i comandi standard Python a diversi browser, nonostante la variazione nel design del loro browser. Ricordiamo che abbiamo già installato e lavorato con Selenium nei capitoli precedenti. Qui creeremo script di test in Selenium e lo useremo per l'automazione.
Esempio
Con l'aiuto del prossimo script Python, stiamo creando uno script di test per l'automazione della pagina di accesso di Facebook. Puoi modificare l'esempio per automatizzare altri moduli e accessi a tua scelta, tuttavia il concetto sarebbe lo stesso.
Primo per la connessione al browser web, importeremo il webdriver dal modulo selenio -
from selenium import webdriver
Ora, dobbiamo importare le chiavi dal modulo selenio.
from selenium.webdriver.common.keys import Keys
Successivamente dobbiamo fornire nome utente e password per accedere al nostro account Facebook
user = "[email protected]"
pwd = ""
Quindi, fornisci il percorso del driver web per Chrome.
path = r'C:\\Users\\gaurav\\Desktop\\Chromedriver'
driver = webdriver.Chrome(executable_path=path)
driver.get("http://www.facebook.com")
Ora verificheremo le condizioni utilizzando assert keyword.
assert "Facebook" in driver.title
Con l'aiuto della seguente riga di codice stiamo inviando i valori alla sezione email. Qui lo stiamo cercando per il suo ID ma possiamo farlo cercandolo per nome comedriver.find_element_by_name("email").
element = driver.find_element_by_id("email")
element.send_keys(user)
Con l'aiuto della seguente riga di codice stiamo inviando i valori alla sezione password. Qui lo stiamo cercando per il suo ID ma possiamo farlo cercandolo per nome comedriver.find_element_by_name("pass").
element = driver.find_element_by_id("pass")
element.send_keys(pwd)
La riga di codice successiva viene utilizzata per premere invio / login dopo aver inserito i valori nel campo e-mail e password.
element.send_keys(Keys.RETURN)
Adesso chiuderemo il browser.
driver.close()
Dopo aver eseguito lo script precedente, il browser web Chrome verrà aperto e potrai vedere che email e password vengono inserite e fare clic sul pulsante di accesso.
Confronto: unittest o selenio
Il confronto tra unittest e selenio è difficile perché se si desidera lavorare con grandi suite di test, è necessaria la rigidità sintattica delle unità. D'altra parte, se hai intenzione di testare la flessibilità del sito web, il test del selenio sarebbe la nostra prima scelta. Ma cosa succede se possiamo combinare entrambi? Possiamo importare il selenio in Python unittest e ottenere il meglio da entrambi. Il selenio può essere utilizzato per ottenere informazioni su un sito Web e unittest può valutare se tali informazioni soddisfano o meno i criteri per superare il test.
Ad esempio, stiamo riscrivendo lo script Python sopra per l'automazione dell'accesso a Facebook combinando entrambi come segue:
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()