Day055爬虫（二）

七、数据提取-正则表达式

1. 提取数据

在前面我们已经搞定了怎样获取页面的内容，不过还差一步，这么多杂乱的代码夹杂文字我们怎样把它提取出来整理呢？下面就开始介绍一个十分强大的工具，正则表达式！

正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。

正则表达式是用来匹配字符串非常强大的工具，在其他编程语言中同样有正则表达式的概念，Python同样不例外，利用了正则表达式，我们想要从返回的页面内容提取出我们想要的内容就易如反掌了

规则：

2. 正则表达式相关注解

2.1 数量词的贪婪模式与非贪婪模式

正则表达式通常用于在文本中查找匹配的字符串 Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符

例如：正则表达式”ab”如果用于查找”abbbc”，将找到”abbb”。而如果使用非贪婪的数量词”ab?”，将找到”a”

2.2 常用方法

re.match re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none函数语法： re.match(pattern, string, flags=0)

re.search re.search 扫描整个字符串并返回第一个成功的匹配。函数语法： re.search(pattern, string, flags=0)

re.sub re.sub 替换字符串 re.sub(pattern,replace,string)

re.findall re.findall 查找全部 re.findall(pattern,string,flags=0)

3. 正则表达式修饰符 - 可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

八、08. 数据提取-Beautiful Soup

1. Beautiful Soup的简介

Beautiful Soup提供一些简单的、python式的函数用来处理导航、搜索、修改分析树等功能。它是一个工具箱，通过解析文档为用户提供需要抓取的数据，因为简单，所以不需要多少代码就可以写出一个完整的应用程序。 Beautiful Soup自动将输入文档转换为Unicode编码，输出文档转换为utf-8编码。你不需要考虑编码方式，除非文档没有指定一个编码方式，这时，Beautiful Soup就不能自动识别编码方式了。然后，你仅仅需要说明一下原始编码方式就可以了。 Beautiful Soup已成为和lxml、html6lib一样出色的python解释器，为用户灵活地提供不同的解析策略或强劲的速度

官网 http:// beautifulsoup.readthedocs.io /zh_CN/latest/

2. Beautiful Soup 安装

Beautiful Soup 3 目前已经停止开发，推荐在现在的项目中使用Beautiful Soup 4，不过它已经被移植到BS4了,也就是说导入时我们需要 import bs4 pip install beautifulsoup4 Beautiful Soup支持Python标准库中的HTML解析器,还支持一些第三方的解析器，如果我们不安装它，则 Python 会使用 Python默认的解析器，lxml 解析器更加强大，速度更快，推荐安装

3. 创建 Beautiful Soup 对象

from bs4 import BeautifulSoup bs = BeautifulSoup(html,"lxml")

4. 四大对象种类

Beautiful Soup将复杂HTML文档转换成一个复杂的树形结构,每个节点都是Python对象,所有对象可以归纳为4种: TagNavigableStringBeautifulSoupComment

4.1 Tag 是什么？通俗点讲就是 HTML 中的一个个标签

例如：<div> <title>

使用方式：

#以以下代码为例子 <title>标题</title> <div class='info' float='left'>Welcome to SXT</div> <div class='info' float='right'> <span>Good Good Study</span> <a href='www.bjsxt.cn'></a> <strong><!--没用--></strong> </div>

4.1.1 获取标签

#以lxml方式解析 soup = BeautifulSoup(info, 'lxml') print(soup.title) # <title>标题</title>

注意

相同的标签只能获取第一个符合要求的标签

4.1.2 获取属性：

#获取所有属性 print(soup.title.attrs) #class='info' float='left' #获取单个属性的值 print(soup.div.get('class')) print(soup.div['class']) print(soup.a['href']) #info

4.2 NavigableString 获取内容

print(soup.title.string) print(soup.title.text) 标题

4.3 BeautifulSoup

