正则表达式-常用方法介绍

1.什么是正则表达式

正则表达式是字符串匹配工具,他是为了在某些需求下可以更方便、更快速的处理字符串。
import re

2.怎么使用正则处理字符串

python通过提供re模块来支持正则表达式

re.fullmatch(正则表达式,字符串) – 让正则表达式和字符串进行完全匹配,返回匹配结果;如果匹配不成功,返回None

3.怎么写正则表达式

python中正则表达式是放在字符串中,并且这个字符串一般会在最前面加r/R。
r’正则’

4.正则语法

1)普通字符 – 代表字符本身

re_str = r'abc'
result = re.fullmatch(re_str,'abc')
print(result)

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

re_str = r'.abc'  #匹配一个字符串,长度是4,第一个字符是任意字符,后面三位是abc
result = re.fullmatch(re_str,'1abc')
print(result)

3) \w – 匹配一个字母、数字、或者下划线（ASCII表中），还可以匹配一个非ASCII表字符

re_str = r'.\w'
result = re.fullmatch(re_str,'哈.')
print(result)

4）\s – 匹配一个空白字符:包括空格、回车、制表符

re_str = r'金额:\s\s商品:'
result = re.fullmatch(re_str,'金额:  商品:')
print(result)

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

re_str = r'年龄:\d\d'  #匹配一个字符串,长度是5,前面固定为 '年龄:'  后面是两位任意数字
result = re.fullmatch(re_str,'年龄:24')
print(result)

5) \b – 检测单词边界(检测\b所在的位置是否是单词边界)

单词边界:所有能够标志一个单词结束的符号都是单词边界;例如:空格、换行、标点符号、字符串开头、字符串结尾等

re_str = r'\bhow\b are\b'  #匹配一个字符串是否是'howare',并且要求w的后面(a的前面)是一个单词边界
result = re.fullmatch(re_str,'how are')
print(result)

查找替换

re_str = r'\bhow\b'
result = re.search(re_str,'mmhowo are how')
print(result)

7） ^ - 检测是否是字符串开头

re_str = r'^\d\d'  #匹配两个数字字符的字符串,并且检测这个字符串是否是字符串开头
result = re.fullmatch(re_str,'24')
print(result)

result = re.findall(re_str,'12wwddd22e32')   #查找
print(result)

8) $ - 检测是否是字符串结尾

result = re.findall(r'...$','非法违法12fff')
print(result)

9)\大写字母 - \小写字母功能的否定

    # \W   --匹配非数字、字母、下划线
    # \S   --匹配非空白字符
    # \D   --匹配非数字字符
    # \B   --检测是否是非单词边界
re_str = '\W\S\B\D'
result = re.fullmatch(re_str,'=qq')
print(result)

10) [字符集] – 匹配一个[]中的任意一个字符

[普通字符集] – 匹配[]中任意一个字符
[字符1-字符2] – 匹配编码值在字符1编码到字符2编码之前的编码对应的任意字符,边界都能取到
字符1的编码 小于 字符2的编码值
[0-9] 相当于\d
[a-zA-Z] 所有字母
[a-zA-Z0-9_] 数字字母下划线,相当于/w
[1-9] 数字字符1-9中的一个
[]
[]内容中的最前面加 ^ 表示否定 (只有放在[]里面的最前面才有意义,放在其他位置就表示普通字符^)
[^abc] 匹配除了’a’‘b’'c’以外任意一个字符
[^a-z] 匹配除了小写字母外的任意一个字符

匹配一个字符串,长度是4,后三位是’123’,第一位是’a’ ‘b’ 'c’中的任意一个

re_str = r'[abc]123'
result = re.fullmatch(re_str,'a123')
print(result)

# 第一个字符是'a' 'b' 或任意数字
re_str = r'[ab\d]123'
result = re.fullmatch(re_str,'0123')
print(result)

# 第一个字符不是小写字母
re_str = r'[^a-z]123'
result = re.fullmatch(re_str,'Z123')
print(result)

