您的位置：首页 > 编程语言 > Python开发

Python爬虫：正则表达式

2020-01-14 12:42 351 查看

数据的分类

1. 结构化数据

特点：数据以行为单位，每一个数据表示一个实体，每一行数据的属性都是一样的
举例：关系型数据库中的表就是结构化数据
处理方法：sql

2. 半结构化数据

特点：结构化数据的另一种形式，并不符合关系型数据的特点，不能用关系型模型来描述，但是这种数据包含相关标记，有用来分割语义元素以及字段进行分层的描述。因此也被称为自描述结构。
举例：xml，html，json
处理方法：正则，xpath，jsonpath，css选择器

3. 非结构化数据

特点：没有固定结构的数据
举例：文档，图片，音频，视频
处理方法：常常用二进制形式来做整体保存

json数据

1. json是什么语言的内容？

json 是js 语言中用字符串格式来保存对象和数组的一种数据结构
json 数据本质上是字符串

2. js 中数组和对象

js的数组：var array = [‘aaa’,‘bb’,‘cc’] — 和python列表对应
js的对象：var obj = {name：‘zhangsan’,age:10}—和python字典对应。name = obj.name

3. json数据的解析方法

对json 字符串得操作

json.loads(json_str)  ---->  python的list或者dict
json.dumps(python的list或者dict)  ---->  json_str

对json文件的操作

json.load(fp)--->从json文件中读出json数据，返回一个python的list或者dict
json.dump(python的list或者dict，fp)---》python的list或者dict保存到fp所对应的的文件中。

json的意义

json 作为数据格式进行传输，具有较高的效率
json 不像xml 那样具有严格的闭合标签，所以json 作为数据传输的时候，他的数据有效占比（有效数据和总数据的比）比xml高很多。
在相同的流量下，json 比xml 作为数据传输，传输的数据多。

正则表达式

1. 元字符

匹配边界

符号	意义
^	行首
$	行尾

重复次数

符号	意义
?	0次或者1次
*	0次或者多次
+	一次或者多次
{n,}	n次或者更多次，至少n次
{n,m}	n - m次
{n}	n次

各种字符的表示

符号	意义
[]	匹配括号中一个字符，单字符
[abc]	匹配 a 或者 b 或者 c
[a-z0-9A-Z]	对应取值范围的匹配
\d	数字
\w	数字字母下划线
\s	空白字符：换行符，制表符，空格
\b	单子边界
.	除换行符意外的任意字符

2. re模块的使用

python 中的 re 模块是用来做正则处理的

2-1. re模块的使用步骤

导包：
```
import re
```

将正则表达式编译成一个pattern对象

pattern = re.compile(
r'正则表达式'，
'匹配模式'
)
r 表示元字符

用 pattern 对象来使用相应的方法来匹配内容。

2-2. pattern对象的方法

match方法
默认从头开始，只匹配一次
返回值：match对象

pattern.match(
'匹配的目标字符串'，
start,匹配开始的位置--缺省，start = 0
end，匹配结束的位置--缺省,end = -1
)

match对象的属性：

性	意义
atch.group()	获取匹配内容。
atch.span()	匹配的范围
atch.start()	开始位置
atch.end()	结束位置
atch.groups()	将所有分组的内容，按顺序放到一个元组中返回

search方法
从任意位置开始匹配，只匹配一次
返回值：match对象

pattern.search(
'匹配的目标字符串'，
start,匹配开始的位置--缺省，start = 0
end，匹配结束的位置--缺省,end = -1
)

findall方法
全文匹配，匹配多次，将每次匹配的结果放到list 中返回
返回值：list

pattern.findall(
'匹配的目标字符串'，
start,匹配开始的位置--缺省，start = 0
end，匹配结束的位置--缺省,end = -1
)

finditer方法
全文匹配，匹配多次，主要匹配内容比较多的情况
返回值：迭代器

pattern.finditer(
'匹配的目标字符串'，
start,匹配开始的位置--缺省，start = 0
end，匹配结束的位置--缺省,end = -1
)

split方法
切分，按照正则所表示内容进行切分字符串，返回切分后的每个字符串
返回值：list
```
pattern.split(
'要切分的字符串'，
'切分字数'，默认是全部分。
)
```
sub方法
用指定字符串，替代正则表达式所匹配到的内容
返回值：替换之后新的字符串
```
pattern.sub(
repl,# 替换成什么内容
content,# 被替换的内容
count,# 替换次数，默认替换所有
)
```
repl 替换内容可以是函数
函数要求：
- 函数必须有参数，参数就是正则匹配目标字符串所得到的每个match对象
- 这个函数必须要有返回值，返回值必须是字符串，这个字符串将来就作为替换的内容

import re

str1 = 'Ian:1111,Alaric:2222,Damon:3333'
# 自定义sub的repl参数：add方法
def add(m):
return str(int(m.group())+1111)
content = str1
# 实例化pattern对象
p = re.compile(r'\d+')
result = p.sub(add,content,)
print(result)       # Ian:2222,Alaric:3333,Damon:4444

分组
分组在正则表达式中使用 () 来表示，一个括号就是一个分组
分组的作用：
- 筛选特定内容
- 可以在同一个表达式中应用前面的分组： ‘\1’ 表示引用第一个分组
- findall 配合分组使用
```
import re
content = '<html><h1>正则表达式</h1></html>'
p = re.compile(r'<(html)><(h1)>(.*)</\2></\1>')	# print(p.search(content).group())
print(p.findall(content))	#[('html', 'h1', '正则表达式')]
```
贪婪非贪婪模式
贪婪和非贪婪的区别在于匹配内容的多少
贪婪是用 * 来控制匹配次数的，正则默认是贪婪模式
非贪婪是用？来控制的。
在表示数量控制元字符后面加一个？，此时就表示这个数量控制符取最小值，也就是非贪婪。

import re

pattern1 = re.compile(r'ab*')
res1 = pattern1.findall('abbbc')
pattern2 = re.compile(r'ab*?')
res2 = pattern2.findall('abbbc')
# * 表示最少0次，最多无限次匹配
# 在控制之数量的元字符 * 后面加上非贪婪 ？ 之后，尽可能少的匹配 b，于是就匹配0次
print(res1)    # ['abbb']
print(res2)    # ['a']

s = 'aa<div>test1</div>bb<div>test2</div>cc'
pattern = re.compile(r'<div>.*?</div>')
result = pattern.findall(s)

print(result)   # ['<div>test1</div>', '<div>test2</div>']

匹配模式

匹配模式	意义
re.S	‘.’，点可以匹配换行符
re.I	忽略大小写
re.M	多行匹配，影响 ^ 和 $

通用匹配正则表达式
ps：需要配合 re.S 使用

import re

content = '{name:"zhangsan",age:"10",hobby:["basktball","football","read"]}'
pattern = re.compile(r'.*?"(.*?)".*?"(.*?)".*?')
match = pattern.search(content)
print(match)
print(match.group(1))
print(match.group(2))

点赞
收藏
分享
文章举报

铭铭铭铭天发布了41 篇原创文章 · 获赞 33 · 访问量 443 私信关注

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航