Crawler-Analysemethode 2: Beautifulsoup

Viele Sprachen können crawlen, aber Python-basierte Crawler sind prägnanter und bequemer. Crawler sind auch zu einem wesentlichen Bestandteil der Python-Sprache geworden. Es gibt auch viele Möglichkeiten, Crawler zu analysieren.

Jeder muss die Verwendung der Requests-Bibliothek beherrschen, aber wenn wir Requests verwenden, um die HTML-Codeinformationen der Webseite zu erhalten, wie können wir dann die gewünschten Informationen abrufen? Ich glaube, Sie müssen viele Methoden ausprobiert haben, beispielsweise die Suchmethode für Zeichenfolgen und fortgeschrittenere reguläre Ausdrücke. Obwohl reguläre Ausdrücke die von uns benötigten Informationen abgleichen können, glaube ich, dass jeder sehr frustriert sein muss, wenn er die regulären Abgleichsregeln immer wieder ausprobiert, um eine bestimmte Zeichenfolge abzugleichen.

Dann werden wir uns fragen, ob es ein praktischeres Tool gibt. Die Antwort lautet: Ja, wir haben auch ein leistungsstarkes Tool namens BeautifulSoup. Damit können wir den Inhalt ganz einfach in HTML- oder XML-Tags extrahieren. In diesem Artikel lernen wir die gängigen Methoden von BeautifulSoup kennen.

Im vorherigen Artikel wurde Ihnen die Crawler-Analysemethode 1: JOSN-Analyse erläutert.

Was ist BeautifulSoup?

Das Parsen von Python-Webseiten kann mit regulären Ausdrücken abgeschlossen werden. Wenn wir also schreiben, müssen wir die Codes einzeln abgleichen und auch Abgleichsregeln schreiben. Die Gesamtimplementierung ist sehr kompliziert . Bei BeautifulSoup handelt es sich um eine praktische Webseiten-Parsing-Bibliothek mit effizienter Verarbeitung und Unterstützung mehrerer Parser. In den meisten Fällen können wir damit problemlos Webseiteninformationen extrahieren, ohne reguläre Ausdrücke schreiben zu müssen.

Offizielle Dokumente

Installation: $ pip install beautifulsoup4

BeautifulSoup ist eine Bibliothek zum Parsen von Webseiten, die viele Parser unterstützt, aber es gibt zwei, die am weitesten verbreitet sind. Eine davon ist die Python-Standardbibliothek und die andere ist der lxml-HTML-Parser. Die Verwendung der beiden ist ähnlich:

from bs4 import BeautifulSoup
 
# Python的标准库
BeautifulSoup(html, 'html.parser')
 
# lxml
BeautifulSoup(html, 'lxml')

Die Ausführungsgeschwindigkeit der integrierten Standardbibliothek von Python ist durchschnittlich, aber in niedrigeren Versionen von Python ist die Fehlertoleranz von Chinesisch relativ schlecht. Die Ausführungsgeschwindigkeit des lxmlHTML-Parsers ist hoch, erfordert jedoch die Installation von C-Sprachabhängigen Bibliotheken.

Installation von lxml

Da die Installation von lxml von der C-Sprachbibliothek abhängt, werden wir bei der Installation von lxml unter Windows natürlich verschiedene seltsame Fehler feststellen Für eine erfolgreiche Installation empfiehlt es sich, pip install lxml

zu verwenden. Aber die meisten Menschen werden hierher fallen.

Es wird empfohlen, für die Installation die .whl-Datei von lxml zu verwenden. Zuerst müssen wir die Radbibliothek installieren. Nur mit dieser Bibliothek können wir die .whl-Datei normal installieren. pip install wheel

Laden Sie die zum System und zur Python-Version passende lxml-Datei von der offiziellen Website herunter.

Außerdem Freunde, die ihre eigenen System- und Python-Versionsinformationen nicht kennen. Sie müssen das Systemadministrator-Tool (CMD) oder Pythons IDLE aufrufen und den folgenden Code eingeben:

import pip
 
print(pip.pep425tags.get_supported())

Dann können wir die gedruckten Python-Versionsinformationen sehen.
Nachdem wir die lxml-Datei heruntergeladen haben, müssen wir den Speicherort der Datei finden, dann das Administrator-Tool aufrufen und mit pip installieren: pip install Der vollständige Name der WHL-Datei

Nachdem die Installation abgeschlossen ist , Sie können Python eingeben und importieren. Wenn kein Fehler gemeldet wird, herzlichen Glückwunsch zur erfolgreichen Installation.
Wenn einige Freunde es als problematisch empfinden, empfehle ich Ihnen, die Anaconda-Download-Adresse zu installieren (wenn die Installationsgeschwindigkeit langsam ist, können Sie es bei Google verwenden). Diejenigen, die pip unter Windows verwenden, haben keine Probleme mehr mit Installationsfehlern.

