Przeglądanie sieci w Pythonie - szybki przewodnik

Skrobanie sieci to automatyczny proces wyodrębniania informacji z sieci. Ten rozdział zawiera szczegółowe informacje na temat skrobania sieci, jego porównania z indeksowaniem sieci oraz powodów, dla których warto wybrać tę metodę. Dowiesz się również o elementach i działaniu skrobaka do wstęgi.

Co to jest przeglądanie sieci?

Słownikowe znaczenie słowa „złomowanie” oznacza pobieranie czegoś z sieci. Powstają tutaj dwa pytania: co możemy uzyskać z sieci i jak to osiągnąć.

Odpowiedź na pierwsze pytanie brzmi ‘data’. Dane są niezbędne dla każdego programisty, a podstawowym wymaganiem każdego projektu programistycznego jest duża ilość użytecznych danych.

Odpowiedź na drugie pytanie jest nieco trudna, ponieważ istnieje wiele sposobów uzyskiwania danych. Ogólnie możemy uzyskać dane z bazy danych lub pliku danych i innych źródeł. Ale co, jeśli potrzebujemy dużej ilości danych dostępnych online? Jednym ze sposobów uzyskania takich danych jest ręczne wyszukiwanie (kliknięcie w przeglądarce internetowej) i zapisanie (skopiowanie i wklejenie do arkusza kalkulacyjnego lub pliku) wymaganych danych. Ta metoda jest dość żmudna i czasochłonna. Innym sposobem uzyskania takich danych jest użycieweb scraping.

Web scraping, nazywany również web data mining lub web harvesting, to proces tworzenia agenta, który może automatycznie wyodrębniać, analizować, pobierać i organizować przydatne informacje z sieci. Innymi słowy, możemy powiedzieć, że zamiast ręcznie zapisywać dane ze stron internetowych, oprogramowanie do skrobania stron internetowych automatycznie ładuje i wyodrębnia dane z wielu witryn internetowych zgodnie z naszymi wymaganiami.

Pochodzenie skrobania sieci

Źródłem skrobania stron internetowych jest zrzut ekranu, który był używany do integracji aplikacji innych niż internetowe lub natywnych aplikacji systemu Windows. Pierwotnie skrobanie ekranów było używane przed szerokim użyciem World Wide Web (WWW), ale nie mogło skalować w górę rozszerzonego WWW. To spowodowało konieczność zautomatyzowania podejścia do skrobania ekranu i techniki tzw‘Web Scraping’ powstała.

Indeksowanie sieci a przeszukiwanie sieci

Pojęcia „indeksowanie sieci i pobieranie danych” są często używane zamiennie, ponieważ ich podstawową koncepcją jest wyodrębnianie danych. Jednak różnią się od siebie. Możemy zrozumieć podstawową różnicę w ich definicjach.

Przeszukiwanie sieci jest zasadniczo używane do indeksowania informacji na stronie za pomocą botów zwanych przeszukiwaczami. Nazywa się to równieżindexing. Z drugiej strony, skrobanie sieci to zautomatyzowany sposób wydobywania informacji za pomocą botów zwanych skrobakami. Nazywa się to równieżdata extraction.

Aby zrozumieć różnicę między tymi dwoma terminami, spójrzmy na tabelę porównawczą podaną poniżej -

Indeksowanie sieci	Skrobanie sieci
Odnosi się do pobierania i przechowywania zawartości dużej liczby witryn internetowych.	Odnosi się do wyodrębniania poszczególnych elementów danych ze strony internetowej przy użyciu struktury specyficznej dla witryny.
Przeważnie wykonywane na dużą skalę.	Może być wdrożony w dowolnej skali.
Dostarcza ogólnych informacji.	Podaje konkretne informacje.
Używany przez główne wyszukiwarki, takie jak Google, Bing, Yahoo. Googlebot to przykład robota indeksującego.	Informacje wyodrębnione za pomocą skrobania sieci można wykorzystać do powielenia w innej witrynie internetowej lub do przeprowadzenia analizy danych. Na przykład elementami danych mogą być nazwy, adres, cena itp.

Zastosowania skrobania sieci

Zastosowania i powody korzystania ze skrobania sieci są tak samo nieograniczone, jak zastosowania sieci WWW. Skrobaki internetowe mogą robić wszystko, na przykład zamawiać jedzenie online, skanować witrynę zakupów online i kupować bilety na mecz, gdy tylko są dostępne itp., Tak jak może to zrobić człowiek. Omówiono tutaj niektóre z ważnych zastosowań skrobania sieci -

E-commerce Websites - Skrobaki internetowe mogą zbierać dane dotyczące ceny konkretnego produktu z różnych witryn e-commerce w celu ich porównania.
Content Aggregators - Skrobanie sieci jest szeroko stosowane przez agregatory treści, takie jak agregatory wiadomości i agregatory ofert pracy, do dostarczania zaktualizowanych danych swoim użytkownikom.
Marketing and Sales Campaigns - Skrobaki internetowe mogą być używane do pobierania danych, takich jak e-maile, numer telefonu itp. Na potrzeby kampanii sprzedażowych i marketingowych.
Search Engine Optimization (SEO) - Skrobanie stron internetowych jest szeroko stosowane przez narzędzia SEO, takie jak SEMRush, Majestic itp., Aby poinformować firmy, jak pozycjonują się w wyszukiwanych słowach kluczowych, które są dla nich ważne.
Data for Machine Learning Projects - Pobieranie danych do projektów uczenia maszynowego zależy od skrobania sieci.

Data for Research - Naukowcy mogą gromadzić przydatne dane do celów swoich prac badawczych, oszczędzając czas dzięki temu zautomatyzowanemu procesowi.

Składniki skrobaka internetowego

Skrobak do wstęgi składa się z następujących elementów -

Moduł robota indeksującego

Bardzo niezbędny składnik skrobaczki sieciowej, moduł robota indeksującego, służy do nawigacji po witrynie docelowej poprzez wysyłanie żądań HTTP lub HTTPS do adresów URL. Przeszukiwacz pobiera nieustrukturyzowane dane (zawartość HTML) i przekazuje je do ekstraktora, następnego modułu.

Ekstraktor

Ekstraktor przetwarza pobraną zawartość HTML i wyodrębnia dane do półstrukturalnego formatu. Jest to również nazywane modułem parsera i wykorzystuje różne techniki parsowania, takie jak wyrażenie regularne, analiza HTML, analizowanie DOM lub sztuczna inteligencja.

Moduł Transformacji i Czyszczenia Danych

Dane wyodrębnione powyżej nie nadają się do użycia. Musi przejść przez jakiś moduł czyszczący, żebyśmy mogli z niego skorzystać. W tym celu można użyć metod, takich jak manipulacja ciągami znaków lub wyrażenie regularne. Należy pamiętać, że ekstrakcję i transformację można również przeprowadzić w jednym kroku.

Moduł pamięci

Po wyodrębnieniu danych musimy je przechowywać zgodnie z naszymi wymaganiami. Moduł pamięci wyprowadza dane w standardowym formacie, który można przechowywać w bazie danych lub w formacie JSON lub CSV.

Działanie skrobaka internetowego

Skrobak sieciowy można zdefiniować jako oprogramowanie lub skrypt używany do pobierania zawartości wielu stron internetowych i wyodrębniania z nich danych.

Możemy zrozumieć działanie skrobaka w prostych krokach, jak pokazano na powyższym schemacie.

Krok 1: Pobieranie treści ze stron internetowych

Na tym etapie skrobak sieciowy pobierze żądaną zawartość z wielu stron internetowych.

Krok 2: Wyodrębnianie danych

Dane na stronach internetowych to HTML i przeważnie nieustrukturyzowane. W związku z tym na tym etapie skrobak sieciowy przeanalizuje i wyodrębni ustrukturyzowane dane z pobranych treści.

Krok 3: Przechowywanie danych

Tutaj skrobak sieciowy będzie przechowywać i zapisywać wyodrębnione dane w dowolnym formacie, takim jak CSV, JSON lub w bazie danych.

Krok 4: Analiza danych

Po pomyślnym wykonaniu wszystkich tych kroków skrobak sieci przeanalizuje uzyskane w ten sposób dane.

W pierwszym rozdziale dowiedzieliśmy się, na czym polega skrobanie sieci. W tym rozdziale zobaczmy, jak zaimplementować skrobanie sieci przy użyciu Pythona.

Dlaczego Python do przeglądania sieci?

Python to popularne narzędzie do implementacji skrobania sieci. Język programowania Python jest również używany w innych przydatnych projektach związanych z cyberbezpieczeństwem, testami penetracyjnymi, a także aplikacjami do kryminalistyki cyfrowej. Korzystając z podstawowego programowania Pythona, skrobanie stron internetowych można wykonywać bez użycia innych narzędzi innych firm.

Język programowania Python zyskuje ogromną popularność, a powody, dla których Python dobrze sprawdza się w projektach skrobania stron internetowych, są następujące:

Prostota składni

Python ma najprostszą strukturę w porównaniu z innymi językami programowania. Ta funkcja języka Python ułatwia testowanie, a programista może bardziej skupić się na programowaniu.

Wbudowane moduły

Innym powodem używania Pythona do skrobania stron internetowych są wbudowane, a także zewnętrzne przydatne biblioteki, które posiada. Możemy wykonać wiele implementacji związanych z web scrapingiem wykorzystując Python jako podstawę programowania.

Język programowania Open Source

Python ma ogromne wsparcie społeczności, ponieważ jest językiem programowania typu open source.

Szeroki zakres zastosowań

Python może być używany do różnych zadań programistycznych, od małych skryptów powłoki po aplikacje internetowe dla przedsiębiorstw.

