Hướng dẫn beautifulsoup trong python

Bạn đã khá quen thuộc với một số ví dụ có trong ví dụ trên, nhưng có một số khá mới. Các giá trị truyền vào như string hay id chúng có ý nghĩa gì? Tại sao hàm find_all(“p”, “title”) sẽ tìm thẻ

cùng với CSS class “title”? Nào, ta cùng tìm hiểu về đối số của hàm find_all().

Name argument

Truyền một giá trị vào name và bạn sẽ nói cho Beautiful Soup biết là chỉ xem xét những thẻ có tên là giá trị được truyền vào name. Các text string sẽ bị bỏ qua cũng như các thẻ có tên không khớp.

Đây là cách sử dụng đơn giản nhất:

soup.find_all("title")
# []

Xem lại phần Các loại bộ lọc, giá trị truyền vào name có thể là một chuỗi, biểu thức chính quy, list, function, hoặc True.

Keyword arguments

Bất kỳ đối số nào không có trong hàm find_all() đều sẽ được chuyển thành một dạng bộ lọc trong thuộc tính của thẻ. Nếu bạn truyền vào một giá trị cho một đối số được gọi là id, Beautiful Soup sẽ lọc các thẻ có thuộc tính id với giá trị được chỉ định:

soup.find_all(id='link2')
# [Lacie]

Nếu bạn truyền một giá trị vào href, Beautiful Soup sẽ lọc dựa theo thuộc tính href:

soup.find_all(href="/redirect?Id=VV4DCjRYHnaSds2LlPoP7D5C1bH%2bvGxljiVtPSdQHhws6gq91nZVQ8U74LNWms1V"
# [Elsie]

Bạn cũng có thể lọc các thuộc tính dựa theo một chuỗi, biểu thức chính quy, list, function, hay bằng giá trị True:

Đoạn code này sẽ tìm tất cả các thẻ mà trong nó có thuộc tính id, bất kể giá trị trong nó là gì:

soup.find_all(id=True)
# [Elsie,
# Lacie,
# Tillie]

Bạn có thể lọc nhiều thuộc tính cùng một lúc bằng cách truyền vào nhiều hơn một keyword argument:

soup.find_all(href="/redirect?Id=VV4DCjRYHnaSds2LlPoP7IYWyJrlG8f8MIWKFhNe73RQef%2b%2fpwIqwlc%2bcVx%2bmwJJ" id='link1')
# [three]

Một vài thuộc tính, như data-* trong HTML 5, có tên không thể được sử dụng như tên của keyword arguments:

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

Bạn có thể sử dụng những thuộc tính này để lọc bằng cách đưa chúng vào một dict, dict này sẽ được truyền vào đối số attrs trong hàm find_all():

data_soup.find_all(attrs={"data-foo": "value"})
# [
foo!
]

Bạn không thể sử dụng một keyword argument để tìm phần tử name trong HTML, vì Beautiful Soup sử dụng đối số name để chứa tên của các thẻ. Thay vào đó, bạn hãy đưa nó vào một dict thông qua đối số attrs:

name_soup = BeautifulSoup('')
name_soup.find_all(name="email")
# []
name_soup.find_all(attrs={"name": "email"})
# []

Tìm kiếm bằng class CSS

Thật hữu ích khi có thể tìm kiếm một tag bằng một class CSS cụ thể. Nhưng tên của thuộc tính CSS, “class”, nó trùng với từ khóa class trong Python. Sử dụng class như một keyword argument sẽ bắn ra syntax error. Từ Beautiful Soup 4.1.2, bạn có thể tìm kiếm bằng CSS class bằng cách sử dụng keyword argument class_:

soup.find_all("a", class_="sister")
# [Elsie,
# Lacie,
# Tillie]

Giống như bất kỳ keyword argument nào, bạn có thể truyền vào class_ một chuỗi, một biểu thức chính quy, hàm hoặc True:

soup.find_all(class_=re.compile("itl"))
# [
The Dormouse's story
]

def has_sicharacters(css_class):
    return css_class is not None and len(css_class) == 6

soup.find_all(class_=has_sicharacters)
# [Elsie,
# Lacie,
# Tillie]

Hãy nhớ rằng, một thẻ đơn có thể có nhiều giá trị trong thuộc tính "class" của nó. Khi bạn tìm kiếm một thẻ match với CSS class chỉ định, bạn có thể match bất kỳ CSS class nào của nó.

css_soup = BeautifulSoup('
')
css_soup.find_all("p", class_="strikeout")
# [
]

css_soup.find_all("p", class_="body")
# [
]

Bạn cũng có thể tìm kiếm cách đưa y nguyên giá trị của thuộc tính class vào:

css_soup.find_all("p", class_="body strikeout")
# [
]

Nhưng tìm ngược lại thì lại không hoạt động, ở đây chuỗi strikeout body bị đảo ngược so với body strikeout, cho nên nó không thể tìm thấy:

css_soup.find_all("p", class_="strikeout body")
# []

Nếu bạn muốn tìm kiếm thẻ khớp hai hay nhiều hơn class CSS, bạn có thể dùng CSS selector:

css_soup.select("p.strikeout.body")
# [
]

Trong các phiên bản cũ hơn của Beautiful Soup, thì không có shortcut class_, bạn có thể sử dụng mẹo attrs được đề cập bên trên. Tạo một dict chứa key là "class" và value là một chuỗi (hoặc một regular expression, hay bất cứ thứ gì) bạn muốn tìm:

soup.find_all("a", attrs={"class": "sister"})
# [Elsie,
# Lacie,
# Tillie]

String argument

Với string bạn có thể tìm kiếm chuỗi thay cho thẻ. Như name và keyword arguments, bạn có thể truyền vào một chuỗi, một biểu thức chính quy, một list, một hàm, hoặc giá trị True. Dưới đây là một ví dụ:

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

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

soup.find_all(string=re.compile("Dormouse"))
[u"The Dormouse's story", u"The Dormouse's story"]

def is_the_only_string_within_a_tag(s):
    """Return True if this string is the only child of its parent tag."""
    return (s == s.parent.string)

soup.find_all(string=is_the_only_string_within_a_tag)
# [u"The Dormouse's story", u"The Dormouse's story", u'Elsie', u'Lacie', u'Tillie', u'...']

Mặc dù string là để tìm chuỗi, bạn có thể kết hợp nó với các đối số tìm kiếm khác: Beautiful Soup sẽ tìm tất cả các thẻ có .string khớp với giá trị string. Đoạn code này sẽ tìm những thẻ có .string là "Elsie":

soup.find_all("a", string="Elsie")
# [Elsie]

string là một đối số mới trong Beautiful Soup 4.4.0. Trong các phiên bản trước đó nó được gọi là text:

soup.find_all("a", text="Elsie")
# [Elsie]

Limit argument

find_all() trả về tất cả những thẻ và chuỗi khớp với bộ lọc của bạn. Điều này có thể khá tốn thời gian nếu tài liệu của bạn lớn. Nếu bạn không cần lấy hết kết quả, bạn có thể truyền thêm một số cho đối số limit. Nó hoạt động giống như keyword LIMIT trong SQL. Nó nói cho Beautiful Soup biết rằng ngừng thu thập kết quả sau khi lấy được một số lượng nhất định.

Có ba link trong tài liệu "three sisters", nhưng đoạn code này chỉ tìm thấy hai:

soup.find_all("a", limit=2)
# [Elsie,
# Lacie]

Recursive argument

Nếu bạn gọi mytag.find_all(), Beautiful Soup sẽ kiểm tra tất cả các descendant (con cháu) của mytag, con của con của nó, vân vân. Nếu bạn muốn Beautiful Soup duyệt trực tiếp phần tử con, bạn có thể truyền recursive=False, không đệ quy tiếp vào các phần tử con của phần tử con. Hãy xem sự khác biệt dưới đây:

soup.html.find_all("title")
# []

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

Đây là phần đó trong tài liệu:

  
    
  
...

Thẻ ] soup.find('title') #

Chỉ khác đó là find_all() trả về một list chứa kết quả, và find() thì trả về kết quả.

