python beautiful soup庫的用法

阿新 • • 發佈：2019-01-31

1. Beautiful Soup 簡介

簡單來說，Beautiful Soup是python的一個庫，最主要的功能是從網頁抓取資料。官方解釋如下：

Beautiful Soup提供一些簡單的、python式的函式用來處理導航、搜尋、修改分析樹等功能。它是一個工具箱，通過解析文件為使用者提供需要抓取的資料，因為簡單，所以不需要多少程式碼就可以寫出一個完整的應用程式。Beautiful Soup自動將輸入文件轉換為Unicode編碼，輸出文件轉換為utf-8編碼。你不需要考慮編碼方式，除非文件沒有指定一個編碼方式，這時，Beautiful Soup就不能自動識別編碼方式了。然後，你僅僅需要說明一下原始編碼方式就可以了。Beautiful Soup已成為和lxml、html6lib一樣出色的python直譯器，為使用者靈活地提供不同的解析策略或強勁的速度。

2. Beautiful Soup 安裝

Beautiful Soup 3 目前已經停止開發，推薦在現在的專案中使用Beautiful Soup 4，不過它已經被移植到BS4了，也就是說匯入時我們需要 import bs4 。所以這裡我們用的版本是 Beautiful Soup 4.3.2 (簡稱BS4)，另外據說 BS4 對 Python3 的支援不夠好，不過我用的是 Python2.7.7，如果有小夥伴用的是 Python3 版本，可以考慮下載 BS3 版本。

可以利用 pip 或者 easy_install 來安裝，以下兩種方法均可

easy_install beautifulsoup4
pip install beautifulsoup4

如果想安裝最新的版本，請直接下載安裝包來手動安裝，也是十分方便的方法。下載完成之後解壓，執行下面的命令即可完成安裝

sudo python setup.py install

然後需要安裝 lxml

easy_install lxml
pip install lxml

另一個可供選擇的解析器是純Python實現的 html5lib , html5lib的解析方式與瀏覽器相同,可以選擇下列方法來安裝html5lib:

easy_install html5lib
pip install html5lib

Beautiful Soup支援Python標準庫中的HTML解析器,還支援一些第三方的解析器，如果我們不安裝它，則 Python 會使用 Python預設的解析器，lxml 解析器更加強大，速度更快，推薦安裝。

解析器	使用方法	優勢	劣勢
Python標準庫	BeautifulSoup(markup, “html.parser”)	Python的內建標準庫執行速度適中文件容錯能力強	Python 2.7.3 or 3.2.2)前的版本中文件容錯能力差
lxml HTML 解析器	BeautifulSoup(markup, “lxml”)	速度快文件容錯能力強	需要安裝C語言庫
lxml XML 解析器	BeautifulSoup(markup, [“lxml”, “xml”]) BeautifulSoup(markup, “xml”)	速度快唯一支援XML的解析器	需要安裝C語言庫
html5lib	BeautifulSoup(markup, “html5lib”)	最好的容錯性以瀏覽器的方式解析文件生成HTML5格式的文件	速度慢不依

3. 建立 Beautiful Soup 物件

首先必須要匯入 bs4 庫

from bs4 import BeautifulSoup

我們建立一個字串，後面的例子我們便會用它來演示

html = """
<html><head><title>The Dormouse's story</title></head>
<body>
<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 href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>
<p class="story">...</p>
"""

建立 beautifulsoup 物件

soup = BeautifulSoup(html)

另外，我們還可以用本地 HTML 檔案來建立物件，例如

soup = BeautifulSoup(open('index.html'))

上面這句程式碼便是將本地 index.html 檔案開啟，用它來建立 soup 物件。下面我們來列印一下 soup 物件的內容，格式化輸出

print soup.prettify()

指定編碼：當html為其他型別編碼（非utf-8和asc ii），比如GB2312的話，則需要指定相應的字元編碼，BeautifulSoup才能正確解析。

htmlCharset = "GB2312"
soup = BeautifulSoup(respHtml, fromEncoding=htmlCharset)

BeautifulSoup 使用示例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
from bs4 import BeautifulSoup
import re

#待分析字串
html_doc = """
<html>
<head>
    <title>The Dormouse's story</title>
</head>
<body>
<p class="title aq">
    <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="sister" id="link1">Elsie</a>,
    <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> 
    and
    <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
    and they lived at the bottom of a well.
</p>
<p class="story">...</p>
"""


soup = BeautifulSoup(html_doc, 'html.parser', from_encoding='utf-8')   # 使用 html字串 建立 BeautifulSoup物件
print soup.title              # 輸出第一個 title 標籤
print soup.title.name         # 輸出第一個 title 標籤 的 標籤名稱
print soup.title.string       # 輸出第一個 title 標籤 的 包含內容
print soup.title.parent.name  # 輸出第一個 title 標籤的父標籤的標籤名稱
print soup.p                  # 輸出第一個  p 標籤
print soup.p['class']         # 輸出第一個  p 標籤的 class 屬性內容
print soup.a['href']          # 輸出第一個  a 標籤的  href 屬性內容

'''
soup的屬性可以被新增,刪除或修改. 再說一次, soup的屬性操作方法與字典一樣
'''
dasd
soup.a['href'] = 'http://www.baidu.com/'    # 修改第一個 a 標籤的href屬性為 http://www.baidu.com/
soup.a['name'] = u'百度'                    # 給第一個 a 標籤新增 name 屬性
del soup.a['class']                         # 刪除第一個 a 標籤的 class 屬性為

print soup.p.contents          # 輸出第一個  p 標籤的所有子節點
print soup.a                   # 輸出第一個  a 標籤

print soup.find_all('a')       # 輸出所有的  a 標籤，以列表形式顯示
print soup.find(id="link3")    # 輸出第一個 id 屬性等於  link3 的  a 標籤
ul = soup.find('ul', attrs={'class':'country'})
print ul
print ul.find('li')            # returns just the first match

print(soup.get_text())        # 獲取所有文字內容

print soup.a.attrs            # 輸出第一個  a 標籤的所有屬性資訊

for link in soup.find_all('a'):    
    print(link.get('href'))    # 獲取 link 的  href 屬性內容


# 對 soup.p 的子節點進行迴圈輸出    
for child in soup.p.children:
    print(child)

#正則匹配，名字中帶有b的標籤
for tag in soup.find_all(re.compile("b")):
    print(tag.name)

import bs4 # 匯入BeautifulSoup庫
Soup = BeautifulSoup(html) # 其中html 可以是字串，也可以是控制代碼

需要注意的是，BeautifulSoup會自動檢測傳入檔案的編碼格式，然後轉化為Unicode格式。通過如上兩句話，BS自動把文件生成為如上圖中的解析樹。

使用示例2：

# -*- coding: utf-8 -*-

import urllib2
from bs4 import BeautifulSoup

def scrape(html):
    soup = BeautifulSoup(html) 
    tr = soup.find(attrs={'id':'places_area__row'}) # locate the area row
    # 'class' is a special python attribute so instead 'class_' is used
    td = tr.find(attrs={'class':'w2p_fw'})  # locate the area tag
    area = td.text  # extract the area contents from this tag
    return area

if __name__ == '__main__':
    html = urllib2.urlopen('http://example.webscraping.com/view/United-Kingdom-239').read()
    print scrape(html)

4. 四大物件種類

Beautiful Soup將複雜HTML文件轉換成一個複雜的樹形結構,每個節點都是Python物件,所有物件可以歸納為4種:

1. Tag
2. NavigableString
3. BeautifulSoup
4. Comment

（1）Tag

Tag 是什麼？通俗點講就是 HTML 中的一個個標籤，例如

<title>The Dormouse's story</title>
<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>

上面的 title a 等等 HTML 標籤加上裡面包括的內容就是 Tag，下面我們來感受一下怎樣用 Beautiful Soup 來方便地獲取 Tags

下面每一段程式碼中註釋部分即為執行結果

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

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

print soup.a
#<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>

print soup.p
#<p class="title" name="dromouse"><b>The Dormouse's story</b></p>

