TOC

Arbeiten mit Webdaten mit Requests und Beautiful Soup mit Python 3

Einführung

Das Web liefert uns mehr Daten, als jeder von uns lesen und verstehen kann. Daher möchten wir häufig programmgesteuert mit diesen Informationen arbeiten, um einen Sinn daraus zu ziehen. Gelegentlich werden uns diese Daten von Website-Erstellern über "+ .csv +" oder durch Kommas getrennte Wertedateien oder über eine API (Application Programming Interface) zur Verfügung gestellt. In anderen Fällen müssen wir selbst Text aus dem Web sammeln.

In diesem Tutorial erfahren Sie, wie Sie mit den Python-Paketen Requests und Beautiful Soup arbeiten um Daten von Webseiten zu nutzen. Mit dem Anforderungsmodul können Sie Ihre Python-Programme in Webdienste integrieren, während mit dem Beautiful Soup-Modul das Scrapen von Bildschirmen schnell erledigt werden soll. Mit der interaktiven Python-Konsole und diesen beiden Bibliotheken erfahren Sie, wie Sie eine Webseite sammeln und mit den dort verfügbaren Textinformationen arbeiten.

Voraussetzungen

Um dieses Tutorial abzuschließen, benötigen Sie eine Entwicklungsumgebung für Python 3. Sie können dem entsprechenden Handbuch für Ihr Betriebssystem folgen, das unter https://www.digitalocean.com/community/tutorial_series/how-to-install-and-set-up-a-local-programming-environment-for- verfügbar ist. python-3 [So installieren und konfigurieren Sie eine lokale Programmierumgebung für Python 3] oder https://www.digitalocean.com/community/tutorials/how-to-install-python-3-and-set-up-a -Programmierumgebung-auf-einem-Ubuntu-16-04-Server [So installieren Sie Python 3 und richten eine Programmierumgebung auf einem Ubuntu 16.04-Server ein], um alles zu konfigurieren, was Sie benötigen.

Darüber hinaus sollten Sie mit Folgendem vertraut sein:

Beginnen wir mit der Arbeit mit Requests und Beautiful Soup, wenn Ihre Entwicklungsumgebung eingerichtet ist und Sie diese Python-Programmierkonzepte berücksichtigen.

Anfragen installieren

Beginnen wir mit der Aktivierung unserer Python 3-Programmierumgebung. Stellen Sie sicher, dass Sie sich in dem Verzeichnis befinden, in dem sich Ihre Umgebung befindet, und führen Sie den folgenden Befehl aus:

. /bin/activate

Um mit Webseiten arbeiten zu können, müssen wir die Seite anfordern. Mit der Requests-Bibliothek können Sie HTTP in Ihren Python-Programmen auf eine für Menschen lesbare Weise verwenden.

Bei aktivierter Programmierumgebung installieren wir Requests mit pip:

pip install requests

Während der Installation der Requests-Bibliothek erhalten Sie folgende Ausgabe:

OutputCollecting requests
 Downloading requests-2.18.1-py2.py3-none-any.whl (88kB)
   100% |████████████████████████████████| 92kB 3.1MB/s
...
Installing collected packages: chardet, urllib3, certifi, idna, requests
Successfully installed certifi-2017.4.17 chardet-3.0.4 idna-2.5 requests-2.18.1 urllib3-1.21.1

Wenn Requests zuvor installiert worden wäre, hätten Sie von Ihrem Terminalfenster eine ähnliche Rückmeldung erhalten:

OutputRequirement already satisfied
...

Wenn Requests in unserer Programmierumgebung installiert ist, können wir mit der Installation des nächsten Moduls fortfahren.

Schöne Suppe installieren

Genau wie bei Requests installieren wir Beautiful Soup mit pip. Die aktuelle Version von Beautiful Soup 4 kann mit dem folgenden Befehl installiert werden:

pip install beautifulsoup4

Sobald Sie diesen Befehl ausführen, sollte eine Ausgabe angezeigt werden, die der folgenden ähnelt:

OutputCollecting beautifulsoup4
 Downloading beautifulsoup4-4.6.0-py3-none-any.whl (86kB)
   100% |████████████████████████████████| 92kB 4.4MB/s
Installing collected packages: beautifulsoup4
Successfully installed beautifulsoup4-4.6.0

Nachdem sowohl Beautiful Soup als auch Requests installiert sind, lernen wir, wie man mit den Bibliotheken arbeitet, um Websites zu durchsuchen.

Sammeln einer Webseite mit Anfragen

Mit den beiden Python-Bibliotheken, die wir jetzt verwenden, können wir uns mit dem Durchlaufen einer einfachen Webseite vertraut machen.

Wechseln wir zunächst in die https://www.digitalocean.com/community/tutorials/wie-mit-der-python-interaktiven-Konsole-arbeiten]:

python

Von hier aus importieren wir das Anforderungsmodul, damit wir eine Beispielwebseite sammeln können:

import requests

Wir weisen der https://www.digitalocean.com/community/tutorials/how-to-use-variables-in-python-3 die URL (unten) der Beispielwebseite "+ mockturtle.html " zu [variable] ` url +`:

url = 'https://assets.digitalocean.com/articles/eng_python/beautiful-soup/mockturtle.html'

Als nächstes können wir das Ergebnis einer Anfrage dieser Seite der Variablen "+ page " mit der URL http://docs.python-requests.org/en/master/user/quickstart/#make-a-request [`zuweisen + request.get () + `Methode]. Wir übergeben die URL der Seite (die der Variablen " url +" zugewiesen wurde) an diese Methode.

page = requests.get(url)

Der Variablen "+ Seite +" wird ein Antwortobjekt zugewiesen:

>>> page
<Response [200]>
>>>

Das Response-Objekt oben gibt die Eigenschaft "+ status_code " in eckigen Klammern an (in diesem Fall " 200 +"). Dieses Attribut kann explizit aufgerufen werden:

>>> page.status_code
200
>>>

Der zurückgegebene Code von "+ 200 " teilt uns mit, dass die Seite erfolgreich heruntergeladen wurde. Codes, die mit der Zahl " 2 " beginnen, zeigen im Allgemeinen den Erfolg an, während Codes, die mit " 4 " oder " 5 +" beginnen, anzeigen, dass ein Fehler aufgetreten ist. Weitere Informationen zu HTTP-Statuscodes finden Sie unter W3Cs Statuscode-Definitionen.

Um mit Webdaten arbeiten zu können, möchten wir auf den textbasierten Inhalt von Webdateien zugreifen. Wir können den Inhalt der Serverantwort mit "+ page.text" lesen (auf "+ page.content", wenn wir auf die Antwort in Bytes zugreifen möchten).

page.text

Sobald wir "+ ENTER +" drücken, erhalten wir die folgende Ausgabe:

Output'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"\n
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">\n\n<html lang="en-US"
xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">\n<head>\n  <meta
http-equiv="content-type" content="text/html; charset=us-ascii" />\n\n  <title>Turtle
Soup</title>\n</head>\n\n<body>\n  <h1>Turtle Soup</h1>\n\n  <p class="verse"
id="first">Beautiful Soup, so rich and green,<br />\n  Waiting in a hot tureen!<br />\n  Who for
such dainties would not stoop?<br />\n  Soup of the evening, beautiful Soup!<br />\n  Soup of
the evening, beautiful Soup!<br /></p>\n\n  <p class="chorus" id="second">Beau--ootiful
Soo--oop!<br />\n  Beau--ootiful Soo--oop!<br />\n  Soo--oop of the e--e--evening,<br />\n
Beautiful, beautiful Soup!<br /></p>\n\n  <p class="verse" id="third">Beautiful Soup! Who cares
for fish,<br />\n  Game or any other dish?<br />\n  Who would not give all else for two<br />\n
Pennyworth only of Beautiful Soup?<br />\n  Pennyworth only of beautiful Soup?<br /></p>\n\n
<p class="chorus" id="fourth">Beau--ootiful Soo--oop!<br />\n  Beau--ootiful Soo--oop!<br />\n
Soo--oop of the e--e--evening,<br />\n  Beautiful, beauti--FUL SOUP!<br
/></p>\n</body>\n</html>\n'
>>>

