正则表达式学习01

最新推荐文章于 2021-03-05 04:04:43 发布

走遍星空的CG

最新推荐文章于 2021-03-05 04:04:43 发布

阅读量274

点赞数

分类专栏：正则表达式文章标签：正则表达式

本文链接：https://blog.csdn.net/qq_24137739/article/details/84530096

版权

正则表达式专栏收录该内容

2 篇文章 0 订阅

订阅专栏

正则表达式

1.动机：
   1. 文本处理已经成为计算机的常见工作之一
   2. 对文本内容的搜索，定位，提取是逻辑比较复杂的工作
   3. 为了快速结局上述问题，差生了正则表达式技术

2. 定义：
文本的高级匹配模式，提供搜索，代替等功能，其本质是一系列由特殊符号组成的字串，这个自出即正则表达式

3.匹配原理：
由普通字符和特殊符号组成字符串，通过描述字符的重复和位置等行为，达到匹配某一类字符串的目的

4.目标：
   1.熟练掌握正则表达式符号
   2.能够实现基本的文本搜索，定位，提取，理解正则用法
   3.能够使用re模块操作正则表达式

5.特点：
   1.方便文本处理
   2.支持语言众多
   3.使用灵活多样

6 python ---> re模块（用于操作正则表达式）
   re.findall(pattern,string)
   功能：使用正则表达式匹配，目标字符串内容
   参数： pattern 正则表达式
   string 目标字符串
   返回值列表，列表中为匹配到的内容

7.元字符的使用
   1.普通字符
       元字符： a b c
       匹配规则：每个字符串匹配对应的字符
       例：
       In [14]: re.findall('hello','hello world')
       Out[14]: ['hello']

In [5]: re.findall('o','hello,world')
Out[5]: ['o', 'o']

       In [2]: re.findall('你好','你好北京')
       Out[2]: ['你好']
   2. 或
       元字符： |
       匹配规则: 匹配 | 两边任意一个正则表达式
       例：
       In [4]: re.findall('ab|cd','abcefdsabaacde')
       Out[4]: ['ab', 'ab', 'cd']

In [7]: re.findall('ab | cd','abasdsde cd')
Out[7]: [' cd'] #空格也作为字符查询

In [9]: re.findall('abc|cde','abcdefasdasfweqwf')
Out[9]: ['abc'] #不会重复查询

   3.匹配单个字符
       元字符： .
       注意：一个.代表一个字符
       匹配规则：匹配除换行外的任意字符
       f.o -----> foo fao
       匹配
       例：
       In [10]: re.findall('f.o','foo is not fao')
       Out[10]: ['foo', 'fao']

In [11]: re.findall('张.','张某是李某的同学')
Out[11]: ['张某']

In [12]: re.findall('....','hel\nlo')
Out[12]: []

   4.匹配开始位置
       元字符：^
       注意：使用在正则表达式最前面
       匹配规则：匹配目标字符串开头位置
       例：
       In [14]: re.findall('^tom','tom is a boy')
       Out[14]: ['tom']

In [17]: re.findall('^tom','hi,tom')
Out[17]: []

   5.匹配结束位置
       元字符：
       注意： $在正则表达式的最后使用
       匹配规则：匹配字符串的结束位置
       例：
       In [18]: re.findall('tom$','hi,tom')
       Out[18]: ['tom']

       In [19]: re.findall('tom$','tom is a boy')
       Out[19]: []

   6.匹配重复：
       元字符： *
       匹配规则：匹配前面的字符出现0次或多次
       fo* ----------> f fo fooooooo
       匹配 0次 1次多次

       例：
       In [22]: re.findall('fo*','foooooacfaooofofo')
       Out[22]: ['fooooo', 'f', 'fo', 'fo']