利用 soup加標籤名輕鬆地獲取這些標籤的內容，是不是感覺比正則表示式方便多了？不過有一點是，它查詢的是在所有內容中的第一個符合要求的標籤，如果要查詢所有的標籤，我們在後面進行介紹。soup.title 得到的是title標籤，soup.p 得到的是文件中的第一個p標籤，要想得到所有標籤，得用find_all函式。find_all 函式返回的是一個序列，可以對它進行迴圈，依次得到想到的東西.。

我們可以驗證一下這些物件的型別

print type(soup.a)
#<class 'bs4.element.Tag'>

對於 Tag，它有兩個重要的屬性，是 name 和 attrs

name

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

soup 物件本身比較特殊，它的 name 即為 [document]，對於其他內部標籤，輸出的值便為標籤本身的名稱。

attrs

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

在這裡，我們把 p 標籤的所有屬性列印輸出了出來，得到的型別是一個字典。如果我們想要單獨獲取某個屬性，可以這樣，例如我們獲取它的 class 叫什麼

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

還可以這樣，利用get方法，傳入屬性的名稱，二者是等價的

print soup.p.get('class')
#['title']

我們可以對這些屬性和內容等等進行修改，例如

soup.p['class']="newClass"
print soup.p
#<p class="newClass" name="dromouse"><b>The Dormouse's story</b></p>

還可以對這個屬性進行刪除，例如

del soup.p['class']
print soup.p
#<p name="dromouse"><b>The Dormouse's story</b></p>

不過，對於修改刪除的操作，不是我們的主要用途，在此不做詳細介紹了，如果有需要，請檢視前面提供的官方文件

head = soup.find('head')
#head = soup.head
#head = soup.contents[0].contents[0]
print head

html = soup.contents[0]       # <html> ... </html>
head = html.contents[0]       # <head> ... </head>
body = html.contents[1]       # <body> ... </body>

可以通過Tag.attrs訪問，返回字典結構的屬性。

或者Tag.name這樣訪問特定屬性值，如果是多值屬性則以列表形式返回。

（2）NavigableString

既然我們已經得到了標籤的內容，那麼問題來了，我們要想獲取標籤內部的文字怎麼辦呢？很簡單，用 .string 即可，例如

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

這樣我們就輕鬆獲取到了標籤裡面的內容，想想如果用正則表示式要多麻煩。它的型別是一個 NavigableString，翻譯過來叫可以遍歷的字串，不過我們最好還是稱它英文名字吧。來檢查一下它的型別

print type(soup.p.string)
#<class 'bs4.element.NavigableString'>

（3）BeautifulSoup

BeautifulSoup 物件表示的是一個文件的全部內容.大部分時候,可以把它當作 Tag 物件，是一個特殊的 Tag，我們可以分別獲取它的型別，名稱，以及屬性來感受一下

print type(soup.name)
#<type 'unicode'>
print soup.name 
# [document]
print soup.attrs 
#{} 空字典

（4）Comment

Comment 物件是一個特殊型別的 NavigableString 物件，其實輸出的內容仍然不包括註釋符號，但是如果不好好處理它，可能會對我們的文字處理造成意想不到的麻煩。

我們找一個帶註釋的標籤

print soup.a
print soup.a.string
print type(soup.a.string)

執行結果如下

<a class="sister" href="http://example.com/elsie" id="link1"><!-- Elsie --></a>
 Elsie 
<class 'bs4.element.Comment'>

a 標籤裡的內容實際上是註釋，但是如果我們利用 .string 來輸出它的內容，我們發現它已經把註釋符號去掉了，所以這可能會給我們帶來不必要的麻煩。

另外我們列印輸出下它的型別，發現它是一個 Comment 型別，所以，我們在使用前最好做一下判斷，判斷程式碼如下

if type(soup.a.string)==bs4.element.Comment:
    print soup.a.string

上面的程式碼中，我們首先判斷了它的型別，是否為 Comment 型別，然後再進行其他操作，如列印輸出。

5. 遍歷文件樹

（1）直接子節點

Tag.Tag_child1：直接通過下標名稱訪問子節點。
Tag.contents：以列表形式返回所有子節點。
Tag.children：生成器，可用於迴圈訪問：for child in Tag.children

