python正则表达式总结

"""author = 陈俊龙"""

==============正则表达式符号============

re模块主要提供正则相关的方法

import re

1.什么是正则

正则是匹配字符串的一直工具，拥有自己的语法，语法中包含各种符号的使用

2.正则语法

re.fullmatch(正则表达式,字符串) -
检测字符串是否完全符合正则规则（完全匹配）

如果匹配成功返回匹配对象，如果匹配失败结果返回None

正则表达式 - python中的正则表达式是写在引号中的内容，可以是单引号，也可以是双引号，但是一般会在引号前加r， r'正则表达式'

3.匹配符号

1)普通字符 - 除了正则中有特色功能和特殊意义以外的其他所以字符

例如：a,b,c,123,~,你....

普通字符在正则表达式中就表示字符本身

re_str = r'abc'
res = re.fullmatch(re_str, 'abc')
print(res)  # <_sre.SRE_Match object; span=(0, 3), match='abc'>

2).（点） - 匹配任意一个字符

正则中出现点.的位置可以匹配任意字符（一个点匹配一个任意字符）

re_str = r'a..c'  # 匹配一个长度是4的字符串，以a开头，c结尾，中间任意两个字符
res = re.fullmatch(re_str, 'a4cc')
print(res)  # <_sre.SRE_Match object; span=(0, 4), match='a4cc'>

3)\w - 匹配任意一个字母，数字，下划线(只针对ASCII码有效）用得较少！

re_str = r'a\wc.'
res = re.fullmatch(re_str, 'a_c6')
print(res)  # <_sre.SRE_Match object; span=(0, 4), match='a_c6'>

4)\s - 匹配一个空白字符

空白字符：空格，回车/换行，制表符

re_str = r'a\sc.'
res = re.fullmatch(re_str, 'a\nc6')
print(res)  # <_sre.SRE_Match object; span=(0, 4), match='a\nc6'>

5) \d - 匹配一个数字字符

re_str = r'a\dc'
res = re.fullmatch(re_str, 'a6c')
print(res)  # <_sre.SRE_Match object; span=(0, 3), match='a6c'>

6) \大写字母 - 匹配\小写字母取反的类容

\W - 匹配非数字，字母下划线
\S - 匹配非空白字符
\D - 匹配非数字字符

re_str = r'a\D\S\Wc'
res = re.fullmatch(re_str, 'a#A#c')
print(res)  # <_sre.SRE_Match object; span=(0, 5), match='a#A#c'>

7) [ ] - 匹配字符集 注意：一个中括号只匹配一个字符

a.普通用法

[字符集] - 匹配字符集中的任意一个字符
例如：
[az1+] - 表示匹配一个字符是中括号中的任意一个字符
[\dabc] - 表示匹配一个数字或者a b c 中的一个字符

b.表示范围的字符集

[字符1-字符2] - 匹配字符1到字符2中的任意一个字符，注意，字符2的编码值必须大于字符1
例如：
[5-9] - 匹配5到9中的任意一个字符
[a-zA-Z] - 匹配任意一个字母
[a-zA-Z\d_] - 匹配字母，数字，下划线

c.表示反向选中[^字符集] - 表示选中除了字符集中以外的其他任意一个字符

任意字符实例：

re_str = r'[abc\d]bc'
res = re.fullmatch(re_str, 'cbc')
print(res)

范围实例：

re_str = r'[a-zA-Z\d_]bc'
res = re.fullmatch(re_str, '2bc')
print(res)

反向实例：

re_str = r'[^a-zA-Z\d_]bc'
res = re.fullmatch(re_str, '#bc')
print(res)

4.检测符号

注意：
一个匹配符号必须对应一个具体字符，而检测符号只是对符号所在位置进行检查，不会影响字符串长度

1）\b - 检测是否是单词边界

单词边界：
一切可以将两个单词区分开的符号都是单词边界，例如单词开头，单词结尾，空白，标点符号等....

print(re.fullmatch(r'how\b are', 'how are'))

2) ^ - 检查^所在位置是否是字符串开头

print(re.fullmatch(r'^how are', 'how are'))
print(re.search(r'^are', 'are234'))

3) $$ - 检查$所在位置是否是字符串结尾

print(re.search(r'\dare$', '123are234are'))  # 如果不加后面$会匹配到3are

==============正则表达式符号2===========

import re

1.匹配次数：

* - 匹配星号*前的字符0次或多次

+ - 匹配加号+前的字符1次或多次

？- 匹配问号？前的字符0次或1次

print(re.fullmatch(r'[abc]*', 'aaa'))
print(re.fullmatch(r'[abc]+', 'a'))
print(re.fullmatch(r'[+-]?\d+', '12345'))

{}

{N} - 匹配n次
{M,N} - 匹配m到n次
{M,} - 匹配至少m次
{,N} - 匹配至多N次

print(re.fullmatch(r'a{2}bc', 'aabc'))
print(re.fullmatch(r'a{3,5}bc', 'aaaabc'))
print(re.fullmatch(r'a{3,}bc', 'aaaaaaaaabc'))
print(re.fullmatch(r'a{,5}bc', 'aaaaabc'))

练习：

