Python爬虫原理与常用模块——数据提取与清洗策略

- 日理万妓 2022-12-09 11:54 206阅读 0赞

# 1 正则表达式 #

## 1.1概念 ##

世界上信息非常多，而我们关注的信息有限。假如我们希望只提取出关注的数据，此时可以通过一些表达式进行提取，正则表达式就是其中一种进行数据筛选的表达式。

正则表达式(Regular Expression)是一种文本模式，包括普通字符（例如，a 到 z之间的字母）和特殊字符（称为"元字符"）。

正则表达式通常被用来匹配、检索、替换和分割那些符合某个模式(规则)的文本

Python 自1.5版本起增加了re模块，它提供Perl风格的正则表达式模式。

re 模块使 Python 语言拥有全部的正则表达式功能,使用前需要使用 import re导入此模块

## 1.2 原子 ##

### 1.2.1 概念 ###

原子是正则表达式中最基本的组成单位，每个正则表达式中至少包含一个原子。

常见的原子类型有：

普通字符作为原子 如：a b c 字母

非打印字符作为原子 如：\\n \\t

通用字符作为原子 如：\\d \\D \\w \\W \\s \\S

原子表 如：多个原子拼接在一起

### 1.2.2 非打印字符 ###

<table> 
 <thead> 
  <tr> 
   <th><strong>字符</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>\cx</td> 
   <td>匹配由x指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 ‘c’ 字符。</td> 
  </tr> 
  <tr> 
   <td>\f</td> 
   <td>匹配一个换页符。等价于 \x0c 和 \cL。</td> 
  </tr> 
  <tr> 
   <td>\n</td> 
   <td>匹配一个换行符。等价于 \x0a 和 \cJ。</td> 
  </tr> 
  <tr> 
   <td>\r</td> 
   <td>匹配一个回车符。等价于 \x0d 和 \cM。</td> 
  </tr> 
  <tr> 
   <td>\s</td> 
   <td>匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。</td> 
  </tr> 
  <tr> 
   <td>\S</td> 
   <td>匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。</td> 
  </tr> 
  <tr> 
   <td>\t</td> 
   <td>匹配一个制表符。等价于 \x09 和 \cI。</td> 
  </tr> 
  <tr> 
   <td>\v</td> 
   <td>匹配一个垂直制表符。等价于 \x0b 和 \cK。</td> 
  </tr> 
 </tbody> 
</table>

### 1.2.3 通用字符 ###

<table> 
 <thead> 
  <tr> 
   <th><strong>字符</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>\d</td> 
   <td>匹配一个数字字符。等价于[0-9]。</td> 
  </tr> 
  <tr> 
   <td>\D</td> 
   <td>匹配一个非数字字符。等价于[^0-9]。</td> 
  </tr> 
  <tr> 
   <td>\s</td> 
   <td>匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [\f\n\r\t\v]。</td> 
  </tr> 
  <tr> 
   <td>\S</td> 
   <td>匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。</td> 
  </tr> 
  <tr> 
   <td>\w</td> 
   <td>匹配字母、数字、下划线。等价于’[A-Za-z0-9_]’。</td> 
  </tr> 
  <tr> 
   <td>\W</td> 
   <td>匹配非字母、数字、下划线。等价于 ‘[^A-Za-z0-9_]’。</td> 
  </tr> 
 </tbody> 
</table>

## 1.3 元字符 ##

### 1.3.1 概念 ###

所谓的元字符，就是正则表达式中具有一些特殊含义的字符，比如重复N次前面的字符等。

### 1.3.2 常用的元字符 ###