In [23]: re.findall('f*','fashfafoooooafo')
Out[23]: ['f', '', '', '', 'f', '', 'f', '', '', '', '', '', '', 'f', '', '']

   7.匹配重复：
       元字符： +
       匹配规则：匹配前面的字符出现1次或多次
       fo+ -------> fo fooooooooooo
           一次多次
       例：
       In [25]: re.findall('fo+','faaooooofofoooooaofffa')
       Out[25]: ['fo', 'fooooo']

   8.匹配重复
       元字符：？
       匹配规则：匹配前面的字符出现0次或一次

       fo? -----> f fo
           0次 1次
       例：
       In [26]: re.findall('fo?','faaooooofofoooooaofffa')
       Out[26]: ['f', 'fo', 'fo', 'f', 'f', 'f']

   9.匹配重复
       元字符：{n}
       匹配规则：匹配指定的重复次数

       fo{3} ----->fooo
       例：
       In [27]: re.findall('fo{2}','fashfafooooooafo')
       Out[27]: ['foo']

   10.匹配重复
       元字符：{m,n}
       匹配规则：匹配前面的正则表达式 m--n次
       fo{2,4} ----->foo fooo foooo
       例：
       In [31]: re.findall('fo{2,4}','foooashfafoooooafo')
       Out[31]: ['fooo', 'foooo']

   11.匹配字符集合
       元字符：[字符集]
       匹配规则：匹配任意一个集合中的字符
       [abc123] ------? a b c 1 2 3
       匹配
       [a-z] 匹配到a到z之间任意一个小写字符
       [A-Z] 匹配A到Z间任意一个大写字符
       [0-9] 匹配0到9之间任意一个数字
       [_123a-z] 匹配_123或者a到z间任意一个小写字符

       例：
       In [33]: re.findall('[A-Z][a-z]*','A')
       Out[33]: ['A']

       In [36]: re.findall('[A-Z][a-z]*','Boy')
       Out[36]: ['Boy'] # 匹配首字母大写，后面小写的字符串

       In [37]: re.findall('[A-Z][a-z]*','An')
       Out[37]: ['An']

       In [46]: re.findall('[_0-9a-z]+','port_007')
       Out[46]: ['port_007'] # 匹配字符串中含有 _,0-9,a-z其中字符的一位或多位

   12.匹配字符集
       元字符：[^...]
       匹配规则：字符集取非，除了列出的字符之外任意一个字符
       例：
       In [49]: re.findall('[^ ]+','a litte boy')
       Out[49]: ['a', 'litte', 'boy']

   13.匹配任意（非）数字字符
       元字符： \d \D
       匹配规则： \d 匹配任意数字字符 [0-9]
           \D 匹配任意非数字字符 [^0-9]
       例：
       In [50]: re.findall('\d{11}','18844650688')
       Out[50]: ['18844650688']

       In [52]: re.findall('1\d{10}','18844650688')
       Out[52]: ['18844650688']


       In [53]: re.findall('\D','18844650688ll')
       Out[53]: ['l', 'l']

In [54]: re.findall('\D','18844650aa688')
Out[54]: ['a', 'a']

   14.匹配任意普通字符
       元字符：\w \W
       匹配规则： \w 普通字符[0-9a-zA-Z]也能匹配到普通汉子
           \W 非普通字符
       例：
       In [56]: re.findall('\w+','hello#nihao%asdhi!df@fet$')
       Out[56]: ['hello', 'nihao', 'asdhi', 'df', 'fet'] # 匹配普通字符

       In [57]: re.findall('\W+','hello#nihao%asdhi!df@fet$')
       Out[57]: ['#', '%', '!', '@', '$'] # 匹配非普通字符

   15. 匹配任意（非）空字符
       元字符： \s \S
       匹配规则： \s 匹配任意空字符 [\r\t\n\v\f]
           \S 匹配任意非空字符
       例：
       In [58]: re.findall('\w+ \w+','hello world')
       Out[58]: ['hello world'] # 中间有多个空格不适用

In [60]: re.findall('\w+\s+\w+','hello world')
Out[60]: ['hello world']

