python数据分析-正则表达式讲解及函数

1、首先要了解和明确的是如何用字符来描述字符或字符串。
2、在正则表达式中，如果直接给出字符，就是精确匹配。（eg：re.match(‘one’ , ‘one’ , regs=0)）
3、除了直接给出的字符还有一类元字符（metacharacters），包括：

4、熟悉python中re模块的常用函数。
5、正则表达式可以设定整个文本的模式：
（1）单行模式，文本被强制当作单行来匹配，什么样的文本不会被当作单行？就是里面包含有换行符的文本。（换行符：n）
（2）多行模式，文本被强制当作多行来匹配。包含换行符的字符串总是被当作多行处理。

示例：
1、. 的用法

2、[ ] 的用法

3、d和D的用法

a = 'python' 
match_object1 = re.match('pyd',a,flags=0)
print(match_object1)
match_object2 = re.match('pyD',a,flags=0)
print(match_object2.group())

b = 'py6thon' 
match_object3 = re.match('pyd',b,flags=0)
print(match_object3.group())
match_object4 = re.match('pyD',b,flags=0)
print(match_object4)
c = 'python'
d = 'pynhon'
e = 'pyrhon'
f = 'pybhon'
match_object5 = re.match('pyD',c,flags=0)
print(match_object5.group())
match_object6 = re.match('pyD',d,flags=0)
print(match_object6.group())
match_object7 = re.match('pyD',e,flags=0)
print(match_object7.group())
match_object8 = re.match('pyD',f,flags=0)
print(match_object8.group())

4、{ } 的用法

a = 'python222' 
match_object1 = re.match('python2{3}',a,flags=0)  #指定2匹配的次数
print(match_object1.group())
#结果：python222
match_object4 = re.match('python2{4}',a,flags=0)  #超过出现的次数则返回None
print(match_object4)
#结果：None

b = 'python2232' 
match_object2 = re.match('python2{2,3}',b,flags=0)  #指定2匹配的次数范围
print(match_object2.group())
#结果：python22
match_object3 = re.match('python2{3}',b,flags=0)  #{}代表连续出现的次数，2只连续出现了2次所以返回None
print(match_object3)
#结果：None

c = 'python22232'
match_object5 = re.match('python2{2,}',c,flags=0) 
print(match_object5.group())
#结果：python222

5、^ 和 $ 的用法
（1）单行模式，^ 表示匹配整个文本的开头位置。
（2）多行模式，^ 表示匹配文本每行的开头位置。

a = """01-张三-120斤n
02-李四-130斤n
03-王五-110斤n
04-小明-140斤n
"""
match_object1 = re.compile('^d{2,}')  #默认单行模式
print(match_object1.findall(a))
#结果：['01']
match_object2 = re.compile('^d{2,}',re.S)  #re.S指定“整个”文本按照单行模式
print(match_object2.findall(a))
#结果：['01']
match_object3 = re.compile('^d{2,}',re.M)  #re.MULTILINE指定文本按照多行模式
print(match_object3.findall(a))
#结果：['01', '02', '03', '04']

（3）单行模式，$ 表示匹配整个文本的结束位置。
（4）多行模式，$ 表示匹配文本每行的结束位置。

a = """01-张三-120斤n
02-李四-130斤n
03-王五-110斤n
04-小明-140斤n
"""
aa = """01-张三-120斤n02-李四-130斤n03-王五-110斤n04-小明-140斤n"""

b = """01-张三-120斤
02-李四-130斤
03-王五-110斤
04-小明-140斤
"""
match_object0 = re.compile('d{2,}斤$')  #包含换行符拉成一条直的，因为除了n外，本身文本换行也有换行符。
print(match_object0.findall(aa))
#结果：['140斤']
match_object1 = re.compile(r'd{2,}斤$')  #包含换行符不会当作单行处理,指定原生字符也不行。
print(match_object1.findall(a))
#结果：[]
match_object11 = re.compile('d{2,}斤$',re.S)  #包含换行符即使指定为单行模式也不行。
print(match_object11.findall(a))
#结果：[]
match_object3 = re.compile('d{2,}斤$',re.M)  #re.MULTILINE指定文本按照多行模式
print(match_object3.findall(a))
#结果：['120斤', '130斤', '110斤', '140斤']
#b文本中是没有末尾的换行符的，在单行模式下，返回最后一行的结尾字符。
match_object2 = re.compile('d{2,}斤$',re.S)  #re.S指定“整个”文本按照单行模式
print(match_object2.findall(b))
#结果：['140斤']

1、贪婪模式需要尽可能多的去匹配内容，其常用的表达式：.*【.表示识别任意除了n外的字符，表示识别0~n次；这里可以理解为 匹配0~n个 . 】
2、非贪婪模式，则需要精准匹配尽可能少的内容，其常用的表达式为：.?【?表示识别0次或1次；可以理解为匹配0~n个 . 但只匹配第一次符合规格的内容】
3、一般 .*?x 就是取前面任意长度的字符，直到一个x出现。

a = 'th' 
# 解释：<.*>是贪婪模式，所以会有多种组合方式如：和和，还有o中间部分作为整体等，所以结果整个字符串都匹配上。
match_object1 = re.match('<.*>',a,flags=0)
print(match_object1.group())
#结果：th

# 解释：<.*？>是非贪婪模式，所以只会匹配0或1次。
match_object2 = re.match('<.*?>',a,flags=0)
print(match_object2.group())
#结果：

group() 同group(0)就是匹配正则表达式整体结果
group(1) 列出第一个括号匹配部分，group(2) 列出第二个括号匹配部分，group(3) 列出第三个括号匹配部分。

a = """01-张三-120斤n
02-李四-130斤n
03-王五-110斤n
04-小明-140斤n
05-小明明-150斤n
06-小明明明-160斤n
"""
match_object0 = re.compile('(d{2,})-(.*?)-(d*)')  
for i in match_object0.findall(a):
    print(i)
match_object1 = re.match('(d{2,})-(.*?)-(d*)',a)  
print(match_object1.group()) 
print(match_object1.group(1))
print(match_object1.group(2))
print(match_object1.group(3))

1、re.compile(pattern，flags= 0)
将正则表达式模式编译为正则表达式对象，然后返回一个正则表达式对象，可使用match()，search()等方法将其用于匹配。
pattern:编译时用的表达式字符串。
flags:是匹配模式，编译标志位，用于修改正则表达式的匹配方法，可以使用按位或’|'表示同时生效，也可以在正则表达式字符串中指定。Pattern对象是不能直接实例化的，只能通过compile方法得到。如：是否区分大小写，多行匹配。
常用的flags有：

a = '鱼在水里游,鸟在天上飞,羊在地面跑,牛在 ,haha'
match_object1 = re.compile('w{1,}',re.A)  #指定re.A只返回英文的haha
print(match_object1.findall(a))
#结果：['haha']
match_object2 = re.compile('w{1,}')  #未指定re.A返回全部w规则的字符
print(match_object2.findall(a))
#结果：['鱼在水里游', '鸟在天上飞', '羊在地面跑', '牛在', 'haha']

2、re.match(pattern , string , flags=0)
从字符串开头的零个或多个字符与正则表达式模式匹配，如果匹配成功，返回一个匹配成功的对象，否则返回None。

a = 'python'
match_object0 = re.match('py.',a,flags=0)
print(match_object0.group())
#结果：pyt
match_object1 = re.match('y.',a,flags=0)
print(match_object1.group())  #不是从头开始的字符，所以报错
#结果：AttributeError: 'NoneType' object has no attribute 'group'

3、re.fullmatch (pattern，string，flags = 0)
如果整个字符串与正则表达式模式匹配，则返回相应的match对象。如果字符串与模式不匹配，则返回None。

a = 'python'
match_object0 = re.fullmatch('py....',a,flags=0)
print(match_object0.group())
#结果：python
match_object1 = re.fullmatch('py...',a,flags=0)
print(match_object1.group())
#结果：AttributeError: 'NoneType' object has no attribute 'group'

4、re.search(pattern , string , flags=0)
检查匹配项，在字符串中的任何位置检查匹配项

a = 'python'
match_object0 = re.search('.th.',a,flags=0)
print(match_object0.group())
#结果：ytho

5、re.findall(pattern , string , flags=0 )
以列表形式返回string中pattern的所有非重叠匹配项。从左到右扫描该字符串，并以找到的顺序返回匹配项。如果该模式中存在一个或多个组，则返回一个组列表；否则，返回一个列表。如果模式包含多个组，则这将是一个元组列表。空匹配项包含在结果中。

a = 'pythonn,pythonn,pythonn'
match_object0 = re.findall('.th',a,flags=0)
print(match_object0)
#结果：['yth', 'yth', 'yth']
match_object1 = re.findall('(py)th(on)',a,flags=0)
print(match_object1)
#结果：[('py', 'on'), ('py', 'on'), ('py', 'on')]

6、re.finditer(pattern , string , flags=0 )
与 findall()函数相同，从左到右扫描该字符串，但返回的不是一个列表，而是一个迭代器，该迭代器在string类型的re模式的所有非重叠匹配中产生匹配对象。对于每一次匹配，迭代器都以找到的顺序返回一个匹配对象,空匹配项包含在结果中。

a = 'pythonn,pythonn,pythonn'
match_object0 = re.finditer('.th',a,flags=0)
print(match_object0)
#结果：
print(next(match_object0).group())  #查看下一个匹配值
#结果：yth
for i in match_object0:
    print(i.group())
#结果：
# yth
# yth
# yth

7、re.split(pattern, string, maxsplit=0, flags=0)
根据正则表达式的模式分隔符，split函数将字符串分割为列表，然后返回成功匹配的列表，分隔最多操作max次（默认分割所有匹配成功的位置）

a = 'pythonn,pythonn,pythonn'
match_object0 = re.split('n',a)
print(match_object0)
#结果：['python', ',python', ',python', '']
match_object1 = re.split('n',a,maxsplit=2)
print(match_object1)
#结果：['python', ',python', ',pythonn']

8、re.sub(pattern,repl,string,count=0 , flags = 0)
使用 repl 替换所有正则表达式的模式在字符串中出现的位置的字符串。如果找不到该模式， 则返回的字符串不变。 repl可以是字符串或函数；如果是字符串，则处理其中的任何反斜杠转义。即，将其转换为单个换行符，将其转换为回车，依此类推。count参数表示将匹配到的内容进行替换的次数。
即：用repl替换pattern匹配到的字符串。

a = 'pythonn,pythonn,pythonn'
match_object0 = re.sub('n','OK',a,count=0)  #将匹配到的n替换成OK,返回结果为字符串
print(match_object0)
#结果：pythonOK,pythonOK,pythonOK
print(type(match_object0))
#结果：
match_object1 = re.sub('n','OK',a,count=2)  #将匹配到的n替换成OK,替换2次
print(match_object1)
#结果：pythonOK,pythonOK,python

9、re.subn（pattern，repl，string，count = 0，flags = 0 ）
执行与相同的操作sub()，但返回一个元组。(new_string, number_of_subs_made)

a = 'pythonn,pythonn,pythonn'
match_object0 = re.subn('n','OK',a,count=0)  #将匹配到的n替换成OK,返回结果为字符串
print(match_object0)
#结果：('pythonOK,pythonOK,pythonOK', 3)
print(type(match_object0))
#结果：
match_object1 = re.subn('n','OK',a,count=2)  #将匹配到的n替换成OK,替换2次
print(match_object1)
#结果：('pythonOK,pythonOK,pythonn', 2)

10、re.purge()
清除隐式编译的正则表达式模式。

11、re.escape(pattern)
escape中的所有字符图案，除了ASCII字母，数字和’_’。对字符串中所有可能被解释为正则运算符的字符进行转义的应用函数。如果字符串很长且包含很多特殊技字符，而你又不想输入一大堆反斜杠，或者字符串来自于用户(比如通过raw_input函数获取输入的内容)，且要用作正则表达式的一部分的时候，可以使用这个函数。

a = 'www.python.com'
b = re.escape(a)
print(b)
#结果：www.python.com