判断用户名和密码是否合法，用户名要求必须有数字字母下划线，且长度6-20位

print(re.fullmatch(r'[A-Za-z\d_]{6,20}', 'chenjunlong1995'))
print(re.fullmatch(r'[1-9]\d{4,11}', '900000'))

贪婪模式和非贪婪模式：

,+,?,{}对应的匹配次数都是贪婪的,在匹配次数不确定的情况下才有贪婪和非贪婪的区分
在匹配次数不确定的符号后面加？，就会变成非贪婪：?,+?,??,{m,n}?

贪婪模式：在匹配成功的前提下，尽可能多的进行匹配

非贪婪：在匹配成功的前提下，尽可能少的匹配

贪婪模式实例

result = re.search(r'.+b', '123basdb222b')
print(result)  # match='123basdb222b'>

非贪婪模式实例

result = re.search(r'.+?b', '123basdb222b')
print(result)  # match='123b'

分之

正则表达式1 | 正则表达式2

print(re.fullmatch(r'\d{3}|[a-zA-Z]{3}', 'ZZZ'))

需求:一个字符串最开头是三个数字或者三个小写字母，后面大写字母 分组实例：

print(re.fullmatch(r'(\d{3}|[a-zA-Z]{3})[A-Z]+', 'asdBB'))

4. 分组（）

分组（） - 将正则中的一部分看成一个整体进行操作
重复 - 添加分组后，可以在分组的后面加上\M来重复前面的第M个分组匹配到的结果

分组实例：

print(re.fullmatch(r'(\d\d:)+\d\d', '19:29:90:88'))

重复实例：

print(re.fullmatch(r'(\d+)abc\1', '12abc12'))
print(re.fullmatch(r'(\d+)([a-z])abc\2', '12aabca'))
print(re.fullmatch(r'(\d+)\1([a-z])abc\2', '1212aabca'))

5.转义符号 - 在正则符号前加反斜杠\让符号的功能消失

正则中的转义符号和字符串的转义字符串是两回事

第二种转义方式：

单独的特殊符号放在[]中括号中特殊意义也会消失

转义字符实例：

print(re.fullmatch(r'\.a', '.a'))
print(re.fullmatch(r'\d\+\d', '3+3'))

中括号转义的实例：

print(re.fullmatch(r'[.]a', '.a'))
print(re.fullmatch(r'\d[+]\d', '3+3'))
print(re.fullmatch(r'[.+*][+]\d', '++3'))
print(re.fullmatch(r'[15-]\d', '-2'))
print(re.fullmatch(r'[a\]]\d', '\6'))  # 匹配不了？？？？？？？？？？？？？

=================re模块==============

import re

1.创建正则对象

compile(正则表达式） - 根据正则表达式创建正则对象

2.匹配

fullmatch(正则表达式，字符串) - 让整个字符串和正则表达式进行匹配（完全匹配）

match(正则表达式，字符串) - 让正则表达式的开头和正则表达式进行匹配

返回值：匹配成功是匹配结果对象，匹配失败是None

print(re.match(r'[1-9]{3}', '11111111111'))  # match='111'>

匹配结果

1）能取到匹配结果对应的字符串

匹配对象.group() - 获取整个正则匹配到的结果

匹配对象.group(N) - 获取第n个分组匹配到的结果

获取匹配结果实例：

result = re.match(r'[1-9]{3}', '11111111111')
print(result.group())  # 111
# 取第二个分组匹配到的结果实例：
result = re.match(r'([1-9])([123])', '12')
print(result.group(2))  # 2

2）获取匹配位置：

匹配对象.span() - 获取匹配匹配结果在字符串中的开始和结束下标

匹配对象.span(N)
匹配对象.start()
匹配对象.end()

3).获取原字符串

匹配对象.string - 获取原来的字符串

3.查找

search(正则表达式，字符串) -

匹配出字符串中第一个满足正则表达式的子串，结果是匹配对象

findall(正则表达式，字符串) -

获取字符串中所有满足正则表达式的字串，结果是一个列表，列表中的元素是字符串

finditer(正则表达式，字符串) -

获取字符串中所有满足正则表达式的字串,结果是一个迭代器，迭代器的元素是匹配对象

result = re.search(r'\d{3}', '123ashdahdb76438hbbd')
print(result.group())  # 123

result = re.findall(r'\d{3}', '123ashdahdb76438hbbd')
print(result)  # ['123', '764']

4.切割

split(正则表达式，字符串) -

按照满足正则表达式的字串对字符串进行切割，返回的是列表
可以使切割更加灵活

str1 = 'aaa0bbb0ccc0ddd'
print(str1.split('0'))  # ['aaa', 'bbb', 'ccc', 'ddd']
# 灵活切割实例
str1 = 'aaa01bbb03ccc05ddd'
print(re.split('\d+',str1))  #  ['aaa', 'bbb', 'ccc', 'ddd']

5.替换

sub(正则表达式，字符串1，字符串2，替换次数=0) -

将字符串2中满足正则表达式的字串替换成字符串1，替换次数为0时全部替换

str1 = 'aaa01bbb03ccc05ddd'
print(re.sub('\d+', '+', str1))  # aaa+bbb+ccc+ddd