正则表达式

正则表达式

一、概念相关

1、正则表达式处理的对象也是字符串

2、定义

2.1、就其本质而言，正则表达式（或RE）是一种小型的、高度专业化的编程语言

在python中，它内嵌在python中，并通过re模块实现。

2.2、正则表达式模块被编译成一系列的字节码，然后用C编写的匹配引擎执行

3、字符匹配

3.1、普通字符：大多数字符和字母都会和自身匹配

import re
result = re.findall('jiggigug','dsabdjbkjjiggigugdbsakdbkajd')
print(result)

#打印结果
'''
['jiggigug']
'''

3.2、2元字符

4、2元字符：.   ^   $  *  +  ?  {}  []  |  ()   \

4.1、.    除换行符（\n）之外的字符，都能匹配到

import re
result = re.findall('jiggigug','dsabdjbkjjiggigugdbsakdbkajd')
result1 = re.findall('j.ggigug','dsabdjbkjjiggigugdbsakdbkajd')
result2 = re.findall('j.ggigug','dsabdjbkjj\nggigugdbsakdbkajd')
print(result)
print(result1)
print(result2)

#打印结果
'''
['jiggigug']
['jiggigug']
[]
'''

4.2、^  在起始位置进行匹配

import re
result = re.findall('^jig.igug','dsabdjbkjjiggigugdbsakdbkajd')
result1 = re.findall('^jj.ggigug','jjiggigugdbsakdbkajd')
print(result)
print(result1)


#打印结果
'''
[]
['jjiggigug']
'''

4.3、$  在最末尾位置进行匹配

import re
result = re.findall('jig.igug$','dsabdjbkjjiggigugdbsakdbkajd')
result1 = re.findall('jj.ggigug$','dbsakdbkajdjjiggigug')
print(result)
print(result1)


#打印结果
'''
[]
['jjiggigug']
'''

4.4、* :可以匹配0-多个字符，.表示的是一个字符

import re
result = re.findall('jiggigug','dsabdjbkjjiggigugdbsakdbkajd')
result1 = re.findall('j.*igug','dsabdjbkjjiggigugdbsakdbkajd')
result2 = re.findall('haha.*haha','dsabdhahahahagugdbsakdbkajd')

print(result) 
print(result1)
print(result2) 

#打印结果 
''' 
['jiggigug']
['jbkjjiggigug']
['hahahaha']
 '''

4.5、+ ：1-多个字符

import re
result = re.findall('haha.+haha','dsabdhahahagugdbsakdbkajd')
result1 = re.findall('haha.+a','dsabdjhahahagugdbsakdbkajd')
print(result)
print(result1)

#打印结果
'''
[]
['hahahagugdbsakdbka']
'''

4.6、? :0-1个字符

import re
result = re.findall('haha.?haha','dsabdhahahahagugdbsakdbkajd')
result1 = re.findall('haha.?b','dsabdjhahahagugdbsakdbkajd')
print(result)
print(result1)

#打印结果
'''
['hahahaha']
[]
'''

4.7、 {}：匹配固定的氛围或者字符数

{,5}：从0--5

{5,}：从5--无数多

import re
result = re.findall('haha.{3}a','dsabdhahahahagugdbsakdbkajd')
result1 = re.findall('haha.{0,2}a','dsabdjhahahagugdbsakdbkajd')
print(result)
print(result1)

#打印结果
'''
['hahahaha']
['hahaha']
'''

4.8、[] ：或的作用，并且只代表一个字符

import re
result = re.findall('a[bc]d','acd')  #只匹配一个
result1 = re.findall('a[bc]d','abcd')  #不能匹配多个
result2 = re.findall('a[a-z]+d','abcdd')  #匹配多个
result3 = re.findall('a[b-z]d','aed')  #可以取匹配的范围
print(result)
print(result1)
print(result2)
print(result3)

#打印结果
'''
['acd']
[]
['abcdd']
['aed']
'''

除了-（代表范围）、^（代表非而不是起始的位置）、\d（代表数字）有特殊的意义，其他的字符都是代表普通的字符

import re
result = re.findall('a[a-z]+d','abcdd')  #匹配多个
result2 = re.findall('a[^f]d','aed')
result3 = re.findall('a[^f]d','afd')
result4 = re.findall('a[\d]d','a2d')

print(result)
print(result2)
print(result3)
print(result4)

#打印结果
'''
['abcdd']
['aed']
[]
['a2d']
'''

4.9、 | 

4.10、() 

4.11、 \

• 如果上面描述的元字符.   ^   $  *  +  ?  {}  []  |  () 加上\取消这些字符的功能
  
• \+部分普通的字符会有特殊的功能
  • \d：匹配任何十进制数，相当于类[0-9]
  • \D：匹配任何非数字，相当于类[^0-9]
  • \s：匹配任何空白字符，相当于类[\t\n\r\f\v]
  • \S：匹配任何非空白字符，相当于类[^ \t\n\r\f\v]
  • \w：匹配任何字母数字字符，相当于类[a-z A-Z 0-9  _ ]
  • \W：匹配任何非字母数字字符，相当于类[a-z A-Z 0-9]
  • \b：匹配一个单词边界，也就是指单词和空格间的位置

匹配单词边界（包括开始和结束），这里的“单词”，是指连续的字母、数字和下划线组成的字符串。

注意：\b的定义是\w和\W的交界

这是个零宽界定符，只用以匹配单词的词首和词尾。单词被定义为一个字母数字序列，因为词尾就是用空白符或非字母数字符来标示的

import re
result = re.findall('I','I am  Ihhahh')  #匹配所有包含I的地方
result2 = re.findall(r'I\b','I am  Ihhahh')  #匹配单独的单词I
result3 = re.findall(r'I\b','I&am  Ihhahh')  #匹配单独的单词I


print(result)
print(result2)
print(result3)


#打印结果
'''
['I', 'I']
['I']
['I']
'''

二、函数相关

1、math

1.1、格式

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

1.2、re.match('X','XXX').group()：返回被RE匹配的字符串

s1 = re.match('com','comsaohd')
print(s1)

s2 = re.match('com','comsaohd').group()
print(s2)

#打印结果
'''
<_sre.SRE_Match object; span=(0, 3), match='com'>
com
'''

1.3、start()：返回匹配开始的位置

s5 = re.match('com','comsaohd').start()
print(s5)

#打印结果
'''
0
'''

1.4、end()：返回匹配结束的位置

s6 = re.match('com','comsaohd').end()
print(s6)

#打印结果
'''
3
'''

1.5、span() :返回一个元组包含匹配（开始、结束）的位置

s7 = re.match('com','comsaohd').span()
print(s7)

#打印结果
'''
(0,3)
'''

1.6、group()：返回re整体匹配的字符串，可以一次输入多个组号，对应组号匹配的字符串

 

s8 = re.match('com','comsaohd').group()
print(s8)

#打印结果
'''
com
'''

 

注：match只匹配字符串的起始位置，如果起始位置没有，后面有的话返回为None

匹配不是前面的字符串可以使用search方法来进行匹配，并且只匹配第一个的位置信息，第二个不进行匹配

import re
s1 = re.match('com','saohcomsaohd')
print(s1)

s2 = re.match('com','comsaohcomsaohd')
print(s2)

#打印结果
'''
None
<_sre.SRE_Match object; span=(0, 3), match='com'>
'''

s4 = re.search('com','saohdcom')
print(s4)

#打印结果
'''
<_sre.SRE_Match object; span=(5, 8), match='com'>
'''

2、findall()：以列表形式返回所有匹配的字符串

2.1、格式

 

import re
re.findall(pattern.string,flags=0)

 

2.2、用法

 

import re
result = re.findall('I','I am  Ihhahh')  #匹配所有包含I的地方
result2 = re.findall(r'I\b','I am  Ihhahh')  #匹配单独的单词I
result3 = re.findall(r'I\b','I&am  Ihhahh')  #匹配单独的单词I

print(result)
print(result2)
print(result3)


#打印结果
'''
['I', 'I']
['I']
['I']
'''

3、finditer()：返回的是iterator对象（findall返回的是列表，其他用法都一样）

 

import re
result = re.finditer('I','I am  Ihhahh')  #匹配所有包含I的地方
result2 = re.finditer(r'I\b','I am  Ihhahh')  #匹配单独的单词I

print(result)
print(result2)


#打印结果
'''
<callable_iterator object at 0x10225fdd8>
<callable_iterator object at 0x10225f4a8>
'''

 

4、sub():匹配替换

4.1、格式('匹配替换的内容'，‘匹配替换后的内容’，‘替换的语句’)

 

import re
result = re.sub(pattern, repl, string, count=0, flags=0)

 

4.2、 全部替换

 

