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

爬虫学习——正则表达式与python的re库(二)

2019-08-06 21:21 344 查看
版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。 本文链接:https://blog.csdn.net/weixin_42412973/article/details/98662359

正则表达式

总结自北理工网络公开课《Python网络爬虫与信息提取》

http://open.163.com/movie/2019/5/8/I/MEEMCM1NP_MEEU4DG8I.html

三、Re库的基本使用

Re库是Python的标准库,主要用于字符串匹配(正则表达式库)
import re
re库采用
1、raw string类型(原生字符串类型)表示正则表达式
表示为:r'text'
例如:r'[1-9]\d{5}'
raw string 是不包含转义符的字符串
2、string类型(更繁琐)
例如:'[1-9]\\d{5}' 增加转义符
建议:当正则表达式包含<转义符>时使用raw string

re库的主要功能函数:
---------------------------------------------------------------------------
    函数        |                说明
re.search()      在一个字符串中搜索匹配正则表达式的第一个位置,返回match对象
re.match()       在一个字符串的开始位置起匹配正则表达式,返回match对象
re.findall()     搜索字符串,以列表类型返回全部能匹配的子串
re.split()       将一个字符串按照正则表达式匹配结果进行分割,返回列表类型
re.finditer()    搜索字符串,返回一个匹配结果的迭代类型,每个迭代元素是match对象,可以循环
re.sub()         在一个字符串中替换所有匹配正则表达式的子串,返回替换后的字符串

举例:
1、re.search(pattern,string,flags=0)
>pattern:正则表达式的字符串或原生字符串表示
>string:待匹配字符串
>flags:正则表达式使用时的控制标记
常用标记
①re.I re.IGNORECASE   忽略正则表达式的大小写,[A-Z]能够匹配小写字符
②re.M re.MULTILINE    正则表达式中的^操作符能够将给定字符串(假如是一篇文章)的每行当作匹配开始
③re.S re.DOTALL       正则表达式中的.操作符能够匹配所有字符,默认匹配除换行外的所有字符
例子:
import re
match=re.search(r'[1-9]\d{5}','BIT 100081')
if match:
print(match.group(0))
打印结果:100081
2、re.match(pattern,string,flags=0)
>pattern:正则表达式的字符串或原生字符串表示
>string:待匹配字符串
>flags:正则表达式使用时的控制标记
例子:
import re
match=re.search(r'[1-9]\d{5}','BIT 100081')
if match:
print(match.group(0))
打印结果为空
若直接打印match.group(0) 会报match没有group这一属性,即match为空
match从字符串的起始位置开始匹配,给的例子中从起始位置匹配不了,所以为空,所以一定要加if判断
调整:
import re
match=re.search(r'[1-9]\d{5}','100081 BIT')
if match:
print(match.group(0))

打印结果为:'100081'
3、re.findall(pattern,string,flags=0)
>pattern:正则表达式的字符串或原生字符串表示
>string:待匹配字符串
>flags:正则表达式使用时的控制标记
例子:
import re
ls=re.findall(r'[1-9]\d{5}','BIT100081 TSU100084')
print(ls)
打印结果为:['100081','100084']
4、re.split(pattern,string,maxsplit=0,flags=0)
>pattern:正则表达式的字符串或原生字符串表示
>string:待匹配字符串
>maxsplit:最大分割数,剩余部分作为最后一个元素输出
>flags:正则表达式使用时的控制标记
例子:
import re
print(re.split(r'[1-9]\d{5}','BIT100081 TSU100084'))
打印结果为:['BIT',' TSU',''] 匹配的部分去掉,剩余的部分作为分割后的元素放在列表里
print(re.split(r'[1-9]\d{5}','BIT100081 TSU100084',maxsplit=1))
打印结果为:['BIT',' TSU100084'] 只匹配第一个,剩余部分作为最后一个元素输出
5、re.finditer(pattern,string,flags=0)
>pattern:正则表达式的字符串或原生字符串表示
>string:待匹配字符串
>flags:正则表达式使用时的控制标记
例子:
import re
for m in re.finditer(r'[1-9]\d{5}','BIT100081 TSU100084'):
if m:
print(m.group(0))
打印结果为:100081
100084
6、re.sub(pattern,repl,string,count=0,flags=0)
简单来说,是用一个新的字符串替换正则表达式中匹配的那一部分并与原来的部分进行组合,从而返回一个新的字符串
>pattern:正则表达式的字符串或原生字符串表示
>repl:替换匹配字符串的字符串
>string:待匹配字符串
>count:最大替换次数
>flags:正则表达式使用时的控制标记
例子:
import re
print(re.finditer(r'[1-9]\d{5}',':zipcode','BIT100081 TSU100084'))
打印结果为:'BIT:zipcode TSU:zipcode'
re库的另一种等价用法:
>>>rst=re.search(r'[1-9]\d{5}','BIT 100081')    被称为函数式用法:一次性操作
||
>>>pat=re.compile(r'[1-9]\d{5}') (将字符串编译为正则表达式的对象)   被称为面向对象用法:编译后的多次操作
rst=pat.search('BIT 100081')
regex=re.compile(pattern,flags=0)
将正则表达式的字符串形式编译成正则表达式对象,pattern不是正则表达式,regex才是
>pattern:正则表达式的字符串或原生字符串表示
>flags:正则表达式使用时的控制标记

四、re库的Match对象
match对象就是一次匹配后的结果,包含很多匹配的相关信息
例子:
import re
match=re.search(r'[1-9]\d{5}','BIT 100081')
if match:
    print(match.group(0))
打印结果为:100081
type(match)
结果为:<class '_sre.SRE_Match'>

match对象的属性:
1、.string       待匹配的文本
2、.re           匹配时使用的pattern对象(正则表达式)
3、.pos          正则表达式搜索文本的开始位置
4、.endpos       正则表达式搜索文本的结束位置

match对象的方法:
1、.group(0)     获得匹配后的字符串    还有group(1)等
2、.start()      匹配字符串在原始字符串的开始位置
3、.end()        匹配字符串在原始字符串的结束位置
4、.span()       返回(.start(),.end())

例子:
import re
m=re.search(r'[1-9]\d{5}','BIT100081 TSU100084')
print(m.string)
打印结果为:'BIT100081 TSU100084'
print(m.re)
打印结果为:re.compile('[1-9]\\d{5}') 看来在程序内部也是认为只有经过compile才是正则表达式
print(m.pos)
打印结果为:0
print(m.endpos)
打印结果为:19
print(m.group(0))
打印结果为:'100081' match对象只包含一次匹配(第一次)的结果,想得到每一次匹配的对象,可以用finditer
print(m.start())
打印结果为:3
print(m.end())
打印结果为:9

五、re库的贪婪匹配和最小匹配
例子:
>>>match=re.search(r'PY.*N','PYANBNCNDN')
>>>match.group(0)
同时匹配长短不同的多项,返回哪一个呢?
re库默认采用贪婪匹配,即输出匹配最长的子串
结果为:'PYANBNCNDN'

最小匹配:
>>>match=re.search(r'PY.*?N','PYANBNCNDN')
>>>match.group(0)
结果为'PYAN'

最小匹配操作符
*?       前一个字符0次或无限次扩展,但最小匹配
+?       前一个字符1次或无限次扩展,但最小匹配
??      前一个字符0或1次扩展,但最小匹配
{m,n}》? 扩展前一个字符m至n次(含n),但最小匹配

至此正则表达式的相关学习告一段落

内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: