Beautiful Soup

http://python.su/static/books/10.1_.jpg

Beautiful Soup - это парсер для синтаксического разбора файлов HTML/XML, написанный на языке программирования Python, который может преобразовать даже неправильную разметку в дерево синтаксического разбора. Он поддерживает простые и естественные способы навигации, поиска и модификации дерева синтаксического разбора. В большинстве случаев он поможет программисту сэкономить часы и дни работы. Написанный на языке программирования Ruby порт называется Rubyful Soup.

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

Содержание

  1. Beautiful Soup
  2. Быстрый старт
  3. Синтаксический разбор документа
    1. Синтаксический разбор HTML
    2. Синтаксический разбор XML
    3. Если это не работает
  4. Beautiful Soup дает тебе Unicode, черт побери
  5. Печать документа
  6. Дерево синтаксического разбора
    1. Атрибуты Tag-ов
  7. Навигация по дереву синтаксического разбора
    1. parent
    2. contents
    3. string
    4. nextSibling и previousSibling
    5. next и previous
    6. Итерации над объектом Tag
    7. Используем имена тегов как элементы
  8. Поиск в дереве синтаксического разбора
    1. Основной метод поиска: findAll(name, attrs, recursive, text, limit, **kwargs)
      1. Поиск класса CSS
      2. Вызов тега подобно вызову findall
    2. find(name, attrs, recursive, text, **kwargs)
    3. Что происходит с элементом first?
  9. Поиск в дереве синтаксического разбора
    1. findNextSiblings(name, attrs, text, limit, **kwargs) и findNextSibling(name, attrs, text, **kwargs)
    2. findPreviousSiblings(name, attrs, text, limit, **kwargs) и findPreviousSibling(name, attrs, text, **kwargs)
    3. findAllNext(name, attrs, text, limit, **kwargs) и findNext(name, attrs, text, **kwargs)
    4. findAllPrevious(name, attrs, text, limit, **kwargs) и findPrevious(name, attrs, text, **kwargs)
    5. findParents(name, attrs, limit, **kwargs) и findParent(name, attrs, **kwargs)
  10. Модификация дерева синтаксического разбора
    1. Изменение значений атрибутов
    2. Удаление элементов
    3. Замена одного элемента на другой
    4. Добавление другого нового элемента
  11. Известные проблемы
    1. Почему Beautiful Soup не может вывести на экран не-ASCII символы, которые я передал ему?
    2. Beautiful Soup потерял данные, которые я ему передал! Почему? ПОЧЕМУ?????
    3. Синтаксическое дерево разбора, построенное классом !BeautifulSoup, меня раздражает!
    4. Beautiful Soup слишком медленно работает!
  12. Дополнительные темы
    1. Генераторы
    2. Другие встроенные парсеры
    3. Настраиваем парсер
    4. Преобразование сущностей
    5. Очистка от плохих данных с помощью регулярных выражений
    6. Наслаждаемся SoupStrainer-ми
    7. Улучшаем производительность за счет синтаксического разбора только части документа
    8. Улучшаем использование памяти при помощи extract
  13. Смотрите также
    1. Приложения, использующие Beautiful Soup
    2. Похожие библиотеки
  14. Заключение

Быстрый старт

Скачать Beautiful Soup можно здесь. Список изменений содержит отличия версии 3.0 от более ранних.

Подключить Beautiful Soup к вашему приложению можно с помощью одной из ниже приведенных строк:

   1 from BeautifulSoup import BeautifulSoup          # Для обработки HTML
   2 from BeautifulSoup import BeautifulStoneSoup     # Для обработки XML
   3 import BeautifulSoup                             # Для обработки и того и другого