Nếu find_all() không thể tìm thấy gì, nó sẽ trả về một list rỗng. Còn với find(), không tìm thấy gì thì nó trả về None:

print(soup.find("nosuchtag"))
# None

Bạn có nhớ mẹo soup.head.title từ Duyệt bằng cách sử dụng tag name? Mẹo đó hoạt động bằng cách gọi find() liên tục:

soup.head.title
# 

soup.find("head").find("title")
# 

find_parents() và find_parent()

find_parents(name, attrs, string, limit, **kwargs)
find_parent(name, attrs, string, **kwargs)

Mình đã dành nhiều thời gian để nói về find_all() và find(). Beautiful Soup API định nghĩa tới mười phương thức khác nhau để tìm kiếm trong cây. Nhưng đừng sợ. Năm trong số những phương thức đó cơ bản thì giống như find_all(), và năm phương thức còn lại thì tương tự find(). Chỉ khác là những phần trong cây mà chúng tìm kiếm.

Đầu tiên ta sẽ bắt đầu với find_parents() và find_parent(). Nhớ rằng cách mà find_all() và find() hoạt động là đi xuống trong một cây. Nhìn vào những các descendant (thẻ con cháu) của thẻ. Hai phương thức này thì làm ngược lại: cách mà chúng hoạt động là đi lên trong một cây, nhìn vào các phần tử cha của một thẻ hoặc một chuỗi. Ta sẽ thử xem, bắt đầu là một chuỗi nằm sâu trong tài liệu “three sisters”:

a_string = soup.find(string="Lacie")
a_string
# u'Lacie'

a_string.find_parents("a")
# [Lacie]

a_string.find_parent("p")
# 
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.

a_string.find_parents("p", class="title")
# []

Một trong ba thẻ là phần tử cha trực tiếp của chuỗi được đề cập. Vì vậy ta có thể tìm thấy nó. Hoặc một trong ba thẻ

là phần tử cha gián tiếp của chuỗi này. Cho nên ta cũng tìm thấy nó luôn. Vẫn còn một thẻ

có CSS class là “title” nằm ở đâu đó trong tài liệu, nhưng nó không là phần tử cha của chuỗi này, cho nên ta không thể tìm thấy nó bằng find_parents().

Bạn có thể tạo ra kết nối giữa find_parent() và find_parents() và hai thuộc tính .parent và .parents đã được đề cập bên trên. Sự kết nối này rất mạnh. Các phương thức tìm kiếm này thực ra là sử dụng .parents để lặp qua tất cả phần tử cha, và kiểm tra từng cái một trong bộ lọc được cung cấp để xem chúng có khớp hay không.

find_next_siblings() và find_next_sibling()

find_next_siblings(name, atts, string, limit, **kwargs)
find_next_sibling(name, atts, string, **kwargs)

Phương thức này sử dụng .next_siblings để lặp qua những siblings còn lại của một phần tử trong một cây. Phương thức find_next_siblings() trả về tất cả những siblings phù hợp, và find_next_sibling() chỉ trả về một kết quả:

first_link = soup.a
first_link
# Elsie

first_link.find_next_siblings("a")
# [Lacie,
# Tillie]

first_story_paragraph = soup.find("p", "story")
first_story_paragraph.find_next_sibling("p")
# 
...

find_previous_siblings() và find_previous_sibling()

find_previous_siblings(name, atts, string, limit, **kwargs)
find_previous_sibling(name, atts, string, **kwargs)

Hai phương thức này sử dụng .previous_siblings để lặp qua các siblings của phần tử đó ở trước nó trong cây. Phương thức find_previous_siblings() trả về một list chứa tất cả các siblings phù hợp, và find_previous_sibling() chỉ trả về một kết quả:

last_link = soup.find("a", id="link3")
last_link
# Tillie

last_link.find_previous_siblings("a")
# [Lacie,
# Elsie]

first_story_paragraph = soup.find("p", "story")
first_story_paragraph.find_previous_sibling("p")
# 
The Dormouse's story

find_all_next() và find_next()

find_all_next(name, attrs, string, limit, **kwargs)
find_next(name, attrs, string, **kwargs)