Hier sehen wir, dass der vollständige Text der Seite mit allen HTML-Tags ausgedruckt wurde. Es ist jedoch schwierig zu lesen, da der Abstand nicht groß ist.

Im nächsten Abschnitt können wir das Beautiful Soup-Modul nutzen, um mit diesen Textdaten auf menschlichere Weise zu arbeiten.

Eine Seite mit schöner Suppe durchgehen

Die Bibliothek Beautiful Soup erstellt einen Analysebaum aus analysierten HTML- und XML-Dokumenten (einschließlich Dokumenten mit nicht geschlossenen Tags oder tag soup und anderen fehlerhaften Markups). Durch diese Funktion wird der Text der Webseite besser lesbar als im Anforderungsmodul.

Zunächst importieren wir Beautiful Soup in die Python-Konsole:

from bs4 import BeautifulSoup

Als Nächstes führen wir das Dokument + page.text + durch das Modul, um ein Objekt + BeautifulSoup + zu erhalten - das heißt, einen Analysebaum von dieser analysierten Seite, den wir durch Ausführen von Pythons integriertem https erhalten: //docs.python.org/3/library/html.parser.html [+ html.parser +] über den HTML-Code. Das konstruierte Objekt repräsentiert das Dokument + mockturtle.html + als verschachtelte Datenstruktur. Dies wird der Variablen "+ soup +" zugewiesen.

soup = BeautifulSoup(page.text, 'html.parser')

Um den Inhalt der Seite auf dem Terminal anzuzeigen, können wir ihn mit der Methode + prettify () + drucken, um den Syntaxanalysebaum von Beautiful Soup in eine schön formatierte Unicode-Zeichenfolge umzuwandeln.

print(soup.prettify())

Dadurch wird jedes HTML-Tag in einer eigenen Zeile dargestellt:

Output<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html lang="en-US" xml:lang="en-US" xmlns="http://www.w3.org/1999/xhtml">
<head>
 <meta content="text/html; charset=utf-8" http-equiv="content-type"/>
 <title>
  Turtle Soup
 </title>
</head>
<body>
 <h1>
  Turtle Soup
 </h1>
 <p class="verse" id="first">
  Beautiful Soup, so rich and green,
  <br/>
  Waiting in a hot tureen!
  <br/>
  Who for such dainties would not stoop?
  <br/>
  Soup of the evening, beautiful Soup!
...
</html>

In der obigen Ausgabe sehen wir, dass es ein Tag pro Zeile gibt und dass die Tags aufgrund des von Beautiful Soup verwendeten Baumschemas verschachtelt sind.

Suchen von Instanzen eines Tags

Mit der + find_all + - Methode von Beautiful Soup können wir ein einzelnes Tag aus einer Seite extrahieren. Dadurch werden alle Instanzen eines bestimmten Tags in einem Dokument zurückgegeben.

soup.find_all('p')

Wenn Sie diese Methode für unser Objekt ausführen, wird der vollständige Text des Songs zusammen mit den relevanten + <p> + - Tags und allen in diesem angeforderten Tag enthaltenen Tags zurückgegeben, einschließlich der Zeilenumbruch-Tags + <br/> +:

Output[<p class="verse" id="first">Beautiful Soup, so rich and green,<br/>
 Waiting in a hot tureen!<br/>
 Who for such dainties would not stoop?<br/>
 Soup of the evening, beautiful Soup!<br/>
 Soup of the evening, beautiful Soup!<br/></p>, <p class="chorus" id="second">Beau--ootiful Soo--oop!<br/>
...
 Beau--ootiful Soo--oop!<br/>
 Soo--oop of the e--e--evening,<br/>
 Beautiful, beauti--FUL SOUP!<br/></p>]

Sie werden in der obigen Ausgabe feststellen, dass die Daten in eckigen Klammern + [] + stehen. Dies bedeutet, dass es sich um einen Python-https://www.digitalocean.com/community/tutorials/understanding-lists-in-python-3[list-Datentyp handelt.