<table> 
 <thead> 
  <tr> 
   <th><strong>字符</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>.</td> 
   <td>匹配除 “\n” 之外的任何单个字符。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>要匹配包括 ‘\n’ 在内的任何字符，请使用像"(.¦\n)"的模式。</td> 
  </tr> 
  <tr> 
   <td>[xyz]</td> 
   <td>字符集合。匹配所包含的任意一个字符。例如， ‘[abc]’ 可以匹配 “plain” 中的 ‘a’。</td> 
  </tr> 
  <tr> 
   <td>[^xyz]</td> 
   <td>负值字符集合。匹配未包含的任意字符。例如， ‘[^abc]’ 可以匹配 “plain” 中的’p’、‘l’、‘i’、‘n’。</td> 
  </tr> 
  <tr> 
   <td>[a-z]</td> 
   <td>字符范围。匹配指定范围内的任意字符。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>例如，’[a-z]’ 可以匹配 ‘a’ 到 ‘z’ 范围内的任意小写字母字符。</td> 
  </tr> 
  <tr> 
   <td>[^a-z]</td> 
   <td>负值字符范围。匹配任何不在指定范围内的任意字符。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>例如，’[^a-z]’ 可以匹配任何不在 ‘a’ 到 'z’范围内的任意字符。</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>匹配前面的子表达式零次或多次。例如，zo 能匹配 “z” 以及 “zoo”。 等价于{0,}。</td> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>匹配前面的子表达式一次或多次。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>例如，‘zo+’ 能匹配 “zo” 以及 “zoo”，但不能匹配 “z”。+ 等价于 {1,}。</td> 
  </tr> 
  <tr> 
   <td>?</td> 
   <td>匹配前面的子表达式零次或一次。例如，“do(es)?” 可以匹配 “do” 或 “does” 。? 等价于 {0,1}。</td> 
  </tr> 
  <tr> 
   <td>{n}</td> 
   <td>n 是一个非负整数。匹配确定的 n 次。</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>例如，‘o{2}’ 不能匹配 “Bob” 中的 ‘o’，但是能匹配 “food” 中的两个 o。</td> 
  </tr> 
  <tr> 
   <td>{n,}</td> 
   <td>n 是一个非负整数。至少匹配n 次。例如，‘o{2,}’ 不能匹配 “Bob” 中的 ‘o’，但能匹配 “foooood” 中的所有 o。‘o{1,}’ 等价于 ‘o+’。‘o{0,}’ 则等价于 ‘o*’。</td> 
  </tr> 
  <tr> 
   <td>{n,m}</td> 
   <td>m 和 n 均为非负整数，其中n &lt;= m。最少匹配 n 次且最多匹配 m 次。例如，“o{1,3}” 将匹配 “fooooood” 中的前三个 o。‘o{0,1}’ 等价于 ‘o?’。请注意在逗号和两个数之间不能有空格。</td> 
  </tr> 
  <tr> 
   <td>\</td> 
   <td>将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，‘n’ 匹配字符 “n”。’\n’ 匹配一个换行符。序列 ‘\’ 匹配 “\” 而 “(” 则匹配 “(”。</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 ‘\n’ 或 ‘\r’ 之后的位置。</td> 
  </tr> 
  <tr> 
   <td>$</td> 
   <td>匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 ‘\n’ 或 ‘\r’ 之前的位置。</td> 
  </tr> 
  <tr> 
   <td>?</td> 
   <td>当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 “oooo”，‘o+?’ 将匹配单个 “o”，而 ‘o+’ 将匹配所有 ‘o’。</td> 
  </tr> 
  <tr> 
   <td>(pattern)</td> 
   <td>匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 ‘(’ 或 ‘)’。</td> 
  </tr> 
  <tr> 
   <td>(?:pattern)</td> 
   <td>匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 “或” 字符 (¦) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y¦ies) 就是一个比’industry¦industries’更简略的表达式。</td> 
  </tr> 
  <tr> 
   <td>x¦y</td> 
   <td>匹配 x 或 y。例如，‘z¦food’ 能匹配 “z” 或 “food”。’(z¦f)ood’ 则匹配 “zood” 或 “food”。</td> 
  </tr> 
 </tbody> 
</table>

### 1.3.3 实例 ###

import re 
    
    rst = re.rearch('',str)

## 1.4 模式修正符 ##

### 1.4.1 概念 ###

所谓模式修正符，即可以在不改变正则表达式的情况下，通过模式修正符改变正则表达  
式的含义，从而实现一些匹配结果的调整等功能。

### 1.4.2 常用的修饰符 ###

<table> 
 <thead> 
  <tr> 
   <th><strong>修饰符</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>re.I</td> 
   <td>使匹配对大小写不敏感</td> 
  </tr> 
  <tr> 
   <td>re.L</td> 
   <td>做本地化识别（locale-aware）匹配</td> 
  </tr> 
  <tr> 
   <td>re.M</td> 
   <td>多行匹配，影响 ^ 和 $</td> 
  </tr> 
  <tr> 
   <td>re.S</td> 
   <td>使 . 匹配包括换行在内的所有字符</td> 
  </tr> 
  <tr> 
   <td>re.U</td> 
   <td>根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.</td> 
  </tr> 
  <tr> 
   <td>re.X</td> 
   <td>该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。</td> 
  </tr> 
 </tbody> 
</table>

## 1.5贪婪模式与懒惰模式 ##

### 1.5.1概念 ###

贪婪型的匹配会去抓取满足匹配的最长的字符串，这个也是正则表达式的默认的模式。当我们不需要最长的匹配的时候就需要使用懒惰模式。

### 1.5.2匹配数量的元字符 ###

<table> 
 <thead> 
  <tr> 
   <th><strong>字符</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>?</td> 
   <td>重复0次或1次，等同于{0,1}</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>重复0次或更多次，等同于{0,}</td> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>重复1次或更多次，等同于{1,}</td> 
  </tr> 
  <tr> 
   <td>{n,}</td> 
   <td>重复n次及以上</td> 
  </tr> 
 </tbody> 
</table>

### 1.5.3模式表达式 ###

### 1.5.4实例 ###

s="abcbd" 
    patt=r'a.*b' #*的贪婪类型 
    re.search(patt,s).group() 'abcb' 
    patt=r'a.*?b' #*的懒惰类型 
    re.search(patt,s).group() 'ab' 
    s='caaaaab' 
    patt=r'a.+b' #+的贪婪类型 
    s='caaaaabcccb'
    re.search(patt,s).group() 
    patt=r'a.+?b' #+的懒惰类型 
    re.search(patt,s).group()   #'aaaaab'

## 1.6 常用函数 ##

### 1.6.1 compile() ###

#### 1.6.1.1 概念 ####

根据包含的正则表达式的字符串创建模式对象。可以实现更有效率的匹配

#### 1.6.1.2 格式 ####

re.compile(pattern[,flags=0])

参数详解:

pattern: 编译时用的表达式字符串。

flags: 编译标志位，用于修改正则表达式的匹配方式，如：re.I(不区分大小写)、re.S等

#### 1.6.1.3代码实例 ####

import re 
    tt = "Tina is a good girl, she is cool, clever, and so on..." 
    rr = re.compile(r'\w*oo\w*') 
    print(rr.findall(tt)) #查找所有包含'oo'的单词 
    # 执行结果如下： 
    # ['good', 'cool']

### 1.6.2 match() ###

#### 1.6.2.1 概念 ####

尝试从字符串起始位置匹配，如果不是起始位置匹配成功的话，match()就返回none.

注：这个方法并不是完全匹配。当pattern结束时若string还有剩余字符，仍然视为成功。

#### 1.6.2.2 格式 ####

re.match(pattern, string[, flags=0])

参数详解:

pattern: 编译时用的表达式字符串。

flags: 编译标志位，用于修改正则表达式的匹配方式，如：re.I(不区分大小写)、re.S等

#### 1.6.2.3 代码实例 ####

import re 
    print(re.match('com','comwww.csdn').group()) print(re.match('com','Comwww.csdn',re.I).group()) 
    #执行结果如下：
    #com #com

#### 1.6.3.1 概念 ####

扫描整个字符串，并返回第一个成功的匹配。如果匹配失败，则返回None。

#### 1.6.3.2 格式 ####

re.search(pattern, string\[, flags=0\])

#### 1.6.3.3 代码实例 ####

import re 
    a = "123abc456" 
    print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0)) #123abc456,返回整体 
    print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1)) #123 
    print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2)) #abc 
    print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3)) #456 ###group(1) 列出第一个括号匹配部分，group(2) 列出第二个括号匹配部分，group(3) 列出第三个括号匹配部分。