Instalacja Pythona

Dystrybucja Pythona jest dostępna na platformy takie jak Windows, MAC i Unix / Linux. Aby zainstalować Pythona, musimy pobrać tylko kod binarny odpowiedni dla naszej platformy. Ale w przypadku, gdy kod binarny dla naszej platformy nie jest dostępny, musimy mieć kompilator C, aby kod źródłowy mógł być skompilowany ręcznie.

Możemy zainstalować Pythona na różnych platformach w następujący sposób -

Instalowanie Pythona w systemach Unix i Linux

Musisz wykonać poniższe kroki, aby zainstalować Python na komputerach z systemem Unix / Linux -

Step 1 - Przejdź do linku https://www.python.org/downloads/

Step 2 - Pobierz spakowany kod źródłowy dostępny dla systemów Unix / Linux na powyższy link.

Step 3 - Wypakuj pliki na swój komputer.

Step 4 - Użyj następujących poleceń, aby zakończyć instalację -

run ./configure script
make
make install

Możesz znaleźć zainstalowany Python w standardowej lokalizacji /usr/local/bin i jego biblioteki pod adresem /usr/local/lib/pythonXX, gdzie XX to wersja Pythona.

Instalowanie Pythona w systemie Windows

Musisz wykonać poniższe czynności, aby zainstalować Python na komputerach z systemem Windows -

Step 1 - Przejdź do linku https://www.python.org/downloads/

Step 2 - Pobierz instalator Windows python-XYZ.msi plik, gdzie XYZ to wersja, którą musimy zainstalować.

Step 3 - Teraz zapisz plik instalatora na komputerze lokalnym i uruchom plik MSI.

Step 4 - Na koniec uruchom pobrany plik, aby wywołać kreatora instalacji Pythona.

Instalowanie Pythona na Macintoshu

Musimy użyć Homebrew do instalacji Pythona 3 w systemie Mac OS X. Homebrew jest łatwy w instalacji i jest świetnym instalatorem pakietów.

Homebrew można również zainstalować za pomocą następującego polecenia -

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

Aby zaktualizować menedżera pakietów, możemy użyć następującego polecenia -

$ brew update

Za pomocą następującego polecenia możemy zainstalować Python3 na naszej maszynie MAC -

$ brew install python3

Konfigurowanie ŚCIEŻKI

Możesz skorzystać z następujących instrukcji, aby skonfigurować ścieżkę w różnych środowiskach -

Konfigurowanie ścieżki w systemie Unix / Linux

Użyj następujących poleceń do konfigurowania ścieżek za pomocą różnych powłok poleceń -

Dla powłoki csh

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

Dla powłoki bash (Linux)

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

Dla powłoki sh lub ksh

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

Konfigurowanie ścieżki w systemie Windows

Aby ustawić ścieżkę w systemie Windows, możemy użyć ścieżki %path%;C:\Python w wierszu polecenia, a następnie naciśnij klawisz Enter.

Uruchamianie Pythona

Możemy uruchomić Pythona na jeden z trzech następujących sposobów -

Interaktywny tłumacz

Do uruchamiania języka Python można użyć systemu operacyjnego, takiego jak UNIX i DOS, który udostępnia interpreter lub powłokę wiersza poleceń.

Możemy rozpocząć kodowanie w interaktywnym tłumaczu w następujący sposób -

Step 1 - Wejdź python w wierszu poleceń.

Step 2 - Wtedy możemy od razu rozpocząć kodowanie w interaktywnym tłumaczu.

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

Skrypt z wiersza poleceń

Możemy wykonać skrypt Pythona z wiersza poleceń, wywołując interpreter. Można to rozumieć następująco:

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

Zintegrowane środowisko programistyczne

Możemy również uruchomić Pythona ze środowiska GUI, jeśli system ma aplikację GUI obsługującą Python. Niektóre środowiska IDE obsługujące Python na różnych platformach podano poniżej -

IDE for UNIX - UNIX dla Pythona ma IDLE IDE.

IDE for Windows - Windows ma PythonWin IDE, które ma również GUI.

IDE for Macintosh - Macintosh ma IDLE IDE, które można pobrać jako pliki MacBinary lub BinHex z głównej strony internetowej.

W tym rozdziale poznajmy różne moduły Pythona, których możemy użyć do skrobania stron internetowych.

Środowiska programistyczne Python korzystające z virtualenv

Virtualenv to narzędzie do tworzenia izolowanych środowisk Python. Z pomocą virtualenv możemy stworzyć folder zawierający wszystkie pliki wykonywalne niezbędne do korzystania z pakietów, których wymaga nasz projekt w Pythonie. Pozwala nam także dodawać i modyfikować moduły Pythona bez dostępu do instalacji globalnej.

Możesz użyć następującego polecenia, aby zainstalować 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

Teraz musimy stworzyć katalog, który będzie reprezentował projekt za pomocą następującego polecenia -

(base) D:\ProgramData>mkdir webscrap

Teraz wejdź do tego katalogu za pomocą następującego polecenia -

(base) D:\ProgramData>cd webscrap

Teraz musimy zainicjować wybrany przez nas folder środowiska wirtualnego w następujący sposób -