import re
result = re.sub('g.t','have','I get pen ,I gat a apple')

print(result)


#打印结果
'''
I have pen ,I have a apple
'''

 

4.3、限制替换的次数

 

import re
result = re.sub('g.t','have','I get pen ,I gat a apple',1)

print(result)


#打印结果
'''
I have pen ,I gat a apple
'''

5、subn():匹配替换之后并且返回替换的次数

 

import re
result = re.subn('g.t','have','I get pen ,I gat a apple')

print(result)


#打印结果
'''
('I have pen ,I have a apple', 2)
'''

 

6、split():对字符串做分割

 

import re
result = re.split('\d+','one1two2three3four4')

print(result)


#打印结果
'''
['one', 'two', 'three', 'four', '']
通过遍历的形式进行分割
第1个分割：
1的前面与后面进行分割：one  与 two2three3four4
...
第4次分割：
'one  two three four （前面）'  4  ' '（后面）
\d+：代表数字的分割符
'''

7、compile()

7.1、格式

 

import re
result = re.compile(pattern, flags=0)

 

7.2、查找所有包含'oo'的单词

 

import re
text = 'JGood is a handsome boy , he is cool , clever , and  so on ...'
regex = re.compile(r'\w*oo\w*')
print(regex.findall(text))


#打印结果
'''
['JGood', 'cool']
'''

 

7.3、相关原理介绍

这个方法是Pattern类的工厂方法，用于将字符串形式的正则表达式编译为Pattern对象。第二个参数flag是匹配模式，取值可以使用按位或运算符‘|’表示同时生效，比如re.I | re.M

可以把正则表达式编译成一个正则表达式对象，可以把那些经常使用的正则表达式编译成正则表达式对象，这样可以提高一定的效率。

8、其他方法

8.1、re.I  使匹配对大小写不敏感

8.2、re.L  做本地化识别匹配

8.3、re.M  多行匹配，影响^ 和 $

8.4、re.S  使 . 匹配包括换行在内的所有字符

8.5、re.U  根据unicode 字符集解析字符。这个标志影响\w，\W ，\b，\B

8.6、re.X  该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解

9、匹配反斜杠（）

9.1、方法一：r（告知python后面加上的字符都是原生字符串）

 

import re
print(re.search(r'\\com','www.run\comoobkkk').group())


#打印结果
'''
\com
'''

 

9.2、方法二：\\\\

 

import re
print(re.search('\\\\com','www.run\comoobkkk').group())


#打印结果
'''
\com
'''

 

三、分组

1、python中re模块提供了正则表达式相关操作

1.1、字符

.  匹配除换行符以外的任意字符

\W  匹配字母或数字或下划线或汉字

\s  匹配任意的空白符

\d  匹配数字

\b  匹配单词的开始或结束

^  匹配字符串的开始

$  匹配字符串的结束

1.2、次数

*  重复零次或更多次

+ 重复一次或更多次

? 重复零次或一次

{n}  重复n次

{n,}  重复n 次或更多次

{n,m} 重复n到m次

1.3、正则分组

定义：去已经提取到的数据中再去提取数据

1.3.1、math分组

import re
orgin = 'has defhsahochashdo123197312'

r1 = re.match('h\w+',orgin)
r2 = re.match('h(\w+)',orgin)
r3 = re.match('h(?P<name>\w+)',orgin)

print(r1.group())
print(r2.groups())
print(r3.groupdict())


#打印结果
'''
has
('as',)
{'name': 'as'}
'''

1.3.2、findall分组

import re
orgin = 'hasaabc ochalaabc hdo123197312'

r1 = re.findall('h\w+',orgin)  #正常匹配
r2 = re.findall('h(\w+)',orgin)  #分组匹配
r3 = re.findall('h(\w+)a(ab)c',orgin)  #多个分组匹配

print(r1)
print(r2)
print(r3)


#打印结果
'''
['hasaabc', 'halaabc', 'hdo123197312']
['asaabc', 'alaabc', 'do123197312']
[('as', 'ab'), ('al', 'ab')]
'''

1.3.3、split分组

import re
orgin = 'hasaabc ochalaabc'

r1 = re.split('a',orgin,2)  #正常匹配
r2 = re.split('(a)',orgin,2)  #分组匹配


print(r1)
print(r2)


#打印结果
'''
['h', 's', 'abc ochalaabc']
['h', 'a', 's', 'a', 'abc ochalaabc']
'''