Beautiful Soup
Beautiful Soup - это парсер для синтаксического разбора файлов HTML/XML, написанный на языке программирования Python, который может преобразовать даже неправильную разметку в дерево синтаксического разбора. Он поддерживает простые и естественные способы навигации, поиска и модификации дерева синтаксического разбора. В большинстве случаев он поможет программисту сэкономить часы и дни работы. Написанный на языке программирования Ruby порт называется Rubyful Soup.
Данный документ иллюстрирует основные возможности Beautiful Soup версии 3.0 на примерах. Вы увидите, для чего лучше использовать данную библиотеку, как она работает, как ее использовать, как добиться необходимых вам результатов и что делать, когда она не оправдывает ваших ожиданий.
Содержание
- Beautiful Soup
- Быстрый старт
- Синтаксический разбор документа
- 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 был словарем:
Навигация по дереву синтаксического разбора
Все объекты 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 и т.д., так что в данный момент времени он может находиться только в одном месте.
Известные проблемы
В этом разделе описываются общие проблемы, с которыми сталкиваются при работе с Beautiful Soup.
Почему Beautiful Soup не может вывести на экран не-ASCII символы, которые я передал ему?
Если вы получаете ошибки примерно такого содержания: "'ascii' codec can't encode character 'x' in position y: ordinal not in range(128)", это значит, что проблема вероятно в установленном Python, а не в Beautiful Soup. Попробуйте вывести на экран не-ASCII символы без использования Beautiful Soup и вы столкнетесь с той же проблемой. Например, попробуйте запустить такой код:
Если он сработает нормально, а при использовании Beautiful Soup все равно выдается сообщение об ошибке – значит ошибка в Beautiful Soup. Однако же если код не работает – проблема с установленным Python. Python выполняет код безопасно и не посылает не-ASCII символы на терминал. Для изменения такого поведения есть два способа.
- Легкий способ – переназначить стандартный вывод в конвертер, который не боится отправлять символы ISO-Latin-1 или UTF-8 на терминал.
codecs.lookup возвращает количество ограничивающих методов и других объектов, связанных с кодеком. В последней строке объект StreamWriter реализует обертку вокруг потока вывода.
- Более сложный способ – в каталоге, где установлен Python, создать файл sitecustomize.py, который установит кодировкой по умолчанию ISO-Latin-1 или UTF-8. В этом случае все ваши программы на Python будут использовать эту кодировку для стандартного вывода, не требуя ничего менять в каждой программе.. В моем случае имеется файл /usr/lib/python/sitecustomize.py, который выглядит так:
За дополнительной информацией о поддержке Unicode в Python смотрите Unicode for Programmers или End to End Unicode Web Applications in Python. Также будут очень полезны Рецепт 1.20 и 1.21 Поваренной книги Python.
Помните, что даже если ваш дисплей ограничен ASCII, вы можете использовать Beautiful Soup для синтаксического разбора, обработки и записи документов в UTF-8 и других кодировках. Просто некоторые строки не получится распечатать с помощью print.
Beautiful Soup потерял данные, которые я ему передал! Почему? ПОЧЕМУ?????
Beautiful Soup может обрабатывать плохо структурированный SGML, но иногда он теряет данные когда получает нечто, совершенно не похожее на SGML. Это не особенно близко к плохо структурированной разметке, но если у вас в планах построить поисковый агент или что-нибудь вроде этого, то вы наверняка столкнетесь с этим.
Единственным решением является рассматриваемая далее очистка данных с помощью регулярного выражения. Вот несколько примеров, которые выявили я и пользователи Beautiful Soup:
- Beautiful Soup интерпретирует плохо оформленные определения XML как данные. Однако он теряет хорошо оформленные определения XML, которые не существуют:
- Если документ начинается с декларации и не завершает ее, Beautiful Soup предполагает, что оставшаяся часть документа является частью декларации. Если документ заканчивается посередине декларации, Beautiful Soup игнорирует декларацию полностью. Пара примеров:
- Имеется пара способов исправить это; один из них детально рассмотрен здесь. Beautiful Soup также игнорирует ссылки на сущности, которые не завершены до конца документа: Я никогда не видел такого в реальных веб-страницах, но, наверное, где-нибудь такое встречается.
- Плохо сформированный комментарий заставит Beautiful Soup проигнорировать оставшийся фрагмент документа. Это раскрывается в примере Очистка от плохих данных с помощью регулярных выражений.
Синтаксическое дерево разбора, построенное классом !BeautifulSoup, меня раздражает!
Чтобы получить синтаксический разбор вашей разметки другим способом, загляните в раздел Другие встроенные парсеры или же Создание собственного парсера.
Beautiful Soup слишком медленно работает!
Beautiful Soup никогда не будет столь же быстр как ElementTree или специально разработанный подкласс SGMLParser. ElementTree написан на Си, а с помощью SGMLParser можно написать собственный мини-Beautiful Soup, который будет делать то, что вам необходимо. Суть Beautiful Soup состоит в экономии времени работы программиста, а не процессора.
Это говорит о том, что достаточно сильно ускорить Beautiful Soup можно подвергнув синтаксическому разбору только нужную часть документа, а также вы можете убрать ненужные объекты с помощью extract или decompose.
Дополнительные темы
Все это необходимо для стандартного использования Beautiful Soup. Но HTML и XML сложны и в реальной ситуации могут слишком сложны. Поэтому Beautiful Soup содержит несколько дополнительных трюков для исправления собственных проблем.
Генераторы
Методы поиска, описываемые выше, управляются с помощью методов генераторов. Вы сами можете использовать эти методы: они называются nextGenerator, previousGenerator, nextSiblingGenerator, previousSiblingGenerator и parentGenerator. Объекты Tag и парсера также имеют в наличии методы childGenerator и recursiveChildGenerator.
Простой пример, в котором при итерациях по документу HTML удаляются все теги и оставшиеся строки объединяются в одну.
1 from BeautifulSoup import BeautifulSoup
2 soup = BeautifulSoup("""<div>You <i>bet</i>
3 <a href="http://www.crummy.com/software/BeautifulSoup/">BeautifulSoup</a>
4 rocks!</div>""")
5
6 ''.join([e for e in soup.recursiveChildGenerator()
7 if isinstance(e,unicode)])
8 # u'You bet\nBeautifulSoup\nrocks!'
Конечно, вам действительно не нужен генератор только для поиска текста внутри тега. Этот код делает то же самое что и .findAll(text=True).
Вот более сложный пример, в котором используется recursiveChildGenerator для итераций по элементам документа, выводя их на экран по мере нахождения.
Другие встроенные парсеры
Помимо BeautifulSoup и BeautifulStoneSoup в составе Beautiful Soup имеются еще три класса парсеров:
MinimalSoup – подкласс BeautifulSoup. Он обладает знанием большинства фактов о HTML таких, как какие из тегов самозакрывающиеся, особое поведение тега <SCRIPT>, возможности указания кодировки в теге <META> и т.д. Но он совсем не имеет вложенных эвристик. Поэтому он не знает, что теги <LI> всегда вложены в теги <UL> и никак иначе. Он полезен для синтаксического разбора патологически плохой разметки и для наследования.
ICantBelieveItsBeautifulSoup – также подкласс BeautifulSoup. Он содержит эвристики HTML, которые почти соответствуют стандарту HTML, но игнорирует реальное использование HTML. Например, он проверят вложенность тегов <B>, но в реальном мире такая вложенность тегов <B> почти всегда означает, что автор документа забыл закрыть первый тег <B>. Когда вы столкнетесь с чем-нибудь, где используется вложенность тегов <B>, вы можете использовать ICantBelieveItsBeautifulSoup.
BeautifulSOAP – подкласс BeautifulStoneSoup. Он полезен при синтаксическом разборе таких документов как сообщения SOAP, которые используют подэлементы, вместо использования атрибутов родительского элемента. Вот пример:
С помощью BeautifulSOAP можно получить доступ сразу к содержимому тега <TAG> без спуска по дереву к тегу.
Настраиваем парсер
Когда встроенные классы парсеров не делают то, что нужно, тогда необходимо заняться настройкой. Обычно это означает настройку списков вложенности и самозакрываемости тегов. Список самозакрывающихся тегов можно настроить передав в конструктор супа аргумент selfClosingTags. Для настройки же списков вложенности тегов придется использовать производный класс.
Наиболее полезные классы для создания производных – MinimalSoup (для HTML) и BeautifulStoneSoup (для XML). Я покажу, как перегрузить RESET_NESTING_TAGS и NESTABLE_TAGS в подклассах. Это наиболее сложная часть Beautiful Soup и я не смогу разъяснить здесь ее всю, но кое-что я все же покажу и смогу улучшить с помощью обратной связи.
Когда Beautiful Soup разбирает документ, он сохраняет открытые теги в стеке. Всякий раз, когда встречается новый открывающий тег, он помещает его на вершину стека. Но до этого он может закрыть некоторые из открытых тегов и удалить их из стека. Какие теги он закроет – зависит от вида найденного тега и от вида тегов в стеке.
Лучшим способом объяснить все это будет пример. Предположим, что стек выглядит таким образом ['html', 'p', 'b'] и Beautiful Soup встретился тег <P>. Если просто поместить еще один 'p' в стек, то это будет означать, что второй тег <P> находится внутри первого тега <P>, не говоря уже о теге <B>. Но теги <P> функционируют по-другому Вы не сможете вставить один тег <P> в другой тег <P>. Тег <P> вообще «не вкладываемый».
Поэтому когда Beautiful Soup встречает тег <P>, он закрывает и извлекает из стека все теги и их содержимое ранее встреченного тега такого же типа. Это поведение по умолчанию, и BeautifulStoneSoup обращается так с каждым тегом. Вот что получится, если тег не упомянут ни в NESTABLE_TAGS, ни в RESET_NESTING_TAGS. Если тег указан в RESET_NESTING_TAGS, но не указан в NESTABLE_TAGS, поведение будет таким же, как и в случае тега.
1 from BeautifulSoup import BeautifulSoup
2 BeautifulSoup.RESET_NESTING_TAGS['p'] == None
3 # True
4 BeautifulSoup.NESTABLE_TAGS.has_key('p')
5 # False
6
7 print BeautifulSoup("<html><p>Para<b>one<p>Para two")
8 # <html><p>Para<b>one</b></p><p>Para two</p></html>
9 # ^---^--Второй тег <p> предполагает закрытие этих двух тегов
Давайте предположим, что стек выглядит следующим образом ['html', 'span', 'b'] и Beautiful Soup встретил тег <SPAN>. Теперь теги <SPAN> могут содержать другие теги <SPAN> без ограничений, так что при встрече тега <SPAN> теперь не нужно убирать со стека предыдущий тег такого же типа. Все это представлено отображением имени тега на пустой список в NESTABLE_TAGS. Этот тип тегов не должен указываться в RESET_NESTING_TAGS: не существует ситуаций, когда при встрече тега <SPAN> придется удалять со стека какие-либо теги.
Третий пример: предположим, что стек выглядит так ['ol','li','ul']: т.е. мы получим упорядоченный список, первый элемент которого содержит неупорядоченный список. Теперь предположим, что Beautiful Soup встретил тег <LI>. Это не приведет к удалению со стека первого тега <LI>, т.к. новый тег <LI> является часть неупорядоченного подсписка. С тегом <LI> внутри другого тега <LI> все в порядке до тех пор, пока встречается теги <UL> или <OL>.
Но если не встретится <UL> или <OL>, то один тег <LI> не может быть внутри другого:
Сообщим Beautiful Soup о том, чтобы он трактовал теги <LI> поместив "li" в RESET_NESTING_TAGS, и передавая "li" в элемент NESTABLE_TAGS, чтобы показать список тегов, в которые он может быть вложен.
Таким же образом мы обрабатываем вложенность тегов таблиц:
1 BeautifulSoup.NESTABLE_TAGS['td']
2 # ['tr']
3 BeautifulSoup.NESTABLE_TAGS['tr']
4 # ['table', 'tbody', 'tfoot', 'thead']
5 BeautifulSoup.NESTABLE_TAGS['tbody']
6 # ['table']
7 BeautifulSoup.NESTABLE_TAGS['thead']
8 # ['table']
9 BeautifulSoup.NESTABLE_TAGS['tfoot']
10 # ['table']
11 BeautifulSoup.NESTABLE_TAGS['table']
12 # []
Это означает, что теги <TD> могут быть вложены внутри тегов <TR>. Теги <TR> могут быть вложены внутри тегов <TABLE>, <TBODY>, <TFOOT> и <THEAD>. Теги <TBODY>, <TFOOT> и <THEAD> могут быть вложены в теги <TABLE> и теги <TABLE>, в свою очередь, могут быть вложены в другие теги <TABLE>. Если вы освоили таблицы HTML, то эти правила будут вам понятны.
Еще один пример. Предположим, что стек выглядит так ['html', 'p', 'table'] и Beautiful Soup встретил тег <P>.
На первый взгляд это выглядит почти так же как в примере со стеком вида ['html', 'p', 'b'] когда Beautiful Soup встретил тег <P>. В данном примере, мы закрыли теги <B> и <P>, поскольку один параграф не может быть внутри другого.
За исключением того... что вы можете иметь параграф, содержащий таблицу, и в этой таблице содержится параграф. Т.е. правильным будет не закрывать какие-либо из этих тегов. Beautiful Soup поступит правильно:
1 from BeautifulSoup import BeautifulSoup
2 print BeautifulSoup("<p>Para 1<b><p>Para 2")
3 # <p>
4 # Para 1
5 # <b>
6 # </b>
7 # </p>
8 # <p>
9 # Para 2
10 # </p>
11
12 print BeautifulSoup("<p>Para 1<table><p>Para 2").prettify()
13 # <p>
14 # Para 1
15 # <table>
16 # <p>
17 # Para 2
18 # </p>
19 # </table>
20 # </p>
В чем же разница? Разница заключается в том, что тег <TABLE> содержится в RESET_NESTING_TAGS, а тег <B> - нет. Тег, содержащийся в RESET_NESTING_TAGS, не сможет покинуть стек так же легко как не содержащийся там тег.
Итак, будем надеяться, вы поняли идею. Вот NESTABLE_TAGS для класса BeautifulSoup. Соотнесите его с тем, что вы знаете о HTML и вы сможете создать свой собственный NESTABLE_TAGS для необычных документов HTML, которые не подчиняются нормальным правилам, и для других диалектов XML, имеющих различные правила вложенности.
1 from BeautifulSoup import BeautifulSoup
2 nestKeys = BeautifulSoup.NESTABLE_TAGS.keys()
3 nestKeys.sort()
4 for key in nestKeys:
5 print "%s: %s" % (key, BeautifulSoup.NESTABLE_TAGS[key])
6 # bdo: []
7 # blockquote: []
8 # center: []
9 # dd: ['dl']
10 # del: []
11 # div: []
12 # dl: []
13 # dt: ['dl']
14 # fieldset: []
15 # font: []
16 # ins: []
17 # li: ['ul', 'ol']
18 # object: []
19 # ol: []
20 # q: []
21 # span: []
22 # sub: []
23 # sup: []
24 # table: []
25 # tbody: ['table']
26 # td: ['tr']
27 # tfoot: ['table']
28 # th: ['tr']
29 # thead: ['table']
30 # tr: ['table', 'tbody', 'tfoot', 'thead']
31 # ul: []
А вот и BeautifulSoup класса RESET_NESTING_TAGS. Важны только ключи: фактически RESET_NESTING_TAGS является списком, вставленным в форму словаря в целях организации быстрого случайного доступа.
1 from BeautifulSoup import BeautifulSoup
2 resetKeys = BeautifulSoup.RESET_NESTING_TAGS.keys()
3 resetKeys.sort()
4 resetKeys
5 # ['address', 'blockquote', 'dd', 'del', 'div', 'dl', 'dt', 'fieldset',
6 # 'form', 'ins', 'li', 'noscript', 'ol', 'p', 'pre', 'table', 'tbody',
7 # 'td', 'tfoot', 'th', 'thead', 'tr', 'ul']
В любом случае получив подкласс, вы можете точно также заменить SELF_CLOSING_TAGS пока вы в нем. Это словарь, который отображает имена самозакрывающихся тегов в какие-либо значения (аналогично RESET_NESTING_TAGS, он фактически является списком в виде словаря). К тому же, вам не захочется передавать этот список в конструктор (аналогично selfClosingTags) каждый раз, когда создаете экземпляр своего подкласса.
Преобразование сущностей
Когда идет синтаксический разбор документа вы можете преобразовать HTML или XML ссылки на сущности в соответствующие символы Unicode. Данный код преобразует HTML сущность "é" в символ Unicode ЛАТИНСКАЯ МАЛЕНЬКАЯ БУКВА E С АКУТОМ и числовую сущность "e" в символ Unicode ЛАТИНСКУЮ МАЛЕНЬКУЮ БУКВУ E.
Это если вы используете HTML_ENTITIES (который является только строкой "html"). Если используется XML_ENTITIES (или строка "xml"), , то только числовые сущности и пять XML сущностей (""", "'", ">", "<", and "&") будут конвертированы. Если используется ALL_ENTITIES (или список ["xml", "html"]), то оба вида сущностей будут конвертированы Последний случай необходим, поскольку ' - сущность XML, а не HTML.
1 BeautifulStoneSoup("Sacré bleu!",
2 convertEntities=BeautifulStoneSoup.XML_ENTITIES)
3 # Sacré bleu!
4
5 from BeautifulSoup import BeautifulStoneSoup
6 BeautifulStoneSoup("Il a dit, <<Sacré bleu!>>",
7 convertEntities=BeautifulStoneSoup.XML_ENTITIES)
8 # Il a dit, <<Sacré bleu!>>
Если вы сообщите Beautiful Soup о необходимости конвертировать XML- или HTML-сущности в соответствующие символы Unicode, то символы Windows-1252 (такие как изящные кавычки Microsoft) также будут трансформированы в символы Unicode. Это произойдет даже если сообщить Beautiful Soup о конвертировании этих символов в сущности.
1 from BeautifulSoup import BeautifulStoneSoup
2 smartQuotesAndEntities = "Il a dit, \x8BSacré bleu!\x9b"
3
4 BeautifulStoneSoup(smartQuotesAndEntities, smartQuotesTo="html").contents[0]
5 # u'Il a dit, ‹Sacré bleu!›'
6
7 BeautifulStoneSoup(smartQuotesAndEntities, convertEntities="html",
8 smartQuotesTo="html").contents[0]
9 # u'Il a dit, \u2039Sacr\xe9 bleu!\u203a'
10
11 BeautifulStoneSoup(smartQuotesAndEntities, convertEntities="xml",
12 smartQuotesTo="xml").contents[0]
13 # u'Il a dit, \u2039Sacré bleu!\u203a'
Пока вы заняты преобразованием всех имеющихся сущностей в символы Unicode, создавать новые HTML/XML сущности не имеет смысла.
Очистка от плохих данных с помощью регулярных выражений
Beautiful Soup прекрасно подходит для обработки плохой разметки, когда под "плохой разметкой" понимается неверное расположение тегов. Но иногда разметка настолько деформирована, что базовый парсер не может обработать ее. Поэтому Beautiful Soup выполняет к исходному документу регулярные выражения прежде, чем попытается произвести его синтаксический разбор.
По умолчанию Beautiful Soup использует регулярные выражения и функции замены для выполнения поиска и замены в исходных документах. Он находит самозакрывающиеся теги, такие как <BR/>, и изменяет их на такие <BR />. Он находит декларации, содержащие внешние пробелы, такие как <! --Comment-->, и удаляет из них пробелы: <!--Comment-->.
Если имеется плохая разметка, для исправления которой требуются другие методы, вы можете передать свой список кортежей вида (regular expression, replacement function) в конструктора супа как аргумент markupMassage.
Давайте рассмотрим пример: страница имеет деформированный комментарий. Базовый парсер SGML не справился и пропустил комментарий со всем, что было после него:
Давайте исправим это с помощью регулярных выражений и функции:
Ой, мы к тому же пропустили тег <BR>. Наш аргумент markupMassage поменял манипуляцию парсера по умолчанию, так что функция поиска и замены по умолчанию не выполнялась. Парсер сделал это, пропустив комментарий, но деформированный самозакрывающийся тег вывел его из строя. Давайте добавим свою функцию манипулирования данными в список умолчаний, а затем выполним все функции.
Теперь мы получили все.
Если вы уверены в том, что разметка не нуждается в применении регулярных выражений, вы можете ускорить время запуска передав значение False в аргументе markupMassage.
Наслаждаемся SoupStrainer-ми
Припомните, что все поисковые методы получают больше или меньше вот таких аргументов. За кулисами, ваши аргументы поисковых методов преобразуются в объект SoupStrainer. Если вызвать один из методов, возвращающих список (например, findAll), объект SoupStrainer станет доступным как свойство source результирующего списка.
1 from BeautifulSoup import BeautifulStoneSoup
2 xml = '<person name="Bob"><parent rel="mother" name="Alice">'
3 xmlSoup = BeautifulStoneSoup(xml)
4 results = xmlSoup.findAll(rel='mother')
5
6 results.source
7 # <BeautifulSoup.SoupStrainer instance at 0xb7e0158c>
8 str(results.source)
9 # "None|{'rel': 'mother'}"
Конструктор SoupStrainer получает большую часть тех же аргументов, что и find: name, attrs, text и **kwargs. Можно передать SoupStrainer как аргумент name в любой поисковый метод:
Не велика важность, не правда ли? Можно передать аргументы в метод и другими способами. Но с другой стороны SoupStrainer можно передать в конструктор супа для ограничения фрагмента документа, который фактически будет подвернут синтаксическому разбору. Это рассматривается в следующем разделе:
Улучшаем производительность за счет синтаксического разбора только части документа
Beautiful Soup преобразует каждый элемент документа в объект Python и присоединяет его к группе других объектов Python. Если вам необходимо лишь подмножество документа, то это крайне медленно. Но SoupStrainer можно передать в качестве аргумента parseOnlyThese в конструктор супа. Beautiful Soup проверяет каждый элемент – не является ли он SoupStrainer, и только если является преобразует в объект Tag или NavigableText, и добавляет в дерево.
Если элемент добавлен в дерево, то он имеет потомков – даже если они не являются SoupStrainer. Это позволяет разбирать только фрагментов документа, которые содержит нужную вам информацию.
Вот значительно реорганизованный документ:
1 doc = '''Bob reports <a href="http://www.bob.com/">success</a>
2 with his plasma breeding <a
3 href="http://www.bob.com/plasma">experiments</a>. <i>Don't get any on
4 us, Bob!</i>
5
6 <br><br>Ever hear of annular fusion? The folks at <a
7 href="http://www.boogabooga.net/">BoogaBooga</a> sure seem obsessed
8 with it. Secret project, or <b>WEB MADNESS?</b> You decide!'''
Имеется несколько разных способов синтаксического разбора документа в супе в зависимости от того, какие части необходимы. Все они работают быстрее и используют меньше памяти, нежели синтаксический разбор всего документа и используют SoupStrainer для выделения необходимых вам частей.
1 from BeautifulSoup import BeautifulSoup, SoupStrainer
2 import re
3
4 links = SoupStrainer('a')
5 [tag for tag in BeautifulSoup(doc, parseOnlyThese=links)]
6 # [<a href="http://www.bob.com/">success</a>,
7 # <a href="http://www.bob.com/plasma">experiments</a>,
8 # <a href="http://www.boogabooga.net/">BoogaBooga</a>]
9
10 linksToBob = SoupStrainer('a', href=re.compile('bob.com/'))
11 [tag for tag in BeautifulSoup(doc, parseOnlyThese=linksToBob)]
12 # [<a href="http://www.bob.com/">success</a>,
13 # <a href="http://www.bob.com/plasma">experiments</a>]
14
15 mentionsOfBob = SoupStrainer(text=re.compile("Bob"))
16 [text for text in BeautifulSoup(doc, parseOnlyThese=mentionsOfBob)]
17 # [u'Bob reports ', u"Don't get any on\nus, Bob!"]
18
19 allCaps = SoupStrainer(text=lambda(t):t.upper()==t)
20 [text for text in BeautifulSoup(doc, parseOnlyThese=allCaps)]
21 # [u'. ', u'\n', u'WEB MADNESS?']
Между передачей SoupStrainer в метод поиска и его передачей в конструктор супа имеется одно существенное отличие. Припомним, что аргумент name может принимать значение функции с объектом Tag в качестве аргумента. Для аргумента SoupStrainer'а name это сделать нельзя, поскольку SoupStrainer используется для решения: будет или нет вообще создан объект Tag. В аргумент SoupStrainer'а name можно передать функцию, но не объект Tag: можно передать только имя тега и таблицу аргументов.
Улучшаем использование памяти при помощи extract
Когда Beautiful Soup разбирает документ, то он загружает в память большие, сильно связанные структуры данных. Можно решить, что если необходимо найти строку в этой структуре данных, то достаточно просто вытащить строку и оставить остальное для уборки мусора. Все несколько сложнее. Эта строка является объектом NavigableString. Который имеет элемент parent, указывающий на объект Tag, который в свою очередь указывает на другие объекты Tag и так далее. Поэтому для того, чтобы иметь в распоряжении любую часть дерева, необходимо всю ее хранить в памяти.
Метод extract разрывает эти связи. Если вызвать extract для искомой строки, то она будет оторвана от остального дерева синтаксического разбора. После этого остальное дерево может выйти за пределы видимости и будет удалено из памяти при сборке мусора до тех пор, пока вы используете строку для чего-нибудь еще. Если вам необходим небольшой фрагмент дерева, вы можете вызывать extract для самого верхнего объекта Tag и позволить убрать из памяти остальное дерево при сборке мусора.
И наоборот. Если имеется большой фрагмент документа, не нужный вам, то можно вызвать extract для его извлечения из дерева, а затем удалить из памяти с помощью уборки мусора, удерживая в то же время контроль над (меньшим) деревом.
Если extract не устраивает вас, можете попробовать Tag.decompose. Она более медленная чем extract, но более совершенная. Она рекурсивно разбирает Tag и его содержимое, отсоединяя каждую часть дерева ото всех других частей.
Если вы обнаружите, что заняты удалением больших фрагментов дерева, то вы можете сэкономить время, если сразу исключите из разбора часть дерева.
Смотрите также
Приложения, использующие Beautiful Soup
Многие реальные приложения используют Beautiful Soup. Здесь приведены общедоступные приложения, которые я знаю:
Scrape 'N' Feed разработан для работы с Beautiful Soup, чтобы создавать RSS потоки для сайтов, которые их не имеют.
htmlatex использует Beautiful Soup для поиска выражений LaTeX и формирования их графического представления.
chmtopdf конвертирует CHM-файлы в PDF формат. Кто я чтобы спорить с этим?
Duncan Gough в Fotopic backup использует Beautiful Soup для скачивания (scrape) веб-сайта Fotopic.
Iñigo Serna в googlenews.py использует Beautiful Soup для скачивания (scrape) Google News (см. функции parse_entry и parse_category).
Сайт Weather Office Screen Scraper использует Beautiful Soup для скачивания (scrape) Государственного метеорологического сайта Канады (Canadian government's weather office site).
News Clues использует Beautiful Soup для синтаксического разбора RSS потоков.
BlinkFlash использует Beautiful Soup для автоматизации форм подписки на онлайновые сервисы.
Программа linky использует Beautiful Soup для поиска ссылок и изображений на странице, которые нужно проверить.
Matt Croydon заставил работать Beautiful Soup версии 1.x на своем смартфоне Nokia на платформе Series 60. C.R. Sandeep, используя Beautiful Soup, написал работающий на платформе Series 60 в реальном времени конвертер валют, но он не хочет показать нам как он это сделал.
Небольшой скрипт с jacobian.org для исправления метаданных в музыкальных файлах, скачанных с сайта allofmp3.com.
Сайт Python Community Server использует Beautiful Soup в своем детекторе спама.
Похожие библиотеки
Я нашел несколько других парсеров на разных языках программирования, которые могут работать с поврежденной разметкой, обходить дерево или делать еще что-нибудь сверх того, что может ваш стандартный парсер.
Я портировал Beautiful Soup на Ruby. Результат называется Rubyful Soup.
Hpricot платит за использование Rubyful Soup.
ElementTree - быстрый парсер поврежденных файлов XML на Python. Мне он понравился.
Tag Soup - XML/HTML парсер, написанный на Java, который переписывает поврежденный HTML файл в виде, доступном для синтаксического разбора HTML.
HtmlPrag - библиотека языка программирования Scheme для синтаксического разбора поврежденных HTML.
xmltramp - отличная реализация парсера файлов XML/XHTML, сравнимая со ‘стандартными’. Как и большинство парсеров он позволяет обходить дерево разбора, но использовать его проще.
pullparser включает в себя метод обхода дерева разбора (tree-traversal method).
Mike Foord не понравилось, как Beautiful Soup изменяет HTML когда записывает его обратно, и он написал HTML Scraper. Основываясь на HTMLParser, он способен обрабатывать поврежденный HTML. Может быть, после выхода Beautiful Soup 3.0 он устареет, но в этом я не уверен.
Ka-Ping Yee в своем скрипте scrape.py сочетает скачивание с открытием URL.
Заключение
Вот и все! Наслаждайтесь! Я написал Beautiful Soup чтобы сэкономить вам время. Однажды воспользовавшись им вы будете способны в течение всего нескольких минут отстоять в споре выходные данные плохо спроектированных веб-сайтов. Присылайте мне по электропочте свои комментарии, описания возникающих при работе проблем или просто сообщите мне о вашем проекте с применением Beautiful Soup.