四、数据提取

一、正则表达式

 1. 提取数据

正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。正则表达式是用来匹配字符串非常强大的工具，在其他编程语言中同样有正则表达式的概念，Python同样不例外，利用了正则表达式，我们想要从返回的页面内容提取出我们想要的内容就易如反掌了

**规则**：模式 | 描述         --|--

^ | 匹配字符串的开头

$ | 匹配字符串的末尾

. | 匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符

[...] | 用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'

[^...] | 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符

re* | 匹配0个或多个的表达式

re+ | 匹配1个或多个的表达式

re? | 匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式

re{ n} |

re{ n,} | 精确匹配n个前面表达式

re{ n, m} | 匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式

a |  b | 匹配a或b

(re) | G匹配括号内的表达式，也表示一个组

(?imx) | 正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域

(?-imx) | 正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域

(?: re) | 类似 (...), 但是不表示一个组

(?imx: re) | 在括号中使用i, m, 或 x 可选标志

(?-imx: re) | 在括号中不使用i, m, 或 x 可选标志

(?#...) | 注释

(?= re) | 前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。

(?! re) | 前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功

(?> re) | 匹配的独立模式，省去回溯

\w | 匹配字母数字及下划线

\W | 匹配非字母数字及下划线

\s | 匹配任意空白字符，等价于 [\t\n\r\f].

\S | 匹配任意非空字符

\d | 匹配任意数字，等价于 [0-9]

\D | 匹配任意非数字

\A | 匹配字符串开始

\Z | 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。c

\z | 匹配字符串结束

\G | 匹配最后匹配完成的位置

\b | 匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'

\B | 匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'

\n, \t, 等. | 匹配一个换行符。匹配一个制表符。等

\1...\9 | 匹配第n个分组的内容

\10 | 匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式

[\u4e00-\u9fa5]|中文

2. 正则表达式相关注解

1） 数量词的贪婪模式与非贪婪模式

正则表达式通常用于在文本中查找匹配的字符串

Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符

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

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 标志：

修饰符|描述          --|--

re.I|使匹配对大小写不敏感

re.L|做本地化识别（locale-aware）匹配

re.M||多行匹配，影响 ^ 和

re.S|使 . 匹配包括换行在内的所有字符

re.U|根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B

re.X|该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解

二、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/)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 解析器更加强大，速度更快，推荐安装

解析器 | 使用方法 | 优势  | 劣势

--- | --- | --- | ---

Python标准库 | BeautifulSoup(markup, “html.parser”)| 1. Python的内置标准库  2. 执行速度适中 3.文档容错能力强 |Python 2.7.3 or 3.2.2)前 的版本中文档容错能力差

lxml HTML 解析器 | BeautifulSoup(markup, “lxml”) | 1. 速度快 2.文档容错能力强  | 需要安装C语言库

lxml XML 解析器 | BeautifulSoup(markup, [“lxml”, “xml”])  BeautifulSoup(markup, “xml”) | 1. 速度快 2.唯一支持XML的解析器 3.需要安装C语言库

html5lib | BeautifulSoup(markup, “html5lib”) | 1. 最好的容错性 2.以浏览器的方式解析文档 3.生成HTML5格式的文档 4.速度慢 | 不依赖外部扩展

 3. 创建 Beautiful Soup 对象

```

from bs4 import BeautifulSoup

bs = BeautifulSoup(html,"lxml")

```

4. 四大对象种类

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

- Tag

- NavigableString

- BeautifulSoup

- Comment

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'))

