Мыло красивое как сделать: Мыло своими руками — мастер-класс для начинающих. Фото — Ботаничка

Мы можем получить доступ к вышеуказанному документу по URL-адресу https://dataquestio.github.io/web-scraping-pages/ids_and_classes.html .

Давайте сначала загрузим страницу и создадим объект BeautifulSoup :

 страница = request.get("https://dataquestio.github.io/web-scraping-pages/ids_and_classes.html")
суп = BeautifulSoup(page. content, 'html.parser')
суп 

 
<голова>

<тело>
История Сони
Жили-были три сестрички; и их имена были
Элси,
Лейси и
Тилли;
и жили они на дне колодца.
...
"""
 

Прогон документа «три сестры» через Beautiful Soup дает нам Объект BeautifulSoup , представляющий документ как вложенный структура данных:

 из импорта bs4 BeautifulSoup
суп = BeautifulSoup(html_doc, 'html. parser')
распечатать (суп.красиво())
# 
# <голова>
# <название>
# История Сони
# 
# 
# <тело>
# <р>
# <б>
# История Сони
# 
# 

# <р>
# Жили-были три сестрички; и их имена были
# 
# Элси
# 
# ,
# 
# Лейси
# 
#    а также
# 
# Тилли
# 
# ; и жили они на дне колодца.
# 

# <р>
# ...
# 

# 
# 
 

Вот несколько простых способов навигации по этой структуре данных:

 суп.название
# 
суп.название.название
# U'название'
суп.название.строка
# u'История Сони'
суп.название.родителя.имя
# у'голова
суп.п
# 
История Сони
суп.p['класс']
# U'название'
суп.а
# Элси
суп.найти_все('а')
# [Элси,
# Лейси,
# Тилли]
суп. найти (id = "ссылка3")
#  com/tillie">Тилли
 

Одной из распространенных задач является извлечение всех URL-адресов, найденных в тегах страницы:

 для ссылки в sup.find_all('a'):
    печать (ссылка. получить ('href'))
# http://example.com/элси
# http://example.com/lacie
# http://example.com/tillie
 

Другой распространенной задачей является извлечение всего текста со страницы:

 print(soup.get_text())
# История Сони
#
# История Сони
#
# Жили-были три сестрички; и их имена были
# Элси,
# Лейси и
# Тилли;
# и они жили на дне колодца.
#
# ...
 

Похоже, это то, что вам нужно? Если это так, читайте дальше.

Если вы используете последнюю версию Debian или Ubuntu Linux, вы можете установить Beautiful Soup с помощью системного менеджера пакетов:

$ apt-get install python-bs4 (для Python 2)

$ apt-get install python3-bs4 (для Python 3)

Beautiful Soup 4 опубликован через PyPi, поэтому, если вы не можете установить его с помощью системного упаковщика вы можете установить его с помощью easy_install или пункт . Имя пакета beautifulsoup4 , и тот же пакет работает на Python 2 и Python 3. Убедитесь, что вы используете правильную версию pip или easy_install для вашей версии Python (они могут называться pip3 и easy_install3 соответственно, если вы используете Python 3).

$ easy_install BeautifulSoup4

$ pip install BeautifulSoup4

(Пакет BeautifulSoup , вероятно, , а не , что вы хотите. Это предыдущий основной выпуск, Beautiful Soup 3. Много программ используется BS3, так что он по-прежнему доступен, но если вы пишете новый код, вам следует установить beautifulsoup4 .)

Если у вас не установлены easy_install или pip , вы можете загрузите архив с исходным кодом Beautiful Soup 4 и установите его с помощью setup.py .

$ python setup.py install

Если ничего не помогает, лицензия Beautiful Soup позволяет упакуйте всю библиотеку вместе с вашим приложением. Вы можете скачать tarball, скопируйте его bs4 в кодовую базу вашего приложения, и используйте Beautiful Soup, вообще не устанавливая его.

Я использую Python 2.7 и Python 3.2 для разработки Beautiful Soup, но это должен работать с другими последними версиями.

Проблемы после установки

Beautiful Soup упакован как код Python 2. Когда вы устанавливаете его для использовать с Python 3, он автоматически преобразуется в код Python 3. Если вы не устанавливаете пакет, код не будет конвертирован. Там есть также были сообщения о компьютерах с Windows неправильной версии. установлены.

Если вы получаете ImportError «Нет модуля с именем HTMLParser», ваш проблема в том, что вы используете версию кода Python 2 под Python 3.

Если вы получаете ImportError «Нет модуля с именем html.parser», ваш проблема в том, что вы используете версию кода Python 3 под Python 2.

В обоих случаях лучше всего полностью удалить Beautiful Установка Soup из вашей системы (включая любой каталог, созданный после распаковки архива) и повторите попытку установки.

Если вы получаете SyntaxError «Неверный синтаксис» в строке ROOT_TAG_NAME = u'[document]' , вам нужно преобразовать Python 2 код на Python 3. Это можно сделать либо путем установки пакета:

$ python3 setup.py install

, либо вручную запустив скрипт преобразования Python 2to3 на bs4 каталог:

$ 2to3-3.2 -w bs4

Установка синтаксического анализатора

Beautiful Soup поддерживает синтаксический анализатор HTML, включенный в стандарт Python библиотека, но она также поддерживает ряд сторонних парсеров Python. Одним из них является парсер lxml. В зависимости от вашей настройки, вы можете установить lxml с помощью одной из этих команд:

$ apt-get install python-lxml

$ easy_install lxml

$ pip install lxml

веб-браузер делает. В зависимости от вашей настройки вы можете установить html5lib с помощью одной из следующих команд:

$ apt-get install python-html5lib

$ easy_install html5lib

$ pip install html5lib

В этой таблице приведены преимущества и недостатки каждой библиотеки анализаторов: Типичное использование Преимущества Недостатки html. parser Python BeautifulSoup(разметка, "html.parser")

• Батарейки в комплекте
• Достойная скорость
• Снисходительный (начиная с Python 2.7.3 и 3.2.)

• Не так быстро, как lxml, менее снисходителен, чем html5lib.

 из bs4 import BeautifulSoup
с open("index.html") как fp:
    суп = BeautifulSoup(fp)
суп = BeautifulSoup("данные")
 

 BeautifulSoup("Sacré bleu!")
Голубой святой!
 

 суп = BeautifulSoup('Очень жирный шрифт')
тег = суп.b
тип (тег)
# <класс 'bs4.element.Tag'>
 

 тэг.имя
# у'б'
 

 tag.name = "blockquote"
ярлык
# 
Очень жирный шрифт
 

 тег['id']
# ты самый смелый
 

 tag.attrs
# {u'id': 'самый смелый'}
 

 tag['id'] = 'verybold'
тег['другой-атрибут'] = 1
ярлык
# 
тег ['id']
del tag['другой-атрибут']
ярлык
# 
тег['id']
# KeyError: 'идентификатор'
печать (тег. получить ('идентификатор'))
# Никто
 

 css_soup = BeautifulSoup('
')
css_soup.p['класс']
# ["тело"]
css_soup = BeautifulSoup('
')
css_soup.p['класс']
# ["тело", "перечеркивание"]
 

 id_soup = BeautifulSoup('
')
id_soup.p['id']
# 'мой ID'
 

 rel_soup = BeautifulSoup('
Вернуться на домашнюю страницу
')
rel_soup. a['rel']
# ['индекс']
rel_soup.a['rel'] = ['индекс', 'содержимое']
печать (rel_soup.p)
# 
Вернуться на домашнюю страницу
 

Вы можете отключить это, передав multi_valued_attributes=None в качестве Аргумент ключевого слова в конструктор BeautifulSoup :

 no_list_soup = BeautifulSoup('
', 'html', multi_valued_attributes=None)
no_list_soup.p['класс']
# u'тело вычеркнуто'
 

Вы можете использовать `get_attribute_list , чтобы получить значение, которое всегда список, независимо от того, является ли он многозначным атрибутом:

 id_soup.p.get_attribute_list('id')
# ["мой ID"]
 

При анализе документа как XML многозначные атрибуты отсутствуют:

 xml_soup = BeautifulSoup('
', 'xml')
xml_soup.p['класс']
# u'тело вычеркнуто'
 

Опять же, вы можете настроить это с помощью аргумента multi_valued_attributes :

 class_is_multi= { '*' : 'класс'}
xml_soup = BeautifulSoup('
', 'xml', multi_valued_attributes=class_is_multi)
xml_soup. p['класс']
# [u'body', u'strikeout']
 

Возможно, вам не понадобится это делать, но если вы это сделаете, используйте значения по умолчанию, как Руководство. Они реализуют правила, описанные в спецификации HTML:

 из bs4.builder import builder_registry
builder_registry.lookup('html').DEFAULT_CDATA_LIST_ATTRIBUTES
 

Навигационная строка

Строка соответствует фрагменту текста внутри тега. Красивый суп использует класс NavigableString , чтобы содержать следующие биты текста:

 tag.string
# u'Очень смело'
тип(тег.строка)
# <класс 'bs4.element.NavigableString'>
 

A NavigableString аналогична строке Python Unicode, за исключением что он также поддерживает некоторые функции, описанные в разделе Навигация. дерево и поиск дерева. Вы можете преобразовать NavigableString в строку Unicode с unicode() :

 unicode_string = unicode(tag.string)
unicode_string
# u'Очень смело'
тип (unicode_string)
# <тип 'юникод'>
 

Вы не можете редактировать строку на месте, но можете заменить одну строку на другой, используя replace_with():

 tag. string.replace_with("Больше не полужирный")
ярлык
# 
Больше не жирный шрифт
 

NavigableString поддерживает большинство функций, описанных в Навигация по дереву и поиск по дереву, но не все их. В частности, поскольку строка не может ничего содержать (как тег может содержать строку или другой тег), строки не поддерживают .contents или .string атрибуты или метод find() .

Если вы хотите использовать NavigableString вне Beautiful Soup, вы должны вызвать unicode() , чтобы превратить его в обычный Python Строка Юникода. Если вы этого не сделаете, ваша строка будет носить ссылка на все дерево синтаксического анализа Beautiful Soup, даже если вы сделано с помощью Beautiful Soup. Это большая трата памяти.

Красивый суп

Объект BeautifulSoup представляет проанализированный документ как весь. В большинстве случаев вы можете рассматривать его как тег объект. Это означает, что он поддерживает большинство методов, описанных в Навигация по дереву и поиск по дереву.

Вы также можете передать объект BeautifulSoup в один из методов определено в разделе «Изменение дерева», точно так же, как и тег. Этот позволяет вам делать такие вещи, как объединение двух проанализированных документов:

 doc = BeautifulSoup("INSERT FOOTER HEREВот нижний колонтитул", "xml")
doc.find(text="ВСТАВЬТЕ НИЖНИЙ ФУТЕР ЗДЕСЬ").replace_with(нижний колонтитул)
# u'ВСТАВЬТЕ НИЖНИЙ ФУТЕР ЗДЕСЬ'
распечатать (документ)
# 
# 
 

Поскольку объект BeautifulSoup не соответствует фактическому Тег HTML или XML, у него нет ни имени, ни атрибутов. Но иногда это полезно взглянуть на его .name , так что ему было присвоено специальное . имя «[документ]»:

 суп.название
# u'[документ]'
 

Вот снова HTML-документ «Три сестры»:

 html_doc = """

