Beautiful Soup - это парсер для синтаксического разбора файлов HTML/XML, написанный на языке программирования Python, который может преобразовать даже неправильную разметку в дерево синтаксического разбора. Он поддерживает простые и естественные способы навигации, поиска и модификации дерева синтаксического разбора. В большинстве случаев он поможет программисту сэкономить часы и дни работы. Написанный на языке программирования Ruby порт называется Rubyful Soup.
Данный документ иллюстрирует основные возможности Beautiful Soup версии 3.0 на примерах. Вы увидите, для чего лучше использовать данную библиотеку, как она работает, как ее использовать, как добиться необходимых вам результатов и что делать, когда она не оправдывает ваших ожиданий.
Содержание
- Быстрый старт
- Синтаксический разбор документа
- Beautiful Soup дает тебе Unicode, черт побери
- Печать документа
- Дерево синтаксического разбора
- Навигация по дереву синтаксического разбора
- Поиск в дереве синтаксического разбора
-
Поиск в дереве синтаксического разбора
- findNextSiblings(name, attrs, text, limit, **kwargs) и findNextSibling(name, attrs, text, **kwargs)
- findPreviousSiblings(name, attrs, text, limit, **kwargs) и findPreviousSibling(name, attrs, text, **kwargs)
- findAllNext(name, attrs, text, limit, **kwargs) и findNext(name, attrs, text, **kwargs)
- findAllPrevious(name, attrs, text, limit, **kwargs) и findPrevious(name, attrs, text, **kwargs)
- findParents(name, attrs, limit, **kwargs) и findParent(name, attrs, **kwargs)
- Модификация дерева синтаксического разбора
Быстрый старт
Скачать Beautiful Soup можно здесь. Список изменений содержит отличия версии 3.0 от более ранних.
Подключить Beautiful Soup к вашему приложению можно с помощью одной из ниже приведенных строк:
Следующий код демонстрирует основные возможности Beautiful Soup. Можете скопировать его в сессию Python и запустить.
1 from BeautifulSoup import BeautifulSoup
2 import re
3
4 doc = ['<html><head><title>Page title</title></head>',
5 '<body><p id="firstpara" align="center">This is paragraph <b>one</b>.',
6 '<p id="secondpara" align="blah">This is paragraph <b>two</b>.',
7 '</html>']
8 soup = BeautifulSoup(''.join(doc))
9
10 print soup.prettify()
11 # <html>
12 # <head>
13 # <title>
14 # Page title
15 # </title>
16 # </head>
17 # <body>
18 # <p id="firstpara" align="center">
19 # This is paragraph
20 # <b>
21 # one
22 # </b>
23 # .
24 # </p>
25 # <p id="secondpara" align="blah">
26 # This is paragraph
27 # <b>
28 # two
29 # </b>
30 # .
31 # </p>
32 # </body>
33 # </html>
Продемонстрируем несколько способов навигации по супу:
1 soup.contents[0].name
2 # u'html'
3
4 soup.contents[0].contents[0].name
5 # u'head'
6
7 head = soup.contents[0].contents[0]
8 head.parent.name
9 # u'html'
10
11 head.next
12 # <title>Page title</title>
13
14 head.nextSibling.name
15 # u'body'
16
17 head.nextSibling.contents[0]
18 # <p id="firstpara" align="center">This is paragraph <b>one</b>.</p>
19
20 head.nextSibling.contents[0].nextSibling
21 # <p id="secondpara" align="blah">This is paragraph <b>two</b>.</p>
А вот как искать в супе определенные теги или теги с заданными атрибутами:
1 titleTag = soup.html.head.title
2 titleTag
3 # <title>Page title</title>
4
5 titleTag.string
6 # u'Page title'
7
8 len(soup('p'))
9 # 2
10
11 soup.findAll('p', align="center")
12 # [<p id="firstpara" align="center">This is paragraph <b>one</b>. </p>]
13
14 soup.find('p', align="center")
15 # <p id="firstpara" align="center">This is paragraph <b>one</b>. </p>
16
17 soup('p', align="center")[0]['id']
18 # u'firstpara'
19
20 soup.find('p', align=re.compile('^b.*'))['id']
21 # u'secondpara'
22
23 soup.find('p').b.string
24 # u'one'
25
26 soup('p')[1].b.string
27 # u'two'
Изменять суп также весьма просто:
1 titleTag['id'] = 'theTitle'
2 titleTag.contents[0].replaceWith("New title")
3 soup.html.head
4 # <head><title id="theTitle">New title</title></head>
5
6 soup.p.extract()
7 soup.prettify()
8 # <html>
9 # <head>
10 # <title id="theTitle">
11 # New title
12 # </title>
13 # </head>
14 # <body>
15 # <p id="secondpara" align="blah">
16 # This is paragraph
17 # <b>
18 # two
19 # </b>
20 # .
21 # </p>
22 # </body>
23 # </html>
24
25 soup.p.replaceWith(soup.b)
26 # <html>
27 # <head>
28 # <title id="theTitle">
29 # New title
30 # </title>
31 # </head>
32 # <body>
33 # <b>
34 # two
35 # </b>
36 # </body>
37 # </html>
38
39 soup.body.insert(0, "This page used to have ")
40 soup.body.insert(2, " <p> tags!")
41 soup.body
42 # <body>This page used to have <b>two</b> <p> tags!</body>
Приведем реальный пример. Скачаем ICC Commercial Crime Services weekly piracy report, произведем его синтаксический разбор с помощью Beautiful Soup и выведем на экран сообщения о случаях пиратства (piracy incidents):
1 import urllib2
2 from BeautifulSoup import BeautifulSoup
3
4 page = urllib2.urlopen("http://www.icc-ccs.org/prc/piracyreport.php")
5 soup = BeautifulSoup(page)
6 for incident in soup('td', width="90%"):
7 where, linebreak, what = incident.contents[:3]
8 print where.strip()
9 print what.strip()
10 print
Синтаксический разбор документа
Для работы конструктору Beautiful Soup требуется документ XML или HTML в виде строки (или открытого файлоподобного объекта). Он произведет синтаксический разбор и создаст в памяти структуры данных, соответствующие документу.
Если обработать с помощью Beautiful Soup хорошо оформленный документ, то разобранная структура будет выглядеть также как и исходный документ. Но если его разметка будет содержать ошибки, то Beautiful Soup использует эвристические методы для построения наиболее подходящей структуры данных.
Синтаксический разбор HTML
Используйте класс BeautifulSoup для синтаксического разбора документа HTML. Несколько фактов, которые необходимо знать о BeautifulSoup:
Некоторые теги могут быть вложенными (<BLOCKQUOTE>), а некоторые - нет (<P>). Таблицы и списки тегов имеют естественный порядок вложенности. Например, теги <TD> появляются только в обрамлении тегов <TR> и никак иначе. Содержимое тега <SCRIPT> не будет участвовать в разборе HTML. Тег <META> может определять кодировку документа. Вот как это работает:
1 from BeautifulSoup import BeautifulSoup
2 html = "<html><p>Para 1<p>Para 2<blockquote>Quote 1<blockquote>Quote 2"
3 soup = BeautifulSoup(html)
4 print soup.prettify()
5 # <html>
6 # <p>
7 # Para 1
8 # </p>
9 # <p>
10 # Para 2
11 # <blockquote>
12 # Quote 1
13 # <blockquote>
14 # Quote 2
15 # </blockquote>
16 # </blockquote>
17 # </p>
18 # </html>
Обратите внимание на то, что BeautifulSoup вычисляет наиболее вероятные места для закрывающих тегов, даже если они отсутствуют в исходном документе.
Хотя приведенный документ HTML является невалидным, с ним все же можно работать. А вот действительно отвратительный документ. Помимо всего прочего он содержит тег <FORM>, который начинается вне тега <TABLE>, но закрывается внутри тега <TABLE>. (Пример такого HTML был найден на веб-сайте одной из ведущих веб-компаний.)
Beautiful Soup справится с обработкой и такого документа:
1 print BeautifulSoup(html).prettify()
2 # <html>
3 # <form>
4 # <table>
5 # <td>
6 # <input name="input1" />
7 # Row 1 cell 1
8 # </td>
9 # <tr>
10 # <td>
11 # Row 2 cell 1
12 # </td>
13 # </tr>
14 # </table>
15 # </form>
16 # <td>
17 # Row 2 cell 2
18 # <br />
19 # This
20 # sure is a long cell
21 # </td>
22 # </html>
Последняя ячейка таблицы находится вне тега <TABLE>; Beautiful Soup решил закрыть тег <TABLE> там, где закрыт тег <FORM>. Автор исходного документа планировал, вероятно, продлить действие тега <FORM> до конца таблицы, но Beautiful Soup не сможет об этом догадаться. Даже в таком необычном случае Beautiful Soup произведет синтаксический разбор и предоставит вам доступ ко всем данным документа.
Синтаксический разбор XML
Класс BeautifulSoup содержит эвристики, полностью аналогичные применяющимся в веб-браузерах, что позволяет делать предположения о замыслах авторов HTML файлов. Но в XML нет фиксированного порядка тегов такие эвристики здесь не пригодятся. Поэтому BeautifulSoup не сможет хорошо работать с XML.
Используйте класс BeautifulStoneSoup для синтаксического разбора документов XML. Это основной класс, не требующий знания диалекта XML и имеющий очень простые правила о вложенности тегов: Вот он в действии:
1 from BeautifulSoup import BeautifulStoneSoup
2 xml = "<doc><tag1>Contents 1<tag2>Contents 2<tag1>Contents 3"
3 soup = BeautifulStoneSoup(xml)
4 print soup.prettify()
5 # <doc>
6 # <tag1>
7 # Contents 1
8 # <tag2>
9 # Contents 2
10 # </tag2>
11 # </tag1>
12 # <tag1>
13 # Contents 3
14 # </tag1>
15 # </doc>
Одним из общеизвестных недостатков BeautifulStoneSoup является то, что он не знает о самозакрывающихся тегах. В HTML имеется фиксированный набор самозакрывающихся тегов, но в случае с XML все зависит от того, что записано в DTD. Вы можете сообщить BeautifulStoneSoup, что определенные теги являются самозакрывающимися, передав их имена через аргумент конструктора selfClosingTags:
1 from BeautifulSoup import BeautifulStoneSoup
2 xml = "<tag>Text 1<selfclosing>Text 2"
3 print BeautifulStoneSoup(xml).prettify()
4 # <tag>
5 # Text 1
6 # <selfclosing>
7 # Text 2
8 # </selfclosing>
9 # </tag>
10
11 print BeautifulStoneSoup(xml, selfClosingTags=['selfclosing']).prettify()
12 # <tag>
13 # Text 1
14 # <selfclosing />
15 # Text 2
16 # </tag>
Если это не работает
Имеется несколько других классов парсеров, эвристики которых отличаются от двух описанных выше. Также вы можете создать подкласс и настроить парсер и задать в нем свои собственные эвристики.
Beautiful Soup дает тебе Unicode, черт побери
Во время синтаксического разбора документа он перекодируется в Unicode. В своих структурах данных Beautiful Soup хранит только строки Unicode.
Вот пример с японским документом в кодировке UTF-8:
1 from BeautifulSoup import BeautifulSoup
2 soup = BeautifulSoup("\xe3\x81\x93\xe3\x82\x8c\xe3\x81\xaf")
3 soup.contents[0]
4 # u'\u3053\u308c\u306f'
5 soup.originalEncoding
6 # 'utf-8'
7
8 str(soup)
9 # '\xe3\x81\x93\xe3\x82\x8c\xe3\x81\xaf'
10
11 # Note: this bit uses EUC-JP, so it only works if you have cjkcodecs
12 # installed, or are running Python 2.4.
13 soup.__str__('euc-jp')
14 # '\xa4\xb3\xa4\xec\xa4\xcf'
Beautiful Soup использует класс с именем UnicodeDammit для определения кодировки передаваемых вами документов и перекодировки его в Unicode, не беспокойтесь об этом. Если это также необходимо для других документов (без их синтаксического разбора с помощью Beautiful Soup), то вы можете использовать UnicodeDammit отдельно. Он в значительной мере основан на коде из Universal Feed Parser.
Если вы работаете с Python более ранних версий, чем 2.4, то заранее скачайте и установите cjkcodecs и iconvcodec, которые добавляют в Python поддержку многих кодеков, особенно кодеков CJK. Для лучшего автоопределения кодировки установите также библиотеку chardet.
Перед перекодировкой в Unicode Beautiful Soup проверяет кодировки в следующем порядке:
- Кодировка, переданная конструктору супа в параметре fromEncoding.
- Кодировка, обнаруженная в самом документе: например, в декларации XML или (для документов HTML) в атрибуте http-equiv тега META. Как только Beautiful Soup обнаружит подобное указание о кодировке документа, он повторно приступит к синтаксическому разбору документа с самого начала, но уже применяя найденную кодировку. Избежать этого можно только явным заданием кодировки, которая будет работать: тогда любая найденная в документе кодировка будет игнорироваться.
- Кодировка, вычисленная по нескольким первым байтам файла. Если кодировка определяется на этом этапе, то она будет либо UTF-*, либо EBCDIC, либо ASCII.
Кодировка, вычисленная библиотекой chardet, в случае если она была установлена.
- UTF-8
- Windows-1252
Если Beautiful Soup сможет сделать предположение, то почти всегда оно будет верным. Но для документов без декларации или в неизвестной кодировке он не сможет сделать каких-либо предположений. В таком случае – скорее всего, ошибочно, – будет использоваться кодировка Windows-1252. Вот пример в кодировке EUC-JP, когда предположение Beautiful Soup о кодировке будет ошибочным. (Кроме того, поскольку используется кодировка EUC-JP пример будет работать только под Python 2.4 или если установлен cjkcodecs):
Но если задать кодировку с помощью fromEncoding, то синтаксический разбор документа будет корректным и его можно будет перекодировать в UTF-8 или обратно в – EUC-JP.
Если обрабатывать с помощью Beautiful Soup документ в кодировке Windows-1252 (или подобных, например, ISO-8859-1 или ISO-8859-2), то Beautiful Soup обнаружит и уничтожит изящные кавычки и другие символы, специфичные для Windows. Чтобы этого избежать Beautiful Soup преобразует эти символы в сущности HTML (BeautifulSoup) или в сущности XML (BeautifulStoneSoup).
Чтобы этого избежать можно передать параметр smartQuotesTo=None в конструктор супа: тогда кавычки будут конвертироваться в Unicode также, как и другие символы данной кодировки. Для изменения поведения BeautifulSoup и BeautifulStoneSoup можно передать в параметре smartQuotesTo значения "xml" или "html".
1 from BeautifulSoup import BeautifulSoup, BeautifulStoneSoup
2 text = "Deploy the \x91SMART QUOTES\x92!"
3
4 str(BeautifulSoup(text))
5 # 'Deploy the ‘SMART QUOTES’!'
6
7 str(BeautifulStoneSoup(text))
8 # 'Deploy the ‘SMART QUOTES’!'
9
10 str(BeautifulSoup(text, smartQuotesTo="xml"))
11 # 'Deploy the ‘SMART QUOTES’!'
12
13 BeautifulSoup(text, smartQuotesTo=None).contents[0]
14 # u'Deploy the \u2018SMART QUOTES\u2019!'
Печать документа
Документ Beautiful Soup (или любое их подмножество) можно превратить в строку с помощью функции str или методов prettify или renderContents. Также можно использовать функцию unicode для получения всего документа в виде строки Unicode.
Метод prettify добавляет значимые переводы строки и пробелы для придания структуре документа лучшей читабельности. Метод также удаляет текстовые узлы, состоящие только из пробелов, что может изменить смысл XML документа. Функции str и unicode не удаляют текстовые узлы, состоящие только из пробелов, и не добавляют пробелы между узлами.
Приведем пример.
1 from BeautifulSoup import BeautifulSoup
2 doc = "<html><h1>Heading</h1><p>Text"
3 soup = BeautifulSoup(doc)
4
5 str(soup)
6 # '<html><h1>Heading</h1><p>Text</p></html>'
7 soup.renderContents()
8 # '<html><h1>Heading</h1><p>Text</p></html>'
9 soup.__str__()
10 # '<html><h1>Heading</h1><p>Text</p></html>'
11 unicode(soup)
12 # u'<html><h1>Heading</h1><p>Text</p></html>'
13
14 soup.prettify()
15 # '<html>\n <h1>\n Heading\n </h1>\n <p>\n Text\n </p>\n</html>'
16
17 print soup.prettify()
18 # <html>
19 # <h1>
20 # Heading
21 # </h1>
22 # <p>
23 # Text
24 # </p>
25 # </html>
Обратите внимание, что функции str и renderContents дают различный результат, когда используются для тегов внутри документа. Функция str печатает и теги и их содержимое, а функция renderContents - только содержимое.
При вызове функций str, prettify или renderContents, вы можете задать кодировку вывода. Кодировкой по умолчанию (используется функцией str) является UTF-8. Вот пример разбора строки ISO-8851-1 с последующим выводом на экран той же строки в других кодировках:
1 from BeautifulSoup import BeautifulSoup
2 doc = "Sacr\xe9 bleu!"
3 soup = BeautifulSoup(doc)
4 str(soup)
5 # 'Sacr\xc3\xa9 bleu!' # UTF-8
6 soup.__str__("ISO-8859-1")
7 # 'Sacr\xe9 bleu!'
8 soup.__str__("UTF-16")
9 # '\xff\xfeS\x00a\x00c\x00r\x00\xe9\x00 \x00b\x00l\x00e\x00u\x00!\x00'
10 soup.__str__("EUC-JP")
11 # 'Sacr\x8f\xab\xb1 bleu!'
Если в исходном документе в декларации указывалась кодировка, то при обратном преобразовании в строку Beautiful Soup запишет в декларацию новую кодировку. Это означает, что если загрузить документ HTML в BeautifulSoup, а потом распечатать его, то HTML не только будет вычищен, но и прозрачно перекодирован в UTF-8.
Пример HTML:
1 from BeautifulSoup import BeautifulSoup
2 doc = """<html>
3 <meta http-equiv="Content-type" content="text/html; charset=ISO-Latin-1" >
4 Sacr\xe9 bleu!
5 </html>"""
6
7 print BeautifulSoup(doc).prettify()
8 # <html>
9 # <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
10 # Sacré bleu!
11 # </html>
Пример XML:
Дерево синтаксического разбора
До сих пор мы рассматривали загрузку и запись документов. Однако, большую часть времени будет приковывать к себе дерево синтаксического разбора: структуры данных Beautiful Soup, которые создаются по мере синтаксического разбора документа.
Объект парсера (экземпляр класса BeautifulSoup или BeautifulStoneSoup) обладает большой глубиной вложенности связанных структур данных, соответствующих структуре документа XML или HTML. Объект парсера состоит из объектов двух других типов: объектов Tag, которые соответствуют тегам, к примеру, тегу <TITLE> и тегу <B>; и объекты NavigableString, соответствующие таким строкам как "Page title" или "This is paragraph".
Класс NavigableString имеет несколько подклассов (CData, Comment, Declaration и ProcessingInstruction), которые соответствуют специальным конструкциям в XML. Они работают также как NavigableStringи, за исключением того, что когда приходит время выводить их на экран, они содержат некоторые дополнительные данные. Вот документ с включенным в него комментарием:
1 from BeautifulSoup import BeautifulSoup
2 import re
3 hello = "Hello! <!--I've got to be nice to get what I want.-->"
4 commentSoup = BeautifulSoup(hello)
5 comment = commentSoup.find(text=re.compile("nice"))
6
7 comment.__class__
8 # <class 'BeautifulSoup.Comment'>
9 comment
10 # u"I've got to be nice to get what I want."
11 comment.previousSibling
12 # u'Hello! '
13
14 str(comment)
15 # "<!--I've got to be nice to get what I want.-->"
16 print commentSoup
17 # Hello! <!--I've got to be nice to get what I want.-->
Итак, давайте более внимательно посмотрим на тот документ, что приводился в начале документации:
1 from BeautifulSoup import BeautifulSoup
2 doc = ['<html><head><title>Page title</title></head>',
3 '<body><p id="firstpara" align="center">This is paragraph <b>one</b>.',
4 '<p id="secondpara" align="blah">This is paragraph <b>two</b>.',
5 '</html>']
6 soup = BeautifulSoup(''.join(doc))
7
8 print soup.prettify()
9 # <html>
10 # <head>
11 # <title>
12 # Page title
13 # </title>
14 # </head>
15 # <body>
16 # <p id="firstpara" align="center">
17 # This is paragraph
18 # <b>
19 # one
20 # </b>
21 # .
22 # </p>
23 # <p id="secondpara" align="blah">
24 # This is paragraph
25 # <b>
26 # two
27 # </b>
28 # .
29 # </p>
30 # </body>
31 # </html>
Атрибуты Tag-ов
Объекты Tag и NavigableString имеют множество полезных элементов, большая часть которых описывается в разделах Навигация по дереву синтаксического разбора и Поиск в дереве синтаксического разбора. Тем не менее, рассмотрим здесь один аспект объектов Tag: атрибуты.
Теги SGML имеют атрибуты: например, каждый тег <P> в приведенном выше примере HTML имеет атрибуты "id" и "align". К атрибутам тегов можно обращаться таким же образом, как если бы объект Tag был словарем:
NavigableString objects don't have attributes; only Tag objects have them.
Навигация по дереву синтаксического разбора
Все объекты Tag содержат элементы, перечисленные ниже (тем не менее, фактическое значение элемента может равняться None). Объекты NavigableString имеют все из них за исключением contents и string.
parent
В примере выше, родителем объекта <HEAD> Tag является объект <HTML> Tag. Родителем объекта <HTML> Tag является сам объект парсера BeautifulSoup. Родитель объекта парсера равен None. Передвигаясь по объектам parent, можно перемещаться по дереву синтаксического разбора:
contents
С помощью parent вы перемещаетесь вверх по дереву синтаксического разбора. С помощью contents вы перемещаетесь вниз по дереву синтаксического разбора. contents является упорядоченным списком объектов Tag и NavigableString, содержащихся в элементе страницы (page element). Только объект парсера самого высокого уровня и объекты Tag содержат contents. Объекты NavigableString являются простыми строками и не могут содержать подэлементов, поэтому они не содержат contents.
В примере выше, элемент contents первого объекта <P> Tag является списком, содержащим объект NavigableString ("This is paragraph "), объекта <B> Tag и еще одного объекта NavigableString ("."). Элемент contents объекта <B> Tag: список, состоящий из одного объекта NavigableString ("one").
string
Для вашего удобства сделано так, что в случае, когда тег имеет только один дочерний узел, который является строкой, дочерний узел будет доступен через tag.string точно также как и через tag.contents[0]. В примере выше soup.b.string является объектом NavigableString отображающий Unicode-строку "one". Эта строка содержится в первом объекте <B> Tag дерева синтаксического разбора.
Но soup.p.string равен None, поскольку первый объект <P> Tag в дереве синтаксического разбора имеет более одного дочернего элемента. soup.head.string также равен None, хотя объект <HEAD> Tag имеет только один дочерний элемент, поскольку этот дочерний элемент – Tag (объект <TITLE> Tag), а не объект NavigableString.
nextSibling и previousSibling
Эти элементы позволяют пропускать следующий или предыдущий элемент на этом же уровне дерева синтаксического разбора. В представленном выше документе, элемент nextSibling объекта <HEAD> Tag равен объекту <BODY> Tag, поскольку объект <BODY> Tag является следующим вложенным элементом по отношению к объекту <html> Tag. Элемент nextSibling объекта <BODY> Tag равен None, поскольку в нем больше нет вложенных по отношению к объекту <HTML> Tag элементов.
И наоборот, элемент previousSibling объекта <BODY> Tag равен объекту <HEAD> tag, а элемент previousSibling объекта <HEAD> Tag равен None:
Несколько примеров: элемент nextSibling первого объекта <P> Tag равен второму объекту <P> Tag. Элемент previousSibling объекта <B> Tag внутри второго объекта <P> Tag равен объекту NavigableString "This is paragraph". Элемент previousSibling данного объекта NavigableString равен None, внутри первого объекта <P> Tag.
next и previous
Данные элементы позволяют передвигаться по элементам документа в том порядке, в котором они были обработаны парсером, а не в порядке появления в дереве. Например, элемент next для объекта <HEAD> Tag равен объекту <TITLE> Tag, а не объекту <BODY> Tag. Это потому, что в исходном документе, тег <TITLE> идет сразу после тега <HEAD>.
Поскольку элементы next и previous связаны, содержимое элемента contents объекта Tag обновляется до того как элемент nextSibling. Как правило, эти элементы не используют, но иногда это наиболее быстрый способ получить что-либо скрытое в глубине дерева синтаксического разбора.
Итерации над объектом Tag
Над элементом contents объекта Tag можно производить итерации, рассматривая его качестве списка. Это полезное упрощение. Подобным образом можно узнать, сколько дочерних узлов имеет объект Tag, вызвав функцию len(tag) вместо len(tag.contents). В терминах документа выше:
Используем имена тегов как элементы
Гораздо легче перемещаться по дереву синтаксического разбора, если в качестве имен тегов выступали элементы парсера или объекта Tag. Будем так делать на протяжении следующих примеров. В терминах документа выше, soup.head возвращает нам первый (как и следовало ожидать, единственный) объекта <HEAD> Tag документа:
Вообще, вызов mytag.foo возвратит первого потомка mytag, чем, как ни странно, будет объект <FOO> Tag. Если каких-либо объектов <FOO> Tag внутри mytag нет, то mytag.foo возвратит None. Вы можете использовать это для очень быстрого обхода дерева синтаксического разбора:
Также это можно использовать для быстрого перехода к определенной части дерева синтаксического разбора. Например, если вас не беспокоит отсутствие тегов <TITLE> на предусмотренных для них месте, вы можете просто использовать soup.title для получения названия документа HTML. Вам не нужно использовать soup.head.title:
soup.p перейдет к первому тегу <P> внутри документа, где бы тот ни был. soup.table.tr.td перейдет к первому столбцу первой строки первой же таблицы документа.
Фактически эти элементы – алиасы для метода first, описываемого ниже. Я упоминаю их здесь потому, что алиасы делают очень легким увеличение масштаба интересующей вас части хорошо знакомого дерева синтаксического разбора.
Альтернативная форма этого стиля позволяет обращаться к первому тегу <FOO> как .fooTag вместо .foo. Например, soup.table.tr.td можно также отобразить как soup.tableTag.trTag.tdTag или даже soup.tableTag.tr.tdTag. Это полезно если вы предпочитаете быть более осведомленным о том, что делаете или если вы разбираете XML, в котором имена тегов конфликтуют с именами методов и элементов Beautiful Soup.
1 from BeautifulSoup import BeautifulStoneSoup
2 xml = '<person name="Bob"><parent rel="mother" name="Alice">'
3 xmlSoup = BeautifulStoneSoup(xml)
4
5 xmlSoup.person.parent # A Beautiful Soup member
6 # <person name="Bob"><parent rel="mother" name="Alice"></parent></person>
7 xmlSoup.person.parentTag # A tag name
8 # <parent rel="mother" name="Alice"></parent>
Если вы присмотритесь к именам тегов, то увидите что они не являются корректными идентификаторами Python (как hyphenated-name), вам нужно использовать first.
Поиск в дереве синтаксического разбора
Beautiful Soup предоставляет множество методов для обхода дерева синтаксического разбора, отбирая по заданным критериям объекты Tag и NavigableString.
Для определения критериев отбора объектов Beautiful Soup есть несколько способов. Продемонстрируем доскональное исследование наиболее общего из всех методов поиска Beautiful Soup, findAll. Как и раньше, показывать будем на следующем документе:
1 from BeautifulSoup import BeautifulSoup
2 doc = ['<html><head><title>Page title</title></head>',
3 '<body><p id="firstpara" align="center">This is paragraph <b>one</b>.',
4 '<p id="secondpara" align="blah">This is paragraph <b>two</b>.',
5 '</html>']
6 soup = BeautifulSoup(''.join(doc))
7 print soup.prettify()
8 # <html>
9 # <head>
10 # <title>
11 # Page title
12 # </title>
13 # </head>
14 # <body>
15 # <p id="firstpara" align="center">
16 # This is paragraph
17 # <b>
18 # one
19 # </b>
20 # .
21 # </p>
22 # <p id="secondpara" align="blah">
23 # This is paragraph
24 # <b>
25 # two
26 # </b>
27 # .
28 # </p>
29 # </body>
30 # </html>
Между прочим, оба описываемых в этом разделе метода (findAll и find) доступны только для объектов Tag и объектов парсера самого высокого уровня, но не для объектов NavigableString. Методы, описываемые в разделе Поиск в дереве синтаксического разбора, доступны и для объектов NavigableString.
Основной метод поиска: findAll(name, attrs, recursive, text, limit, **kwargs)
Метод обхода дерева findAll начинает с заданной точки и ищет все объекты Tag и NavigableString, соответствующие заданным критериям. Сигнатура метода findall следующая:
findAll(name=None, attrs={}, recursive=True, text=None, limit=None, **kwargs)
Эти аргументы появляются снова и снова повсюду в Beautiful Soup API. Наиболее важными являются аргументы name и именованные аргументы.
Аргумент name ограничивает набор имен тегов. Имеется несколько способов ограничить имена и все они появляются снова и снова повсюду в Beautiful Soup API.
Самый простой способ – передать имя тега. Приведем код, который ищет все объекты <B> Tag в документе:
- Также можно передать регулярное выражение. Код, который ищет все теги, имена которых начинаются на букву B:
Можно передать список или словарь. Эти два вызова ищут все теги <TITLE> и <P>. Принцип работы у них одинаков, но второй вызов отработает быстрее:
1 soup.findAll(['title', 'p']) 2 # [<title>Page title</title>, 3 # <p id="firstpara" align="center">This is paragraph <b>one</b>.</p>, 4 # <p id="secondpara" align="blah">This is paragraph <b>two</b>.</p>] 5 6 soup.findAll({'title' : True, 'p' : True}) 7 # [<title>Page title</title>, 8 # <p id="firstpara" align="center">This is paragraph <b>one</b>.</p>, 9 # <p id="secondpara" align="blah">This is paragraph <b>two</b>.</p>]
- Можно передать специальное значение True, которому соответствуют все теги с любыми именами.
- Это не выглядит полезным, но True очень полезно, когда нужно ограничить значения атрибутов.
- Можно передать вызываемый объект, который принимает объект Tag как единственный аргумент и возвращает логическое значение. Каждый объект Tag, который находит findAll, будет передан в этот объект и если его вызов возвращает True, то необходимый тег найден.
- Вот код, который ищет теги с двумя и только двумя атрибутами: Данный код ищет теги, имена которых состоят из одной букву и которые не имеют атрибутов:
- Вот код, который ищет теги с двумя и только двумя атрибутами:
- Аргументы ключевых слов (keyword arguments) налагают ограничения на атрибуты тега. Вот простой пример поиска всех тегов, атрибут "align" которых имеет значение "center":
- Как и в случае с аргументом name вы можете передать именованный аргумент различными видами объектов для наложения разных ограничений на соответствующие атрибуты. Можно передать строку, как показано выше, чтобы ограничить значение атрибута единственным значением. Можно также передать регулярное выражение, список, хэш, специальные значения True или None, или вызываемый объект, который получает значение атрибута в качестве аргумента (обратите внимание на то, что значение может быть и None). Несколько примеров:Специальные значения True и None особо интересны. Значению True соответствует тег, заданный атрибут которого имеет любое значение, а None соответствует тег, у которого заданный атрибут не содержит значения. Несколько примеров:
1 soup.findAll(id=re.compile("para$")) 2 # [<p id="firstpara" align="center">This is paragraph <b>one</b>.</p>, 3 # <p id="secondpara" align="blah">This is paragraph <b>two</b>.</p>] 4 5 soup.findAll(align=["center", "blah"]) 6 # [<p id="firstpara" align="center">This is paragraph <b>one</b>.</p>, 7 # <p id="secondpara" align="blah">This is paragraph <b>two</b>.</p>] 8 9 soup.findAll(align=lambda(value): value and len(value) < 5) 10 # [<p id="secondpara" align="blah">This is paragraph <b>two</b>.</p>]
Если необходимо наложить сложные или взаимосвязанные ограничения на атрибуты тегов, передавайте вызываемый объект для name, как показано выше, и работайте с объектом Tag. Здесь вы должны обратить внимание на одну проблему. Что делать, если в вашем документе есть тег, который определяет атрибут с именем name? Поскольку методы поиска Beautiful Soup всегда определяют аргумент name, вы не можете использовать именованный аргумент с именем name. В качестве именованного аргумента также нельзя использовать зарезервированные слова Python, такие как for. Beautiful Soup предоставляет специальный аргумент, который с именем attrs, который можно использовать в таких ситуациях. attrs представляет собой словарь, который работает также как именованные аргументы:Можно использовать attrs если необходимо наложить ограничения на атрибуты, имена которых совпадают с зарезервированными словами Python такими, как class, for или import; или атрибуты, имена которых являются неименованными аргументами методов поиска Beautiful Soup: name, recursive, limit, text или сам attrs itself.1 soup.findAll(id=re.compile("para$")) 2 # [<p id="firstpara" align="center">This is paragraph <b>one</b>.</p>, 3 # <p id="secondpara" align="blah">This is paragraph <b>two</b>.</p>] 4 5 soup.findAll(attrs={'id' : re.compile("para$")}) 6 # [<p id="firstpara" align="center">This is paragraph <b>one</b>.</p>, 7 # <p id="secondpara" align="blah">This is paragraph <b>two</b>.</p>]
Поиск класса CSS
Аргумент attrs был бы приятным средством, если бы его не портила одна вещь: CSS. Очень полезно находить теги, которые принадлежат определенному классу CSS, но имя атрибута CSS, class, также является зарезервированным словом Python.
Искать класс CSS можно с помощью soup.find("tagName", { "class" : "cssClass" }), но это требует слишком большого объема кода для столь простой операции. Вместо этого можно передать строку для attrs взамен словаря. Строка будет использована для ограничения класса CSS.
1 from BeautifulSoup import BeautifulSoup
2 soup = BeautifulSoup("""Bob's <b>Bold</b> Barbeque Sauce now available in
3 <b class="hickory">Hickory</b> and <b class="lime">Lime</a>""")
4
5 soup.find("b", { "class" : "lime" })
6 # <b class="lime">Lime</b>
7
8 soup.find("b", "hickory")
9 # <b class="hickory">Hickory</b>
text – аргумент, позволяющий находить вместо объектов NavigableString объекты Tag. Его значением может быть строка, регулярное выражение, список или словарь, True или None, или вызываемый объект, который получает объект NavigableString в качестве аргумента:
1 soup.findAll(text="one")
2 # [u'one']
3 soup.findAll(text=u'one')
4 # [u'one']
5
6 soup.findAll(text=["one", "two"])
7 # [u'one', u'two']
8
9 soup.findAll(text=re.compile("paragraph"))
10 # [u'This is paragraph ', u'This is paragraph ']
11
12 soup.findAll(text=True)
13 # [u'Page title', u'This is paragraph ', u'one', u'.', u'This is paragraph ',
14 # u'two', u'.']
15
16 soup.findAll(text=lambda(x): len(x) < 12)
17 # [u'Page title', u'one', u'.', u'two', u'.']
Если вы используете text, то любые значения передаются в name и именованные аргументы игнорируются.
recursive – логический аргумент (по умолчанию равен True), который сообщает Beautiful Soup о том, нужно ли обходить все поддерево или искать лишь среди непосредственных потомков объекта Tag или объекта парсера. Вот в чем различие:
Когда аргумент recursive ложен, ищутся только непосредственные потомки тега <HTML>. Если вы знаете, что нужно найти, с помощью этого способа можно сэкономить время.
Установка аргумента limit позволяет останавливать поиск после того, как будет найдено заданное число совпадений. Если в документе тысячи таблиц, а нужно только четыре, то задайте в аргументе limit 4 и сэкономьте время. По умолчанию, ограничения нет.
Вызов тега подобно вызову findall
Небольшое упрощение. Если вызвать объекта парсера или объект Tag как функцию, то можно передать ему все аргументы метода findall и вызывать также как и findall. В терминах документа выше:
find(name, attrs, recursive, text, **kwargs)
Теперь давайте взглянем на другие методы поиска. Все они получают примерно те же аргументы, что и findAll.
Метод find почти в точности совпадает с findAll, за исключением того, что он ищет первое вхождение искомого объекта, а не все. Это похоже на установку для результирующего множества limit равным 1 и затем извлечения единственного результата из массива. В терминах документа выше:
В общем, когда взглянете на метод поиска с множественными именами (такой, как findAll или findNextSiblings), этот метод получает аргумент limit и возвращает список результатов. Когда взгляните на метод поиска без множественных имен (такой, как find или findNextSibling), вы знаете что метод не получает limit и возвращает единственный результат.
Что происходит с элементом first?
В предыдущих версиях Beautiful Soup имелись такие методы как first, fetch и fetchPrevious. Эти методы по-прежнему есть, но использовать их нежелательно и в будущем они могут быть убраны. Общий эффект этих имен очень сбивал с толку. Новые имена присвоены единообразно: как упоминалось выше, если имя метода является множественным или ссылается на All, то он возвращает множественные объекты. В противном случае он возвращает единственный объект.
Поиск в дереве синтаксического разбора
Методы описанные выше – findAll и find, – стартуют с определенной точки в дереве синтаксического разбора и движутся по нему вниз. Они рекурсивно производят итерацию по элементу contents объектов до тех пор, пока не достигнут конца документа.
Это означает, что вызывать эти методы для объектов NavigableStringне получится, поскольку в них нет элемента contents: они всегда являются листьями дерева синтаксического разбора.
Но спуск по дереву не единственный способ итерации по документу. Не так давно в Навигации по дереву синтаксического разбора я продемонстрировал много других способов: parent, nextSibling и т.д. Каждый из этих методов итерации имеют два соответствующих метода: один из них работает аналогично findAll, а другой – find. И поскольку объекты NavigableString поддерживают эти операции и эти методы можно вызывать для них также как и для объектов Tag и основного объекта парсера.
Почему это полезно? Иногда вы не сможете применить методы findAll или find чтобы получить желаемый объект Tag или NavigableString. Например, рассмотрим такой HTML:
Для навигации по тегу <LI>, содержащим необходимые данные, существуют несколько способов. Наиболее очевидный:
В равной степени очевидно, что это будет не самым стабильным способом получения этого тега <LI>. Если эта страница скачивается (scraping) единожды это не имеет значения, но если ее предполагается скачивать неоднократно в течение значительного периода времени, такие соображения становятся существенными. Если в несущественный список (irrelevant list) будет вставлен тег <LI>, то вместо искомого тега будет получен этот ненужный тег и работа скрипта прервется или же он выдаст ошибочные данные.
Несколько лучше, поскольку теперь учитываются несущественные изменения в списке. Но если выше в документ будет вставлен другой ненужный список, то будет получен первый тег <LI> из этого списка вместо того, который вам нужен. Более надежным способом указания необходимого тега ul будет служить указание на его место в структуре документа.
Когда вы смотрите на этот фрагмент HTML, вы думаете о нужном списке примерно так: 'тег <UL>, который идет сразу после тега <H1>'. Проблема состоит в том, что этот тег не содержится внутри тега <H1>; так уж получилось, что он идет после него. Довольно просто перейти к тегу <H1>, но нет способа перейти с этого места к тегу <UL> с помощью first и fetch, поскольку эти методы проверят только элемент contents тега <H1>. Необходимо переместиться к тегу <UL> с помощью элементов next или nextSibling:
Или, если вы считаете это более стабильным:
Но для достижения нужной вам цели это слишком сложно. Методы из этого раздела предоставляют полезные упрощения. Ими можно воспользоваться, когда возникает желание написать цикл while над одним из элементов перемещения. Получив начальную точку где-нибудь в дереве, они позволяют перемещаться по дереву в том же направлении и отслеживают объекты Tag или NavigableString, соответствующие заданным критериям. Вместо первого цикла в примере кода выше можно написать:
Вместо второго цикла можно написать так:
Циклы заменены вызовами findNextSibling и findNext. В оставшейся части раздела приведена справочная информация для всех методов такого рода. С другой стороны, каждый метод имеет два варианта: один возвращает список аналогично findAll и другой, возвращающий одно значение также как find.
И напоследок, примера ради, давайте загрузим документ в уже знакомый нам суп:
1 from BeautifulSoup import BeautifulSoup
2 doc = ['<html><head><title>Page title</title></head>',
3 '<body><p id="firstpara" align="center">This is paragraph <b>one</b>.',
4 '<p id="secondpara" align="blah">This is paragraph <b>two</b>.',
5 '</html>']
6 soup = BeautifulSoup(''.join(doc))
7 print soup.prettify()
8 # <html>
9 # <head>
10 # <title>
11 # Page title
12 # </title>
13 # </head>
14 # <body>
15 # <p id="firstpara" align="center">
16 # This is paragraph
17 # <b>
18 # one
19 # </b>
20 # .
21 # </p>
22 # <p id="secondpara" align="blah">
23 # This is paragraph
24 # <b>
25 # two
26 # </b>
27 # .
28 # </p>
29 # </body>
30 # </html>
findNextSiblings(name, attrs, text, limit, **kwargs) и findNextSibling(name, attrs, text, **kwargs)
Эти методы часто следуют за элементом nextSibling объектов, собирая объекты Tag или NavigableText, соответствующие заданным критериям. В терминах документа выше:
findPreviousSiblings(name, attrs, text, limit, **kwargs) и findPreviousSibling(name, attrs, text, **kwargs)
Эти методы часто следуют за элементом previousSibling member, gathering <объектов, собирая объекты Tag или NavigableText, соответствующие заданным критериям. В терминах документа выше:
findAllNext(name, attrs, text, limit, **kwargs) и findNext(name, attrs, text, **kwargs)
Эти методы часто следуют за элементом c0>next объектов, собирая объекты Tag или NavigableText, соответствующие заданным критериям. В терминах документа выше:
findAllPrevious(name, attrs, text, limit, **kwargs) и findPrevious(name, attrs, text, **kwargs)
Эти методы часто следуют за элементом previous объектов, собирая объекты Tag или NavigableText, соответствующие заданным критериям. В терминах документа выше:
findParents(name, attrs, limit, **kwargs) и findParent(name, attrs, **kwargs)
Эти методы часто следуют за элементом parent объектов, собирая объекты Tag или NavigableText, соответствующие заданным критериям. Они не принимают аргумент text, поскольку не может быть объектов, предком которых был бы объект NavigableString. В терминах документа выше:
Модификация дерева синтаксического разбора
Теперь вам известно как разыскать что-либо в дереве синтаксического разбора. Но, возможно, вы захотите изменить это что-либо и записать обратно. Можно просто вырезать элемент из contents родительского элемента, но в документе останутся ссылки на извлеченный фрагмент. Beautiful Soup предлагает несколько методов, позволяющих изменить дерево синтаксического разбора во время разбора и сохраняющих при этом внутреннюю согласованность данных.
Изменение значений атрибутов
Модифицировать значения атрибутов объекта Tag можно так же, как если бы он был словарем.
1 from BeautifulSoup import BeautifulSoup
2 soup = BeautifulSoup("<b id="2">Argh!</b>")
3 print soup
4 # <b id="2">Argh!</b>
5 b = soup.b
6
7 b['id'] = 10
8 print soup
9 # <b id="10">Argh!</b>
10
11 b['id'] = "ten"
12 print soup
13 # <b id="ten">Argh!</b>
14
15 b['id'] = 'one "million"'
16 print soup
17 # <b id='one "million"'>Argh!</b>
Так же можно удалять значения атрибутов и добавлять новые:
Удаление элементов
Если имеется ссылка на элемент, то удалить его из дерева можно с помощью метода extract. Приведем код, который удалит все комментарии из документа:
1 from BeautifulSoup import BeautifulSoup, Comment
2 soup = BeautifulSoup("""1<!--The loneliest number-->
3 <a>2<!--Can be as bad as one--><b>3""")
4 comments = soup.findAll(text=lambda text:isinstance(text, Comment))
5 [comment.extract() for comment in comments]
6 print soup
7 # 1
8 # <a>2<b>3</b></a>
Код, который удалит из документа все поддерево целиком:
1 from BeautifulSoup import BeautifulSoup
2 soup = BeautifulSoup("<a1></a1><a><b>Amazing content<c><d></a><a2></a2>")
3 soup.a1.nextSibling
4 # <a><b>Amazing content<c><d></d></c></b></a>
5 soup.a2.previousSibling
6 # <a><b>Amazing content<c><d></d></c></b></a>
7
8 subtree = soup.a
9 subtree.extract()
10
11 print soup
12 # <a1></a1><a2></a2>
13 soup.a1.nextSibling
14 # <a2></a2>
15 soup.a2.previousSibling
16 # <a1></a1>
Метод extract разъединяет синтаксическое дерево разбора на два несвязанных дерева. Элементы навигации изменяются таким образом, что все выглядит так, будто деревья никогда не были одним целым:
Замена одного элемента на другой
Метод replaceWith извлекает один страничный элемент (page element) и заменяет его другим. Новый элемент может быть объектом Tag (возможно, с целым деревом синтаксического разбора внутри) или NavigableString. Если передавать в метод replaceWith плоскую старую строку, он поместит ее в объект NavigableString. Элементы навигации изменятся таким образом, как будто документ прошел синтаксический разбор с самого начала.
Простой пример:
1 from BeautifulSoup import BeautifulSoup
2 soup = BeautifulSoup("<b>Argh!</b>")
3 soup.find(text="Argh!").replaceWith("Hooray!")
4 print soup
5 # <b>Hooray!</b>
6
7 newText = soup.find(text="Hooray!")
8 newText.previous
9 # <b>Hooray!</b>
10 newText.previous.next
11 # u'Hooray!'
12 newText.parent
13 # <b>Hooray!</b>
14 soup.b.contents
15 # [u'Hooray!']
Вот более сложный пример, в котором один тег замещается другим:
Можно даже вырезать элемент из одного места документа и вставить в другое:
Добавление другого нового элемента
Класс Tag и классы парсеров поддерживают метод insert. Он работает также как метод insert обычного списка Python: получает индекс элемента contents тега и вставляет в эту позицию новый элемент.
Это было продемонстрировано в предыдущем разделе, когда мы заменяли тег в документе другим новым тегом. Можно использовать insert для построения полного дерева синтаксического разбора с нуля:
1 from BeautifulSoup import BeautifulSoup, Tag, NavigableString
2 soup = BeautifulSoup()
3 tag1 = Tag(soup, "mytag")
4 tag2 = Tag(soup, "myOtherTag")
5 tag3 = Tag(soup, "myThirdTag")
6 soup.insert(0, tag1)
7 tag1.insert(0, tag2)
8 tag1.insert(1, tag3)
9 print soup
10 # <mytag><myOtherTag></myOtherTag><myThirdTag></myThirdTag></mytag>
11
12 text = NavigableString("Hello!")
13 tag3.insert(0, text)
14 print soup
15 # <mytag><myOtherTag></myOtherTag><myThirdTag>Hello!</myThirdTag></mytag>
В дереве синтаксического разбора элемент может встретиться только в одном месте. Если применить insert к элементу, который уже соединен с объектом супа, он будет отсоединен (с помощью extract) перед тем, как будет подсоединен где-либо. В данном примере я попытался вставить NavigableString во вторую часть супа, но во второй раз он не вставился. Он переместился:
Это произойдет даже если элемент до этого принадлежал принципиально другому объекту супа. У элемента может быть только один parent, только один – nextSibling и т.д., так что в данный момент времени он может находиться только в одном месте.