Следующий код демонстрирует основные возможности 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, " &lt;p&gt; tags!")
  41 soup.body
  42 # <body>This page used to have <b>two</b> &lt;p&gt; 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 был найден на веб-сайте одной из ведущих веб-компаний.)

   1 from BeautifulSoup import BeautifulSoup
   2 html = """
   3 <html>
   4 <form>
   5  <table>
   6  <td><input name="input1">Row 1 cell 1
   7  <tr><td>Row 2 cell 1
   8  </form> 
   9  <td>Row 2 cell 2<br>This</br> sure is a long cell
  10 </body> 
  11 </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.

   1 from BeautifulSoup import BeautifulSoup
   2 soup = BeautifulSoup("Hello")
   3 soup.contents[0]
   4 # u'Hello'
   5 soup.originalEncoding
   6 # 'ascii'

Вот пример с японским документом в кодировке 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 проверяет кодировки в следующем порядке:

Если Beautiful Soup сможет сделать предположение, то почти всегда оно будет верным. Но для документов без декларации или в неизвестной кодировке он не сможет сделать каких-либо предположений. В таком случае – скорее всего, ошибочно, – будет использоваться кодировка Windows-1252. Вот пример в кодировке EUC-JP, когда предположение Beautiful Soup о кодировке будет ошибочным. (Кроме того, поскольку используется кодировка EUC-JP пример будет работать только под Python 2.4 или если установлен cjkcodecs):

   1 from BeautifulSoup import BeautifulSoup
   2 euc_jp = '\xa4\xb3\xa4\xec\xa4\xcf'
   3 
   4 soup = BeautifulSoup(euc_jp)
   5 soup.originalEncoding
   6 # 'windows-1252'
   7 
   8 str(soup)
   9 # '\xc2\xa4\xc2\xb3\xc2\xa4\xc3\xac\xc2\xa4\xc3\x8f'     # Wrong!

Но если задать кодировку с помощью fromEncoding, то синтаксический разбор документа будет корректным и его можно будет перекодировать в UTF-8 или обратно в – EUC-JP.

   1 soup = BeautifulSoup(euc_jp, fromEncoding="euc-jp")
   2 soup.originalEncoding
   3 # 'windows-1252'
   4 
   5 str(soup)
   6 # '\xe3\x81\x93\xe3\x82\x8c\xe3\x81\xaf'                 # Right!
   7 
   8 soup.__str__(self, 'euc-jp') == euc_jp
   9 # True

Если обрабатывать с помощью 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 &lsquo;SMART QUOTES&rsquo;!'
   6 
   7 str(BeautifulStoneSoup(text))
   8 # 'Deploy the &#x2018;SMART QUOTES&#x2019;!'
   9 
  10 str(BeautifulSoup(text, smartQuotesTo="xml"))
  11 # 'Deploy the &#x2018;SMART QUOTES&#x2019;!'
  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 - только содержимое.

   1 heading = soup.h1
   2 str(heading)
   3 # '<h1>Heading</h1>'
   4 heading.renderContents()
   5 # 'Heading'

При вызове функций __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:

   1 from BeautifulSoup import BeautifulStoneSoup
   2 doc = """<?xml version="1.0" encoding="ISO-Latin-1">Sacr\xe9 bleu!"""
   3 
   4 print BeautifulStoneSoup(doc).prettify()
   5 # <?xml version='1.0' encoding='utf-8'>
   6 # Sacré bleu!

Дерево синтаксического разбора

До сих пор мы рассматривали загрузку и запись документов. Однако, большую часть времени будет приковывать к себе дерево синтаксического разбора: структуры данных 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 был словарем:

   1 firstPTag, secondPTag = soup.findAll('p')
   2 
   3 firstPTag['id']
   4 # u'firstPara'
   5 
   6 secondPTag['id']
   7 # u'secondPara'
   8 
   9 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, можно перемещаться по дереву синтаксического разбора:

   1 soup.head.parent.name
   2 # u'html'
   3 soup.head.parent.parent.__class__.__name__
   4 # 'BeautifulSoup'
   5 soup.parent == None
   6 # True

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").

   1 pTag = soup.p
   2 pTag.contents
   3 # [u'This is paragraph ', <b>one</b>, u'.']
   4 pTag.contents[1].contents
   5 # [u'one']
   6 pTag.contents[0].contents
   7 # AttributeError: 'NavigableString' object has no attribute 'contents'

string

Для вашего удобства сделано так, что в случае, когда тег имеет только один дочерний узел, который является строкой, дочерний узел будет доступен через tag.string точно также как и через tag.contents[0]. В примере выше soup.b.string является объектом NavigableString отображающий Unicode-строку "one". Эта строка содержится в первом объекте <B> Tag дерева синтаксического разбора.

   1 soup.b.string
   2 # u'one'
   3 soup.b.contents[0]
   4 # u'one'

Но soup.p.string равен None, поскольку первый объект <P> Tag в дереве синтаксического разбора имеет более одного дочернего элемента. soup.head.string также равен None, хотя объект <HEAD> Tag имеет только один дочерний элемент, поскольку этот дочерний элемент – Tag (объект <TITLE> Tag), а не объект NavigableString.

   1 soup.p.string == None
   2 # True
   3 soup.head.string == None
   4 # True

nextSibling и previousSibling

Эти элементы позволяют пропускать следующий или предыдущий элемент на этом же уровне дерева синтаксического разбора. В представленном выше документе, элемент nextSibling объекта <HEAD> Tag равен объекту <BODY> Tag, поскольку объект <BODY> Tag является следующим вложенным элементом по отношению к объекту <html> Tag. Элемент nextSibling объекта <BODY> Tag равен None, поскольку в нем больше нет вложенных по отношению к объекту <HTML> Tag элементов.

   1 soup.head.nextSibling.name
   2 # u'body'
   3 soup.html.nextSibling == None
   4 # True

И наоборот, элемент previousSibling объекта <BODY> Tag равен объекту <HEAD> tag, а элемент previousSibling объекта <HEAD> Tag равен None:

   1 soup.body.previousSibling.name
   2 # u'head'
   3 soup.head.previousSibling == None
   4 # True

Несколько примеров: элемент nextSibling первого объекта <P> Tag равен второму объекту <P> Tag. Элемент previousSibling объекта <B> Tag внутри второго объекта <P> Tag равен объекту NavigableString "This is paragraph". Элемент previousSibling данного объекта NavigableString равен None, внутри первого объекта <P> Tag.

   1 soup.p.nextSibling
   2 # <p id="secondpara" align="blah">This is paragraph <b>two</b>.</p>
   3 
   4 secondBTag = soup.findAlll('b')[1]
   5 secondBTag.previousSibling
   6 # u'This is paragraph'
   7 secondBTag.previousSibling.previousSibling == None
   8 # True

next и previous

Данные элементы позволяют передвигаться по элементам документа в том порядке, в котором они были обработаны парсером, а не в порядке появления в дереве. Например, элемент next для объекта <HEAD> Tag равен объекту <TITLE> Tag, а не объекту <BODY> Tag. Это потому, что в исходном документе, тег <TITLE> идет сразу после тега <HEAD>.

   1 soup.head.next
   2 # u'title'
   3 soup.head.nextSibling.name
   4 # u'body'
   5 soup.head.previous.name
   6 # u'html'

Поскольку элементы next и previous связаны, содержимое элемента contents объекта Tag обновляется до того как элемент nextSibling. Как правило, эти элементы не используют, но иногда это наиболее быстрый способ получить что-либо скрытое в глубине дерева синтаксического разбора.

Итерации над объектом Tag

Над элементом contents объекта Tag можно производить итерации, рассматривая его качестве списка. Это полезное упрощение. Подобным образом можно узнать, сколько дочерних узлов имеет объект Tag, вызвав функцию len(tag) вместо len(tag.contents). В терминах документа выше:

   1 for i in soup.body:
   2     print i
   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 len(soup.body)
   7 # 2
   8 len(soup.body.contents)
   9 # 2

Используем имена тегов как элементы

Гораздо легче перемещаться по дереву синтаксического разбора, если в качестве имен тегов выступали элементы парсера или объекта Tag. Будем так делать на протяжении следующих примеров. В терминах документа выше, soup.head возвращает нам первый (как и следовало ожидать, единственный) объекта <HEAD> Tag документа:

   1 soup.head
   2 # <head><title>Page title</title></head>

Вообще, вызов mytag.foo возвратит первого потомка mytag, чем, как ни странно, будет объект <FOO> Tag. Если каких-либо объектов <FOO> Tag внутри mytag нет, то mytag.foo возвратит None. Вы можете использовать это для очень быстрого обхода дерева синтаксического разбора:

   1 soup.head.title
   2 # <title>Page title</title>
   3 
   4 soup.body.p.b.string
   5 # u'one'

Также это можно использовать для быстрого перехода к определенной части дерева синтаксического разбора. Например, если вас не беспокоит отсутствие тегов <TITLE> на предусмотренных для них месте, вы можете просто использовать soup.title для получения названия документа HTML. Вам не нужно использовать soup.head.title:

   1 soup.title.string
   2 # u'Page 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 и именованные аргументы.

Поиск класса 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>

   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 и именованные аргументы игнорируются.

   1 [tag.name for tag in soup.html.findAll()]
   2 # [u'head', u'title', u'body', u'p', u'b', u'p', u'b']
   3 
   4 [tag.name for tag in soup.html.findAll(recursive=False)]
   5 # [u'head', u'body']

Когда аргумент recursive ложен, ищутся только непосредственные потомки тега <HTML>. Если вы знаете, что нужно найти, с помощью этого способа можно сэкономить время.

   1 soup.findAll('p', limit=1)
   2 # [<p id="firstpara" align="center">This is paragraph <b>one</b>.</p>]
   3 
   4 soup.findAll('p', limit=100)
   5 # [<p id="firstpara" align="center">This is paragraph <b>one</b>.</p>, 
   6 #  <p id="secondpara" align="blah">This is paragraph <b>two</b>.</p>]

Вызов тега подобно вызову findall

Небольшое упрощение. Если вызвать объекта парсера или объект Tag как функцию, то можно передать ему все аргументы метода findall и вызывать также как и findall. В терминах документа выше:

   1 soup(text=lambda(x): len(x) < 12)
   2 # [u'Page title', u'one', u'.', u'two', u'.']
   3 
   4 soup.body('p', limit=1)
   5 # [<p id="firstpara" align="center">This is paragraph <b>one</b>.</p>]

find(name, attrs, recursive, text, **kwargs)

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

Метод find почти в точности совпадает с findAll, за исключением того, что он ищет первое вхождение искомого объекта, а не все. Это похоже на установку для результирующего множества limit равным 1 и затем извлечения единственного результата из массива. В терминах документа выше:

   1 soup.findAll('p', limit=1)
   2 # [<p id="firstpara" align="center">This is paragraph <b>one</b>.</p>]
   3 
   4 soup.find('p', limit=1)
   5 # <p id="firstpara" align="center">This is paragraph <b>one</b>.</p>
   6 
   7 soup.find('nosuchtag', limit=1) == None
   8 # True

В общем, когда взглянете на метод поиска с множественными именами (такой, как 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:

   1 from BeautifulSoup import BeautifulSoup
   2 soup = BeautifulSoup('''<ul>
   3  <li>An unrelated list
   4 </ul>
   5 
   6 <h1>Heading</h1>
   7 <p>This is <b>the list you want</b>:</p>
   8 <ul><li>The data you want</ul>''')

Для навигации по тегу <LI>, содержащим необходимые данные, существуют несколько способов. Наиболее очевидный:

   1 soup('li', limit=2)[1]
   2 # <li>The data you want</li>

В равной степени очевидно, что это будет не самым стабильным способом получения этого тега <LI>. Если эта страница скачивается (scraping) единожды это не имеет значения, но если ее предполагается скачивать неоднократно в течение значительного периода времени, такие соображения становятся существенными. Если в несущественный список (irrelevant list) будет вставлен тег <LI>, то вместо искомого тега будет получен этот ненужный тег и работа скрипта прервется или же он выдаст ошибочные данные.

   1 soup('ul', limit=2)[1].li
   2 # <li>The data you want</li>

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

Когда вы смотрите на этот фрагмент HTML, вы думаете о нужном списке примерно так: 'тег <UL>, который идет сразу после тега <H1>'. Проблема состоит в том, что этот тег не содержится внутри тега <H1>; так уж получилось, что он идет после него. Довольно просто перейти к тегу <H1>, но нет способа перейти с этого места к тегу <UL> с помощью first и fetch, поскольку эти методы проверят только элемент contents тега <H1>. Необходимо переместиться к тегу <UL> с помощью элементов next или nextSibling:

   1 s = soup.h1
   2 while getattr(s, 'name', None) != 'ul':
   3     s = s.nextSibling
   4 s.li
   5 # <li>The data you want</li>

Или, если вы считаете это более стабильным:

   1 s = soup.find(text='Heading')
   2 while getattr(s, 'name', None) != 'ul':
   3     s = s.next
   4 s.li
   5 # <li>The data you want</li>

Но для достижения нужной вам цели это слишком сложно. Методы из этого раздела предоставляют полезные упрощения. Ими можно воспользоваться, когда возникает желание написать цикл while над одним из элементов перемещения. Получив начальную точку где-нибудь в дереве, они позволяют перемещаться по дереву в том же направлении и отслеживают объекты Tag или NavigableString, соответствующие заданным критериям. Вместо первого цикла в примере кода выше можно написать:

   1 soup.h1.findNextSibling('ul').li
   2 # <li>The data you want</li>

Вместо второго цикла можно написать так:

   1 soup.find(text='Heading').findNext('ul').li
   2 # <li>The data you want</li>

Циклы заменены вызовами 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, соответствующие заданным критериям. В терминах документа выше:

   1 paraText = soup.find(text='This is paragraph ')
   2 paraText.findNextSiblings('b')
   3 # [<b>one</b>]
   4 
   5 paraText.findNextSibling(text = lambda(text): len(text) == 1)
   6 # u'.'

findPreviousSiblings(name, attrs, text, limit, **kwargs) и findPreviousSibling(name, attrs, text, **kwargs)

Эти методы часто следуют за элементом previousSibling member, gathering <объектов, собирая объекты Tag или NavigableText, соответствующие заданным критериям. В терминах документа выше:

   1 paraText = soup.find(text='.')
   2 paraText.findPreviousSiblings('b')
   3 # [<b>one</b>]
   4 
   5 paraText.findPreviousSibling(text = True)
   6 # u'This is paragraph '

findAllNext(name, attrs, text, limit, **kwargs) и findNext(name, attrs, text, **kwargs)

Эти методы часто следуют за элементом c0>next объектов, собирая объекты Tag или NavigableText, соответствующие заданным критериям. В терминах документа выше:

   1 pTag = soup.find('p')
   2 pTag.findAllNext(text=True)
   3 # [u'This is paragraph ', u'one', u'.', u'This is paragraph ', u'two', u'.']
   4 
   5 pTag.findNext('p')
   6 # <p id="secondpara" align="blah">This is paragraph <b>two</b>.</p>
   7 
   8 pTag.findNext('b')
   9 # <b>one</b>

findAllPrevious(name, attrs, text, limit, **kwargs) и findPrevious(name, attrs, text, **kwargs)

Эти методы часто следуют за элементом previous объектов, собирая объекты Tag или NavigableText, соответствующие заданным критериям. В терминах документа выше:

   1 lastPTag = soup('p')[-1]
   2 lastPTag.findAllPrevious(text=True)
   3 # [u'.', u'one', u'This is paragraph ', u'Page title']
   4 # Note the reverse order!
   5 
   6 lastPTag.findPrevious('p')
   7 # <p id="firstpara" align="center">This is paragraph <b>one</b>.</p>
   8 
   9 lastPTag.findPrevious('b')
  10 # <b>one</b>

findParents(name, attrs, limit, **kwargs) и findParent(name, attrs, **kwargs)

Эти методы часто следуют за элементом parent объектов, собирая объекты Tag или NavigableText, соответствующие заданным критериям. Они не принимают аргумент text, поскольку не может быть объектов, предком которых был бы объект NavigableString. В терминах документа выше:

   1 bTag = soup.find('b')
   2 
   3 [tag.name for tag in bTag.findParents()]
   4 # [u'p', u'body', u'html', '[document]']
   5 # NOTE: "u'[document]'" means that that the parser object itself matched.
   6 
   7 bTag.findParent('body').name
   8 # u'body'

Модификация дерева синтаксического разбора

Теперь вам известно как разыскать что-либо в дереве синтаксического разбора. Но, возможно, вы захотите изменить это что-либо и записать обратно. Можно просто вырезать элемент из 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>

Так же можно удалять значения атрибутов и добавлять новые:

   1 del(b['id'])
   2 print soup
   3 # <b>Argh!</b>
   4 
   5 b['class'] = "extra bold and brassy!"
   6 print soup
   7 # <b class="extra bold and brassy!">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 разъединяет синтаксическое дерево разбора на два несвязанных дерева. Элементы навигации изменяются таким образом, что все выглядит так, будто деревья никогда не были одним целым:

   1 soup.a1.nextSibling
   2 # <a2></a2>
   3 soup.a2.previousSibling
   4 # <a1></a1>
   5 subtree.previousSibling == None
   6 # True
   7 subtree.parent == None
   8 # True

Замена одного элемента на другой

Метод 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!']

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

   1 from BeautifulSoup import BeautifulSoup, Tag
   2 soup = BeautifulSoup("<b>Argh!<a>Foo</a></b><i>Blah!</i>")
   3 tag = Tag(soup, "newTag", [("id", 1)])
   4 tag.insert(0, "Hooray!")
   5 soup.a.replaceWith(tag)
   6 print soup
   7 # <b>Argh!<newTag id="1">Hooray!</newTag></b><i>Blah!</i>

Можно даже вырезать элемент из одного места документа и вставить в другое:

   1 from BeautifulSoup import BeautifulSoup
   2 text = "<html>There's <b>no</b> business like <b>show</b> business</html>"
   3 soup = BeautifulSoup(text)
   4 
   5 no, show = soup.findAll('b')
   6 show.replaceWith(no)
   7 print soup
   8 # <html>There's  business like <b>no</b> business</html>

Добавление другого нового элемента

Класс 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 во вторую часть супа, но во второй раз он не вставился. Он переместился:

   1 tag2.insert(0, text)
   2 print soup
   3 # <mytag><myOtherTag>Hello!</myOtherTag><myThirdTag></myThirdTag></mytag>

Это произойдет даже если элемент до этого принадлежал принципиально другому объекту супа. У элемента может быть только один 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 и вы столкнетесь с той же проблемой. Например, попробуйте запустить такой код:

   1 latin1word = 'Sacr\xe9 bleu!'
   2 unicodeword = unicode(latin1word, 'latin-1')
   3 print unicodeword

Если он сработает нормально, а при использовании Beautiful Soup все равно выдается сообщение об ошибке – значит ошибка в Beautiful Soup. Однако же если код не работает – проблема с установленным Python. Python выполняет код безопасно и не посылает не-ASCII символы на терминал. Для изменения такого поведения есть два способа.

  1. Легкий способ – переназначить стандартный вывод в конвертер, который не боится отправлять символы ISO-Latin-1 или UTF-8 на терминал.
       1 import codecs
       2 import sys
       3 streamWriter = codecs.lookup('utf-8')[-1]
       4 sys.stdout = streamWriter(sys.stdout)
    

codecs.lookup возвращает количество ограничивающих методов и других объектов, связанных с кодеком. В последней строке объект StreamWriter реализует обертку вокруг потока вывода.

  1. Более сложный способ – в каталоге, где установлен Python, создать файл sitecustomize.py, который установит кодировкой по умолчанию ISO-Latin-1 или UTF-8. В этом случае все ваши программы на Python будут использовать эту кодировку для стандартного вывода, не требуя ничего менять в каждой программе.. В моем случае имеется файл /usr/lib/python/sitecustomize.py, который выглядит так:
    •    1 import sys
         2 sys.setdefaultencoding("utf-8")
      

За дополнительной информацией о поддержке 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:

Синтаксическое дерево разбора, построенное классом !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).

   1 ''.join(soup.findAll(text=True))
   2 # u'You bet\nBeautifulSoup\nrocks!'

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

   1 from BeautifulSoup import BeautifulSoup
   2 soup = BeautifulSoup("1<a>2<b>3")
   3 g = soup.recursiveChildGenerator()
   4 while True:
   5     try:
   6         print g.next()
   7     except StopIteration:
   8         break
   9 # 1
  10 # <a>2<b>3</b></a>
  11 # 2
  12 # <b>3</b>
  13 # 3

Другие встроенные парсеры

Помимо BeautifulSoup и BeautifulStoneSoup в составе Beautiful Soup имеются еще три класса парсеров:

С помощью 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> придется удалять со стека какие-либо теги.

   1 from BeautifulSoup import BeautifulSoup
   2 BeautifulSoup.NESTABLE_TAGS['span']
   3 # []
   4 BeautifulSoup.RESET_NESTING_TAGS.has_key('span')
   5 # False
   6 
   7 print BeautifulSoup("<html><span>Span<b>one<span>Span two")
   8 # <html><span>Span<b>one<span>Span two</span></b></span></html>

Третий пример: предположим, что стек выглядит так ['ol','li','ul']: т.е. мы получим упорядоченный список, первый элемент которого содержит неупорядоченный список. Теперь предположим, что Beautiful Soup встретил тег <LI>. Это не приведет к удалению со стека первого тега <LI>, т.к. новый тег <LI> является часть неупорядоченного подсписка. С тегом <LI> внутри другого тега <LI> все в порядке до тех пор, пока встречается теги <UL> или <OL>.

   1 from BeautifulSoup import BeautifulSoup
   2 print BeautifulSoup("<ol><li>1<ul><li>A").prettify()
   3 # <ol>
   4 #  <li>
   5 #   1
   6 #   <ul>
   7 #    <li>
   8 #     A
   9 #    </li>
  10 #   </ul>
  11 #  </li>
  12 # </ol>

Но если не встретится <UL> или <OL>, то один тег <LI> не может быть внутри другого:

   1 print BeautifulSoup("<ol><li>1<li>A").prettify()
   2 # <ol>
   3 #  <li>
   4 #   1
   5 #  </li>
   6 #  <li>
   7 #   A
   8 #  </li>
   9 # </ol>

Сообщим Beautiful Soup о том, чтобы он трактовал теги <LI> поместив "li" в RESET_NESTING_TAGS, и передавая "li" в элемент NESTABLE_TAGS, чтобы показать список тегов, в которые он может быть вложен.

   1 BeautifulSoup.RESET_NESTING_TAGS.has_key('li')
   2 # True
   3 BeautifulSoup.NESTABLE_TAGS['li']
   4 # ['ul', 'ol']

Таким же образом мы обрабатываем вложенность тегов таблиц:

   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.

   1 from BeautifulSoup import BeautifulStoneSoup
   2 BeautifulStoneSoup("Sacr&eacute; bl&#101;u!", 
   3                    convertEntities=BeautifulStoneSoup.HTML_ENTITIES).contents[0]
   4 # u'Sacr\xe9 bleu!'

Это если вы используете HTML_ENTITIES (который является только строкой "html"). Если используется XML_ENTITIES (или строка "xml"), , то только числовые сущности и пять XML сущностей (""", "'", ">", "<", and "&") будут конвертированы. Если используется ALL_ENTITIES (или список ["xml", "html"]), то оба вида сущностей будут конвертированы Последний случай необходим, поскольку ' - сущность XML, а не HTML.

   1 BeautifulStoneSoup("Sacr&eacute; bl&#101;u!", 
   2                    convertEntities=BeautifulStoneSoup.XML_ENTITIES)
   3 # Sacr&eacute; bleu!
   4 
   5 from BeautifulSoup import BeautifulStoneSoup
   6 BeautifulStoneSoup("Il a dit, &lt;&lt;Sacr&eacute; bl&#101;u!&gt;&gt;", 
   7                    convertEntities=BeautifulStoneSoup.XML_ENTITIES)
   8 # Il a dit, <<Sacr&eacute; bleu!>>

