正则表达式学习总结

import re

'''
re.match()函数
原型：match(pattern,string,flags=0)
pattern:匹配的正则表达式
string：要匹配的字符串
flags:标志位，用于控制正则表达式的匹配方式，值如下：
re.I  忽略大小写
re.L  做本地化识别
re.M  多行匹配，影响^和$元字符
re.S  是.匹配包括换行符在内的所有字符
re.U  根据Unicode字符集解析字符，影响\w \W \b \B
re.X  使我们跟了灵活的格式使用正则表达式
参数：
功能：尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，返回None
'''
# www.baidu.com
print(re.match('www','www.baidu.com'))

print(re.match('www','12www.baidu.com'))

print(re.match('www','ww.baidu.com'))

print(re.match('www','Www.baidu.com',flags=re.I))

'''
输出结果：
<_sre.SRE_Match object; span=(0, 3), match='www'>
None
None
<_sre.SRE_Match object; span=(0, 3), match='Www'>
'''

'''
# 扫描整个字符串，返回从起始位置匹配成功的匹配
re.search函数
原型：原型：search(pattern,string,flags=0)
pattern:匹配的正则表达式
string：要匹配的字符串
flags:标志位，用于控制正则表达式的匹配方式
功能：扫描整个字符串，并返回第一个成功的匹配
'''
# serarch和match的区别是match是从头开始匹配，
# search是返回第一个匹成功的字符串
print(re.search('sunck', 'good man is sunck!sunck! is nice'))

'''
输出结果：<_sre.SRE_Match object; span=(12, 17), match='sunck'>

'''

'''
# 如果想要全部查找呢？
re.findall函数
原型：原型：findall(pattern,string,flags=0)
pattern:匹配的正则表达式
string：要匹配的字符串
flags:标志位，用于控制正则表达式的匹配方式
功能：扫描整个字符串，并返回一个列表
'''
print(re.findall('sunck', 'good man is sunck!sunck! is nice'))
['sunck', 'sunck']

 

import re

print('---------------匹配单个字符与数字---------------')
r'''
 .   ：  匹配除换行符以外的字符
 [0123456789]:  []是字符集合，表示匹配方括号中所包含的任意一个字符
 [sunck]     : 匹配sunck中任意一个字符
 [a-z]       : 匹配任意一个小写之母
 [A-Z]       : 匹配任意一个大写字母
 [0-9]       : 匹配任意一个数字
 [0-9a-zA-Z] : 匹配任意的数字和字母
 [0-9a-zA-Z_] : 匹配任意的数字和字母和下划线
 [^sunck]     : 匹配除了sunck这几个字母意外的所有字符，中括号里的
                ^称为托字符，表示不匹配集合的字符
 [^0-9]       :匹配所有的非数字字符
 \d           : 匹配数字，效果同[0-9]
 \D           ： 匹配非数字字符，效果同[^0-9]
 \w           : 匹配数字、字母、和下划线，效果同[0-9a-zA-Z_]
\W            : 匹配非数字、字母、和下划线，效果同[^0-9a-zA-Z_]
\s            : 匹配任何的空白符(空格、换行、回车、换业、制表)，效果和[ \f\n\r\t]
\S            : 匹配非任何的空白符(空格、换行、回车、换业、制表)，效果和[^ \f\n\r\t]
'''

print(re.search('.','sunk is a good man '))
print(re.search('[0123456789]','sunk is a good man 2 4,7'))
print(re.search('[sunk]','sunk is a good man '))
print(re.findall('[^0-9]','sunk is a good man 1,2,3,4,5,'))
print(re.findall('\d','sunk is a good man 1,2,3,4,5,'))
print(re.findall('\D','sunk is a good man 1,2,3,4,5,'))
print(re.findall('\w','___sunk is a #$%^ good man 1,2,3,4,5,'))
print(re.findall('\w','___Sunk is A #$%^ good man 1,2,3,4,5,',flags=re.S))