(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.

Teraz aktywuj środowisko wirtualne poleceniem podanym poniżej. Po pomyślnej aktywacji zobaczysz jego nazwę po lewej stronie w nawiasach.

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

Możemy zainstalować dowolny moduł w tym środowisku w następujący sposób -

(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

Do dezaktywacji środowiska wirtualnego możemy użyć następującego polecenia -

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

Jak widać, usługa (websc) została dezaktywowana.

Moduły Pythona do przeglądania sieci

Web scraping to proces konstruowania agenta, który może automatycznie wyodrębniać, analizować, pobierać i organizować użyteczne informacje z sieci. Innymi słowy, zamiast ręcznie zapisywać dane ze stron internetowych, oprogramowanie do skrobania stron internetowych automatycznie ładuje i wyodrębnia dane z wielu witryn internetowych zgodnie z naszymi wymaganiami.

W tej sekcji omówimy przydatne biblioteki Pythona do skrobania stron internetowych.

Upraszanie

Jest to prosta biblioteka do skrobania sieci w języku Python. Jest to wydajna biblioteka HTTP używana do uzyskiwania dostępu do stron internetowych. Z pomocąRequests, możemy uzyskać nieprzetworzony kod HTML stron internetowych, który można następnie przeanalizować w celu pobrania danych. Przed użyciemrequests, zrozummy jego instalację.

Instalowanie żądań

Możemy go zainstalować w naszym środowisku wirtualnym lub w instalacji globalnej. Z pomocąpip polecenie, możemy go łatwo zainstalować w następujący sposób -

(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

Przykład

W tym przykładzie wykonujemy żądanie GET HTTP dla strony internetowej. W tym celu musimy najpierw zaimportować bibliotekę żądań w następujący sposób -

In [1]: import requests

W poniższym wierszu kodu używamy żądań do wykonania żądań HTTP GET dla adresu URL: https://authoraditiagarwal.com/ wykonując żądanie GET.

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

Teraz możemy pobrać zawartość za pomocą .text właściwość w następujący sposób -

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

Zauważ, że na poniższym wyjściu otrzymaliśmy pierwsze 200 znaków.

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

Jest to kolejna biblioteka Pythona, której można użyć do pobierania danych z adresów URL podobnych do requestsbiblioteka. Możesz przeczytać więcej na ten temat w dokumentacji technicznej pod adresemhttps://urllib3.readthedocs.io/en/latest/.

Instalowanie Urllib3

Używając pip polecenie, możemy zainstalować urllib3 w naszym środowisku wirtualnym lub w instalacji globalnej.

(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

Przykład: skrobanie przy użyciu Urllib3 i BeautifulSoup

W poniższym przykładzie zdrapujemy stronę internetową przy użyciu Urllib3 i BeautifulSoup. UżywamyUrllib3w miejscu żądań biblioteka do pobrania surowych danych (HTML) ze strony WWW. Następnie używamyBeautifulSoup do analizowania tych danych 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)

Oto dane wyjściowe, które zobaczysz po uruchomieniu tego kodu -

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

Selen

Jest to zautomatyzowany pakiet testowy typu open source dla aplikacji internetowych w różnych przeglądarkach i platformach. To nie jest pojedyncze narzędzie, ale pakiet oprogramowania. Mamy powiązania selenu dla Pythona, Java, C #, Ruby i JavaScript. Tutaj zamierzamy wykonać skrobanie sieci przy użyciu selenu i jego powiązań Pythona. Możesz dowiedzieć się więcej o Selenium z Javą pod linkiem Selenium .

Powiązania Selenium Python zapewniają wygodny interfejs API do dostępu do Selenium WebDrivers, takich jak Firefox, IE, Chrome, Remote itp. Aktualnie obsługiwane wersje Pythona to 2.7, 3.5 i nowsze.

Instalowanie Selenium

Używając pip polecenie, możemy zainstalować urllib3 w naszym środowisku wirtualnym lub w instalacji globalnej.

pip install selenium

Ponieważ selen wymaga sterownika do współpracy z wybraną przeglądarką, musimy go pobrać. W poniższej tabeli przedstawiono różne przeglądarki i ich łącza do pobierania tego samego.

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

Przykład

Ten przykład pokazuje skrobanie sieci przy użyciu selenu. Może być również używany do testowania, które nazywa się testowaniem selenu.

Po pobraniu konkretnego sterownika dla określonej wersji przeglądarki, musimy programować w języku Python.

Najpierw musisz zaimportować webdriver z selenu w następujący sposób -

from selenium import webdriver

Teraz podaj ścieżkę sterownika sieciowego, który pobraliśmy zgodnie z naszymi wymaganiami -

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

Teraz podaj adres URL, który chcemy otworzyć w tej przeglądarce internetowej, teraz kontrolowanej przez nasz skrypt Pythona.

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

Możemy również zeskrobać określony element, podając xpath podany w lxml.

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

Możesz sprawdzić przeglądarkę, kontrolowaną przez skrypt Pythona, pod kątem danych wyjściowych.

Scrapy

Scrapy to szybka platforma do indeksowania stron internetowych typu open source napisana w języku Python, używana do wyodrębniania danych ze strony internetowej za pomocą selektorów opartych na XPath. Scrapy został wydany po raz pierwszy 26 czerwca 2008 na licencji BSD, a kamień milowy 1.0 został wydany w czerwcu 2015. Dostarcza nam wszystkich narzędzi potrzebnych do wydobywania, przetwarzania i strukturyzowania danych ze stron internetowych.

Instalowanie Scrapy

Używając pip polecenie, możemy zainstalować urllib3 w naszym środowisku wirtualnym lub w instalacji globalnej.

pip install scrapy

Bardziej szczegółowe badanie Scrapy można znaleźć pod linkiem Scrapy

Dzięki Pythonowi możemy zeskrobać dowolną witrynę lub poszczególne elementy strony internetowej, ale czy masz pojęcie, czy jest to legalne, czy nie? Przed skrobaniem jakiejkolwiek strony internetowej musimy wiedzieć o legalności skrobania sieci. W tym rozdziale wyjaśnione zostaną pojęcia związane z legalnością skrobania sieci.

Wprowadzenie

Ogólnie rzecz biorąc, jeśli zamierzasz wykorzystać zeskrobane dane do użytku osobistego, może nie być żadnego problemu. Ale jeśli zamierzasz ponownie opublikować te dane, to przed zrobieniem tego samego powinieneś poprosić właściciela o pobranie lub poszukać informacji na temat zasad, a także danych, które zamierzasz zeskrobać.

Wymagane badania przed skrobaniem

Jeśli kierujesz stronę internetową do pobierania z niej danych, musimy zrozumieć jej skalę i strukturę. Poniżej znajduje się kilka plików, które musimy przeanalizować przed rozpoczęciem skrobania sieci.

Analiza pliku robots.txt

W rzeczywistości większość wydawców pozwala programistom w pewnym zakresie indeksować ich witryny internetowe. Inaczej mówiąc, wydawcy chcą, aby indeksowane były określone fragmenty witryn. Aby to zdefiniować, strony internetowe muszą określić reguły określające, które części mogą być indeksowane, a które nie. Takie reguły są zdefiniowane w pliku o nazwierobots.txt.

robots.txtto czytelny dla człowieka plik używany do identyfikowania części witryny, które roboty indeksujące mogą, a które nie mogą zeskrobać. Nie ma standardowego formatu pliku robots.txt, a wydawcy strony mogą wprowadzać modyfikacje zgodnie ze swoimi potrzebami. Możemy sprawdzić plik robots.txt dla konkretnej witryny, podając ukośnik i robots.txt po adresie URL tej witryny. Na przykład, jeśli chcemy sprawdzić go pod kątem Google.com, musimy wpisaćhttps://www.google.com/robots.txt a otrzymamy coś takiego -

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……..

Oto niektóre z najczęstszych reguł zdefiniowanych w pliku robots.txt witryny -

User-agent: BadCrawler
Disallow: /

Powyższa reguła oznacza, że plik robots.txt pyta robota indeksującego o rozszerzenie BadCrawler klient użytkownika nie indeksuje swojej witryny.

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

Powyższa reguła oznacza, że plik robots.txt opóźnia robota indeksującego o 5 sekund między żądaniami pobierania dla wszystkich klientów użytkownika, aby uniknąć przeciążenia serwera. Plik/traplink spróbuje zablokować złośliwe roboty, które korzystają z niedozwolonych linków. Istnieje wiele innych reguł, które wydawca witryny może zdefiniować zgodnie z ich wymaganiami. Niektóre z nich są omówione tutaj -

Analizowanie plików map witryn

Co powinieneś zrobić, jeśli chcesz przeszukać witrynę w celu uzyskania aktualnych informacji? Przeszukasz każdą stronę internetową w celu uzyskania zaktualizowanych informacji, ale zwiększy to ruch na serwerze w tej konkretnej witrynie. Dlatego strony internetowe udostępniają pliki map witryn, które pomagają robotom indeksującym w lokalizowaniu aktualizowanych treści bez konieczności indeksowania każdej strony internetowej. Standard mapy witryny jest zdefiniowany pod adresemhttp://www.sitemaps.org/protocol.html.

Zawartość pliku mapy witryny

Poniżej znajduje się zawartość pliku mapy witryny https://www.microsoft.com/robots.txt który jest wykryty w pliku 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

Powyższa treść pokazuje, że mapa witryny zawiera listę adresów URL w witrynie, a ponadto pozwala webmasterowi określić dodatkowe informacje, takie jak data ostatniej aktualizacji, zmiana treści, znaczenie adresu URL w stosunku do innych itp. O każdym adresie URL.

Jaki jest rozmiar witryny internetowej?

Czy rozmiar witryny internetowej, tj. Liczba jej stron internetowych, wpływa na sposób, w jaki się indeksujemy? Z pewnością tak. Ponieważ jeśli mamy mniej stron internetowych do zindeksowania, to wydajność nie byłaby poważnym problemem, ale załóżmy, że jeśli nasza witryna ma miliony stron internetowych, na przykład Microsoft.com, pobieranie każdej ze stron sekwencyjne zajmie kilka miesięcy i wtedy wydajność byłaby poważnym problemem.

Sprawdzanie rozmiaru witryny

Sprawdzając rozmiar wyniku robota Google, możemy oszacować rozmiar witryny. Nasz wynik można filtrować za pomocą słowa kluczowegositepodczas wyszukiwania w Google. Na przykład oszacowanie rozmiaruhttps://authoraditiagarwal.com/ podano poniżej -

Możesz zobaczyć około 60 wyników, co oznacza, że nie jest to duża witryna, a indeksowanie nie doprowadziłoby do problemu z wydajnością.

Z jakiej technologii korzysta strona internetowa?

Kolejnym ważnym pytaniem jest to, czy technologia używana przez witrynę wpływa na sposób, w jaki się indeksujemy? Tak, to wpływa. Ale jak możemy sprawdzić, z jakiej technologii korzysta strona internetowa? Istnieje biblioteka Pythona o nazwiebuiltwith za pomocą których możemy dowiedzieć się, z jakiej technologii korzysta serwis.

Przykład

W tym przykładzie sprawdzimy technologię używaną przez serwis https://authoraditiagarwal.com przy pomocy biblioteki Python builtwith. Ale przed użyciem tej biblioteki musimy zainstalować ją w następujący sposób -

(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

Teraz, podążając za prostą linią kodów, możemy sprawdzić technologię używaną przez daną witrynę -

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']}

Kto jest właścicielem strony internetowej?

Właściciel witryny ma również znaczenie, ponieważ jeśli znany jest z blokowania robotów indeksujących, to roboty muszą być ostrożne podczas pobierania danych ze strony. Istnieje protokół o nazwieWhois za pomocą których możemy dowiedzieć się o właścicielu serwisu.

Przykład

W tym przykładzie sprawdzimy, czy właściciel witryny internetowej mówi microsoft.com z pomocą Whois. Ale przed użyciem tej biblioteki musimy zainstalować ją w następujący sposób -

(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

Teraz, podążając za prostą linią kodów, możemy sprawdzić technologię używaną przez daną witrynę -

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]"
   ],
}

Analiza strony internetowej oznacza zrozumienie jej struktury. Teraz pojawia się pytanie, dlaczego jest to ważne dla skrobania sieci? W tym rozdziale wyjaśnijmy to szczegółowo.

Analiza strony internetowej

Analiza strony internetowej jest ważna, ponieważ bez analizy nie jesteśmy w stanie wiedzieć, w jakiej formie otrzymamy dane z tej strony (ustrukturyzowanej lub nieustrukturyzowanej) po ekstrakcji. Możemy przeprowadzić analizę strony internetowej na następujące sposoby -

Wyświetlanie źródła strony

Jest to sposób na zrozumienie struktury strony internetowej poprzez zbadanie jej kodu źródłowego. Aby to zaimplementować, musimy kliknąć stronę prawym przyciskiem myszy, a następnie wybrać plikView page sourceopcja. Następnie z tej strony otrzymamy dane, które nas interesują w postaci HTML. Ale głównym problemem są białe znaki i formatowanie, które jest dla nas trudne do sformatowania.

Inspekcja źródła strony, klikając opcję Sprawdź element

To kolejny sposób analizy strony internetowej. Ale różnica polega na tym, że rozwiąże problem formatowania i białych znaków w kodzie źródłowym strony internetowej. Możesz to zaimplementować, klikając prawym przyciskiem myszy, a następnie wybierając plikInspect lub Inspect elementopcja z menu. Dostarcza informacji o konkretnym obszarze lub elemencie tej strony internetowej.

Różne sposoby wyodrębniania danych ze strony internetowej

Następujące metody są najczęściej używane do wyodrębniania danych ze strony internetowej -

Wyrażenie regularne

Są to wysoce wyspecjalizowane języki programowania osadzone w Pythonie. Możemy to wykorzystaćremoduł Pythona. Nazywa się to również RE lub wyrażeniami regularnymi lub wzorcami wyrażeń regularnych. Za pomocą wyrażeń regularnych możemy określić pewne reguły dla możliwego zestawu ciągów, które chcemy dopasować z danych.

Jeśli chcesz dowiedzieć się więcej o ogólnych wyrażeniach regularnych, przejdź do łącza https://www.tutorialspoint.com/automata_theory/regular_expressions.htma jeśli chcesz dowiedzieć się więcej o module re lub wyrażeniach regularnych w Pythonie, możesz skorzystać z łącza https://www.tutorialspoint.com/python/python_reg_expressions.htm .

Przykład

W poniższym przykładzie zamierzamy pobrać dane o Indiach z http://example.webscraping.com po dopasowaniu zawartości <td> za pomocą wyrażenia regularnego.

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)

Wynik

Odpowiednie wyjście będzie wyglądać tak, jak pokazano tutaj -

[
   '<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>'
]

Zauważ, że na powyższym wyjściu możesz zobaczyć szczegółowe informacje o kraju w Indiach używając wyrażenia regularnego.

Piękna Zupa

Załóżmy, że chcemy zebrać wszystkie hiperłącza ze strony internetowej, a następnie możemy użyć parsera o nazwie BeautifulSoup, który można poznać bardziej szczegółowo pod adresem https://www.crummy.com/software/BeautifulSoup/bs4/doc/.Krótko mówiąc, BeautifulSoup to biblioteka Pythona do pobierania danych z plików HTML i XML. Może być używany z żądaniami, ponieważ potrzebuje danych wejściowych (dokumentu lub adresu URL), aby utworzyć obiekt zupy, ponieważ nie może samodzielnie pobrać strony internetowej. Możesz użyć następującego skryptu Python, aby zebrać tytuł strony internetowej i hiperłącza.

Instalowanie pięknej zupy

Używając pip polecenie, możemy zainstalować beautifulsoup w naszym środowisku wirtualnym lub w instalacji globalnej.

(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

Przykład

Zauważ, że w tym przykładzie rozszerzamy powyższy przykład zaimplementowany z modułem żądań python. Używamyr.text do tworzenia obiektu zupy, który będzie dalej używany do pobierania szczegółów, takich jak tytuł strony internetowej.

Najpierw musimy zaimportować niezbędne moduły Pythona -

import requests
from bs4 import BeautifulSoup

W poniższym wierszu kodu używamy żądań do wykonania żądań HTTP GET dla adresu URL: https://authoraditiagarwal.com/ wykonując żądanie GET.

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

Teraz musimy utworzyć obiekt Soup w następujący sposób -

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

Wynik

Odpowiednie wyjście będzie wyglądać tak, jak pokazano tutaj -

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

Lxml

Kolejną biblioteką Pythona, którą omówimy do skrobania stron internetowych, jest lxml. Jest to wysokowydajna biblioteka analizująca HTML i XML. Jest stosunkowo szybki i prosty. Więcej o tym przeczytasz na stroniehttps://lxml.de/.

Instalowanie lxml

Za pomocą polecenia pip możemy zainstalować lxml w naszym środowisku wirtualnym lub w instalacji globalnej.

(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

Przykład: wyodrębnianie danych przy użyciu lxml i żądań

W poniższym przykładzie pobieramy określony element strony internetowej z authoraditiagarwal.com używając lxml i żądań -

Najpierw musimy zaimportować żądania i html z biblioteki lxml w następujący sposób -

import requests
from lxml import html

Teraz musimy podać adres URL strony internetowej do złomowania

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

Teraz musimy podać ścieżkę (Xpath) do konkretnego elementu tej strony internetowej -

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())

Wynik

Odpowiednie wyjście będzie wyglądać tak, jak pokazano tutaj -

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.

We wcześniejszych rozdziałach dowiedzieliśmy się o wyodrębnianiu danych ze stron internetowych lub skrobaniu sieci przez różne moduły Pythona. W tym rozdziale przyjrzyjmy się różnym technikom przetwarzania zeskrobanych danych.

Wprowadzenie

Aby przetworzyć zeskrobane dane, musimy przechowywać dane na naszej lokalnej maszynie w określonym formacie, takim jak arkusz kalkulacyjny (CSV), JSON lub czasami w bazach danych, takich jak MySQL.

Przetwarzanie danych CSV i JSON

Najpierw zapiszemy informacje, po pobraniu ich ze strony internetowej, do pliku CSV lub arkusza kalkulacyjnego. Najpierw zrozumiemy przez prosty przykład, w którym najpierw zdobędziemy informacje za pomocąBeautifulSoup moduł, tak jak wcześniej, a następnie za pomocą modułu Python CSV zapiszemy te informacje tekstowe do pliku CSV.

Najpierw musimy zaimportować niezbędne biblioteki Pythona w następujący sposób -

import requests
from bs4 import BeautifulSoup
import csv

W poniższym wierszu kodu używamy żądań do wykonania żądań HTTP GET dla adresu URL: https://authoraditiagarwal.com/ wykonując żądanie GET.

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

Teraz musimy utworzyć obiekt Soup w następujący sposób -

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

Teraz, przy pomocy kolejnych linii kodu, zapiszemy pobrane dane do pliku CSV o nazwie dataprocessing.csv.

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

Po uruchomieniu tego skryptu informacje tekstowe lub tytuł strony internetowej zostaną zapisane w wyżej wymienionym pliku CSV na komputerze lokalnym.

Podobnie możemy zapisać zebrane informacje w pliku JSON. Poniżej znajduje się łatwy do zrozumienia skrypt w Pythonie, który robi to samo, w którym pobieramy te same informacje, co w ostatnim skrypcie Pythona, ale tym razem przechwycone informacje są zapisywane w JSONfile.txt przy użyciu modułu 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)

Po uruchomieniu tego skryptu, pobrane informacje, tj. Tytuł strony, zostaną zapisane w wyżej wymienionym pliku tekstowym na Twoim komputerze.

Przetwarzanie danych za pomocą AWS S3

Czasami możemy chcieć zapisać zeskrobane dane w naszej lokalnej pamięci do celów archiwalnych. Ale co, jeśli musimy przechowywać i analizować te dane na masową skalę? Odpowiedzią jest usługa przechowywania w chmurze o nazwie Amazon S3 lub AWS S3 (Simple Storage Service). Zasadniczo AWS S3 to obiektowa pamięć masowa zbudowana do przechowywania i pobierania dowolnej ilości danych z dowolnego miejsca.

Możemy wykonać następujące kroki, aby przechowywać dane w AWS S3 -

Step 1- Najpierw potrzebujemy konta AWS, które zapewni nam tajne klucze do wykorzystania w naszym skrypcie Python podczas przechowywania danych. Stworzy wiadro S3, w którym będziemy mogli przechowywać nasze dane.

Step 2 - Następnie musimy zainstalować boto3Biblioteka Pythona do uzyskiwania dostępu do zasobnika S3. Można go zainstalować za pomocą następującego polecenia -

pip install boto3

Step 3 - Następnie możemy użyć następującego skryptu Python do pobierania danych ze strony internetowej i zapisywania ich w wiadrze AWS S3.

Najpierw musimy zaimportować biblioteki Pythona do skrobania, tutaj pracujemy requests, i boto3 zapisywanie danych w zasobniku S3.

import requests
import boto3

Teraz możemy pobrać dane z naszego adresu URL.

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

Teraz, aby przechowywać dane w zasobniku S3, musimy utworzyć klienta S3 w następujący sposób -

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

Następny wiersz kodu utworzy zasobnik S3 w następujący sposób -

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

Teraz możesz sprawdzić wiadro z nazwą our-content na swoim koncie AWS.

Przetwarzanie danych za pomocą MySQL

Nauczmy się przetwarzać dane za pomocą MySQL. Jeśli chcesz dowiedzieć się więcej o MySQL, możesz kliknąć łączehttps://www.tutorialspoint.com/mysql/.

Za pomocą poniższych kroków możemy zeskrobać i przetworzyć dane do tabeli MySQL -

Step 1- Najpierw za pomocą MySQL musimy stworzyć bazę danych i tabelę, w której chcemy zapisywać nasze zeskrobane dane. Na przykład tworzymy tabelę z następującym zapytaniem -

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

Step 2- Następnie musimy zająć się Unicode. Zauważ, że MySQL nie obsługuje standardu Unicode. Musimy włączyć tę funkcję za pomocą następujących poleceń, które zmienią domyślny zestaw znaków dla bazy danych, dla tabeli i dla obu kolumn -

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- Teraz zintegruj MySQL z Pythonem. W tym celu będziemy potrzebować PyMySQL, który można zainstalować za pomocą następującego polecenia

pip install PyMySQL

Step 4- Teraz nasza baza danych o nazwie Scrap, utworzona wcześniej, jest gotowa do zapisania danych po zeskrobaniu z sieci w tabeli o nazwie Scrap_pages. W naszym przykładzie pobieramy dane z Wikipedii i zostaną one zapisane w naszej bazie danych.

Najpierw musimy zaimportować wymagane moduły Pythona.

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

Teraz zrób połączenie, czyli zintegruj to z Pythonem.

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()

Teraz połącz się z Wikipedią i pobierz z niej dane.

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)

