Website-Suche

Wie man Webseiten mit Beautiful Soup und Python 3 scrapt

Einführung

Viele Datenanalysen, Big-Data- und Machine-Learning-Projekte erfordern das Scrapen von Websites, um die Daten zu sammeln, mit denen Sie arbeiten werden. Die Programmiersprache Python wird in der Datenwissenschaftsgemeinschaft weit verbreitet und hat daher ein Ökosystem von Modulen und Werkzeugen, die Sie in Ihren eigenen Projekten verwenden können. In diesem Tutorial werden wir uns auf das Beautiful Soup-Modul konzentrieren.

Beautiful Soup, eine Anspielung auf das Lied der Mock Turtle aus Kapitel 10 von Lewis Carrolls Alices Abenteuer im Wunderland, ist eine Python-Bibliothek, die eine schnelle Umsetzung von Web-Scraping-Projekten ermöglicht. Derzeit in der Version Beautiful Soup 4 verfügbar und kompatibel mit sowohl Python 2.7 als auch Python 3, erstellt Beautiful Soup einen Parse-Baum aus geparsten HTML- und XML-Dokumenten (einschließlich Dokumenten mit nicht geschlossenen Tags oder Tag-Suppe und anderem fehlerhaften Markup).

In diesem Tutorial werden wir eine Webseite sammeln und parsen, um Textdaten zu erfassen und die gesammelten Informationen in eine CSV-Datei zu schreiben.

Voraussetzungen

Bevor Sie mit diesem Tutorial beginnen, sollten Sie eine lokale oder serverbasierte Python-Programmierumgebung auf Ihrem Computer eingerichtet haben.

Sie sollten die Module Requests und Beautiful Soup installiert haben, was Sie erreichen können, indem Sie unser Tutorial „Wie man mit Webdaten mit Requests und Beautiful Soup in Python 3 arbeitet“ befolgen. Es wäre auch nützlich, eine gewisse Vertrautheit mit diesen Modulen zu haben.

Zusätzlich sollten Sie, da wir mit aus dem Internet gesammelten Daten arbeiten werden, mit der HTML-Struktur und -Tagging vertraut sein.

Das Verständnis der Daten

In diesem Tutorial werden wir mit Daten von der offiziellen Website der National Gallery of Art in den Vereinigten Staaten arbeiten. Die National Gallery ist ein Kunstmuseum, das sich auf dem National Mall in Washington, D.C. befindet. Sie beherbergt über 120.000 Werke, die vom Renaissance bis zur Gegenwart stammen und von mehr als 13.000 Künstlern geschaffen wurden.

Wir möchten das Verzeichnis der Künstler durchsuchen, das zum Zeitpunkt der Aktualisierung dieses Tutorials über die Wayback Machine des Internet Archive unter folgender URL verfügbar ist:

https://web.archive.org/web/20170131230332/https://www.nga.gov/collection/an.shtm

Hinweis: Die lange URL oben liegt daran, dass diese Website vom Internet Archive archiviert wurde.

Das Internet Archive ist eine gemeinnützige digitale Bibliothek, die kostenlosen Zugang zu Internetseiten und anderen digitalen Medien bietet. Diese Organisation macht Schnappschüsse von Websites, um die Geschichte der Seiten zu bewahren, und wir können derzeit auf eine ältere Version der Website der National Gallery zugreifen, die verfügbar war, als dieses Tutorial zum ersten Mal geschrieben wurde. Das Internet Archive ist ein hilfreiches Werkzeug, das man im Hinterkopf behalten sollte, wenn man historische Daten scrapen möchte, einschließlich des Vergleichs von Iterationen derselben Website und der verfügbaren Daten.

Unter der Kopfzeile des Internet Archives sehen Sie eine Seite, die so aussieht:

Da wir dieses Projekt durchführen werden, um über Web-Scraping mit Beautiful Soup zu lernen, müssen wir nicht zu viele Daten von der Seite abrufen, also lassen Sie uns den Umfang der Künstlerinformationen, die wir scrapen möchten, einschränken. Lassen Sie uns daher einen Buchstaben auswählen — in unserem Beispiel wählen wir den Buchstaben Z — und wir werden eine Seite sehen, die so aussieht:

In der obigen Seite sehen wir, dass der erste Künstler, der zum Zeitpunkt des Schreibens aufgeführt ist, Zabaglia, Niccola ist, was wichtig ist, um es zu beachten, wenn wir anfangen, Daten zu ziehen. Wir werden mit dieser ersten Seite arbeiten, mit der folgenden URL für den Buchstaben Z:.

https://web.archive.org/web/20121007172955/http://www.nga.gov/collection/anZ1.htm

Es ist wichtig, sich für später zu notieren, wie viele Seiten es insgesamt für den Brief gibt, den Sie auswählen möchten, was Sie herausfinden können, indem Sie zur letzten Seite der Künstler klicken. In diesem Fall gibt es insgesamt 4 Seiten, und der zuletzt aufgelistete Künstler zum Zeitpunkt des Schreibens ist Zykmund, Václav. Die letzte Seite der Z Künstler hat die folgende URL:

https://web.archive.org/web/20121010201041/http://www.nga.gov/collection/anZ4.htm

Allerdings können Sie die obige Seite auch aufrufen, indem Sie die gleiche numerische Zeichenfolge des Internet Archive von der ersten Seite verwenden:

https://web.archive.org/web/20121007172955/http://www.nga.gov/collection/anZ4.htm

Es ist wichtig zu beachten, da wir später in diesem Tutorial durch diese Seiten iterieren werden.

Um sich mit der Struktur dieser Webseite vertraut zu machen, können Sie sich ihr DOM ansehen, was Ihnen hilft zu verstehen, wie das HTML aufgebaut ist. Um das DOM zu inspizieren, können Sie die Entwicklertools Ihres Browsers öffnen.

Die Bibliotheken importieren

Um unser Code-Projekt zu beginnen, lassen Sie uns unsere Python 3-Programmierumgebung aktivieren. Stellen Sie sicher, dass Sie sich im Verzeichnis befinden, in dem sich Ihre Umgebung befindet, und führen Sie den folgenden Befehl aus:

  1. . my_env/bin/activate

Mit unserer aktivierten Programmierumgebung erstellen wir eine neue Datei, zum Beispiel mit nano. Du kannst deine Datei benennen, wie du möchtest, wir werden sie in diesem Tutorial nga_z_artists.py nennen.

  1. nano nga_z_artists.py

In dieser Datei können wir beginnen, die Bibliotheken zu importieren, die wir verwenden werden – Requests und Beautiful Soup.

Die Requests-Bibliothek ermöglicht es Ihnen, HTTP in Ihren Python-Programmen auf eine menschenlesbare Weise zu nutzen, und das Beautiful Soup-Modul wurde entwickelt, um Web-Scraping schnell durchzuführen.

Wir werden sowohl Requests als auch Beautiful Soup mit der import-Anweisung importieren. Für Beautiful Soup werden wir es aus bs4 importieren, dem Paket, in dem Beautiful Soup 4 zu finden ist.

Import libraries
import requests
from bs4 import BeautifulSoup

Nachdem wir sowohl die Module Requests als auch Beautiful Soup importiert haben, können wir damit beginnen, eine Seite zu sammeln und sie dann zu analysieren.

Das Sammeln und Parsen einer Webseite

Der nächste Schritt, den wir machen müssen, besteht darin, die URL der ersten Webseite mit Requests zu sammeln. Wir werden die URL für die erste Seite der Variable page zuweisen, indem wir die Methode requests.get() verwenden.

import requests
from bs4 import BeautifulSoup


Collect first page of artists’ list
page = requests.get('https://web.archive.org/web/20121007172955/https://www.nga.gov/collection/anZ1.htm')

Hinweis: Da die URL lang ist, wird der obige Code und der gesamte Code in diesem Tutorial nicht die PEP 8 E501 Regel bestehen, die Zeilen länger als 79 Zeichen kennzeichnet. Sie sollten die URL möglicherweise einer Variablen zuweisen, um den Code in den endgültigen Versionen lesbarer zu machen. Der Code in diesem Tutorial dient Demonstrationszwecken und ermöglicht es Ihnen, kürzere URLs im Rahmen Ihrer eigenen Projekte auszutauschen.

Wir werden jetzt ein BeautifulSoup-Objekt oder einen Parse-Baum erstellen. Dieses Objekt nimmt als Argumente das page.text-Dokument von Requests (den Inhalt der Serverantwort) und analysiert es mit dem integrierten html.parser von Python.

import requests
from bs4 import BeautifulSoup


page = requests.get('https://web.archive.org/web/20121007172955/https://www.nga.gov/collection/anZ1.htm')

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

Nachdem unsere Seite gesammelt, analysiert und als BeautifulSoup-Objekt eingerichtet wurde, können wir mit dem Sammeln der Daten fortfahren, die wir gerne hätten.

Text von einer Webseite abrufen

Für dieses Projekt werden wir die Namen der Künstler und die relevanten Links auf der Website sammeln. Möglicherweise möchten Sie andere Daten sammeln, wie die Nationalität der Künstler und deren Geburtsdaten. Welche Daten Sie auch immer sammeln möchten, Sie müssen herausfinden, wie sie im DOM der Webseite beschrieben sind.

Um dies zu tun, klicken Sie mit der rechten Maustaste in Ihrem Webbrowser — oder CTRL + Klicken auf macOS — auf den Namen des ersten Künstlers, Zabaglia, Niccola. Im Kontextmenü, das erscheint, sollten Sie einen Menüeintrag ähnlich Element untersuchen (Firefox) oder Untersuchen (Chrome) sehen.

Sobald Sie auf den entsprechenden Untersuchen-Menüpunkt klicken, sollten die Werkzeuge für Webentwickler in Ihrem Browser erscheinen. Wir wollen nach der Klasse und den Tags suchen, die mit den Namen der Künstler in dieser Liste verbunden sind.

Zunächst werden wir feststellen, dass die Tabelle der Namen innerhalb von <div>-Tags mit class="BodyText" liegt. Dies ist wichtig zu beachten, damit wir nur nach Text innerhalb dieses Abschnitts der Webseite suchen. Wir bemerken auch, dass der Name Zabaglia, Niccola in einem Link-Tag steht, da der Name auf eine Webseite verweist, die den Künstler beschreibt. Daher werden wir das <a>-Tag für Links berücksichtigen. Der Name jedes Künstlers verweist auf einen Link.

Dafür verwenden wir die Methoden find() und find_all() von Beautiful Soup, um den Text der Künstlernamen aus dem BodyText <div> zu extrahieren.

import requests
from bs4 import BeautifulSoup


Collect and parse first page
page = requests.get('https://web.archive.org/web/20121007172955/https://www.nga.gov/collection/anZ1.htm')
soup = BeautifulSoup(page.text, 'html.parser')

Pull all text from the BodyText div
artist_name_list = soup.find(class_='BodyText')

Pull text from all instances of <a> tag within BodyText div
artist_name_list_items = artist_name_list.find_all('a')

Als nächstes werden wir am Ende unserer Programmdatei eine for-Schleife erstellen, um über alle Künstlernamen zu iterieren, die wir gerade in die Variable artist_name_list_items eingefügt haben.

Wir werden diese Namen mit der prettify() Methode ausdrucken, um den Beautiful Soup Parse-Baum in einen schön formatierten Unicode-String zu verwandeln.

...
artist_name_list = soup.find(class_='BodyText')
artist_name_list_items = artist_name_list.find_all('a')

Create for loop to print out all artists' names
for artist_name in artist_name_list_items:
    print(artist_name.prettify())

Lass uns das Programm so ausführen, wie wir es bisher haben:

  1. python nga_z_artists.py

Sobald wir das tun, erhalten wir die folgende Ausgabe:

<a href="/web/20121007172955/https://www.nga.gov/cgi-bin/tsearch?artistid=11630">
 Zabaglia, Niccola
</a>
...
<a href="/web/20121007172955/https://www.nga.gov/cgi-bin/tsearch?artistid=3427">
 Zao Wou-Ki
</a>
<a href="/web/20121007172955/https://www.nga.gov/collection/anZ2.htm">
 Zas-Zie
</a>

<a href="/web/20121007172955/https://www.nga.gov/collection/anZ3.htm">
 Zie-Zor
</a>

<a href="/web/20121007172955/https://www.nga.gov/collection/anZ4.htm">
 <strong>
  next
  <br/>
  page
 </strong>
</a>

Was wir zu diesem Zeitpunkt im Output sehen, ist der vollständige Text und die Tags zu allen Künstlernamen innerhalb der <a>-Tags, die im <div class="BodyText">-Tag auf der ersten Seite gefunden wurden, sowie einige zusätzliche Linktexte am Ende. Da wir diese zusätzliche Information nicht möchten, lassen Sie uns im nächsten Abschnitt daran arbeiten, dies zu entfernen.

Entfernen überflüssiger Daten

Bisher konnten wir alle Linktextdaten innerhalb eines <div>-Abschnitts unserer Webseite sammeln. Wir möchten jedoch die unteren Links, die nicht auf die Namen von Künstlern verweisen, nicht haben, also sollten wir daran arbeiten, diesen Teil zu entfernen.

Um die unteren Links der Seite zu entfernen, klicken wir erneut mit der rechten Maustaste und untersuchen das DOM. Wir werden sehen, dass die Links am Ende des <div class="BodyText">-Bereichs in einer HTML-Tabelle enthalten sind: <table class="AlphaNav">.

Wir können daher Beautiful Soup verwenden, um die AlphaNav-Klasse zu finden und die decompose()-Methode zu verwenden, um ein Tag aus dem Parse-Baum zu entfernen und es zusammen mit seinen Inhalten zu zerstören.

Wir werden die Variable last_links verwenden, um auf diese unteren Links zu verweisen und sie zur Programmdaten-Datei hinzuzufügen:

import requests
from bs4 import BeautifulSoup


page = requests.get('https://web.archive.org/web/20121007172955/https://www.nga.gov/collection/anZ1.htm')

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

Remove bottom links
last_links = soup.find(class_='AlphaNav')
last_links.decompose()

artist_name_list = soup.find(class_='BodyText')
artist_name_list_items = artist_name_list.find_all('a')

for artist_name in artist_name_list_items:
    print(artist_name.prettify())

Jetzt, wenn wir das Programm mit dem Befehl python nga_z_artist.py ausführen, erhalten wir die folgende Ausgabe:

<a href="/web/20121007172955/https://www.nga.gov/cgi-bin/tsearch?artistid=11630">
 Zabaglia, Niccola
</a>
<a href="/web/20121007172955/https://www.nga.gov/cgi-bin/tsearch?artistid=34202">
 Zaccone, Fabian
</a>
...
<a href="/web/20121007172955/http://www.nga.gov/cgi-bin/tsearch?artistid=11631">
 Zanotti, Giampietro
</a>
<a href="/web/20121007172955/http://www.nga.gov/cgi-bin/tsearch?artistid=3427">
 Zao Wou-Ki
</a>

An diesem Punkt sehen wir, dass die Ausgabe die Links am Ende der Webseite nicht mehr enthält und jetzt nur noch die Links anzeigt, die mit den Namen der Künstler verbunden sind.

Bis jetzt haben wir die Links mit den Namen der Künstler gezielt angesprochen, aber wir haben die zusätzlichen Tag-Daten, die wir nicht wirklich wollen. Lass uns das im nächsten Abschnitt entfernen.

Den Inhalt aus einem Tag ziehen

Um nur die tatsächlichen Namen der Künstler abzurufen, möchten wir den Inhalt der <a>-Tags anvisieren, anstatt den gesamten Link-Tag auszugeben.

Wir können dies mit Beautiful Soup's .contents tun, das die Kinder des Tags als eine Python-Liste zurückgibt.

Lass uns die for-Schleife überarbeiten, sodass wir anstelle des gesamten Links und seines Tags die Liste der Kinder (d.h. die vollständigen Namen der Künstler) ausgeben.

import requests
from bs4 import BeautifulSoup


page = requests.get('https://web.archive.org/web/20121007172955/https://www.nga.gov/collection/anZ1.htm')

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

last_links = soup.find(class_='AlphaNav')
last_links.decompose()

artist_name_list = soup.find(class_='BodyText')
artist_name_list_items = artist_name_list.find_all('a')

Use .contents to pull out the <a> tag’s children
for artist_name in artist_name_list_items:
    names = artist_name.contents[0]
    print(names)

Bitte beachten Sie, dass wir die obige Liste durch Aufrufen der Indexnummer jedes Elements durchlaufen.

