Python HTML解析器BeautifulSoup(爬蟲解析器)

時間 2019-11-08

標籤 python html 解析 beautifulsoup 爬蟲欄目 Python 简体版

原文原文鏈接

BeautifulSoup簡介

　　咱們知道，Python擁有出色的內置HTML解析器模塊——HTMLParser，然而還有一個功能更爲強大的HTML或XML解析工具——BeautifulSoup（美味的湯），它是一個第三方庫。簡單來講，BeautifulSoup最主要的功能是從網頁抓取數據。本文咱們來感覺一下BeautifulSoup的優雅而強大的功能吧！html

BeautifulSoup安裝

　　BeautifulSoup3 目前已經中止開發，推薦在如今的項目中使用BeautifulSoup4，不過它已經被移植到bs4了，也就是說導入時咱們須要 import bs4 。能夠利用 pip 或者 easy_install 兩種方法來安裝。下面採用pip安裝。node

　　pip install beautifulsoup4python

　　pip install lxml
正則表達式

　　建議同時安裝"lxml"模塊，BeautifulSoup支持Python標準庫中的HTML解析器（HTMLParser），還支持一些第三方的解析器，若是咱們不安裝它，則 Python 會使用 Python默認的解析器，lxml 解析器更增強大，速度更快，推薦安裝。express

建立對象

　　安裝後，建立對象：soup = BeautifulSoup(markup='html文件', 'lxml')函數

　　格式化輸出：soup.prettify()工具

BeautifulSoup四大對象類型

　　BeautifulSoup將複雜HTML文檔轉換成一個複雜的樹形結構,每一個節點都是Python對象,全部對象能夠概括爲4種：spa

BeautifulSoup（文檔）
Tag（標籤）
NavigableString（內容）
Comment（註釋）

1.BeautifulSoup類型（文檔）

　　BeautifulSoup對象表示的是一個文檔的所有內容：code

print soup.name 
# [document]

2.Tag類型（標籤）

　　即HTML的整個標籤，如獲取<title>標籤：orm

print soup.title
#<title>The Dormouse's story</title>

　　Tag有兩個重要屬性：name，attrs。

name

　　即HTML的標籤名稱：

print soup.name
#[document]
print soup.head.name
#head

attrs

　　即HTML的標籤屬性字典：

print soup.p.attrs
#{'class': ['title'], 'name': 'dromouse'}

　　若是想要單獨獲取某個屬性：

print soup.p['class']
#['title']

3.NavigableString類型（內容）

　　既然咱們已經獲得了整個標籤，那麼問題來了，咱們要想獲取標籤內部的文字內容怎麼辦呢？很簡單，用 string 便可：

print soup.p.string
#The Dormouse's story

4.Comment類型（註釋）

　　HTML的註釋內容，注意的是，不包含註釋符號。咱們首先判斷它的類型，是否爲 Comment 類型，而後再進行其餘操做，如打印輸出：

if type(soup.a.string)==bs4.element.Comment:
    print soup.a.string
#<!-- Elsie -->

遍歷文檔樹

1.子節點

　　獲取全部子節點，返回列表：

print soup.head.contents 
#[<title>The Dormouse's story</title>]

children

　　獲取全部子節點，返回列表生成器：

print soup.head.children
#<listiterator object at 0x7f71457f5710>

## 須要遍歷
for child in  soup.body.children:
    print child

## 結果
<p class="title" name="dromouse"><b>The Dormouse's story</b></p>

<p class="story">Once upon a time there were three little sisters; and their names were
<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>,
<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a> and
<a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>


<p class="story">...</p>

2.節點內容

string

　　返回單個文本內容。若是一個標籤裏面沒有標籤了，那麼 string 就會返回標籤裏面的內容。若是標籤裏面只有惟一的一個標籤了，那麼 string 也會返回最裏面的內容。若是tag包含了多個子節點,tag就沒法肯定，string 方法應該調用哪一個子節點的內容，string 的輸出結果是 None。例如：

print soup.head.string
print soup.title.string
#The Dormouse's story
#The Dormouse's story

print soup.html.string
# None

strings

　　返回多個文本內容，且包含空行和空格。

stripped_strings

　　返回多個文本內容，且不包含空行和空格：

for string in soup.stripped_strings:
    print(repr(string))
    # u"The Dormouse's story"
    # u"The Dormouse's story"
    # u'Once upon a time there were three little sisters; and their names were'
    # u'Elsie'
    # u','
    # u'Lacie'
    # u'and'
    # u'Tillie'
    # u';\nand they lived at the bottom of a well.'
    # u'...'

get_text()方法

　　返回當前節點和子節點的文本內容。

from bs4 import BeautifulSoup

html_doc = """
<html><head><title>The Dormouse's story</title></head>
<body>
    <p class="title"><b>The Dormouse's story</b></p>
    <p class="story">Once upon a time there were three little sisters; and their names were
        <a href="http://example.com/elsie" class="sister1" id="link1">Elsie</a>,
        <a href="http://example.com/lacie" class="sister2" id="link2">Lacie</a> and
        <a href="http://example.com/tillie" class="sister3" id="link3">Tillie</a>;
        and they lived at the bottom of a well.
    </p>
    <p class="story">...</p>
</body>
</html>
"""

