Maison > Article > développement back-end > Explication détaillée de la façon dont Python utilise le module Beautiful Soup pour rechercher du contenu

Explication détaillée de la façon dont Python utilise le module Beautiful Soup pour rechercher du contenu

高洛峰original: 2017-03-31 09:47:212836parcourir

Cet article vous présente principalement la fonction de méthode de recherche du module Beautiful Soup en python. Méthodes Différents types de paramètres de filtrage peuvent effectuer différents filtrages pour obtenir les résultats souhaités. L'introduction de l'article est très détaillée et a une certaine valeur de référence pour tous les amis qui en ont besoin peuvent y jeter un œil ci-dessous.

Préface

Nous utiliserons la fonction de recherche du module Beautiful Soup pour effectuer une recherche en fonction du nom de la balise, des attributs de la balise, du texte du document et des éléments réguliers. expression.

Méthode de recherche

La méthode de recherche intégrée de Beautiful Soup est la suivante :

trouver ()
find_all()
find_parent()
find_parents()
find_next_sibling()
find_next_siblings()
find_previous_sibling()
find_previous_siblings()
find_previous()
find_all_previous()
find_next ()
find_all_next()

Utilisez la méthode find() pour rechercher

Vous devez d'abord créer un fichier HTML pour le test.

<html>
<body>
<p class="ecopyramid">
 <ul id="producers">
 <li class="producerlist">
  <p class="name">plants</p>
  <p class="number">100000</p>
 </li>
 <li class="producerlist">
  <p class="name">algae</p>
  <p class="number">100000</p>
 </li>
 </ul>
 <ul id="primaryconsumers">
 <li class="primaryconsumerlist">
  <p class="name">deer</p>
  <p class="number">1000</p>
 </li>
 <li class="primaryconsumerlist">
  <p class="name">rabbit</p>
  <p class="number">2000</p>
 </li>
 </ul>
 <ul id="secondaryconsumers">
 <li class="secondaryconsumerlist">
  <p class="name">fox</p>
  <p class="number">100</p>
 </li>
 <li class="secondaryconsumerlist">
  <p class="name">bear</p>
  <p class="number">100</p>
 </li>
 </ul>
 <ul id="tertiaryconsumers">
 <li class="tertiaryconsumerlist">
  <p class="name">lion</p>
  <p class="number">80</p>
 </li>
 <li class="tertiaryconsumerlist">
  <p class="name">tiger</p>
  <p class="number">50</p>
 </li>
 </ul>
</p>
</body>
</html>

Nous pouvons obtenir la balise ff6d136ddc5fdfeffaf53ff6ee95f185 via la méthode find() , et par défaut nous obtiendrons la première qui apparaît. Ensuite, récupérez la balise 25edfb22a4f469ecb59f1190150159c6. Par défaut, vous obtiendrez toujours la première qui apparaît. Ensuite, récupérez la balise e388a4556c0f65e1904146cc1a846bee et vérifiez si vous avez obtenu la première en affichant le contenu.