```

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(参数)

表达式 | 说明

--|--

tag | 选择指定标签

* | 选择所有节点

#id |选择id为container的节点

.class |选取所有class包含container的节点

li a |选取所有li下的所有a节点

ul + p |(兄弟)选择ul后面的第一个p元素

div#id > ul |(父子)选取id为id的div的第一个ul子元素

table ~ div |选取与table相邻的所有div元素

a[title] |选取所有有title属性的a元素

a[class=”title”] |选取所有class属性为title值的a

a[href*=”sxt”] |选取所有href属性包含sxt的a元素

a[href^=”http”] |选取所有href属性值以http开头的a元素

a[href$=”.png”] |选取所有href属性值以.png结尾的a元素

input[type="redio"]:checked |选取选中的hobby的元素

三、XPath

 1. 介绍

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

[官网](http://lxml.de/index.html) http://lxml.de/index.html

[w3c](http://www.w3school.com.cn/xpath/index.asp) 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 常用的路径表达式

表达式 | 描述

--|--

nodename | 选取此节点的所有子节点

/ | 从根节点选取

// | 从匹配选择的当前节点选择文档中的节点，而不考虑它们的位置

. | 选取当前节点

.. | 选取当前节点的父节点

@ | 选取属性

3.2.2 通配符

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

通配符 | 描述 | 举例 | 结果

--|-- |-- | --

* | 匹配任何元素节点|xpath('div/*') | 获取div下的所有子节点

@* | 匹配任何属性节点|xpath('div[@*]') |选取所有带属性的div节点

node() | 匹配任何类型的节点

3.2.3 选取若干路径

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

表达式 | 结果

--|--

xpath('//div`|`//table')|获取所有的div与table节点

 3.2.4 谓语

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

表达式 | 结果

--|--

xpath('/body/div[1]')|选取body下的第一个div节点

xpath('/body/div[last()]')|选取body下最后一个div节点

xpath('/body/div[last()-1]')|选取body下倒数第二个节点

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节点

 3.2.5 XPath 运算符

运算符 | 描述 | 实例  | 返回值

--|--|--|--|

| | 计算两个节点集 | //book | //cd | 返回所有拥有 book 和 cd 元素的节点集

+ | 加法 | 6 + 4 | 10

– | 减法 | 6 – 4 | 2

* | 乘法 | 6 * 4 | 24

div | 除法 | 8 div 4 | 2

= | 等于 | price=9.80 | 如果 price 是 9.80，则返回 true。如果 price 是 9.90，则返回 false。

!= | 不等于 | price!=9.80 | 如果 price 是 9.90，则返回 true。如果 price 是 9.80，则返回 false。

< | 小于 | price<9.80 | 如果 price 是 9.00，则返回 true。如果 price 是 9.90，则返回 false。

<= | 小于或等于 | price<=9.80 | 如果 price 是 9.00，则返回 true。如果 price 是 9.90，则返回 false。

> | 大于 | price>9.80 | 如果 price 是 9.90，则返回 true。如果 price 是 9.80，则返回 false。

>= | 大于或等于 | price>=9.80 | 如果 price 是 9.90，则返回 true。如果 price 是 9.70，则返回 false。

or | 或 | price=9.80 or price=9.70 | 如果 price 是 9.80，则返回 true。如果 price 是 9.50，则返回 false。

and | 与 | price>9.00 and price<9.90 | 如果 price 是 9.80，则返回 true。如果 price 是 8.50，则返回 false。

mod | 计算除法的余数 | 5 mod 2 | 1

 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具体使用

依然以上一段程序为例

1. 获取所有的 `<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 类型

2. 获取` <li> `标签的所有 class

```

result = html.xpath('//li/@class')

print (result)

```

运行结果

```

['item-0', 'item-1', 'item-inactive', 'item-1', 'item-0']

```

3. 获取 `<li>` 标签下 href 为 link1.html 的 `<a>` 标签

```

result = html.xpath('//li/a[@href="link1.html"]')

print (result)

```

运行结果

```

[<Element a at 0x10ffaae18>]

```

4. 获取` <li> `标签下的所有 `<span>` 标签

**注意**: 这么写是不对的

```

result = html.xpath('//li/span')

#因为 / 是用来获取子元素的，而 <span> 并不是 <li> 的子元素，所以，要用双斜杠

result = html.xpath('//li//span')

print(result)

```

运行结果

```

[<Element span at 0x10d698e18>]

```

5. 获取 `<li>` 标签下的所有 class，不包括`<li>`

```

result = html.xpath('//li/a//@class')

print (resul)t

#运行结果

['blod']

```

6. 获取最后一个 `<li>` 的 `<a>` 的 href

```

result = html.xpath('//li[last()]/a/@href')

print (result)

```

运行结果

```

['link5.html']

```

7. 获取倒数第二个元素的内容

```

result = html.xpath('//li[last()-1]/a')

print (result[0].text)

```

运行结果

```

fourth item

```

8. 获取 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中的对象和数组，所以这两种结构就是对象和数组两种结构，通过这两种结构可以表示各种复杂的结构

1. 对象：对象在js中表示为{ }括起来的内容，数据结构为 { key：value, key：value, ... }的键值对的结构，在面向对象的语言中，key为对象的属性，value为对应的属性值，所以很容易理解，取值方法为 对象.key 获取属性值，这个属性值的类型可以是数字、字符串、数组、对象这几种

2. 数组：数组在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的用法

XPath | JSONPath | 描述

--|--|--

/ | $ | 根节点

. | @ | 现行节点

/ | .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/)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'])

```

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

```

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,294评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,493评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,790评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,595评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,718评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,906评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,053评论 3赞 410
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,797评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,250评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,570评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,711评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,388评论 4赞 332
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,018评论 3赞 316
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,796评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,023评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,461评论 2赞 360
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,595评论 2赞 350