<тело>
История Сони
Жили-были три сестрички; и их имена были
Элси,
Лейси и
Тилли;
и жили они на дне колодца.
...
"""
из bs4 импортировать BeautifulSoup
суп = BeautifulSoup(html_doc, 'html.parser')
 

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

Вниз

Теги могут содержать строки и другие теги. Эти элементы являются тегом детей . Beautiful Soup предоставляет множество различных атрибутов для навигация и перебор дочерних элементов тега.

Обратите внимание, что строки Beautiful Soup не поддерживают ни один из этих атрибуты, потому что у строки не может быть дочерних элементов.

Навигация с использованием имен тегов

Самый простой способ навигации по дереву синтаксического анализа — произнести имя тег, который вы хотите. Если вам нужен тег, просто скажите суп.голова :

 суп.голова
# 
суп.название
# 
 

Вы можете использовать этот трюк снова и снова, чтобы увеличить определенную часть дерева синтаксического анализа. Этот код получает первый тег под тегом:

 суп.тело.b
# История Сони
 

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

 суп.а
# Элси
 

Если вам нужно получить все теги или что-то более сложное чем первый тег с определенным именем, вам нужно будет использовать один из методы, описанные в разделе Поиск по дереву, такие как find_all() :

 soap. find_all('a')
# [Элси,
# Лейси,
# Тилли]
 

.contents и .children

Дочерние элементы тега доступны в списке с именем .contents :

 head_tag ​​= суп.голова
head_tag
# 
head_tag.contents
[]
title_tag = head_tag.contents[0]
title_tag
# 
title_tag.contents
# [u'История Сони']
 

BeautifulSoup 9Сам объект 0108 имеет дочерние элементы. В этом случае Тег является потомком объекта BeautifulSoup .:

 len(soup.contents)
№ 1
суп.содержимое[0].имя
# u'html'
 

Строка не имеет .contents , потому что она не может содержать что угодно:

 текст = title_tag.contents[0]
text.contents
# AttributeError: объект 'NavigableString' не имеет атрибута 'contents'
 

Вместо того, чтобы получать их в виде списка, вы можете перебирать теги дети используют . children генератор:

 для дочернего элемента в title_tag.children:
    печать (ребенок)
# История Сони
 

.descendants

Атрибуты .contents и .children учитывают только теги прямых детей. Например, тег имеет один прямой дочерний элемент — тег]

Но у самого тега # История Сони

Тег имеет только одного потомка, но двух потомков: Тег] head_tag.string # u'История Сони'

Если тег содержит более одной вещи, то непонятно, что .string должен ссылаться, поэтому .string определяется как Нет :

 print(soup.html.string)
# Никто
 

. strings и stripped_strings

только струны. Используйте .strings генератор:

 для строки в супе.строки:
    печать (представление (строка))
# u"История Сони"
# u'\n\n'
# u"История Сони"
# u'\n\n'
# u'Жили-были три сестрички; и их имена были\n'
# ты Элси
# u',\n'
# ты Лейси
# и' и\n'
# у'Тилли'
# u';\nи жили они на дне колодца.'
# u'\n\n'
# ты...'
# п'\п'
 

В этих строках обычно много лишних пробелов, которые вы можете удалить с помощью .stripped_strings 9Генератор 0108 вместо:

 для строки в супе.stripped_strings:
    печать (представление (строка))
# u"История Сони"
# u"История Сони"
# u'Жили-были три сестрички; и их имена были'
# ты Элси
# у','
# ты Лейси
# и'и'
# у'Тилли'
# u';\nи жили они на дне колодца.'
# ты...'
 

Здесь игнорируются строки, полностью состоящие из пробелов, и пробелы в начале и конце строк удаляются.

Вверх

Продолжая аналогию с «генеалогическим древом», каждый тег и каждая строка имеют parent : содержащий его тег.

.parent

Вы можете получить доступ к родителю элемента с помощью атрибута .parent . В пример документа «три сестры», тег является родительским тега title_tag.parent #

Сама строка заголовка имеет родителя: тег

Родителем тега верхнего уровня, такого как, является объект BeautifulSoup сам:

 html_tag = суп.html
тип (html_tag.parent)
# <класс 'bs4.BeautifulSoup'>
 

И .parent объекта BeautifulSoup определяется как None:

 print(soup.parent)
# Никто
 

.parents

Вы можете перебрать всех родителей элемента с помощью .родители . В этом примере используется .parents для перехода от тега спрятан глубоко внутри документа, до самого верха документа:

 ссылка = суп. а
ссылка на сайт
# Элси
для родителя в link.parents:
    если родитель None:
        печать (родительский)
    еще:
        печать (родитель.имя)
# п
# тело
# html
# [документ]
# Никто
 

Идти боком

Рассмотрим простой документ вроде этого:

 sibling_soup = BeautifulSoup("text1text2")
печать (sibling_soup.prettify())
# 
# <тело>
# <а>
# <б>
#     текст 1
# 
# <с>
# текст2
# 
# 
# 
# 
 

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

.next_sibling и .previous_sibling

Вы можете использовать .next_sibling и .previous_sibling для навигации между элементами страницы, которые находятся на одном уровне дерева разбора:

 sibling_soup. b.next_sibling
# текст2
sibling_soup.c.previous_sibling
# текст1
 

В теге есть .next_sibling , но нет .previous_sibling , потому что перед тегом на том же уровне дерево . По той же причине тег имеет .previous_sibling но нет .next_sibling :

 print(sibling_soup.b.previous_sibling)
# Никто
печать (sibling_soup.c.next_sibling)
# Никто
 

Строки «текст1» и «текст2» являются , а не одноуровневыми, потому что они не иметь одного родителя:

 sibling_soup.b.string
# у'текст1'
печать (sibling_soup.b.string.next_sibling)
# Никто
 

В реальных документах .next_sibling или .previous_sibling тег обычно представляет собой строку, содержащую пробелы. Возвращаясь к Документ «три сестры»:

 Элси
Лейси
Тилли
 

Можно подумать, что . next_sibling первого тега будет быть вторым тегом . Но на самом деле это строка: запятая и перевод строки, отделяющий первый тег от второго:

 ссылка = суп.а
ссылка на сайт
# Элси
ссылка.next_sibling
# u',\n'
 

Второй тег на самом деле является .next_sibling запятой:

 link.next_sibling.next_sibling
# Лейси
 

.next_siblings и .previous_siblings

Вы можете перебрать одноуровневых элементов тега с помощью .previous_siblings :

 для брата в супе.а.next_siblings:
    печать (репр (родной брат))
# u',\n'
# Лейси
# и' и\n'
# Тилли
# у'; и жили они на дне колодца».
# Никто
для родного брата в супе.find(id="link3").previous_siblings:
    печать (репр (родной брат))
# ' и н'
# Лейси
# u',\n'
#  com/elsie">Элси
# u'Жили-были три сестрички; и их имена были\n'
# Никто
 

Взад и вперед

Взгляните на начало документа «Три сестры»:

 
История Сони
 

Анализатор HTML берет эту строку символов и превращает ее в серии событий: «открыть тег», «открыть тег», «открыть тег Тег <тело>

История Сони

Жили-были три сестрички; и их имена были com/elsie">Элси, Лейси и Тилли; и жили они на дне колодца.

...

""" из bs4 импортировать BeautifulSoup суп = BeautifulSoup(html_doc, 'html.parser')

Передав фильтр аргументу вроде find_all() , вы можете увеличьте интересующие вас части документа.

Виды фильтров

хотите показать примеры различных фильтров, которые вы можете передать в эти методы. Эти фильтры появляются снова и снова на протяжении всего поисковый API. Вы можете использовать их для фильтрации по имени тега, на его атрибутах, на тексте строки или на некоторой комбинации эти.

Строка

Простейшим фильтром является строка. Передайте строку методу поиска и Beautiful Soup выполнит сопоставление именно с этой строкой. Этот код находит все теги в документе:

 soap.find_all('b')
# [История Сони]
 

Если вы передаете строку байтов, Beautiful Soup будет считать, что строка кодируется как UTF-8. Вы можете избежать этого, передав вместо этого строку Unicode.

Регулярное выражение

9б")): печать (тег.имя) # тело # б

Этот код находит все теги, имена которых содержат букву «t»:

 для тега в супе.find_all(re.compile("t")):
    печать (тег.имя)
# html
# заглавие
 

Список

Если вы передадите список, Beautiful Soup разрешит совпадение строки против любого элемента в этом списке. Этот код находит все теги и все теги :

 суп.find_all(["a", "b"])
# [История Сони,
# Элси,
# Лейси,
# Тилли]
 

True

Значение True соответствует всему, что возможно. Этот код находит все теги в документе, но ни одна из текстовых строк:

 для тега в супе.find_all(True):
    печать (тег.имя)
# html
# глава
# заглавие
# тело
# п
# б
# п
# а
# а
# а
# п
 

Функция

Если ни одно из других совпадений вам не подходит, определите функцию, которая принимает элемент в качестве единственного аргумента. Функция должна вернуть Истинно , если аргумент совпадает, и Ложь иначе.

Вот функция, которая возвращает True , если тег определяет «класс» атрибут, но не определяет атрибут «id»:

 def has_class_but_no_id(tag):
    вернуть tag.has_attr('класс'), а не tag.has_attr('id')
 

Передайте эту функцию в find_all() и вы получите все

теги:

 суп.find_all (has_class_but_no_id)
# [
История Сони
,
# 
Жили-были...
,
# 
...
]
 

Эта функция принимает только теги

. Он не поднимает теги, потому что эти теги определяют как «класс», так и «идентификатор». Он не выбирает теги, такие как и] суп.найти_все ("р", "название") # [

История Сони

] суп.найти_все ("а") # [Элси, # Лейси, # Тилли] суп.найти_все (id = "ссылка2") # [Лейси] импортировать повторно суп.найти(строка=перекомпилировать("сестры")) # u'Жили-были три сестрички; и их имена были\n'

Некоторые из них должны выглядеть знакомыми, а другие — новыми. Что это делает значит передать значение для строки или id ? Почему find_all("p", "title") найти тег

с CSS-классом title? Давайте посмотрим на аргументы find_all() .

Имя

Аргумент

Введите значение для имени , и вы скажете Beautiful Soup только рассмотреть теги с определенными именами. Текстовые строки будут игнорироваться, т.к. будут теги, имена которых не совпадают.

Это самое простое использование:

 суп.найти_все("название")
# []
 

Напомним из Виды фильтров, что значение имя может быть строка, регулярное выражение, список, функция или значение Истинный.

Аргументы ключевого слова

Любой аргумент, который не распознан, будет преобразован в фильтр на одном атрибутов тега. Если вы передаете значение для аргумента с именем id , Beautiful Soup будет фильтровать по атрибуту «id» каждого тега:

 суп.find_all(id='link2')
# [Лейси]
 

Если вы передадите значение для href , Beautiful Soup будет фильтровать против атрибута href каждого тега:

 soap.find_all(href=re.compile("elsie"))
# [Элси]
 

Вы можете фильтровать атрибут на основе строки, обычного выражение, список, функция или значение True.

Этот код находит все теги, атрибут id имеет значение, независимо от значения:

 суп. найти_все (идентификатор = Истина)
# [Элси,
# Лейси,
# Тилли]
 

Вы можете фильтровать несколько атрибутов одновременно, передавая более одного Аргумент ключевого слова:

 soap.find_all(href=re.compile("Элси"),)
# [три]
 

Некоторые атрибуты, например атрибуты data-* в HTML 5, имеют имена, нельзя использовать в качестве имен аргументов ключевого слова:

 data_soup = BeautifulSoup('
foo!
')
data_soup.find_all (данные-foo = "значение")
# SyntaxError: ключевое слово не может быть выражением
 

Вы можете использовать эти атрибуты в поиске, поместив их в словарь и передать словарь в find_all() как attrs аргумент:

 data_soup.find_all(attrs={"data-foo": "value"})
# [
foo!
]
 

Вы не можете использовать аргумент ключевого слова для поиска элемента «имя» HTML, потому что Beautiful Soup использует аргумент имя , чтобы содержать имя самого тега. Вместо этого вы можете указать значение «имя» в attrs аргумент:

 name_soup = BeautifulSoup('')
name_soup.find_all(name="email")
# []
name_soup.find_all(attrs={"name": "email"})
# []
 

Поиск по классу CSS

Очень удобно искать тег с определенным классом CSS, но имя атрибута CSS, «класс», является зарезервированным словом в Питон. Использование class в качестве аргумента ключевого слова даст вам синтаксис ошибка. Начиная с Beautiful Soup 4.1.2, вы можете искать по классу CSS, используя аргумент ключевого слова class_ :

 суп.найти_все("а", class_="сестра")
# [Элси,
# Лейси,
# Тилли]
 

Как и в случае любого аргумента ключевого слова, вы можете передать class_ строку, обычный выражение, функция или True :

 суп. найти_все(класс_=повторно.компилировать("itl"))
# [
История Сони
]
защита has_six_characters (css_class):
    вернуть css_class не None и len(css_class) == 6
суп.найти_все (класс_ = имеет_шесть_символов)
# [Элси,
# Лейси,
# Тилли]
 

Помните, что у одного тега может быть несколько значения для его атрибута «класс». Когда вы ищете тег, который соответствует определенному классу CSS, вы сопоставляете любые своего CSS классы:

 css_soup = BeautifulSoup('
')
css_soup.find_all("p", class_="strikeout")
# [
]
css_soup.find_all("p", class_="тело")
# [
]
 

Вы также можете выполнить поиск точного строкового значения атрибута класса :

 css_soup.find_all("p", class_="body strikeout")
# [
]
 

Но поиск вариантов строкового значения не сработает:

 css_soup.find_all("p", class_="strikeout body")
# []
 

Если вы хотите найти теги, соответствующие двум или более классам CSS, вам следует использовать селектор CSS:

 css_soup. select("p.strikeout.body")
# [
]
 

В старых версиях Beautiful Soup, в которых нет класса _ ярлык, вы можете использовать трюк attrs , упомянутый выше. Создать словарь, значением которого для «класса» является строка (или обычный выражение или что-то еще), которое вы хотите найти:

 soap.find_all("a", attrs={"class": "sister"})
# [Элси,
# Лейси,
# Тилли]
 

Строка

Аргумент

С помощью строки вы можете искать строки вместо тегов. Как с имя и аргументы ключевого слова, вы можете передать в строке, регулярное выражение, список, функция или значение True. Вот несколько примеров:

 soap.find_all(string="Элси")
# [у'Элси']
суп.найти_все (строка = ["Тилли", "Элси", "Лейси"])
# [у'Элси', у'Лейси', у'Тилли']
суп.найти_все (строка = перекомпилировать ("Соня"))
[u"История Сони", u"История Сони"]
def is_the_only_string_within_a_tag(s):
    """Возвращает True, если эта строка является единственным дочерним элементом своего родительского тега. """
    возврат (s == s.parent.string)
суп.найти_все (строка = is_the_only_string_within_a_tag)
# [u"История Сони", u"История Сони", u'Элси', u'Лейси', u'Тилли', u'...']
 

Хотя строка предназначена для поиска строк, вы можете комбинировать ее с аргументы, которые находят теги: Beautiful Soup найдет все теги, .string соответствует вашему значению для string . Этот код находит теги, у которых .string — «Элси»:

 суп.найти_все («а», строка = «Элси»)
# [Элси]
 

Аргумент string появился в Beautiful Soup 4.4.0. Ранее версии он назывался текст :

 суп.find_all ("а", текст = "Элси")
# [Элси]
 

Аргумент

limit

find_all() возвращает все теги и строки, соответствующие вашему фильтры. Это может занять некоторое время, если документ большой. Если вы не нужно все результаты, вы можете передать число для ограничение . Этот работает так же, как ключевое слово LIMIT в SQL. Он сообщает Beautiful Soup прекратить сбор результатов после того, как будет найдено определенное число.

В документе «три сестры» есть три ссылки, но этот код находит только первые два:

 soap.find_all("a", limit=2)
# [Элси,
# Лейси]
 

рекурсивный аргумент

Если вы вызовете mytag.find_all() , Beautiful Soup проверит все потомки mytag : его дочерние, его дочерние дочерние и скоро. Если вы хотите, чтобы Beautiful Soup учитывал только прямых детей, вы можете пройти через рекурсивный=ложь . Посмотрите разницу здесь:

 суп.html.find_all("название")
# []
суп.html.find_all ("заголовок", рекурсивный = Ложь)
# []
 

Вот эта часть документа:

 
 <голова>
  <название>
   История Сони
  
 
... 
 

Тег] суп. найти('название') #

Единственное отличие состоит в том, что find_all() возвращает список, содержащий единственный результат, а find() просто возвращает результат.

Если find_all() ничего не может найти, возвращается пустой список. Если find() ничего не может найти, возвращает None :

 print(soup.find("nosuchtag"))
# Никто
 

Помните трюк soap.head.title из Навигация с использованием тега имена? Этот трюк работает при повторном вызове find() :

 sup.head.title
# 
суп.найти("голова").найти("название")
# 
 

find_parents() и find_parent()

Подпись: find_parents(name, attrs, string, limit, **kwargs)

Подпись: find_parent(name, attrs, string, **kwargs)

I

2 провел много времени выше, охватывая

find_all() и найти() . Beautiful Soup API определяет десять других методов для ищите дерево, но не бойтесь. Пять из этих методов в основном то же самое, что и find_all() , а остальные пять в основном то же, что найти() . Различия только в том, какие части дерево они ищут.

Сначала рассмотрим find_parents() и find_parent() . Помните, что find_all() и find() работают спускаются по дереву, глядя на потомков тега. Эти методы делают наоборот: они прокладывают себе путь вверх по дереву, глядя на теги (или строки) родителей. Давайте попробуем их, начиная со строки похоронен глубоко в документе «трех дочерей»:

 a_string = суп.найти (строка = "Лейси")
строка
# ты Лейси
a_string.find_parents ("а")
# [Лейси]
a_string.find_parent("p")
# 
Жили-были три сестрички; и их имена были
# Элси,
# Лейси и
#  com/tillie">Тилли;
# и они жили на дне колодца.
a_string.find_parents("p",)
# []
 

Один из трех тегов является прямым родительским элементом строки в вопрос, поэтому наш поиск находит его. Один из трех тегов

является косвенный родитель строки, и наш поиск находит, что как Что ж. Там есть тег

с CSS-классом title где-то в document, но он не является одним из родителей этой строки, поэтому мы не можем найти это с find_parents() .

Возможно, вы установили связь между find_parent() и find_parents() и атрибуты .parent и .parents упомянутый ранее. Связь очень сильная. Эти методы поиска на самом деле используйте .parents для перебора всех родителей и проверки каждый против предоставленного фильтра, чтобы увидеть, соответствует ли он.

find_next_siblings() и find_next_sibling()

Подпись: find_next_siblings(name, attrs, string, limit, **kwargs)

Подпись: find_next_sibling(name, **ktrs, string0002 Эти методы используют . next_siblings для итерация по остальным братьям и сестрам элемента в дереве. Метод find_next_siblings() возвращает всех совпадающих братьев и сестер, и find_next_sibling() возвращает только первый:

 first_link = суп.а
первая_ссылка
# Элси
first_link.find_next_siblings("а")
# [Лейси,
# Тилли]
first_story_paragraph = суп.найти("р", "история")
first_story_paragraph.find_next_sibling("p")
# 
...
 

find_previous_siblings() и find_previous_sibling()

Подпись: find_previous_siblings(name, attrs, string, limit, **kwargs)

Signature: find_previous_sibling(name, at**trs, string) методы используют .previous_siblings для перебора элементов братьев и сестер, которые предшествуют ему в дереве. find_previous_siblings() метод возвращает всех совпадающих братьев и сестер, и find_previous_sibling() возвращает только первый:

 last_link = суп. найти("а",)
последняя_ссылка
# Тилли
last_link.find_previous_siblings("а")
# [Лейси,
# Элси]
first_story_paragraph = суп.найти("р", "история")
first_story_paragraph.find_previous_sibling("p")
# 
История Сони
 

find_all_next() и find_next()

Подпись: find_all_next(name, attrs, string, limit, **kwargs)

Подпись: find_next(name, attrs, string, **kwargs)

Эти методы используют .next_elements для перебирать любые теги и строки, которые идут после него в документ. Метод find_all_next() возвращает все совпадения и find_next() возвращает только первое совпадение:

 first_link = суп.а
первая_ссылка
# Элси
first_link.find_all_next (строка = Истина)
# [u'Элси', u',\n', u'Лейси', u' и\n', u'Тилли',
# u';\nи жили они на дне колодца. ', u'\n\n', u'...', u'\n']
first_link.find_next("p")
# 
...
 

В первом примере появилась строка «Элси», хотя она была содержится в теге , с которого мы начали. Во втором примере появился последний тег

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

find_all_previous() и find_previous()

Подпись: find_all_previous(name, attrs, string, limit, **kwargs)

Подпись: find_previous(name, attrs, string, **kwargs)

Эти методы используют .previous_elements для перебирать теги и строки, которые были до него в документ. Метод find_all_previous() возвращает все совпадения и find_previous() возвращает только первое совпадение:

 first_link = суп.а
первая_ссылка
# Элси
first_link. find_all_previous("p")
# [
Жили-были три сестрички; ...
,
# 
История Сони
]
first_link.find_previous("название")
# 
 

Вызов find_all_previous("p") нашел первый абзац в документ (тот, у которого class="title"), но также находит второй абзац, тег

, который содержит тег , который мы начали с. Это не должно быть слишком удивительным: мы смотрим на все теги которые появляются в документе раньше, чем тот, с которого мы начали. А Тег

, содержащий тег , должен отображаться перед тегом . тег, который он содержит.

Селекторы CSS

Начиная с версии 4.7.0 Beautiful Soup поддерживает большинство селекторов CSS4 через СупСито проект. Если вы установили Beautiful Soup через pip , SoupSieve был установлен в то же время, поэтому вам не нужно делать ничего дополнительно.

BeautifulSoup имеет метод .select() , который использует SoupSieve для запустите селектор CSS для проанализированного документа и верните все совпадающие элементы. Тег имеет аналогичный метод, который запускает CSS селектор против содержимого одного тега.

(в более ранних версиях Beautiful Soup также есть .select() метод, но поддерживаются только наиболее часто используемые селекторы CSS.)

В документации SoupSieve перечислены все текущие поддерживаются селекторы CSS, но вот некоторые из основ:

Вы можете найти теги:

 soap.select("title")
# []
суп.выбрать("p:n-го типа(3)")
# [
...
]
 

Найти теги под другими тегами:

 суп.выбрать("тело а")
# [Элси,
# Лейси,
# Тилли]
суп.выбрать("заголовок html")
# []
 

Найти теги напрямую под другими тегами:

 суп.выбрать("head > title")
# []
суп.выбрать("р > а")
# [Элси,
#  com/lacie" >Лейси,
# Тилли]
суп.выбрать("p > a:nth-of-type(2)")
# [Лейси]
суп.выбрать("р > #ссылка1")
# [Элси]
суп.выбрать("тело > а")
# []
 

Найти братьев и сестер тегов:

 soap.select("#link1 ~ .sister")
# [Лейси,
# Тилли]
суп.выбрать("#ссылка1 + .сестра")
# [Лейси]
 

Найти теги по классу CSS:

 суп.выбрать(".sister")
# [Элси,
# Лейси,
# Тилли]
суп.выбрать("[класс~=сестра]")
# [Элси,
# Лейси,
# Тилли]
 

Поиск тегов по ID:

 суп.выберите("#link1")
# [ com/elsie">Элси]
суп.выбрать("#ссылка2")
# [Лейси]
 

Найти теги, соответствующие любому селектору из списка селекторов:

 суп.выбрать("#link1,#link2")
# [Элси,
# Лейси]
 

Проверка наличия атрибута: 9="http://example.com/"]') # [Элси, # Лейси, # Тилли] суп.выбрать('а[href$="тилли"]') # [Тилли] суп.выбрать('а[href*=".com/el"]') # [Элси]

Существует также метод под названием select_one() , который находит только первый тег, соответствующий селектору:

 суп.select_one(".сестра")
# Элси
 

Если вы проанализировали XML, определяющий пространства имен, вы можете использовать их в CSS селекторы. :

 из импорта bs4 BeautifulSoup
xml = """<тег xmlns:ns1="http://namespace1/" xmlns:ns2="http://namespace2/">
 Я нахожусь в пространстве имен 1
 Я нахожусь в пространстве имен 2
 """
суп = BeautifulSoup(xml, "xml")
суп.выбрать("ребенок")
# [Я в пространстве имен 1, Я в пространстве имен 2]
суп.выбрать("ns1|ребенок", namespaces=namespaces)
# [Я нахожусь в пространстве имен 1]
 

При обработке селектора CSS, использующего пространства имен, Beautiful Soup использует аббревиатуры пространств имен, найденные при анализе документ. Вы можете переопределить это, передав свой собственный словарь сокращения:

 пространств имен = dict(first="http://namespace1/", second="http://namespace2/")
суп.выбрать("второй|дочерний", namespaces=namespaces)
# [Я нахожусь в пространстве имен 2]
 

Все эти CSS-селекторы удобны для тех, кто уже знать синтаксис селектора CSS. Все это можно сделать с помощью API красивого супа. И если селекторы CSS — это все, что вам нужно, вы должны разобрать документ с помощью lxml: это намного быстрее. Но это позволяет вам объединяет селектора CSS с API Beautiful Soup.

Основная сила Beautiful Soup заключается в поиске по дереву синтаксического анализа, но вы также можете изменить дерево и записать свои изменения в виде нового HTML или XML документ.

Изменение имен тегов и атрибутов

Я рассказывал об этом ранее, в разделе Атрибуты, но стоит повторить. Ты может переименовывать тег, изменять значения его атрибутов, добавлять новые атрибуты и атрибуты удаления:

 суп = BeautifulSoup('Очень жирный шрифт')
тег = суп.b
tag.name = "Цитата"
тег ['класс'] = 'очень жирный'
тег ['id'] = 1
ярлык
# 
Очень жирный шрифт
тег ['класс']
тег ['id']
ярлык
# 
Очень жирный шрифт
 

Изменение

.string

Если вы установите для атрибута . string тега новую строку, содержимое тега заменено этой строкой:

 markup = 'Я связался с example.com'
суп = BeautifulSoup(разметка)
тег = суп.а
tag.string = "Текст новой ссылки."
ярлык
# Новый текст ссылки.
 

Будьте осторожны: если тег содержит другие теги, они и все их содержимое будет уничтожено.

append()

Вы можете добавить содержимое тега с помощью Tag.append() . Это работает просто например, вызов .append() в списке Python:

 суп = BeautifulSoup("Foo")
суп.a.append("Бар")
суп
# FooBar
суп.а.содержимое
# [у'Фу', у'Бар']
 

extend()

Начиная с Beautiful Soup 4.7.0, Тег также поддерживает метод вызывается .extend() , который работает так же, как вызов .extend() на Список Python:

 суп = BeautifulSoup("Soup")
суп. а.расширить(["с", " ", "на"])
суп
# Суп готов
суп.а.содержимое
# [т'Суп', т'с', у'', у'он']
 

NavigableString() и .new_tag()

Если вам нужно добавить строку в документ, нет проблем — вы можете передать Строка Python до append() , или вы можете вызвать NavigableString конструктор:

 суп = BeautifulSoup("")
тег = суп.b
тег.append("Привет")
new_string = NavigableString ("там")
тег.append(новая_строка)
ярлык
# Здравствуйте.
тег.содержимое
# [у'Привет', ты там']
 

Если вы хотите создать комментарий или другой подкласс NavigableString , просто вызовите конструктор:

 из импорта bs4 Комментарий
new_comment = Комментарий("Рад тебя видеть")
тег.append(новый_комментарий)
ярлык
# Здравствуйте
тег.содержимое
# [u'Привет', u'там', u'Рад тебя видеть.']
 

(Это новая функция в Beautiful Soup 4. 4.0.)

Что делать, если вам нужно создать совершенно новый тег? Лучшее решение - вызвать фабричный метод BeautifulSoup.new_tag() :

 суп = BeautifulSoup("")
original_tag = суп.b
новый_тег = суп.новый_тег("а", href="http://www.example.com")
original_tag.append (новый_тег)
original_tag
# 
new_tag.string = "Текст ссылки."
original_tag
# Текст ссылки.
 

Требуется только первый аргумент, имя тега.

insert()

Tag.insert() аналогичен Tag.append() , за исключением нового элемента не обязательно идет в конце родительского .содержимое . Он будет вставлен в любую числовую позицию, которую вы сказать. Он работает так же, как .insert() в списке Python:

 markup = 'Я связан с example.com'
суп = BeautifulSoup(разметка)
тег = суп. а
tag.insert(1, "но не одобрял")
ярлык
# Я дал ссылку на example.com, но не поддержал его
тег.содержимое
# [u'я сделал ссылку на ', u'но не одобрил', example.com]
 

insert_before() и insert_after()

Метод insert_before() вставляет теги или строки немедленно перед чем-то еще в дереве синтаксического анализа:

 суп = BeautifulSoup("stop")
тег = суп.новый_тег("я")
tag.string = "Не"
суп.b.string.insert_before(тег)
суп.б
# Не останавливайтесь
 

Метод insert_after() немедленно вставляет теги или строки после чего-то еще в дереве синтаксического анализа:

 раздел = суп.новый_тег('дел')
div.string = 'когда-либо'
суп.b.i.insert_after("вы", div)
суп.б
# Не 
никогда
 останавливаться
суп.b.содержимое
# [Не, ты, 
когда-нибудь
, остановись']
 

clear()

Tag. clear() удаляет содержимое тега:

 markup = 'Я связан с example .com'
суп = BeautifulSoup(разметка)
тег = суп.а
тег.очистить()
ярлык
# 
 

decompose()

Tag.decompose() удаляет тег из дерева, затем полностью уничтожает его и его содержимое :

 markup = 'Я связан с example.com'
суп = BeautifulSoup(разметка)
a_tag = суп.а
суп.и.разложить()
a_tag
# Я связался с
 

replace_with()

PageElement.replace_with() удаляет тег или строку из дерева, и заменяет его тегом или строкой по вашему выбору:

 markup = 'Я связан с example.com'
суп = BeautifulSoup(разметка)
a_tag = суп.а
новый_тег = суп.новый_тег ("б")
new_tag.string = "example.net"
a_tag.i.replace_with (новый_тег)
a_tag
#  com/">Я связался с example.net
 

replace_with() возвращает тег или строку, которая была заменена, поэтому что вы можете изучить его или добавить обратно в другую часть дерева.

wrap()

PageElement.wrap() заключает элемент в указанный вами тег. Это возвращает новую оболочку:

 суп = BeautifulSoup("
Хотел бы я быть смелым.
")
суп.p.string.wrap(soup.new_tag("b"))
# Хотел бы я быть смелым.
суп.p.wrap(soup.new_tag("div")
# 
Хотел бы я быть смелым.
 

Этот метод появился в Beautiful Soup 4.0.5.

развернуть()

Tag.unwrap() является противоположностью wrap() . Он заменяет тег на все, что находится внутри этого тега. Это удобно для удаления разметки:

 markup = 'Я сделал ссылку на example.com'
суп = BeautifulSoup(разметка)
a_tag = суп.а
a_tag.i.unwrap()
a_tag
#  com/">Я сделал ссылку на example.com
 

Как replace_with() , unwrap() возвращает тег что заменили.

smooth()

После вызова нескольких методов, изменяющих дерево синтаксического анализа, вы можете получить два или более объекта NavigableString рядом друг с другом. У Beautiful Soup с этим проблем нет, но, поскольку это невозможно в только что проанализированном документе, можно не ожидать следующего поведения: ) суп.п.добавить(", двойка") суп.п.содержимое # [u'A one', u', a two'] печать (суп.p.encode()) #

Раз, два

печать (суп.p.prettify()) # <р> # Один # , двойка #

Вы можете вызвать Tag.smooth() для очистки дерева синтаксического анализа путем объединения соседних строк:

 суп.smooth()
суп.п.содержимое
# [u'A один, два']
печать (суп.p.prettify())
# <р>
# Раз, два
# 

 

Метод smooth() появился в Beautiful Soup 4.8.0.

Pretty-printing

Метод prettify() превратит дерево синтаксического анализа Beautiful Soup в красиво отформатированная строка Unicode, с отдельной строкой для каждой тег и каждая строка:

 markup = ' com/">Я сделал ссылку на example.com'
суп = BeautifulSoup(разметка)
суп.красиво()
# '\n \n \n \n \n...'
распечатать (суп.красиво())
# 
# <голова>
# 
# <тело>
# 
# Я связался с
# <я>
# пример.com
# 
# 
# 
# 
 

Вы можете вызвать prettify() для объекта верхнего уровня BeautifulSoup , или на любом из его объектов Tag :

 print(soup.a.prettify())
# 
# Я связался с
# <я>
# пример.com
# 
# 
 

Некрасивая печать

Если вам нужна просто строка без причудливого форматирования, вы можете позвонить unicode() или str() на объекте BeautifulSoup или Тег внутри него:

 ул(суп)
# 'Я сделал ссылку на example.com'
юникод (суп. а)
# u'Я связался с example.com'
 

Функция str() возвращает строку в кодировке UTF-8. Видеть Кодировки для других опций.

Вы также можете вызвать encode() , чтобы получить строку байтов, и декодировать() чтобы получить Юникод.

Средства форматирования вывода

Если вы предоставите Beautiful Soup документ, содержащий объекты HTML, такие как «&lquot;», они будут преобразованы в символы Юникода:

 суп = BeautifulSoup("“Черт возьми!” сказал он.")
юникод (суп)
# u'\u201cЧерт возьми!\u201d он сказал.'
 

Если затем преобразовать документ в строку, символы Unicode будет закодирован как UTF-8. Вы не вернете HTML-сущности:

 ул(суп)
# '\xe2\x80\x9cЧерт возьми!\xe2\x80\x9d сказал он.'
 

По умолчанию единственные символы, которые экранируются при выводе, пусты. Амперсанды и угловые скобки. Они превращаются в «&», «<», и «>», чтобы Beautiful Soup случайно не сгенерировал неверный HTML или XML:

 суп = BeautifulSoup("
Юридическая фирма Dewey, Cheatem, & Howe
")
суп.п
# 
Юридическая фирма Dewey, Cheatem, & Хоу
суп = BeautifulSoup('Ссылка')
суп.а
# Ссылка
 

Вы можете изменить это поведение, указав значение для форматер аргумент для prettify() , encode() , или декодировать() . Beautiful Soup распознает пять возможных значений для форматер .

По умолчанию formatter="minimal" . Строки будут обрабатываться только достаточно, чтобы убедиться, что Beautiful Soup генерирует правильный HTML/XML:

 french = "
Il a dit <<Sacré bleu!>>
"
суп = BeautifulSoup (французский)
печать (soup. prettify (formatter = "минимальный"))
# 
# <тело>
# <р>
# Il a dit <<Sacré bleu!>>
# 

# 
# 
 

Если вы передадите formatter="html" , Beautiful Soup преобразует Символы Юникода в объекты HTML, когда это возможно:

 print(soup.prettify(formatter="html"))
# 
# <тело>
# <р>
# Il a dit <<Sacré блю!>>
# 

# 
# 
 

Если вы передадите formatter="html5" , это то же самое, что formatter="html5" , но Beautiful Soup опустите закрывающую косую черту в HTML-тегах void, таких как «br»:

 суп = BeautifulSoup("
")
печать (суп.кодировать (formatter = "html"))
# 

печать (суп.кодировать (formatter = "html5"))
# 

 

Если вы передадите formatter=None , Beautiful Soup не будет изменен строки вообще на выходе. Это самый быстрый вариант, но он может привести на Beautiful Soup, создающий недопустимый HTML/XML, как в этих примерах:

 print(soup. prettify(formatter=None))
# 
# <тело>
# <р>
# Il a dit <>
# 

# 
# 
link_soup = BeautifulSoup('Ссылка')
печать (link_soup.a.encode (formatter = None))
# Ссылка
 

Если вам нужен более сложный контроль над вашим выходом, вы можете используйте класс Formatter от Beautiful Soup. Вот форматтер, который преобразует строки в верхний регистр, независимо от того, встречаются ли они в текстовом узле или в значение атрибута:

 из bs4.formatter import HTMLFormatter
заглавная буква (ул):
    вернуть ул.верхний()
форматтер = HTMLFormatter (верхний регистр)
печать (soup.prettify (форматтер = форматтер))
# 
# <тело>
# <р>
# IL A DIT <>
# 

# 
# 
print(link_soup.a.prettify(formatter=formatter))
# 
#  ССЫЛКА
# 
 

Подклассы HTMLFormatter или XMLFormatter дадут вам даже больше контроля над выводом. Например, Beautiful Soup сортирует атрибуты в каждом теге по умолчанию:

 attr_soup = BeautifulSoup(b'
')
печать (attr_soup.p.encode())
# 

 

Чтобы отключить это, вы можете создать подкласс Formatter.attributes() метод, который контролирует, какие атрибуты выводятся и в каком заказ. Эта реализация также отфильтровывает атрибут с именем «m». всякий раз, когда он появляется:

 класс UnsortedAttributes (HTMLFormatter):
    Атрибуты определения (я, тег):
        для k, v в tag.attrs.items():
            если к == 'м':
                Продолжать
            выход k, v
print(attr_soup.p.encode(formatter=UnsortedAttributes()))
# 

 

Последнее предостережение: если вы создаете объект CData , текст внутри этот объект всегда представляется точно таким, каким он выглядит, без форматирование . Beautiful Soup вызовет замену вашей сущности на тот случай, если вы написали пользовательскую функцию, которая все строки в документе или что-то в этом роде, но он будет игнорировать возвращаемое значение:

 из bs4. element импорт CData
суп = BeautifulSoup("")
суп.а.строка = CData("один < три")
печать (soup.a.prettify (formatter = "xml"))
# <а>
# 
 

get_text()

Если вам нужна только текстовая часть документа или тега, вы можете использовать метод get_text() . Он возвращает весь текст в документе или под тегом в виде одной строки Unicode:

 markup = '\nЯ связан с example.com\n '
суп = BeautifulSoup(разметка)
суп.get_text()
u'\nЯ связался с example.com\n'
суп.i.get_text()
u'example.com'
 

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

 # суп.get_text("|")
u'\nЯ связан с |example.com|\n'
 

Вы можете указать Beautiful Soup удалять пробелы с самого начала и конец каждого бита текста:

 # soap.get_text("|", strip=True)
u'Я связан с |example.com'
 

Но в этот момент вы можете захотеть использовать . stripped_strings вместо генератора и обработайте текст самостоятельно:

 [текст для текста в супе.stripped_strings]
# [u'Я связан с', u'example.com']
 

Если вам просто нужно проанализировать HTML, вы можете сбросить разметку в конструктор BeautifulSoup , и, наверное, все будет хорошо. Красивый Soup подберет для вас парсер и проанализирует данные. Но есть несколько дополнительных аргументов, которые вы можете передать конструктору для изменения какой парсер используется.

Первым аргументом конструктора BeautifulSoup является строка или открытый дескриптор файла — разметка, которую вы хотите проанализировать. Второй аргумент как вы хотите анализировать разметку.

Если вы ничего не укажете, вы получите лучший анализатор HTML, который установлены. Beautiful Soup оценивает синтаксический анализатор lxml как лучший, затем html5lib, затем встроенный парсер Python. Вы можете переопределить это, указав одно из следующего:

• Какой тип разметки вы хотите анализировать. В настоящее время поддерживаются «html», «xml» и «html5».
• Имя библиотеки парсера, которую вы хотите использовать. В настоящее время поддерживается варианты «lxml», «html5lib» и «html.parser» (Python’s встроенный парсер HTML).

Раздел Установка парсера сравнивает поддерживаемые парсеры.

Если у вас не установлен соответствующий синтаксический анализатор, Beautiful Soup проигнорируйте ваш запрос и выберите другой парсер. Прямо сейчас, единственный поддерживаемый синтаксический анализатор XML — lxml. Если у вас не установлен lxml, спросите для синтаксического анализатора XML вам его не даст, а запрос «lxml» не сработает либо.

Различия между синтаксическими анализаторами

Beautiful Soup представляет один и тот же интерфейс для ряда различных парсеры, но каждый парсер отличается. Различные парсеры будут создавать разные деревья синтаксического анализа из одного и того же документа. Самые большие различия находятся между парсерами HTML и парсерами XML. Вот краткий документ, проанализированный как HTML:

 BeautifulSoup("")
# 
 

Поскольку пустой тег не является допустимым HTML, синтаксический анализатор превращает его в Пара тегов .

Вот тот же документ, проанализированный как XML (для запуска требуется, чтобы вы установлен lxml). Обратите внимание, что пустой тег остается в покое, а что документ получает XML-декларацию, а не помещается в тег.:

 BeautifulSoup("", "xml")
# 
# <а>
 

Существуют также различия между парсерами HTML. Если вы дадите Красивое Будь то идеально сформированный HTML-документ, этих различий не будет. иметь значение. Один парсер будет быстрее другого, но все они дадут вам структура данных, которая выглядит точно так же, как исходный HTML документ.

Но если документ не идеально сформирован, разные парсеры будут дают разные результаты. Вот короткий недопустимый документ, проанализированный с помощью HTML-парсер lxml. Обратите внимание, что оборванный тег

просто проигнорировано:

 BeautifulSoup("
", "lxml")
# 
 

Вот тот же документ, проанализированный с помощью html5lib:

 BeautifulSoup("
", "html5lib")
# 

 

Вместо того, чтобы игнорировать висячий тег

, html5lib связывает его с открывающий тег

. Этот синтаксический анализатор также добавляет пустой тег к документ.

Вот тот же документ, проанализированный с помощью встроенного в Python HTML парсер:

 BeautifulSoup("
", "html.parser")
# <а>
 

Как и html5lib, этот синтаксический анализатор игнорирует закрывающий тег

. в отличие html5lib, этот синтаксический анализатор не пытается создать правильно сформированный HTML-код. документа, добавив тег. В отличие от lxml, даже не беспокоит чтобы добавить тег.

Поскольку документ «

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

Различия между парсерами могут повлиять на ваш скрипт. Если вы планируете при распространении вашего сценария среди других людей или запуске его на нескольких машины, следует указать парсер в BeautifulSoup конструктор. Это уменьшит вероятность того, что ваши пользователи проанализируют документ отличается от того, как вы его анализируете.

Любой документ HTML или XML написан в определенной кодировке, такой как ASCII или UTF-8. Но когда вы загрузите этот документ в Beautiful Soup, вы обнаружить, что он был преобразован в Unicode:

 разметка = " 
Sacr\xc3\xa9 bleu!
 "
суп = BeautifulSoup(разметка)
суп.h2
#  
Синий священный!
 
суп.h2.строка
# u'Sacr\xe9 bleu!'
 

Это не волшебство. (Было бы неплохо.) Beautiful Soup использует подбиблиотека под названием Unicode, Dammit для определения кодировки документа и преобразовать его в Unicode. Автоопределяемая кодировка доступна как атрибут .original_encoding объекта BeautifulSoup :

 soap.original_encoding
'утф-8'
 

Unicode, черт возьми, в большинстве случаев угадывает правильно, но иногда делает ошибки. Иногда угадывает правильно, но только после побайтовый поиск документа, который занимает очень много времени. Если если вы знаете кодировку документа заранее, вы можете избежать ошибок и задержек, передав его конструктору BeautifulSoup как from_encoding .

Вот документ, написанный в ISO-8859-8. Документ настолько короткий, что Unicode, Dammit не может его заблокировать и ошибочно идентифицирует как ИСО-8859-7:

 разметка = b" 
\xed\xe5\xec\xf9
 "
суп = BeautifulSoup(разметка)
суп.h2
 
νεμω
 
суп.original_encoding
«ИСО-8859-7»
 

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

 суп = BeautifulSoup(markup, from_encoding="iso-8859-8")
суп. h2
 
Совет
 
суп.original_encoding
'исо8859-8'
 

Если вы не знаете, какая кодировка правильная, но знаете, что Unicode, черт возьми, ты ошибаешься, ты можешь передать неправильные предположения в как exclude_encodings :

 суп = BeautifulSoup (разметка, exclude_encodings = ["ISO-8859-7"])
суп.h2
 
Совет
 
суп.original_encoding
'ВИНДОВ-1255'
 

Windows-1255 не на 100% верна, но эта кодировка совместима надмножество ISO-8859-8, так что это достаточно близко. ( exclude_encodings — новая функция в Beautiful Soup 4.4.0.)

В редких случаях (обычно когда документ UTF-8 содержит текст, написанный на совершенно другая кодировка), единственный способ получить Unicode может быть заменить некоторые символы специальным символом Unicode «ЗАМЕНЯЮЩИЙ СИМВОЛ» (U+FFFD, �). Если Unicode, Dammit нужно сделать это установит .contains_replacement_characters атрибут на True в объекте UnicodeDammit или BeautifulSoup . Этот позволяет узнать, что представление Unicode не является точным представление оригинала - некоторые данные были потеряны. Если документ содержит �, но .contains_replacement_characters равно False , вы узнаете, что � изначально был там (как и в этом абзац) и не заменяет отсутствующие данные.

Кодирование вывода

Когда вы выписываете документ из Beautiful Soup, вы получаете UTF-8 документ, даже если документ не был в UTF-8 с самого начала. Вот документ, написанный в кодировке Latin-1:

 markup = b'''
 
  <голова>
   
  
  <тело>
   
Sacr\xe9 bleu!
  
 
'''
суп = BeautifulSoup(разметка)
распечатать (суп.красиво())
# 
# <голова>
# 
# 
# <тело>
# <р>
# Сакре синий!
# 

# 
# 
 

Обратите внимание, что тег был переписан, чтобы отразить тот факт, что документ теперь в UTF-8.

Если вам не нужна UTF-8, вы можете передать кодировку в prettify() :

 print(soup.prettify("latin-1"))
# 
# <голова>
# 
# ...
 

Вы также можете вызвать encode() для объекта BeautifulSoup или любого элемент в супе, как если бы это была строка Python:

 суп.p.кодировать("латиница-1")
# '
Sacr\xe9 bleu!
'
суп.p.кодировать("utf-8")
# '
Sacr\xc3\xa9 bleu!
'
 

Любые символы, которые не могут быть представлены в выбранной вами кодировке, будут быть преобразованы в числовые ссылки на объекты XML. Вот документ который включает символ Юникода SNOWMAN:

 markup = u"\N{SNOWMAN}"
snowman_soup = BeautifulSoup(разметка)
тег = snowman_soup.b
 

Символ SNOWMAN может быть частью документа UTF-8 (выглядит как ☃), но для этого символа нет представления в ISO-Latin-1 или ASCII, поэтому он преобразуется в « ».731” для этих кодировок:

 print(tag. encode("utf-8"))
# ☃
напечатать tag.encode("latin-1")
# ☃
распечатать tag.encode("ascii")
# ☃
 

Unicode, Dammit

Вы можете использовать Unicode, Dammit без использования Beautiful Soup. это полезно всякий раз, когда у вас есть данные в неизвестной кодировке, и вы просто хотите, чтобы они стать Unicode:

 из bs4 импортировать UnicodeDammit
dammit = UnicodeDammit("Sacr\xc3\xa9 bleu!")
печать (черт возьми. unicode_markup)
# Сакре синий!
черт возьми.original_encoding
# 'утф-8'
 

Unicode, догадки Дэммита станут намного точнее, если вы установите библиотеки Python chardet или cchardet . Чем больше данных вы дай юникод, черт возьми, тем точнее угадаешь. Если у вас есть ваши собственные подозрения относительно кодировки, вы можете передать их в виде списка:

 dammit = UnicodeDammit("Sacr\xe9 bleu!", ["latin-1", "iso-8859-1"])
печать (черт возьми. unicode_markup)
# Сакре синий!
черт возьми. original_encoding
# 'латиница-1'
 

Unicode, у Dammit есть две особенности, которых нет у Beautiful Soup использовать.

Умные кавычки

Вы можете использовать Unicode, черт возьми, для преобразования умных кавычек Microsoft в HTML или XML entity:

 markup = b"
Я просто \x93love\x94 Microsoft Word\x92s умные кавычки
"
UnicodeDammit(разметка, ["windows-1252"], smart_quotes_to="html").unicode_markup
# u'
Я просто “люблю” Умные кавычки Microsoft Word
'
UnicodeDammit(разметка, ["windows-1252"], smart_quotes_to="xml").unicode_markup
# u'
Я просто “люблю” Microsoft Word’умные кавычки
'
 

Вы также можете конвертировать смарт-кавычки Microsoft в кавычки ASCII:

 UnicodeDammit(markup, ["windows-1252"], smart_quotes_to="ascii").unicode_markup
# u'
Я просто "люблю" умные кавычки Microsoft Word
'
 

Надеюсь, вы найдете эту функцию полезной, но Beautiful Soup — нет. используй это. Beautiful Soup предпочитает поведение по умолчанию, т. е. конвертировать смарт-кавычки Microsoft в символы Unicode вместе с все остальное:

 UnicodeDammit(разметка, ["windows-1252"]).unicode_markup
# u'
Я просто \u201clove\u2019 умные кавычки Microsoft Word
'
 

Несовместимые кодировки

Иногда документ в основном в UTF-8, но содержит Windows-1252 символы, такие как (опять же) умные кавычки Microsoft. Это может случиться когда веб-сайт включает данные из нескольких источников. Вы можете использовать UnicodeDammit.detwingle() , чтобы превратить такой документ в чистый УТФ-8. Вот простой пример:

 снеговики = (u"\N{СНЕГОВИК}" * 3)
quote = (u"\N{ЛЕВАЯ ДВОЙНАЯ КАВАТЫ}Мне нравятся снеговики!\N{ПРАВАЯ ДВОЙНАЯ КАВАТЫ}")
doc = snowmen.encode("utf8") + quote.encode("windows_1252")
 

В этом документе беспорядок. Снеговики в кодировке UTF-8, кавычки в Windows-1252. Вы можете отображать снеговиков или цитаты, но не оба:

 печать(док)
# ☃☃☃�Я люблю снеговиков!� 
печать (doc.decode («окна-1252»))
# ☃☃☃“Мне нравятся снеговики!”
 

При декодировании документа как UTF-8 возникает ошибка UnicodeDecodeError и расшифровка его как Windows-1252 дает вам тарабарщину. К счастью, UnicodeDammit.detwingle() преобразует строку в чистую UTF-8, что позволяет декодировать его в Unicode и отображать снеговиков и цитаты отмечает одновременно:

 new_doc = UnicodeDammit.detwingle(doc)
печать (new_doc.decode («utf8»))
# ☃☃☃«Мне нравятся снеговики!»
 

UnicodeDammit.detwingle() знает только, как обращаться с Windows-1252 встроенный в UTF-8 (или наоборот, я полагаю), но это самый общий случай.

Обратите внимание, что вы должны знать, что для вызова UnicodeDammit.detwingle() на вашем данные перед передачей их в BeautifulSoup или UnicodeDammit конструктор. Beautiful Soup предполагает, что документ имеет единственный кодировка, какой бы она ни была. Если вы передадите ему документ, который содержит и UTF-8, и Windows-1252, скорее всего, думает, что весь документ Windows-1252, и документ будет выглядеть так: ☃☃☃“Мне нравятся снеговики!” .

UnicodeDammit. detwingle() — новинка в Beautiful Soup 4.1.0.

Парсеры html.parser` и ``html5lib могут отслеживать, где в исходный документ, каждый тег был найден. Вы можете получить доступ к этому информация как Tag.sourceline (номер строки) и Tag.sourcepos (позиция начального тега в строке):

 markup = "Абзац 1
\n 
Абзац 2
"
суп = BeautifulSoup (разметка, 'html.parser')
для тега в soap.find_all('p'):
    print(tag.sourceline, tag.sourcepos, tag.string)
# (1, 0, u'Абзац 1')
# (2, 3, u'Параграф 2')
 

Обратите внимание, что два синтаксических анализатора имеют в виду немного разные вещи. sourceline и sourcepos . Для html.parser эти числа представляют положение начального знака «меньше». Для html5lib, эти числа представляют позицию последнего знака «больше»:

 суп = BeautifulSoup(markup, 'html5lib')
для тега в soap.find_all('p'):
    print(tag.sourceline, tag.sourcepos, tag. string)
# (2, 1, u'Параграф 1')
# (3, 7, u'Параграф 2')
 

Вы можете отключить эту функцию, передав store_line_numbers = Ложь` в конструктор BeautifulSoup :

 markup = "Абзац 1
\n 
Абзац 2
"
суп = BeautifulSoup (разметка, 'html.parser', store_line_numbers = False)
суп.п.источник
# Никто
 

Эта функция является новой в версии 4.8.1, и синтаксические анализаторы на основе lxml не поддерживаются. поддержите это.

Beautiful Soup сообщает, что два объекта NavigableString или Tag равны, если они представляют одну и ту же разметку HTML или XML. В этом Например, два тега считаются равными, даже если они в разных частях дерева объектов, потому что они оба выглядят как “пицца”:

 markup = "
Я хочу пиццу и еще пиццу!
"
суп = BeautifulSoup (разметка, 'html.parser')
first_b, second_b = суп.find_all('b')
напечатать first_b == second_b
# Истинный
напечатать first_b.previous_element == second_b. previous_element
# ЛОЖЬ
 

Если вы хотите увидеть, относятся ли две переменные к одному и тому же объект, используйте is :

 print first_b is second_b
# ЛОЖЬ
 

Вы можете использовать copy.copy() для создания копии любых Тег или NavigableString :

 импортировать копию
p_copy = copy.copy(суп.p)
распечатать p_copy
# 
Я хочу пиццу и еще пиццу!
 

Копия считается равной оригиналу, поскольку представляет собой та же разметка, что и у оригинала, но это не тот же объект:

 print soap.p == p_copy
# Истинный
напечатать суп.p — это p_copy
# ЛОЖЬ
 

Единственная реальная разница в том, что копия полностью отделена от оригинальное дерево объектов Beautiful Soup, как если бы экстракт() имел был вызван на нем:

 print p_copy.parent
# Никто
 

Это связано с тем, что два разных объекта Tag не могут занимать одно и то же место. пространство одновременно.

Допустим, вы хотите использовать Beautiful Soup для просмотра документа теги. Это пустая трата времени и памяти, чтобы разобрать весь документ и затем снова просмотрите его в поисках тегов . Было бы гораздо быстрее игнорировать все, что не было тегом в первую очередь. Класс SoupStrainer позволяет выбирать, какие части поступающего документ анализируется. Вы просто создаете SoupStrainer и передаете его в конструктор BeautifulSoup в качестве аргумента parse_only .

(Обратите внимание, что эта функция не будет работать, если вы используете парсер html5lib . Если вы используете html5lib, будет проанализирован весь документ, нет от того, что. Это потому, что html5lib постоянно перестраивает синтаксический анализ дерево, как оно работает, и если какая-то часть документа на самом деле не сделать это в дереве синтаксического анализа, он рухнет. Во избежание путаницы в примеры ниже я заставлю Beautiful Soup использовать Python встроенный парсер. )

SoupStrainer

Класс SoupStrainer принимает те же аргументы, что и типичный метод из Searching the tree: name, attrs, string и **kwargs. Здесь три объекта SoupStrainer :

 из bs4 import SoupStrainer
only_a_tags = Ситечко для супа ("а")
only_tags_with_id_link2 = Ситечко для супа(id="link2")
определение is_short_string (строка):
    возврат len (строка) < 10
only_short_strings = Ситечко для супа (string=is_short_string)
 

Я еще раз принесу документ «три сестры», и мы увидим, как выглядит документ, когда он будет проанализирован с помощью этих три SoupStrainer объекты:

 html_doc = """

<тело>
История Сони
Жили-были три сестрички; и их имена были
Элси,
Лейси и
Тилли;
и жили они на дне колодца.
...
"""
print(BeautifulSoup(html_doc, "html. parser", parse_only=only_a_tags).prettify())
# 
# Элси
# 
# 
# Лейси
# 
# 
# Тилли
# 
print(BeautifulSoup(html_doc, "html.parser", parse_only=only_tags_with_id_link2).prettify())
# 
# Лейси
# 
print(BeautifulSoup(html_doc, "html.parser", parse_only=only_short_strings).prettify())
# Элси
# ,
# Лейси
# а также
# Тилли
# ...
#
 

Вы также можете использовать SoupStrainer любым из описанных методов. в поиске дерева. Это, вероятно, не очень полезно, но я решил упомянуть об этом:

 суп = BeautifulSoup(html_doc)
суп.find_all (only_short_strings)
# [u'\n\n', u'\n\n', u'Элси', u',\n', u'Лейси', u' и\n', u'Тилли',
# и'\n\n', и'...', и'\n']
 

диагностика()

Если у вас возникли проблемы с пониманием того, что Beautiful Soup делает с документ, передать документ в диагностика() функция. (Новое в Beautiful Soup 4.2.0.) Beautiful Soup распечатает отчет, показывающий вы узнаете, как разные парсеры обрабатывают документ, и сообщите, если вы отсутствует синтаксический анализатор, который мог бы использовать Beautiful Soup:

 из диагностики импорта bs4.diagnose
с open("bad.html") как fp:
    данные = fp.read()
диагностировать (данные)
# Диагностика на Beautiful Soup 4.2.0
# Версия Python 2.7.3 (по умолчанию, 1 августа 2012 г., 05:16:07)
# Я заметил, что html5lib не установлен. Установка может помочь.
# Найден lxml версии 2.3.2.0
#
# Пытаемся разобрать ваши данные с помощью html.parser
# Вот что html.parser сделал с документом:
# ...
 

Просто взглянув на результат диагностики(), вы поймете, как решить проблему. проблема. Даже если нет, вы можете вставить вывод диагностировать () , когда просить помощи.

Ошибки при синтаксическом анализе документа

Существует два вида ошибок синтаксического анализа. Бывают сбои, где вы отправляете документ в Beautiful Soup, и он поднимает исключение, обычно HTMLParser. HTMLParseError . И есть неожиданное поведение, когда дерево синтаксического анализа Beautiful Soup выглядит много отличается от документа, использованного для его создания.

Почти ни одна из этих проблем не связана с Beautiful Суп. Это не потому, что Beautiful Soup удивительно хорошо написана. часть программного обеспечения. Это потому, что Beautiful Soup не содержит код разбора. Вместо этого он полагается на внешние парсеры. Если один парсер не работает с определенным документом, лучшее решение — попробовать другой парсер. См. Установка парсера для получения подробной информации и парсера. сравнение.

Наиболее распространенными ошибками синтаксического анализа являются HTMLParser.HTMLParseError: неправильный начальный тег и HTMLParser.HTMLParseError: плохой конец тег . Они оба генерируются встроенным в Python парсером HTML. библиотека, и решение состоит в том, чтобы установить lxml или html5lib.

Самый распространенный тип неожиданного поведения — невозможность найти тег, который, как вы знаете, находится в документе. Вы видели, как он входит, но find_all() возвращает [] или find() возвращает None . Это еще одна распространенная проблема со встроенным в Python парсером HTML, который иногда пропускает теги, которые не понимает. Опять же, решение состоит в том, чтобы установите lxml или html5lib.

Проблемы с несоответствием версий

• SyntaxError: Неверный синтаксис (в строке ROOT_TAG_NAME = u'[document]' ): вызван запуском Python 2 версии Beautiful Soup под Python 3, без конвертации кода.
• ImportError: нет модуля с именем HTMLParser — вызвано запуском Версия Beautiful Soup для Python 2 под Python 3.
• ImportError: нет модуля с именем html.parser — вызвано запуском Версия Beautiful Soup для Python 3 под Python 2.
• ImportError: нет модуля с именем BeautifulSoup — вызвано запуском Код Beautiful Soup 3 в системе без BS3 установлены. Или, написав код Beautiful Soup 4, не зная, что имя пакета изменилось на bs4 .
• ImportError: нет модуля с именем bs4 — вызвано запуском Beautiful Код Soup 4 в системе, в которой не установлена ​​BS4.

Анализ XML

По умолчанию Beautiful Soup анализирует документы как HTML. Чтобы разобрать документа в формате XML, передайте «xml» в качестве второго аргумента BeautifulSoup конструктор:

 суп = BeautifulSoup(разметка, "xml")
 

Вам необходимо установить lxml.

Другие проблемы с парсером

• Если ваш скрипт работает на одном компьютере, но не работает на другом, или на одном виртуальной среде, но не другой, или вне виртуальной окружающей среде, но не внутри, вероятно, потому, что два средам доступны разные библиотеки парсеров. Например, возможно, вы разработали скрипт на компьютере с lxml установлен, а затем попытался запустить его на компьютере, на котором html5lib установлен. См. Различия между парсерами, почему это имеет значение, и устраните проблему, упомянув конкретную библиотеку синтаксического анализатора в Конструктор BeautifulSoup .
• Поскольку теги и атрибуты HTML нечувствительны к регистру, все три HTML-тега синтаксические анализаторы преобразуют имена тегов и атрибутов в нижний регистр. Это разметка преобразуется в . Если ты хочешь сохранять теги и атрибуты в смешанном или верхнем регистре, вам нужно будет разобрать документ как XML.

Разное

• UnicodeEncodeError: кодек 'charmap' не может кодировать символ u'\xfoo' в такте позиции (или почти любой другой UnicodeEncodeError ) — это не проблема с Beautiful Soup. Эта проблема проявляется в двух основных ситуациях. Во-первых, когда вы пытаетесь напечатать символ Unicode, который ваша консоль не знает, как отображать. (См. эту страницу в вики Python для справки.) Во-вторых, когда вы пишете в файл и передаете символ Unicode, который не поддерживается вашей кодировкой по умолчанию. В этом случае самый простой решение состоит в том, чтобы явно закодировать строку Unicode в UTF-8 с помощью u.encode("utf8") .
• KeyError: [attr] — вызвано доступом к тегу ['attr'] , когда рассматриваемый тег не определяет атрибут attr . Большинство распространенными ошибками являются KeyError: 'href' и KeyError: 'класс' . Используйте tag.get('attr') , если вы не уверены, что attr определено так же, как если бы вы использовали словарь Python.
• AttributeError: объект «ResultSet» не имеет атрибута «foo» — это обычно происходит потому, что вы ожидали find_all() для возврата один тег или строка. Но find_all() возвращает _list_ тегов и строки — объект ResultSet . Вам нужно перебрать list и посмотрите на .foo каждого из них. Или, если вы действительно только хотите один результат, вам нужно использовать find() вместо найти_все() .
• AttributeError: объект «NoneType» не имеет атрибута «foo» — это обычно происходит потому, что вы вызвали find() , а затем попытались получить доступ к .foo` атрибут результата. Но в вашем случае, find() ничего не нашел, поэтому вернул None вместо возвращает тег или строку. Вы должны выяснить, почему ваш find() вызов ничего не возвращает.

Повышение производительности

Beautiful Soup никогда не будет таким же быстрым, как парсеры, на которых он установлен из. Если время отклика критично, если вы платите за компьютерное время по часам, или если есть какая-либо другая причина, по которой компьютерное время больше ценнее, чем время программиста, вы должны забыть о Beautiful Soup и работать непосредственно поверх lxml.

Тем не менее, есть вещи, которые вы можете сделать, чтобы ускорить Beautiful Soup. Если вы не используете lxml в качестве базового синтаксического анализатора, мой совет: Начало. Beautiful Soup разбирает документы значительно быстрее при использовании lxml, чем при использовании html.parser или html5lib.

Вы можете значительно ускорить обнаружение кодировки, установив библиотека ccardet.

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

Новые переводы документации Beautiful Soup значительно оценил. Переводы должны быть лицензированы по лицензии MIT, точно так же, как Beautiful Soup и его англоязычная документация.

Есть два способа добавить перевод в основную кодовую базу. и на сайт Beautiful Soup:

1. Создайте ветку репозитория Beautiful Soup, добавьте свой перевод, и предложить слияние с основной веткой, то же самое как вы поступили бы с предлагаемым изменением исходного кода.
2. Отправьте сообщение в дискуссионную группу Beautiful Soup со ссылкой на свой перевод или прикрепите свой перевод к сообщению.

В качестве образца используйте перевод на китайский или бразильский португальский язык. В в частности, переведите исходный файл doc/source/index.rst , а не HTML-версия документации. Это делает это возможность публиковать документацию в различных форматах, не просто HTML.

Beautiful Soup 3 — это предыдущая серия выпусков, которая больше не активно развивается. В настоящее время он поставляется со всеми основными версиями Linux. раздачи:

$ apt-get install python-beautifulsoup

It's also published through PyPi as BeautifulSoup .:

$ easy_install BeautifulSoup

$ pip install BeautifulSoup

You can also download a tarball of Beautiful Суп 3.2.0.

Если вы запустили easy_install, beautifulsoup или easy_install BeautifulSoup , но ваш код не работает, вы установили Beautiful Суп 3 по ошибке. Вам нужно запустить easy_install beautifulsoup4 .

Документация по Beautiful Soup 3 находится в онлайн-архиве.

Перенос кода на BS4

Большая часть кода, написанного для Beautiful Soup 3, будет работать и для Beautiful Суп 4 с одним простым изменением. Все, что вам нужно сделать, это изменить имя пакета с BeautifulSoup на bs4 . Итак:

 из BeautifulSoup импортирует BeautifulSoup
 

становится следующим:

 из импорта bs4 BeautifulSoup
 

• Если вы получаете ImportError «Нет модуля с именем BeautifulSoup», ваш проблема в том, что вы пытаетесь запустить код Beautiful Soup 3, но вы установлен только Beautiful Soup 4.
• Если вы получаете ImportError «Нет модуля с именем bs4», ваша проблема заключается в том, что вы пытаетесь запустить код Beautiful Soup 4, но вы только установить Beautiful Soup 3.

Хотя BS4 в основном обратно совместима с BS3, большинство его методы устарели и получили новые имена для соответствия PEP 8. Есть множество других переименовывает и изменяет, а некоторые из них нарушают обратную совместимость.

Вот что вам нужно знать, чтобы преобразовать код и привычки BS3 в BS4:

Вам нужен синтаксический анализатор

Beautiful Soup 3 использовал модуль SGMLParser Python, устарел и удален в Python 3.0. Красивый суп 4 использования html.parser по умолчанию, но вы можете подключить lxml или html5lib и используйте это вместо этого. См. Установка парсера для сравнения.

Поскольку html.parser — это не тот же парсер, что и SGMLParser , вы может обнаружить, что Beautiful Soup 4 дает вам дерево синтаксического анализа, отличное от Beautiful Soup 3 за ту же разметку. Если поменять местами html.parser для lxml или html5lib вы можете обнаружить, что дерево синтаксического анализа еще не изменилось опять таки. Если это произойдет, вам нужно будет обновить код парсинга до разобраться с новым деревом.

Имена методов

• renderContents -> encode_contents
• replaceWith -> replace_with
• replaceWithChildren -> развернуть
• найти все -> найти все
• findAllNext -> find_all_next
• findAllPrevious -> find_all_previous
• findNext -> find_next
• findNextSibling -> find_next_sibling
• findNextSiblings -> find_next_siblings
• findParent -> find_parent
• найти родителей -> найти_родителей
• findPrevious -> find_previous
• findPreviousSibling -> find_previous_sibling
• findPreviousSiblings -> find_previous_siblings
• getText -> get_text
• nextSibling -> next_sibling
• предыдущий одноуровневый элемент -> предыдущая одноуровневая версия

Некоторые аргументы конструктора Beautiful Soup были переименованы для те же причины:

• BeautifulSoup(parseOnlyThese=. ..) -> BeautifulSoup(parse_only=...)
• BeautifulSoup(fromEncoding=...) -> BeautifulSoup(from_encoding=...)

Я переименовал один метод для совместимости с Python 3:

• Tag.has_key() -> Tag.has_attr()

Я переименовал один атрибут, чтобы использовать более точную терминологию:

• Tag.isSelfClosing -> Tag.is_empty_element

Я переименовал три атрибута, чтобы не использовать слова, имеющие особое значение. значение для Python. В отличие от других, эти изменения не в обратном порядке. совместимый. Если вы использовали эти атрибуты в BS3, ваш код сломается на BS4, пока вы их не измените.

• UnicodeDammit.unicode -> UnicodeDammit.unicode_markup
• Тег.следующий -> Тег.следующий_элемент
• Тег.предыдущий -> Тег. предыдущий_элемент

Генераторы

Я дал генераторам имена, совместимые с PEP 8, и преобразовал их в свойства:

• childGenerator() -> детей
• nextGenerator() -> next_elements
• следующийSiblingGenerator() -> соседние_братья
• предыдущийГенератор() -> предыдущие_элементы
• предыдущаяSiblingGenerator() -> предыдущая_siblings
• recursiveChildGenerator() -> потомков
• parentGenerator() -> родителей

Итак, вместо этого:

 для родителя в tag.parentGenerator():
    ...
 

Вы можете написать это:

 для родителя в tag.parents:
    ...
 

(Но старый код все равно будет работать.)

Некоторые из генераторов давали None после того, как они были выполнены, и тогда остановись. Это была ошибка. Теперь генераторы просто останавливаются.

Есть два новых генератора, .strings и .stripped_strings. .strings дает Объекты NavigableString и .stripped_strings дают Python строки, в которых были удалены пробелы.

XML

Больше нет Класс BeautifulStoneSoup для разбора XML. К анализировать XML, который вы передаете в «xml» в качестве второго аргумента Конструктор BeautifulSoup . По той же причине Конструктор BeautifulSoup больше не распознает isHTML аргумент.

Beautiful Soup обрабатывает теги XML с пустыми элементами. улучшенный. Раньше, когда вы анализировали XML, вам нужно было явно указать какие теги считались тегами пустых элементов. selfClosingTags аргумент конструктора больше не распознается. Вместо, Beautiful Soup считает любой пустой тег тегом пустого элемента. Если вы добавляете дочерний элемент в тег пустого элемента, он перестает быть тег пустого элемента.

Объекты

Входящий объект HTML или XML всегда преобразуется в соответствующий символ Юникода. В Beautiful Soup 3 было несколько перекрывающиеся способы работы с сущностями, которые были удаленный. Конструктор BeautifulSoup больше не распознает smartQuotesTo или convertEntities аргументов. (Юникод, Черт побери, все еще есть smart_quotes_to , но по умолчанию теперь умные кавычки в Unicode.) Константы HTML_ENTITIES , XML_ENTITIES и XHTML_ENTITIES были удалены, так как они настроить функцию (преобразование некоторых, но не всех объектов в символы Unicode), которого больше не существует.

Если вы хотите превратить символы Unicode обратно в объекты HTML на вывод, а не превращать их в символы UTF-8, вам нужно используйте средство форматирования вывода.

Разное

Строка тегов теперь работает рекурсивно. Если тег А содержит один тег B и ничего больше, то A. string совпадает с B.строка. (Ранее это было None.)

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

Если вы передадите один из методов find* , обе строки и специфический для тега аргумент, такой как имя, Beautiful Soup будет поиск тегов, которые соответствуют вашим критериям тегов и чьи Tag.string соответствует вашему значению для строки. , а не сами найдут строки. Ранее, Beautiful Soup игнорировал аргументы, относящиеся к тегам, и искал струны.

Конструктор BeautifulSoup больше не распознает markupMassage аргумент. Теперь парсер отвечает за корректно обрабатывать разметку.

Редко используемые альтернативные классы синтаксического анализатора, такие как ICantBelieveItsBeautifulSoup и BeautifulSOAP были удаленный. Теперь синтаксический анализатор решает, как обрабатывать неоднозначные наценка.

Метод prettify() теперь возвращает строку Unicode, а не строку байтов.

Requests и BeautifulSoup — LearnDataSci

Автор: Brendan Martin
Основатель LearnDataSci

Первая часть этой серии посвящена запросу и обработке HTML с использованием двух самых популярных библиотек Python для парсинга веб-страниц: Requests и BeautifulSoup

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

Записная книжка для этого руководства — GitHub

В первой части серии мы будем получать данные о предвзятости медиа и сосредоточимся только на локальной работе на вашем компьютере, но если вы хотите узнать, как развернуть что-то подобное в рабочей среде, не стесняйтесь оставлять комментарии и дайте мне знать.

Вы уже должны знать:

• Основы Python — списки, словари, функции, циклы — изучайте на Coursera
• Базовый HTML

Вы изучите:

• Запрос веб-страниц
• Анализ HTML
• Сохранение и загрузка очищенных данных
• Скрейпинг нескольких страниц подряд

просто человек с браузером, вы не можете причинить большого вреда. С помощью скрипта Python, который может выполнять тысячи запросов в секунду при неправильном кодировании, вы можете в конечном итоге дорого обойтись владельцу веб-сайта и, возможно, вывести его сайт из строя (см. Атака типа «отказ в обслуживании» (DoS)).

Имея это в виду, мы хотим быть очень осторожными с тем, как мы программируем парсеры, чтобы избежать сбоев сайтов и причинения ущерба. Каждый раз, когда мы очищаем веб-сайт, мы пытаемся сделать только один запрос на страницу . Мы не хотим делать запрос каждый раз, когда наш синтаксический анализ или другая логика не работают, поэтому нам нужно выполнять синтаксический анализ только после того, как мы сохранили страницу локально.

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

После того, как мы сделали запрос и получили содержимое веб-страницы, мы можем сохранить это содержимое локально с помощью функции Python open() . Для этого нам нужно использовать аргумент wb , что означает «записать байты». Это позволяет избежать проблем с кодировкой при сохранении.

Ниже приведена функция, которая является оберткой для функции open() , чтобы в дальнейшем уменьшить объем повторяющегося кода:

 def save_html(html, path):
    с открытым (путь, 'wb') как f:
        f.написать (html)
        
        
save_html(r. content, 'google_com') 

Предположим, мы захватили HTML-код с google.com в html , что вы увидите позже, как это сделать. После запуска этой функции у нас теперь будет файл в том же каталоге, что и эта записная книжка, с именем google_com , который содержит HTML.

Чтобы получить наш сохраненный файл, мы создадим еще одну функцию, чтобы обернуть чтение HTML обратно в html . В этом случае нам нужно использовать rb для «чтения байтов».

 по умолчанию open_html (путь):
    с открытым (путь, 'rb') как f:
        вернуть f.read()
    
    
html = open_html('google_ru') 

Функция open делает прямо противоположное: читает HTML из google_com . Если наш скрипт дает сбой, блокнот закрывается, компьютер выключается и т. д., нам больше не нужно снова запрашивать Google, что снижает наше влияние на их серверы. Хотя для Google это не имеет большого значения, поскольку у них много ресурсов, небольшие сайты с меньшими серверами выиграют от этого.

Я сохраняю почти каждую страницу и анализирую ее позже при парсинге из соображений безопасности.

Каждый сайт обычно имеет robots.txt в корне своего домена. Здесь владелец веб-сайта прямо указывает, что ботам разрешено делать на его сайте. Просто зайдите на example.com/robots.txt, и вы должны найти текстовый файл, который выглядит примерно так:

 User-agent: *
Задержка сканирования: 10
Разрешить: /страницы/
Запретить: /скрипты/
# more stuff 

Поле User-agent — это имя бота, а следующие правила — это то, чему бот должен следовать. В файле robots.txt может быть много пользовательских агентов с разными правилами. Обычных ботов googlebot , bingbot и applebot , о назначении и происхождении которых вы, вероятно, догадываетесь.

На самом деле нам не нужно предоставлять User-agent при парсинге, поэтому User-agent: * — это то, чему мы будем следовать. * означает, что следующие правила применяются ко всем ботам (это мы).

Crawl-delay сообщает нам количество секунд ожидания перед запросами, поэтому в этом примере нам нужно подождать 10 секунд, прежде чем делать новый запрос.

Разрешить дает нам определенные URL-адреса, которые мы можем разрешить запрашивать с ботами, и наоборот для Запретить . В этом примере нам разрешено запрашивать что угодно в подпапке /pages/ , что означает все, что начинается с example.com/pages/ . С другой стороны, нам запрещено очищать что-либо из подпапки /scripts/.

Много раз вы будете видеть * рядом с Разрешить или Запретить, что означает, что вам либо разрешено, либо запрещено очищать все на сайте.

Иногда будут запрещены все страницы, за которыми следуют разрешенные страницы, например:

 Запретить: *
Разрешить: /pages/ 

Это означает, что вам не разрешено очищать что-либо кроме подпапки /pages/ . По сути, вы просто хотите прочитать правила в том порядке, в котором следующее правило переопределяет предыдущее правило.

Этот проект в основном будет выполняться через блокнот Jupyter, который предназначен для учебных целей и не является обычным способом программирования парсеров. После того, как мы покажем вам фрагменты, мы объединим их в скрипт Python, который можно запустить из командной строки или выбранной вами IDE.

С библиотекой запросов Python ( запросов на установку pip ) мы получаем веб-страницу, используя get() в URL-адресе. Ответ r содержит много вещей, но использование r.content даст нам HTML. Получив HTML-код, мы можем разобрать его на предмет данных, которые нам интересны для анализа.

Есть интересный веб-сайт под названием AllSides , на котором есть таблица рейтинга предвзятости СМИ, где пользователи могут согласиться или не согласиться с рейтингом.

Media Bias Ratings на AllSides

Поскольку в их файле robots. txt нет ничего, что запрещало бы нам очищать этот раздел сайта, я полагаю, что можно продолжить и извлечь эти данные для нашего проекта. Давайте запросим эту первую страницу:

 запросов на импорт
url = 'https://www.allsides.com/media-bias/media-bias-ratings'
г = запросы.get(url)
print(r.content[:100]) 

Out:

 b'\n\n  добавлены мной):
 
 Итак, чтобы получить каждую строку, мы просто выбираем все 
 внутри  :
 rows = суп.  
 (  t able  r  ow) теги, которые являются дочерними тегами   body. Если бы на этой странице было больше одной таблицы, нам пришлось бы сделать более конкретный селектор, но поскольку это единственная таблица, все готово. 
 Теперь у нас есть список строк таблицы HTML, каждая из которых содержит четыре ячейки: 
 
 Название источника новостей и ссылка 
 
 Данные предвзятости 
 
 Кнопки соглашения 
 
 Данные отзывов сообщества 
 
 один. 
 Посмотрим на первую ячейку: 
 
 Имя выхода (  ABC News  ) представляет собой текст тега привязки, вложенного в 
 Мы также могли бы использовать атрибут  alt , но ссылка выглядит проще. Возьмем его:
bias = row. select_one('.views-field-field-bias-image a')['href']
смещение = смещение.split('/')[-1]
print(bias) 
 left-center 
 Здесь мы выбрали тег привязки, используя имя класса и тег вместе:  .views-field-field-bias-image  — это класс 
 Нужные нам числа расположены в двух элементах  span  в последнем  div  . Оба элемента  span  имеют классы, уникальные в этой ячейке, поэтому мы можем использовать их для выбора:
 accept = row.select_one('.agree').text
согласен = int (согласен)
не согласен = row.select_one('.disagree').текст
не согласен = int (не согласен)
accept_ratio = согласен / не согласен
print(f"Согласен: {согласен}, Не согласен: {не согласен}, Отношение {agree_ratio:.2f}") 
 Исход:
 Согласен: 8411, Не согласен: 6662, Отношение 1,26 
 Использование  . text  вернет строку, поэтому нам нужно преобразовать их в целые числа, чтобы вычислить отношение.
  Примечание:  Если вы никогда не видели такой способ форматирования операторов печати в Python,  f  в начале позволяет нам вставлять переменные прямо в строку с помощью фигурных скобок.  :.2f  — это способ форматирования чисел с плавающей запятой для отображения только двух знаков после запятой.
 Если вы посмотрите на страницу в своем браузере, вы заметите, что они говорят, насколько сообщество согласно, используя «в некоторой степени согласен», «полностью согласен» и т. д., так как же мы это получим? Если мы попытаемся выбрать его:
 print(row.select_one('.community-feedback-rating-page')) 
 Out:
 None 
 Отображается как None, потому что этот элемент отображается с помощью Javascript и  запросов  не может получить HTML визуализируется с помощью Javascript. Мы рассмотрим, как получить данные, отображаемые с помощью JS, в следующей статье, но, поскольку это единственная часть информации, которая отображается таким образом, мы можем вручную воссоздать текст.
 Чтобы найти файлы JS, которые они используют, просто нажмите CTRL+F для «.js» в исходном коде страницы и откройте файлы в новой вкладке, чтобы найти эту логику.
 Оказалось логика находится в одиннадцатом JS файле и у них есть функция которая вычисляет текст и цвет с такими параметрами:

    

        
    
    

        
 
            
 
                
            
            
 
                
            
            
 
                
            
            
 
                
            
        
 
        
    
 
 
 
 
      

    Новости ABC
 
  тег, который представляет собой ячейку — или  t  способный  d  тег ata.
 Получить имя выхода довольно просто: просто получите первую строку в  rows  и запустите  select_one  для этого объекта:
 row = rows[0]
имя = row. select_one('.source-title').text.strip()
print(name) 
 Out:
 ABC News 
 Единственным классом, который нам нужно было использовать в этом случае, был  .source-title , так как  .views-field  выглядит просто классом, который задается для стилизации каждой строки и не обеспечивает никакой уникальности.
 Обратите внимание, что нам не нужно беспокоиться о выборе тега привязки  a , содержащего текст. Когда мы используем  .text , он получает весь текст в этом элементе, и поскольку «ABC News» — единственный текст, это все, что нам нужно сделать. Имейте в виду, что использование  select  или  select_one  даст вам весь элемент с включенными тегами, поэтому нам нужно  .text , чтобы дать нам текст между тегами.
  .strip()  обеспечивает удаление всех пробелов вокруг имени. Многие веб-сайты используют пробелы для визуального заполнения текста внутри элементов, поэтому использование  strip()  всегда хорошая идея.
 Вы заметите, что мы можем запускать методы BeautifulSoup сразу в одной из строк. Это потому, что строки становятся их собственными объектами BeautifulSoup, когда мы делаем выбор из другого объекта BeautifulSoup. С другой стороны, наша переменная  name  больше не является объектом BeautifulSoup, потому что мы назвали  .text  .
 Нам также нужна ссылка на страницу этого источника новостей на AllSides. Если мы вернемся к HTML, то увидим, что в этом случае мы  do  хотите выбрать якорь, чтобы получить  href , содержащий ссылку, поэтому давайте сделаем это:
 allsides_page = row.select_one('.source-title a')['href']
allsides_page = 'https://www.allsides.com' + allsides_page
print(allsides_page) 
 Исходящий:
 https://www.allsides.com/news-source/abc-news-media-bias 
 Это относительный путь в HTML, поэтому мы добавляем URL-адрес сайта, чтобы сделать это ссылка, которую мы можем запросить позже.
 Получение ссылки немного отличается от простого выбора элемента. Нам нужно было получить доступ к  атрибут  (  href  ) элемента, который делается с помощью квадратных скобок, подобно тому, как мы получили бы доступ к словарю Python. То же самое будет и для других атрибутов элементов, таких как  src  в изображениях и видео.
 Мы видим, что рейтинг отображается в виде изображения, так как же нам получить рейтинг словами? Глядя на HTML, обратите внимание, что ссылка, окружающая изображение, содержит нужный нам текст:
 

    
        
    
 
  и    для якоря, вложенного внутрь.
 После этого извлекаем  href , как и раньше, но теперь нам нужна только последняя часть URL-адреса для имени уклона, поэтому мы разделяем косые черты и получаем последний элемент этого разделения (  left-center  ).
 Последнее, что нужно очистить, — это соотношение «согласен/не согласен» из области отзывов сообщества. HTML этой ячейки довольно запутан из-за стиля, но вот основная структура:
 

    <дел>
        <дел>
             <дел>
                <ул>
                    

                         ..">согласен
                    
                    

                        не согласен
                    
                
            
            <дел>
                8241/6568
            
        
    
 
 908$ratio >$ratio $ 1,5 <Коэффициент \ LEQ 2 $ 9 9084 $
 Диапазон
 Согласие
 Абсолютно соглашается
 $ 2 <Соотношение \ LEQ 3 $
 Тщательно соглашается
 $ 1,5 <Коэффициент \ LEQ 2 $
 соглашается
3
 $.0854
 somewhat agrees
 $ratio = 1$
 neutral
 $0. 67 < ratio < 1$
 somewhat disgrees
 $0.5 < ratio \leq 0.67$
 disgrees
 $0.33 < ratio \leq 0.5$
 полностью не согласен
 $ratio \leq 0.33$
 абсолютно не согласен
 Давайте создадим функцию, которая повторяет эту логику:
 по определению get_agreeance_text (соотношение):
    если отношение > 3: вернуть "абсолютно согласен"
    elif 2 < ratio <= 3: вернуть «полностью согласен»
    elif 1.5 < ratio <= 2: возврат «согласен»
    elif 1 < ratio <= 1.5: вернуть "отчасти согласен"
    elif ratio == 1: вернуть «нейтральный»
    elif 0.67 < ratio < 1: вернуть "несколько не согласен"
    elif 0.5 < ratio <= 0.67: вернуть "не согласен"
    elif 0,33 < ratio <= 0,5: вернуть «категорически не согласен»
    elif ratio <= 0,33: возврат «абсолютно не согласен»
    иначе: вернуть None
    
печать (get_agreeance_text (2. 5)) 
 Out:
 полностью согласен 
 Теперь, когда у нас есть общая логика для одной строки и мы можем сгенерировать текст соглашения, давайте создадим цикл, который будет получать данные из каждой строки на первой странице:
 data= []
для строки в строке:
    д = дикт()
    
    d['name'] = row.select_one('.source-title').text.strip()
    d['allsides_page'] = 'https://www.allsides.com' + row.select_one('.source-title a')['href']
    d['bias'] = row.select_one('.views-field-field-bias-image a')['href'].split('/')[-1]
    d['согласен'] = int(row.select_one('.согласен').текст)
    d['не согласен'] = int(row.select_one('.не согласен').текст)
    d['соотношение_согласия'] = d['согласен'] / d['не согласен']
    d['текст_согласия'] = get_text_agreeance(d['коэффициент_согласия'])
    
    data.append(d) 
 В цикле мы можем объединить любые многошаговые извлечения в одно, чтобы создать значения за наименьшее количество шагов.
 Наш список данных   теперь содержит словарь, содержащий ключевую информацию для каждой строки.
 print(data[0]) 
 Out:
 {'name': 'ABC News', 'allsides_page': 'https://www.allsides.com/news-source/abc-news-media- предвзятость», «предвзятость»: «лево-центр», «согласен»: 8411, «не согласен»: 6662, «соотношение согласия»: 1.2625337736415492, «согласие_текст»: «отчасти согласен»} 
 Имейте в виду, что  это еще только первая страница . На момент написания этой статьи список на AllSides состоит из трех страниц, поэтому нам нужно изменить этот цикл, чтобы получить другие страницы.
 Обратите внимание, что URL-адреса для каждой страницы следуют шаблону. Первая страница не имеет параметров в URL-адресе, но следующие страницы имеют; в частности, они прикрепляют  ?page=#  к URL-адресу, где '#' - это номер страницы.
 На данный момент самый простой способ получить все страницы — просто вручную составить список из этих трех страниц и просмотреть их. Если бы мы работали над проектом с тысячами страниц, мы могли бы создать более автоматизированный способ создания/поиска следующих URL-адресов, но пока это работает.
 страниц = [
    'https://www.allsides.com/media-bias/media-bias-ratings',
    'https://www.allsides.com/media-bias/media-bias-ratings?page=1',
    'https://www.allsides.com/media-bias/media-bias-ratings?page=2'
] 
 В соответствии с  robots.txt  AllSides нам нужно убедиться, что мы ждем десять секунд перед каждым запросом.
 Наш цикл будет:
 запрашивать страницу
 анализировать страницу
 ждать десять секунд
 повторять для следующей страницы.
 Помните, мы уже тестировали вышеописанный синтаксический анализ на странице, которая была кэширована локально, поэтому мы знаем, что она работает. Вы должны убедиться, что сделали это  до того, как  создадите цикл, который выполняет запросы, чтобы предотвратить повторный цикл, если вы забыли что-то проанализировать.
 Объединив все шаги, которые мы сделали до этого момента, и добавив цикл по страницам, вот как это выглядит:
 from time import sleep
данные = []
для страницы на страницах:
    г = запросы.получить(страница)
    суп = BeautifulSoup(r.content, 'html.parser')
    
    строки = суп.выбрать('tbody tr')
    для строки в строке:
        д = дикт()
        d['name'] = row.select_one('.source-title').text.strip()
        d['allsides_page'] = 'https://www.allsides.com' + row.select_one('.source-title a')['href']
        d['bias'] = row.select_one('.views-field-field-bias-image a')['href'].split('/')[-1]
        d['согласен'] = int(row.select_one('.согласен').текст)
        d['не согласен'] = int(row.select_one('.не согласен').текст)
        d['соотношение_согласия'] = d['согласен'] / d['не согласен']
        d['текст_согласия'] = get_text_agreeance(d['коэффициент_согласия'])
        data. append(d)
    
    спать(10) 
 Теперь у нас есть список словарей для каждой строки на всех трех страницах.
 В довершение всего, мы хотим получить настоящий URL-адрес источника новостей, а не только ссылку на их присутствие на AllSides. Для этого нам нужно будет зайти на страницу AllSides и найти ссылку.
 Если мы перейдем на страницу ABC News, там будет ряд внешних ссылок на Facebook, Twitter, Wikipedia и веб-сайт ABC News. HTML для этих разделов выглядит так:
 

    <дел>
        
            Фейсбук
        
        
            
            Твиттер
        
        
            
            Википедия
        
         go.com/">
            Новости ABC
        
        
            
            Улучшить эту страницу
        
    
 
 Обратите внимание, что тег привязки (    ), содержащий ссылку на ABC News, имеет класс «www». Довольно легко получить с тем, что мы уже узнали:
 веб-сайт = суп.выберите_one('.www')['href'] 
 Итак, давайте сделаем еще один цикл, чтобы запросить страницу AllSides и получить ссылки для каждого источника новостей. К сожалению, на некоторых страницах в этой серой полосе нет ссылки на источник новостей, что наводит на мысль:  всегда учитывает элементы, которые случайно не существуют  .
 До сих пор мы предполагали, что элементы существуют в таблицах, которые мы очищали, но всегда полезно программировать парсеры таким образом, чтобы они не ломались, когда элемент отсутствует.
 Использование  select_one  или  select  всегда будет возвращать None или пустой список, если ничего не найдено, поэтому в этом цикле мы проверим, нашли ли мы элемент веб-сайта или нет, чтобы он не выдавал исключение при попытке получить доступ к атрибуту  href .
 Наконец, поскольку имеется 265 страниц источника новостей и время ожидания между страницами составляет 10 секунд, это займет ~44 минуты. Вместо того, чтобы слепо не знать о нашем прогрессе, давайте использовать  tqdm  library (  pip install tqdm  ), чтобы дать нам хороший индикатор выполнения:
 from copy import deepcopy
из tqdm импортировать tqdm_notebook
для d в tqdm_notebook (данные):
    r = запросы.get(d['allsides_page'])
    суп = BeautifulSoup(r.content, 'html.parser')
    
    пытаться:
        веб-сайт = суп.select_one('.www')['href']
        d['веб-сайт'] = веб-сайт
    кроме TypeError:
        проходить
    
    sleep(10) 
  tqdm  сначала немного странно, но по существу  tqdm_notebook  просто оборачивает наш список данных, чтобы создать индикатор выполнения. Мы по-прежнему можем получить доступ к каждому словарю,  d , как обычно. Обратите внимание, что  tqdm_notebook  предназначен только для ноутбуков Jupyter. В обычных редакторах вы просто импортируете  tqdm из tqdm  и вместо этого используете  tqdm .
 Итак, что мы имеем сейчас? На данный момент  данные  представляют собой список словарей, каждый из которых содержит все данные из таблиц, а также сайты со страницы каждого отдельного источника новостей на AllSides.
 Первое, что нам сейчас нужно сделать, это сохранить эти данные в файл, чтобы нам не приходилось делать эти запросы снова. Мы будем хранить данные в формате JSON, так как они уже в таком виде:
 import json
с open('allsides.json', 'w') как f:
    json.dump(data, f) 
 Чтобы загрузить его обратно, когда он вам понадобится:
 с open('allsides. json', 'r') как f:
    data = json.load(f) 
 Если вы не знакомы с JSON, просто быстро откройте  allsides.json  в редакторе и посмотрите, как это выглядит. Это должно выглядеть почти так же, как  data  выглядит так, если мы напечатаем его в Python: список словарей.
 Прежде чем закончить эту статью, я думаю, было бы полезно посмотреть, что интересного в этих данных, которые мы только что получили. Итак, давайте ответим на пару вопросов.
  С какими оценками торговых точек сообщество    полностью согласно   ? 
 Чтобы найти, где сообщество абсолютно согласно, мы можем сделать простое понимание списка, которое проверяет каждые  dict  для текста соглашения, который мы хотим:
 abs_agree = [d вместо d в данных if d['agreeance_text'] == 'абсолютно согласен']
print(f"{'Выход':<20} {'Смещение':<20}")
печать("-" * 30)
для d в abs_agree:
    print(f"{d['name']:<20} {d['bias']:<20}") 
 Out:
 Outlet Bias
------------------------------
C-SPAN центр
Текущие дела слева
InfoWars право
Якобинец ушел
Mashable слева
Мать Джонс ушла
PoliticusUSA оставил
Красное государственное право
RollingStone. com ушел
осколок слева
Ежедневный сигнал прямо
Вице-левый 
 Используя форматирование строк, мы можем сделать их табличными. Интересно, что  C-SPAN  — это единственный центральный уклон, с которым сообщество абсолютно согласно. Остальные для левого и правого не так уж удивительны.
  С какими оценками торговых точек сообщество    абсолютно не согласно   ? 
 Чтобы немного упростить анализ, мы также можем загрузить наши данные JSON в Pandas DataFrame. Это легко сделать с Pandas, поскольку у них есть простая функция для чтения JSON в DataFrame.
 Кроме того, если вы никогда не использовали Pandas (  pip install pandas  ), Matplotlib (  pip install matplotlib  ) или любую другую библиотеку по науке о данных, я определенно рекомендую ознакомиться с курсом по науке о данных Хосе Портильи. за отличное введение в эти инструменты и многие концепции машинного обучения.
 Теперь к DataFrame:
 импортировать pandas как pd
df = pd. read_json(open('allsides.json', 'r'))
df.set_index('имя', inplace=Истина)
df.head() 
 Выход:
 agree
 agree_ratio
 agreeance_text
 allsides_page
 bias
 disagree
 name
 ABC News
 8355
 1.260371
 отчасти согласен
 https://www.allsides.com/news-source/abc-news-...
 левый центр
 6629
 Al Jazeera
 1996
 0.6
 somewhat disagrees
 https://www.allsides.com/news-source/al-jazeer...
 center
 2872
 AllSides
 2615
 2.485741
 strongly agrees
 https://www.allsides.com/news-source/allsides-0
 allsides
 1052
 AllSides Community
 1760
 1. 668246
 agrees
 https://www .allsides.com/news-source/allsides-...
 allsides
 1055
 AlterNet
 1226
 2.181495
 strongly agrees
 https://www.allsides.com/news-source/alternet
 left
 562
 Now отфильтровать DataFrame по "agreeance_text":
 df[df['agreeance_text'] == 'категорически не согласен'] 
 Out:
 согласен
 соглашение4text 9088842
 allsides_page
 bias
 disagree
 name
 CNBC
 1239
 0.398905
 strongly disagrees
 https://www.allsides.com/news -source/cnbc
 center
 3106
 Quillette
 45
 0. 416667
 категорически не согласен
0854
 Право-центр
 108
 Courier-Journal
 64
 0,410256
 Сильные. left-center
 156
 The Economist
 779
 0.485964
 strongly disagrees
 https://www.allsides.com/news-source/economist
 left-center
 1603
 The Observer (New York)
 123
 0.484252
 strongly disagrees
 https://www.allsides.com/news-source/observer
 center
 254
 The Oracle
 33
 0.485294
 strongly disagrees
 https://www.allsides.com/news-source/oracle
 center
 68
 The Republican
 108
 0.3
 strongly disagrees
 https://www.allsides.com/news-source/republican
 center
 275
 Похоже, что большая часть сообщества категорически не согласна с тем, что некоторые СМИ оцениваются как «центральные».
 Давайте сделаем быструю визуализацию согласия. Поскольку источников новостей слишком много, давайте выберем только те, которые набрали наибольшее количество голосов. Для этого мы можем создать новый столбец, который подсчитывает общее количество голосов, а затем сортировать по этому значению:
 df['total_votes'] = df['agree'] + df['disagree']
df.sort_values ​​("total_votes", по возрастанию = False, inplace = True)
дф.голова(10) 
 Out:
353 2638053 2638053 26380453 26380453 26380.
 agree
 agree_ratio
 agreeance_text
 allsides_page
 bias
 disagree
 total_votes
 name
 CNN ( Web News)
 22907
 0,970553
 скорее не согласен
 https://www.allsides.com/news-source/cnn-media. ..
 left-center
 23602
 46509
 Fox News
 17410
 0.650598
 disagrees
 https://www.allsides.com/news-source/fox-news-...
 right-center
 26760
 44170
 Washington Post
 21434
 1.682022
 agrees
 https://www.allsides.com/news-source/washingto...
 left-center
 12743
 34177
 New York Times - News
 12275
 0.570002
 disagrees
 https://www.allsides.com/news-source/new-york-...
 left-center
 21535
 33810
 HuffPost
 15056
 0.834127
 somewhat disagrees
 https://www.allsides.com/news-source/huffpost-...
 left
 18050
 33106
 Политик
 11047
 0. 598656
 disagrees
 https://www.allsides.com/news-source/politico-...
 left-center
 18453
 29500
 Washington Times
 18934
 2.017475
 strongly agrees
 https://www.allsides.com/news-source/washingto...
 right-center
 9385
 28319
 NPR News
 15751
 1.481889
 несколько согласен
 https: //www.allsides.com/news-source/npr-media ...
 Центр
 10629
 26380
 disagrees
 https://www.allsides.com/news-source/wall-stre...
 center
 15744
 25616
 Townhall
 7632
 0.606967
 disagrees
 https ://www. allsides.com/news-source/townhall-...
 справа
 12574
 20206
 Чтобы сделать гистограмму, мы будем использовать Matplotlib со стилем темной сетки Seaborn:
plt.style.use('seaborn-darkgrid') 
 Как упоминалось выше, у нас слишком много новостных изданий, поэтому просто сделайте копию 25 лучших и поместите ее в новую переменную  df2 :
 df2 = df.head(25).copy()
df2.head() 
 Выход:
 agree
 agree_ratio
 agreeance_text
 allsides_page
 bias
 disagree
 total_votes
 name
 CNN (Web News)
 22907
 0,970553
 несколько не согласен
 https://www. allsides.com/news-source/cnn-media...
 левый центр
 23602
 46509
 Fox News
 17410
 0.650598
 disagrees
 https://www.allsides.com/news-source/fox-news-...
 right-center
 26760
 44170
 Washington Post
 21434
 1.682022
 agrees
 https://www.allsides.com/news-source/washingto...
 left-center
 12743
 34177
 New Йорк Таймс - Новости
 12275
 0.570002
 disagrees
 https://www.allsides.com/news-source/new-york-...
 left-center
 21535
 33810
 HuffPost
 15056
 0.834127
 somewhat disagrees
 https://www.allsides.com/news-source/huffpost-...
 left
 18050
 33106
 With the top 25 news sources by количество отзывов, давайте создадим гистограмму с накоплением, где число  согласных  расположены над числом  несогласных  . Это делает общую высоту полосы общим количеством отзывов.
 Ниже мы сначала создаем фигуру и оси, наносим столбцы согласия, наносим столбцы несогласия поверх согласований, используя  снизу  , затем устанавливаем различные текстовые функции:
 fig, ax = plt.subplots(figsize=( 20, 10))
ax.bar(df2.index, df2['согласен'], color='#5DAF83')
ax.bar(df2.index, df2['не согласен'], дно=df2['согласен'], цвет='#AF3B3B')
ax.set_ylabel = 'Всего отзывов'
plt.yticks (размер шрифта = 'x-большой')
plt.xticks(rotation=60, ha='right', fontsize='x-large', rotate_mode='anchor')
plt.legend(['Согласен', 'Не согласен'], fontsize='xx-large')
plt.title('Рейтинг предвзятости AllSides по сравнению с отзывами сообщества', fontsize='xx-large')
plt.show() 
 РЕЗУЛЬТАТ:
 Для немного более сложной версии давайте создадим подсюжет для каждого предубеждения и нанесем соответствующие источники новостей.
 На этот раз мы заранее создадим новую копию исходного DataFrame, так как теперь мы можем отображать больше выпусков новостей.
 Вместо того, чтобы создавать одну ось, мы создадим новую для каждого смещения, чтобы получить шесть подграфиков:
 df3 = df.copy()
рис = plt.figure(figsize=(15,15))
смещения = df3['предвзятость'].unique()
для i смещение в перечислении (смещения):
    # Получить 10 лучших источников новостей для этого уклона и отсортировать индекс по алфавиту
    temp_df = df3[df3['смещение'] == смещение].iloc[:10]
    temp_df.sort_index (на месте = Истина)
    
    # Получить максимальное количество голосов, т.е. значение y для самого высокого бара в этом временном кадре данных
    max_votes = temp_df['total_votes'].max()
    
    # Добавляем новый участок в правильную позицию сетки
    топор = fig.add_subplot (длина (смещения) / 2, 2, я + 1)
    
    # Создаем сложенные бары
    ax. bar(temp_df.index, temp_df['согласен'], color='#5DAF83')
    ax.bar(temp_df.index, temp_df['не согласен'], дно=temp_df['согласен'], цвет='#AF3B3B')
    
    # Разместите текст соотношения над каждым столбцом
    для x, y, соотношение в zip(ax.get_xticks(), temp_df['total_votes'], temp_df['agree_ratio']):
        ax.text(x, y + (0,02 * max_votes), f"{ratio:.2f}", ha='center')
    
    ax.set_ylabel('Всего отзывов')
    ax.set_title (смещение. название ())
    
    # Увеличить лимит y, чтобы компенсировать текст на полосах
    ax.set_ylim (0, max_votes + (0,12 * max_votes))
    
    # Поворачиваем галочки так, чтобы они не перекрывались
    plt.setp(ax.get_xticklabels(), вращение=30, ha='право')
plt.tight_layout(w_pad=3.0, h_pad=1.0)
plt.show() 
 РЕЗУЛЬТАТ:
 Надеемся, что комментарии помогут понять, как были созданы эти графики. Мы просто перебираем каждое уникальное смещение и добавляем к рисунку подзаговор.
 При интерпретации этих графиков имейте в виду, что ось Y имеет разные масштабы для каждого подграфика.