Die grundlegende Tag-Auswahlmethode von BeautifulSoup

Obwohl Pythons integrierter Standardbibliotheksparser nicht schlecht ist, kann ich ihn dennoch jedem empfehlen .lxml, weil es schnell genug ist. Anschließend verwenden wir den lxml-Parser zur Demonstration im folgenden Code.
Wir importieren zuerst das offizielle Dokumentbeispiel:

html_doc = """
<html><head><title>The Dormouse&#39;s story</title></head>
<body>
<p class="title"><b>The Dormouse&#39;s story</b></p>
 
<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>
 
<p class="story">...</p>
"""

HTML-Code, wir können ein BeautifulSoup-Objekt erhalten und es gemäß der Standardstruktur im eingerückten Format ausgeben:

from bs4 import BeautifulSoup
soup = BeautifulSoup(html_doc, 'lxml')

Wir können sehen, dass der obige HTML-Code nicht vollständig ist. Als nächstes verwenden wir die Methode prettify(), um die automatische Vervollständigung durchzuführen:

print(soup.prettify())
# <html>
#  <head>
#   <title>
#    The Dormouse&#39;s story
#   </title>
#  </head>
#  <body>
#   <p class="title">
#    <b>
#     The Dormouse&#39;s story
#    </b>
#   </p>
#   <p class="story">
#    Once upon a time there were three little sisters; and their names were
#    <a class="sister" href="http://example.com/elsie" id="link1">
#     Elsie
#    </a>
#    ,
#    <a class="sister" href="http://example.com/lacie" id="link2">
#     Lacie
#    </a>
#    and
#    <a class="sister" href="http://example.com/tillie" id="link2">
#     Tillie
#    </a>
#    ; and they lived at the bottom of a well.
#   </p>
#   <p class="story">
#    ...
#   </p>
#  </body>
# </html>

Tag abrufen

print(soup.title)
# <title>The Dormouse&#39;s story</title>

Durch die Ausgabe des Ergebnisses können wir das Attribut zum Abrufen des Inhalts sehen, bei dem es sich tatsächlich um ein Titel-Tag im handelt HTML-Code.

Hol dir den Namen

print(soup.title.name)
# 'title'

ist eigentlich der Name des Labels.

Attribute abrufen

print(soup.p.attrs['class'])
# 'title'
 
print(soup.p['class'])
# 'title'

Um die Attribute einer Beschriftung abzurufen, können wir die Methode attrs verwenden und ihr den Attributnamen übergeben, um die zu erhalten Attribute des Etiketts. Aus den Ergebnissen können wir ersehen, dass Sie auch das Tag-Attribut erhalten können, wenn Sie den p-Tag-Attributnamen direkt übergeben.

Inhalte abrufen

print(soup.title.string)
# 'The Dormouse's story'

   

我们还可以使用嵌套的选择，比如我们获得body标签里面p标签的内容：

print(soup.body.p.string)
# 'The Dormouse's story'

   

常见用法

标准选择器

虽然BeautifulSoup的基本用法，标签获取，内容获取，可以解析一些 html代码。但是在遇到很多复杂的页面时，上面的方法是完全不足的，或者是很繁琐的，因为有时候有的标签会有几个属性（class、id等）。

索性BeautifulSoup给我们提供了很方便的标准选择器，也就是 API 方法，这里着重介绍2个: find() 和 find_all() 。其它方法的参数和用法类似,大家举一反三吧。

find_all()

find_all(name, attrs, recursive, text, **kwargs)可以根据标签，属性，内容查找文档。
find_all()其实和正则表达式的原理很相似，他能找出所有能满足匹配模式的结果，在把结果以列表的形式返回。
仍然是文档的例子：

html_doc = """
<html><head><title>The Dormouse&#39;s story</title></head>
<body>
<p class="title"><b>The Dormouse&#39;s story</b></p>
 
<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>
 
<p class="story">...</p>
"""
from bs4 import BeautifulSoup
 
soup = BeautifulSoup(html_doc, 'lxml')

   

过滤器

文档参考
介绍 find_all() 方法前,大家可以参考一下过滤器的类型。过滤器只能作为搜索文档的参数,或者说应该叫参数类型更为贴切。这些过滤器贯穿整个搜索的API。过滤器可以被用在 tag 的name中,节点的属性中,字符串中或他们的混合中。

find_all() 方法搜索当前 tag 的所有 tag 子节点,并判断是否符合过滤器的条件。这里有几个例子:

soup.find_all("title")
# [<title>The Dormouse&#39;s story</title>]
 
soup.find_all("p", "title")
# [<p class="title"><b>The Dormouse&#39;s story</b></p>]
 
soup.find_all("a")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
 
soup.find_all(id="link2")
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

   