### 1.6.4 match与search的异同点 ###

1.  match和search一旦匹配成功，就是一个match object对象，而match object对象有以下方法：

<table> 
 <thead> 
  <tr> 
   <th><strong>方法</strong></th> 
   <th><strong>说明</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>group()</td> 
   <td>返回被 RE 匹配的字符串</td> 
  </tr> 
  <tr> 
   <td>start()</td> 
   <td>返回匹配开始的位置</td> 
  </tr> 
  <tr> 
   <td>end()</td> 
   <td>返回匹配结束的位置</td> 
  </tr> 
  <tr> 
   <td>span()</td> 
   <td>返回一个元组包含匹配 (开始,结束) 的位置</td> 
  </tr> 
 </tbody> 
</table>

1.  re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；
2.  re.search匹配整个字符串，直到找到一个匹配。

代码实例：

a=re.search('[\d]',"abc33").group() 
    print(a) p=re.match('[\d]',"abc33") 
    print(p) b=re.findall('[\d]',"abc33") 
    print(b) #执行结果： 3 None ['3', '3']

### 1.6.5 findall() ###

#### 1.6.5.1 概念 ####

遍历匹配，可以获取字符串中所有匹配的字符串，返回一个列表。

#### 1.6.5.2 格式 ####

re.findall(pattern, string[, flags=0])

#### 1.6.5.3 代码实例 ####