BeautifulSoup 对象表示的是一个文档的全部内容.大部分时候,可以把它当作 Tag 对象,它支持 遍历文档树 和 搜索文档树 中描述的大部分的方法. 因为 BeautifulSoup 对象并不是真正的HTML或XML的tag,所以它没有name和attribute属性.但有时查看它的 .name 属性是很方便的,所以 BeautifulSoup 对象包含了一个值为 “[document]” 的特殊属性 .name print(soup.name) print(soup.head.name) # [document] # head

4.4 Comment

Comment 对象是一个特殊类型的 NavigableString 对象，其实输出的内容仍然不包括注释符号，但是如果不好好处理它，可能会对我们的文本处理造成意想不到的麻烦 if type(soup.strong.string)==Comment: print(soup.strong.prettify()) else: print(soup.strong.string)

5 搜索文档树

Beautiful Soup定义了很多搜索方法,这里着重介绍2个: find() 和 find_all() .其它方法的参数和用法类似,请同学们举一反三

5.1 过滤器

介绍 find_all() 方法前,先介绍一下过滤器的类型 ,这些过滤器贯穿整个搜索的API.过滤器可以被用在tag的name中,节点的属性中,字符串中或他们的混合中

5.1.1 字符串

最简单的过滤器是字符串.在搜索方法中传入一个字符串参数,Beautiful Soup会查找与字符串完整匹配的内容,下面的例子用于查找文档中所有的<div>标签 #返回所有的div标签 print(soup.find_all('div')) 如果传入字节码参数,Beautiful Soup会当作UTF-8编码,可以传入一段Unicode 编码来避免Beautiful Soup解析编码出错

5.1.2 正则表达式

如果传入正则表达式作为参数,Beautiful Soup会通过正则表达式的 match() 来匹配内容

#返回所有的div标签 print (soup.find_all(re.compile("^div")))

5.1.3 列表

如果传入列表参数,Beautiful Soup会将与列表中任一元素匹配的内容返回 #返回所有匹配到的span a标签 print(soup.find_all(['span','a']))

5.1.4 keyword

如果一个指定名字的参数不是搜索内置的参数名,搜索时会把该参数当作指定名字tag的属性来搜索,如果包含一个名字为 id 的参数,Beautiful Soup会搜索每个tag的”id”属性 #返回id为welcom的标签 print(soup.find_all(id='welcom'))

5.1.4 True

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

5.1.5 按CSS搜索

按照CSS类名搜索tag的功能非常实用,但标识CSS类名的关键字 class 在Python中是保留字,使用 class 做参数会导致语法错误.从Beautiful Soup的4.1.1版本开始,可以通过 class_ 参数搜索有指定CSS类名的tag # 返回class等于info的div print(soup.find_all('div',class_='info'))

5.1.6 按属性的搜索

soup.find_all("div", attrs={"class": "info"})

6. CSS选择器（扩展）

soup.select(参数)

九、09. 数据提取-XPath

1. 介绍

之前 BeautifulSoup 的用法，这个已经是非常强大的库了，不过还有一些比较流行的解析库，例如 lxml，使用的是 Xpath 语法，同样是效率比较高的解析方法。如果大家对 BeautifulSoup 使用不太习惯的话，可以尝试下 Xpath

官网 http://lxml.de/index.html

w3c http://www.w3school.com.cn/xpath/index.asp

2. 安装

pip install lxml

3. XPath语法

XPath 是一门在 XML 文档中查找信息的语言。XPath 可用来在 XML 文档中对元素和属性进行遍历。XPath 是 W3C XSLT 标准的主要元素，并且 XQuery 和 XPointer 都构建于 XPath 表达之上

3.1 节点的关系

父（Parent）子（Children）同胞（Sibling）先辈（Ancestor）后代（Descendant）

3.2 选取节点

3.2.1 常用的路径表达式

3.2.2 通配符

XPath 通配符可用来选取未知的 XML 元素。

3.2.3 选取若干路径

通过在路径表达式中使用“|”运算符，您可以选取若干个路径

3.2.4 谓语

谓语被嵌在方括号内，用来查找某个特定的节点或包含某个制定的值的节点