有几个方法很相似,还有几个方法是新的,参数中的 string 和id是什么含义? 为什么 find_all("p", "title") 返回的是CSS Class为”title”的标签? 我们来仔细看一下find_all()的参数:

name参数

name 参数可以查找所有名字为 name 的 tag,字符串对象会被自动忽略掉。

soup.find_all("title")
# [The Dormouse's story]

   

搜索 name 参数的值可以使任一类型的过滤器,字符窜,正则表达式,列表,方法或是True 。
我们常用的 name 参数是搜索文档的标签名。

keyword参数

如果我们的 HTML代码中有几个div标签，但是我们只想获取到class属性为top的div标签，我们怎么出来呢。

soup.find_all('div', class_='top')

# 这里注意下，class是Python的内部关键词，我们需要在css属性class后面加一个下划线'_'，不然会报错。

   

仍然以上面的代码实例：

soup.find_all('a', id='link2')
# [<a id="link2" href="http://example.com/lacie">Lacie</a>]

   

这样我们就只获取到id为link2的a标签。

limit参数

find_all() 方法返回全部的搜索结构,如果文档树很大那么搜索会很慢。如果我们不需要全部结果,可以使用 limit 参数限制返回结果的数量。效果与 SQL 中的limit关键字类似,当搜索到的结果数量达到limit的限制时,就停止搜索返回结果。

比如我们要搜索出a标签，但是满足的有3个，我们只想要得到2个：

soup.find_all("a", limit=2)
# [<a id="link1" class="sister" href="http://example.com/elsie">Elsie</a>,
# <a id="link2" class="sister" href="http://example.com/lacie">Lacie</a>]

   

其他的参数，不是经常用到，大家如需了解可以参考官方文档。

find()

find_all()返回的是所有元素列表，find()返回单个元素。

find( name , attrs , recursive , string , **kwargs )

find_all()方法将返回文档中符合条件的所有 tag,尽管有时候我们只想得到一个结果。比如文档中只有一个标签,那么使用find_all()方法来查找标签就不太合适, 使用find_all方法并设置limit=1参数不如直接使用find()方法。下面两行代码是等价的:

soup.find_all('title', limit=1)
# [The Dormouse's story]
 
soup.find('title')
#The Dormouse's story

   

唯一的区别是find_all()方法的返回结果是值包含一个元素的列表,而find()方法直接返回结果。find_all()方法没有找到目标是返回空列表, find()方法找不到目标时,返回None。

CSS选择器

Beautiful Soup支持大部分的 CSS选择器。在Tag或BeautifulSoup对象的.select()方法中传入字符串参数, 即可使用 CSS选择器的语法找到 tag。我们在写 css 时，标签 class类名加”.“，id属性加”#“。

soup.select("title")
# [The Dormouse's story]

   

通过 tag标签逐层查找:

soup.select("body a")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie"  id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
 
soup.select("html head title")
# [<title>The Dormouse&#39;s story</title>]

   

找到某个 tag标签下的直接子标签:

soup.select("head > title")
# [<title>The Dormouse&#39;s story</title>]
 
soup.select("p > a")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie"  id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]
 
soup.select("p > #link1")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]
 
soup.select("body > a")
# []

   

通过 CSS 的 class类名查找:

soup.select(".sister")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

   

通过 tag 的 id 查找:

soup.select("#link1")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]
 
soup.select("a#link2")
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

   

同时用多种 CSS选择器查询元素，使用逗号隔开:

soup.select("#link1,#link2")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

   

提取标签内容

如果我们得到了几个标签：

list = [<a href="http://www.baidu.com/">百度</a>,
 
<a href="http://www.163.com/">网易</a>,
 
<a href="http://www.sina.com/"新浪</a>]

   

我们要怎样提取他里面的内容呢。我们开始的时候有提及。

for i in list:
    print(i.get_text()) # 我们使用get_text()方法获得标签内容
    print(i.get['href'] # get['attrs']方法获得标签属性
    print(i['href']) # 简写结果一样

   

结果：

百度
网易
新浪
http://www.baidu.com/
http://www.163.com/
http://www.sina.com/
http://www.baidu.com/
http://www.163.com/
http://www.sina.com/

   

总结

Für die Parsing-Bibliothek von BeautifulSoup wird die Verwendung von lxml empfohlen. Wenn verstümmelte Zeichen angezeigt werden, können Sie die Tag-Auswahl- und Filtermethode von BeautifulSoup verwenden. Es wird empfohlen, find_all() und find() zu verwenden. Methoden zum Durchsuchen von Tags. Wenn Sie mit CSS-Selektoren vertraut sind, wird natürlich empfohlen, die Methode .select() zu verwenden, um den Textinhalt des Etiketts abzurufen, und die Methode get[attrs], um den zu erhalten Label-Attributwert.

Das obige ist der detaillierte Inhalt vonCrawler-Analysemethode 2: Beautifulsoup. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!