Если вы сообщите Beautiful Soup о необходимости конвертировать XML- или HTML-сущности в соответствующие символы Unicode, то символы Windows-1252 (такие как изящные кавычки Microsoft) также будут трансформированы в символы Unicode. Это произойдет даже если сообщить Beautiful Soup о конвертировании этих символов в сущности.

   1 from BeautifulSoup import BeautifulStoneSoup
   2 smartQuotesAndEntities = "Il a dit, \x8BSacr&eacute; bl&#101;u!\x9b"
   3 
   4 BeautifulStoneSoup(smartQuotesAndEntities, smartQuotesTo="html").contents[0]
   5 # u'Il a dit, &lsaquo;Sacr&eacute; bl&#101;u!&rsaquo;'
   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&eacute; bleu!\u203a'

Пока вы заняты преобразованием всех имеющихся сущностей в символы Unicode, создавать новые HTML/XML сущности не имеет смысла.

Очистка от плохих данных с помощью регулярных выражений

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

По умолчанию Beautiful Soup использует регулярные выражения и функции замены для выполнения поиска и замены в исходных документах. Он находит самозакрывающиеся теги, такие как <BR/>, и изменяет их на такие <BR />. Он находит декларации, содержащие внешние пробелы, такие как <! --Comment-->, и удаляет из них пробелы: <!--Comment-->.

