python--re模块（正则表达式）

RE是什么

正则 表达 式子

就是一些带有特殊含义的符号或者符号的组合

它的作用是对字符串进行过滤

在一堆字符串中找到你所关心的内容

你就需要告诉计算机你的过滤规则是什么样 通过什么方式来告诉计算机 就通过正则表达式

注： re模块的内部实现 不是python 而是调用了c库

import re

s = "abc a1c 12\+- $_\n\tqaz" #定义字符串

b = "a ab abb abbb abbbbb a1bbbbbbbb" #定义字符串

\w	#匹配所有字母数字下划线
\W	#匹配所有非字母数字下划线
\s	#匹配所有空白字符
\S	#匹配所有非空白字符
\d	#匹配所有数字
\D	#匹配所有非数字
\n	#匹配所有的\n
\t	#匹配所有的\t
^ab	#从开头匹配字符串ab，只匹配一次
qaz$	#从结尾匹配字符串qaz，只匹配一次
.	代表除了换行符外的任意一个字符
?	不能单独用，代表左边的那一个字符重复0次或一次
*	代表左边的那一个字符重复0次或多次
+	代表左边的那一个字符重复1次或多次(至少出现一次)
{m，n}	代表左边的那一个字符出现m次到n次（n不写，代表无穷次）
.*	匹配任意长度，任意的字符-----》贪婪匹配(例：a.*c,从a开始，会一直找到最右边一个c，中间所有的字符都获取了，比较贪婪)
.*?	非贪婪匹配，找到最近的即可
()	分组:带括号去匹配，如果匹配成功，只留下括号内的字符串
[]	中括号内可以放任意字符，一个中括号代表一个字符，，这一个字符来自于中括号内

"""

re模块常用方法：

findall 从左往右查找所有满足条件的字符 返回一个列表

search 返回第一个匹配的字符串 结果封装为对象 span=(0, 5) 匹配的位置 match匹配的值

match 匹配行首 返回值与search相同

对于search match 匹配的结果通过group来获取

compile 将正则表达式 封装为一个正则对象 好处是可以重复使用这个表达式

"""

例子：

print(re.findall("\w",s)) #匹配所有字母数字下划线

print(re.findall("\W",s)) #匹配所有非字母数字下划线

print(re.findall("\s",s)) #匹配所有空白字符

print(re.findall("\S",s)) #匹配所有非空白字符

print(re.findall("\d",s)) #匹配所有数字

print(re.findall("\D",s)) #匹配所有非数字

print(re.findall("\n",s)) #匹配所有的\n

print(re.findall("\t",s)) #匹配所有的\t

print(re.findall("^ab",s)) #从开头匹配字符串，只匹配一次

print(re.findall("qaz$",s)) #从结尾匹配字符串，只匹配一次

# .代表除了换行符外的任意一个字符（要想可以匹配换行符，findall方法里可以加参数，re.DOTALL--DOT：点，ALL：所有）

print(re.findall("a.c",s)) #['abc', 'a1c']

# ? 不能单独用，代表左边的那一个字符重复0次或一次

print(re.findall("ab?",b)) #['a', 'ab', 'ab', 'ab', 'ab', 'a']

print(re.findall("ab{0,1}",b)) #['a', 'ab', 'ab', 'ab', 'ab', 'a']

# *代表左边的那一个字符重复0次或多次

print(re.findall("ab*",b)) #['a', 'ab', 'abb', 'abbb', 'abbbbb', 'a']

print(re.findall("ab{0,}",b)) #['a', 'ab', 'abb', 'abbb', 'abbbbb', 'a']

# + 代表左边的那一个字符重复1次或多次(至少出现一次)

print(re.findall("ab+",b)) #['ab', 'abb', 'abbb', 'abbbbb']

print(re.findall('ab{1,}',b)) #['ab', 'abb', 'abbb', 'abbbbb']

# {m，n}代表左边的那一个字符出现m次到n次（n不写，代表无穷次）