• 11. 转义符号 – 将正则中有特殊意义或特殊功能的符号,表示符号本身(特殊意义或功能消失)
• – 在特殊意义的符号前加’’,让其表示自己
  ######- 注意:单独有特殊意义的符号,在[]里面除了’-‘在两个字符间和’^'在最前面外, 其他的都不需要转义,特殊意义自动消失

re_str = r'\d\.\d'
result = re.fullmatch(re_str,'1.3')
print(result)

写一个正则,匹配一个金额,金额要求小数点后面保留两位小数

re_str = r'[1-9]\d+\.\d\d'
result = re.fullmatch(re_str,'220.22')
print(result)

import re
1.匹配次数==

1. • – 匹配0次或多次(*前符号)

r'a*bc'  -- 匹配一个字符串, 'bc'前有0个或多个'a'例如:'bc','aaaabc'
r'\d*'   -- 匹配一个字符串,由0个或多个数字字符组成,例如: '','12345'
r'[abc\d]*-'   -- 例如:'-','ab-','aaa111-'
'''
re_str = r'a\d*b'
result = re.fullmatch(re_str,'a12306b')   #'ab'之间0个或多个数字
print(result)

#练习:写一个正则表达式,能够匹配所有的小数
re_str = r'\d*\d\.\d*\d'
result = re.fullmatch(re_str,'2.0')
print(result)

• 2. • –匹配一次或多次

r'\d+'   -- 数字出现一次或多次
r'[abc]+'  -- abc中任意字符出现一次或多次,例如:'ab','c','abcabcba'
r'a+|b+|c+'  -- 出现多个abc   例如'aaa', 'bbbbb','cccccc'
'''
re_str = r'a\d+b'
result = re.fullmatch(re_str,'a12306b')   #'ab'之间1个或多个数字
print(result)

• 3. {} – 匹配n次,括号内次数

{N}    -- 匹配N次,{2} 匹配2次
{M,N}  -- 匹配M~N次
{M,}   -- 匹配至少M次
{,N}   -- 匹配最多N次(0次也可以)
?      -- 匹配1次或0次
'''
re_str = r'a{3}'
result = re.fullmatch(re_str,'aaa')
print(result)

• 2.=贪婪和非贪婪==
• 4)贪婪和非贪婪
• 以上是贪婪匹配:匹配次数不确定的时候,尽可能多的匹配
• 非贪婪: 在匹配次数不确定的符号后加 ? – 尽可能少的匹配

*?
+?
{M,N}?
{M,}
{,N}
'''
re_str = r'a{3,}?'
result = re.fullmatch(re_str,'aaaaaaaa')
print(result)
result = re.search(re_str,'aaaaaaa')
print(result)           #match='aaa'

• 3.=分之/选择=

正则1|正则2 – 先匹配正则1,如果匹配不成功,再匹配正则2（或）

#要求用户名全部都是数字或者全部都是字母,长度6-12
re_str = r'\d{6,12}|[a-zA-Z]{6,12}'
result = re.fullmatch(re_str,'12345678')
print(result)
result = re.fullmatch(re_str,'asdfghj')
print(result)

• 4.分组:()====

a.将小括号中的内容作为一个整体操作