Если имеется плохая разметка, для исправления которой требуются другие методы, вы можете передать свой список кортежей вида (regular expression, replacement function) в конструктора супа как аргумент markupMassage.

Давайте рассмотрим пример: страница имеет деформированный комментарий. Базовый парсер SGML не справился и пропустил комментарий со всем, что было после него:

   1 from BeautifulSoup import BeautifulSoup
   2 badString = "Foo<!-This comment is malformed.-->Bar<br/>Baz"
   3 BeautifulSoup(badString)
   4 # Foo

Давайте исправим это с помощью регулярных выражений и функции:

   1 import re
   2 myMassage = [(re.compile('<!-([^-])'), lambda match: '<!--' + match.group(1))]
   3 BeautifulSoup(badString, markupMassage=myMassage)
   4 # Foo<!--This comment is malformed.-->Bar

Ой, мы к тому же пропустили тег <BR>. Наш аргумент markupMassage поменял манипуляцию парсера по умолчанию, так что функция поиска и замены по умолчанию не выполнялась. Парсер сделал это, пропустив комментарий, но деформированный самозакрывающийся тег вывел его из строя. Давайте добавим свою функцию манипулирования данными в список умолчаний, а затем выполним все функции.

   1 import copy
   2 myNewMassage = copy.copy(BeautifulSoup.MARKUP_MASSAGE)
   3 myNewMassage.extend(myMassage)
   4 BeautifulSoup(badString, markupMassage=myNewMassage)
   5 # Foo<!--This comment is malformed.-->Bar<br />Baz

