Skip to content

🕷️ The BEST Web Scraping framework that handles everything from a single request to a full-scale crawl! Don't be shy, join here: https://discord.gg/EMgGbDceNQ and follow here for daily tips and tricks: https://x.com/Scrapling_dev

28.4 KB
Raw Blame

title: "Selector et Selectors de Scrapling : donnĂ©es et navigation" description: "DĂ©couvrez comment Selector et Selectors stockent le HTML, le texte et les attributs. Extrayez des valeurs, rĂ©solvez les URL et parcourez parents, enfants et frères."

Classes principales du parser {#parsing-main-classes}

!!! success "Avant de commencer"

- Lisez [Rechercher des éléments](../parsing/selection.md) pour savoir comment trouver et extraire des éléments d’un objet [Selector](../parsing/main_classes.md#selector).

Après les méthodes de sélection et leurs fonctions, voyons la classe Selector et les autres objets. Cela vous aidera à mieux comprendre le parser.

La classe Selector est au cĹ“ur du parser de Scrapling. Elle analyse le HTML et permet de sĂ©lectionner des Ă©lĂ©ments. Vous pouvez l’importer de l’une de ces façons :

from scrapling import Selector
from scrapling.parser import Selector

Utilisez-la ensuite directement, comme dans la vue d’ensemble :

page = Selector(
    '<html>...</html>',
    url='https://example.com'
)

# Then select elements as you like
elements = page.css('.product')

Quand vous fournissez du HTML ou récupérez un site, vous travaillez principalement avec un Selector. Les opérations de sélection ou de navigation qui renvoient des éléments de la page donnent un Selector ou un Selectors. Cela ne concerne pas les opérations qui renvoient du texte ou d’autres valeurs.

La page est un Selector, et chaque élément qu’elle contient est aussi un Selector. Le texte des éléments et des attributs utilise TextHandler. Les attributs de chaque élément sont stockés dans AttributesHandler. Nous y reviendrons. Commençons par Selector.

Selector {#selector}

Arguments {#arguments-explained}

Le plus important est content, qui reçoit le HTML à analyser sous forme de str ou de bytes.

url définit l’URL de la page, utilisée pour résoudre les liens relatifs et séparer les données adaptatives enregistrées par domaine. Les arguments adaptive, storage et storage_args configurent la fonction adaptative. Ils n’ont pas d’effet si vous n’utilisez pas cette fonction.

Ces arguments contrĂ´lent le traitement du HTML :

  • encoding : encodage utilisĂ© pour analyser le HTML. La valeur par dĂ©faut est UTF-8.
  • keep_comments : indique si les commentaires HTML doivent ĂŞtre conservĂ©s. Cette option est dĂ©sactivĂ©e par dĂ©faut, car les commentaires peuvent poser problème lors de l’extraction.

Nous laisserons huge_tree et root de côté pour ne pas compliquer cette page. Ce sont des fonctions avancées dont vous n’avez pas besoin pour commencer. La section développement couvre ces détails si vous souhaitez approfondir.

La plupart des propriĂ©tĂ©s de la page et de ses Ă©lĂ©ments ne sont chargĂ©es que lorsque vous les utilisez, comme le contenu textuel. Ce chargement Ă  la demande explique en partie la vitesse de Scrapling :)

Propriétés {#properties}

Nous en avons déjà vu une partie dans la vue d’ensemble, mais nous allons les détailler avec des exemples plus complets. Les propriétés pour parcourir la page sont regroupées dans la section navigation.

Pour les exemples, analysons cette page HTML :

<html>
  <head>
    <title>Some page</title>
  </head>
  <body>
    <div class="product-list">
      <article class="product" data-id="1">
        <h3>Product 1</h3>
        <p class="description">This is product 1</p>
        <span class="price">$10.99</span>
        <div class="hidden stock">In stock: 5</div>
      </article>
    
      <article class="product" data-id="2">
        <h3>Product 2</h3>
        <p class="description">This is product 2</p>
        <span class="price">$20.99</span>
        <div class="hidden stock">In stock: 3</div>
      </article>
    
      <article class="product" data-id="3">
        <h3>Product 3</h3>
        <p class="description">This is product 3</p>
        <span class="price">$15.99</span>
        <div class="hidden stock">Out of stock</div>
      </article>
    </div>

    <script id="page-data" type="application/json">
      {
        "lastUpdated": "2024-09-22T10:30:00Z",
        "totalProducts": 3
      }
    </script>
  </body>
</html>

Chargez la page comme prĂ©cĂ©demment :

from scrapling import Selector
page = Selector(html_doc)

Obtenez tout le texte de la page, y compris celui des Ă©lĂ©ments internes :

>>> page.get_all_text()
'Some page\n\n    \n\n      \nProduct 1\nThis is product 1\n$10.99\nIn stock: 5\nProduct 2\nThis is product 2\n$20.99\nIn stock: 3\nProduct 3\nThis is product 3\n$15.99\nOut of stock'

Obtenez le premier article, qui servira d’exemple :

article = page.find('article')

De la mĂŞme façon, obtenez tout le texte de l’élĂ©ment et des Ă©lĂ©ments qu’il contient :

>>> article.get_all_text()
'Product 1\nThis is product 1\n$10.99\nIn stock: 5'

Si vous cherchez seulement son texte direct, le rĂ©sultat sera vide. Dans le HTML ci-dessus, cet Ă©lĂ©ment n’a pas de texte en dehors de ses enfants :

>>> article.text
''

La mĂ©thode get_all_text accepte ces arguments facultatifs :

  1. separator : sĂ©parateur utilisĂ© pour joindre les textes trouvĂ©s. La valeur par dĂ©faut est '\n'.
  2. strip : supprime les espaces au dĂ©but et Ă  la fin de chaque texte avant de les joindre. DĂ©sactivĂ© par dĂ©faut.
  3. ignore_tags : tuple de noms de balises Ă  ignorer, ainsi que tout leur contenu. La valeur par dĂ©faut est ('script', 'style',).
  4. valid_values : collecte uniquement les textes ayant un contenu. Ignore les textes vides ou composĂ©s uniquement d’espaces. ActivĂ© par dĂ©faut.

Le texte renvoyĂ© est un TextHandler, pas une chaĂ®ne ordinaire. Nous le verrons plus loin. S’il contient du JSON valide, vous pouvez utiliser .json() :

>>> script = page.find('script')
>>> script.json()
{'lastUpdated': '2024-09-22T10:30:00Z', 'totalProducts': 3}

Obtenez la balise de l’élĂ©ment :

>>> article.tag
'article'

Sur la page directement, vous travaillez avec l’élĂ©ment racine html :

>>> page.tag
'html'

La même idée s’applique à page et à element, nous n’y reviendrons donc pas.

Obtenez les attributs de l’élĂ©ment :

>>> print(article.attrib)
{'class': 'product', 'data-id': '1'}

AccĂ©dez Ă  un attribut prĂ©cis de l’une de ces façons :

article.attrib['class']
article.attrib.get('class')
article['class']  # new in v0.3

VĂ©rifiez si un attribut existe avec l’une de ces mĂ©thodes :

'class' in article.attrib
'class' in article  # new in v0.3

Obtenez le HTML de l’élĂ©ment :

>>> article.html_content
'<article class="product" data-id="1"><h3>Product 1</h3>\n        <p class="description">This is product 1</p>\n        <span class="price">$10.99</span>\n        <div class="hidden stock">In stock: 5</div>\n      </article>'

Obtenez une version du HTML mise en forme pour ĂŞtre plus lisible :

print(article.prettify())
<article class="product" data-id="1"><h3>Product 1</h3>
    <p class="description">This is product 1</p>
    <span class="price">$10.99</span>
    <div class="hidden stock">In stock: 5</div>
</article>

Utilisez .body pour obtenir le contenu brut de la page. Depuis la v0.4, sur les objets Response des fetchers, .body renvoie toujours des bytes.

>>> page.body
'<html>\n  <head>\n    <title>Some page</title>\n  </head>\n  ...'

Obtenez tous les ancĂŞtres de l’élĂ©ment dans l’arbre DOM :

>>> article.path
[<data='<div class="product-list"> <article clas...' parent='<body> <div class="product-list"> <artic...'>,
 <data='<body> <div class="product-list"> <artic...' parent='<html><head><title>Some page</title></he...'>,
 <data='<html><head><title>Some page</title></he...'>]

GĂ©nĂ©rez un sĂ©lecteur CSS court si possible, sinon un sĂ©lecteur complet :

>>> article.generate_css_selector
'body > div > article'
>>> article.generate_full_css_selector
'body > div > article'

La mĂŞme chose avec XPath :

>>> article.generate_xpath_selector
"//body/div/article"
>>> article.generate_full_xpath_selector
"//body/div/article"

Navigation {#traversal}

À partir des éléments précédents, voyons les propriétés et méthodes pour parcourir la page.

Si vous ne connaissez pas l’arbre DOM ou les structures en arbre, cette section peut sembler déroutante. Je vous conseille de lire une présentation de ces notions.

Voici une explication rapide pour commencer.
L’élément html est la racine de l’arbre de la page, car toute page commence par un élément html.
Juste en dessous se trouvent des éléments comme head et body. Ce sont les enfants de html, et cet élément html est leur parent. head et body sont frères parce qu’ils partagent le même parent.

AccĂ©dez au parent d’un Ă©lĂ©ment :

>>> article.parent
<data='<div class="product-list"> <article clas...' parent='<body> <div class="product-list"> <artic...'>
>>> article.parent.tag
'div'

Vous pouvez enchaîner cette propriété. Cela vaut aussi pour les propriétés et méthodes similaires présentées ensuite.

>>> article.parent.parent.tag
'body'

Obtenez les enfants d’un Ă©lĂ©ment :

>>> article.children
[<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>,
 <data='<p class="description">This is product 1...' parent='<article class="product" data-id="1"><h3...'>,
 <data='<span class="price">$10.99</span>' parent='<article class="product" data-id="1"><h3...'>,
 <data='<div class="hidden stock">In stock: 5</d...' parent='<article class="product" data-id="1"><h3...'>]

Obtenez tous les Ă©lĂ©ments situĂ©s en dessous, mĂŞme aux niveaux plus profonds. Cela fonctionne comme children, mais parcourt tous les niveaux :

>>> article.below_elements
[<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>,
 <data='<p class="description">This is product 1...' parent='<article class="product" data-id="1"><h3...'>,
 <data='<span class="price">$10.99</span>' parent='<article class="product" data-id="1"><h3...'>,
 <data='<div class="hidden stock">In stock: 5</d...' parent='<article class="product" data-id="1"><h3...'>]

Ici, le résultat est le même que pour children, car les enfants n’ont pas eux-mêmes d’enfants.

Cet exemple avec l’élĂ©ment de classe product-list montre mieux la diffĂ©rence entre children et below_elements :

>>> products_list = page.css('.product-list')[0]
>>> products_list.children
[<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>,
 <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>,
 <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]

>>> products_list.below_elements
[<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>,
 <data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>,
 <data='<p class="description">This is product 1...' parent='<article class="product" data-id="1"><h3...'>,
 <data='<span class="price">$10.99</span>' parent='<article class="product" data-id="1"><h3...'>,
 <data='<div class="hidden stock">In stock: 5</d...' parent='<article class="product" data-id="1"><h3...'>,
 <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>,
...]

Obtenez les frères d’un Ă©lĂ©ment :

>>> article.siblings
[<data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>,
 <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]

Obtenez l’élĂ©ment suivant :

>>> article.next
<data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>

La mĂŞme logique s’applique Ă  previous :

>>> article.previous  # It's the first child, so it doesn't have a previous element
>>> second_article = page.css('.product[data-id="2"]')[0]
>>> second_article.previous
<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>

VĂ©rifiez rapidement si un Ă©lĂ©ment possède une classe prĂ©cise :

>>> article.has_class('product')
True

Si vous devez remonter au-delĂ  du parent, vous pouvez parcourir tous les ancĂŞtres de l’élĂ©ment :

for ancestor in article.iterancestors():
    # do something with it...

Vous pouvez aussi rechercher un ancĂŞtre qui remplit une condition. Passez une fonction qui reçoit un Selector et renvoie True si la condition est remplie, ou False sinon :

>>> article.find_ancestor(lambda ancestor: ancestor.has_class('product-list'))
<data='<div class="product-list"> <article clas...' parent='<body> <div class="product-list"> <artic...'>

>>> article.find_ancestor(lambda ancestor: ancestor.css('.product-list'))  # Same result, different approach
<data='<div class="product-list"> <article clas...' parent='<body> <div class="product-list"> <artic...'>

Selectors {#selectors}

Selectors est la version liste de Selector. Elle hérite du type List de Python et conserve les propriétés et méthodes de List. Elle ajoute aussi des méthodes pour travailler avec les objets Selector qu’elle contient.

Dans Selector, les méthodes et propriétés qui renvoient plusieurs éléments les fournissent dans un objet Selectors.

Depuis la v0.4, toutes les méthodes de sélection renvoient des objets Selector/Selectors, même pour le texte et les attributs. Les nœuds de texte obtenus avec ::text, /text(), ::attr() ou /@attr sont enveloppés dans des objets Selector. Leur tag vaut "#text" et leur propriété text renvoie la valeur textuelle. Les autres propriétés renvoient des valeurs vides ou par défaut sans erreur.

page.css('a::text')              # -> Selectors (of text node Selectors)
page.xpath('//a/text()')         # -> Selectors
page.css('a::text').get()        # -> TextHandler (the first text value)
page.css('a::text').getall()     # -> TextHandlers (all text values)
page.css('a::attr(href)')        # -> Selectors
page.xpath('//a/@href')          # -> Selectors
page.css('.price_color')         # -> Selectors

Méthodes d’extraction de données {#data-extraction-methods}

Depuis la v0.4, Selector et Selectors proposent get(), getall() et leurs alias extract_first et extract, selon les conventions de Scrapy. L’ancienne méthode get_all() a été supprimée.

Sur un objet Selector :

  • get() renvoie un TextHandler : la valeur du texte pour un nĹ“ud de texte, ou le HTML externe complet sous forme de chaĂ®ne pour un Ă©lĂ©ment HTML.
  • getall() renvoie une liste TextHandlers contenant cette seule chaĂ®ne.
  • extract_first est un alias de get(), et extract est un alias de getall().
>>> page.css('h3')[0].get()        # Outer HTML of the element
'<h3>Product 1</h3>'

>>> page.css('h3::text')[0].get()  # Text value of the text node
'Product 1'

Sur un objet Selectors :

  • get(default=None) renvoie la chaĂ®ne du premier Ă©lĂ©ment, ou default si la liste est vide.
  • getall() convertit tous les Ă©lĂ©ments en chaĂ®nes et renvoie une liste TextHandlers.
  • extract_first est un alias de get(), et extract est un alias de getall().
>>> page.css('.price::text').get()      # First price text
'$10.99'

>>> page.css('.price::text').getall()   # All price texts
['$10.99', '$20.99', '$15.99']

>>> page.css('.price::text').get('')    # With default value
'$10.99'

Ces méthodes fonctionnent avec tous les types de sélection, comme CSS, XPath et find. Elles sont recommandées pour extraire le texte et les attributs dans un style compatible avec Scrapy.

Voyons maintenant ce que Selectors propose en plus.

Propriétés {#properties_1}

En plus des opĂ©rations habituelles sur les listes Python, comme les parcourir ou en prendre une tranche, vous pouvez effectuer les opĂ©rations suivantes :

Exécuter des sélecteurs CSS et XPath directement sur les objets Selector de la liste. Les types renvoyés sont les mêmes que pour css et xpath de Selector. Les arguments sont similaires, sauf que adaptive n’est pas disponible ici. Cela facilite l’enchaînement des méthodes.

>>> page.css('.product h3::text').getall()
['Product 1', 'Product 2', 'Product 3']
>>> page.css('.product').css('h3::text').getall()
['Product 1', 'Product 2', 'Product 3']

Exécuter re et re_first directement, avec les mêmes arguments que dans Selector. Nous les expliquerons dans la section TextHandler.

Ici, re_first fonctionne diffĂ©remment : il exĂ©cute re sur chaque Selector et renvoie le premier ayant un rĂ©sultat. re renvoie un TextHandlers qui rassemble tous les objets TextHandler dans un seul TextHandlers.

>>> page.css('.price::text').re(r'[\d.]+')
['10.99', '20.99', '15.99']
>>> page.css('.product h3::text').re(r'Product (\d+)')
['1', '2', '3']

Avec search, vous pouvez rechercher parmi les objets Selector de la liste. Passez une fonction qui reçoit un Selector comme premier argument et renvoie True ou False. La méthode renvoie le premier Selector qui remplit la condition, ou None s’il n’y en a aucun.

>>> product = page.css('.product').search(lambda p: p.css('.price::text').get() == '$20.99')
>>> product.css('h3::text').get()
'Product 2'

Vous pouvez aussi utiliser filter. Il reçoit une fonction comme search, mais renvoie un Selectors contenant tous les objets Selector qui remplissent la condition.

>>> products = page.css('.product').filter(lambda p: float(p.css('.price::text').re_first(r'[\d.]+')) > 15)
>>> products.css('h3::text').getall()
['Product 2', 'Product 3']

Vous pouvez accĂ©der au premier ou au dernier Ă©lĂ©ment sans risquer d’erreur d’indice :

>>> page.css('.product').first   # First Selector or None
<data='<article class="product" data-id="1"><h3...'>
>>> page.css('.product').last    # Last Selector or None
<data='<article class="product" data-id="3"><h3...'>
>>> page.css('.nonexistent').first  # Returns None instead of raising IndexError

Pour connaĂ®tre le nombre d’objets Selector dans un Selectors, faites ceci :

page.css('.product').length

Cela Ă©quivaut Ă  :

len(page.css('.product'))

Oui, comme en JavaScript :)

TextHandler {#texthandler}

Cette classe est importante : les mĂ©thodes et propriĂ©tĂ©s qui renvoient une chaĂ®ne utilisent TextHandler. Celles qui renvoient une liste de chaĂ®nes utilisent TextHandlers.

TextHandler hĂ©rite de la chaĂ®ne standard de Python et accepte donc toutes ses opĂ©rations. Pourquoi lui donner un autre nom ?

Parce qu’elle ajoute des méthodes et propriétés absentes des chaînes ordinaires. Comme elle est utilisée pour le texte dans toute la bibliothèque, vous pouvez combiner ces fonctions pour écrire du code plus court et plus clair. Vous pouvez aussi l’importer et l’utiliser avec n’importe quelle chaîne, comme nous le verrons plus loin.

Utilisation {#usage}

Les opérations comme prendre une tranche, accéder par indice ou appeler split, replace et strip renvoient un nouveau TextHandler. Vous pouvez donc les enchaîner. Si une opération renvoie une chaîne ordinaire au lieu d’un TextHandler, ouvrez un ticket pour que nous l’adaptions aussi.

Commençons par re et re_first. Ce sont les mêmes méthodes que dans Selector, Selectors et TextHandlers, avec les mêmes arguments.

  • re reçoit une expression rĂ©gulière sous forme de chaĂ®ne ou dĂ©jĂ  compilĂ©e comme premier argument. Il recherche toutes les correspondances et les renvoie dans un TextHandlers. re_first accepte les mĂŞmes arguments, mais ne renvoie que la première correspondance sous forme de TextHandler.

    Les arguments suivants sont aussi disponibles :

    • replace_entities : remplace les rĂ©fĂ©rences d’entitĂ©s par les caractères correspondants. ActivĂ© par dĂ©faut.
    • clean_match : ignore les caractères d’espacement, y compris les espaces consĂ©cutifs, lors de la comparaison. DĂ©sactivĂ© par dĂ©faut.
    • case_sensitive : distingue les majuscules des minuscules. ActivĂ© par dĂ©faut. Si vous le dĂ©sactivez, l’expression rĂ©gulière est compilĂ©e sans cette distinction.

    Nous avons dĂ©jĂ  vu ces exemples. Ils renvoient TextHandlers parce qu’ils utilisent re :

    >>> page.css('.price::text').re(r'[\d.]+')
    ['10.99', '20.99', '15.99']
    >>> page.css('.product h3::text').re(r'Product (\d+)')
    ['1', '2', '3']
    

    Pour montrer les autres arguments, nous utiliserons une chaĂ®ne diffĂ©rente dans chaque exemple :

    >>> from scrapling import TextHandler
    >>> test_string = TextHandler('hi  there')  # Hence the two spaces
    >>> test_string.re('hi there')
    >>> test_string.re('hi there', clean_match=True)  # Using `clean_match` will clean the string before matching the regex
    ['hi there']
    
    >>> test_string2 = TextHandler('Oh, Hi Mark')
    >>> test_string2.re_first('oh, hi Mark')
    >>> test_string2.re_first('oh, hi Mark', case_sensitive=False)  # Hence disabling `case_sensitive`
    'Oh, Hi Mark'
    
    # Mixing arguments
    >>> test_string.re('hi there', clean_match=True, case_sensitive=False)
    ['hi there']
    

    Utiliser TextHandler partout a un autre avantage : comme html_content renvoie un TextHandler, vous pouvez appliquer des expressions rĂ©gulières directement au HTML :

    >>> page.html_content.re('div class=".*">(.*)</div')
    ['In stock: 5', 'In stock: 3', 'Out of stock']
    
  • .json() tente de convertir rapidement le contenu en objet JSON. Si ce n’est pas possible, il produit une erreur :

    >>> page.css('#page-data::text').get()
      '\n      {\n        "lastUpdated": "2024-09-22T10:30:00Z",\n        "totalProducts": 3\n      }\n    '
    >>> page.css('#page-data::text').get().json()
      {'lastUpdated': '2024-09-22T10:30:00Z', 'totalProducts': 3}
    

    Si vous n’indiquez pas de nĹ“ud de texte ou d’attribut lors de la sĂ©lection, le contenu textuel de l’élĂ©ment est utilisĂ© automatiquement :

    >>> page.css('#page-data')[0].json()
    {'lastUpdated': '2024-09-22T10:30:00Z', 'totalProducts': 3}
    

    La classe Selector ajoute un dĂ©tail. Supposons que nous travaillions sur cette page :

    <html>
        <body>
            <div>
              <script id="page-data" type="application/json">
                {
                  "lastUpdated": "2024-09-22T10:30:00Z",
                  "totalProducts": 3
                }
              </script>
            </div>
        </body>
    </html>
    

    Selector possède la méthode get_all_text, qui renvoie un TextHandler.

    Si vous faites ceci :

    >>> page.css('div::text').get().json()
    

    Vous obtenez une erreur, car le div n’a pas de texte direct à convertir en JSON. Il n’a même aucun texte direct.

    Dans ce cas, utilisez get_all_text :

    >>> page.css('div')[0].get_all_text(ignore_tags=[]).json()
      {'lastUpdated': '2024-09-22T10:30:00Z', 'totalProducts': 3}
    

    J’ai utilisé ignore_tags parce que sa valeur par défaut est ('script', 'style',).

    Un autre cas liĂ© se prĂ©sente avec un fetcher. Supposons que vous receviez cette rĂ©ponse JSON :

    >>> page = Selector("""{"some_key": "some_value"}""")
    

    Comme Selector est conçu pour les pages HTML, il traite ce contenu comme du HTML incomplet et le corrige. Avec html_content, vous obtenez ceci :

    >>> page.html_content
    '<html><body><p>{"some_key": "some_value"}</p></body></html>'
    

    Ici, vous pouvez utiliser json directement :

    >>> page.json()
    {'some_key': 'some_value'}
    

    Vous vous demandez peut-être comment cela fonctionne puisque html n’a pas de texte direct.
    Pour les réponses telles que JSON, Selector conserve une copie du contenu brut. Quand vous appelez .json(), il essaie d’abord de convertir cette copie. Si elle n’existe pas, comme pour les éléments internes, il utilise le texte direct de l’élément. S’il n’y en a pas non plus, il appelle get_all_text.

  • .clean() supprime les caractères d’espacement et les espaces consĂ©cutifs, puis renvoie un nouveau TextHandler :

>>> TextHandler('\n wonderful  idea, \reh?').clean()
'wonderful idea, eh?'

Vous pouvez aussi passer remove_entities pour que clean remplace les entités HTML par les caractères correspondants.

  • .sort() trie les caractères d’une chaĂ®ne, comme pour une liste :
>>> TextHandler('acb').sort()
'abc'

Ou dans l’ordre inverse :

>>> TextHandler('acb').sort(reverse=True)
'cba'

D’autres méthodes et propriétés seront ajoutées au fil du temps. Retenez que cette classe remplace les chaînes ordinaires dans presque toute la bibliothèque.

TextHandlers {#texthandlers}

Cette classe suit une idée similaire à Selectors et Selector. Elle hérite des opérations des listes ordinaires et ajoute re et re_first.

Ici, re_first exécute re sur chaque TextHandler et renvoie le premier résultat, ou None. Le reste fonctionne comme nous l’avons vu. D’autres méthodes seront ajoutées avec le temps.

AttributesHandler {#attributeshandler}

C’est une version en lecture seule du dictionnaire dict de Python. Elle stocke les attributs de chaque élément ou objet Selector.

>>> print(page.find('script').attrib)
{'id': 'page-data', 'type': 'application/json'}
>>> type(page.find('script').attrib).__name__
'AttributesHandler'

La lecture seule permet d’utiliser moins de ressources qu’un dictionnaire ordinaire. Les méthodes et propriétés restent les mêmes, sauf celles qui modifient les données.

Deux fonctions simples sont ajoutĂ©es :

  • La mĂ©thode search_values :

    Dans un dictionnaire, vous pouvez utiliser dict.get("key_name") pour rechercher une clĂ©. Rechercher les valeurs demande plus de code. Cette mĂ©thode le fait pour vous : elle recherche dans les valeurs des attributs et renvoie un dictionnaire pour chaque correspondance.

    Un exemple simple :

    >>> for i in page.find('script').attrib.search_values('page-data'):
            print(i)
    {'id': 'page-data'}
    

    Elle accepte aussi partial pour rechercher une partie de la valeur :

    >>> for i in page.find('script').attrib.search_values('page', partial=True):
            print(i)
    {'id': 'page-data'}
    

    Un cas plus courant serait de la combiner avec find_all pour trouver les Ă©lĂ©ments ayant une valeur prĂ©cise dans leurs attributs :

    >>> page.find_all(lambda element: list(element.attrib.search_values('product')))
    [<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>,
     <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>,
     <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]
    

    Tous ces éléments ont 'product' comme valeur de class.

    J’ai utilisé list parce que search_values renvoie un générateur. Sans conversion en liste, la condition vaudrait True pour tous les éléments.

  • La propriĂ©tĂ© json_string :

    Elle convertit les attributs en chaîne JSON. Si la conversion est impossible, elle produit une erreur.

    >>>page.find('script').attrib.json_string
    b'{"id":"page-data","type":"application/json"}'