一、匹配字符

1.什么是正则表达式（语法通用）
定义：一种用来做字符串匹配的工具，通过不同的符号匹配不同的字符

2.python对正则表达式的支持
re模块

re模块方法：
fullmatch(正则表达式，字符串）
功能：正则表达式和指定字符串进行匹配
输出：成功返回匹配对象，失败返回None

注意：python中的正则表达式是写在字符串中的，但是一般情况下不会在最前面加R/r

from re import fullmatch, search

普通字符（代表字符本身）

#匹配一个字符串，只有三个字符，每个字符分别是a,b,c
re_str = r'abc'
result = fullmatch(re_str, 'abc')
print(result)

1 .(匹配任意字符）

注意：
a.一个.代表一个字符
b.不能匹配\n

# 匹配一个字符串，只有三个字符，第一个字符是a,第二个字符是任意字符，第三个字符是c
re_str = r'a.c'
result = fullmatch(re_str, 'acc')
print(result)

2 \w(匹配字母数字下划线)

注意：
a.也可以匹配中文
b.一个\w只能匹配一个字符

# 匹配一个字符串，第一个是任意字符，第二三是字母数字下划线，最后三个是abc
re_str = r'.\w\wabc'
result = fullmatch(re_str, 'd33abc')
print(result)

3 \s(匹配空白字符）

空白字符：所有能产生空白的字符，包括空格，制表符，换行等

# 匹配一个字符串，前面两个是字母数字下划线或中文，第三个是空白，最后是任意字符
re_str = r'\w\w\s.'
result = fullmatch(re_str, 'a2\td')
print(result)

4 \d(匹配数字字符)

# 匹配一个字符串，每个字符都是数字字符
re_str = r'\d\d\d'
result = fullmatch(re_str, '343')
print(result)

5 \b(检测单词边界)

a.检测正则表达式中\b所在的位置，是否是单词边界
b.单词边界：所有可以将两个单词区分开的符号都是单词边界，
例如：空格, 缩进，标点符号等
注意：
\b检测时不看，先匹配，匹配好在加上看
\b不是匹配符号，不会匹配出一个字符，只是检测所在的位置是否满足要求。

# 匹配一个字符串的内容是'how are',并且字符'a'的前面是单词边界
re_str = r'how \bare'
result = fullmatch(re_str, 'how are')
print(result)

6 ^(检测是否以指定的字符串开头)

# 匹配一个字符串是三个数字字符，并且第一个字符所在的位置是字符串开头
re_str = r'^\d\d\d'
result = search(re_str, '333dfd333dffeee444d')
print(result)

7 $ (检测是否以指定的字符串结尾）

# 匹配一个字符串是三个数字字符，并且最后一个字符的后面是字符串结尾
re_str = r'\d\d\d$'
result = search(re_str, '333fdf33332')
print(result)

8 \B(检测非单词边界）

re_str = r'dff\B33'
result = fullmatch(re_str, 'dff33')
print(result)

9 \W(匹配非数字字母下划线)

10 \S(非空白字符）

11 \D(匹配非数字字符）

12 [字符集]（匹配字符集中的任意一个字符）

注意：一个[]代表一个字符
a.普通用法
[字符集] - 匹配字符集中的任意一个字符
b.表示范围
[字符1-字符2] - 表示匹配字符1到字符2中所有的字符，要求字符1的编码值要小于字符2的编码值
[1-9] - 数字1-9
[A-Z] - 大写字母
[a-z] - 小写字母
[a-zA-Z] - 所有字母
[a-zA-Z\d_] - 数字字母下划线

# 匹配一个字符串有4个字符，第一个是a或者b或者c.后边是123
re_str = r'[abc]123'
result = fullmatch(re_str, 'b123')
print(result)

# 匹配一个字符串有4个字符，第一个是数字1-9中的任意一个，最后一个
# 是任意小写字母，中间两个是任意数字
re_str = r'[1-9]\d\d[a-z]'
result = fullmatch(re_str, '323d')
print(result)

re_str = r'[a-zA-Z\d_]'
result = fullmatch(re_str, 'a')
print(result)

13 [^字符集]（匹配没有在字符集中的其他任意字符）

注意：
^放在[]的最前面，才表示匹配不在字符集中的其他任意字符
^不放在[]最前面，就表示字符本身

# 匹配一个字符串，第一个字符只要不是abc中的一个，其他都可以，后面是123
re_str = r'[^abc]123'
result = fullmatch(re_str, 'h123')
print(result)

# 第一个字符是1-9中的一个或者^
re_str = r'[1-9^]123'
result = fullmatch(re_str, '^123')
print(result)

14 转义符号

正则中可以通过在特殊符号前加\来对符号进行转义
\\
\.
\^
b.除了在中括号中有特殊意义的符号，其他符号放在[]中也是表示符号本身
- 想要表示本身，就不要放在两个字符之间
^ 想要表示本身，就不要放在字符集开头
[] 表示中括号本身，加\
注意：
转义字符是字符串中的概念
转义符号是正则表达式的概念

re_str = r'\d\d\.\d\d\\b'
print(fullmatch(re_str, '34.23\\b'))
print(fullmatch(r'[-19.\]*^]', '*'))

二、匹配次数

1 *(匹配0次或多次）

字符* - 指定的字符出现0次或者多次（字符可以是正则符号，也可以是普通字符）
a* - a出现0次或者多次
\d* - 任意数字出现0次或者多次
[a-z]* - 任意小写字母出现0次或者多次

# 123前有0个或者多个字符，并且每个是a
re_str = r'[a-z]*123'
print(re.fullmatch(re_str, '123'))
print(re.fullmatch(re_str, 'a123'))

# 123前有0个或者多个字符，并且每个是数字字符
re_str = r'\d*123'
print(re.fullmatch(re_str, '123'))
print(re.fullmatch(re_str, '1123'))

2 +(一次或者多次）

re_str = r'[a-z]+123'
print(re.fullmatch(re_str, 'aaa123'))
print(re.fullmatch(re_str, 'a123'))

3 ?(0次或1次）

re_str = r'\+?abc'
print(re.fullmatch(re_str, 'abc'))
print(re.fullmatch(re_str, '+abc'))

# 练习：写一个正则表达式能够匹配所有的整数字符串
re_str = r'[+-]?[1-9]\d*|0'
print(re.fullmatch(re_str, '0'))

4 {}(匹配次数）

• {m,n} - 匹配m到n次（最少m次，最多n次）
• {m,} - 至少m次
• {，n} - 最多n次
• {n} - n次

print(re.fullmatch(r'a{2,5}', 'aaa'))
# 密码：6-16，只能是数字字母
print(re.fullmatch(r'[a-zA-Z\d]{6,16}', '222222'))

三、分支和分组

1 |(分支）

表达式1|表达式2|表达式3
先用表达式1进行匹配，匹配成功就成功，不成功就使用表达式2区匹配，如果表达式2
也不成功，就使用表达式3去匹配（三个表达式只要有一个能够匹配成功就成功，否则就失败）

import re

re_str = r'[a-z]{3}|\d{3}'
print(re.fullmatch(re_str, '384'))

2 （）（分组）

a.分组
将括号里的内容看做一个整体

b.分组重复
在有分组的正则表达式中，可以在分组的后面通过 \数字 来重复前面第几
个分组匹配到的结果
注意：如果前面没有括号，程序会报错

re_str = r'abc([a-z]{3}|\d{3})'
print(re.fullmatch(re_str, 'abc384'))

re_str = r'(abc){2}'
print(re.fullmatch(re_str, 'abcabc'))

re_str = r'(\d{2})a(\d{3})bc\2'
print(re.fullmatch(re_str, '34a909bc909'))

c.捕获
步骤：
第一步：先用整个正则表达式去匹配字符串，匹配成功
第二步：再获取部分数据（括号里的数据）

re_str = r'(\d\d)\.[a-z]{2,3}'
result = re.findall(re_str, 's56fjh22.huk--=334.ko";sss;ss94.al////')
print(result)  # ['22', '34', '94']

四、非贪婪

定义：在正则中控制匹配不确定次数的符号后边可以加?,来表示尽可能少的匹配
注意：尽可能少是在能够匹配到的前提下尽可能少
贪婪：尽可能匹配多的次数

print(re.search(r'\d+', 'abchs3482==sdd'))  # <_sre.SRE_Match object; span=(5, 9), match='3482'>
print(re.search(r'\d+?', 'abchs3482==sdd'))  # <_sre.SRE_Match object; span=(5, 6), match='3'>