Na koniec musimy zamknąć zarówno kursor, jak i połączenie.

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

Spowoduje to zapisanie danych zebranych z Wikipedii w tabeli o nazwie scrap_pages. Jeśli znasz MySQL i skrobanie stron internetowych, powyższy kod nie byłby trudny do zrozumienia.

Przetwarzanie danych za pomocą PostgreSQL

PostgreSQL, opracowany przez zespół wolontariuszy z całego świata, to system zarządzania relacyjnymi bazami danych typu open source (RDMS). Proces przetwarzania zeskrobanych danych przy użyciu PostgreSQL jest podobny do procesu MySQL. Byłyby dwie zmiany: po pierwsze, polecenia byłyby inne niż MySQL, a po drugie, tutaj będziemy używaćpsycopg2 Biblioteka Pythona do integracji z Pythonem.

Jeśli nie znasz PostgreSQL, możesz się tego nauczyć pod adresem https://www.tutorialspoint.com/postgresql/. Za pomocą następującego polecenia możemy zainstalować bibliotekę psycopg2 Python -

pip install psycopg2

Web scraping zazwyczaj obejmuje pobieranie, przechowywanie i przetwarzanie treści mediów internetowych. W tym rozdziale wyjaśnimy, jak przetwarzać zawartość pobraną z sieci.