import re 
    tt = "Tina is a good girl, she is cool, clever, and so on..." 
    rr = re.compile(r'\w*oo\w*') print(rr.findall(tt)) 
    print(re.findall(r'(\w)*oo(\w)',tt))#()表示子表达式 
    #执行结果如下： ['good', 'cool'] [('g', 'd'), ('c', 'l')]

### 1.6.6 split() ###

#### 1.6.6.1 概念 ####

1.  按照能够匹配的子串将string分割后返回列表。
2.  可以使用re.split来分割字符串，如：re.split(r’\\s+’,text)；将字符串按空格分割成一个单词列表。

#### 1.6.6.2 格式 ####

re.split(pattern, string[, maxsplit])

参数详解:maxsplit: 用于指定最大分割次数，不指定将全部分割。

#### 1.6.6.3 代码实例 ####

print(re.split('\d+','one1two2three3four4five5')) 
    # 执行结果如下： # ['one', 'two', 'three', 'four', 'five', '']

### 1.6.7sub() ###

#### 1.6.7.1 概念 ####

使用re替换string中每一个匹配的子串后返回替换后的字符串。

#### 1.6.7.2 格式 ####

re.split(pattern, string[, maxsplit])

参数详解:maxsplit: 用于指定最大分割次数，不指定将全部分割。

代码实例：

import re 
    text = "JGood is a handsome boy, he is cool, clever, and so on..." 
    print(re.sub(r'\\s+', '-', text)) 
    #执行结果如下： JGood-is-a-handsome-boy,-he-is-cool,-clever,-and-so-on... 
    #其中第二个函数是替换后的字符串；本例中为'-' 
    #第四个参数指替换个数。默认为0，表示每个匹配项都替换。 re.sub还允许使用函数对匹配项的替换进行复杂的处理。 如：re.sub(r’\\s’, lambda m: ‘[’ + m.group(0) + ‘]’, text, 0)；将字符串中的空格’ ‘替换为’[ ]’。

#### 1.6.7.3 代码实例 ####

import re 
    text = "JGood is a handsome boy, he is cool, clever, and so on..." 
    print(re.sub(r'\\s+', lambda m:'['+m.group(0)+']', text,0)) 
    #执行结果如下： JGood[ ]is[ ]a[ ]handsome[ ]boy,[ ]he[ ]is[ ]cool,[ ]clever,[ ]and[ ]so[ ]on... |

# 2 xpath解析库 #

## 2.1 概念 ##

1.  XPath(XML Path Language)是一门在XML文档中查找信息的语言。
2.  XPath 可用来在XML文档中对元素和属性进行遍历。
3.  XPath 是 W3C XSLT 标准的主要元素，并且 XQuery 和 XPointer 都构建于 XPath表达之上。
4.  python中如何安装使用XPath:
    
    ①: 安装 lxml 库。
    
    ②: from lxml import etree
    
    ③: Selector = etree.HTML(网页源代码)
    
    ④: Selector.xpath(一段神奇的符号)
5.  使用etree处理html文本,会自动将未补全或者缺失的html部分的代码补充完整

## 2.2 准备工作 ##

1.  要使用XPath首先要先安装lxml库：pip install lxml
2.  谷歌浏览器配置XPath插件

注:如果安装报 包装包无效,解决办法如下:

> 1>将crx结尾的扩展包的后缀名更改为rar格式的压缩包文件，直接确认。

![20200630101842133.png][]

> 2>将压缩包进行解压缩，然后将路径下的\_metadata改为metadata

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70][]

> 3>进入Chrome浏览器的加载扩展程序界面，打开开发者模式，点击“加载已解压的扩展程序”，进入解压后的文件夹就可以直接安装了。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 1][]

> 4>有的可能没有“加载已解压的扩展程序”的选项，这个选中“打开开发者选项”就可以显示了。

## 2.3节点选取规则 ##

<table> 
 <thead> 
  <tr> 
   <th><strong>表达式</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>/</td> 
   <td>从当前节点选择直接子节点</td> 
  </tr> 
  <tr> 
   <td>//</td> 
   <td>从当前节点选取子孙节点</td> 
  </tr> 
  <tr> 
   <td>.</td> 
   <td>选择当前节点</td> 
  </tr> 
  <tr> 
   <td>…</td> 
   <td>选取当前节点的父节点</td> 
  </tr> 
  <tr> 
   <td>@</td> 
   <td>选取属性</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>匹配任何节点</td> 
  </tr> 
  <tr> 
   <td>[nodename]</td> 
   <td>根据节点筛选</td> 
  </tr> 
  <tr> 
   <td>contains(@属性,’包含的内容’)</td> 
   <td>模糊查询</td> 
  </tr> 
  <tr> 
   <td>text()</td> 
   <td>文本内容</td> 
  </tr> 
 </tbody> 