3.2.5 XPath 运算符

3.3 使用

3.3.1 小例子

from lxml import etree text = ''' <div> <ul> <li class="item-0"><a href="link1.html">first item</a></li> <li class="item-1"><a href="link2.html">second item</a></li> <li class="item-inactive"><a href="link3.html">third item</a></li> <li class="item-1"><a href="link4.html">fourth item</a></li> <li class="item-0"><a href="link5.html">fifth item</a> </ul> </div> ''' html = etree.HTML(text) result = etree.tostring(html) print(result)

首先我们使用 lxml 的 etree 库，然后利用 etree.HTML 初始化，然后我们将其打印出来。

其中，这里体现了 lxml 的一个非常实用的功能就是自动修正 html 代码，大家应该注意到了，最后一个 li 标签，其实我把尾标签删掉了，是不闭合的。不过，lxml 因为继承了 libxml2 的特性，具有自动修正 HTML 代码的功能。

所以输出结果是这样的

<html><body> <div> <ul> <li class="item-0"><a href="link1.html">first item</a></li> <li class="item-1"><a href="link2.html">second item</a></li> <li class="item-inactive"><a href="link3.html">third item</a></li> <li class="item-1"><a href="link4.html">fourth item</a></li> <li class="item-0"><a href="link5.html">fifth item</a></li> </ul> </div> </body></html>

不仅补全了 li 标签，还添加了 body，html 标签。 文件读取

除了直接读取字符串，还支持从文件读取内容。比如我们新建一个文件叫做 hello.html，内容为

<div> <ul> <li class="item-0"><a href="link1.html">first item</a></li> <li class="item-1"><a href="link2.html">second item</a></li> <li class="item-inactive"><a href="link3.html"><span class="bold">third item</span></a></li> <li class="item-1"><a href="link4.html">fourth item</a></li> <li class="item-0"><a href="link5.html">fifth item</a></li> </ul> </div>

利用 parse 方法来读取文件

from lxml import etree html = etree.parse('hello.html') result = etree.tostring(html, pretty_print=True) print(result)

同样可以得到相同的结果

3.3.2 XPath具体使用

依然以上一段程序为例

获取所有的 <li> 标签 from lxml import etree html = etree.parse('hello.html') print (type(html)) result = html.xpath('//li') print (result) print (len(result)) print (type(result)) print (type(result[0]))

运行结果

<type 'lxml.etree._ElementTree'> [<Element li at 0x1014e0e18>, <Element li at 0x1014e0ef0>, <Element li at 0x1014e0f38>, <Element li at 0x1014e0f80>, <Element li at 0x1014e0fc8>] <type 'list'> <type 'lxml.etree._Element'>

可见，etree.parse 的类型是 ElementTree，通过调用 xpath 以后，得到了一个列表，包含了 5 个 <li> 元素，每个元素都是 Element 类型

获取<li>标签的所有 class result = html.xpath('//li/@class') print (result)

运行结果

['item-0', 'item-1', 'item-inactive', 'item-1', 'item-0'] 获取 <li> 标签下 href 为 link1.html 的 <a> 标签 result = html.xpath('//li/a[@href="link1.html"]') print (result)

运行结果

[<Element a at 0x10ffaae18>] 获取<li>标签下的所有 <span> 标签

注意: 这么写是不对的

result = html.xpath('//li/span') #因为 / 是用来获取子元素的，而 <span> 并不是 <li> 的子元素，所以，要用双斜杠 result = html.xpath('//li//span') print(result)

运行结果

[<Element span at 0x10d698e18>] 获取 <li> 标签下的所有 class，不包括<li> result = html.xpath('//li/a//@class') print (resul)t #运行结果 ['blod'] 获取最后一个 <li> 的 <a> 的 href result = html.xpath('//li[last()]/a/@href') print (result)

运行结果

['link5.html'] 获取倒数第二个元素的内容 result = html.xpath('//li[last()-1]/a') print (result[0].text)

运行结果

