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

37.4 KB
Raw Blame

title: "Selector и Selectors в Scrapling: данные и навигация" description: "Узнайте, как Selector и Selectors хранят HTML, текст и атрибуты. Извлекайте значения, преобразуйте URL и переходите к родителям, дочерним и соседним элементам."

Основные классы парсера {#parsing-main-classes}

!!! success "Перед началом"

- Прочитайте страницу [Поиск элементов](../parsing/selection.md), чтобы понять, как находить и извлекать элементы из объекта [Selector](../parsing/main_classes.md#selector).

Теперь, когда мы рассмотрели способы выбора элементов в Scrapling, разберём класс Selector и связанные объекты. Это поможет лучше понять работу парсера.

Класс Selector составляет основу парсера Scrapling: он разбирает HTML и позволяет выбирать элементы. Его можно импортировать любым из следующих способов:

from scrapling import Selector
from scrapling.parser import Selector

Затем используйте его напрямую, как показано на странице Обзор:

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

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

После передачи HTML или получения страницы основным объектом в Scrapling становится Selector. Выбор элементов, навигация и другие операции возвращают объект Selector или Selectors, если результатом является один или несколько элементов страницы, а не текст или подобные данные.

Другими словами, сама страница является объектом Selector, и каждый её элемент тоже является объектом Selector. Любой текст, включая содержимое элементов и значения их атрибутов, представлен объектом TextHandler. Атрибуты каждого элемента хранятся в AttributesHandler. К этим двум объектам мы вернёмся позже, а пока рассмотрим Selector.

Selector {#selector}

Аргументы {#arguments-explained}

Самый важный аргумент, content, принимает HTML для разбора в виде str или bytes.

Аргумент url задаёт URL страницы для преобразования относительных ссылок и разделения сохранённых адаптивных данных по доменам. Аргументы adaptive, storage и storage_args относятся к адаптивной функции и не влияют на работу, если вы её не используете.

Следующие аргументы управляют разбором и обработкой HTML:

  • encoding: кодировка HTML. По умолчанию UTF-8.
  • keep_comments: сохранять ли HTML-комментарии при разборе страницы. По умолчанию выключено, так как комментарии могут мешать сбору данных.

Я намеренно пропустил аргументы huge_tree и root, чтобы не усложнять эту страницу. Возможно, вы заметили, что я часто так поступаю с расширенными возможностями, которые не нужны для начала работы. Подробнее о них можно узнать в разделе разработки.

Большинство свойств страницы и её элементов загружаются только при первом обращении. Например, текст страницы или элемента обрабатывается, когда он вам понадобится. Это одна из причин высокой скорости Scrapling :)

Свойства {#properties}

Многое из этого уже было на странице Обзор, но здесь мы разберём свойства подробнее и рассмотрим более сложные примеры. Свойства для перемещения по элементам вынесены в раздел Навигация.

Для примера разберём такую 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>

Загрузим страницу, как показано ранее:

from scrapling import Selector
page = Selector(html_doc)

Получим весь текст страницы, включая вложенные элементы:

>>> 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'

Получим первый элемент article и используем его в примерах:

article = page.find('article')

Таким же способом получим весь текст элемента, включая вложенные элементы:

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

Но если запросить только непосредственный текст элемента, результат будет пустым: в HTML выше у него нет собственного текста.

>>> article.text
''

Метод get_all_text принимает следующие необязательные аргументы:

  1. separator: разделитель для объединения найденных строк. По умолчанию '\n'.
  2. strip: удалять пробельные символы по краям строк перед объединением. По умолчанию выключено.
  3. ignore_tags: кортеж имён тегов, которые нужно пропустить вместе со всем вложенным содержимым. По умолчанию ('script', 'style',).
  4. valid_values: собирать только элементы с непустым текстом. Пустой текст и текст только из пробельных символов пропускаются. По умолчанию включено.

Возвращаемый текст имеет тип TextHandler, а не обычной строки. Позже мы разберём его подробнее. Если текст содержит JSON, его можно преобразовать методом .json():

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

Теперь получим имя тега элемента:

>>> article.tag
'article'

Если обратиться к этому свойству у самой страницы, вы увидите, что работаете с корневым элементом html:

>>> page.tag
'html'

Думаю, связь между page и element теперь понятна, поэтому больше не будем к ней возвращаться.

Получим атрибуты элемента:

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

К отдельному атрибуту можно обратиться любым из этих способов:

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

Проверить наличие атрибута можно так:

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

Получим HTML элемента:

>>> 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>'

Получим красиво отформатированный HTML элемента:

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>

Свойство .body возвращает исходное содержимое страницы. Начиная с v0.4, у объектов Response, полученных через Fetcher, .body всегда возвращает bytes.

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

Получим всех предков элемента в дереве 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...'>]

Создадим сокращённый CSS-селектор, если это возможно, или полный селектор:

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

То же самое для XPath:

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

Навигация {#traversal}

На найденных выше элементах подробно рассмотрим свойства и методы для перемещения по странице.

Если вы не знакомы с деревом DOM или структурой данных «дерево», этот раздел может быть непонятен. Советую сначала прочитать об этих понятиях.

А если хотите сразу продолжить, вот краткое объяснение.
Элемент html является корнем дерева сайта: каждая страница начинается с элемента html.
Непосредственно под ним находятся такие элементы, как head и body. Они считаются дочерними элементами html, а html является их родителем. Элементы body и head считаются соседними, так как у них один родитель.

Получим родителя элемента:

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

Обращения можно объединять в цепочки. Это относится и к остальным похожим свойствам и методам ниже.

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

Получим дочерние элементы:

>>> 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...'>]

Получим все элементы ниже текущего, включая вложенные. Это похоже на свойство children, но для всех уровней вложенности:

>>> 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...'>]

Здесь результат совпадает со свойством children, потому что у дочерних элементов нет своих дочерних элементов.

Пример с элементом класса product-list лучше показывает разницу между children и 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...'>,
...]

Получим соседние элементы с тем же родителем:

>>> 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...'>]

Получим следующий соседний элемент:

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

Свойство 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...'>

Можно быстро проверить, есть ли у элемента определённый класс:

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

Если одного родителя недостаточно, можно перебрать всех предков элемента:

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

Также можно найти предка, который удовлетворяет условию. Передайте функцию, которая принимает объект Selector и возвращает True, если условие выполнено, или False в противном случае:

>>> 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 представляет список объектов Selector. Он наследует стандартный тип Python List, поэтому содержит все свойства и методы List, а также дополнительные методы для удобной работы с объектами Selector внутри него.

Все методы и свойства Selector, которые возвращают несколько элементов, возвращают экземпляр Selectors.

Начиная с v0.4, все методы выбора возвращают объекты Selector/Selectors, даже для текстовых узлов и значений атрибутов. Текстовые узлы, выбранные через ::text, /text(), ::attr() или /@attr, оборачиваются в объекты Selector. У них tag равен "#text", а свойство text возвращает текстовое значение. Текст по-прежнему доступен напрямую, а остальные свойства возвращают пустые значения или значения по умолчанию.

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

Методы извлечения данных {#data-extraction-methods}

Начиная с v0.4, Selector и Selectors предоставляют методы get(), getall() и их псевдонимы extract_first и extract, как в Scrapy. Старый метод get_all() удалён.

У объекта Selector:

  • get() возвращает TextHandler: для текстовых узлов это текстовое значение, для HTML-элементов это строка с внешним HTML элемента.
  • getall() возвращает список TextHandlers с одной строкой представления элемента.
  • extract_first является псевдонимом get(), а extract является псевдонимом 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'

У объекта Selectors:

  • get(default=None) возвращает строковое представление первого элемента или default, если список пуст.
  • getall() преобразует все элементы в строки и возвращает список TextHandlers.
  • extract_first является псевдонимом get(), а extract является псевдонимом 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'

Эти методы работают со всеми способами выбора: CSS, XPath, find и другими. Это рекомендуемый способ извлекать текст и значения атрибутов в стиле Scrapy.

Теперь посмотрим, какие ещё возможности добавляет класс Selectors.

Свойства {#properties_1}

Помимо обычных операций со списками Python, таких как перебор и срезы, доступны следующие возможности:

Можно выполнять CSS- и XPath-запросы прямо для содержащихся в списке объектов Selector. Типы результатов такие же, как у методов css и xpath класса Selector. Аргументы тоже совпадают, кроме отсутствующего здесь adaptive. Благодаря этому методы легко объединять в цепочки.

>>> 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']

Можно напрямую вызывать re и re_first. Они принимают те же аргументы, что и в классе Selector. Подробнее о них читайте ниже в разделе TextHandler.

Однако здесь re_first работает иначе: вызывает re для каждого Selector и возвращает первый найденный результат. Метод re возвращает обычный объект TextHandlers, объединяя все экземпляры TextHandler в один 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']

Метод search позволяет быстро искать среди объектов Selector. Переданная функция должна принимать Selector первым аргументом и возвращать True/False. Метод вернёт первый Selector, для которого условие выполнено, или None, если совпадений нет.

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

Метод filter тоже принимает функцию, как search, но возвращает объект Selectors со всеми экземплярами Selector, которые удовлетворяют условию.

>>> 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']

К первому и последнему элементу можно безопасно обращаться без риска ошибки индекса:

>>> 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

Если вам, как и мне, хочется короче записать число объектов Selector в Selectors, можно сделать так:

page.css('.product').length

Это равнозначно следующей записи:

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

Да, как в JavaScript :)

TextHandler {#texthandler}

Этот класс важно знать: все методы и свойства, которые должны вернуть строку, возвращают TextHandler. А вместо списка строк они возвращают TextHandlers.

TextHandler наследует стандартную строку Python, поэтому поддерживает все обычные операции со строками. Зачем тогда отдельное имя?

TextHandler добавляет методы и свойства, которых нет у стандартных строк Python. Мы сейчас их рассмотрим. Помните, что все классы возвращают строки как TextHandler. Это позволяет писать более короткий и удобный код. Можно также импортировать класс и применять его к любой строке, как описано далее.

Использование {#usage}

Срезы, доступ по индексу и методы вроде split, replace и strip снова возвращают TextHandler. Поэтому их можно объединять в цепочки. Если найдёте метод или свойство, которое возвращает обычную строку вместо TextHandler, создайте issue, и мы исправим его.

Начнём с методов re и re_first. Они есть и в классах Selector, Selectors и TextHandlers и везде принимают одинаковые аргументы.

  • Метод re принимает первым аргументом строку или скомпилированное регулярное выражение. Он находит все совпадения и возвращает их как TextHandlers. Метод re_first принимает те же аргументы и работает похожим образом, но возвращает только первый результат как TextHandler.

    Есть и другие полезные аргументы:

    • replace_entities: по умолчанию включён. Заменяет HTML-сущности соответствующими символами.
    • clean_match: по умолчанию выключен. Позволяет игнорировать пробельные символы, в том числе последовательности пробелов, при поиске совпадений.
    • case_sensitive: по умолчанию включён. При отключении регулярное выражение компилируется без учёта регистра.

    Вы уже видели эти примеры. Результат имеет тип TextHandlers, так как мы использовали 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']
    

    Чтобы показать остальные аргументы, возьмём отдельную строку для каждого примера:

    >>> 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']
    

    Ещё одно преимущество использования TextHandler: свойство html_content тоже возвращает TextHandler, поэтому можно искать регулярным выражением прямо в HTML:

    >>> page.html_content.re('div class=".*">(.*)</div')
    ['In stock: 5', 'In stock: 3', 'Out of stock']
    
  • Метод .json() быстро преобразует содержимое в объект JSON, если это возможно. Иначе он вызывает ошибку.

    >>> 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}
    

    Если при выборе элемента вы не указали текстовый узел, например текст элемента или значение атрибута, текст элемента будет выбран автоматически:

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

    Класс Selector добавляет ещё одну возможность. Допустим, мы работаем с такой страницей:

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

    У класса Selector есть уже знакомый метод get_all_text, который возвращает TextHandler.

    Если выполнить следующее:

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

    Возникнет ошибка: у тега div нет собственного текста, который можно преобразовать в JSON. У него вообще нет непосредственного текстового содержимого.

    В этом случае поможет метод get_all_text:

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

    Здесь я указал ignore_tags, потому что его значение по умолчанию равно ('script', 'style',).

    Ещё один связанный случай возникает при работе с Fetcher, которые мы рассмотрим позже. Допустим, вы получили такой JSON-ответ:

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

    Класс Selector предназначен для HTML-страниц. Он воспринимает такой ответ как повреждённый HTML и исправляет его. Поэтому свойство html_content вернёт следующее:

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

    При этом метод json можно вызвать напрямую, и он сработает:

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

    Как это возможно, если у тега html нет непосредственного текста?
    Для таких случаев, как JSON-ответы, класс Selector сохраняет исходную копию полученного содержимого. Метод .json() сначала проверяет эту копию и преобразует её в JSON. Если копии нет, как у отдельных элементов, он проверяет текст текущего элемента, а затем при необходимости использует get_all_text.

  • Полезный метод .clean() удаляет пробельные символы и последовательности пробелов и возвращает новый экземпляр TextHandler.

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

Аргумент remove_entities позволяет методу clean заменять HTML-сущности соответствующими символами.

  • Метод .sort() сортирует символы строки, как при сортировке списка:
>>> TextHandler('acb').sort()
'abc'

Можно сортировать и в обратном порядке:

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

Со временем появятся и другие методы и свойства. Главное помнить: почти везде в библиотеке этот класс используется вместо обычных строк.

TextHandlers {#texthandlers}

Как вы, наверное, догадались, этот класс похож на Selectors и Selector, но наследует поведение стандартного списка. Дополнительно он предоставляет методы re и re_first.

Метод re_first здесь вызывает re для каждого TextHandler и возвращает первый результат или None. В остальном новых особенностей пока нет, но позже будут добавлены новые методы.

AttributesHandler {#attributeshandler}

Это версия стандартного словаря Python, dict, доступная только для чтения. Она хранит атрибуты каждого элемента, то есть экземпляра Selector.

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

Благодаря режиму только для чтения этот класс использует меньше ресурсов, чем обычный словарь. При этом у него те же методы и свойства, кроме тех, которые изменяют или перезаписывают данные.

Сейчас он добавляет две простые возможности:

  • Метод search_values.

    В обычном словаре можно проверить наличие ключа через dict.get("key_name"). Но для поиска по значениям нужен дополнительный код. Этот метод делает это за вас: ищет среди значений атрибутов и возвращает словарь для каждого совпадения.

    Простой пример:

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

    Аргумент partial позволяет искать по части значения:

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

    Предыдущие примеры условны. В реальной задаче метод можно использовать вместе с find_all, чтобы найти все элементы с определённым значением атрибута:

    >>> 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...'>]
    

    У всех этих элементов значение атрибута class равно 'product'.

    Здесь используется list, потому что search_values возвращает генератор. Сам генератор дал бы True для каждого элемента.

  • Свойство json_string.

    Преобразует текущие атрибуты в строку JSON, если это возможно. Иначе вызывает ошибку.

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