Wprowadzenie

Treści internetowe, które uzyskujemy podczas scrapingu, mogą być obrazami, plikami audio i wideo w postaci stron innych niż strony internetowe, a także plikami danych. Ale czy możemy ufać pobranym danym, zwłaszcza jeśli chodzi o rozszerzenie danych, które będziemy pobierać i przechowywać w pamięci naszego komputera? Dlatego ważne jest, aby wiedzieć, jakie dane będziemy przechowywać lokalnie.

Pobieranie treści multimedialnych ze strony internetowej

W tej sekcji dowiemy się, w jaki sposób możemy pobierać treści multimedialne, które poprawnie reprezentują typ mediów na podstawie informacji z serwera internetowego. Możemy to zrobić przy pomocy Pythonarequests moduł, tak jak to zrobiliśmy w poprzednim rozdziale.

Najpierw musimy zaimportować niezbędne moduły Pythona w następujący sposób -

import requests

Teraz podaj adres URL treści multimedialnych, które chcemy pobrać i przechowywać lokalnie.

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

Użyj poniższego kodu, aby utworzyć obiekt odpowiedzi HTTP.

r = requests.get(url)

Za pomocą poniższego wiersza kodu możemy zapisać otrzymaną treść jako plik .png.

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

Po uruchomieniu powyższego skryptu w Pythonie otrzymamy plik o nazwie ThinkBig.png, który będzie zawierał pobrany obraz.

Wyodrębnianie nazwy pliku z adresu URL

Po pobraniu treści ze strony internetowej chcemy również zapisać ją w pliku o nazwie pliku znajdującej się w adresie URL. Ale możemy też sprawdzić, czy w adresie URL istnieje również liczba dodatkowych fragmentów. W tym celu musimy znaleźć rzeczywistą nazwę pliku z adresu URL.

Z pomocą następującego skryptu Pythona, używając urlparse, możemy wyodrębnić nazwę pliku z adresu URL -

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

Możesz obserwować wyjście, jak pokazano poniżej -

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

Możesz obserwować wyjście, jak pokazano poniżej -

'MetaSlider_ThinkBig-1080x180.jpg'

Po uruchomieniu powyższego skryptu otrzymamy nazwę pliku z adresu URL.

Informacje o typie treści z adresu URL

Podczas wypakowywania treści z serwera WWW, poprzez żądanie GET, możemy również sprawdzić jego informacje dostarczone przez serwer WWW. Za pomocą poniższego skryptu w Pythonie możemy określić, co serwer WWW ma na myśli z rodzajem treści -

Najpierw musimy zaimportować niezbędne moduły Pythona w następujący sposób -

import requests

Teraz musimy podać adres URL treści multimedialnych, które chcemy pobrać i przechowywać lokalnie.

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

Poniższy wiersz kodu utworzy obiekt odpowiedzi HTTP.

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

Teraz możemy dowiedzieć się, jakiego typu informacje o treściach może dostarczyć serwer WWW.

for headers in r.headers: print(headers)

Możesz obserwować wyjście, jak pokazano poniżej -

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

Za pomocą następującego wiersza kodu możemy uzyskać szczegółowe informacje o typie treści, powiedzmy typ zawartości -

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

Możesz obserwować wyjście, jak pokazano poniżej -

image/jpeg

Za pomocą następującego wiersza kodu możemy uzyskać szczegółowe informacje o typie treści, powiedzmy EType -

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

Możesz obserwować wyjście, jak pokazano poniżej -

None

Obserwuj następujące polecenie -

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

Możesz obserwować wyjście, jak pokazano poniżej -

Za pomocą następującego wiersza kodu możemy uzyskać szczegółowe informacje o typie zawartości, powiedzmy Serwer -

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

Możesz obserwować wyjście, jak pokazano poniżej -

Apache

Generowanie miniatur dla obrazów

Miniatura to bardzo mały opis lub reprezentacja. Użytkownik może chcieć zapisać tylko miniaturę dużego obrazu lub zapisać zarówno obraz, jak i miniaturę. W tej sekcji utworzymy miniaturę obrazu o nazwieThinkBig.png pobrane w poprzedniej sekcji „Pobieranie treści multimedialnych ze strony internetowej”.

W przypadku tego skryptu Python musimy zainstalować bibliotekę Python o nazwie Pillow, rozwidlenie biblioteki obrazów Pythona, która ma przydatne funkcje do manipulowania obrazami. Można go zainstalować za pomocą następującego polecenia -

pip install pillow

Poniższy skrypt w Pythonie utworzy miniaturę obrazu i zapisze ją w bieżącym katalogu, poprzedzając plik miniatury znakiem 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")

Powyższy kod jest bardzo łatwy do zrozumienia i możesz sprawdzić plik miniatury w bieżącym katalogu.

Zrzut ekranu ze strony internetowej

Podczas skrobania stron internetowych bardzo częstym zadaniem jest wykonanie zrzutu ekranu witryny internetowej. W tym celu użyjemy selenu i webdrivera. Poniższy skrypt w Pythonie pobierze zrzut ekranu ze strony internetowej i zapisze go w bieżącym katalogu.

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

Możesz obserwować wyjście, jak pokazano poniżej -

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")>>

Po uruchomieniu skryptu możesz sprawdzić bieżący katalog screenshot.png plik.

Generowanie miniatur dla wideo

Załóżmy, że pobraliśmy filmy ze strony internetowej i chcieliśmy wygenerować dla nich miniatury, aby można było kliknąć określony film na podstawie jego miniatury. Do generowania miniatur dla filmów potrzebujemy prostego narzędzia o nazwieffmpeg które można pobrać z www.ffmpeg.org. Po pobraniu musimy go zainstalować zgodnie ze specyfikacjami naszego systemu operacyjnego.

Poniższy skrypt w języku Python wygeneruje miniaturę wideo i zapisze go w naszym katalogu lokalnym -

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"])

Po uruchomieniu powyższego skryptu otrzymamy miniaturę o nazwie thumbnail_solar_video.jpg zapisane w naszym katalogu lokalnym.

Zgrywanie wideo MP4 do MP3

Załóżmy, że pobrałeś jakiś plik wideo ze strony internetowej, ale potrzebujesz tylko dźwięku z tego pliku, aby spełnić swoje zadanie, wtedy można to zrobić w Pythonie za pomocą biblioteki Pythona o nazwie moviepy które można zainstalować za pomocą następującego polecenia -

pip install moviepy

Teraz po pomyślnym zainstalowaniu moviepy za pomocą poniższego skryptu możemy przekonwertować MP4 na MP3.

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

Możesz obserwować wyjście, jak pokazano poniżej -

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

Powyższy skrypt zapisze plik audio MP3 w katalogu lokalnym.

W poprzednim rozdziale widzieliśmy, jak postępować z filmami wideo i obrazami, które uzyskujemy w ramach treści do pobierania z sieci. W tym rozdziale zajmiemy się analizą tekstu przy użyciu biblioteki Python i dowiemy się o tym szczegółowo.

Wprowadzenie

Analizę tekstu można przeprowadzić w programie za pomocą biblioteki Python o nazwie Natural Language Tool Kit (NLTK). Zanim przejdziemy do koncepcji NLTK, zrozummy związek między analizą tekstu a skrobaniem sieci.

Analiza słów w tekście może doprowadzić nas do ustalenia, które słowa są ważne, które są nietypowe, jak słowa są grupowane. Ta analiza ułatwia zadanie skrobania sieci.

Pierwsze kroki z NLTK

Zestaw narzędzi języka naturalnego (NLTK) to zbiór bibliotek Pythona, który został zaprojektowany specjalnie do identyfikowania i oznaczania części mowy występujących w tekście języka naturalnego, takiego jak angielski.

Instalowanie NLTK

Możesz użyć następującego polecenia, aby zainstalować NLTK w Pythonie -

pip install nltk

Jeśli używasz programu Anaconda, pakiet conda dla NLTK można zbudować za pomocą następującego polecenia -

conda install -c anaconda nltk

Pobieranie danych NLTK

Po zainstalowaniu NLTK musimy pobrać gotowe repozytoria tekstu. Ale przed pobraniem repozytoriów predefiniowanych tekstów musimy zaimportować NLTK za pomocąimport polecenie w następujący sposób -

mport nltk

Teraz za pomocą następującego polecenia można pobrać dane NLTK -

nltk.download()

Instalacja wszystkich dostępnych pakietów NLTK zajmie trochę czasu, ale zawsze zaleca się zainstalowanie wszystkich pakietów.

Instalowanie innych niezbędnych pakietów

Potrzebujemy również innych pakietów Pythona, takich jak gensim i pattern do przeprowadzania analizy tekstu, a także budowania aplikacji przetwarzających język naturalny przy użyciu NLTK.

gensim- Solidna biblioteka do modelowania semantycznego, przydatna w wielu aplikacjach. Można go zainstalować za pomocą następującego polecenia -

pip install gensim

pattern - Robiłem gensimpakiet działa poprawnie. Można go zainstalować za pomocą następującego polecenia -

pip install pattern