fourth item 获取 class 为 bold 的标签名 result = html.xpath('//*[@class="bold"]') print (result[0].tag)

运行结果

span

选择XML文件中节点：

element（元素节点）attribute（属性节点）text （文本节点）concat(元素节点,元素节点)comment （注释节点）root （根节点）

十、数据提取-JsonPath

1. JSON与JsonPATH

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，它使得人们很容易的进行阅读和编写。同时也方便了机器进行解析和生成。适用于进行数据交互的场景，比如网站前台与后台之间的数据交互。

JSON和XML的比较可谓不相上下。

Python 中自带了JSON模块，直接import json就可以使用了。

官方文档：http://docs.python.org/library/json.html

Json在线解析网站：http://www.json.cn/#

2. JSON

json简单说就是javascript中的对象和数组，所以这两种结构就是对象和数组两种结构，通过这两种结构可以表示各种复杂的结构

对象：对象在js中表示为{ }括起来的内容，数据结构为 { key：value, key：value, ... }的键值对的结构，在面向对象的语言中，key为对象的属性，value为对应的属性值，所以很容易理解，取值方法为 对象.key 获取属性值，这个属性值的类型可以是数字、字符串、数组、对象这几种数组：数组在js中是中括号[ ]括起来的内容，数据结构为 ["Python", "javascript", "C++", ...]，取值方式和所有语言中一样，使用索引获取，字段值的类型可以是 数字、字符串、数组、对象几种

3. Python中的json模块

json模块提供了四个功能：dumps、dump、loads、load，用于字符串 和 python数据类型间进行转换

3.1 json.loads()

把Json格式字符串解码转换成Python对象 从json到python的类型转化对照如下： import json strList = '[1, 2, 3, 4]' strDict = '{"city": "北京", "name": "范爷"}' json.loads(strList) # [1, 2, 3, 4] json.loads(strDict) # json数据自动按Unicode存储 # {u'city': u'\u5317\u4eac', u'name': u'\u5927\u732b'}

3.2 json.dumps()

实现python类型转化为json字符串，返回一个str对象 把一个Python对象编码转换成Json字符串

从python原始类型向json类型的转化对照如下：

# json_dumps.py import json listStr = [1, 2, 3, 4] tupleStr = (1, 2, 3, 4) dictStr = {"city": "北京", "name": "范爷"} json.dumps(listStr) # '[1, 2, 3, 4]' json.dumps(tupleStr) # '[1, 2, 3, 4]' # 注意：json.dumps() 序列化时默认使用的ascii编码 # 添加参数 ensure_ascii=False 禁用ascii编码，按utf-8编码 json.dumps(dictStr) # '{"city": "\\u5317\\u4eac", "name": "\\u5927\\u5218"}' print(json.dumps(dictStr, ensure_ascii=False)) # {"city": "北京", "name": "范爷"}

3.3 json.dump()

将Python内置类型序列化为json对象后写入文件 import json listStr = [{"city": "北京"}, {"name": "范爷"}] json.dump(listStr, open("listStr.json","w"), ensure_ascii=False) dictStr = {"city": "北京", "name": "范爷"} json.dump(dictStr, open("dictStr.json","w"), ensure_ascii=False)

3.4 json.load()

读取文件中json形式的字符串元素 转化成python类型 import json strList = json.load(open("listStr.json")) print(strList) # [{u'city': u'\u5317\u4eac'}, {u'name': u'\u5927\u5218'}] strDict = json.load(open("dictStr.json")) print(strDict) # {u'city': u'\u5317\u4eac', u'name': u'\u5927\u5218'}

4 JsonPath

JsonPath 是一种信息抽取类库，是从JSON文档中抽取指定信息的工具，提供多种语言实现版本，包括：Javascript, Python， PHP 和 Java。

JsonPath 对于 JSON 来说，相当于 XPATH 对于 XML。

安装方法：pip install jsonpath

官方文档：http://goessner.net/articles/JsonPath

5 JsonPath与XPath语法对比

Json结构清晰，可读性高，复杂度低，非常容易匹配，下表中对应了XPath的用法