In [62]: re.findall('\S+','hello this is Tom')
Out[62]: ['hello', 'this', 'is', 'Tom']

In [67]: re.findall('\w+\s+\w+','hello this is Tom')
Out[67]: ['hello this', 'is Tom']

   16.匹配字符串位置
       元字符： \A \Z
       匹配规则: \A 匹配字符串开头位置
          \Z 匹配字符串结尾位置
       例：
       In [70]: re.findall('\Ahello','hello this is Tom')
       Out[70]: ['hello']

In [72]: re.findall('Tom\Z','hello his is Tom')
Out[72]: ['Tom']

   17.绝对匹配
       正则表达式要完全匹配目标字符串内容
       在正则表达式开始和结束位置加上 ^ $ {\A \Z}
       这样正则表达式必须匹配整个目标的字符串才会有结果

       例：
       In [73]: re.findall('^\d+$','fhu1234556ad')
       Out[73]: [] # 匹配任意数字字符

In [74]: re.findall('^\d+$','1235657')
Out[74]: ['1235657']

   18.匹配（非）单词边界
       元字符： \b \B
       注意：普通字符和非普通字符交界认为是单词边界
       匹配规则：\b 匹配单词边界位置
           \b 匹配非单词边界位置
       例：
       n [75]: re.findall(r'\bis','This is a boy')
       Out[75]: ['is'] # is为普通字符，空格为非普通字符，所以is 为单词边界

       In [77]: re.findall(r'\Bis','This is a boy')
       Out[77]: ['is']

In [78]: re.findall(r'num\b','num#toock#')
Out[78]: ['num'] # num和#之间也是单词边界

In [79]: re.findall(r'num\b','numatoock#')
Out[79]: []

元字符总结：
1.匹配单词字符： a . \d \D \s \S [...] [^...]
2.匹配重复： * + ？ {n} {m,n}
3.匹配位置： $ \A \Z \b \B
4.其他： | () \

正则表达式的转义

正则表达式特殊字符
. * > $ ^ [] {} () \
在表达式中如果想匹配这些特殊字符需要进行转义
e.g.
In [82]: re.findall('\[\d+\]','abc[123]')
Out[82]: ['[123]'] # \[ \d+ \] 转义

eg.
raw 字符串 ----》原始字符串

特点：对字符串中的内容不进行转移，即表达原始含义
r'\b'------ \b
'\\b'------ \b
In [84]: re.findall('\\w+@\w+\\.cn','lvze@tedu.cn')
Out[84]: ['lvze@tedu.cn']

In [86]: re.findall(r'\w+@\w+\.cn','lvze@tedu.cn')
Out[86]: ['lvze@tedu.cn']

贪婪和非贪婪
   贪婪模式：正则表达式的重复匹配，总是尽可能多的向后匹配内容
   * + ? {m,n}
   贪婪 ----> 非贪婪（懒惰）尽可能少的匹配内容
   *？ +？？？ {m,n}?
   e.g.
   In [93]: re.findall(r'ab*?','abbbbb')
   Out[93]: ['a'] # 匹配0次

   In [94]: re.findall(r'ab+?','abbbbb')
   Out[94]: ['ab'] # 匹配一次

正则表达式的子组

使用()可以为正则表达式建立子组，子组不会影响正则表达式整体的匹配内容，
可以被看做是一个内部单元

子组的作用
1.形成内部整体，该表某些元字符的行为
In [98]: re.search(r'(ab)+','abababab').group()
Out[98]: 'abababab' # group用来返回值

In [99]: re.search(r'\w+@\w+\.(com|cn)','lvze@tedu.cn').group()
Out[99]: 'lvze@tedu.cn'

2.子组匹配内容可以被单独获取
In [100]: re.search(r'\w+@\w+\.(com|cn)','lvze@tedu.com').group(1)
Out[100]: 'com'