Tokenizacja

Proces dzielenia danego tekstu na mniejsze jednostki zwane tokenami nazywa się tokenizacją. Tymi żetonami mogą być słowa, cyfry lub znaki interpunkcyjne. Nazywa się to równieżword segmentation.

Przykład

Moduł NLTK udostępnia różne pakiety do tokenizacji. Możemy używać tych pakietów zgodnie z naszymi wymaganiami. Niektóre pakiety są opisane tutaj -

sent_tokenize package- Ten pakiet podzieli tekst wejściowy na zdania. Możesz użyć następującego polecenia, aby zaimportować ten pakiet -

from nltk.tokenize import sent_tokenize

word_tokenize package- Ten pakiet podzieli tekst wejściowy na słowa. Możesz użyć następującego polecenia, aby zaimportować ten pakiet -

from nltk.tokenize import word_tokenize

WordPunctTokenizer package- Ten pakiet podzieli tekst wejściowy oraz znaki interpunkcyjne na słowa. Możesz użyć następującego polecenia, aby zaimportować ten pakiet -

from nltk.tokenize import WordPuncttokenizer

Przybitka

W każdym języku istnieją różne formy słów. Język zawiera wiele odmian ze względów gramatycznych. Na przykład rozważ słowademocracy, democratic, i democratization. Zarówno w przypadku uczenia maszynowego, jak i projektów związanych z pobieraniem z sieci Web, ważne jest, aby maszyny rozumiały, że te różne słowa mają tę samą formę podstawową. Stąd możemy powiedzieć, że przy analizie tekstu przydatne może być wyodrębnienie form bazowych słów.

Można to osiągnąć przez zapychanie, które można zdefiniować jako heurystyczny proces wyodrębniania podstawowych form słów przez odcinanie końców słów.

Moduł NLTK zapewnia różne pakiety do wyprowadzania. Możemy używać tych pakietów zgodnie z naszymi wymaganiami. Niektóre z tych pakietów są opisane tutaj -

PorterStemmer package- Algorytm Portera jest używany przez ten pakiet bazujący w Pythonie do wyodrębnienia formy podstawowej. Możesz użyć następującego polecenia, aby zaimportować ten pakiet -

from nltk.stem.porter import PorterStemmer

Na przykład po podaniu słowa ‘writing’ jako dane wejściowe do tego stempla, wyjściem będzie słowo ‘write’ po wyhodowaniu.

LancasterStemmer package- Algorytm Lancaster jest używany przez ten pakiet bazujący w Pythonie do wyodrębnienia formy podstawowej. Możesz użyć następującego polecenia, aby zaimportować ten pakiet -

from nltk.stem.lancaster import LancasterStemmer

Na przykład po podaniu słowa ‘writing’ jako dane wejściowe do tego stempla, wówczas wyjściem będzie słowo ‘writ’ po wyhodowaniu.

SnowballStemmer package- Algorytm Snowball jest używany przez ten pakiet bazujący w Pythonie do wyodrębnienia formy podstawowej. Możesz użyć następującego polecenia, aby zaimportować ten pakiet -

from nltk.stem.snowball import SnowballStemmer

Na przykład, po podaniu słowa „pisanie” jako danych wejściowych do tego stempla, wynikiem będzie słowo „napisz” po wbudowaniu.

Lemmatyzacja

Innym sposobem wyodrębnienia podstawowej formy słów jest lematyzacja, zwykle mająca na celu usunięcie końcówek fleksyjnych za pomocą słownictwa i analizy morfologicznej. Podstawową formą dowolnego słowa po lematyzacji jest lemat.

Moduł NLTK udostępnia następujące pakiety do lematyzacji -

WordNetLemmatizer package- Wyodrębni podstawową formę słowa w zależności od tego, czy jest używane jako rzeczownik jako czasownik. Możesz użyć następującego polecenia, aby zaimportować ten pakiet -

from nltk.stem import WordNetLemmatizer

Kruszenie

Chunking, czyli dzielenie danych na małe fragmenty, jest jednym z ważnych procesów w przetwarzaniu języka naturalnego w celu identyfikacji części mowy i krótkich fraz, takich jak frazy rzeczownikowe. Chunking polega na etykietowaniu tokenów. Możemy uzyskać strukturę zdania za pomocą procesu fragmentacji.

Przykład

W tym przykładzie zaimplementujemy fragmentację rzeczownik-fraza za pomocą modułu NLTK Python. NP chunking to kategoria dzielenia się na fragmenty, w której znajdują się fragmenty wyrażeń rzeczownikowych w zdaniu.

Kroki implementacji fragmentacji fraz rzeczownikowych

Aby zaimplementować fragmentację wyrażeń rzeczownikowych, musimy postępować zgodnie z poniższymi krokami -

Krok 1 - Definicja gramatyki fragmentów

W pierwszym kroku zdefiniujemy gramatykę fragmentów. Składałby się z zasad, których musimy przestrzegać.

Krok 2 - Tworzenie parsera fragmentów

Teraz utworzymy parser fragmentów. Sparsowałby gramatykę i dałby wynik.

Krok 3 - Wynik

W tym ostatnim kroku dane wyjściowe będą tworzone w formacie drzewa.

Najpierw musimy zaimportować pakiet NLTK w następujący sposób -

import nltk

Następnie musimy zdefiniować zdanie. Tutaj DT: wyznacznik, VBP: czasownik, JJ: przymiotnik, IN: przyimek i NN: rzeczownik.

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

Następnie podajemy gramatykę w postaci wyrażenia regularnego.

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

Teraz następny wiersz kodu zdefiniuje parser do analizowania gramatyki.

parser_chunking = nltk.RegexpParser(grammar)

Teraz parser przeanalizuje zdanie.

parser_chunking.parse(sentence)

Następnie podajemy nasze wyjście w zmiennej.

Output = parser_chunking.parse(sentence)

Za pomocą poniższego kodu możemy narysować nasze dane wyjściowe w postaci drzewa, jak pokazano poniżej.

output.draw()

Model worka słów (BoW) Wyodrębnianie i przekształcanie tekstu w postać liczbową

Bag of Word (BoW), przydatny model przetwarzania języka naturalnego, jest zasadniczo używany do wyodrębniania cech z tekstu. Po wyodrębnieniu funkcji z tekstu można go użyć w modelowaniu w algorytmach uczenia maszynowego, ponieważ surowych danych nie można używać w aplikacjach ML.

Działanie modelu BoW

Początkowo model wydobywa słownictwo ze wszystkich słów w dokumencie. Później, używając macierzy terminów dokumentu, zbudowałoby model. W ten sposób model BoW przedstawia dokument jako zbiór samych słów, a kolejność lub struktura jest odrzucana.

Przykład

Załóżmy, że mamy następujące dwa zdania -

Sentence1 - To jest przykład modelu Bag of Words.

Sentence2 - Możemy wyodrębnić funkcje za pomocą modelu Bag of Words.

Teraz, biorąc pod uwagę te dwa zdania, mamy następujących 14 różnych słów:

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

Tworzenie modelu worka słów w NLTK

Przyjrzyjmy się poniższemu skryptowi w Pythonie, który zbuduje model BoW w NLTK.

Najpierw zaimportuj następujący pakiet -

from sklearn.feature_extraction.text import CountVectorizer

Następnie zdefiniuj zestaw zdań -

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_)

Wynik

Pokazuje, że mamy 14 różnych słów w powyższych dwóch zdaniach -

{
   '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
}

Modelowanie tematów: identyfikowanie wzorców w danych tekstowych

Ogólnie dokumenty są pogrupowane w tematy, a modelowanie tematyczne jest techniką identyfikowania wzorców w tekście, które odpowiadają określonemu tematowi. Innymi słowy, modelowanie tematyczne służy do odkrywania abstrakcyjnych motywów lub ukrytej struktury w danym zestawie dokumentów.

Modelowania tematów można używać w następujących scenariuszach -

Klasyfikacja tekstu

Klasyfikację można ulepszyć za pomocą modelowania tematycznego, ponieważ grupuje ono podobne słowa, zamiast używać każdego słowa oddzielnie jako cechy.

Systemy rekomendujące

Możemy budować systemy rekomendujące używając miar podobieństwa.

Algorytmy modelowania tematycznego

Możemy zaimplementować modelowanie tematyczne za pomocą następujących algorytmów -

Latent Dirichlet Allocation(LDA) - Jest to jeden z najpopularniejszych algorytmów wykorzystujący probabilistyczne modele graficzne do implementacji modelowania tematycznego.

Latent Semantic Analysis(LDA) or Latent Semantic Indexing(LSI) - Opiera się na algebrze liniowej i wykorzystuje koncepcję SVD (rozkład wartości osobliwych) na macierzy terminów dokumentu.

Non-Negative Matrix Factorization (NMF) - Opiera się również na algebrze liniowej, podobnie jak LDA.

Powyższe algorytmy miałyby następujące elementy -

Liczba tematów: parametr
Macierz dokument-słowo: wejście
WTM (Word Topic Matrix) i TDM (Topic Document Matrix): Wyjście

Wprowadzenie

Skrobanie sieci jest złożonym zadaniem, a złożoność wzrasta, jeśli witryna jest dynamiczna. Według Global Audit of Web Accessibility Organizacji Narodów Zjednoczonych, ponad 70% stron internetowych ma charakter dynamiczny, a ich funkcjonalność opiera się na JavaScript.

Przykład dynamicznej witryny internetowej