XPathJSONPath描述/$根节点.@现行节点/.or[]取子节点..n/a取父节点，Jsonpath未支持//..就是不管位置，选择所有符合条件的条件**匹配所有元素节点@n/a根据属性访问，Json不支持，因为Json是个Key-value递归结构，不需要。[][]迭代器标示（可以在里边做简单的迭代操作，如数组下标，根据内容选值等）[,][]?()支持过滤操作.n/a()支持表达式计算()n/a分组，JsonPath不支持

6. 示例

我们以拉勾网城市JSON文件 http://www.lagou.com/lbs/getAllCitySearchLabels.json 为例，获取所有城市

from urllib.request import urlopen from urllib.request import Request import jsonpath import json url = 'http://www.lagou.com/lbs/getAllCitySearchLabels.json' request =Request(url) response = urlopen(request) html = response.read() # 把json格式字符串转换成python对象 jsonobj = json.loads(html) # 从根节点开始，匹配name节点 citylist = jsonpath.jsonpath(jsonobj,'$..name') print(citylist) print(type(citylist)) fp = open('city.json','w') content = json.dumps(citylist, ensure_ascii=False) print(content) fp.write(content) fp.close()

7. 注意事项

json.loads() 是把 Json格式字符串解码转换成Python对象，如果在json.loads的时候出错，要注意被解码的Json字符的编码。 如果传入的字符串的编码不是UTF-8的话，需要指定字符编码的参数 encoding dataDict = json.loads(jsonStrGBK); dataJsonStr是JSON字符串，假设其编码本身是非UTF-8的话而是GBK 的，那么上述代码会导致出错，改为对应的：dataDict = json.loads(jsonStrGBK, encoding="GBK"); 如果 dataJsonStr通过encoding指定了合适的编码，但是其中又包含了其他编码的字符，则需要先去将dataJsonStr转换为Unicode，然后再指定编码格式调用json.loads()dataJsonStrUni = dataJsonStr.decode("GB2312"); dataDict = json.loads(dataJsonStrUni, encoding="GB2312");

7.1 字符串编码转换

这是中国程序员最苦逼的地方，什么乱码之类的几乎都是由汉字引起的

其实编码问题很好搞定，只要记住一点：

任何平台的任何编码 都能和 Unicode 互相转换

UTF-8 与 GBK 互相转换，那就先把UTF-8转换成Unicode，再从Unicode转换成GBK，反之同理。

# 这是一个 UTF-8 编码的字符串 utf8Str = "你好地球" # 1. 将 UTF-8 编码的字符串 转换成 Unicode 编码 unicodeStr = utf8Str.decode("UTF-8") # 2. 再将 Unicode 编码格式字符串 转换成 GBK 编码 gbkData = unicodeStr.encode("GBK") # 1. 再将 GBK 编码格式字符串 转化成 Unicode unicodeStr = gbkData.decode("gbk") # 2. 再将 Unicode 编码格式字符串转换成 UTF-8 utf8Str = unicodeStr.encode("UTF-8")

decode的作用是将其他编码的字符串转换成 Unicode 编码

encode的作用是将 Unicode 编码转换成其他编码的字符串

一句话：UTF-8是对Unicode字符集进行编码的一种编码方式

十一、 数据提取-PyQuery

1. pyquery

1.1 介绍

如果你对CSS选择器与Jquery有有所了解，那么还有个解析库可以适合你--Jquery 官网 https://pythonhosted.org/pyquery/

1.2 安装

pip install pyquery

1.3 使用方式

1.3.1 初始化方式

字符串 from pyquery import PyQuery as pq doc = pq(str) print(doc(tagname)) url from pyquery import PyQuery as pq doc = pq(url='http://www.baidu.com') print(doc('title')) 文件 from pyquery import PyQuery as pq doc = pq(filename='demo.html') print(doc(tagname))

1.3.2 选择节点