soup = BeautifulSoup(markup=html_doc,features='lxml')

node_p_text=soup.find('p',class_='story').get_text()　　　　# 注意class_帶下劃線 print(node_p_text)

# 結果
Once upon a time there were three little sisters; and their names were
        Elsie,
        Lacie and
        Tillie;
        and they lived at the bottom of a well.

3.父節點

parent

　　返回某節點的直接父節點：

p = soup.p
print p.parent.name
#body

parents

　　返回某節點的全部父輩及以上輩的節點：

content = soup.head.title.string
for parent in  content.parents:
    print parent.name

## 結果
title
head
html
[document]

4.兄弟節點

next_sibling

　　next_sibling 屬性獲取該節點的下一個兄弟節點，結果一般是字符串或空白，由於空白或者換行也能夠被視做一個節點。

previous_sibling

　　previous_sibling 屬性獲取該節點的上一個兄弟節點。

print soup.p.next_sibling
#       實際該處爲空白
print soup.p.prev_sibling
#None   沒有前一個兄弟節點，返回 None
print soup.p.next_sibling.next_sibling
#<p class="story">Once upon a time there were three little sisters; and their names were
#<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>,
#<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a> and
#<a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>;
#and they lived at the bottom of a well.</p>
#下一個節點的下一個兄弟節點是咱們能夠看到的節點

next_siblings、previous_siblings

　　迭代獲取所有兄弟節點。

5.先後節點

next_element、previous_element

　　不是針對於兄弟節點，而是在於全部節點，不分層次的前一個和後一個節點。

next_elements、previous_elements

　　迭代獲取全部前和後節點。

搜索文檔樹

1.find_all(name=None, attrs={}, recursive=True, text=None, limit=None, **kwargs)

　　find_all()方法搜索當前tag的全部tag子節點，並判斷是否符合過濾器的條件。

參數說明

name參數

　　name參數很強大，能夠傳多種方式的參數，查找全部名字爲 name 的tag，字符串對象會被自動忽略掉。

（a）傳標籤名

　　最簡單的過濾器是標籤名。在搜索方法中傳入一個標籤名參數，BeautifulSoup會查找與標籤名完整匹配的內容，下面的例子用於查找文檔中全部的<a>標籤：

print soup.find_all('a')
#[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

　　返回結果列表中的元素仍然是BeautifulSoup對象。

（b）傳正則表達式

　　若是傳入正則表達式做爲參數，BeautifulSoup會經過正則表達式的 match() 來匹配內容。下面例子中找出全部以b開頭的標籤,這表示<body>和<b>標籤都應該被找到：

import re
for tag in soup.find_all(re.compile("^b")):
    print(tag.name)
# body
# b

（c）傳列表

　　若是傳入列表參數，BeautifulSoup會將與列表中任一元素匹配的內容返回。下面代碼找到文檔中全部<a>標籤和<b>標籤：

soup.find_all(["a", "b"])
# [<b>The Dormouse's story</b>,
#  <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

（d）傳True

　　True 能夠匹配任何值，下面代碼查找到全部的tag，可是不會返回字符串節點：

for tag in soup.find_all(True):
    print(tag.name)
# html
# head
# title
# body
# p
# b
# p
# a
# a

（e）傳函數

　　若是沒有合適過濾器，那麼還能夠定義一個方法，方法只接受一個元素參數。若是這個方法返回 True 表示當前元素匹配而且被找到，若是不是則反回 False：

def has_class_but_no_id(tag):
    return tag.has_attr('class') and not tag.has_attr('id')

soup.find_all(has_class_but_no_id)
# [<p class="title"><b>The Dormouse's story</b></p>,
#  <p class="story">Once upon a time there were...</p>,
#  <p class="story">...</p>]

keyword參數

　　注意的是，若是一個指定名字的參數不是搜索內置的參數名，搜索時會把該參數看成指定名字tag的屬性來搜索，若是包含一個名字爲 id 的參數,BeautifulSoup會搜索每一個tag的」id」屬性：

soup.find_all(id='link2')
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

　　若是傳入 href 參數，Beautiful Soup會搜索每一個tag的"href"屬性：

soup.find_all(href=re.compile("elsie"))
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]

　　使用多個指定名字的參數能夠同時過濾tag的多個屬性:

soup.find_all(href=re.compile("elsie"), id='link1')
# [<a class="sister" href="http://example.com/elsie" id="link1">three</a>]

　　在這裏咱們想用 class 過濾，不過 class 是 python 的關鍵詞，這怎麼辦？加個下劃線就能夠：

soup.find_all("a", class_="sister")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

attrs參數

　　有些tag屬性在搜索不能使用,好比HTML5中的 " data-* " 自定義屬性：

