Once upon a time there were three little sisters; and their names were
Elsie
Hello
Lacie
and
Tillie
and they lived at the bottom of a well.
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print('next sibling:',soup.a.next_sibling)
print('previous sibling:',soup.a.previous_sibling)
print("next siblings:",list(soup.a.next_siblings))
print("previouos siblings:",list(soup.a.previous_siblings))
```
运行结果:
```
next sibling:
Hello
...
```
**提取信息**
获取一些信息，比如文本、属性等等
```
html = """
Once upon a time there were three little sisters; and their names were
BobLacie
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print('Next Sibling:')
print(type(soup.a.next_sibling))
print(soup.a.next_sibling)
print(soup.a.next_sibling.string)
print('Parent:')
print(type(soup.a.parents))
print(list(soup.a.parents)[0])
print(list(soup.a.parents)[0].attrs['class'])
```
运行结果:
```
Next Sibling:
...
```
#### 方法选择器
常用查询方法:find\_all()、find()
**find\_all()**
查询所有符合条件的元素
语法：
```
find_all(name , attrs , recursive , text , **kwargs)
```
**name**
根据节点名来查询元素
```
html='''
'''
from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print(soup.find_all(name='ul'))
print(type(soup.find_all(name='ul')[0]))
```
运行结果：返回结果类型为:bs4.element.Tag
```
[
- Foo
...
```
获取ul下的li节点以及li下的文本内容
```
from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
# print(soup.find_all(name='ul'))
# print(type(soup.find_all(name='ul')[0]))
for ul in soup.find_all(name='ul'):
print(ul.find_all(name='li'))
for li in ul.find_all(name='li'):
print(li.string)
```
运行结果：
```
[- Foo
, - Bar
, - Jay
]
....
```
**attrs**
根据属性来进行查询
```
html='''
'''
from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
# 查询属性以字典的的进行查询
print(soup.find_all(attrs={'id':'list-1'}))
print(soup.find_all(attrs={"name":"elements"}))
```
运行结果：
```
[
- Foo
...
```
对于常用的属性比如id，class，可以不用attrs传递
```
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.find_all(id='list-1'))
# 由于class是关键字需要添加下划线区分
print(soup.find_all(class_='element'))
```
运行结果：
```
[]
[- Foo
, - Bar
, - Jay
, - Foo
, - Bar
]
```
**text**
text 参数可以用来匹配节点的文本，传入的形式可以是字符串，可以是正则表达式对象
```
html='''
'''
import re
from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
# 查询文本包含有link的文本
print(soup.find_all(text=re.compile('link')))
```
运行结果：
```
['Hello, this is a link', 'Hello, this is a link, too']
```
**find()**
find() 方法返回的是单个元素，即第一个匹配的元素，而 find\_all() 返回的是所有匹配的元素组成的列表
```
html='''
'''
from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print(soup.find(name='a'))
print(soup.find(attrs={'class':'element'}))
print(soup.find(class_='element'))
print(type(soup.find(name='a')))
```
返回结果:返回类型为\
```
Hello, this is a link
Hello, this is a link
Hello, this is a link
```
其他查询方法
**find\_parents() find\_parent()**
find\_parents() 返回所有祖先节点，find\_parent() 返回直接父节点。
**find\_next\_siblings() find\_next\_sibling()**
find\_next\_siblings() 返回后面所有兄弟节点，find\_next\_sibling() 返回后面第一个兄弟节点。
**find\_previous\_siblings() find\_previous\_sibling()**
find\_previous\_siblings() 返回前面所有兄弟节点，find\_previous\_sibling() 返回前面第一个兄弟节点。
**find\_all\_next() find\_next()**
find\_all\_next() 返回节点后所有符合条件的节点, find\_next() 返回第一个符合条件的节点。
**find\_all\_previous() 和 find\_previous()**
find\_all\_previous() 返回节点后所有符合条件的节点, find\_previous() 返回第一个符合条件的节点
#### CSS选择器
相关链接:
使用 CSS 选择器，只需要调用 select() 方法，传入相应的 CSS 选择器
实例：
```
html='''
'''
from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
print(soup.select('.panel .panel-heading'))
print(soup.select('ul li'))
print(soup.select('#list-2 .element'))
print(soup.select('ul')[0])
```
运行结果：
```
[
Hello
]
...
```
**嵌套选择**
实例:select() 方法同样支持嵌套选择，例如我们先选择所有 ul 节点，再遍历每个 ul 节点选择其 li 节点
```
from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
for ul in soup.select('ul'):
print(ul.select('li'))
```
运行结果：
```
[- Foo
, - Bar
, - Jay
]
[- Foo
, - Bar
]
```
**获取属性**
获取属性还是可以用上面的方法获取
```
from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
for ul in soup.select('ul'):
print(ul['id'])
print(ul.attrs['id'])
```
运行结果：
```
list-1
list-1
list-2
list-2
```
**获取文本**
获取文本可以用string 属性，还有一种方法那就是 get\_text()，同样可以获取文本值。
```
from bs4 import BeautifulSoup
soup = BeautifulSoup(html,'lxml')
for li in soup.select('li'):
print('GET TEXT:',li.get_text())
print('STRING:',li.string)
```
运行结果：
```
GET TEXT: Foo
STRING: Foo
GET TEXT: Bar
...
```
#### 细节
推荐使用 LXML 解析库，必要时使用 html.parser
节点选择筛选功能弱但是速度快
建议使用 find()、find\_all() 查询匹配单个结果或者多个结果
如果对 CSS 选择器熟悉的话可以使用 select() 选择法
如何匹配规则不是熟练，而且想快速获取，可以如下操作:
右键
## Pyquery
### 安装
```
pip install pquery
```
### 用途
`PyQuery`允许像`JQuery`一样对快速对`xml（lxml）`文档进行元素查询、元素操作的python库。如果熟悉JQuery的api，那么掌握PyQuery是一件十分容易的事情，因为PyQuery的api和JQuery的api基本上**一致**。PyQuery是一款基于lxml的库，而lxml能够快速处理xml和html文档。
### 文档
[官方文档](http://pyquery.readthedocs.io/en/latest/api.html)
[css选择器文档](https://www.w3school.com.cn/css/index.asp)
### 用法
#### 初始化
PyQuery 初始化的时候也需要传入 HTML 数据源来初始化一个操作对象，它的初始化方式有多种，比如直接传入字符串，传入 URL，传文件名
**字符串初始化**
```
html = '''
'''
from pyquery import PyQuery as pq
doc = pq(html)
print(doc('li')) # 获取li节点
```
运行结果：
```
- first item
- second item
- third item
- fourth item
- fifth item
```
**url初始化**
* 指定传入的参数为url
```
from pyquery import PyQuery as pq
doc = pq(url="http://thefoxfairy.gitbook.io/")
print(doc("title"))
```
运行结果：
```
Introduction - 112的一员
```
> 但是不建议这样做，应该配合请求库一起使用
**文件初始化**
传入参数指定为 filename
```
from pyquery import PyQuery as pq
doc = pq(filename='test.html')
print(doc('li'))
```
#### CSS选择器
通过css选择器，筛选出所需的数据
```
from pyquery import PyQuery as pq
html = '''
'''
doc = pq(html)
print(doc('#container .list li'))
print(type(doc('#container .list li')))
```
运行结果：
```
- first item
- second item
- third item
- fourth item
- fifth item
```
[参考文档](http://www.w3school.com.cn/cssref/css_selectors.asp)
| 选择器 | 例子 | 例子描述 |
| -------------------- | --------------------- | --------------------------------------------- |
| .class | .intro | 选择 class="intro" 的所有元素。 |
| #id | #firstname | 选择 id="firstname" 的所有元素。 |
| \* | \* | 选择所有元素。 |
| element | p | 选择所有
元素。
|
| element,element | div,p | 选择所有元素和所有
元素。
|
| elementelement | div p | 选择元素内部的所有
元素。
|
| element>element | div>p | 选择父元素为元素的所有
元素。
|
| element+element | div+p | 选择紧接在元素之后的所有
元素。
|
| \[attribute] | \[target] | 选择带有 target 属性所有元素。 |
| \[attribute=value] | \[target=\_blank] | 选择 target="\_blank" 的所有元素。 |
| \[attribute\~=value] | \[title\~=flower] | 选择 title 属性包含单词 "flower" 的所有元素。 |
| \[attribute\|=value] | \[lang\|=en] | 选择 lang 属性值以 "en" 开头的所有元素。 |
| :link | a:link | 选择所有未被访问的链接。 |
| :visited | a:visited | 选择所有已被访问的链接。 |
| :active | a:active | 选择活动链接。 |
| :hover | a:hover | 选择鼠标指针位于其上的链接。 |
| :focus | input:focus | 选择获得焦点的 input 元素。 |
| :first-letter | p:first-letter | 选择每个
元素的首字母。
|
| :first-line | p:first-line | 选择每个
元素的首行。
|
| :first-child | p:first-child | 选择属于父元素的第一个子元素的每个
元素。
|
| :before | p:before | 在每个
元素的内容之前插入内容。
|
| :after | p:after | 在每个
元素的内容之后插入内容。
|
| :lang(language) | p:lang(it) | 选择带有以 "it" 开头的 lang 属性值的每个
元素。
|
| element1\~element2 | p\~ul | 选择前面有
元素的每个
|
| \[attribute^=value] | a\[src^="https"] | 选择其 src 属性值以 "https" 开头的每个 元素。 |
| \[attribute$=value] | a\[src$=".pdf"] | 选择其 src 属性以 ".pdf" 结尾的所有 元素。 |
| \[attribute\*=value] | a\[src\*="abc"] | 选择其 src 属性中包含 "abc" 子串的每个 元素。 |
| :first-of-type | p:first-of-type | 选择属于其父元素的首个
元素的每个
元素。
|
| :last-of-type | p:last-of-type | 选择属于其父元素的最后
元素的每个
元素。
|
| :only-of-type | p:only-of-type | 选择属于其父元素唯一的
元素的每个
元素。
|
| :only-child | p:only-child | 选择属于其父元素的唯一子元素的每个
元素。
|
| :nth-child(n) | p:nth-child(2) | 选择属于其父元素的第二个子元素的每个
元素。
|
| :nth-last-child(n) | p:nth-last-child(2) | 同上，从最后一个子元素开始计数。 |
| :nth-of-type(n) | p:nth-of-type(2) | 选择属于其父元素第二个
元素的每个
元素。
|
| :nth-last-of-type(n) | p:nth-last-of-type(2) | 同上，但是从最后一个子元素开始计数。 |
| :last-child | p:last-child | 选择属于其父元素最后一个子元素每个
元素。
|
| :root | :root | 选择文档的根元素。 |
| :empty | p:empty | 选择没有子元素的每个
元素（包括文本节点）。
|
| :target | #news:target | 选择当前活动的 #news 元素。 |
| :enabled | input:enabled | 选择每个启用的 元素。 |
| :disabled | input:disabled | 选择每个禁用的 元素 |
| :checked | input:checked | 选择每个被选中的 元素。 |
| :not(selector) | :not(p) | 选择非
元素的每个元素。
|
| ::selection | ::selection | 选择被用户选取的元素部分。 |
#### 查找节点
pyquery的常用的查询函数，这些函数和 jQuery 中的函数用法完全相同
**子节点**
查找**子节点**需要用到 find() 方法，传入的参数是 CSS 选择器
```
from pyquery import PyQuery as pq
doc = pq(html)
items = doc('.list')
print(type(items))
print(items)
list_itmes = items.find('li')
print(type(list_itmes))
print(list_itmes)
```
运行结果：
```
- first item
- second item
- third item
- fourth item
- fifth item
()
```
**子孙节点**
find() 的查找范围是节点的所有**子孙节点**，而如果只想查找子节点，那可以用 children() 方法
```
from pyquery import PyQuery as pq
doc = pq(html)
lis = doc.children()
print(type(lis))
print(lis)
```
运行结果：
```
```
实例：筛选出子节点class属性值为active
```
from pyquery import PyQuery as pq
items = pq(html)
lis = items.children('.list .active')
print(type(lis))
print(lis)
```
运行结果：
```
- third item
- fourth item
```
**父节点**
可以用 parent() 方法来获取某个节点的父节点
实例：返回class属性值list当前节点的父节点下的内容
```
html = '''
'''
from pyquery import PyQuery as pq
doc = pq(html)
items = doc('.list')
container = items.parent()
print(type(container))
print(container)
```
运行结果：
```
```
**祖先节点**
parents() 方法会返回所有的祖先节点
```
from pyquery import PyQuery as pq
doc = pq(html)
items = doc('.list')
parents= items.parents()
print(type(parents))
print(parents)
```
结果会有两个节点
运行结果：
```
```
筛选出指定父节点
实例：筛选出属性值为wrap的父节点
```
from pyquery import PyQuery as pq
doc = pq(html)
items = doc('.list')
parents = items.parents('.wrap')
print(type(parents))
print(parents)
```
运行结果：
```
```
**兄弟节点**
要获取兄弟节点可以使用 siblings() 方法
```
from pyquery import PyQuery as pq
doc = pq(html)
li = doc('.list .item-0.active')
print(li.siblings())
```
运行结果：
```
- second item
- first item
- fourth item
- fifth item
```
筛选某个指定兄弟节点
```
from pyquery import PyQuery as pq
doc = pq(html)
li = doc('.list .item-0.active')
print(li.siblings('.active'))
```
运行结果：
```
- fourth item
- first item
- second item
- third item
- fourth item
- fifth item
```
**获取信息**
* 获取属性
* 获取文本
**获取属性**
使用**attr()** 方法获取属性
```
html = '''
'''
from pyquery import PyQuery as pq
doc = pq(html)
a = doc('.item-0.active a')
print(a,type(a))
print(a.attr('href'))
print(a.attr.href)
```
有两种获取属性方法:
```
a.attr('href')
a.attr.href
```
运行结果:
```
third item
link3.html
link3.html
```
当返回结果包含多个节点时，调用 **attr()** 方法只会得到第一个节点的属性
```
from pyquery import PyQuery as pq
doc = pq(html)
a = doc('a')
for item in a.items():
print(item.attr('href'))
```
运行结果：
```
link2.html
link3.html
link4.html
link5.html
```
**获取文本**
调用 **text()** 方法，就可以获取其内部的文本信息了，它会忽略掉节点内部包含的所有 HTML，只返回纯文字内容
```
html = '''
'''
from pyquery import PyQuery as pq
doc = pq(html)
a = doc('.item-0.active a')
print(a)
print(a.text())
```
运行结果：
```
third item
third item
```
获取这个节点内部的 HTML 文本，就可以用 **html()** 方法
```
from pyquery import PyQuery as pq
doc = pq(html)
a = doc('.item-0.active a')
print(a)
print(a.html())
```
运行结果：
```
third item
third item
```
在多个节点的情况下，**html()** 方法返回**第一个** li 节点的内部 HTML 文本，而 text() 返回**所有**的 li 节点内部纯文本
#### 节点操作
PyQuery 提供了一系列方法来对节点进行动态修改操作
**add\_class、remove\_class**
添加、删除类属性
```
from pyquery import PyQuery as pq
doc = pq(html)
li = doc('.item-0.active')
print(li)
li.remove_class('active')
print(li)
li.add_class("active")
print(li)
```
返回结果：
```
- third item
- third item
- third item
```
**attr、text、html**
```
from pyquery import PyQuery as pq
doc = pq(html)
li = doc('.item-0.active')
print(li)
li.attr('name','link')
print(li)
li.text('chaned item')
print(li)
li.html('changed itemthird item
- third item
- chaned item
- changed item
```
**remove**
**移除**
实例：
```
html = '''
Hello, World
This is a paragraph.
- first item
- fifth item
- second item
- fourth item
- fifth item
- second item
- fourth item
- second item
```