子组注意事项
* 一个正则表达式中可以有多个子组
In [117]: re.search(r'((ab)cd)(ef)','abcdefghijklmn').group()
Out[117]: 'abcdef'
* 子组一般由外到内，由左到右，区分第一，第二。。。子组
In [115]: re.search(r'((ab)cd)(ef)','abcdefghijklmn').group(1)
Out[115]: 'abcd'

In [116]: re.search(r'((ab)cd)(ef)','abcdefghijklmn').group(2)
Out[116]: 'ab'

In [111]: re.search(r'((ab)cd)(ef)','abcdefghijklmn').group(3)
Out[111]: 'ef'

* 子组不要出现重叠的情况，尽量简单

捕获组和非捕获组（命令组，未命令组）

格式： (?P<name>pattern)

re.search(r'(?P<dog>ab)+)','ababababab').group()

In [7]: re.search(r'(?P<dog>ab)+','abababab').group()
Out[7]: 'abababab' # 给组命名

作用： 1. 方便通过名字区分每个子组
2. 捕获组可以重复调用
   格式：(?P=name)
   e.g. (?P<dog>ab)cd(?P=dog)====>abcdab
   In [8]: re.search(r'(?P<dog>ab)cdef(?P=dog)','abcdefab').group()
   Out[8]: 'abcdefab'

正则表达式的匹配原则

1. 正确性能够正确匹配目标字符串
2. 唯一性除了匹配的目标内容，尽可能不会有不需要的
3. 全面性对目标字符串可能的情况要考虑全面不漏

re 模块的使用

regex = re.compile(pattern,flags=0)
功能：生成正则表达式对象
参数： pattern 正则表达式
flags 功能标志位，丰富正则表达式的匹配
返回值：返回正则表达式对象

re.findall(pattern,string,flags=0)
功能：根据正则表达式匹配目标字串内容
参数： pattern 正则表达式
string 目标字符串
返回值：列表里面是匹配到的内容
如果正则表达式有子组，则只返回子组中的内容

regex.findall(string,pos,endpos)
功能：根据正则表达式匹配目标字串内容
参数： string 目标字符串
pos,endpos : 截取目标字符串的起始位置进行匹配
（前包后不包）
返回值：列表里面是匹配到的内容
如果正则表达式有子组，则只返回子组中的内容

re.split(pattern,string,flags=0)
功能：通过正则表达式切割字符串
参数： pattern 正则
string 目标字串
返回值：返回列表，返回切割后的内容

re.sub(pattern,replace,string,max,flags)
功能：替换正则表达式匹配内容
参数： pattern 正则
replace 要替换的目标
string 目标字符串
max 设定最多替换几处
返回值：替换后的字符串

re.finditer(pattern,string,flags)
功能：使用正则匹配目标字串
参数： pattern 正则
string 目标字串
返回值：迭代对象 -----》迭代内容match对象

re.fullmatch(pattern,string,flags)
功能：匹配一个字符串
参数： pattern 正则
string 目标字串
返回值： match对象，匹配到内容
如果没有匹配成功返回None

re.match(pattern,string,flags)
功能：匹配一个字符串起始内容
参数：pattern 正则
string 目标字串
返回值： match对象，匹配到的内容
如果没有匹配成功返回None

re.search(pattern,string,flags)
功能：匹配第一个符合条件的字符串
参数： pattern 正则
   string 目标字串
返回值： match对象，匹配到的内容
   如果没有匹配成功返回None

compile对象属性：

flags: 标志位
pattern : 正则表达式
groups : 有多少子组
groupindex: 捕获组形成的组名和序列的字典
组名为键，第几组为值

作业：
第一项熟悉元字符使用
第二项使用compile对象调用正则表达式方法
第三项读取一个文本，分别匹配文本中所有的以大写字母开头的单词（包含特殊字符的不算）
* 以大写字母开头的单词（包含特殊字符的不算）
* 数字包括整数，小数，正数，负数，分数，百分数

9.匹配重复
元字符：{n}
匹配规则：匹配指定的重复次数