Теперь мы получили все.

Если вы уверены в том, что разметка не нуждается в применении регулярных выражений, вы можете ускорить время запуска передав значение 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 в любой поисковый метод:

   1 xmlSoup.findAll(results.source) == results
   2 # True
   3 
   4 customStrainer = BeautifulSoup.SoupStrainer(rel='mother')
   5 xmlSoup.findAll(customStrainer) == results
   6 #  True

Не велика важность, не правда ли? Можно передать аргументы в метод и другими способами. Но с другой стороны 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: можно передать только имя тега и таблицу аргументов.

   1 shortWithNoAttrs = SoupStrainer(lambda name, attrs: \
   2                                 len(name) == 1 and not attrs)
   3 [tag for tag in BeautifulSoup(doc, parseOnlyThese=shortWithNoAttrs)]
   4 # [<i>Don't get any on us, Bob!</i>, 
   5 #  <b>WEB MADNESS?</b>]

Улучшаем использование памяти при помощи extract

Когда Beautiful Soup разбирает документ, то он загружает в память большие, сильно связанные структуры данных. Можно решить, что если необходимо найти строку в этой структуре данных, то достаточно просто вытащить строку и оставить остальное для уборки мусора. Все несколько сложнее. Эта строка является объектом NavigableString. Который имеет элемент parent, указывающий на объект Tag, который в свою очередь указывает на другие объекты Tag и так далее. Поэтому для того, чтобы иметь в распоряжении любую часть дерева, необходимо всю ее хранить в памяти.