Spójrzmy na przykład dynamicznej strony internetowej i dowiedzmy się, dlaczego trudno ją zeskrobać. W tym miejscu weźmiemy przykład wyszukiwania w witrynie o nazwiehttp://example.webscraping.com/places/default/search.Ale jak możemy powiedzieć, że ta witryna ma charakter dynamiczny? Można to ocenić na podstawie danych wyjściowych następującego skryptu Pythona, który spróbuje zeskrobać dane z wyżej wymienionej strony internetowej -

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)

Wynik

[ ]

Powyższe dane wyjściowe pokazują, że przykładowy skrobak nie mógł wyodrębnić informacji, ponieważ element <div>, który próbujemy znaleźć, jest pusty.

Podejścia do pobierania danych z dynamicznych witryn internetowych

Widzieliśmy, że skrobak nie może pobrać informacji z dynamicznej witryny internetowej, ponieważ dane są ładowane dynamicznie za pomocą JavaScript. W takich przypadkach możemy skorzystać z dwóch technik pobierania danych z dynamicznych witryn zależnych od JavaScript -

Inżynieria odwrotna JavaScript
Renderowanie JavaScript

Inżynieria odwrotna JavaScript

Proces zwany inżynierią odwrotną byłby przydatny i pozwala nam zrozumieć, w jaki sposób dane są ładowane dynamicznie przez strony internetowe.

Aby to zrobić, musimy kliknąć plik inspect elementtab dla określonego adresu URL. Następnie klikniemyNETWORK tab, aby znaleźć wszystkie żądania skierowane do tej strony internetowej, w tym search.json ze ścieżką do /ajax. Zamiast uzyskiwać dostęp do danych AJAX z przeglądarki lub przez zakładkę SIEĆ, możemy to zrobić również za pomocą następującego skryptu Pythona -

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

Przykład

Powyższy skrypt umożliwia nam dostęp do odpowiedzi JSON przy użyciu metody json w języku Python. Podobnie możemy pobrać nieprzetworzoną odpowiedź łańcuchową i używając metody json.loads w Pythonie, możemy ją również załadować. Robimy to za pomocą następującego skryptu Pythona. Zasadniczo zeskrobuje wszystkie kraje, wyszukując literę alfabetu „a”, a następnie iterując wynikowe strony odpowiedzi 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)))

Po uruchomieniu powyższego skryptu otrzymamy następujące dane wyjściowe, a rekordy zostaną zapisane w pliku o nazwie countries.txt.

Wynik

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

Renderowanie JavaScript

W poprzedniej sekcji przeprowadziliśmy inżynierię wsteczną na stronie internetowej, w jaki sposób działa API i jak możemy go użyć do pobrania wyników w pojedynczym żądaniu. Jednak podczas inżynierii odwrotnej możemy napotkać następujące trudności -

Czasami witryny internetowe mogą być bardzo trudne. Na przykład, jeśli strona internetowa jest utworzona za pomocą zaawansowanego narzędzia przeglądarki, takiego jak Google Web Toolkit (GWT), wynikowy kod JS byłby generowany maszynowo i trudny do zrozumienia i inżynierii wstecznej.
Niektóre frameworki wyższego poziomu, takie jak React.js może utrudnić inżynierię wsteczną poprzez abstrakcję już złożonej logiki JavaScript.

Rozwiązaniem powyższych trudności jest użycie silnika renderującego w przeglądarce, który analizuje HTML, stosuje formatowanie CSS i wykonuje JavaScript w celu wyświetlenia strony internetowej.

Przykład

W tym przykładzie do renderowania skryptu Java użyjemy znanego modułu Pythona Selenium. Poniższy kod Pythona wyrenderuje stronę internetową przy pomocy Selenium -

Najpierw musimy zaimportować webdriver z selenu w następujący sposób -

from selenium import webdriver

Teraz podaj ścieżkę sterownika sieciowego, który pobraliśmy zgodnie z naszymi wymaganiami -

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

Teraz podaj adres URL, który chcemy otworzyć w tej przeglądarce internetowej, teraz kontrolowanej przez nasz skrypt Pythona.

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

Teraz możemy użyć identyfikatora zestawu narzędzi wyszukiwania do ustawienia elementu do wybrania.

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

Następnie możemy użyć skryptu java, aby ustawić zawartość pola wyboru w następujący sposób -

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

Poniższy wiersz kodu pokazuje, że wyszukiwanie jest gotowe do kliknięcia na stronie internetowej -

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

Następny wiersz kodu pokazuje, że będzie czekał 45 sekund na zakończenie żądania AJAX.

driver.implicitly_wait(45)

Teraz, aby wybrać linki do krajów, możemy użyć selektora CSS w następujący sposób -

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

Teraz można wyodrębnić tekst każdego linku w celu utworzenia listy krajów -

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

W poprzednim rozdziale widzieliśmy skrobanie dynamicznych witryn internetowych. W tym rozdziale przyjrzyjmy się skrobaniu witryn internetowych, które działają na podstawie danych wejściowych użytkownika, czyli witryn internetowych opartych na formularzach.

Wprowadzenie

Obecnie WWW (World Wide Web) zmierza w kierunku mediów społecznościowych, a także treści generowanych przez użytkowników. Powstaje więc pytanie, w jaki sposób możemy uzyskać dostęp do takich informacji, które są poza ekranem logowania? W tym celu musimy zająć się formularzami i loginami.

W poprzednich rozdziałach pracowaliśmy z metodą HTTP GET w celu żądania informacji, ale w tym rozdziale będziemy pracować z metodą HTTP POST, która wypycha informacje na serwer WWW w celu ich przechowywania i analizy.

Interakcja z formularzami logowania

Podczas pracy w Internecie musiałeś wielokrotnie wchodzić w interakcję z formularzami logowania. Mogą być bardzo proste, na przykład zawierające tylko kilka pól HTML, przycisk przesyłania i stronę akcji, lub mogą być skomplikowane i zawierać dodatkowe pola, takie jak e-mail, zostaw wiadomość wraz z captcha ze względów bezpieczeństwa.

W tej sekcji zajmiemy się prostym formularzem przesyłania za pomocą biblioteki żądań Python.

Najpierw musimy zaimportować bibliotekę żądań w następujący sposób -

import requests

Teraz musimy podać informacje w polach formularza logowania.

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

W kolejnym wierszu kodu musimy podać adres URL, na którym miałaby nastąpić akcja formularza.

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

Po uruchomieniu skryptu zwróci zawartość strony, na której nastąpiło działanie.

Załóżmy, że jeśli chcesz przesłać dowolne zdjęcie za pomocą formularza, jest to bardzo łatwe dzięki request.post (). Możesz to zrozumieć za pomocą następującego skryptu Pythona -

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

Ładowanie plików cookie z serwera internetowego

Plik cookie, czasami nazywany plikiem cookie sieciowym lub cookie internetowym, to niewielka część danych wysyłana ze strony internetowej, a nasz komputer przechowuje ją w pliku znajdującym się w naszej przeglądarce internetowej.

W kontekście obsługi formularzy logowania pliki cookie mogą być dwojakiego rodzaju. Po pierwsze, omówiliśmy w poprzedniej sekcji, która pozwala nam na przesyłanie informacji do witryny internetowej, a po drugie, która pozwala nam pozostać w stałym stanie „zalogowania” przez cały czas naszej wizyty na stronie. W przypadku drugiego rodzaju formularzy strony internetowe używają plików cookie, aby śledzić, kto jest zalogowany, a kto nie.

Co robią pliki cookie?

Obecnie większość witryn używa plików cookie do śledzenia. Możemy zrozumieć działanie plików cookie za pomocą następujących kroków -

Step 1- Najpierw witryna uwierzytelni nasze dane logowania i zapisze je w pliku cookie naszej przeglądarki. Ten plik cookie zawiera generowane przez serwer informacje o toke, time-out i śledzeniu.

Step 2- Następnie witryna wykorzysta plik cookie jako dowód uwierzytelnienia. To uwierzytelnienie jest zawsze pokazywane za każdym razem, gdy odwiedzamy witrynę.

Pliki cookie są bardzo problematyczne dla skrobaków internetowych, ponieważ jeśli skrobaki internetowe nie śledzą plików cookie, przesłany formularz jest odsyłany, a na następnej stronie wydaje się, że nigdy się nie zalogowali. Bardzo łatwo jest śledzić pliki cookie za pomocą Pyton requests biblioteka, jak pokazano poniżej -

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

W powyższym wierszu kodu adres URL będzie stroną, która będzie działać jako procesor dla formularza logowania.

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

Po uruchomieniu powyższego skryptu pobierzemy pliki cookie z wyniku ostatniego żądania.

Istnieje inny problem z plikami cookie, że czasami witryny internetowe często modyfikują pliki cookie bez ostrzeżenia. Z taką sytuacją można sobie poradzićrequests.Session() w następujący sposób -

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)

W powyższym wierszu kodu adres URL będzie stroną, która będzie działać jako procesor dla formularza logowania.

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

Zwróć uwagę, że możesz łatwo zrozumieć różnicę między skryptem z sesją a bez sesji.

Automatyzacja formularzy w Pythonie

W tej sekcji zajmiemy się modułem Pythona o nazwie Mechanize, który ograniczy naszą pracę i zautomatyzuje proces wypełniania formularzy.

Moduł zmechanizowany

Moduł Mechanize zapewnia nam interfejs wysokiego poziomu do interakcji z formularzami. Przed rozpoczęciem korzystania z niego musimy zainstalować go za pomocą następującego polecenia -

pip install mechanize

Zauważ, że działałoby to tylko w Pythonie 2.x.

Przykład

W tym przykładzie zautomatyzujemy proces wypełniania formularza logowania zawierającego dwa pola, a mianowicie adres e-mail i hasło -

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()