from bs4 import BeautifulSoup
with open(&#39;search.html&#39;,&#39;r&#39;) as filename:
 soup = BeautifulSoup(filename,&#39;lxml&#39;)
first_ul_entries = soup.find(&#39;ul&#39;)
print first_ul_entries.li.p.string

La méthode find() est la suivante :

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

Comme indiqué ci-dessus code, find() La méthode accepte cinq paramètres : nom, attrs, récursif, texte et **kwargs. Le nom, les attributs et les paramètres de texte peuvent tous agir comme des filtres dans la méthode find() pour améliorer la précision des résultats de correspondance.

Rechercher des balises

En plus de rechercher la balise ff6d136ddc5fdfeffaf53ff6ee95f185 dans le code ci-dessus, nous pouvons également rechercher la balise 25edfb22a4f469ecb59f1190150159c6 le résultat renvoyé est également le premier qui apparaît.

tag_li = soup.find(&#39;li&#39;)
# tag_li = soup.find(name = "li")
print type(tag_li)
print tag_li.p.string

Rechercher du texte

Si nous voulons uniquement rechercher en fonction du contenu du texte, nous ne pouvons transmettre que le texte paramètre :

search_for_text = soup.find(text=&#39;plants&#39;)
print type(search_for_text)
<class &#39;bs4.element.NavigableString&#39;>

Le résultat renvoyé est également un objet NavigableString.

Recherchez

selon l'expression régulière et vous pouvez voir le contenu du texte HTML suivant

<p>The below HTML has the information that has email ids.</p>
 abc@example.com 
<p>xyz@example.com</p> 
 <span>foo@example.com</span>

L'adresse e-mail abc@example n'est incluse dans aucune balise, donc l'adresse e-mail ne peut pas être trouvée en fonction des balises. À ce stade, nous pouvons utiliser des expressions régulières pour faire correspondre.

email_id_example = """
 <p>The below HTML has the information that has email ids.</p>
 abc@example.com
 <p>xyz@example.com</p>
 <span>foo@example.com</span>
 """
email_soup = BeautifulSoup(email_id_example,&#39;lxml&#39;)
print email_soup
# pattern = "\w+@\w+\.\w+"
emailid_regexp = re.compile("\w+@\w+\.\w+")
first_email_id = email_soup.find(text=emailid_regexp)
print first_email_id

Lors de l'utilisation d'expressions régulières pour la correspondance, s'il existe plusieurs éléments correspondants, le premier sera renvoyé en premier.

Recherche par valeur d'attribut de balise

Vous pouvez effectuer une recherche par valeur d'attribut de balise :

search_for_attribute = soup.find(id=&#39;primaryconsumers&#39;)
print search_for_attribute.li.p.string

Recherche basé sur les valeurs des attributs de balise est disponible pour la plupart des attributs, tels que l'identifiant, le style et le titre.

Mais il y aura des différences dans les deux situations suivantes :

Attribut personnalisé
Class ( class ) Attributs

Nous ne pouvons plus rechercher directement à l'aide des valeurs d'attribut, mais devons utiliser le paramètre attrs pour passer à la fonction find().

Recherche basée sur des attributs personnalisés

En HTML5, vous pouvez ajouter des attributs personnalisés aux balises, par exemple en ajoutant des attributs aux balises.

Comme le montre le code suivant, si nous effectuons la même opération que la recherche d'un identifiant, une erreur sera signalée. Les variables Python ne peuvent pas inclure le symbole -.

customattr = """
 <p data-custom="custom">custom attribute example</p>
   """
customsoup = BeautifulSoup(customattr,&#39;lxml&#39;)
customsoup.find(data-custom="custom")
# SyntaxError: keyword can&#39;t be an expression

À ce stade, utilisez la valeur de l'attribut attrs pour transmettre un type de dictionnaire comme paramètre de recherche :

using_attrs = customsoup.find(attrs={&#39;data-custom&#39;:&#39;custom&#39;})
print using_attrs

Recherche basée sur les classes en CSS

Pour les attributs de classe CSS, puisque class est un mot-clé en Python, il ne peut pas être transmis comme paramètre d'attribut de balise dans ce cas. , recherchez comme des propriétés personnalisées. Utilisez également l'attribut attrs pour transmettre un dictionnaire pour correspondance.

En plus d'utiliser l'attribut attrs, vous pouvez également utiliser l'attribut class_ pour passer, qui est différent de class et ne provoquera pas d'erreurs.

css_class = soup.find(attrs={&#39;class&#39;:&#39;producerlist&#39;})
css_class2 = soup.find(class_ = "producerlist")
print css_class
print css_class2

Utilisez une fonction personnalisée pour rechercher

Vous pouvez transmettre une fonction à la méthode find() , afin que il sera recherché en fonction de la recherche en fonction des conditions définies par la fonction.

La fonction doit renvoyer une valeur vraie ou fausse.

def is_producers(tag):
 return tag.has_attr(&#39;id&#39;) and tag.get(&#39;id&#39;) == &#39;producers&#39;
tag_producers = soup.find(is_producers)
print tag_producers.li.p.string

Le code définit une fonction is_producers, qui vérifiera si la balise a un attribut id spécifique et si la valeur de l'attribut est égale à celle des producteurs si les conditions sont remplies. rencontré, il retournera true, sinon il retournera false .

Utiliser diverses méthodes de recherche ensemble

Beautiful Soup propose diverses méthodes de recherche De même, nous pouvons également utiliser ces méthodes conjointement pour effectuer une correspondance et améliorer la précision de la recherche. Dépenser.

combine_html = """
 <p class="identical">
  Example of p tag with class identical
 </p>
 <p class="identical">
  Example of p tag with class identical
 <p>
 """
combine_soup = BeautifulSoup(combine_html,&#39;lxml&#39;)
identical_p = combine_soup.find("p",class_="identical")
print identical_p

使用 find_all() 方法搜索

使用 find() 方法会从搜索结果中返回第一个匹配的内容，而 find_all() 方法则会返回所有匹配的项。

在 find() 方法中用到的过滤项，同样可以用在 find_all() 方法中。事实上，它们可以用到任何搜索方法中，例如：find_parents() 和 find_siblings() 中。

# 搜索所有 class 属性等于 tertiaryconsumerlist 的标签。
all_tertiaryconsumers = soup.find_all(class_=&#39;tertiaryconsumerlist&#39;)
print type(all_tertiaryconsumers)
for tertiaryconsumers in all_tertiaryconsumers:
 print tertiaryconsumers.p.string

find_all() 方法为：

find_all(name,attrs,recursive,text,limit,**kwargs)

它的参数和 find() 方法有些类似，多个了 limit 参数。limit 参数是用来限制结果数量的。而 find() 方法的 limit 就是 1 了。

同时，我们也能传递一个字符串列表的参数来搜索标签、标签属性值、自定义属性值和 CSS 类。

# 搜索所有的 p 和 li 标签
p_li_tags = soup.find_all(["p","li"])
print p_li_tags
print
# 搜索所有类属性是 producerlist 和 primaryconsumerlist 的标签
all_css_class = soup.find_all(class_=["producerlist","primaryconsumerlist"])
print all_css_class
print

搜索相关标签

一般情况下，我们可以使用 find() 和 find_all() 方法来搜索指定的标签，同时也能搜索其他与这些标签相关的感兴趣的标签。

搜索父标签

可以使用 find_parent() 或者 find_parents() 方法来搜索标签的父标签。

find_parent() 方法将返回第一个匹配的内容，而 find_parents() 将返回所有匹配的内容，这一点与 find() 和 find_all() 方法类似。

# 搜索 父标签
primaryconsumers = soup.find_all(class_=&#39;primaryconsumerlist&#39;)
print len(primaryconsumers)
# 取父标签的第一个
primaryconsumer = primaryconsumers[0]
# 搜索所有 ul 的父标签
parent_ul = primaryconsumer.find_parents(&#39;ul&#39;)
print len(parent_ul)
# 结果将包含父标签的所有内容
print parent_ul
print
# 搜索,取第一个出现的父标签.有两种操作
immediateprimary_consumer_parent = primaryconsumer.find_parent()
# immediateprimary_consumer_parent = primaryconsumer.find_parent(&#39;ul&#39;)
print immediateprimary_consumer_parent

搜索同级标签

Beautiful Soup 还提供了搜索同级标签的功能。

使用函数 find_next_siblings() 函数能够搜索同一级的下一个所有标签，而 find_next_sibling() 函数能够搜索同一级的下一个标签。

producers = soup.find(id=&#39;producers&#39;)
next_siblings = producers.find_next_siblings()
print next_siblings

同样，也可以使用 find_previous_siblings() 和 find_previous_sibling() 方法来搜索上一个同级的标签。

搜索下一个标签

使用 find_next() 方法将搜索下一个标签中第一个出现的，而 find_next_all() 将会返回所有下级的标签项。

# 搜索下一级标签
first_p = soup.p
all_li_tags = first_p.find_all_next("li")
print all_li_tags

搜索上一个标签

与搜索下一个标签类似，使用 find_previous() 和 find_all_previous() 方法来搜索上一个标签。

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!

Déclaration：

Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn

Article précédent：Explication détaillée des méthodes d'instance d'itérateur et de générateur en PythonArticle suivant：Explication détaillée des méthodes d'instance d'itérateur et de générateur en Python

Articles Liés

Voir plus