De nombreux langages peuvent explorer, mais les robots d'exploration basés sur Python sont plus concis et plus pratiques. Les robots d’exploration sont également devenus un élément essentiel du langage Python. Il existe également de nombreuses façons d’analyser les robots.
Tout le monde doit maîtriser l'utilisation de la bibliothèque Requests, mais lorsque nous utilisons Requests pour obtenir les informations du code HTML de la page Web, comment pouvons-nous récupérer les informations souhaitées ? Je pense que vous devez avoir essayé de nombreuses méthodes, telles que la méthode find de chaînes et des expressions régulières plus avancées. Bien que les expressions régulières puissent correspondre aux informations dont nous avons besoin, je pense que tout le monde doit être très frustré lorsqu'il essaie encore et encore les règles de correspondance régulières pour faire correspondre une certaine chaîne.
Ensuite, on se demandera s'il existe un outil plus pratique. La réponse est oui, nous disposons également d’un outil puissant appelé BeautifulSoup. Avec lui, nous pouvons facilement extraire le contenu des balises HTML ou XML. Dans cet article, découvrons les méthodes courantes de BeautifulSoup.
L'article précédent vous a expliqué la méthode d'analyse crawler 1 : analyse JOSN Cet article vous propose l'analyse Beautifulsoup.
Qu'est-ce que BeautifulSoup ?
L'analyse des pages Web de Python peut être complétée à l'aide d'expressions régulières. Ainsi, lorsque nous écrivons, nous devons faire correspondre les codes un par un, et nous devons également écrire des règles de correspondance. La mise en œuvre globale est très compliquée. . Quant à BeautifulSoup, il s'agit d'une bibliothèque d'analyse de pages Web pratique avec un traitement efficace et prenant en charge plusieurs analyseurs. Dans la plupart des cas, nous pouvons l'utiliser pour extraire facilement des informations sur une page Web sans écrire d'expressions régulières.
Documents officiels
Installation : $ pip install beautifulsoup4
BeautifulSoup est une bibliothèque d'analyse de pages Web qui prend en charge de nombreux analyseurs, mais il y en a deux les plus courants. L’une est la bibliothèque standard Python et l’autre est l’analyseur HTML lxml. L'utilisation des deux est similaire :
from bs4 import BeautifulSoup # Python的标准库 BeautifulSoup(html, 'html.parser') # lxml BeautifulSoup(html, 'lxml')
La vitesse d'exécution de la bibliothèque standard intégrée de Python est moyenne, mais dans les versions inférieures de Python, la tolérance aux pannes du chinois est relativement faible. L'analyseur lxmlHTML a une vitesse d'exécution rapide, mais nécessite l'installation de bibliothèques dépendantes du langage C.
Installation de lxml
Étant donné que l'installation de lxml dépend de la bibliothèque du langage C, lorsque lxml est installé sur Windows, nous trouverons diverses erreurs étranges. Bien sûr, le visage est là. est bon d'utiliser pip install lxml
pour installer avec succès. Mais la plupart des gens tomberont ici.
Il est recommandé d'utiliser le fichier .whl de lxml pour l'installation. Nous devons d’abord installer la bibliothèque wheel. Ce n’est qu’avec cette bibliothèque que nous pouvons installer le fichier .whl normalement. pip install wheel
Téléchargez le fichier lxml correspondant au système et à la version Python sur le site officiel.
De plus, les amis qui ne connaissent pas leur propre système et les informations sur la version de Python. Vous devez entrer dans l'outil d'administrateur système (CMD) ou IDLE de Python et entrer le code suivant :
import pip print(pip.pep425tags.get_supported())
Ensuite, nous pouvons voir les informations imprimées sur la version Python.
Après avoir téléchargé le fichier lxml, nous devons trouver l'emplacement du fichier, puis entrer dans l'outil d'administration et utiliser pip pour installer : pip install Le nom complet du fichier whl
Une fois l'installation terminée , vous pouvez saisir Python et l'importer, si aucune erreur n'est signalée, félicitations pour une installation réussie.
Si certains amis trouvent cela gênant, alors je vous recommande d'installer l'adresse de téléchargement anaconda (si la vitesse d'installation est lente, vous pouvez trouver des miroirs domestiques. Les amis qui ne savent pas ce que c'est peuvent la rechercher sur Google. ceux qui utilisent pip sous Windows Les problèmes d'erreurs d'installation n'existeront plus.
Méthode de sélection de balises de base de BeautifulSoup
Bien que l'analyseur de bibliothèque standard intégré de Python ne soit pas mauvais, je le recommande toujours à tout le monde .lxml parce que c'est assez rapide. Ensuite, nous utilisons l'analyseur lxml pour démontrer le code suivant.
Nous importons d'abord l'exemple de document officiel :
html_doc = """ <html><head><title>The Dormouse's story</title></head> <body> <p class="title"><b>The Dormouse'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> """
Code HTML, nous pouvons obtenir un objet BeautifulSoup et le sortir selon la structure de format indenté standard :
from bs4 import BeautifulSoup soup = BeautifulSoup(html_doc, 'lxml')
Nous pouvons voir que le code HTML ci-dessus n'est pas complet. Ensuite, nous utilisons la méthode prettify() pour effectuer la complétion automatique. La partie commentaire est le résultat de l'opération :
print(soup.prettify()) # <html> # <head> # <title> # The Dormouse's story # </title> # </head> # <body> # <p class="title"> # <b> # The Dormouse'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>
.
Obtenir la balise
print(soup.title) # <title>The Dormouse's story</title>
En affichant le résultat, nous pouvons voir l'attribut d'obtention du contenu, qui est en fait une balise de titre dans le Code HTML.
Obtenir le nom
print(soup.title.name) # 'title'
est en fait le nom du label.
Obtenir les attributs
print(soup.p.attrs['class']) # 'title' print(soup.p['class']) # 'title'
Pour obtenir les attributs d'une étiquette, nous pouvons utiliser la méthode attrs et lui passer le nom de l'attribut pour obtenir le attributs de l'étiquette. D'après les résultats, nous pouvons voir que si vous transmettez directement le nom de l'attribut de balise p, vous pouvez également obtenir l'attribut de balise.
Obtenir du contenu
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's story</title></head> <body> <p class="title"><b>The Dormouse'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's story</title>]
soup.find_all("p", "title")
# [<p class="title"><b>The Dormouse'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's story</title>]
找到某个 tag标签下的直接子标签:
soup.select("head > title")
# [<title>The Dormouse'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/
总结
Pour la bibliothèque d'analyse de BeautifulSoup, il est recommandé d'utiliser lxml. Si des caractères tronqués apparaissent, vous pouvez utiliser html.parser ; la méthode de sélection et de filtrage des balises de BeautifulSoup est faible mais rapide ; ) pour rechercher des balises. Bien sûr, si vous êtes familier avec les sélecteurs CSS, il est recommandé d'utiliser la méthode .select() pour obtenir le contenu du texte de l'étiquette et la méthode get[attrs] ; pour obtenir la valeur de l'attribut d'étiquette.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