b. \数字   -- 重复第几个分组的匹配结果
'''
re_str = r'100(a|b|c)'
result = re.fullmatch(re_str,'100b')
print(result)

re_str = r'(\d{3})([a-z]{3})-\1\2{2}'
result = re.fullmatch(re_str,'100aaa-100aaaaaa')
print(result)

import re

• 1.完全匹配 – 让字符串的长度和字符串每个字符的值,和正则表达式完全匹配
• re.fullmatch(正则表达式,字符串) – 匹配成功返回匹配对象,匹配失败返回None
• 应用:当需要对整个字符串进行条件判断的时候:例如:检查账号/密码是否符合要求等

result = re.fullmatch(r'(\d{3})=([a-z]{3})','123=abc')
print(result)   # <_sre.SRE_Match object; span=(0, 7), match='123=abc'>

• 1. 匹配到的内容在原字符串的位置
     print(result.span()) #获取整个正则表达式匹配结果的范围 (0, 7) 开始下标,结束下标

print(result.span(1)) #获取正则表达式第一个分组匹配结果的范围 (0, 3)
print(result.start(1),result.end(1))

• 2)获取匹配到的值

print(result.group()) ##获取整个正则表达式匹配的结果 ‘123=abc’
print(result.group(1)) ##获取正则表达式第一个分组匹配结果

• 3)获取原字符串
  print(result.string) #‘123=abc’

• 2.匹配字符串开头

• re.match(正则表达式,字符串) – 判断字符串的开头是否和正则表达式相匹配,匹配成功返回匹配对象,失败返回None

• 只检测字符串开头是否满足要求

• 3.搜索search

• re.search(正则表达式,字符串) – 在字符串中查找是否有和正则表达式匹配的子串,如果没有返回None,如果有返回第一个匹配结果

result = re.search(r'(\d{3})=([a-z]{3})','how 123=abcm321=cba')
print(result)  #<_sre.SRE_Match object; span=(4, 11), match='123=abc'>

• 4.查找 findall
• re.findall(正则表达式,字符串) – 在字符串中查找和正则表达式匹配的子串,以列表返回;如果没有,则返回空的列表

result = re.findall(r'(\d{3})=[a-z]{3}','how 123=abcm321=cba')
print(result)   #['123', '321']

######- 注意:正则表达式中有没有分组的情况:
- 没有分组   --  整个正则表达式匹配到的结果作为列表元素(列表元素为字符串)
result = re.findall(r'\d{3}=[a-z]{3}','how 123=abcm321=cba')
print(result)   #['123=abc', '321=cba']
# 有一个分组  -- 将这个分组匹配到的结果作为列表元素返回(列表元素为字符串)
result = re.findall(r'(\d{3})=[a-z]{3}','how 123=abcm321=cba')
print(result)   #['123', '321']
# 有多个分组  --  将元祖作为列表元素返回,每个分组匹配到的结果作为元祖的元素(不建议使用)
result = re.findall(r'(\d{3})=([a-z]{3})','how 123=abcm321=cba')
print(result)  #[('123', 'abc'), ('321', 'cba')]

• 5.finditer
• re.finditer(正则表达式,字符串) --在字符串中获取和正则表达式匹配的子串,以迭代器形式返回(迭代器中元素是匹配结果)

result = re.finditer(r'(\d{3})=([a-z]{3})','how 123=abcm321=cba')
print(result)
for item in result:
    print(item.group(),item)

#练习:计算一个字符串中所有数字的和  例如
re_str = r'(\d+\.\d+)|(\d+)'   #存在匹配顺序
str = 're 89he ks90.2 ans78oo1.23h!w9end9009ooo'
result = re.finditer(re_str,str)

sum1 = 0
for item in result:
    sum1 += float(item.group())
print(sum1)

• 6.分割split
• re.split(正则表达式,字符串) – 将字符串按照匹配正则表达式的子串进行切割

result=re.split(r'[=/-]','aaa=bbb-ccc/ddd')
print(result)  #['aaa', 'bbb', 'ccc', 'ddd']
result=re.split(r'=|/|-','aaa=bbb-ccc/ddd')
print(result)  #['aaa', 'bbb', 'ccc', 'ddd']

• 7.sub
• re.sub(正则表达式,新替换字符串,原字符串,替换次数-可以不赋值表示全部) – 将原字符串中满足正则表达式的子串,替换成新字符串

result = re.sub(r'\d','=','dwqfw112fdsfsd')
print(result)   #dwqfw===fdsfsd
result = re.sub(r'\d','=','dwqfw112fdsfsd',2)
print(result)   #dwqfw==2fdsfsd