</table>

## 2.4代码实例 ##

from lxml import etree 
    text = ''' <div> <ul> <li class="sp item-0" name="one"> <a href="www.baidu.com">baidu<a> <li class="sp item-1" ame="two"> <a href="https://blog.csdn.net/qq_25343557">myblog</a> <li class="sp item-2" name="two"><a href="https://www.csdn.net/">csdn</a> <li class="sp item-3" name="four"> <a href="https://hao.360.cn/?a1004">hao123</a> </div\> '''
    html = etree.HTML(text)
    
    result = html.xpath('//li[2]/a/text()')\#选择第二个li节点，获取a节点的文本
    
    print(result)
    
    result = html.xpath('//li[last()]/a/text()')\#选择最后一个li节点，获取a节点的文本
    
    print(result)
    
    result = html.xpath('//li[last()-1]/a/text()')\#选择倒数第2个li节点，获取a节点的文本
    
    print(result)
    
    result = html.xpath('//li[position()\<=3]/a/text()')\#选择前三个li节点，获取a节点的文本
    
    print(result)
    
    \#运行结果
    
    [‘myblog’]
    
    [‘hao123’]
    
    [‘csdn’]
    
    [‘baidu’,‘myblog’,’csdn’]

# 3 JsonPATH #

## 3.1 概念 ##

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，易于人阅读和编写。

## 3.2 Python—Json数据对比 ##

<table> 
 <thead> 
  <tr> 
   <th><strong>Python</strong></th> 
   <th><strong>Json</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>dict</td> 
   <td>object</td> 
  </tr> 
  <tr> 
   <td>list,tuple</td> 
   <td>array</td> 
  </tr> 
  <tr> 
   <td>str,unicode</td> 
   <td>string</td> 
  </tr> 
  <tr> 
   <td>int,long,float</td> 
   <td>number</td> 
  </tr> 
  <tr> 
   <td>True</td> 
   <td>true</td> 
  </tr> 
  <tr> 
   <td>False</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td>None</td> 
   <td>null</td> 
  </tr> 
 </tbody> 
</table>

## 3.3 常用方法 ##

使用json相关的函数需要 导入Json库,导入方式: import json

### 3.3.1 json.dumps ###

#### 3.3.1.1 概念 ####

用于将 Python 对象编码成 JSON 字符串。

#### 3.3.1.2 实例 ####

import json 
    a = { 'name': 'wang', 'age': 29} 
    b = json.dumps(a)
    print (b, type(b)) #以上代码执行结果为:{"age": 29, "name": "wang"} <type 'str'>

### 3.3.2 json.loads ###

#### 3.3.2.1 概念 ####

用于解码 JSON 数据。该函数返回 Python 字段的数据类型。

#### 3.3.2.2 实例 ####

import json 
    jsonData = '{"a":1,"b":2,"c":3,"d":4,"e":5}' 
    text = json.loads(jsonData) 
    print text 
    
    # 以上代码执行结果为： 
    { u'a': 1, u'c': 3, u'b': 2, u'e': 5, u'd': 4}

### 3.3.3 json.dump ###

#### 3.3.3.1 概念 ####

用于把python类型的数据转化成json类型的字符串,并保存到本地文件中。

#### 3.3.3.2 实例 ####

import json 
    python_data=[{ 'username':'name1','vip':True,},{ 'username': None,'vip': False,} ] 
    
    # dump 把python类型的数据转化成json类型的字符串并保存到本地文件中
    json.dump(python_data,open('json.txt','w')) 
    
    #以上代码执行结果为： 
    #生成一个json.txt文件,文件文本内容为:
     [{ "username": "name1", "vip": true}, { "username": null, "vip": false}]

### 3.3.4json.load ###

#### 3.3.4.1概念 ####

json.dump 用于读取本地的json数据并转换成python对象.

#### 3.3.4.2实例 ####

#json.txt数据: [{"username": "name1", "vip": true}, {"username": null, "vip": false}] 
    
    #代码: 
    pythondata2=json.load(open('json.txt')) 
    print(pythondata2) 
    
    #以上代码运行结果: 
    [{ 'username': 'name1', 'vip': True}, { 'username': None, 'vip': False}]

[20200630101842133.png]: /images/20221123/43733059445b414999dcda2fcf3988ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70]: /images/20221123/4c86077b830b44fb875805290f7a393c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 1]: /images/20221123/d93b96c33b2d47e7bd1a310b8bb67cf0.png