Powyższy kod jest bardzo łatwy do zrozumienia. Najpierw zaimportowaliśmy moduł mechanize. Następnie został utworzony obiekt przeglądarki Mechanize. Następnie przeszliśmy do adresu URL logowania i wybraliśmy formularz. Następnie nazwy i wartości są przekazywane bezpośrednio do obiektu przeglądarki.

W tym rozdziale wyjaśnijmy, jak wykonać przeglądanie sieci i przetwarzanie CAPTCHA, które jest używane do testowania użytkownika na obecność człowieka lub robota.

Co to jest CAPTCHA?

Pełna forma CAPTCHA to Completely Automated Public Turing test to tell Computers and Humans Apart, co wyraźnie sugeruje, że jest to test mający na celu określenie, czy użytkownik jest człowiekiem, czy nie.

CAPTCHA to zniekształcony obraz, który zwykle nie jest łatwy do wykrycia przez program komputerowy, ale człowiek może w jakiś sposób go zrozumieć. Większość witryn korzysta z CAPTCHA, aby uniemożliwić botom interakcję.

Ładowanie CAPTCHA za pomocą Pythona

Załóżmy, że chcemy dokonać rejestracji na stronie internetowej i jest formularz z CAPTCHA, a następnie przed załadowaniem obrazu CAPTCHA musimy wiedzieć o konkretnych informacjach wymaganych przez formularz. Przy pomocy kolejnego skryptu w Pythonie możemy zrozumieć wymagania formularza rejestracyjnego na stronie o nazwiehttp://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)

W powyższym skrypcie Pythona najpierw zdefiniowaliśmy funkcję, która przeanalizuje formularz za pomocą modułu lxml python, a następnie wydrukuje wymagania formularza w następujący sposób -

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

Na podstawie powyższych danych wyjściowych możesz sprawdzić, czy wszystkie informacje oprócz recpatcha_response_fieldsą zrozumiałe i proste. Teraz pojawia się pytanie, w jaki sposób możemy obsłużyć te złożone informacje i pobrać CAPTCHA. Można to zrobić za pomocą biblioteki Python poduszek w następujący sposób;

Pakiet Pillow Python

Pillow to rozwidlenie biblioteki obrazów Pythona, które ma przydatne funkcje do manipulowania obrazami. Można go zainstalować za pomocą następującego polecenia -

pip install pillow

W następnym przykładzie użyjemy go do załadowania 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

Powyższy skrypt w Pythonie używa pillowpython i zdefiniowanie funkcji do ładowania obrazu CAPTCHA. Musi być używany z funkcją o nazwieform_parser()to jest zdefiniowane w poprzednim skrypcie do uzyskiwania informacji o formularzu rejestracyjnym. Ten skrypt zapisze obraz CAPTCHA w użytecznym formacie, który można następnie wyodrębnić jako ciąg.

OCR: wyodrębnianie tekstu z obrazu za pomocą Pythona

Po załadowaniu CAPTCHA w użytecznym formacie możemy go wyodrębnić za pomocą optycznego rozpoznawania znaków (OCR), procesu wyodrębniania tekstu z obrazów. W tym celu wykorzystamy silnik Tesseract OCR typu open source. Można go zainstalować za pomocą następującego polecenia -

pip install pytesseract

Przykład

Tutaj rozszerzymy powyższy skrypt Pythona, który załadował CAPTCHA za pomocą pakietu Pillow Python, w następujący sposób -

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')

Powyższy skrypt w Pythonie odczyta CAPTCHA w trybie czarno-białym, który byłby przejrzysty i łatwy do przekazania do tesseraktu w następujący sposób -

pytesseract.image_to_string(bw)

Po uruchomieniu powyższego skryptu otrzymamy CAPTCHA formularza rejestracyjnego jako wyjście.

W tym rozdziale wyjaśniono, jak przeprowadzić testy przy użyciu skrobaków sieci w języku Python.

Wprowadzenie

W dużych projektach internetowych automatyczne testowanie zaplecza witryny jest wykonywane regularnie, ale testy frontendu są często pomijane. Głównym powodem takiego stanu rzeczy jest to, że programowanie stron internetowych przypomina sieć różnych języków znaczników i języków programowania. Możemy napisać testy jednostkowe dla jednego języka, ale staje się to trudne, jeśli interakcja odbywa się w innym języku. Dlatego musimy mieć zestaw testów, aby upewnić się, że nasz kod działa zgodnie z naszymi oczekiwaniami.

Testowanie w Pythonie

Kiedy mówimy o testowaniu, oznacza to testowanie jednostkowe. Zanim zagłębimy się w testowanie w Pythonie, musimy wiedzieć o testowaniu jednostkowym. Oto niektóre cechy testów jednostkowych:

Przynajmniej jeden aspekt funkcjonalności komponentu byłby testowany w każdym teście jednostkowym.
Każdy test jednostkowy jest niezależny i może również działać niezależnie.
Test jednostkowy nie koliduje z sukcesem ani porażką żadnego innego testu.
Testy jednostkowe mogą być uruchamiane w dowolnej kolejności i muszą zawierać co najmniej jedno potwierdzenie.

Unittest - moduł Pythona

Moduł Pythona o nazwie Unittest do testów jednostkowych jest dostarczany ze wszystkimi standardowymi instalacjami Pythona. Wystarczy go zaimportować, a resztą zajmie się klasa unittest.TestCase, która wykona następujące czynności -

Funkcje SetUp i tearDown są udostępniane przez klasę unittest.TestCase. Te funkcje mogą być uruchamiane przed i po każdym teście jednostkowym.
Zawiera również instrukcje assert, które pozwalają testom przejść lub nie.
Uruchamia wszystkie funkcje, które zaczynają się od test_ jako test jednostkowy.

Przykład

W tym przykładzie zamierzamy połączyć skrobanie sieci z unittest. Przetestujemy stronę Wikipedii pod kątem wyszukiwania ciągu „Python”. Zasadniczo wykona dwa testy, najpierw czy strona tytułowa jest taka sama jak szukany ciąg, tj. „Python” lub nie, a drugi test upewnia się, że strona zawiera element div z treścią.

Najpierw zaimportujemy wymagane moduły Pythona. Używamy BeautifulSoup do skrobania stron internetowych i oczywiście niestety do testowania.

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

Teraz musimy zdefiniować klasę, która będzie rozszerzać unittest.TestCase. Globalne obiekty b byłyby współużytkowane przez wszystkie testy. Dokonuje tego unittest określona funkcja setUpClass. Tutaj zdefiniujemy dwie funkcje, jedną do testowania strony tytułowej, a drugą do testowania zawartości strony.

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()

Po uruchomieniu powyższego skryptu otrzymamy następujący wynik -

----------------------------------------------------------------------
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)

Testowanie z selenem

Omówmy, jak używać Python Selenium do testowania. Nazywa się to również testowaniem selenu. Zarówno Pythonunittest i Seleniumnie mają ze sobą wiele wspólnego. Wiemy, że Selenium wysyła standardowe polecenia Pythona do różnych przeglądarek, pomimo różnic w projekcie ich przeglądarek. Przypomnij sobie, że już zainstalowaliśmy Selenium i pracowaliśmy z nim w poprzednich rozdziałach. Tutaj stworzymy skrypty testowe w Selenium i wykorzystamy je do automatyzacji.

Przykład

Z pomocą kolejnego skryptu w Pythonie tworzymy skrypt testowy do automatyzacji strony logowania na Facebooku. Możesz zmodyfikować przykład automatyzacji innych wybranych formularzy i loginów, jednak koncepcja byłaby taka sama.

Najpierw do połączenia z przeglądarką internetową zaimportujemy webdriver z modułu selenium -

from selenium import webdriver

Teraz musimy zaimportować klucze z modułu selenu.

from selenium.webdriver.common.keys import Keys

Następnie musimy podać nazwę użytkownika i hasło, aby zalogować się do naszego konta na Facebooku

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

Następnie podaj ścieżkę do sterownika internetowego dla przeglądarki Chrome.

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

Teraz zweryfikujemy warunki za pomocą słowa kluczowego assert.

assert "Facebook" in driver.title

Za pomocą następującego wiersza kodu wysyłamy wartości do sekcji e-mail. Tutaj szukamy go według identyfikatora, ale możemy to zrobić, wyszukując go według nazwy jakodriver.find_element_by_name("email").

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

Za pomocą następującego wiersza kodu przesyłamy wartości do sekcji hasła. Tutaj szukamy go według identyfikatora, ale możemy to zrobić, wyszukując go według nazwy jakodriver.find_element_by_name("pass").

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

Kolejna linia kodu służy do naciśnięcia klawisza enter / login po wprowadzeniu wartości w polu adresu e-mail i hasła.

element.send_keys(Keys.RETURN)

Teraz zamkniemy przeglądarkę.

driver.close()

Po uruchomieniu powyższego skryptu otworzy się przeglądarka internetowa Chrome i zobaczysz, że e-mail i hasło są wstawiane i klikane w przycisk logowania.

Porównanie: unittest lub Selenium

Porównanie unittest i selenu jest trudne, ponieważ jeśli chcesz pracować z dużymi zestawami testów, wymagana jest syntaktyczna sztywność jednostek. Z drugiej strony, jeśli zamierzasz przetestować elastyczność witryny, to test Selenium byłby naszym pierwszym wyborem. Ale co, jeśli uda nam się połączyć oba. Możemy zaimportować selen do Python unittest i uzyskać najlepsze z obu. Selen może służyć do uzyskiwania informacji o witrynie, a unittest może ocenić, czy informacje te spełniają kryteria zdania testu, czy nie.

Na przykład przepisujemy powyższy skrypt Pythona do automatyzacji logowania na Facebooku, łącząc oba w następujący sposób -

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()