获取当前节点 from pyquery import PyQuery as pq doc = pq(filename='demo.html') doc('#main #top') 获取子节点 在doc中一层层写出来获取到父标签后使用children方法

from pyquery import PyQuery as pq doc = pq(filename='demo.html') doc('#main #top').children() 获取父节点 获取到当前节点后使用parent方法

获取兄弟节点 获取到当前节点后使用siblings方法

1.3.3 获取属性

from pyquery import PyQuery as pq doc = pq(filename='demo.html') a = doc('#main #top') print(a.attrib['href']) print(a.attr('href'))

1.3.4 获取内容

from pyquery import PyQuery as pq doc = pq(filename='demo.html') div = doc('#main #top') print(a.html()) print(a.text())

1.3.5 样例

from pyquery import PyQuery as pq # 1.可加载一段HTML字符串，或一个HTML文件，或是一个url地址， d=pq("<html><title>hello</title></html>") d=pq(filename=path_to_html_file) d=pq(url='http://www.baidu.com')注意：此处url似乎必须写全 # 2.html()和text() ——获取相应的HTML块或文本块， p=pq("<head><title>hello</title></head>") p('head').html()#返回<title>hello</title> p('head').text()#返回hello # 3.根据HTML标签来获取元素， d=pq('<div><p>test 1</p><p>test 2</p></div>') d('p')#返回[<p>,<p>] print d('p')#返回<p>test 1</p><p>test 2</p> print d('p').html()#返回test 1 # 注意：当获取到的元素不只一个时，html()方法只返回首个元素的相应内容块 # 4.eq(index) ——根据给定的索引号得到指定元素。接上例，若想得到第二个p标签内的内容，则可以： print d('p').eq(1).html() #返回test 2 # 5.filter() ——根据类名、id名得到指定元素，例： d=pq("<div><p id='1'>test 1</p><p class='2'>test 2</p></div>") d('p').filter('#1') #返回[<p#1>] d('p').filter('.2') #返回[<p.2>] # 6.find() ——查找嵌套元素，例： d=pq("<div><p id='1'>test 1</p><p class='2'>test 2</p></div>") d('div').find('p')#返回[<p#1>, <p.2>] d('div').find('p').eq(0)#返回[<p#1>] #7.直接根据类名、id名获取元素，例： d=pq("<div><p id='1'>test 1</p><p class='2'>test 2</p></div>") d('#1').html()#返回test 1 d('.2').html()#返回test 2 # 8.获取属性值，例： d=pq("<p id='my_id'><a href='http://hello.com'>hello</a></p>") d('a').attr('href')#返回http://hello.com d('p').attr('id')#返回my_id # 9.修改属性值，例： d('a').attr('href', 'http://baidu.com')把href属性修改为了baidu # 10.addClass(value) ——为元素添加类，例： d=pq('<div></div>') d.addClass('my_class')#返回[<div.my_class>] # 11.hasClass(name) #返回判断元素是否包含给定的类，例： d=pq("<div class='my_class'></div>") d.hasClass('my_class')#返回True # 12.children(selector=None) ——获取子元素，例： d=pq("<span><p id='1'>hello</p><p id='2'>world</p></span>") d.children()#返回[<p#1>, <p#2>] d.children('#2')#返回[<p#2>] # 13.parents(selector=None)——获取父元素，例： d=pq("<span><p id='1'>hello</p><p id='2'>world</p></span>") d('p').parents()#返回[<span>] d('#1').parents('span')#返回[<span>] d('#1').parents('p')#返回[] # 14.clone() ——返回一个节点的拷贝 #15.empty() ——移除节点内容 # 16.nextAll(selector=None) ——返回后面全部的元素块，例： d=pq("<p id='1'>hello</p><p id='2'>world</p><img scr='' />") d('p:first').nextAll()#返回[<p#2>, <img>] d('p:last').nextAll()#返回[<img>] # 17.not_(selector) ——返回不匹配选择器的元素，例： d=pq("<p id='1'>test 1</p><p id='2'>test 2</p>") d('p').not_('#2')#返回[<p#1>]