Метод extract разрывает эти связи. Если вызвать extract для искомой строки, то она будет оторвана от остального дерева синтаксического разбора. После этого остальное дерево может выйти за пределы видимости и будет удалено из памяти при сборке мусора до тех пор, пока вы используете строку для чего-нибудь еще. Если вам необходим небольшой фрагмент дерева, вы можете вызывать extract для самого верхнего объекта Tag и позволить убрать из памяти остальное дерево при сборке мусора.

И наоборот. Если имеется большой фрагмент документа, не нужный вам, то можно вызвать extract для его извлечения из дерева, а затем удалить из памяти с помощью уборки мусора, удерживая в то же время контроль над (меньшим) деревом.

Если extract не устраивает вас, можете попробовать Tag.decompose. Она более медленная чем extract, но более совершенная. Она рекурсивно разбирает Tag и его содержимое, отсоединяя каждую часть дерева ото всех других частей.

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

Смотрите также

Приложения, использующие Beautiful Soup

Многие реальные приложения используют Beautiful Soup. Здесь приведены общедоступные приложения, которые я знаю:

Похожие библиотеки

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

Заключение

Вот и все! Наслаждайтесь! Я написал Beautiful Soup чтобы сэкономить вам время. Однажды воспользовавшись им вы будете способны в течение всего нескольких минут отстоять в споре выходные данные плохо спроектированных веб-сайтов. Присылайте мне по электропочте свои комментарии, описания возникающих при работе проблем или просто сообщите мне о вашем проекте с применением Beautiful Soup.

Beautiful_Soup (последним исправлял пользователь alafin 2010-05-18 20:10:49)