# .* 匹配任意长度，任意的字符-----》贪婪匹配(从a开始，会一直找到最右边一个c，中间所有的字符都获取了，比较贪婪)

print(re.findall("a.*c","a123c456c")) #['a123c456c']

# .*? 非贪婪匹配，找到最近的即可

print(re.findall("a.*?c","a123c456c")) #['a123c']

#分组:带括号去匹配，如果匹配成功，只留下括号内的字符串

print(re.findall("(abc)_sb","abc_sb sadsaddasdaabc_sb")) #['abc', 'abc']

#[]:中括号内可以放任意字符，一个中括号代表一个字符，，这一个字符来自于中括号内

# 在中括号内，“-”有特殊含义，当需要使用-的普通字符来使用的时候，把-放到[]的最左边或者最右边

print(re.findall("a[0-9]c","a1c a c a-c a+c aAc")) #['a1c']

print(re.findall("a[a-z]c","a1c a c a-c a+c aAc acc")) #['acc']

print(re.findall("a[A-Z]c","a1c a c a-c a+c aAc acc")) #['aAc']

print(re.findall("a[*+-]c","a1c a c a-c a+c a*c aAc acc")) #['a-c', 'a+c', 'a*c']

#^上尖号在中阔内表示取反的意思，并不是以某某开头

print(re.findall("a[^a-z]c","a1c a c a-c a+c aAc acc")) #['a1c', 'a c', 'a-c', 'a+c', 'aAc'](除了acc，都在这儿了)

print(re.findall("([a-z]+)_sb","lxx_sb sadadw213sdaalex_sb egon_sbasdasd "))

# | 竖杠 代表或者的意思

print(re.findall("compan(ies|y)","too many companies shutdown,I have a company"))

#['ies', 'y'],这个结果不是我们需要的，它只打印了ies或者y

print(re.findall("compan(?:ies|y)","too many companies shutdown,I have a company"))

#['companies', 'company']加上 ?: 表示前面的也需要，再加上竖杠选择的结果。

print(re.findall("alex|sb","alex is sb asdasdadalex sadasb egon")) #['alex', 'sb', 'alex', 'sb']

#re模块的其他方法：

# search ：只找一个，如果找到，就返回一个找到的对象，用group方法可以得到对应的值。

# match ：相当于带上尖号版本的search,它是也用group方法获得对应的值

print(re.search("alex","alex is sb asdasdadalex sadasb egon"))

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

print(re.search("alex","alex is sb asdasdadalex sadasb egon").group()) #alex

print(re.match("alex","alex is sb asdasdadalex sadasb egon")) #<_sre.SRE_Match object; span=(0, 4), match='alex'>

print(re.search("^alex","sad asd alex is sb asdasdadalex sadasb egon")) #None

print(re.match("alex","sad asd alex is sb asdasdadalex sadasb egon")) #None

#spilt方法

print(re.split("[a,w]","1a2w3e4r"))

使用字符串替换

# print('egon is beutifull egon'.replace('egon','EGON',1))

使用sub方法替换第二处的egon，替换为EGON

# print(re.sub('(.*?)(egon)(.*?)(egon)(.*?)',r'\1\2\3EGON\5','123 egon is beutifull egon 123'))

# (123 )(egon)( is beutifull )(egon)( 123)

#\1\2\3EGON\5

# print(re.sub('(lqz)(.*?)(SB)',r'\3\2\1',r'lqz is SB'))

# print(re.sub('([a-zA-Z]+)([^a-zA-Z]+)([a-zA-Z]+)([^a-zA-Z]+)([a-zA-Z]+)',r'\5\2\3\4\1',r'lqzzzz123+ is SB'))

#(lqzzzz)(123+ )(is)( )(SB)

如果经常需要用到某个正则表达式，可以先存起来，然后直接调用，存的方法是complie

pattern=re.compile('alex')

print(pattern.findall('alex is alex alex'))

print(pattern.findall('alexasdfsadfsadfasdfasdfasfd is alex alex'))