1、普通字符：大多数字符和字母都会和自身匹配
import re
# 前一段字符串为匹配规则，后一段字符串为要匹配的字符串
ret = re.findall('adc','youareagoodadcpreson')
print(ret)# ['adc']
2、元字符：. ^ $ * + ? {} [] \ () |
2-1 . ^ $ * + ? {}
import re
# . 代表一个字符除了'\n'
ret1 = re.findall('a..d', 'helloabcdefg')
ret2 = re.findall('a..d', 'helloabdefg')
print(ret1,ret2)# ret1匹配成功['abcd']，ret2匹配失败[]
# ^ 代指字符串的开头
ret1 = re.findall('^a..d', 'abcdef')
ret2 = re.findall('^a..d', 'qabcdef')
print(ret1, ret2)# ret1匹配成功['abcd']，ret2匹配失败[]
# $ 代指字符串的结尾
ret1 = re.findall('a..d$', 'qwerabcd')
ret2 = re.findall('a..d$', 'qwerabcdef')
print(ret1, ret2)# ret1匹配成功['abcd']，ret2匹配失败[]
# * 紧挨的字符重复0--无穷次
ret1 = re.findall('ra*', 'qweraaaaabcd')
ret2 = re.findall('qwel*', 'qweraaaaabcd')
print(ret1, ret2)# ['raaaaa'] ['qwe']
# + 紧挨的字符重复1--无穷次
ret1 = re.findall('qwera+', 'qweraaaaabcd')
ret2 = re.findall('qwerb+', 'qwerabcdef')
print(ret1, ret2)# ['qweraaaaa'] []
# ？代表紧挨的字符匹配0--1次
ret1 = re.findall('qwera?', 'qweraaaaabcd')
ret2 = re.findall('qwerb?', 'qwerabcdef')
print(ret1, ret2)#['qwera'] ['qwer']
### 注意：前面的 + * ? 等都是贪婪匹配，也就是尽可能的匹配，后面加 ? 使其变为惰性匹配
ret = re.findall('qwera+?', 'qweraaaaabcd')
print(ret)# ['qwera']
# {0, } == *
# {1, } == +
# {0, 1} == ?
ret1 = re.findall('qwera{0,2}', 'qweraaaaabcd')
ret2 = re.findall('qwera{0,}', 'qweraaaaabcd')
print(ret1, ret2)# ['qweraa'] ['qweraaaaa']
2-2 字符集 []
import re
ret1 = re.findall('a[bc]d', 'qwacd')
ret2 = re.findall('a[bc]d', 'qwabcd')
ret3 = re.findall('a[bc]', 'qwa')
ret4 = re.findall('a[bc]*', 'qwa')
print(ret1, ret2, ret3, ret4)# ['acd'] [] [] ['a']
ret1 = re.findall('a[a-z]d', 'qwacd')
ret2 = re.findall('[a-z]', 'abcd')
print(ret1, ret2)# ['acd'] ['a', 'b', 'c', 'd']
ret = re.findall('a[.*+]', 'qwa.a*ca+d')
print(ret)# ['a.', 'a*', 'a+']
### 字符集中有功能的符号: - ^ \
ret = re.findall('[1-9]', '1ab3cd6f')
# 按ASCII码排列
print(ret)# ['1', '3', '6']
#在字符集中^代表非
ret1 = re.findall('[^1-9]', '123abc')
ret2 = re.findall('[^abc]', '123abc')
print(ret1, ret2)# ['a', 'b', 'c'] ['1', '2', '3']
ret = re.findall('[\d]', 'qwe231')
print(ret)# ['2', '3', '1']
2-3 转义字符 \
反斜杠后面跟元字符去除特殊功能，比如*
反斜杠后面跟普通字符实现特殊功能，比如\d
\d---匹配任何十进制数，相当于类[0-9]
\D---匹配任何非数字字符，相当于类[^0-9]
\s---匹配任何空白字符，相当于类[\t\n\r\f\v]
\S---匹配任何非空白字符，相当于类[^\t\n\r\f\v]
\w---匹配任何字母数字字符，相当于类[a-zA-Z0-9]
\W---匹配任何非字母数字字符，相当于类[^a-zA-Z0-9]
\b---匹配一个特殊字符边界，比如空格，&，#等
import re
a = 'i am good boy'
ret = re.findall('i\\b', a)# 模式字符串
print(ret)# []
ret = re.findall(r'i\b', a)# 原生字符串
print(ret)# ['i']
ret = re.findall(r'i\\l', 'i\lm')
print(ret)# ['i\\l']
由于模式字符串中可能包含大量的特殊字符和反斜杠,所以需要写为原生字符串,即在模式字符串前加 r 或 R.
2-4 分组 ()
import re
ret1 = re.findall(r'(ab)+', '123abbb')
print(ret1)# ['ab']
ret2 = re.findall('abc+', '123abc3abcabc')
print(ret2)# ['abc', 'abc', 'abc']
# 以abc为整体，返回值为abc
ret3 = re.findall('(abc)+', '123abcabcabc')
print(ret3)# ['abc']
# 优先返回分组里的内容
ret4 = re.findall('a(b|c)d', '1abd2acd3')
print(ret4)# ['b', 'c']
# 在 () 中加 ?: 取消权限
ret5 = re.findall('a(?:b|c)d', '1abd2acd3')
print(ret5)# ['abd', 'acd']
2-5 选择字符 |
| 表示或
import re
ret1 = re.findall('abc|d', '123abd')
print(ret1)# ['d']
ret2 = re.findall('abc|d', '123abc|d')
print(ret2)# ['abc', 'd']
ret3 = re.findall('ab(c|d)', 'abc123abd')
print(ret3)# ['c', 'd']
3、标志位
A or ASCII--->对于\w,\W,\b,\B,\d,\D,\s,\S只进行ASCII匹配
I or IGNORECASE--->执行不区分字母大小写的匹配
M or MULTILINE--->将^和$用于包括整个字符串的开始和结尾的每一行
S or DOTALL--->使用(.)字符匹配所有字符,包括换行符
X or VERBISE--->忽略模式字符串中为转移的空格和注释
4、re模块下的常用方法
4-1 re.findall(pattern, string, [flags])
pattern--模式字符串，rep--替换的字符串， string--被查找替换的原始字符串
(可选参数)flags--表示标志位，控制匹配方式
import re
# 满足所有匹配条件的结果，放在列表里
ret1 = re.findall('ab', 'abcabc')
print(ret1)# ['ab', 'ab']
4-2 re.search(pattern, string, [flags])
import re
# 整个字符串中搜索第一个匹配的值，匹配成功则返回Match对象，否则返回None
ret2 = re.search('ab', '123abcabc')
print(ret2)#
ret3 = re.search('ab', '123abcabc').group()
print(ret3)# ab
# 匹配括号中的值赋予一个变量名()-->(?P<变量名>模式字符串)
ret3 = re.search(R'(?P[a-z]+)\d+', 'abc123abc123abc').group()
print(ret3)# abc123
ret4 = re.search(R'(?P[a-z]+)\d+', 'abc123abc123abc').group('name')
print(ret4)# abc
4-3 re.match(pattern, string, [flags])
同Search，但是仅在字符串开始处进行配对
import re
ret1 = re.match('1a', '1a2b3c')
print(ret1)#
ret2 = re.match('2b', '1a2b3c')
print(ret2)# None
4-4 re.split(pattern, string, [maxsplit], [flags])
(可选参数)maxsplit--最大的拆分次数
import re
ret1 = re.split(' ', 'hello world !')
print(ret1)#['hello', 'world', '!']
# 分割字符左边无字符时为空
ret2 = re.split('[ |]', " hello every|world !")
print(ret2)#['', 'hello', 'every', 'world', '!']
4-5 re.sub(pattern, rep1, string, [count], [flags])替换字符串
rep--替换的字符串
(可选参数)count--替换的最大次数，默认为0
import re
ret1 = re.sub('\d', 'A', '123abc', 0)
print(ret1)# AAAabc
ret2 = re.sub('\d+', 'A', '12ab34cd', 1)
print(ret2)# Aab34cd
# 元组形式，包含匹配次数
ret3 = re.subn('\d+', 'A', '1a2b3c4d')
print(ret3)# ('AaAbAcAd', 4)
4-6 将模式字符串转换为正则表达式对象
import re
bj = re.compile('\d+')
ret = obj.findall('1a2b3c4d')# 好处：可以多次使用
print(ret)# ['1', '2', '3', '4']
4-7 re.findall() 与 re.finditer()
import re
# 所有结果封装到列表
ret1 = re.findall('\d', '1a2b3c')
print(ret1)# ['1', '2', '3']
# 返回迭代器对象
ret2 = re.finditer('\d', '1a2b3c')
print(ret2)#
print(next(ret2).group())# 1
print(next(ret2).group())# 2