Da es sich um eine Liste handelt, können wir ein bestimmtes Element darin aufrufen (z. B. das dritte "+ <p> " - Element) und die Methode " get_text () +" verwenden, um den gesamten Text aus diesem Tag zu extrahieren :

soup.find_all('p')[2].get_text()

Die Ausgabe, die wir erhalten, ist in diesem Fall das, was sich im dritten "+ <p> +" - Element befindet:

Output'Beautiful Soup! Who cares for fish,\n  Game or any other dish?\n  Who would not give all else for two\n  Pennyworth only of Beautiful Soup?\n  Pennyworth only of beautiful Soup?'

Beachten Sie, dass in der oben zurückgegebenen Zeichenfolge auch "+ \ n +" Zeilenumbrüche angezeigt werden.

Tags nach Klasse und ID suchen

HTML-Elemente, die auf CSS-Selektoren wie class und ID verweisen, können hilfreich sein, wenn Sie mit Beautiful Soup mit Webdaten arbeiten. Wir können auf bestimmte Klassen und IDs abzielen, indem wir die Methode + find_all () + verwenden und die Zeichenfolgen class und ID als Argumente übergeben.

Lassen Sie uns zunächst alle Instanzen der Klasse "+ chorus " finden. In Beautiful Soup weisen wir die Zeichenfolge für die Klasse dem Schlüsselwortargument " class_ +" zu:

soup.find_all(class_='chorus')

Wenn wir die obige Zeile ausführen, erhalten wir die folgende Liste als Ausgabe:

Output[<p class="chorus" id="second">Beau--ootiful Soo--oop!<br/>
 Beau--ootiful Soo--oop!<br/>
 Soo--oop of the e--e--evening,<br/>
 Beautiful, beautiful Soup!<br/></p>, <p class="chorus" id="fourth">Beau--ootiful Soo--oop!<br/>
 Beau--ootiful Soo--oop!<br/>
 Soo--oop of the e--e--evening,<br/>
 Beautiful, beauti--FUL SOUP!<br/></p>]

Die beiden mit + <p> + gekennzeichneten Abschnitte mit der Klasse + chorus + wurden auf dem Terminal ausgedruckt.

Wir können auch angeben, dass wir nach der Klasse + chorus + nur innerhalb von + <p> + Tags suchen möchten, falls sie für mehr als ein Tag verwendet wird:

soup.find_all('p', class_='chorus')

Wenn Sie die obige Zeile ausführen, wird dieselbe Ausgabe wie zuvor erzeugt.

Wir können Beautiful Soup auch für IDs verwenden, die mit HTML-Tags verknüpft sind. In diesem Fall ordnen wir dem Schlüsselwortargument "+ id " die Zeichenfolge "" drittes "+" zu:

soup.find_all(id='third')

Sobald wir die obige Zeile ausführen, erhalten wir die folgende Ausgabe:

Output[<p class="verse" id="third">Beautiful Soup! Who cares for fish,<br/>
 Game or any other dish?<br/>
 Who would not give all else for two<br/>
 Pennyworth only of Beautiful Soup?<br/>
 Pennyworth only of beautiful Soup?<br/></p>]

Der dem Tag "+ <p> " zugeordnete Text mit der ID " drittes +" wird zusammen mit den entsprechenden Tags an das Terminal ausgegeben.

Fazit

In diesem Lernprogramm haben Sie eine Webseite mit dem Anforderungsmodul in Python abgerufen und einige vorläufige Scrap-Vorgänge für die Textdaten dieser Webseite durchgeführt, um ein besseres Verständnis für Beautiful Soup zu erlangen.

Von hier aus können Sie ein Web-Scraping-Programm erstellen, das aus den im Web gesammelten Daten eine CSV-Datei erstellt. Folgen Sie dazu dem Tutorial https://www.digitalocean.com/community/tutorials/how-to-scrape- Webseiten-mit-schöner-Suppe-und-Python-3 [Wie man Webseiten mit schöner Suppe und Python 3 kratzt].

Related