data_soup = BeautifulSoup('<div data-foo="value">foo!</div>')
data_soup.find_all(data-foo="value")
# SyntaxError: keyword can't be an expression

## 可是能夠經過 find_all() 方法的 attrs 參數定義一個字典參數來搜索包含特殊屬性的tag
data_soup.find_all(attrs={"data-foo": "value"})
# [<div data-foo="value">foo!</div>]

text參數

　　經過 text 參數能夠搜搜文檔中的字符串內容。與 name 參數的可選值同樣，text 參數接受字符串、正則表達式、列表、True。

soup.find_all(text="Elsie")
# [u'Elsie']

soup.find_all(text=["Tillie", "Elsie", "Lacie"])
# [u'Elsie', u'Lacie', u'Tillie']

soup.find_all(text=re.compile("Dormouse"))　　# 模糊查找
[u"The Dormouse's story", u"The Dormouse's story"]

limit參數

　　find_all() 方法返回所有的搜索結構，若是文檔樹很大那麼搜索會很慢。若是咱們不須要所有結果，可使用 limit 參數限制返回結果的數量。效果與SQL中的limit關鍵字相似，當搜索到的結果數量達到 limit 的限制時，就中止搜索返回結果。

soup.find_all("a", limit=2)
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

recursive參數

　　調用tag的 find_all() 方法時，BeautifulSoup會檢索當前tag的全部子孫節點，若是隻想搜索tag的直接子節點，可使用參數 recursive=False。

soup.html.find_all("title")
# [<title>The Dormouse's story</title>]

soup.html.find_all("title", recursive=False)
# []

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

　　它與 find_all() 方法惟一的區別是 find_all() 方法的返回結果是值包含一個元素的列表，而 find() 方法直接返回結果。

3.find_parents() 和 find_parent()

　　find_all() 和 find() 只搜索當前節點的全部子節點，孫子節點等。find_parents() 和 find_parent() 用來搜索當前節點的父輩節點，搜索方法與普通tag的搜索方法相同，搜索文檔搜索文檔包含的內容。

4.find_next_siblings() 和 find_next_sibling()　　

　　這2個方法經過 .next_siblings 屬性對當 tag 的全部後面解析的兄弟 tag 節點進行迭代， find_next_siblings() 方法返回全部符合條件的後面的兄弟節點，find_next_sibling() 只返回符合條件的後面的第一個tag節點。

5.find_previous_siblings() 和 find_previous_sibling()

　　這2個方法經過 .previous_siblings 屬性對當前 tag 的前面解析的兄弟 tag 節點進行迭代， find_previous_siblings() 方法返回全部符合條件的前面的兄弟節點，find_previous_sibling() 方法返回第一個符合條件的前面的兄弟節點。

6.find_all_next() 和 find_next()

　　這2個方法經過 .next_elements 屬性對當前 tag 的以後的 tag 和字符串進行迭代， find_all_next() 方法返回全部符合條件的節點， find_next() 方法返回第一個符合條件的節點。

7.find_all_previous() 和 find_previous()

　　這2個方法經過 .previous_elements 屬性對當前節點前面的 tag 和字符串進行迭代，find_all_previous() 方法返回全部符合條件的節點， find_previous()方法返回第一個符合條件的節點。

CSS選擇器

　　咱們在寫 CSS 時，標籤名不加任何修飾，類名前加點，id名前加 #，在這裏咱們也能夠利用相似的方法來篩選元素，用到的方法是 soup.select()，返回類型是 list。

經過標籤名查找

print soup.select('title') 
#[<title>The Dormouse's story</title>]

print soup.select('a')
#[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

print soup.select('b')
#[<b>The Dormouse's story</b>]

經過類名查找

print soup.select('.sister')
#[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

經過 id 名查找

print soup.select('#link1')
#[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>]

組合查找

　　組合查找即和寫 class 文件時，標籤名與類名、id名進行的組合原理是同樣的，例如查找 p 標籤中，id 等於 link1的內容，兩者須要用空格分開。

print soup.select('p #link1')
#[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>]

　　直接子標籤查找：

print soup.select("head > title")
#[<title>The Dormouse's story</title>]

屬性查找

　　查找時還能夠加入屬性元素，屬性須要用中括號括起來，注意屬性和標籤屬於同一節點，因此中間不能加空格，不然會沒法匹配到。

print soup.select('a[class="sister"]')
#[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

print soup.select('a[href="http://example.com/elsie"]')
#[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>]

　　一樣，屬性仍然能夠與上述查找方式組合，不在同一節點的空格隔開，同一節點的不加空格：

print soup.select('p a[href="http://example.com/elsie"]')
#[<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>]

　　以上的 select 方法返回的結果都是列表形式，能夠遍歷形式輸出，而後用 string或get_text() 方法來獲取它的內容：

soup = BeautifulSoup(html, 'lxml')
print type(soup.select('title'))
print soup.select('title')[0].get_text()

for title in soup.select('title'):
    print title.get_text()