1.4、True

可以匹配任何值,下面代码查找到所有的tag,但是不会返回字符串节点

print(soup.find_all(True))
for tag in soup.find_all(True):
    print(tag.name)

这个不怎么用，可以忽略掉！

1.5、方法

如果没有合适过滤器,那么还可以定义一个方法,方法只接受一个元素参数 ,如果这个方法返回 True 表示当前元素匹配并且被找到,如果不是则反回 False

from bs4 import BeautifulSoup
soup=BeautifulSoup(html_doc,'lxml')
def has_class_but_no_id(tag):  # 有class但是没有id属性的标签
    return tag.has_attr('class') and not tag.has_attr('id')
print(soup.find_all(has_class_but_no_id))  # 将每一个标签传给这个方法过滤

执行输出：

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

最终输出的，都是有class属性，但是没有id属性的标签

2、find_all()

语法

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

2.1、name

搜索name参数的值可以使任一类型的 过滤器 ,字符窜,正则表达式,列表,方法或是 True

from bs4 import BeautifulSoup
soup=BeautifulSoup(html_doc,'lxml')
import re
print(soup.find_all(name=re.compile('^t')))

执行输出：

[<title>The Dormouse's story</title>]

2.2、keyword

key=value的形式，value可以是过滤器：字符串 , 正则表达式 , 列表, True

print(soup.find_all(id=re.compile('my')))  # 查找id含有my属性的标签
# 查找herf含有lacle以及id带有数字的标签。
# 如果是class属性，需要使用class_，因为在python中，class是关键字！
print(soup.find_all(href=re.compile('lacie'),id=re.compile('\d')))
print(soup.find_all(id=True)) #查找有id属性的标签

执行输出：

[<p class="title" id="my p"><b class="boldest" id="bbb">The Dormouse's story</b>
</p>]
[<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]
[<p class="title" id="my p"><b class="boldest" id="bbb">The Dormouse's story</b>
</p>, <b class="boldest" id="bbb">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>]

有些tag属性在搜索不能使用,比如HTML5中的 data-* 属性:

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

但是可以通过 find_all() 方法的 attrs 参数定义一个字典参数来搜索包含特殊属性的tag:

from bs4 import BeautifulSoup
soup=BeautifulSoup(html_doc,'lxml')
data_soup = BeautifulSoup('<div data-foo="value">foo!</div>','lxml')
print(data_soup.find_all(attrs={"data-foo": "value"}))
# [<div data-foo="value">foo!</div>]

2.3、按照类名查找

注意关键字是class，class=value,value可以是五种选择器之一

from bs4 import BeautifulSoup
soup=BeautifulSoup(html_doc,'lxml')
import re
print(soup.find_all('a',class_='sister')) #查找类为sister的a标签
print(soup.find_all('a',class_='sister ssss')) #查找类为sister和sss的a标签，顺序错误也匹配不成功
print(soup.find_all(class_=re.compile('^sis'))) #查找类为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>]
[]
[<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>]

2.4、attrs

如果有多个属性，在attrs里面增加key-value即可

# 查询p标签,class属性为story
print(soup.find_all('p',attrs={'class':'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>, <p class="story">...</p>]

2.5、text

值可以是：字符，列表，True，正则

print(soup.find_all(text='Elsie'))
print(soup.find_all('a',text='Elsie'))

执行输出：

['Elsie']
[<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]

2.6、limit参数

如果文档树很大那么搜索会很慢.如果我们不需要全部结果,可以使用 limit 参数限制返回结果的数量.效果与SQL中的limit关键字类似,当搜索到的结果数量达到 limit 的限制时,就停止搜索返回结果

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

2.7、recursive

调用tag的 find_all() 方法时,Beautiful Soup会检索当前tag的所有子孙节点,如果只想搜索tag的直接子节点,可以使用参数 recursive=False

print(soup.html.find_all('a'))
print(soup.html.find_all('a',recursive=False))

执行输出：

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

备注

像调用 find_all() 一样调用tag
find_all() 几乎是Beautiful Soup中最常用的搜索方法,所以我们定义了它的简写方法. BeautifulSoup 对象和 tag 对象可以被当作一个方法来使用,
这个方法的执行结果与调用这个对象的 find_all() 方法相同,下面两行代码是等价的:
soup.find_all("a")
soup("a")
这两行代码也是等价的:
soup.title.find_all(text=True)
soup.title(text=True)

3、find()

语法

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

find_all() 方法将返回文档中符合条件的所有tag,尽管有时候我们只想得到一个结果.比如文档中只有一个标签,那么使用 find_all() 方法来查找标签就不太合适, 使用 find_all 方法并设置 limit=1 参数不如直接使用 find() 方法.下面两行代码是等价的:

from bs4 import BeautifulSoup
soup=BeautifulSoup(html_doc,'lxml')
print(soup.find_all('title', limit=1))
# soup.find_all('title', limit=1)
print(soup.find('title'))
# <title>The Dormouse's story</title>

唯一的区别是 find_all() 方法的返回结果是值包含一个元素的列表,而 find() 方法直接返回结果.

find_all() 方法没有找到目标是返回空列表, find() 方法找不到目标时,返回 None .

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

soup.head.title 是 tag的名字 方法的简写.这个简写的原理就是多次调用当前tag的 find() 方法:

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

4、其他方法

见官网: https://www.crummy.com/software/BeautifulSoup/bs4/doc/index.zh.html#find-parents-find-parent

5、css选择器

我们在写 CSS 时，标签名不加任何修饰，类名前加点，id名前加 #，在这里我们也可以利用类似的方法来筛选元素，用到的方法是 soup.select()，返回类型是 list

1. 通过标签名查找

from bs4 import BeautifulSoup
soup=BeautifulSoup(html_doc,'lxml')
print(soup.select("title"))  # [<title>The Dormouse's story</title>]
print(soup.select("b"))  # [<b class="boldest" id="bbb">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 #link2"))
#[<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

直接子标签查找

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

5. 属性查找

查找时还可以加入属性元素，属性需要用中括号括起来，注意属性和标签属于同一节点，所以中间不能加空格，否则会无法匹配到。

print(soup.select("a[href='http://example.com/tillie']"))
#[<a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

select 方法返回的结果都是列表形式，可以遍历形式输出，然后用 get_text() 方法来获取它的内容：

for title in soup.select('a'):
    print (title.get_text())
'''
Elsie
Lacie
Tillie
'''

5. 修改文档树

修改文档树

二、Xpath模块

xpath简介

XPath在Python的爬虫学习中，起着举足轻重的地位，对比正则表达式 re两者可以完成同样的工作，实现的功能也差不多，但XPath明显比re具有优势，在网页分析上使re退居二线。

XPath介绍

是什么？ 全称为XML Path Language 一种小型的查询语言

说道XPath是门语言，不得不说它所具备的优点：

• 可在XML中查找信息
• 支持HTML的查找 通
• 过元素和属性进行导航

python开发使用XPath条件： 由于XPath属于lxml库模块，所以首先要安装库lxml。

XPath的简单调用方法：

from lxml import etree
selector=etree.HTML(源码) #将源码转化为能被XPath匹配的格式
selector.xpath(表达式) #返回为一列表

Xpath语法

查询

html_doc = """
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<div class="d1">
    <div class="d2">
            <p class="story">
                <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" id="link3">Tillie</a>
            </p>
    </div>
    <div>
        <p id="p1">ALex is dsb</p>
        <p id="p2">Egon too</p>
    </div>
</div>
<div class="d3">
    <a href="http://www.baidu.com">baidu</a>
    <p>百度</p>
</div>
</body>
</html>
"""
from lxml import etree
selector=etree.HTML(html_doc) # 将源码转化为能被XPath匹配的格式

1. 选取节点

语法：

nodename     选取nodename节点的所有子节点         xpath(‘//div’)         选取了所有div节点
/            从根节点选取                        xpath(‘/div’)          从根节点上选取div节点
//           选取所有的当前节点，不考虑他们的位置    xpath(‘//div’)         选取所有的div节点
.            选取当前节点                        xpath(‘./div’)         选取当前节点下的div节点
..           选取当前节点的父节点                 xpath(‘..’)            回到上一个节点
@            选取属性                           xpath（’//@calss’）     选取所有的class属性

示例代码：

ret=selector.xpath("//div")
ret=selector.xpath("/div")
ret=selector.xpath("./div")
ret=selector.xpath("//p[@id='p1']")
ret=selector.xpath("//div[@class='d1']/div/p[@class='story']")

2. 谓语

语法：

表达式                                         结果
xpath(‘/body/div[1]’)                     选取body下的第一个div节点
xpath(‘/body/div[last()]’)                选取body下最后一个div节点
xpath(‘/body/div[last()-1]’)              选取body下倒数第二个div节点
xpath(‘/body/div[positon()<3]’)           选取body下前两个div节点
xpath(‘/body/div[@class]’)                选取body下带有class属性的div节点
xpath(‘/body/div[@class=”main”]’)         选取body下class属性为main的div节点
xpath(‘/body/div[price>35.00]’)           选取body下price元素值大于35的div节点

示例代码：

from lxml import etree
selector=etree.HTML(html_doc) # 将源码转化为能被XPath匹配的格式
ret=selector.xpath("//p[@class='story']//a[2]")  # [<Element a at 0x20d9a188c88>]
ret=selector.xpath("//p[@class='story']//a[last()]")  # [<Element a at 0x27a64818d88>]

返回结果是一个Element对象

3. 通配符

Xpath通过通配符来选取未知的XML元素

表达式                 结果
xpath（’/div/*’）     选取div下的所有子节点
xpath(‘/div[@*]’)    选取所有带属性的div节点

示例代码：

ret=selector.xpath("//p[@class='story']/*")
# [<Element a at 0x22c8461bcc8>, <Element a at 0x22c8461bc88>, <Element a at 0x22c8461bd88>]
ret=selector.xpath("//p[@class='story']/a[@class]")  # [<Element a at 0x1ebe370bc88>, <Element a at 0x1ebe370bd88>]

4. 取多个路径

使用“|”运算符可以选取多个路径

表达式                         结果
xpath(‘//div|//table’)    选取所有的div和table节点

示例代码：

ret=selector.xpath("//p[@class='story']/a[@class]|//div[@class='d3']")
print(ret)
# [<Element a at 0x1d509bd9cc8>, <Element a at 0x1d509bd9c88>, <Element div at 0x1d509bd9d88>]

5. Xpath轴

轴可以定义相对于当前节点的节点集

轴名称                      表达式                                  描述
ancestor                xpath(‘./ancestor::*’)              选取当前节点的所有先辈节点（父、祖父）
ancestor-or-self        xpath(‘./ancestor-or-self::*’)      选取当前节点的所有先辈节点以及节点本身
attribute               xpath(‘./attribute::*’)             选取当前节点的所有属性
child                   xpath(‘./child::*’)                 返回当前节点的所有子节点
descendant              xpath(‘./descendant::*’)            返回当前节点的所有后代节点（子节点、孙节点）
following               xpath(‘./following::*’)             选取文档中当前节点结束标签后的所有节点
following-sibing        xpath(‘./following-sibing::*’)      选取当前节点之后的兄弟节点
parent                  xpath(‘./parent::*’)                选取当前节点的父节点
preceding               xpath(‘./preceding::*’)             选取文档中当前节点开始标签前的所有节点
preceding-sibling       xpath(‘./preceding-sibling::*’)     选取当前节点之前的兄弟节点
self                    xpath(‘./self::*’)                  选取当前节点

6. 功能函数

使用功能函数能够更好的进行模糊搜索

函数                  用法                                                               解释
starts-with         xpath(‘//div[starts-with(@id,”ma”)]‘)                        选取id值以ma开头的div节点
contains            xpath(‘//div[contains(@id,”ma”)]‘)                           选取id值包含ma的div节点
and                 xpath(‘//div[contains(@id,”ma”) and contains(@id,”in”)]‘)    选取id值包含ma和in的div节点
text()              xpath(‘//div[contains(text(),”ma”)]‘)                        选取节点文本包含ma的div节点

举例1：

# 选取p标签class属性为story,在它下面的a标签id属性为link1的文本信息
ret=selector.xpath("//p[@class='story']/a[@id='link1']/text()")
print(ret)  # ['Elsie']

举例2：

# 选取p标签class属性为story,在它下面的a标签id属性以link开头的文本信息
ret=selector.xpath("//p[@class='story']/a[starts-with(@id,'link')]/text()")
print(ret)  # ['Elsie', 'Lacie', 'Tillie']

举例3：

# 选取p标签class属性为story,在它下面的a标签id属性包含k的文本信息
ret=selector.xpath("//p[@class='story']/a[contains(@id,'k')]/text()")
print(ret)  # ['Elsie', 'Lacie', 'Tillie']

举例4：

# 选取p标签class属性为story,在它下面的a标签class属性包含is的文本信息
ret=selector.xpath("//p[@class='story']/a[contains(@class,'is')]/text()")
print(ret)  # ['Elsie', 'Lacie']

举例5：

# 选取p标签class属性为story,在它下面的a标签文本信息包含ie的文本信息
ret=selector.xpath("//p[@class='story']/a[contains(text(),'ie')]/text()")
print(ret)  # ['Elsie', 'Lacie', 'Tillie']

Element对象

from lxml.etree import _Element
for obj in ret:
    print(obj)
    print(type(obj))  # from lxml.etree import _Element
'''
Element对象
class xml.etree.ElementTree.Element(tag, attrib={}, **extra)
　　tag：string，元素代表的数据种类。
　　text：string，元素的内容。
　　tail：string，元素的尾形。
　　attrib：dictionary，元素的属性字典。
　　
　　＃针对属性的操作
　　clear()：清空元素的后代、属性、text和tail也设置为None。
　　get(key, default=None)：获取key对应的属性值，如该属性不存在则返回default值。
　　items()：根据属性字典返回一个列表，列表元素为(key, value）。
　　keys()：返回包含所有元素属性键的列表。
　　set(key, value)：设置新的属性键与值。
　　＃针对后代的操作
　　append(subelement)：添加直系子元素。
　　extend(subelements)：增加一串元素对象作为子元素。＃python2.7新特性
　　find(match)：寻找第一个匹配子元素，匹配对象可以为tag或path。
　　findall(match)：寻找所有匹配子元素，匹配对象可以为tag或path。
　　findtext(match)：寻找第一个匹配子元素，返回其text值。匹配对象可以为tag或path。
　　insert(index, element)：在指定位置插入子元素。
　　iter(tag=None)：生成遍历当前元素所有后代或者给定tag的后代的迭代器。＃python2.7新特性
　　iterfind(match)：根据tag或path查找所有的后代。
　　itertext()：遍历所有后代并返回text值。
　　remove(subelement)：删除子元素。
'''

本文参考链接：

https://www.cnblogs.com/yuanchenqi/articles/9487175.html

应用案例：安居客

打开安居客二手房链接：

https://beijing.anjuke.com/sale/?from=navigation

需要爬取 标题

务必使用谷歌浏览器打开，右键检查。找到对应的标签，右键copy—>copy Xpath

那么就能得到

//*[@id="leftContent"]/ul/li[1]/div/div[1]/a

接下来写代码：

import requests
from lxml import etree
# 访问二手房网页
res= requests.get("https://beijing.anjuke.com/sale/?from=navigation")
selector=etree.HTML(res.content) # 将html源码转化为能被XPath匹配的格式
# 匹配第一个条信息的标题
ret=selector.xpath('//*[@id="houselist-mod-new"]/li[1]/div[2]/div[1]/a/text()')
print(ret)

执行输出：

['\n                凤凰城二期，高层两居室，看房有钥匙随时，临国际村，金星园澜石']

怎么样，是不是很方便。注意：它能帮你快速生成 XPath表达式。它并不是万能的，在某些动态加载的网页中，可能不适用！

上面的结果只有一条，如果有多条呢？需要自己修改规则了！

XPath Helper

XPath Helper可以支持在网页点击元素生成xpath，整个抓取使用了xpath、正则表达式、消息中间件、多线程调度框架的chrome插件。

这里我已经安装好了

安装完成之后，在页面右上角，有一个图标

点击一下，它会弹出一个黑框。将刚才的XPath规则复制到左边，右边会立即显示结果

如果被选中，页面会有黄色标记！

作业：

爬取链家二手房信息，爬取3页即可！

注意：使用XPath完成！

分解步骤

打开链接二手房链接：

https://bj.lianjia.com/ershoufang/

获取标题

获取第一条信息的标题

选择所有信息中的标题部分

使用python代码实现

import requests
from lxml import etree
# 访问二手房网页
res= requests.get("https://bj.lianjia.com/ershoufang/")
selector=etree.HTML(res.content) # 将html源码转化为能被XPath匹配的格式
# 匹配所有的标题
ret=selector.xpath('//*[@id="leftContent"]/ul/li[*]//div/div/a/text()')
print(ret)

执行输出：

['南向两居室 电梯房 简单装修 适合居住', '惠民家园 ', ...]

那么所有的标题，就获取完成了！