Wir können das Programm mit dem python-Befehl ausführen, um die folgende Ausgabe zu sehen:

Zabaglia, Niccola
Zaccone, Fabian
Zadkine, Ossip
...
Zanini-Viola, Giuseppe
Zanotti, Giampietro
Zao Wou-Ki

Wir haben eine Liste aller Künstlernamen erhalten, die auf der ersten Seite des Buchstabens Z verfügbar sind.

Was ist jedoch, wenn wir auch die URLs erfassen möchten, die mit diesen Künstlern verbunden sind? Wir können die in den <a>-Tags einer Seite gefundenen URLs extrahieren, indem wir die get('href')-Methode von Beautiful Soup verwenden.

Aus den Ergebnissen der obigen Links wissen wir, dass die gesamte URL nicht erfasst wird, daher werden wir den Link-String mit dem Anfang des URL-Strings verketten (in diesem Fall https://web.archive.org/).

Diese Zeilen werden wir auch in die for-Schleife einfügen:

...
for artist_name in artist_name_list_items:
    names = artist_name.contents[0]
    links = 'https://web.archive.org' + artist_name.get('href')
    print(names)
    print(links)

Wenn wir das obige Programm ausführen, erhalten wir beide die Namen der Künstler und die URLs zu den Links, die uns mehr über die Künstler erzählen:

Zabaglia, Niccola
https://web.archive.org/web/20121007172955/https://www.nga.gov/cgi-bin/tsearch?artistid=11630
Zaccone, Fabian
https://web.archive.org/web/20121007172955/https://www.nga.gov/cgi-bin/tsearch?artistid=34202
...
Zanotti, Giampietro
https://web.archive.org/web/20121007172955/https://www.nga.gov/cgi-bin/tsearch?artistid=11631
Zao Wou-Ki
https://web.archive.org/web/20121007172955/https://www.nga.gov/cgi-bin/tsearch?artistid=3427

Obwohl wir jetzt Informationen von der Website erhalten, wird es derzeit nur in unser Terminalfenster ausgegeben. Lassen Sie uns stattdessen diese Daten erfassen, damit wir sie anderswo verwenden können, indem wir sie in eine Datei schreiben.

Die Daten in eine CSV-Datei schreiben

Daten zu sammeln, die nur in einem Terminalfenster existieren, ist nicht sehr nützlich. Komma-getrennte Werte (CSV) Dateien ermöglichen es uns, tabellarische Daten im Klartext zu speichern, und sind ein gängiges Format für Tabellenkalkulationen und Datenbanken. Bevor Sie mit diesem Abschnitt beginnen, sollten Sie sich mit der Handhabung von Klartextdateien in Python vertraut machen.

Zuerst müssen wir das eingebaute csv-Modul von Python zusammen mit den anderen Modulen oben in der Python-Programmierdatei importieren:

import csv

Als Nächstes erstellen und öffnen wir eine Datei mit dem Namen z-artist-names.csv, in die wir schreiben können (wir verwenden hier die Variable f für die Datei) und zwar im Modus 'w'. Wir werden auch die Überschriften der obersten Zeile schreiben: Name und Link, die wir als Liste an die Methode writerow() übergeben:

f = csv.writer(open('z-artist-names.csv', 'w'))
f.writerow(['Name', 'Link'])

Schließlich werden wir innerhalb unserer for-Schleife jede Zeile mit den Namen der Künstler und ihren zugehörigen Links schreiben:

f.writerow([names, links])

Sie können die Zeilen für jede dieser Aufgaben in der Datei unten sehen:

import requests
import csv
from bs4 import BeautifulSoup


page = requests.get('https://web.archive.org/web/20121007172955/http://www.nga.gov/collection/anZ1.htm')

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

last_links = soup.find(class_='AlphaNav')
last_links.decompose()

Create a file to write to, add headers row
f = csv.writer(open('z-artist-names.csv', 'w'))
f.writerow(['Name', 'Link'])

artist_name_list = soup.find(class_='BodyText')
artist_name_list_items = artist_name_list.find_all('a')

for artist_name in artist_name_list_items:
    names = artist_name.contents[0]
    links = 'https://web.archive.org' + artist_name.get('href')


    # Add each artist’s name and associated link to a row
    f.writerow([names, links])

Wenn Sie das Programm jetzt mit dem python-Befehl ausführen, wird keine Ausgabe in Ihr Terminalfenster zurückgegeben. Stattdessen wird eine Datei im Verzeichnis erstellt, in dem Sie arbeiten, die z-artist-names.csv heißt.

Je nachdem, welches Programm Sie zum Öffnen verwenden, könnte es so aussehen:

Name,Link
"Zabaglia, Niccola",https://web.archive.org/web/20121007172955/http://www.nga.gov/cgi-bin/tsearch?artistid=11630
"Zaccone, Fabian",https://web.archive.org/web/20121007172955/http://www.nga.gov/cgi-bin/tsearch?artistid=34202
"Zadkine, Ossip",https://web.archive.org/web/20121007172955/http://www.nga.gov/cgi-bin/tsearch?artistid=3475w
...

Oder es sieht mehr aus wie eine Tabelle:

In jedem Fall können Sie jetzt diese Datei verwenden, um auf sinnvollere Weise mit den Daten zu arbeiten, da die Informationen, die Sie gesammelt haben, jetzt im Speicher Ihres Computers gespeichert sind.

Verwandte Seiten abrufen

Wir haben ein Programm erstellt, das Daten von der ersten Seite der Liste von Künstlern abrufen wird, deren Nachnamen mit dem Buchstaben Z beginnen. Es gibt jedoch insgesamt 4 Seiten mit diesen Künstlern, die auf der Website verfügbar sind.

Um all diese Seiten zu sammeln, können wir mehr Iterationen mit for Schleifen durchführen. Dies wird den Großteil des Codes, den wir bisher geschrieben haben, überarbeiten, verwendet jedoch ähnliche Konzepte.

Um zu beginnen, wollen wir eine Liste initialisieren, um die Seiten zu halten:

pages = []

Wir werden diese initialisierte Liste mit der folgenden for-Schleife befüllen:

for i in range(1, 5):
    url = 'https://web.archive.org/web/20121007172955/https://www.nga.gov/collection/anZ' + str(i) + '.htm'
    pages.append(url)

Früher in diesem Tutorial haben wir festgestellt, dass wir darauf achten sollten, wie viele Seiten es gibt, die die Namen von Künstlern enthalten, die mit dem Buchstaben Z (oder welchem Buchstaben auch immer wir verwenden) beginnen. Da es 4 Seiten für den Buchstaben Z gibt, haben wir die oben stehende for-Schleife mit einem Bereich von 1 bis 5 konstruiert, damit sie durch jede der 4 Seiten iteriert.

Für diese spezielle Webseite beginnen die URLs mit dem String https://web.archive.org/web/20121007172955/https://www.nga.gov/collection/anZ und werden dann mit einer Zahl für die Seite gefolgt (die die ganze Zahl i aus der for-Schleife ist, die wir in einen String umwandeln) und enden mit .htm. Wir werden diese Strings zusammenfügen und dann das Ergebnis zur pages-Liste hinzufügen.

Zusätzlich zu dieser Schleife werden wir eine zweite Schleife haben, die durch jede der oben genannten Seiten geht. Der Code in dieser for Schleife wird ähnlich dem Code aussehen, den wir bisher erstellt haben, da er die Aufgabe, die wir für die erste Seite der Künstler mit dem Buchstaben Z erledigt haben, für jede der insgesamt 4 Seiten ausführt. Beachten Sie, dass wir das ursprüngliche Programm in die zweite for Schleife eingefügt haben, sodass wir jetzt die ursprüngliche Schleife als geschachtelte for Schleife darin enthalten haben.

Die beiden for-Schleifen werden wie folgt aussehen:

pages = []

for i in range(1, 5):
    url = 'https://web.archive.org/web/20121007172955/https://www.nga.gov/collection/anZ' + str(i) + '.htm'
    pages.append(url)
    
for item in pages:
    page = requests.get(item)
    soup = BeautifulSoup(page.text, 'html.parser')

    last_links = soup.find(class_='AlphaNav')
    last_links.decompose()

    artist_name_list = soup.find(class_='BodyText')
    artist_name_list_items = artist_name_list.find_all('a')

    for artist_name in artist_name_list_items:
        names = artist_name.contents[0]
        links = 'https://web.archive.org' + artist_name.get('href')

        f.writerow([names, links])

Im obigen Code sollten Sie sehen, dass die erste for-Schleife über die Seiten iteriert und die zweite for-Schleife Daten von jeder dieser Seiten scrapt und dann die Namen und Links der Künstler zeilenweise durch jede Zeile jeder Seite hinzufügt.

Diese beiden for Schleifen kommen nach den import Anweisungen, der Erstellung der CSV-Datei und dem Writer (mit der Zeile zum Schreiben der Dateikopfzeilen) sowie der Initialisierung der pages Variablen (die einer Liste zugewiesen wird).

Im größeren Kontext der Programmdatei sieht der vollständige Code wie folgt aus:

import requests
import csv
from bs4 import BeautifulSoup


f = csv.writer(open('z-artist-names.csv', 'w'))
f.writerow(['Name', 'Link'])

pages = []

for i in range(1, 5):
    url = 'https://web.archive.org/web/20121007172955/https://www.nga.gov/collection/anZ' + str(i) + '.htm'
    pages.append(url)


for item in pages:
    page = requests.get(item)
    soup = BeautifulSoup(page.text, 'html.parser')

    last_links = soup.find(class_='AlphaNav')
    last_links.decompose()

    artist_name_list = soup.find(class_='BodyText')
    artist_name_list_items = artist_name_list.find_all('a')

    for artist_name in artist_name_list_items:
        names = artist_name.contents[0]
        links = 'https://web.archive.org' + artist_name.get('href')

        f.writerow([names, links])

Da dieses Programm ein wenig Arbeit verrichtet, wird es eine Weile dauern, um die CSV-Datei zu erstellen. Sobald es fertig ist, wird die Ausgabe abgeschlossen sein und die Namen der Künstler sowie ihre zugehörigen Links von Zabaglia, Niccola bis Zykmund, Václav anzeigen.

Rücksichtsvoll sein

Beim Scraping von Webseiten ist es wichtig, Rücksicht auf die Server zu nehmen, von denen Sie Informationen abrufen.

Überprüfen Sie, ob eine Website Nutzungsbedingungen oder Allgemeinen Geschäftsbedingungen hat, die sich auf Web-Scraping beziehen. Überprüfen Sie auch, ob eine Website eine API hat, die es Ihnen ermöglicht, Daten abzurufen, bevor Sie sie selbst scrapen.

Achten Sie darauf, nicht ständig Server abzuhittern, um Daten zu sammeln. Sobald Sie das gesammelt haben, was Sie von einer Seite benötigen, führen Sie Skripte aus, die die Daten lokal durchgehen, anstatt die Server von jemand anderem zu belasten.

Zusätzlich ist es eine gute Idee, mit einem Header zu scrappen, der Ihren Namen und Ihre E-Mail-Adresse enthält, damit eine Website Sie identifizieren und sich melden kann, wenn sie Fragen hat. Ein Beispiel für einen Header, den Sie mit der Python Requests-Bibliothek verwenden können, ist wie folgt:

import requests

headers = {
    'User-Agent': 'Your Name, example.com',
    'From': 'email@example.com'
}

url = 'https://example.com'

page = requests.get(url, headers = headers)

Die Verwendung von Headern mit identifizierbaren Informationen stellt sicher, dass die Personen, die die Protokolle eines Servers überprüfen, Sie kontaktieren können.

Schlussfolgerung

Dieses Tutorial behandelt die Verwendung von Python und Beautiful Soup, um Daten von einer Website zu scrapen. Wir haben den gesammelten Text in einer CSV-Datei gespeichert.

Sie können mit der Arbeit an diesem Projekt fortfahren, indem Sie weitere Daten sammeln und Ihre CSV-Datei robuster gestalten. Zum Beispiel möchten Sie vielleicht die Nationalitäten und Lebensjahre jedes Künstlers einbeziehen. Sie können auch das, was Sie gelernt haben, nutzen, um Daten von anderen Websites zu scrapen.

Um weiterhin zu lernen, wie man Informationen aus dem Internet abruft, lesen Sie unser Tutorial „Wie man eine Webseite mit Scrapy und Python 3 crawlt.“