要點：.contents .children 屬性

.contents

tag 的 .content 屬性可以將tag的子節點以列表的方式輸出。可以使用 [num] 的形式獲得。使用contents向後遍歷樹，使用parent向前遍歷樹

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

輸出方式為列表，我們可以用列表索引來獲取它的某一個元素

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

.children

它返回的不是一個 list，不過我們可以通過遍歷獲取所有子節點。我們列印輸出 .children 看一下，可以發現它是一個 list 生成器物件。

可以使用list可以將其轉化為列表。當然可以使用for 語句遍歷裡面的孩子。

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）所有子孫節點

知識點：.descendants 屬性

.descendants

.contents 和 .children 屬性僅包含tag的直接子節點，.descendants 屬性可以對所有tag的子孫節點進行遞迴迴圈，和 children類似，我們也需要遍歷獲取其中的內容。

Tag.descendants：生成器，可用於迴圈訪問：for des inTag.descendants

for child in soup.descendants:
    print child

執行結果如下，可以發現，所有的節點都被打印出來了，先生成最外層的 HTML標籤，其次從 head 標籤一個個剝離，以此類推。

<html><head><title>The Dormouse's story</title></head>
<body>
<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>
</body></html>
<head><title>The Dormouse's story</title></head>
<title>The Dormouse's story</title>
The Dormouse's story


<body>
<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>
</body>


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


<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>
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>
 Elsie 
,

<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
Lacie
 and

<a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
Tillie
;
and they lived at the bottom of a well.


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

（3）節點內容

知識點：.string 屬性

Tag.String：Tag只有一個String子節點是，可以這麼訪問，否則返回None
Tag.Strings：生成器，可用於迴圈訪問：for str in Tag.Strings

如果tag只有一個 NavigableString 型別子節點,那麼這個tag可以使用 .string 得到子節點。如果一個tag僅有一個子節點,那麼這個tag也可以使用 .string 方法,輸出結果與當前唯一子節點的 .string 結果相同。通俗點說就是：如果一個標籤裡面沒有標籤了，那麼 .string 就會返回標籤裡面的內容。如果標籤裡面只有唯一的一個標籤了，那麼 .string 也會返回最裡面的內容。如果超過一個標籤的話，那麼就會返回None。例如

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

如果tag包含了多個子節點,tag就無法確定，string 方法應該呼叫哪個子節點的內容, .string 的輸出結果是 None

print soup.html.string
# None

（4）多個內容

知識點： .strings .stripped_strings 屬性

.strings

獲取多個內容，不過需要遍歷獲取，比如下面的例子

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

.stripped_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'...'

（5）父節點

知識點： .parent 屬性

使用parent獲取父節點。

Tag.parent：父節點
Tag.parents：父到根的所有節點

body = soup.body
html = body.parent             # html是body的父親

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

content = soup.head.title.string
print content.parent.name
#title

（6）全部父節點

知識點：.parents 屬性

通過元素的 .parents 屬性可以遞迴得到元素的所有父輩節點，例如

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

title
head
html
[document]

（7）兄弟節點

知識點：.next_sibling .previous_sibling 屬性

使用nextSibling, previousSibling獲取前後兄弟

Tag.next_sibling
Tag.next_siblings

Tag.previous_sibling
Tag.previous_siblings

兄弟節點可以理解為和本節點處在統一級的節點，.next_sibling 屬性獲取了該節點的下一個兄弟節點，.previous_sibling 則與之相反，如果節點不存在，則返回 None。

注意：實際文件中的tag的 .next_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方法：只能針對單一元素進行.next，或者說是對contents列表元素的挨個清點。

比如
soup.contents[1]=u'HTML'
soup.contents[2]=u'\n'

則soup.contents[1].next等價於soup.contents[2]

head = body.previousSibling    # head和body在同一層，是body的前一個兄弟
p1 = body.contents[0]          # p1, p2都是body的兒子，我們用contents[0]取得p1
p2 = p1.nextSibling            # p2與p1在同一層，是p1的後一個兄弟, 當然body.content[1]也可得到