Hai phương thức này sử dụng .next_element để lặp qua bất cứ thẻ hay chuỗi nào ở phía sau nó trong tài liệu. Phương thức find_all_next() trả về một list chứa tất cả các kết quả phù hợp, còn find_next() chỉ trả về một kết quả:

first_link = soup.a
first_link
# Elsie

first_link.find_all_next(string=True)
# [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']

first_link.find_next("p")
# 
...

Trong ví dụ đầu tiên, chuỗi “Elsie” xuất hiện, mặc dù ta bắt đầu từ thẻ có chứa nó. Trong ví dụ thứ hai, thẻ

cuối cùng trong tài liệu xuất hiện, mặc dù nó không nằm trong cùng một phần trong cây với thẻ nơi mà ta bắt đầu lặp. Điều ta cần quan tâm khi sử dụng những phương thức này là phần tử khớp với bộ lọc và hiển thị sau so với phần tử bắt đầu trong tài liệu.

find_all_previous() và find_previous()

find_all_previous(name, attrs, string, limit, **kwargs)
find_previous(name, attrs, string, **kwargs)

Hai phương thức này sử dụng .previous_elements để lặp qua nhưng thẻ và chuỗi đứng trước nó trong tài liệu. Phương thức find_all_previous() trả về một list chứa tất cả các kết quả trùng khớp, còn find_previous() thì trả về một kết quả:

first_link = soup.a
first_link
# Elsie

first_link.find_all_previous("p")
# [
Once upon a time there were three little sisters; ...
,
# 
The Dormouse's story
]

first_link.find_previous("title")
# 

Việc gọi find_all_previous("p") tìm thấy đoạn đầu tiên trong tài liệu (đoạn có class=”title”), nhưng nó tìm thấy tới hai đoạn, thẻ

có chứa thẻ nơi mà chúng ta bắt đầu. Điều này không quá bất ngờ. Ta xem xét tất cả thẻ xuất hiện sớm hơn trong tài liệu so với vị trí mà ta bắt đầu. Thẻ

chứa thẻ phải xuất hiện trước thẻ mà nó chứa.

CSS selectors

Trong phiên bản 4.7.0, Beautiful Soup hỗ trợ hầu hết các CSS4 selectors thông qua dự án SoupSieve. Nếu bạn đã cài đặt Beautiful Soup thông qua pip, thì SoupSieve đã được cài đặt cùng lúc đó, vì thế bạn không cần phải làm gì thêm.

BeautifulSoup có phương thức .select() sử dụng SoupSieve để chạy một CSS selector lên tài liệu đã được parse và trả về tất cả các phần tử match. Tag có một phương thức tương tự chạy một CSS selector lên contents của một thẻ.

Tài liệu SoupSieve liệt kê tất cả các CSS selectors hiện tại được hỗ trợ, nhưng ở đây ta chỉ đề cập tới những CSS selectors cơ bản:

Bạn có thể tìm kiếm các tag:

soup.select("title")
# []

soup.select("p:nth-of-type(3)")
# [
...
]

Tìm các thẻ bên dưới các thẻ khác:

soup.select("body a")
# [Elsie,
# Lacie,
# Tillie]

soup.select("html head title")
# []

Tìm những tag con trực tiếp của tag khác:

soup.select("head > title")
# []

soup.select("p > a")
# [Elsie,
# Lacie,
# Tillie]

soup.select("p > a:nth-of-type(2)")
# [Lacie]

soup.select("p > #link1")
# [Elsie]

soup.select("body > a")
# []

Tìm các siblings của tag:

soup.select("#link1 ~ .sister")
# [Lacie,
# Tillie]

soup.select("#link1 + .sister")
# [Lacie]

Tìm thẻ bằng CSS class:

soup.select(".sister")
# [Elsie,
# Lacie,
# Tillie]

soup.select("[class~=sister]")
# [Elsie,
# Lacie,
# Tillie]

Tìm thẻ bằng CSS ID:

soup.select("#link1")
# [Elsie]

soup.select("a#link2")
# [Lacie]

Tìm thẻ match với bất kỳ selector nào nằm trong danh sách các selectors:

soup.select("#link1,#link2")
# [Elsie,
# Lacie]

Kiểm tra sự tồn tại của một thuộc tính:

soup.select('a[href]')
# [Elsie,
# Lacie,
# Tillie]

Tìm thẻ bằng giá trị của thuộc tính:

soup.select('a[href="/redirect?Id=f%2fKgPq4IDV0SyEq0zfYr0L1x0DM4mpSt97%2ftYgbxlC3lW0cWzhMK4ll9WwwLq4Ce"
# [Elsie]

soup.select('a[href^="http://example.com/"]')
# [Elsie,
# Lacie,
# Tillie]

soup.select('a[href$="tillie"]')
# [Tillie]

soup.select('a[href*=".com/el"]')
# [Elsie]

Ngoài ra cũng có phương thức select_one() lấy ra thẻ đầu tiên match với selector:

soup.select_one(".sister")
# Elsie

Nếu bạn parse XML định nghĩa namespaces, bạn có thể sử dụng chúng trong CSS selectors:

from bs4 import BeautifulSoup
xml = """
    I'm in namespace 1
    I'm in namespace 2
 """
soup = BeautifulSoup(xml, "xml")

soup.select("child")
# [I'm in namespace 1, I'm in namespace 2]

soup.select("ns1|child", namespaces=namespaces)
# [I'm in namespace 1]

Khi xử lý CSS selector sử dụng namespaces, Beautiful Soup sử dụng các từ viết tắt namespace nó đã tìm thấy khi parse tài liệu. Bạn có thể ghi đè chúng bằng cách truyền vào một dict chứa các từ viết tắt của riêng bạn:

namespaces = dict(first="http://namespace1/", second="http://namespace2/")
soup.select("second|child", namespaces=namespaces)
# [I'm in namespace 2]

Công cụ CSS selector là một công cụ hữu ích cho những ai đã biết về cú pháp của CSS selector. Bạn có thể làm tất cả điều này với Beautiful Soup API. Và nếu CSS selector là tất cả những gì bạn cần, bạn nên parse tài liệu bằng lxml: Nó nhanh hơn rất nhiều. Nó cho phép bạn kết hợp CSS selectors với Beautiful Soup API.

Chỉnh sửa cây

Sức mạnh chính của Beautiful Soup là tìm kiếm trong parse tree, nhưng ngoài ra bạn cũng có thể chỉnh sửa tree và ghi lại những thay đổi của bạn thành một tài liệu HTML/XML mới.

Thay đổi tên thẻ và thuộc tính

Mình đã đề cập cái này trước đó, trong phần Attributes, nhưng ta sẽ ôn lại một chút, thay đổi giá trị của các thuộc tính, thêm thuộc tính và xóa thuộc tính:

soup = BeautifulSoup('Extremely bold')
tag = soup.b

tag.name = "blockquote"
tag['class'] = 'verybold'
tag['id'] = 1
tag
# 
Extremely bold

del tag['class']
del tag['id']
tag
# 
Extremely bold

Chỉnh sửa .string

Nếu bạn đặt giá trị cho thuộc tính .string của thẻ, nội dung của thẻ đó sẽ được thay thế bằng giá trị bạn truyền vào:

markup = 'example.com'
soup = BeautifulSoup(markup)

tag = soup.a
tag.string = "New link text."
tag
# 

Cẩn thận: Nếu một thẻ chứa một thẻ khác, chúng và tất cả những nội dung bên trong sẽ bị hủy.

.append()

Bạn có thể thêm nội dung cho một thẻ bằng Tag.append(). Nó hoạt động giống như .append() với list trong Python:

soup = BeautifulSoup("Foo")
soup.a.append("Bar")

soup
# FooBar
soup.a.contents
# [u'Foo', u'Bar']

.extend()

Bắt đầu từ Beautiful Soup 4.7.0, Tag có thêm một phương thức được gọi là .extend(), nó hoạt động giống như .extend() với list trong Python:

soup = BeautifulSoup("Soup")
soup.a.extend(["'s", " ", "on"])

soup
# Soup's on
soup.a.contents
# [u'Soup', u''s', u' ', u'on']

.navigablestring() và .new_tag()

Nếu bạn cần thêm một chuỗi vào tài liệu, không thành vấn đề - bạn chỉ cần truyền một chuỗi vào trong append(), hoặc bạn có thể gọi NavigableString constructor:

soup = BeautifulSoup("")
tag = soup.b
tag.append("Hello")
new_string = NavigableString(" there")
tag.append(new_string)
tag
# Hello there.
tag.contents
# [u'Hello', u' there']

Nếu bạn muốn tạo một comment hoặc vài lớp con khác của NavigableString, chỉ cần gọi constructor:

from bs4 import Comment
new_comment = Comment("Nice to see you.")
tag.append(new_comment)
tag
# Hello there
tag.contents
# [u'Hello', u' there', u'Nice to see you.']

(Đây là một chức năng mới trong Beautiful Soup 4.4.0)

Còn nếu bạn muốn tạo một thẻ mới thì sao? Cách tốt nhất là gọi BeautifulSoup.new_tag():

soup = BeautifulSoup("")
original_tag = soup.b

new_tag = soup.new_tag("a", href="/redirect?Id=6UNFqWfJ6w%2fJl4oWIm1IFaq5Qh%2buJOMoNmtk93G2mLtWA3qLMNPV%2fQLdOE8kXVGC"
original_tag.append(new_tag)
original_tag
# 

Chỉ đối số đầu tiên, tên thẻ yêu cầu phải có.

insert()

Tag.insert cũng giống như Tag.append(), chỉ khác là phần tử mới không nhất thiết phải ở cuối của .contents. Nó sẽ được chèn vào bất cứ vị trí nào mà bạn gọi. Nó giống như .insert trong list Python:

markup = 'example.com'
soup = BeautifulSoup(markup)
tag = soup.a

tag.insert(1, "but did not endorse ")
tag
# example.com
tag.contents
# [u'I linked to ', u'but did not endorse', example.com]

insert_before() and insert_after()

Phương thức insert_before() chèn thẻ hoặc chuỗi ngay trước bất cứ thứ gì khác trong parse tree:

soup = BeautifulSoup("stop")
tag = soup.new_tag("i")
tag.string = "Don't"
soup.b.string.insert_before(tag)
soup.b
# Don'tstop

Phương thức insert_after() chèn thẻ hoặc chuỗi ngay sau bất cứ thứ gì khác trong parse tree:

div = soup.new_tag('div')
div.string = 'ever'
soup.b.i.insert_after(" you ", div)
soup.b
# Don't you 
ever
 stop
soup.b.contents
# [Don't, u' you', 
ever
, u'stop']

clear()

Tag.clear() loại bỏ nội dung của một thẻ:

markup = 'example.com'
soup = BeautifulSoup(markup)
tag = soup.a

tag.clear()
tag
# 

extract()

PageElement.extract() loại bỏ một thẻ hay một chuỗi ra khỏi tree. Nó trả về thẻ hay chuỗi đã bị loại bỏ:

markup = 'example.com'
soup = BeautifulSoup(markup)
a_tag = soup.a

i_tag = soup.i.extract()

a_tag
# 

i_tag
# example.com

print(i_tag.parent)
None

Tại lúc này bạn có hẳn cho mình hai parse tree, một là từ BeautifulSoup bạn parse từ markup và còn lại là thẻ mà bạn đã extract ra trước đó. Bạn có thể gọi extract lên phần tử con mà bạn đã extract trước đó:

my_string = i_tag.string.extract()
my_string
# u'example.com'

print(my_string.parent)
# None
i_tag
# 

decompose()

Tag.decompose() loại bỏ một thẻ khỏi cây, sau đó phá hủy hoàn toàn thẻ đó và nội dung của nó:

markup = 'example.com'
soup = BeautifulSoup(markup)
a_tag = soup.a

soup.i.decompose()

a_tag
# 

replace_with()

PageElement.replace_with() loại bỏ một thẻ hoặc chuỗi khỏi cây, và thay thế nó bằng thẻ hay chuỗi khác: