Schöne Suppe - Kurzanleitung
In der heutigen Welt haben wir Tonnen von unstrukturierten Daten / Informationen (meistens Webdaten) frei verfügbar. Manchmal sind die frei verfügbaren Daten leicht zu lesen und manchmal nicht. Unabhängig davon, wie Ihre Daten verfügbar sind, ist Web Scraping ein sehr nützliches Werkzeug, um unstrukturierte Daten in strukturierte Daten umzuwandeln, die einfacher zu lesen und zu analysieren sind. Mit anderen Worten, eine Möglichkeit, diese enorme Datenmenge zu sammeln, zu organisieren und zu analysieren, ist das Web-Scraping. Lassen Sie uns zunächst verstehen, was Web-Scraping ist.
Was ist Web-Scraping?
Scraping ist einfach ein Prozess des Extrahierens (aus verschiedenen Mitteln), Kopierens und Screenings von Daten.
Wenn wir Daten oder Feeds aus dem Web kratzen oder extrahieren (z. B. von Webseiten oder Websites), wird dies als Web-Scraping bezeichnet.
Web Scraping, das auch als Web Data Extraction oder Web Harvesting bezeichnet wird, ist das Extrahieren von Daten aus dem Web. Kurz gesagt, Web Scraping bietet Entwicklern die Möglichkeit, Daten aus dem Internet zu sammeln und zu analysieren.
Warum Web-Scraping?
Web-Scraping bietet eines der großartigen Tools, um die meisten Dinge zu automatisieren, die ein Mensch beim Surfen tut. Web-Scraping wird in einem Unternehmen auf verschiedene Arten eingesetzt -
Daten für die Forschung
Intelligente Analysten (wie Forscher oder Journalisten) verwenden Web-Scrapper, anstatt Daten von den Websites manuell zu sammeln und zu bereinigen.
Produktpreise & Beliebtheitsvergleich
Derzeit gibt es einige Dienste, die Web-Scrapper verwenden, um Daten von zahlreichen Online-Sites zu sammeln und damit die Popularität und Preise von Produkten zu vergleichen.
SEO-Überwachung
Es gibt zahlreiche SEO-Tools wie Ahrefs, Seobility, SEMrush usw., die zur Wettbewerbsanalyse und zum Abrufen von Daten von den Websites Ihrer Kunden verwendet werden.
Suchmaschinen
Es gibt einige große IT-Unternehmen, deren Geschäft ausschließlich vom Web-Scraping abhängt.
Verkauf und Marketing
Die durch Web Scraping gesammelten Daten können von Marketingfachleuten zur Analyse verschiedener Nischen und Wettbewerber oder vom Vertriebsspezialisten für den Verkauf von Content-Marketing- oder Social-Media-Werbediensten verwendet werden.
Warum Python für Web Scraping?
Python ist eine der beliebtesten Sprachen für das Web-Scraping, da es die meisten Aufgaben im Zusammenhang mit dem Web-Crawlen sehr einfach erledigen kann.
Im Folgenden finden Sie einige Punkte, warum Sie Python für das Web-Scraping auswählen sollten:
Benutzerfreundlichkeit
Da die meisten Entwickler der Meinung sind, dass Python sehr einfach zu codieren ist. Wir müssen keine geschweiften Klammern "{}" oder Semikolons ";" verwenden. Überall, wodurch es bei der Entwicklung von Web-Scrapern besser lesbar und benutzerfreundlich ist.
Riesige Bibliotheksunterstützung
Python bietet eine große Anzahl von Bibliotheken für unterschiedliche Anforderungen, sodass es sowohl für das Web-Scraping als auch für die Datenvisualisierung, das maschinelle Lernen usw. geeignet ist.
Leicht erklärbare Syntax
Python ist eine sehr lesbare Programmiersprache, da die Python-Syntax leicht zu verstehen ist. Python ist sehr ausdrucksstark und das Einrücken von Codes hilft den Benutzern, verschiedene Blöcke oder Bereiche im Code zu unterscheiden.
Dynamisch typisierte Sprache
Python ist eine dynamisch typisierte Sprache, dh die einer Variablen zugewiesenen Daten geben Auskunft darüber, um welchen Variablentyp es sich handelt. Das spart viel Zeit und beschleunigt die Arbeit.
Riesige Gemeinschaft
Die Python-Community ist riesig und hilft Ihnen, wo immer Sie beim Schreiben von Code stecken bleiben.
Einführung in die schöne Suppe
The Beautiful Soup ist eine Python-Bibliothek, die nach einem gleichnamigen Lewis Carroll-Gedicht in „Alice's Adventures in the Wonderland“ benannt ist. Beautiful Soup ist ein Python-Paket, das, wie der Name schon sagt, die unerwünschten Daten analysiert und dabei hilft, die unordentlichen Webdaten zu organisieren und zu formatieren, indem schlechtes HTML korrigiert und uns in leicht durchlaufbaren XML-Strukturen präsentiert wird.
Kurz gesagt, Beautiful Soup ist ein Python-Paket, mit dem wir Daten aus HTML- und XML-Dokumenten abrufen können.
Da BeautifulSoup keine Standard-Python-Bibliothek ist, müssen wir sie zuerst installieren. Wir werden die neueste BeautifulSoup 4-Bibliothek (auch als BS4 bekannt) installieren.
Um unsere Arbeitsumgebung zu isolieren, um das vorhandene Setup nicht zu stören, erstellen wir zunächst eine virtuelle Umgebung.
Erstellen einer virtuellen Umgebung (optional)
In einer virtuellen Umgebung können wir eine isolierte Arbeitskopie von Python für ein bestimmtes Projekt erstellen, ohne das externe Setup zu beeinträchtigen.
Der beste Weg, um einen Python-Paketcomputer zu installieren, ist die Verwendung von pip. Wenn pip jedoch noch nicht installiert ist (Sie können dies mit - "pip –version" in Ihrer Befehls- oder Shell-Eingabeaufforderung überprüfen), können Sie die Installation mit dem folgenden Befehl durchführen:
Linux-Umgebung
$sudo apt-get install python-pipWindows-Umgebung
Gehen Sie wie folgt vor, um pip in Windows zu installieren:
Laden Sie die Datei get-pip.py von herunter https://bootstrap.pypa.io/get-pip.py oder vom Github zu Ihrem Computer.
Öffnen Sie die Eingabeaufforderung und navigieren Sie zu dem Ordner mit der Datei get-pip.py.
Führen Sie den folgenden Befehl aus:
>python get-pip.pyDas war's, pip ist jetzt auf Ihrem Windows-Computer installiert.
Sie können die Installation Ihres Pip überprüfen, indem Sie den folgenden Befehl ausführen:
>pip --version
pip 19.2.3 from c:\users\yadur\appdata\local\programs\python\python37\lib\site-packages\pip (python 3.7)Virtuelle Umgebung installieren
Führen Sie den folgenden Befehl in Ihrer Eingabeaufforderung aus -
>pip install virtualenvNach dem Ausführen sehen Sie den folgenden Screenshot -
Mit dem folgenden Befehl wird eine virtuelle Umgebung ("myEnv") in Ihrem aktuellen Verzeichnis erstellt.
>virtualenv myEnvBildschirmfoto
Führen Sie den folgenden Befehl aus, um Ihre virtuelle Umgebung zu aktivieren:
>myEnv\Scripts\activate
Im obigen Screenshot sehen Sie, dass wir "myEnv" als Präfix haben, das uns mitteilt, dass wir uns in der virtuellen Umgebung "myEnv" befinden.
Führen Sie Deaktivieren aus, um die virtuelle Umgebung zu verlassen.
(myEnv) C:\Users\yadur>deactivate
C:\Users\yadur>Nachdem unsere virtuelle Umgebung fertig ist, können wir jetzt beautifulsoup installieren.
BeautifulSoup installieren
Da BeautifulSoup keine Standardbibliothek ist, müssen wir sie installieren. Wir werden das BeautifulSoup 4-Paket (bekannt als bs4) verwenden.
Linux-Maschine
Führen Sie den folgenden Befehl aus, um bs4 unter Debian oder Ubuntu Linux mit dem Systempaket-Manager zu installieren:
$sudo apt-get install python-bs4 (for python 2.x)
$sudo apt-get install python3-bs4 (for python 3.x)Sie können bs4 mit easy_install oder pip installieren (falls Sie Probleme bei der Installation mit dem System Packager haben).
$easy_install beautifulsoup4
$pip install beautifulsoup4(Möglicherweise müssen Sie easy_install3 bzw. pip3 verwenden, wenn Sie Python3 verwenden.)
Windows-Maschine
Die Installation von beautifulsoup4 in Windows ist sehr einfach, insbesondere wenn Sie bereits pip installiert haben.
>pip install beautifulsoup4
Jetzt ist beautifulsoup4 in unserer Maschine installiert. Lassen Sie uns über einige Probleme sprechen, die nach der Installation aufgetreten sind.
Probleme nach der Installation
Auf einem Windows-Computer kann es vorkommen, dass ein Fehler bei der Installation der falschen Version hauptsächlich durch -
Error: ImportError “No module named HTMLParser”Dann müssen Sie die Python 2-Version des Codes unter Python 3 ausführen.
Error: ImportError “No module named html.parser” Fehler, dann müssen Sie Python 3-Version des Codes unter Python 2 ausführen.
Der beste Weg, um aus den beiden oben genannten Situationen herauszukommen, besteht darin, die BeautifulSoup erneut zu installieren und die vorhandene Installation vollständig zu entfernen.
Wenn du das bekommst SyntaxError “Invalid syntax” In der Zeile ROOT_TAG_NAME = u '[document]' müssen Sie den Python 2-Code in Python 3 konvertieren, indem Sie entweder das Paket installieren -
$ python3 setup.py installoder indem Sie das Konvertierungsskript von Python 2 zu 3 manuell im Verzeichnis bs4 ausführen -
$ 2to3-3.2 -w bs4Parser installieren
Standardmäßig unterstützt Beautiful Soup den in der Python-Standardbibliothek enthaltenen HTML-Parser, unterstützt jedoch auch viele externe Python-Parser von Drittanbietern wie den lxml-Parser oder den html5lib-Parser.
Verwenden Sie den Befehl -, um den Parser lxml oder html5lib zu installieren.
Linux-Maschine
$apt-get install python-lxml
$apt-get insall python-html5libWindows-Maschine
$pip install lxml
$pip install html5lib
Im Allgemeinen verwenden Benutzer lxml aus Gründen der Geschwindigkeit. Es wird empfohlen, den Parser lxml oder html5lib zu verwenden, wenn Sie eine ältere Version von Python 2 (vor Version 2.7.3) oder Python 3 (vor Version 3.2.2) als integrierten HTML-Parser von Python verwenden nicht sehr gut im Umgang mit älteren Versionen.
Laufen schöne Suppe
Es ist Zeit, unser Beautiful Soup-Paket auf einer der HTML-Seiten zu testen (Webseite nehmen - https://www.tutorialspoint.com/index.htmkönnen Sie eine beliebige andere Webseite auswählen und einige Informationen daraus extrahieren.
Im folgenden Code versuchen wir, den Titel von der Webseite zu extrahieren -
from bs4 import BeautifulSoup
import requests
url = "https://www.tutorialspoint.com/index.htm"
req = requests.get(url)
soup = BeautifulSoup(req.text, "html.parser")
print(soup.title)Ausgabe
<title>H2O, Colab, Theano, Flutter, KNime, Mean.js, Weka, Solidity, Org.Json, AWS QuickSight, JSON.Simple, Jackson Annotations, Passay, Boon, MuleSoft, Nagios, Matplotlib, Java NIO, PyTorch, SLF4J, Parallax Scrolling, Java Cryptography</title>Eine häufige Aufgabe besteht darin, alle URLs innerhalb einer Webseite zu extrahieren. Dazu müssen wir nur die folgende Codezeile hinzufügen -
for link in soup.find_all('a'):
print(link.get('href'))Ausgabe
https://www.tutorialspoint.com/index.htm
https://www.tutorialspoint.com/about/about_careers.htm
https://www.tutorialspoint.com/questions/index.php
https://www.tutorialspoint.com/online_dev_tools.htm
https://www.tutorialspoint.com/codingground.htm
https://www.tutorialspoint.com/current_affairs.htm
https://www.tutorialspoint.com/upsc_ias_exams.htm
https://www.tutorialspoint.com/tutor_connect/index.php
https://www.tutorialspoint.com/whiteboard.htm
https://www.tutorialspoint.com/netmeeting.php
https://www.tutorialspoint.com/index.htm
https://www.tutorialspoint.com/tutorialslibrary.htm
https://www.tutorialspoint.com/videotutorials/index.php
https://store.tutorialspoint.com
https://www.tutorialspoint.com/gate_exams_tutorials.htm
https://www.tutorialspoint.com/html_online_training/index.asp
https://www.tutorialspoint.com/css_online_training/index.asp
https://www.tutorialspoint.com/3d_animation_online_training/index.asp
https://www.tutorialspoint.com/swift_4_online_training/index.asp
https://www.tutorialspoint.com/blockchain_online_training/index.asp
https://www.tutorialspoint.com/reactjs_online_training/index.asp
https://www.tutorix.com
https://www.tutorialspoint.com/videotutorials/top-courses.php
https://www.tutorialspoint.com/the_full_stack_web_development/index.asp
….
….
https://www.tutorialspoint.com/online_dev_tools.htm
https://www.tutorialspoint.com/free_web_graphics.htm
https://www.tutorialspoint.com/online_file_conversion.htm
https://www.tutorialspoint.com/netmeeting.php
https://www.tutorialspoint.com/free_online_whiteboard.htm
http://www.tutorialspoint.com
https://www.facebook.com/tutorialspointindia
https://plus.google.com/u/0/+tutorialspoint
http://www.twitter.com/tutorialspoint
http://www.linkedin.com/company/tutorialspoint
https://www.youtube.com/channel/UCVLbzhxVTiTLiVKeGV7WEBg
https://www.tutorialspoint.com/index.htm
/about/about_privacy.htm#cookies
/about/faq.htm
/about/about_helping.htm
/about/contact_us.htmEbenso können wir mit beautifulsoup4 nützliche Informationen extrahieren.
Lassen Sie uns nun im obigen Beispiel mehr über „Suppe“ verstehen.
Im vorherigen Codebeispiel analysieren wir das Dokument mithilfe einer Zeichenfolgenmethode durch einen schönen Konstruktor. Eine andere Möglichkeit besteht darin, das Dokument durch ein offenes Dateihandle zu führen.
from bs4 import BeautifulSoup
with open("example.html") as fp:
soup = BeautifulSoup(fp)
soup = BeautifulSoup("<html>data</html>")Zuerst wird das Dokument in Unicode konvertiert und HTML-Entitäten werden in Unicode-Zeichen konvertiert: </ p>
import bs4
html = '''<b>tutorialspoint</b>, <i>&web scraping &data science;</i>'''
soup = bs4.BeautifulSoup(html, 'lxml')
print(soup)Ausgabe
<html><body><b>tutorialspoint</b>, <i>&web scraping &data science;</i></body></html>BeautifulSoup analysiert dann die Daten mithilfe eines HTML-Parsers oder Sie weisen ihn explizit an, sie mithilfe eines XML-Parsers zu analysieren.
HTML-Baumstruktur
Bevor wir uns mit verschiedenen Komponenten einer HTML-Seite befassen, wollen wir zunächst die HTML-Baumstruktur verstehen.
Das Stammelement im Dokumentbaum ist das HTML, das Eltern, Kinder und Geschwister haben kann. Dies wird durch seine Position in der Baumstruktur bestimmt. Um zwischen HTML-Elementen, Attributen und Text zu wechseln, müssen Sie zwischen Knoten in Ihrer Baumstruktur wechseln.
Nehmen wir an, die Webseite ist wie folgt:
Was sich wie folgt in ein HTML-Dokument übersetzt -
<html><head><title>TutorialsPoint</title></head><h1>Tutorialspoint Online Library</h1><p<<b>It's all Free</b></p></body></html>Was einfach bedeutet, dass wir für das obige HTML-Dokument eine HTML-Baumstruktur wie folgt haben:
Wenn wir ein HTML-Dokument oder eine HTML-Zeichenfolge an einen Beautifulsoup-Konstruktor übergeben, konvertiert Beautifulsoup im Grunde eine komplexe HTML-Seite in verschiedene Python-Objekte. Im Folgenden werden vier Hauptarten von Objekten erörtert:
Tag
NavigableString
BeautifulSoup
Comments
Objekte markieren
Ein HTML-Tag wird verwendet, um verschiedene Arten von Inhalten zu definieren. Ein Tag-Objekt in BeautifulSoup entspricht einem HTML- oder XML-Tag auf der tatsächlichen Seite oder im Dokument.
>>> from bs4 import BeautifulSoup
>>> soup = BeautifulSoup('<b class="boldest">TutorialsPoint</b>')
>>> tag = soup.html
>>> type(tag)
<class 'bs4.element.Tag'>Tags enthalten viele Attribute und Methoden, und zwei wichtige Merkmale eines Tags sind sein Name und seine Attribute.
Name (tag.name)
Jedes Tag enthält einen Namen und kann über '.name' als Suffix aufgerufen werden. tag.name gibt den Tag-Typ zurück.
>>> tag.name
'html'Wenn wir jedoch den Tag-Namen ändern, wird dies im HTML-Markup angezeigt, das von BeautifulSoup generiert wird.
>>> tag.name = "Strong"
>>> tag
<Strong><body><b class="boldest">TutorialsPoint</b></body></Strong>
>>> tag.name
'Strong'Attribute (tag.attrs)
Ein Tag-Objekt kann beliebig viele Attribute haben. Das Tag <b class = ”boldest”> hat ein Attribut 'class', dessen Wert "boldest" ist. Alles, was NICHT tag ist, ist im Grunde ein Attribut und muss einen Wert enthalten. Sie können auf die Attribute zugreifen, indem Sie entweder auf die Schlüssel zugreifen (wie im obigen Beispiel auf "class") oder direkt über ".attrs".
>>> tutorialsP = BeautifulSoup("<div class='tutorialsP'></div>",'lxml')
>>> tag2 = tutorialsP.div
>>> tag2['class']
['tutorialsP']Wir können alle Arten von Änderungen an den Attributen unseres Tags vornehmen (Hinzufügen / Entfernen / Ändern).
>>> tag2['class'] = 'Online-Learning'
>>> tag2['style'] = '2007'
>>>
>>> tag2
<div class="Online-Learning" style="2007"></div>
>>> del tag2['style']
>>> tag2
<div class="Online-Learning"></div>
>>> del tag['class']
>>> tag
<b SecondAttribute="2">TutorialsPoint</b>
>>>
>>> del tag['SecondAttribute']
>>> tag
</b>
>>> tag2['class']
'Online-Learning'
>>> tag2['style']
KeyError: 'style'Mehrwertige Attribute
Einige der HTML5-Attribute können mehrere Werte haben. Am häufigsten wird das Klassenattribut verwendet, das mehrere CSS-Werte haben kann. Andere sind 'rel', 'rev', 'headers', 'accesskey' und 'accept-charset'. Die mehrwertigen Attribute in einer schönen Suppe werden als Liste angezeigt.
>>> from bs4 import BeautifulSoup
>>>
>>> css_soup = BeautifulSoup('<p class="body"></p>')
>>> css_soup.p['class']
['body']
>>>
>>> css_soup = BeautifulSoup('<p class="body bold"></p>')
>>> css_soup.p['class']
['body', 'bold']Wenn jedoch ein Attribut mehr als einen Wert enthält, es sich jedoch nicht um mehrwertige Attribute nach einer beliebigen Version des HTML-Standards handelt, lässt eine schöne Suppe das Attribut in Ruhe -
>>> id_soup = BeautifulSoup('<p id="body bold"></p>')
>>> id_soup.p['id']
'body bold'
>>> type(id_soup.p['id'])
<class 'str'>Sie können mehrere Attributwerte konsolidieren, wenn Sie ein Tag in eine Zeichenfolge umwandeln.
>>> rel_soup = BeautifulSoup("<p> tutorialspoint Main <a rel='Index'> Page</a></p>")
>>> rel_soup.a['rel']
['Index']
>>> rel_soup.a['rel'] = ['Index', ' Online Library, Its all Free']
>>> print(rel_soup.p)
<p> tutorialspoint Main <a rel="Index Online Library, Its all Free"> Page</a></p>Wenn Sie 'get_attribute_list' verwenden, erhalten Sie einen Wert, der immer eine Liste oder Zeichenfolge ist, unabhängig davon, ob es sich um einen mehrwertigen Wert handelt oder nicht.
id_soup.p.get_attribute_list(‘id’)Wenn Sie das Dokument jedoch als 'xml' analysieren, gibt es keine mehrwertigen Attribute.
>>> xml_soup = BeautifulSoup('<p class="body bold"></p>', 'xml')
>>> xml_soup.p['class']
'body bold'NavigableString
Das navigablestring-Objekt wird verwendet, um den Inhalt eines Tags darzustellen. Um auf den Inhalt zuzugreifen, verwenden Sie ".string" mit Tag.
>>> from bs4 import BeautifulSoup
>>> soup = BeautifulSoup("<h2 id='message'>Hello, Tutorialspoint!</h2>")
>>>
>>> soup.string
'Hello, Tutorialspoint!'
>>> type(soup.string)
>Sie können die Zeichenfolge durch eine andere Zeichenfolge ersetzen, die vorhandene Zeichenfolge jedoch nicht bearbeiten.
>>> soup = BeautifulSoup("<h2 id='message'>Hello, Tutorialspoint!</h2>")
>>> soup.string.replace_with("Online Learning!")
'Hello, Tutorialspoint!'
>>> soup.string
'Online Learning!'
>>> soup
<html><body><h2 id="message">Online Learning!</h2></body></html>Schöne Suppe
BeautifulSoup ist das Objekt, das erstellt wird, wenn wir versuchen, eine Webressource zu kratzen. Es ist also das vollständige Dokument, das wir zu kratzen versuchen. Meistens wird es als Tag-Objekt behandelt.
>>> from bs4 import BeautifulSoup
>>> soup = BeautifulSoup("<h2 id='message'>Hello, Tutorialspoint!</h2>")
>>> type(soup)
<class 'bs4.BeautifulSoup'>
>>> soup.name
'[document]'Bemerkungen
Das Kommentarobjekt veranschaulicht den Kommentarteil des Webdokuments. Es ist nur eine spezielle Art von NavigableString.
>>> soup = BeautifulSoup('<p><!-- Everything inside it is COMMENTS --></p>')
>>> comment = soup.p.string
>>> type(comment)
<class 'bs4.element.Comment'>
>>> type(comment)
<class 'bs4.element.Comment'>
>>> print(soup.p.prettify())
<p>
<!-- Everything inside it is COMMENTS -->
</p>NavigableString-Objekte
Die navigierbaren Objekte werden verwendet, um Text innerhalb von Tags und nicht die Tags selbst darzustellen.
In diesem Kapitel werden wir uns mit dem Navigieren nach Tags befassen.
Unten ist unser HTML-Dokument -
>>> html_doc = """
<html><head><title>Tutorials Point</title></head>
<body>
<p class="title"><b>The Biggest Online Tutorials Library, It's all Free</b></p>
<p class="prog">Top 5 most used Programming Languages are:
<a href="https://www.tutorialspoint.com/java/java_overview.htm" class="prog" id="link1">Java</a>,
<a href="https://www.tutorialspoint.com/cprogramming/index.htm" class="prog" id="link2">C</a>,
<a href="https://www.tutorialspoint.com/python/index.htm" class="prog" id="link3">Python</a>,
<a href="https://www.tutorialspoint.com/javascript/javascript_overview.htm" class="prog" id="link4">JavaScript</a> and
<a href="https://www.tutorialspoint.com/ruby/index.htm" class="prog" id="link5">C</a>;
as per online survey.</p>
<p class="prog">Programming Languages</p>
"""
>>>
>>> from bs4 import BeautifulSoup
>>> soup = BeautifulSoup(html_doc, 'html.parser')
>>>Basierend auf dem obigen Dokument werden wir versuchen, von einem Teil des Dokuments zu einem anderen zu wechseln.
Untergehen
Eines der wichtigsten Elemente in jedem HTML-Dokument sind Tags, die andere Tags / Zeichenfolgen (untergeordnete Elemente des Tags) enthalten können. Beautiful Soup bietet verschiedene Möglichkeiten zum Navigieren und Durchlaufen der Kinder des Tags.
Navigieren mit Tag-Namen
Die einfachste Möglichkeit, einen Analysebaum zu durchsuchen, besteht darin, das Tag anhand seines Namens zu durchsuchen. Wenn Sie das <head> -Tag möchten, verwenden Sieoup.head -
>>> soup.head
<head>&t;title>Tutorials Point</title></head>
>>> soup.title
<title>Tutorials Point</title>So erhalten Sie ein bestimmtes Tag (wie das erste <b> -Tag) im <body> -Tag.
>>> soup.body.b
<b>The Biggest Online Tutorials Library, It's all Free</b>Wenn Sie einen Tag-Namen als Attribut verwenden, erhalten Sie nur das erste Tag mit diesem Namen.
>>> soup.a
<a class="prog" href="https://www.tutorialspoint.com/java/java_overview.htm" id="link1">Java</a>Um alle Attribute des Tags abzurufen, können Sie die Methode find_all () verwenden.
>>> soup.find_all("a")
[<a class="prog" href="https://www.tutorialspoint.com/java/java_overview.htm" id="link1">Java</a>, <a class="prog" href="https://www.tutorialspoint.com/cprogramming/index.htm" id="link2">C</a>, <a class="prog" href="https://www.tutorialspoint.com/python/index.htm" id="link3">Python</a>, <a class="prog" href="https://www.tutorialspoint.com/javascript/javascript_overview.htm" id="link4">JavaScript</a>, <a class="prog" href="https://www.tutorialspoint.com/ruby/index.htm" id="link5">C</a>]>>> soup.find_all("a")
[<a class="prog" href="https://www.tutorialspoint.com/java/java_overview.htm" id="link1">Java</a>, <a class="prog" href="https://www.tutorialspoint.com/cprogramming/index.htm" id="link2">C</a>, <a class="prog" href="https://www.tutorialspoint.com/python/index.htm" id="link3">Python</a>, <a class="prog" href="https://www.tutorialspoint.com/javascript/javascript_overview.htm" id="link4">JavaScript</a>, <a class="prog" href="https://www.tutorialspoint.com/ruby/index.htm" id="link5">C</a>].inhalte und .kinder
Wir können die Kinder des Tags in einer Liste nach seinen .contents suchen -
>>> head_tag = soup.head
>>> head_tag
<head><title>Tutorials Point</title></head>
>>> Htag = soup.head
>>> Htag
<head><title>Tutorials Point</title></head>
>>>
>>> Htag.contents
[<title>Tutorials Point</title>
>>>
>>> Ttag = head_tag.contents[0]
>>> Ttag
<title>Tutorials Point</title>
>>> Ttag.contents
['Tutorials Point']Das BeautifulSoup-Objekt selbst hat untergeordnete Elemente. In diesem Fall ist das <html> -Tag das untergeordnete Element des BeautifulSoup-Objekts.
>>> len(soup.contents)
2
>>> soup.contents[1].name
'html'Ein String hat keine .contents, weil er nichts enthalten kann -
>>> text = Ttag.contents[0]
>>> text.contents
self.__class__.__name__, attr))
AttributeError: 'NavigableString' object has no attribute 'contents'Verwenden Sie den Generator .children, um auf die untergeordneten Elemente des Tags zuzugreifen, anstatt sie als Liste abzurufen.
>>> for child in Ttag.children:
print(child)
Tutorials Point.Nachkommenschaft
Mit dem Attribut .descendants können Sie alle untergeordneten Elemente eines Tags rekursiv durchlaufen.
seine direkten Kinder und die Kinder seiner direkten Kinder und so weiter -
>>> for child in Htag.descendants:
print(child)
<title>Tutorials Point</title>
Tutorials PointDas <head> -Tag hat nur ein untergeordnetes Element, aber zwei Nachkommen: das <title> -Tag und das untergeordnete Element des <title> -Tags. Das Beautifulsoup-Objekt hat nur ein direktes untergeordnetes Element (das <html> -Tag), aber es hat eine ganze Reihe von Nachkommen -
>>> len(list(soup.children))
2
>>> len(list(soup.descendants))
33.string
Wenn das Tag nur ein untergeordnetes Element hat und dieses untergeordnete Element ein NavigableString ist, wird das untergeordnete Element als .string - verfügbar gemacht.
>>> Ttag.string
'Tutorials Point'Wenn das einzige untergeordnete Tag eines Tags ein anderes Tag ist und dieses Tag eine .string-Zeichenfolge hat, wird davon ausgegangen, dass das übergeordnete Tag dieselbe .string-Zeichenfolge wie sein untergeordnetes Tag hat.
>>> Htag.contents
[<title>Tutorials Point</title>]
>>>
>>> Htag.string
'Tutorials Point'Wenn ein Tag jedoch mehr als eine Sache enthält, ist nicht klar, worauf sich .string beziehen soll. Daher ist .string als Keine definiert.
>>> print(soup.html.string)
None.strings und stripped_strings
Wenn ein Tag mehr als eine Sache enthält, können Sie immer noch nur die Zeichenfolgen betrachten. Verwenden Sie den .strings-Generator -
>>> for string in soup.strings:
print(repr(string))
'\n'
'Tutorials Point'
'\n'
'\n'
"The Biggest Online Tutorials Library, It's all Free"
'\n'
'Top 5 most used Programming Languages are: \n'
'Java'
',\n'
'C'
',\n'
'Python'
',\n'
'JavaScript'
' and\n'
'C'
';\n \nas per online survey.'
'\n'
'Programming Languages'
'\n'Verwenden Sie den Generator .stripped_strings, um zusätzliche Leerzeichen zu entfernen.
>>> for string in soup.stripped_strings:
print(repr(string))
'Tutorials Point'
"The Biggest Online Tutorials Library, It's all Free"
'Top 5 most used Programming Languages are:'
'Java'
','
'C'
','
'Python'
','
'JavaScript'
'and'
'C'
';\n \nas per online survey.'
'Programming Languages'Aufsteigen
In einer "Stammbaum" -Analogie hat jedes Tag und jede Zeichenfolge ein übergeordnetes Element: das Tag, das es enthält:
.Elternteil
Verwenden Sie das Attribut .parent, um auf das übergeordnete Element des Elements zuzugreifen.
>>> Ttag = soup.title
>>> Ttag
<title>Tutorials Point</title>
>>> Ttag.parent
<head>title>Tutorials Point</title></head>In unserem html_doc hat die Titelzeichenfolge selbst ein übergeordnetes Element: das <title> -Tag, das sie enthält
>>> Ttag.string.parent
<title>Tutorials Point</title>Das übergeordnete Element eines Top-Level-Tags wie <html> ist das Beautifulsoup-Objekt selbst -
>>> htmltag = soup.html
>>> type(htmltag.parent)
<class 'bs4.BeautifulSoup'>Die .parent eines Beautifulsoup-Objekts ist definiert als None -
>>> print(soup.parent)
None.Eltern
Verwenden Sie das Attribut .parents, um alle übergeordneten Elemente zu durchlaufen.
>>> link = soup.a
>>> link
<a class="prog" href="https://www.tutorialspoint.com/java/java_overview.htm" id="link1">Java</a>
>>>
>>> for parent in link.parents:
if parent is None:
print(parent)
else:
print(parent.name)
p
body
html
[document]Seitwärts gehen
Unten ist ein einfaches Dokument -
>>> sibling_soup = BeautifulSoup("<a><b>TutorialsPoint</b><c><strong>The Biggest Online Tutorials Library, It's all Free</strong></b></a>")
>>> print(sibling_soup.prettify())
<html>
<body>
<a>
<b>
TutorialsPoint
</b>
<c>
<strong>
The Biggest Online Tutorials Library, It's all Free
</strong>
</c>
</a>
</body>
</html>Im obigen Dokument befinden sich die Tags <b> und <c> auf derselben Ebene und beide sind untergeordnete Elemente desselben Tags. Sowohl das <b> als auch das <c> -Tag sind Geschwister.
.next_sibling und .previous_sibling
Verwenden Sie .next_sibling und .previous_sibling, um zwischen Seitenelementen zu navigieren, die sich auf derselben Ebene des Analysebaums befinden:
>>> sibling_soup.b.next_sibling
<c><strong>The Biggest Online Tutorials Library, It's all Free</strong></c>
>>>
>>> sibling_soup.c.previous_sibling
<b>TutorialsPoint</b>Das <b> -Tag hat ein .next_sibling, aber kein .previous_sibling, da sich vor dem <b> -Tag auf derselben Ebene des Baums nichts befindet, der gleiche Fall gilt für das <c> -Tag.
>>> print(sibling_soup.b.previous_sibling)
None
>>> print(sibling_soup.c.next_sibling)
NoneDie beiden Zeichenfolgen sind keine Geschwister, da sie nicht dasselbe Elternteil haben.
>>> sibling_soup.b.string
'TutorialsPoint'
>>>
>>> print(sibling_soup.b.string.next_sibling)
None.next_scribers und .previous_s Geschwisters
Um die Geschwister eines Tags zu durchlaufen, verwenden Sie .next_s Geschwister und .previous_s Geschwister.
>>> for sibling in soup.a.next_siblings:
print(repr(sibling))
',\n'
<a class="prog" href="https://www.tutorialspoint.com/cprogramming/index.htm" id="link2">C</a>
',\n'
>a class="prog" href="https://www.tutorialspoint.com/python/index.htm" id="link3">Python</a>
',\n'
<a class="prog" href="https://www.tutorialspoint.com/javascript/javascript_overview.htm" id="link4">JavaScript</a>
' and\n'
<a class="prog" href="https://www.tutorialspoint.com/ruby/index.htm"
id="link5">C</a>
';\n \nas per online survey.'
>>> for sibling in soup.find(id="link3").previous_siblings:
print(repr(sibling))
',\n'
<a class="prog" href="https://www.tutorialspoint.com/cprogramming/index.htm" id="link2">C</a>
',\n'
<a class="prog" href="https://www.tutorialspoint.com/java/java_overview.htm" id="link1">Java</a>
'Top 5 most used Programming Languages are: \n'Vor und zurück gehen
Kommen wir nun zu den ersten beiden Zeilen in unserem vorherigen Beispiel "html_doc" zurück -
&t;html><head><title>Tutorials Point</title></head>
<body>
<h4 class="tagLine"><b>The Biggest Online Tutorials Library, It's all Free</b></h4>Ein HTML-Parser nimmt die oben genannte Zeichenfolge auf und wandelt sie in eine Reihe von Ereignissen um, z. B. "Öffnen eines <html> -Tags", "Öffnen eines <head> -Tags", "Öffnen des <title> -Tags", "Hinzufügen einer Zeichenfolge". "Schließen Sie das </ title> -Tag", "Schließen Sie das </ head> -Tag", "Öffnen Sie ein <h4> -Tag" und so weiter. BeautifulSoup bietet verschiedene Methoden zur Rekonstruktion der anfänglichen Analyse des Dokuments.
.next_element und .previous_element
Das Attribut .next_element eines Tags oder einer Zeichenfolge zeigt auf das, was unmittelbar danach analysiert wurde. Manchmal sieht es ähnlich aus wie .next_sibling, ist jedoch nicht ganz dasselbe. Unten finden Sie das letzte <a> -Tag in unserem Beispieldokument "html_doc".
>>> last_a_tag = soup.find("a", id="link5")
>>> last_a_tag
<a class="prog" href="https://www.tutorialspoint.com/ruby/index.htm" id="link5">C</a>
>>> last_a_tag.next_sibling
';\n \nas per online survey.'Das .next_element dieses <a> -Tags, das unmittelbar nach dem <a> -Tag analysiert wurde, ist jedoch nicht der Rest dieses Satzes: Es ist das Wort "C":
>>> last_a_tag.next_element
'C'Das obige Verhalten ist darauf zurückzuführen, dass im ursprünglichen Markup der Buchstabe „C“ vor diesem Semikolon stand. Der Parser stieß auf ein <a> -Tag, dann auf den Buchstaben „C“, dann auf das schließende </a> Tag, dann auf das Semikolon und den Rest des Satzes. Das Semikolon befindet sich auf derselben Ebene wie das <a> -Tag, aber der Buchstabe „C“ wurde zuerst gefunden.
Das Attribut .previous_element ist das genaue Gegenteil von .next_element. Es zeigt auf das Element, das unmittelbar vor diesem Element analysiert wurde.
>>> last_a_tag.previous_element
' and\n'
>>>
>>> last_a_tag.previous_element.next_element
<a class="prog" href="https://www.tutorialspoint.com/ruby/index.htm" id="link5">C</a>.next_elements und .previous_elements
Wir verwenden diese Iteratoren, um vorwärts und rückwärts zu einem Element zu gelangen.
>>> for element in last_a_tag.next_e lements:
print(repr(element))
'C'
';\n \nas per online survey.'
'\n'
<p class="prog">Programming Languages</p>
'Programming Languages'
'\n'Es gibt viele Beautifulsoup-Methoden, mit denen wir einen Analysebaum durchsuchen können. Die beiden am häufigsten verwendeten Methoden sind find () und find_all ().
Bevor wir über find () und find_all () sprechen, sehen wir uns einige Beispiele für verschiedene Filter an, die Sie an diese Methoden übergeben können.
Arten von Filtern
Wir haben verschiedene Filter, die wir an diese Methoden übergeben können, und das Verständnis dieser Filter ist von entscheidender Bedeutung, da diese Filter in der gesamten Such-API immer wieder verwendet werden. Wir können diese Filter basierend auf dem Namen des Tags, seinen Attributen, dem Text einer Zeichenfolge oder gemischt aus diesen verwenden.
Ein Faden
Eine der einfachsten Filterarten ist eine Zeichenfolge. Wenn Sie eine Zeichenfolge an die Suchmethode und an Beautifulsoup übergeben, wird eine Übereinstimmung mit dieser genauen Zeichenfolge durchgeführt.
Der folgende Code enthält alle <p> -Tags im Dokument -
>>> markup = BeautifulSoup('<p>Top Three</p><p><pre>Programming Languages are:</pre></p><p><b>Java, Python, Cplusplus</b></p>')
>>> markup.find_all('p')
[<p>Top Three</p>, <p></p>, <p><b>Java, Python, Cplusplus</b></p>]Regulären Ausdruck
Sie können alle Tags finden, die mit einer bestimmten Zeichenfolge / einem bestimmten Tag beginnen. Vorher müssen wir das re-Modul importieren, um reguläre Ausdrücke zu verwenden.
>>> import re
>>> markup = BeautifulSoup('<p>Top Three</p><p><pre>Programming Languages are:</pre></p><p><b>Java, Python, Cplusplus</b></p>')
>>>
>>> markup.find_all(re.compile('^p'))
[<p>Top Three</p>, <p></p>, <pre>Programming Languages are:</pre>, <p><b>Java, Python, Cplusplus</b></p>]Liste
Sie können mehrere Tags zum Suchen übergeben, indem Sie eine Liste bereitstellen. Der folgende Code findet alle <b> - und <pre> -Tags -
>>> markup.find_all(['pre', 'b'])
[<pre>Programming Languages are:</pre>, <b>Java, Python, Cplusplus</b>]Wahr
True gibt alle Tags zurück, die es finden kann, aber keine eigenen Zeichenfolgen -
>>> markup.find_all(True)
[<html><body><p>Top Three</p><p></p><pre>Programming Languages are:</pre>
<p><b>Java, Python, Cplusplus</b> </p> </body></html>,
<body><p>Top Three</p><p></p><pre> Programming Languages are:</pre><p><b>Java, Python, Cplusplus</b></p>
</body>,
<p>Top Three</p>, <p></p>, <pre>Programming Languages are:</pre>, <p><b>Java, Python, Cplusplus</b></p>, <b>Java, Python, Cplusplus</b>]Um nur die Tags aus der obigen Suppe zurückzugeben -
>>> for tag in markup.find_all(True):
(tag.name)
'html'
'body'
'p'
'p'
'pre'
'p'
'b'finde alle()
Mit find_all können Sie alle Vorkommen eines bestimmten Tags aus der Seitenantwort als - extrahieren
Syntax
find_all(name, attrs, recursive, string, limit, **kwargs)Lassen Sie uns einige interessante Daten aus IMDB- „Bestbewerteten Filmen“ aller Zeiten extrahieren.
>>> url="https://www.imdb.com/chart/top/?ref_=nv_mv_250"
>>> content = requests.get(url)
>>> soup = BeautifulSoup(content.text, 'html.parser')
#Extract title Page
>>> print(soup.find('title'))
<title>IMDb Top 250 - IMDb</title>
#Extracting main heading
>>> for heading in soup.find_all('h1'):
print(heading.text)
Top Rated Movies
#Extracting sub-heading
>>> for heading in soup.find_all('h3'):
print(heading.text)
IMDb Charts
You Have Seen
IMDb Charts
Top India Charts
Top Rated Movies by Genre
Recently ViewedVon oben sehen wir, dass find_all uns alle Elemente gibt, die den von uns definierten Suchkriterien entsprechen. Alle Filter, die wir mit find_all () verwenden können, können auch mit find () und anderen Suchmethoden wie find_parents () oder find_s Geschwistern () verwendet werden.
finden()
Wir haben oben gesehen, dass find_all () verwendet wird, um das gesamte Dokument zu scannen, um den gesamten Inhalt zu finden, aber etwas, die Anforderung besteht darin, nur ein Ergebnis zu finden. Wenn Sie wissen, dass das Dokument nur ein <body> -Tag enthält, ist es Zeitverschwendung, das gesamte Dokument zu durchsuchen. Eine Möglichkeit besteht darin, find_all () mit limit = 1 jedes Mal aufzurufen, oder wir können die find () -Methode verwenden, um dasselbe zu tun -
Syntax
find(name, attrs, recursive, string, **kwargs)Im Folgenden geben zwei verschiedene Methoden die gleiche Ausgabe -
>>> soup.find_all('title',limit=1)
[<title>IMDb Top 250 - IMDb</title>]
>>>
>>> soup.find('title')
<title>IMDb Top 250 - IMDb</title>In den obigen Ausgaben sehen wir, dass die Methode find_all () eine Liste mit einem einzelnen Element zurückgibt, während die Methode find () ein einzelnes Ergebnis zurückgibt.
Ein weiterer Unterschied zwischen find () und find_all () ist -
>>> soup.find_all('h2')
[]
>>>
>>> soup.find('h2')Wenn die Methodeoup.find_all () nichts finden kann, gibt sie eine leere Liste zurück, während find () None zurückgibt.
find_parents () und find_parent ()
Im Gegensatz zu den Methoden find_all () und find (), die den Baum durchlaufen und die Nachkommen des Tags betrachten, machen die Methoden find_parents () und find_parents () das Gegenteil, sie durchlaufen den Baum nach oben und betrachten die Eltern eines Tags (oder eines Strings).
Syntax
find_parents(name, attrs, string, limit, **kwargs)
find_parent(name, attrs, string, **kwargs)
>>> a_string = soup.find(string="The Godfather")
>>> a_string
'The Godfather'
>>> a_string.find_parents('a')
[<a href="/title/tt0068646/" title="Francis Ford Coppola (dir.), Marlon Brando, Al Pacino">The Godfather</a>]
>>> a_string.find_parent('a')
<a href="/title/tt0068646/" title="Francis Ford Coppola (dir.), Marlon Brando, Al Pacino">The Godfather</a>
>>> a_string.find_parent('tr')
<tr>
<td class="posterColumn">
<span data-value="2" name="rk"></span>
<span data-value="9.149038526210072" name="ir"></span>
<span data-value="6.93792E10" name="us"></span>
<span data-value="1485540" name="nv"></span>
<span data-value="-1.850961473789928" name="ur"></span>
<a href="/title/tt0068646/"> <img alt="The Godfather" height="67" src="https://m.media-amazon.com/images/M/MV5BM2MyNjYxNmUtYTAwNi00MTYxLWJmNWYtYzZlODY3ZTk3OTFlXkEyXkFqcGdeQXVyNzkwMjQ5NzM@._V1_UY67_CR1,0,45,67_AL_.jpg" width="45"/>
</a> </td>
<td class="titleColumn">
2.
<a href="/title/tt0068646/" title="Francis Ford Coppola (dir.), Marlon Brando, Al Pacino">The Godfather</a>
<span class="secondaryInfo">(1972)</span>
</td>
<td class="ratingColumn imdbRating">
<strong title="9.1 based on 1,485,540 user ratings">9.1</strong>
</td>
<td class="ratingColumn">
<div class="seen-widget seen-widget-tt0068646 pending" data-titleid="tt0068646">
<div class="boundary">
<div class="popover">
<span class="delete"> </span><ol><li>1<li>2<li>3<li>4<li>5<li>6<li>7<li>8<li>9<li>10</li>0</li></li></li></li&td;</li></li></li></li></li></ol> </div>
</div>
<div class="inline">
<div class="pending"></div>
<div class="unseeable">NOT YET RELEASED</div>
<div class="unseen"> </div>
<div class="rating"></div>
<div class="seen">Seen</div>
</div>
</div>
</td>
<td class="watchlistColumn">
<div class="wlb_ribbon" data-recordmetrics="true" data-tconst="tt0068646"></div>
</td>
</tr>
>>>
>>> a_string.find_parents('td')
[<td class="titleColumn">
2.
<a href="/title/tt0068646/" title="Francis Ford Coppola (dir.), Marlon Brando, Al Pacino">The Godfather</a>
<span class="secondaryInfo">(1972)</span>
</td>]Es gibt acht ähnliche Methoden -
find_next_siblings(name, attrs, string, limit, **kwargs)
find_next_sibling(name, attrs, string, **kwargs)
find_previous_siblings(name, attrs, string, limit, **kwargs)
find_previous_sibling(name, attrs, string, **kwargs)
find_all_next(name, attrs, string, limit, **kwargs)
find_next(name, attrs, string, **kwargs)
find_all_previous(name, attrs, string, limit, **kwargs)
find_previous(name, attrs, string, **kwargs)Wo,
find_next_siblings() und find_next_sibling() Methoden iterieren über alle Geschwister des Elements, die nach dem aktuellen kommen.
find_previous_siblings() und find_previous_sibling() Methoden durchlaufen alle Geschwister, die vor dem aktuellen Element stehen.
find_all_next() und find_next() Methoden durchlaufen alle Tags und Zeichenfolgen, die nach dem aktuellen Element stehen.
find_all_previous und find_previous() Methoden durchlaufen alle Tags und Zeichenfolgen, die vor dem aktuellen Element stehen.
CSS-Selektoren
Die BeautifulSoup-Bibliothek zur Unterstützung der am häufigsten verwendeten CSS-Selektoren. Mit Hilfe der Methode select () können Sie mithilfe von CSS-Selektoren nach Elementen suchen.
Hier einige Beispiele -
>>> soup.select('title')
[<title>IMDb Top 250 - IMDb</title>, <title>IMDb Top Rated Movies</title>]
>>>
>>> soup.select("p:nth-of-type(1)")
[<p>The Top Rated Movie list only includes theatrical features.</p>, <p> class="imdb-footer__copyright _2-iNNCFskmr4l2OFN2DRsf">© 1990- by IMDb.com, Inc.</p>]
>>> len(soup.select("p:nth-of-type(1)"))
2
>>> len(soup.select("a"))
609
>>> len(soup.select("p"))
2
>>> soup.select("html head title")
[<title>IMDb Top 250 - IMDb</title>, <title>IMDb Top Rated Movies</title>]
>>> soup.select("head > title")
[<title>IMDb Top 250 - IMDb</title>]
#print HTML code of the tenth li elemnet
>>> soup.select("li:nth-of-type(10)")
[<li class="subnav_item_main">
<a href="/search/title?genres=film_noir&sort=user_rating,desc&title_type=feature&num_votes=25000,">Film-Noir
</a> </li>]Einer der wichtigen Aspekte von BeautifulSoup ist die Suche im Analysebaum, mit der Sie Änderungen am Webdokument entsprechend Ihren Anforderungen vornehmen können. Wir können Änderungen an den Eigenschaften des Tags mithilfe seiner Attribute vornehmen, z. B. der Methode .name, .string oder .append (). Mithilfe der Methoden .new_string () und .new_tag () können Sie einem vorhandenen Tag neue Tags und Zeichenfolgen hinzufügen. Es gibt auch andere Methoden, z. B. .insert (), .insert_before () oder .insert_after (), um verschiedene Änderungen an Ihrem HTML- oder XML-Dokument vorzunehmen.
Tag-Namen und -Attribute ändern
Sobald Sie die Suppe erstellt haben, können Sie einfach Änderungen vornehmen, z. B. das Tag umbenennen, seine Attribute ändern, neue Attribute hinzufügen und Attribute löschen.
>>> soup = BeautifulSoup('<b class="bolder">Very Bold</b>')
>>> tag = soup.bDas Ändern und Hinzufügen neuer Attribute erfolgt wie folgt:
>>> tag.name = 'Blockquote'
>>> tag['class'] = 'Bolder'
>>> tag['id'] = 1.1
>>> tag
<Blockquote class="Bolder" id="1.1">Very Bold</Blockquote>Das Löschen von Attributen ist wie folgt:
>>> del tag['class']
>>> tag
<Blockquote id="1.1">Very Bold</Blockquote>
>>> del tag['id']
>>> tag
<Blockquote>Very Bold</Blockquote>.String ändern
Sie können das .string-Attribut des Tags einfach ändern.
>>> markup = '<a href="https://www.tutorialspoint.com/index.htm">Must for every <i>Learner>/i<</a>'
>>> Bsoup = BeautifulSoup(markup)
>>> tag = Bsoup.a
>>> tag.string = "My Favourite spot."
>>> tag
<a href="https://www.tutorialspoint.com/index.htm">My Favourite spot.</a>Von oben können wir sehen, ob das Tag ein anderes Tag enthält. Sie und ihr gesamter Inhalt werden durch neue Daten ersetzt.
append ()
Das Hinzufügen neuer Daten / Inhalte zu einem vorhandenen Tag erfolgt mithilfe der tag.append () -Methode. Es ist der Methode append () in der Python-Liste sehr ähnlich.
>>> markup = '<a href="https://www.tutorialspoint.com/index.htm">Must for every <i>Learner</i></a>'
>>> Bsoup = BeautifulSoup(markup)
>>> Bsoup.a.append(" Really Liked it")
>>> Bsoup
<html><body><a href="https://www.tutorialspoint.com/index.htm">Must for every <i>Learner</i> Really Liked it</a></body></html>
>>> Bsoup.a.contents
['Must for every ', <i>Learner</i>, ' Really Liked it']NavigableString () und .new_tag ()
Wenn Sie einem Dokument eine Zeichenfolge hinzufügen möchten, können Sie dies einfach mit dem Konstruktor append () oder NavigableString () tun.
>>> soup = BeautifulSoup("<b></b>")
>>> tag = soup.b
>>> tag.append("Start")
>>>
>>> new_string = NavigableString(" Your")
>>> tag.append(new_string)
>>> tag
<b>Start Your</b>
>>> tag.contents
['Start', ' Your']Note: Wenn Sie beim Zugriff auf die Funktion NavigableString () einen Namensfehler finden, gehen Sie wie folgt vor:
NameError: Der Name 'NavigableString' ist nicht definiert
Importieren Sie einfach das NavigableString-Verzeichnis aus dem bs4-Paket -
>>> from bs4 import NavigableStringWir können den obigen Fehler beheben.
Sie können Kommentare zu Ihren vorhandenen Tags hinzufügen oder eine andere Unterklasse von NavigableString hinzufügen. Rufen Sie einfach den Konstruktor auf.
>>> from bs4 import Comment
>>> adding_comment = Comment("Always Learn something Good!")
>>> tag.append(adding_comment)
>>> tag
<b>Start Your<!--Always Learn something Good!--></b>
>>> tag.contents
['Start', ' Your', 'Always Learn something Good!']Das Hinzufügen eines ganz neuen Tags (das nicht an ein vorhandenes Tag angehängt wird) kann mit der in Beautifulsoup integrierten Methode BeautifulSoup.new_tag () - erfolgen.
>>> soup = BeautifulSoup("<b></b>")
>>> Otag = soup.b
>>>
>>> Newtag = soup.new_tag("a", href="https://www.tutorialspoint.com")
>>> Otag.append(Newtag)
>>> Otag
<b><a href="https://www.tutorialspoint.com"></a></b>Nur das erste Argument, der Tag-Name, ist erforderlich.
einfügen()
Ähnlich wie bei der Methode .insert () in der Python-Liste fügt tag.insert () ein neues Element ein. Im Gegensatz zu tag.append () steht das neue Element jedoch nicht unbedingt am Ende des Inhalts des übergeordneten Elements. Neues Element kann an jeder Position hinzugefügt werden.
>>> markup = '<a href="https://www.djangoproject.com/community/">Django Official website <i>Huge Community base</i></a>'
>>> soup = BeautifulSoup(markup)
>>> tag = soup.a
>>>
>>> tag.insert(1, "Love this framework ")
>>> tag
<a href="https://www.djangoproject.com/community/">Django Official website Love this framework <i>Huge Community base</i></a>
>>> tag.contents
['Django Official website ', 'Love this framework ', <i>Huge Community base</i
>]
>>>insert_before () und insert_after ()
Um ein Tag oder einen String kurz vor etwas in den Analysebaum einzufügen, verwenden wir insert_before () -
>>> soup = BeautifulSoup("Brave")
>>> tag = soup.new_tag("i")
>>> tag.string = "Be"
>>>
>>> soup.b.string.insert_before(tag)
>>> soup.b
<b><i>Be</i>Brave</b>Verwenden Sie insert_after (), um ein Tag oder eine Zeichenfolge direkt nach etwas im Analysebaum einzufügen.
>>> soup.b.i.insert_after(soup.new_string(" Always "))
>>> soup.b
<b><i>Be</i> Always Brave</b>
>>> soup.b.contents
[<i>Be</i>, ' Always ', 'Brave']klar()
Verwenden Sie tag.clear () -, um den Inhalt eines Tags zu entfernen.
>>> markup = '<a href="https://www.tutorialspoint.com/index.htm">For <i>technical & Non-technical&lr;/i> Contents</a>'
>>> soup = BeautifulSoup(markup)
>>> tag = soup.a
>>> tag
<a href="https://www.tutorialspoint.com/index.htm">For <i>technical & Non-technical</i> Contents</a>
>>>
>>> tag.clear()
>>> tag
<a href="https://www.tutorialspoint.com/index.htm"></a>Extrakt()
Verwenden Sie PageElement.extract (), um ein Tag oder Zeichenfolgen aus dem Baum zu entfernen.
>>> markup = '<a href="https://www.tutorialspoint.com/index.htm">For <i&gr;technical & Non-technical</i> Contents</a>'
>>> soup = BeautifulSoup(markup)
>>> a_tag = soup.a
>>>
>>> i_tag = soup.i.extract()
>>>
>>> a_tag
<a href="https://www.tutorialspoint.com/index.htm">For Contents</a>
>>>
>>> i_tag
<i>technical & Non-technical</i>
>>>
>>> print(i_tag.parent)
Nonezersetzen()
Die tag.decompose () entfernt ein Tag aus dem Baum und löscht seinen gesamten Inhalt.
>>> markup = '<a href="https://www.tutorialspoint.com/index.htm">For <i>technical & Non-technical</i> Contents</a>'
>>> soup = BeautifulSoup(markup)
>>> a_tag = soup.a
>>> a_tag
<a href="https://www.tutorialspoint.com/index.htm">For <i>technical & Non-technical</i> Contents</a>
>>>
>>> soup.i.decompose()
>>> a_tag
<a href="https://www.tutorialspoint.com/index.htm">For Contents</a>
>>>Ersetzen mit()
Wie der Name schon sagt, ersetzt die Funktion pageElement.replace_with () das alte Tag oder die alte Zeichenfolge durch das neue Tag oder die neue Zeichenfolge im Baum.
>>> markup = '<a href="https://www.tutorialspoint.com/index.htm">Complete Python <i>Material</i></a>'
>>> soup = BeautifulSoup(markup)
>>> a_tag = soup.a
>>>
>>> new_tag = soup.new_tag("Official_site")
>>> new_tag.string = "https://www.python.org/"
>>> a_tag.i.replace_with(new_tag)
<i>Material</i>
>>>
>>> a_tag
<a href="https://www.tutorialspoint.com/index.htm">Complete Python <Official_site>https://www.python.org/</Official_site></a>In der obigen Ausgabe haben Sie festgestellt, dass replace_with () das Tag oder die Zeichenfolge zurückgibt, die ersetzt wurden (wie in unserem Fall „Material“), sodass Sie es untersuchen oder einem anderen Teil des Baums hinzufügen können.
wickeln()
Das pageElement.wrap () hat ein Element in das von Ihnen angegebene Tag eingeschlossen und gibt einen neuen Wrapper zurück -
>>> soup = BeautifulSoup("<p>tutorialspoint.com</p>")
>>> soup.p.string.wrap(soup.new_tag("b"))
<b>tutorialspoint.com</b>
>>>
>>> soup.p.wrap(soup.new_tag("Div"))
<Div><p><b>tutorialspoint.com</b></p></Div>auspacken()
Die Datei tag.unwrap () befindet sich genau gegenüber von wrap () und ersetzt ein Tag durch das, was sich in diesem Tag befindet.
>>> soup = BeautifulSoup('<a href="https://www.tutorialspoint.com/">I liked <i>tutorialspoint</i></a>')
>>> a_tag = soup.a
>>>
>>> a_tag.i.unwrap()
<i></i>
>>> a_tag
<a href="https://www.tutorialspoint.com/">I liked tutorialspoint</a>Von oben haben Sie bemerkt, dass unwrap () wie replace_with () das ersetzte Tag zurückgibt.
Unten finden Sie ein weiteres Beispiel für unwrap (), um es besser zu verstehen -
>>> soup = BeautifulSoup("<p>I <strong>AM</strong> a <i>text</i>.</p>")
>>> soup.i.unwrap()
<i></i>
>>> soup
<html><body><p>I <strong>AM</strong> a text.</p></body></html>unwrap () eignet sich zum Entfernen von Markups.
Alle HTML- oder XML-Dokumente sind in einer bestimmten Codierung wie ASCII oder UTF-8 geschrieben. Wenn Sie dieses HTML / XML-Dokument jedoch in BeautifulSoup laden, wurde es in Unicode konvertiert.
>>> markup = "<p>I will display £</p>"
>>> Bsoup = BeautifulSoup(markup)
>>> Bsoup.p
<p>I will display £</p>
>>> Bsoup.p.string
'I will display £'Das obige Verhalten ist darauf zurückzuführen, dass BeautifulSoup intern die Unterbibliothek Unicode Dammit verwendet, um die Codierung eines Dokuments zu erkennen und sie dann in Unicode zu konvertieren.
Allerdings nicht die ganze Zeit, der Unicode, errät Dammit richtig. Da das Dokument Byte für Byte durchsucht wird, um die Codierung zu erraten, nimmt dies viel Zeit in Anspruch. Sie können Zeit sparen und Fehler vermeiden, wenn Sie die Codierung bereits kennen, indem Sie sie als from_encoding an den BeautifulSoup-Konstruktor übergeben.
Im Folgenden finden Sie ein Beispiel, in dem die BeautifulSoup ein ISO-8859-8-Dokument als ISO-8859-7 falsch identifiziert.
>>> markup = b"<h1>\xed\xe5\xec\xf9</h1>"
>>> soup = BeautifulSoup(markup)
>>> soup.h1
<h1>νεμω</h1>
>>> soup.original_encoding
'ISO-8859-7'
>>>Um das oben genannte Problem zu beheben, übergeben Sie es mit from_encoding an BeautifulSoup.
>>> soup = BeautifulSoup(markup, from_encoding="iso-8859-8")
>>> soup.h1
<h1>ולש </h1>
>>> soup.original_encoding
'iso-8859-8'
>>>Eine weitere neue Funktion von BeautifulSoup 4.4.0 ist exclude_encoding. Es kann verwendet werden, wenn Sie die richtige Codierung nicht kennen, aber sicher sind, dass Unicode, Dammit ein falsches Ergebnis anzeigt.
>>> soup = BeautifulSoup(markup, exclude_encodings=["ISO-8859-7"])Ausgabecodierung
Die Ausgabe einer BeautifulSoup ist ein UTF-8-Dokument, unabhängig vom eingegebenen Dokument in BeautifulSoup. Unterhalb eines Dokuments, in dem sich die polnischen Zeichen im ISO-8859-2-Format befinden.
html_markup = """
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-2">
</HEAD>
<BODY>
ą ć ę ł ń ó ś ź ż Ą Ć Ę Ł Ń Ó Ś Ź Ż
</BODY>
</HTML>
"""
>>> soup = BeautifulSoup(html_markup)
>>> print(soup.prettify())
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta content="text/html; charset=utf-8" http-equiv="content-type"/>
</head>
<body>
ą ć ę ł ń ó ś ź ż Ą Ć Ę Ł Ń Ó Ś Ź Ż
</body>
</html>Wenn Sie im obigen Beispiel feststellen, wurde das <meta> -Tag neu geschrieben, um das von BeautifulSoup generierte Dokument im UTF-8-Format wiederzugeben.
Wenn Sie die generierte Ausgabe in UTF-8 nicht möchten, können Sie die gewünschte Codierung in prettify () zuweisen.
>>> print(soup.prettify("latin-1"))
b'<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">\n<html>\n <head>\n <meta content="text/html; charset=latin-1" http-equiv="content-type"/>\n </head>\n <body>\n ą ć ę ł ń \xf3 ś ź ż Ą Ć Ę Ł Ń \xd3 Ś Ź Ż\n </body>\n</html>\n'Im obigen Beispiel haben wir das gesamte Dokument codiert. Sie können jedoch jedes bestimmte Element in der Suppe codieren, als wäre es eine Python-Zeichenfolge.
>>> soup.p.encode("latin-1")
b'<p>0My first paragraph.</p>'
>>> soup.h1.encode("latin-1")
b'<h1>My First Heading</h1>'Alle Zeichen, die in der von Ihnen gewählten Codierung nicht dargestellt werden können, werden in numerische XML-Entitätsreferenzen konvertiert. Unten ist ein solches Beispiel -
>>> markup = u"<b>\N{SNOWMAN}</b>"
>>> snowman_soup = BeautifulSoup(markup)
>>> tag = snowman_soup.b
>>> print(tag.encode("utf-8"))
b'<b>\xe2\x98\x83</b>'Wenn Sie versuchen, das Obige in "Latin-1" oder "ASCII" zu codieren, wird "☃" generiert, was darauf hinweist, dass es dafür keine Darstellung gibt.
>>> print (tag.encode("latin-1"))
b'<b>☃</b>'
>>> print (tag.encode("ascii"))
b'<b>☃</b>'Unicode, verdammt
Unicode, Dammit wird hauptsächlich verwendet, wenn das eingehende Dokument in einem unbekannten Format (hauptsächlich in einer Fremdsprache) vorliegt und wir in einem bekannten Format (Unicode) codieren möchten. Außerdem benötigen wir nicht Beautifulsoup, um all dies zu tun.
Der Ausgangspunkt eines BeautifulSoup-Projekts ist das BeautifulSoup-Objekt. Ein BeautifulSoup-Objekt repräsentiert das für seine Erstellung verwendete HTML / XML-Eingabedokument.
Wir können entweder eine Zeichenfolge oder ein dateiähnliches Objekt für Beautiful Soup übergeben, wobei Dateien (Objekte) entweder lokal auf unserem Computer oder auf einer Webseite gespeichert werden.
Die häufigsten BeautifulSoup-Objekte sind -
- Tag
- NavigableString
- BeautifulSoup
- Comment
Objekte auf Gleichheit vergleichen
Gemäß der schönen Suppe sind zwei navigierbare Zeichenfolgen- oder Tag-Objekte gleich, wenn sie dasselbe HTML / XML-Markup darstellen.
Lassen Sie uns nun das folgende Beispiel sehen, in dem die beiden <b> -Tags als gleich behandelt werden, obwohl sie sich in verschiedenen Teilen des Objektbaums befinden, da beide wie "<b> Java </ b>" aussehen.
>>> markup = "<p>Learn Python and <b>Java</b> and advanced <b>Java</b>! from Tutorialspoint</p>"
>>> soup = BeautifulSoup(markup, "html.parser")
>>> first_b, second_b = soup.find_all('b')
>>> print(first_b == second_b)
True
>>> print(first_b.previous_element == second_b.previous_element)
FalseUm jedoch zu überprüfen, ob sich die beiden Variablen auf dieselben Objekte beziehen, können Sie Folgendes verwenden:
>>> print(first_b is second_b)
FalseKopieren von schönen Suppenobjekten
Verwenden Sie die Funktion copy.copy (), um eine Kopie eines Tags oder NavigableString zu erstellen.
>>> import copy
>>> p_copy = copy.copy(soup.p)
>>> print(p_copy)
<p>Learn Python and <b>Java</b> and advanced <b>Java</b>! from Tutorialspoint</p>
>>>Obwohl die beiden Kopien (Original und kopierte Kopie) dasselbe Markup enthalten, stellen die beiden nicht dasselbe Objekt dar -
>>> print(soup.p == p_copy)
True
>>>
>>> print(soup.p is p_copy)
False
>>>Der einzige wirkliche Unterschied besteht darin, dass die Kopie vollständig vom ursprünglichen Beautiful Soup-Objektbaum getrennt ist, als ob extract () darauf aufgerufen worden wäre.
>>> print(p_copy.parent)
NoneDas obige Verhalten ist auf zwei verschiedene Tag-Objekte zurückzuführen, die nicht gleichzeitig denselben Platz belegen können.
Es gibt mehrere Situationen, in denen Sie bestimmte Arten von Informationen (nur <a> -Tags) mit Beautifulsoup4 extrahieren möchten. Mit der SoupStrainer-Klasse in Beautifulsoup können Sie nur einen bestimmten Teil eines eingehenden Dokuments analysieren.
Eine Möglichkeit besteht darin, einen SoupStrainer zu erstellen und ihn als parse_only-Argument an den Beautifulsoup4-Konstruktor weiterzugeben.
SoupStrainer
Ein SoupStrainer teilt BeautifulSoup mit, welche Teile extrahiert werden, und der Analysebaum besteht nur aus diesen Elementen. Wenn Sie Ihre erforderlichen Informationen auf einen bestimmten Teil des HTML-Codes eingrenzen, beschleunigt dies Ihr Suchergebnis.
product = SoupStrainer('div',{'id': 'products_list'})
soup = BeautifulSoup(html,parse_only=product)In den obigen Codezeilen werden nur die Titel einer Produktwebsite analysiert, die sich möglicherweise in einem Tag-Feld befinden.
In ähnlicher Weise können wir wie oben andereoupStrainer-Objekte verwenden, um bestimmte Informationen aus einem HTML-Tag zu analysieren. Nachfolgend einige Beispiele -
from bs4 import BeautifulSoup, SoupStrainer
#Only "a" tags
only_a_tags = SoupStrainer("a")
#Will parse only the below mentioned "ids".
parse_only = SoupStrainer(id=["first", "third", "my_unique_id"])
soup = BeautifulSoup(my_document, "html.parser", parse_only=parse_only)
#parse only where string length is less than 10
def is_short_string(string):
return len(string) < 10
only_short_strings =SoupStrainer(string=is_short_string)Fehlerbehandlung
Es gibt zwei Hauptarten von Fehlern, die in BeautifulSoup behandelt werden müssen. Diese beiden Fehler stammen nicht aus Ihrem Skript, sondern aus der Struktur des Snippets, da die BeautifulSoup-API einen Fehler auslöst.
Die zwei Hauptfehler sind wie folgt:
AttributeError
Dies wird verursacht, wenn die Punktnotation kein Geschwister-Tag für das aktuelle HTML-Tag findet. Möglicherweise ist dieser Fehler aufgetreten, da der Kostenschlüssel aufgrund des fehlenden „Ankertags“ beim Durchlaufen einen Fehler auslöst und ein Ankertag erfordert.
KeyError
Dieser Fehler tritt auf, wenn das erforderliche HTML-Tag-Attribut fehlt. Wenn wir beispielsweise kein Daten-PID-Attribut in einem Snippet haben, löst der PID-Schlüssel einen Schlüsselfehler aus.
Um die beiden oben aufgeführten Fehler beim Parsen eines Ergebnisses zu vermeiden, wird dieses Ergebnis umgangen, um sicherzustellen, dass kein fehlerhaftes Snippet in die Datenbanken eingefügt wird.
except(AttributeError, KeyError) as er:
passdiagnostizieren()
Wenn wir Schwierigkeiten haben zu verstehen, was BeautifulSoup mit unserem Dokument oder HTML macht, übergeben Sie es einfach an die Funktion diagnostose (). Wenn Sie die Dokumentdatei an die Funktion diagnostose () übergeben, können Sie zeigen, wie die Liste der verschiedenen Parser mit dem Dokument umgeht.
Im Folgenden finden Sie ein Beispiel für die Verwendung der Funktion diagnostose ().
from bs4.diagnose import diagnose
with open("20 Books.html",encoding="utf8") as fp:
data = fp.read()
diagnose(data)Ausgabe
Analysefehler
Es gibt zwei Haupttypen von Analysefehlern. Möglicherweise erhalten Sie eine Ausnahme wie HTMLParseError, wenn Sie Ihr Dokument an BeautifulSoup weiterleiten. Möglicherweise erhalten Sie auch ein unerwartetes Ergebnis, bei dem der Analysebaum von BeautifulSoup stark vom erwarteten Ergebnis des Analysedokuments abweicht.
Keiner der Analysefehler wird durch BeautifulSoup verursacht. Dies liegt an dem von uns verwendeten externen Parser (html5lib, lxml), da BeautifulSoup keinen Parser-Code enthält. Eine Möglichkeit, den obigen Analysefehler zu beheben, besteht darin, einen anderen Parser zu verwenden.
from HTMLParser import HTMLParser
try:
from HTMLParser import HTMLParseError
except ImportError, e:
# From python 3.5, HTMLParseError is removed. Since it can never be
# thrown in 3.5, we can just define our own class as a placeholder.
class HTMLParseError(Exception):
passDer in Python integrierte HTML-Parser verursacht zwei häufigste Analysefehler: HTMLParser.HTMLParserError: fehlerhaftes Start-Tag und HTMLParser.HTMLParserError: Bad-End-Tag. Um dies zu beheben, wird hauptsächlich ein anderer Parser verwendet: lxml oder html5lib.
Eine weitere häufige Art von unerwartetem Verhalten besteht darin, dass Sie kein Tag finden, von dem Sie wissen, dass es sich im Dokument befindet. Wenn Sie jedoch find_all () ausführen, wird [] oder find () None zurückgegeben.
Dies kann daran liegen, dass der in Python integrierte HTML-Parser manchmal Tags überspringt, die er nicht versteht.
XML-Parser-Fehler
Standardmäßig analysiert das BeautifulSoup-Paket die Dokumente als HTML. Es ist jedoch sehr einfach zu verwenden und verarbeitet schlecht geformtes XML auf sehr elegante Weise mit beautifulsoup4.
Um das Dokument als XML zu analysieren, benötigen Sie einen lxml-Parser und müssen nur die "xml" als zweites Argument an den Beautifulsoup-Konstruktor übergeben.
soup = BeautifulSoup(markup, "lxml-xml")oder
soup = BeautifulSoup(markup, "xml")Ein häufiger XML-Analysefehler ist -
AttributeError: 'NoneType' object has no attribute 'attrib'Dies kann vorkommen, wenn bei Verwendung der Funktion find () oder findall () ein Element fehlt oder nicht definiert ist.
Andere Analysefehler
Im Folgenden sind einige der anderen Analysefehler aufgeführt, die wir in diesem Abschnitt behandeln werden.
Umweltproblem
Abgesehen von den oben genannten Analysefehlern können andere Analyseprobleme auftreten, z. B. Umweltprobleme, bei denen Ihr Skript möglicherweise in einem Betriebssystem, jedoch nicht in einem anderen Betriebssystem oder in einer virtuellen Umgebung, jedoch nicht in einer anderen virtuellen Umgebung oder möglicherweise nicht funktioniert außerhalb der virtuellen Umgebung. All diese Probleme können darauf zurückzuführen sein, dass in beiden Umgebungen unterschiedliche Parser-Bibliotheken verfügbar sind.
Es wird empfohlen, Ihren Standardparser in Ihrer aktuellen Arbeitsumgebung zu kennen oder zu überprüfen. Sie können den aktuellen Standardparser überprüfen, der für die aktuelle Arbeitsumgebung verfügbar ist, oder die erforderliche Parser-Bibliothek explizit als zweites Argument an den BeautifulSoup-Konstruktor übergeben.
Groß- und Kleinschreibung wird nicht berücksichtigt
Da bei HTML-Tags und -Attributen die Groß- und Kleinschreibung nicht berücksichtigt wird, konvertieren alle drei HTML-Parser Tag- und Attributnamen in Kleinbuchstaben. Wenn Sie jedoch Tags und Attribute in Groß- oder Kleinschreibung beibehalten möchten, ist es besser, das Dokument als XML zu analysieren.
UnicodeEncodeError
Schauen wir uns das folgende Codesegment an -
soup = BeautifulSoup(response, "html.parser")
print (soup)Ausgabe
UnicodeEncodeError: 'charmap' codec can't encode character '\u011f'Das obige Problem kann auf zwei Hauptsituationen zurückzuführen sein. Möglicherweise versuchen Sie, ein Unicode-Zeichen auszudrucken, das auf Ihrer Konsole nicht angezeigt werden kann. Zweitens versuchen Sie, in eine Datei zu schreiben, und übergeben ein Unicode-Zeichen, das von Ihrer Standardcodierung nicht unterstützt wird.
Eine Möglichkeit, das obige Problem zu lösen, besteht darin, den Antworttext / das Antwortzeichen vor der Zubereitung der Suppe zu codieren, um das gewünschte Ergebnis zu erzielen.
responseTxt = response.text.encode('UTF-8')KeyError: [attr]
Dies wird durch den Zugriff auf das Tag ['attr'] verursacht, wenn das betreffende Tag das Attribut attr nicht definiert. Die häufigsten Fehler sind: "KeyError: 'href'" und "KeyError: 'class'". Verwenden Sie tag.get ('attr'), wenn Sie nicht sicher sind, ob attr definiert ist.
for item in soup.fetch('a'):
try:
if (item['href'].startswith('/') or "tutorialspoint" in item['href']):
(...)
except KeyError:
pass # or some other fallback actionAttributeError
Sie können auf AttributeError wie folgt stoßen:
AttributeError: 'list' object has no attribute 'find_all'Der obige Fehler tritt hauptsächlich auf, weil Sie erwartet haben, dass find_all () ein einzelnes Tag oder eine einzelne Zeichenfolge zurückgibt. Oup.find_all gibt jedoch eine Python-Liste von Elementen zurück.
Alles, was Sie tun müssen, ist, die Liste zu durchlaufen und Daten von diesen Elementen abzufangen.