contents[]的靈活運用也可以尋找關係節點,尋找祖先或者子孫可以採用findParent(s), findNextSibling(s), findPreviousSibling(s)

（8）全部兄弟節點

知識點：.next_siblings .previous_siblings 屬性

通過 .next_siblings 和 .previous_siblings 屬性可以對當前節點的兄弟節點迭代輸出

for sibling in soup.a.next_siblings:
    print(repr(sibling))
    # u',\n'
    # <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
    # u' and\n'
    # <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
    # u'; and they lived at the bottom of a well.'
    # None

（9）前後節點

知識點：.next_element .previous_element 屬性

與 .next_sibling .previous_sibling 不同，它並不是針對於兄弟節點，而是在所有節點，不分層次。比如 head 節點為

<head><title>The Dormouse's story</title></head>

那麼它的下一個節點便是 title，它是不分層次關係的

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

（10）所有前後節點

知識點：.next_elements .previous_elements 屬性

通過 .next_elements 和 .previous_elements 的迭代器就可以向前或向後訪問文件的解析內容,就好像文件正在被解析一樣

for element in last_a_tag.next_elements:
    print(repr(element))
# u'Tillie'
# u';\nand they lived at the bottom of a well.'
# u'\n\n'
# <p class="story">...</p>
# u'...'
# u'\n'
# None

以上是遍歷文件樹的基本用法。

6.搜尋文件樹

最常用的是find_all()函式

（1）find_all( name , attrs , recursive , text , kwargs )**

find_all() 方法搜尋當前tag的所有tag子節點,並判斷是否符合過濾器的條件

1）name 引數

name 引數可以查詢所有名字為 name 的tag,字串物件會被自動忽略掉

#第一個引數為Tag的名稱 
tag.find_all(‘title’)  
#得到”<title>&%^&*</title>”,結果為一個列表  

第二個引數為匹配的屬性
tag.find_all(“title”,class=”sister”)  
#得到如”<title class = “sister”>%^*&</title>  

# 第二個引數也可以為字串，得到字串匹配的結果
tag.find_all(“title”,”sister”)  
#得到如”<title class = “sister”>%^*&</title>

A.傳字串

最簡單的過濾器是字串.在搜尋方法中傳入一個字串引數,Beautiful Soup會查詢與字串完整匹配的內容,下面的例子用於查詢文件中所有的<b>標籤

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

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>]

B.傳正則表示式

如果傳入正則表示式作為引數,Beautiful Soup會通過正則表示式的 match() 來匹配內容.下面例子中找出所有以b開頭的標籤,這表示<body>和<b>標籤都應該被找到

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

C.傳列表

如果傳入列表引數,Beautiful Soup會將與列表中任一元素匹配的內容返回.下面程式碼找到文件中所有<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.傳方法

如果沒有合適過濾器,那麼還可以定義一個方法,方法只接受一個元素引數 [4] ,如果這個方法返回 True 表示當前元素匹配並且被找到,如果不是則反回 False。下面方法校驗了當前元素,如果包含 class 屬性卻不包含 id 屬性,那麼將返回 True:

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

將這個方法作為引數傳入 find_all() 方法,將得到所有<p>標籤:

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>]

2）keyword 引數

注意：如果一個指定名字的引數不是搜尋內建的引數名,搜尋時會把該引數當作指定名字tag的屬性來搜尋,如果包含一個名字為 id 的引數,Beautiful Soup會搜尋每個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>]

有些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>]

3）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"]

4）limit 引數

find_all() 方法返回全部的搜尋結構,如果文件樹很大那麼搜尋會很慢.如果我們不需要全部結果,可以使用 limit 引數限制返回結果的數量.效果與SQL中的limit關鍵字類似,當搜尋到的結果數量達到 limit 的限制時,就停止搜尋返回結果.

文件樹中有3個tag符合搜尋條件,但結果只返回了2個,因為我們限制了返回數量

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>]

5）recursive 引數

呼叫tag的 find_all() 方法時,Beautiful Soup會檢索當前tag的所有子孫節點,如果只想搜尋tag的直接子節點,可以使用引數 recursive=False 。一段簡單的文件:

<html>
 <head>
  <title>
   The Dormouse's story
  </title>
 </head>
...

是否使用 recursive 引數的搜尋結果:

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

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

（2）find(name=None, attrs={}, recursive=True, text=None, **kwargs)

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

.find('p'),.findAll('p')：find返回的是字串值，而且是返回從頭查詢到的第一個tag對。但是如果這第一個tag對包括大量的內容，父等級很高，則同時其內部所包含的，此級標籤也全部都find。findAll返回值是個列表，如果發現了一個同名標籤內含多個同名標籤，則內部的標籤一併歸於該父標籤顯示，列表其他元素也不再體現那些內含的同名子標籤。即findAll會返回所有符合要求的結果，並以list返回。

soup.findAll(onclick='document.location...')
    soup.findAll(attrs={'style':r'outline:none;'}) #用來查詢屬性中有style='outline:none;的標籤體。                                 # 搜尋所有tag

tag搜尋
find(tagname)                                  # 直接搜尋名為tagname的tag 如：find('head')
find(list)                                     # 搜尋在list中的tag，如: find(['head', 'body'])
find(dict)                                     # 搜尋在dict中的tag，如:find({'head':True, 'body':True})
find(re.compile(''))                           # 搜尋符合正則的tag, 如:find(re.compile('^p')) 搜尋以p開頭的tag
find(lambda)                       # 搜尋函式返回結果為true的tag, 如:find(lambda name: if len(name) == 1) 搜尋長度為1的tag
find(True)                                     # 搜尋所有tag

attrs搜尋
find(id='xxx')                                  # 尋找id屬性為xxx的
find(attrs={id=re.compile('xxx'), algin='xxx'}) # 尋找id屬性符合正則且algin屬性為xxx的
find(attrs={id=True, algin=None})               # 尋找有id屬性但是沒有algin屬性的

resp1 = soup.findAll('a', attrs = {'href': match1})
resp2 = soup.findAll('h1', attrs = {'class': match2})
resp3 = soup.findAll('img', attrs = {'id': match3})

text搜尋
   文字的搜尋會導致其他搜尋給的值如：tag, attrs都失效。方法與搜尋tag一致   
print p1.text
# u'This is paragraphone.'
print p2.text
# u'This is paragraphtwo.'
# 注意：1，每個tag的text包括了它以及它子孫的text。2，所有text已經被自動轉為unicode，如果需要，可以自行轉碼encode(xxx)

recursive和limit屬性
recursive=False表示只搜尋直接兒子，否則搜尋整個子樹，預設為True。
當使用findAll或者類似返回list的方法時，limit屬性用於限制返回的數量，
如:findAll('p', limit=2)： 返回首先找到的兩個tag

（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()方法返回第一個符合條件的節點

注：以上（2）（3）（4）（5）（6）（7）方法引數用法與 find_all() 完全相同，原理均類似，在此不再贅述。

7. CSS選擇器

在寫 CSS 時，標籤名不加任何修飾，類名前加點，id名前加 #

在這裡我們也可以利用類似的方法來篩選元素，用到的方法是 soup.select()，返回型別是 list

（1）通過標籤名查詢

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>]

（2）通過類名查詢

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>]

（3）通過 id 名查詢

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

（4）組合查詢

組合查詢即和寫 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>]

（5）屬性查詢

查詢時還可以加入屬性元素，屬性需要用中括號括起來，注意屬性和標籤屬於同一節點，所以中間不能加空格，否則會無法匹配到。

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 方法返回的結果都是列表形式，可以遍歷形式輸出，然後用 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()

這就是另一種與 find_all 方法有異曲同工之妙的查詢方法，是不是感覺很方便？

print soup.find_all("a", class_="sister")
print soup.select("p.title")

# 通過屬性進行查詢
print soup.find_all("a", attrs={"class": "sister"})

# 通過文字進行查詢
print soup.find_all(text="Elsie")
print soup.find_all(text=["Tillie", "Elsie", "Lacie"])

# 限制結果個數
print soup.find_all("a", limit=2)