Python正则表达式(干货来袭)天钧深夜肝文

什么是正则表达式

互联网上的信息很多,我们只需要获取我们所关心的数据进行提取就可以了。此时可以通过一些表达式进行提取,正则表达式就是一种进行数据筛选的表达式

所以这不是我连夜码文的理由,求打赏安慰弱小心灵。做弟中弟的第265天。

目录如下

原子

原子是正则表达式中最基本的单位,每个正则表达式中至少要包含一个原子。常见的原子类型;

  • 普通字符作为原子
  • 非打印字符作为原子
  • 通用字符作为原子
  • 原子表

普通字符作为原子

演示代码

 import re#引用re
 string = "shentouyun"#定义整段,普通字符作为原子
 
 pat = "yun"#提取yun
 ret = re.search(pat,string)#第一个参数为提取,第二个为整个字段
 print(ret)#输出

输出

 <_sre.SRE_Match object; span=(7, 10), match='yun'>

非打印字符作为原子

什么是非打印字符,如\n,\t(换行,制表),代表一些操作的字符也可以作为原子

操作代码与小知识

 string1 = '''shentouyun
 nuibi
 '''
 pat1 = '\n'
 
 ret=re.search(pat1,string1)
 print(ret)

运行后

 <_sre.SRE_Match object; span=(10, 11), match='\n'>

小知识

 #在这里解释一个基础,我没有提到过
 string = '''
 shentouyun
 nuibi
 '''
 print(string)
 #这段代码里,其特点为string被三引号包裹,并在代码里实现换行其运行结果
 shentouyun
 nuibi
 #实现了一个\n的操作其代码等同于
 string ="shentouyun\nnuibi"
 print(string)

通用字符作为原子

什么是通用字符

  1. \w匹配任意一个字母数字或下划线。
  2. \W匹配除去字母数字或下划线任意一个字符
  3. \d匹配十进制数
  4. \D除十进制以外的任意一个字符
  5. \s匹配一个空白字符
  6. \S除去空白字符

简单的例子

 string1 = "shentouyun3215454biji"
 
 
 pat1 = '\d\d\d\d'#匹配四个十进制数
 
 ret=re.search(pat1,string1)
 print(ret)

运行后

 <_sre.SRE_Match object; span=(10, 14), match='3215'>

也可以混合使用

 string1 = "shentouyun3215454biji"
 pat1 = '\w\d\d\d\d'#匹配一个字母+匹配四个十进制数
 ret=re.search(pat1,string1)
 print(ret)

运行后

 <_sre.SRE_Match object; span=(9, 14), match='n3215'>

没有符合格式的,如空白就不会匹配出来,这里不过多的描述,占用空间

原子表

[ots]任意的提取一个原子出来,直接任意选择一个原子表原子,如下

 string1 = "shentouyun3215454biji"
 pat1 = "shen[otoasdjojds]ou"
 ret=re.search(pat1,string1)
 print(ret)

运行后

 <_sre.SRE_Match object; span=(0, 7), match='shentou'>

只从原子表中选择一个原子,其原子表内原子地位平等

非原子表

符号^ 英文状态下的shift+6

字符串里出现了非原子表,返回None,其代码如下

 string1 = "shentouyun3215454biji"
 
 pat1 = "shen[^tun]ou"
 #shen后面应该是匹配t结果原子表里出了[tun]三个原子外其他的原子都可以匹配
 #显然本代码中的原子是无法匹配的
 ret=re.search(pat1,string1)
 print(ret)

返回如下

 None

如果正常运行非原子表的外的字符如string1字符串中截取的shen后面是t,在非原子表上,没有出现t,则返回shent

 string1 = "shentouyun3215454biji"
 pat1 = "shen[^asd]"
 #为了更加直白我把ou两个字符去掉了
 ret=re.search(pat1,string1)
 print(ret)

运行后

 <_sre.SRE_Match object; span=(0, 5), match='shent'>

元字符

特殊含义的字符

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

常见的元字符

"."除换行外任意一个字符

"^"如果它不在原子表里代表匹配开始位置,在字符表里表示非

"$"结束位置

"*"0次1次多次

"?"0次1次

"+"1次多次

{n}实现n次如{2}恰好出现2次,使用{n,}前面的原子至少n次,

{n,m}至少出现n次至多出现m次

|模式选择符 或

()模式单元

例子来袭,做好准备,看不懂的转发朋友圈,慢慢看。

"."除换行外任意一个字符

代码如下

 string1 = "shentouyun3215454biji"
 pat1 = "shen.ou"#这里.匹配除了换行符外的任意字符
 ret=re.search(pat1,string1)
 print(ret)

运行结果

 <_sre.SRE_Match object; span=(0, 7), match='shentou'>

当然你也可以多匹配些,比如多些点点。

 string1 = "shentouyun3215454biji"
 pat1 = "shen......"
 ret=re.search(pat1,string1)
 print(ret)

运行后

 <_sre.SRE_Match object; span=(0, 10), match='shentouyun'>

感觉要玩坏了,哈哈哈。

开始位置^与结束位置$

 string1 = "shentouyun3215454biji"
 pat1 = "^s..."
 ret=re.search(pat1,string1)
 print(ret)
 运行后
 <_sre.SRE_Match object; span=(0, 4), match='shen'>