'''
输出：
---------------匹配单个字符与数字---------------
<_sre.SRE_Match object; span=(0, 1), match='s'>
<_sre.SRE_Match object; span=(19, 20), match='2'>
<_sre.SRE_Match object; span=(0, 1), match='s'>
['s', 'u', 'n', 'k', ' ', 'i', 's', ' ', 'a', ' ', 'g', 'o', 'o', 'd', ' ', 'm', 'a', 'n', ' ', ',', ',', ',', ',', ',']
['1', '2', '3', '4', '5']
['s', 'u', 'n', 'k', ' ', 'i', 's', ' ', 'a', ' ', 'g', 'o', 'o', 'd', ' ', 'm', 'a', 'n', ' ', ',', ',', ',', ',', ',']
['_', '_', '_', 's', 'u', 'n', 'k', 'i', 's', 'a', 'g', 'o', 'o', 'd', 'm', 'a', 'n', '1', '2', '3', '4', '5']
['_', '_', '_', 'S', 'u', 'n', 'k', 'i', 's', 'A', 'g', 'o', 'o', 'd', 'm', 'a', 'n', '1', '2', '3', '4', '5']
'''

 

print("-------------锚字符(边界字符)---------------")
'''
^     行首匹配，在[]里面的不一样，这是判断是否是开头的
$     行尾匹配
\A     匹配字符串的开始，他和^的区别是，A\只匹配整个字符串的开头，即使在re.M
       模式下也不会匹配他的行首
\Z      匹配字符串的结束，他和$的区别是，\Z只匹配整个字符串的结尾，即使在re.M
       模式下也不会匹配他的结尾
\b    匹配一个单词的边界，也就是单词和空格间的位置
\B    匹配非单词的边界  
        

'''


print(re.search('sunck$','sunck is a good man 1,2,3,4,5,sunck'))

print(re.findall('^sunk','sunk is a good man \nsunk is a good man',re.M))
print(re.findall('\Asunk','sunk is a good man \nsunk is a good man',re.M))


'''
输出：
-------------锚字符(边界字符)---------------
<_sre.SRE_Match object; span=(30, 35), match='sunck'>
['sunk', 'sunk']
['sunk']
'''

print('---------匹配多个字符-------------')
'''
说明：下方的x、y、z、n均为假设的普通字符，不是正则表达式的元字符(xyz)
(xyz)    匹配小括号内的xyz(作为一个整体去匹配)
x?       匹配0个或者1个x
x*       匹配0个或者任意多个x(.*表示匹配0个或者任意多个字符，换行符除外)
x+       匹配至少一个x
x{n}     匹配至少n个x 
x{n,m}   匹配至少n个，之多m个x注意：n《m
x|y      匹配x或者y

'''


print(re.findall(r'sunck','sunckgood is s godo man , sunck isa nice man'))
print(re.findall(r'i?','sunckgood is s godo man , sunck isa nice man'))
print(re.findall(r'a?','aaaaaa')) # 非贪婪匹配
print(re.findall(r'a*','aaaaaa'))
print(re.findall(r'a*','aaabbabaaa'))# 贪婪匹配
print(re.findall(r'.*','aaabbabaaa'))# 贪婪匹配
print(re.findall(r'.*','aaabbabaaa \nadfal;fjd;ajf'))# 贪婪匹配

print(re.findall(r'a+','aaaadaavaaaa'))


print(re.findall(r'a{4}','aaaadaavaaaa'))
print(re.findall(r'a{3,6}','aaaadaavaaaa'))

'''
---------匹配多个字符-------------
['sunck', 'sunck']
['', '', '', '', '', '', '', '', '', '', 'i', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', 'i', '', '', '', '', 'i', '', '', '', '', '', '', '']
['a', 'a', 'a', 'a', 'a', 'a', '']
['aaaaaa', '']
['aaa', '', '', 'a', '', 'aaa', '']
['aaabbabaaa', '']
['aaabbabaaa ', '', 'adfal;fjd;ajf', '']
['aaaa', 'aa', 'aaaa']
['aaaa', 'aaaa']
['aaaa', 'aaaa']
'''

'''
字符串切割

'''

str1 = '   sunck is a good man  '
print(str1.split())
print(str1.strip().split())

print(re.split(r' +',str1))


'''
输出：
['sunck', 'is', 'a', 'good', 'man']
['sunck', 'is', 'a', 'good', 'man']
['', 'sunck', 'is', 'a', 'good', 'man', '']
'''

 

'''
re.finditer函数

和findall是一样的，只是返回的是迭代器
'''

str2 = 'sunck is a good man! sunck is a good man!sunck is a good man!'
d = re.finditer(r'sunck',str2)
while True :
    try:
        print(next(d))
    except StopIteration as e:
        break

'''
<_sre.SRE_Match object; span=(0, 5), match='sunck'>
<_sre.SRE_Match object; span=(21, 26), match='sunck'>
<_sre.SRE_Match object; span=(41, 46), match='sunck'>
​
'''

'''
字符串的替换和修改
def sub(pattern, repl, string, count=0, flags=0):
def subn(pattern, repl, string, count=0, flags=0):
pattern:正则表达式(规则)
repl: 指定的用来替换的字符串
string: 目标字符串
count:  最多替换次数
flags:
功能：在目标字符串中以正则表达式的规则匹配字符串
再把他们替换成指定字符串。可以指定替换的次数

区别：前者返回的是一个被替换的字符串，后者返回的是一个元组
第一个元素是被替换的字符串，第二个是被替换的次数


'''

str3 = 'sunck is a good good good good man'

print(re.sub(r'(good)','well',str3,2))

print(re.subn(r'(good)','nice',str3))
print(type(re.subn(r'(good)','nice',str3)))

'''
sunck is a well well good good man
('sunck is a nice nice nice nice man', 4)
<class 'tuple'>
'''

'''
分组：
概念：除了简单的判断是否匹配之外，正则表达式还有提取子串的功能
用()小括号表示分组


'''
print('-------------f分组---------------')
str4 =  '010-53421'
m = re.match(r'(\d{3})-(\d{5})',str4)
n = re.match(r'(？P<first>\d{3})-(\d{5})',str4)
print(m)
print(m.group(0))
print(m.group(1))
print(m.group(2))

print(type(m.groups()))
print(m.groups())

'''
-------------f分组---------------
<_sre.SRE_Match object; span=(0, 9), match='010-53421'>
010-53421
010
53421
<class 'tuple'>
('010', '53421')
'''

'''
编译：当我们使用正则表达式时，re模块会干两件事
1.编译正则表达式，如果正则表达式本身不合法，会报错
2.用编译后的正则表达式去匹配对象
'''
pat = r'1(([3578]\d)|(47))\d{8}$'

re_tele = re.compile(pat)

print(re_tele.match('13034352500'))


import re

str1 = '赵守风 1123435 zdfdafdfdafdjkAFJDAKLFJDLAK'
str2 = 'FJAFHJDAFfdjhakfjDFJD中国强大dfd起来了，多好1234啊#@！~%……&*+_)(**&*&&sg'

# 这里我们好好看看替换的用法，这在我们处理文本字符串很有用
# '[^0-9^a-z]'什么意思呢？很简单就是除了这些不匹配其他的都匹配
# 简单来说遇到数字和小写字母都不匹配，反之都匹配
pattern_com = re.compile('[^0-9^a-z]')
# 上面我们编译了匹配模式即pattern形式为除了数字、小写字母都匹配
# 那pattern_com.sub('#', str1)什么意思呢？很简单这是替换的函数，
# 就是说匹配上的都用#进替换，没匹配上的不变，和上面的不匹配字母和数字
# 刚好吻合
print(pattern_com.sub('#', str1))
print(pattern_com.sub('#', str2))

print('**********************************************')
# 那要是匹配上的我都不想要怎么把，直接使用空来替换,这样不匹配的
# 就是我们想要的了，这个在哪里能用到呢？在中文文本处理上，例如我想
# 去掉特殊字符、字母、数字、空格等，但是呢我想先保留逗号或者句号，直接添加进去就好了
print(pattern_com.sub('', str1))
print(pattern_com.sub('', str2))

print("******************文本处理*****************")
# 我只想要中文，保留逗号，句号和问号，其他的都去除，怎么做呢？
str3 = '我只fdafd想要中文，保留ERAEW逗号，句号1324和问号。其他~!@#$%=-&&的都去除，怎么做呢？'
print('原始字符串：', str3)
pattern2 = '[^，^。^？^\u4e00-\u9fa5]'
str_model = re.compile(pattern2)
print(str_model.sub('', str3))

输出：
####1123435#zdfdafdfdafdjk#############
#########fdjhakfj########dfd######1234####################sg
**********************************************
1123435zdfdafdfdafdjk
fdjhakfjdfd1234sg
******************文本处理*****************
原始字符串： 我只fdafd想要中文，保留ERAEW逗号，句号1324和问号。其他~!@#$%=-&&的都去除，怎么做呢？
我只想要中文，保留逗号，句号和问号。其他的都去除，怎么做呢？