因为s是开始,也就是”排头“结束位置也同理

 string1 = "shentouyun3215454biji"
 pat1 = "b...$"
 ret=re.search(pat1,string1)
 print(ret)
 运行后
 <_sre.SRE_Match object; span=(17, 21), match='biji'>

"*"0次1次多次

 string1 = "shentouyun3215454biji"
 pat1 = "shen.*"
 ret=re.search(pat1,string1)
 print(ret)
 运行后
 <_sre.SRE_Match object; span=(0, 21), match='shentouyun3215454biji'>

为什么会全匹配,看*号的定义为多次,咱们的"."表示除了换行外全匹配,两者一配合,唉,这就全出来了

+号与?号

+匹配多次,正常显示无法匹配0次,演示错误例子

 string1 = "shentouyun3215454biji"
 pat1 = "a+"
 ret=re.search(pat1,string1)
 print(ret)
 
 None

演示正确例子

 string1 = "aaaaaaaaaaaa"
 pat1 = "a+"
 ret=re.search(pat1,string1)
 print(ret)
 
 <_sre.SRE_Match object; span=(0, 12), match='aaaaaaaaaaaa'>

问好就更好弄了

问号直接演示错误例子,无法显示多次

 string1 = "aaaafsedfsfdffasafadaaaaaaaa"
 pat1 = "a?"
 ret=re.search(pat1,string1)
 print(ret)
 
 <_sre.SRE_Match object; span=(0, 1), match='a'>

{n}与{n,}

 string1 = "aaaa"
 pat1 = "a{4}"
 ret=re.search(pat1,string1)
 print(ret)
 
 <_sre.SRE_Match object; span=(0, 4), match='aaaa'>

如果换成3呢

 <_sre.SRE_Match object; span=(0, 3), match='aaa'>

打印了三次,成功演示了什么叫做至少,当然你多了不行,改成5试试

 None

{n,m}至少多少次,至多多少次

 string1 = "aaaa"
 pat1 = "a{3,5}"
 ret=re.search(pat1,string1)
 print(ret)
 
 <_sre.SRE_Match object; span=(0, 4), match='aaaa'>

程序真是个耿直的boy

模式修正符

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

模式修正符有什么。

I忽略大小写

M多行匹配

L本地化识别匹配

U unicode编码

S让,匹配包括换行符

错误代码演示

 string = "ShenTouYun"
 pat="shen"
 ret = re.search(pat,string)
 print(ret)

返回None,因为默然有大小写限制,引用一下I就可以了

 string = "ShenTouYun"
 pat="shen"
 ret = re.search(pat,string,re.I)
 print(ret)

运行结果

 <_sre.SRE_Match object; span=(0, 4), match='Shen'>

贪婪模式与懒惰模式

贪婪模式的核心点就是尽可能多的匹配

懒惰模式的狠心就是尽可能少的匹配

贪婪模式

 string = "SheSnTouYunYS"
 pat="s.*S"
 ret = re.search(pat,string,re.I)
 print(ret)

运行结果

 <_sre.SRE_Match object; span=(0, 13), match='SheSnTouYunYS'>

贪婪模式与懒惰模式有什么用呢?

看对比

 string = "SheSnTouYunYS"
 pat="s.*S"#贪婪模式找到最后一个s
 pat1="s.*?S"#懒惰模式,特征为?,找到第一个s就不往下找了
 ret = re.search(pat,string,re.I)
 ret1 = re.search(pat1,string,re.I)
 print(ret)
 print(ret1)

运行结果

 <_sre.SRE_Match object; span=(0, 13), match='SheSnTouYunYS'>
 <_sre.SRE_Match object; span=(0, 4), match='SheS'>

正则表达式函数

  1. re.match()函数从头开始匹配
  2. re.search()函数从任何地方开始匹配
  3. 全局匹配函数

match函数演示

 string1 = "adafafewfaaa"
 pat1 = "a"
 ret=re.match(pat1,string1)
 print(ret)
 
 运行结果可匹配
 <_sre.SRE_Match object; span=(0, 1), match='a'>

不是第一个开始匹配

 string1 = "adafafewfaaa"
 pat1 = "d"
 ret=re.match(pat1,string1)
 print(ret)
 
 运行结果不可匹配
 None

全局匹配函数

全局匹配格式

 re.compile(正则表达式).findall(数据)
 string1 = "adafafewfaaa"
 pat1 = "d.*?a"
 ret=re.compile(pat1).findall(string1)
 print(ret)
 结果
 ['da']

在码文中的一些杂乱代码

 import re#引用re
 '''
 string = "shentouyun"#定义整段,普通字符作为原子
 
 pat = "yun"#提取yun
 ret = re.search(pat,string)#第一个参数为提取,第二个为整个字段
 print(ret)#输出
 
 
 match
 sub
 search
 全局匹配
 
 string = "SheSnTouYunYS"
 pat="s.*S"#贪婪模式找到最后一个s
 pat1="s.*?S"#懒惰模式,特征为?,找到一个y就不往下找了
 ret = re.search(pat,string,re.I)
 ret1 = re.search(pat1,string,re.I)
 print(ret)
 print(ret1)
 '''

原文发布于微信公众号 - 渗透云笔记(shentouyun)

原文发表时间:2019-07-18

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券