1.正则表达式就是做字符串匹配一种工具，很多语言都支持正则语法。正则语法是通用的。

python中通过re模块中提供的方式来使用正则

re.fullmatch(正则表达式, 字符串) - 完全匹配，检测字符串是否满足正则表达式的要求；如果不匹配结果是None, 匹配结果是一个匹配对象

python正则表达式 - r'正则'
js正则表达式 - /正则/

1 普通字符

普通字符在正则中代表字符本身， 例如, a, b, 1...等

要求一个字符串有5个字符，分别是h,e,l,l,o

re_str = r'hello'
a = re.fullmatch(re_str, 'hello')
b = re.fullmatch(re_str, 'helllo')
print(a,'\n',b)

<_sre.SRE_Match object; span=(0, 5), match='hello'>
None

2 .(匹配任意字符)

一个.匹配一个任意字符

匹配一个字符串有三个字符，第一个字符是a，最后一个字符是c, 第二个字符是任意字符

re_str = r'a.c'
result = re.fullmatch(re_str, 'a+c')
print(result)

<_sre.SRE_Match object; span=(0, 3), match='a+c'>

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

一个\w只能匹配一个字符
注意: 在英文环境中只匹配ASCII码表的字符，在中文环境中还可以匹配中文

匹配一个字符串第一个字符是字母、数字或者下划线，后面是'abc'

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

<_sre.SRE_Match object; span=(0, 4), match='你abc'>

4 \s(匹配空白字符)

空白字符：空格、\t、\n
一个\s只能匹配一个空字符

匹配一个长度是8的字符，要求前三个字符是任意字符，中间两个空白字符，后面再三个任意字符

re_str = r'...\s\s...'
result = re.fullmatch(re_str, 'abc  abc')
print(result)
result = re.fullmatch(re_str, '++-\n\t-++')
print(result)
result = re.fullmatch(re_str, '+  \t\t-++')
print(result)

<_sre.SRE_Match object; span=(0, 8), match='abc abc'>
<_sre.SRE_Match object; span=(0, 8), match='++-\n\t-++'>
<_sre.SRE_Match object; span=(0, 8), match='+ \t\t-++'>

5 \d(匹配数字字符)

re_str = r'\d\dabc'
result = re.fullmatch(re_str, '90abc')
print(result)

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

7 \S(匹配非空白字符)

匹配一个长度是4的字符，后面三个字符是'abc',第一个字符可以是任何一个非空白字符

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

<_sre.SRE_Match object; span=(0, 4), match='+abc'>

8 \D(匹配非数字字符)

re_str = r'\Dabc'
print(re.fullmatch(re_str, '9abc'))

None

9 '[]'(匹配字符集中的一个字符)

a. [普通字符集] - 匹配字符集中的任意一个字符
b. [字符1-字符2] - 匹配字符1到字符2中的任意一个字符(要求字符1的编码值小于字符2)
[0-9] - 匹配所有的数字
[a-z] - 匹配小写字母
[A-Z] - 匹配大写字母
[a-zA-Z] - 匹配所有的字母
[\da-zA-Z_] - 匹配字母数字下划线
[\u4e00-\u9fa5] - 匹配所有的中文
##注意: 一个[]只能匹配一个字符

匹配一个长度是4的字符串，第一个字符是x或者y或者z, 后面是abc

re_str = r'[xyz]abc'
print(re.fullmatch(re_str, 'zabc'))

<_sre.SRE_Match object; span=(0, 4), match='zabc'>

匹配一个长度是4的字符串, 第一个字符是数字或者x,y,z

re_str = r'[\dxyz]abc'
print(re.fullmatch(re_str, '3abc'))

匹配一个长度是4的字符串, 第一个字符是数字字符2-8中的一个

re_str = r'[2-8]abc'
print(re.fullmatch(re_str, '4abc'))

匹配一个长度是4的字符串, 第一个字符是数字字符2-8中的一个或者是x,y,z

re_str = r'[2-8xyz]abc'
print(re.fullmatch(re_str, 'zabc'))

匹配一个长度是4的字符串, 第一个字符是中文字符

re_str = r'[\u4e00-\u9fa5]abc'
print(re.fullmatch(re_str, '胡abc'))
# re_str = r'[9-1]abc'
# print(re.fullmatch(re_str, '8abc'))   # 报错！

10 [^]

[^字符集] - 匹配不在字符集中任意一个字符
[^\u4e00-\u9fa5] - 匹配一个非中文字符

匹配一个长度是4的字符串, 第一个字符不是x,y,z

re_str = r'[^xyz]abc'
print(re.fullmatch(re_str, 'zabc'))

匹配一个长度是4的字符串, 第一个字符不是中文字符

re_str = r'[^\u4e00-\u9fa5]abc'
print(re.fullmatch(re_str, '是abc'))

1 \b(检测单词边界)

\b - 检查\b所在的位置是否是单词边界
单词边界 - 字符串开头、字符串结尾、空白、标点符号等
how are you,i am

匹配一个长度是4的字符串，第一个字符是任意字符，后边是abc; 检测c的后面是否是单词边界

re_str = r'.abc\b'
print(re.fullmatch(re_str, '8abc'))

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

2 ^(检测是否是字符串开头)

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

print(re.search(r'^\d\d', 'has89kjkssss'))

3 $(检测是否是字符串结尾)

re_str = r'abc$'
print(re.fullmatch(re_str, 'abc'))
print(re.search(r'\d\d$', 'has89kjkssss77'))

1.转义符号：在有特殊功能、意义的符号前加'',让这个正则符号变成普通符号

注意: 除了^放在[]开头，和-放在两个字符之间以外， 其他单独的特殊符号，在[]没有特殊功能都是表示字符本身

re_str = r'\d\d\.\d\d'
print(re.fullmatch(re_str, '89=78'))

re_str = r'\^\d\d\d'
print(re.fullmatch(re_str, '^789'))

re_str = r'\d\d[.]\d\d'
print(re.fullmatch(re_str, '23=45'))

# ^在[]中不是在开头就没有特殊意义
re_str = r'\d\d[a^]\d\d'
print(re.fullmatch(re_str, '23=45'))

# -在[]中只要不是放在两个字符之间都表示-本身s
re_str = r'\d\d[-a]\d\d'
print(re.fullmatch(re_str, '23-45'))


re_str = r'\d\d[1\-ka\]]\d\d'
print(re.fullmatch(re_str, '23-45'))

4.匹配次数

1 *(匹配0次或多次)

字符* - 指定的字符出现0次或者多次
a* - 字符a匹配0次或者多次
\d* - 数字匹配0次或者多次
[a-z]* - 小写字母匹配0次或者多次

re_str = r'a*bc'
print(re.fullmatch(re_str, 'bc'))
print(re.fullmatch(re_str, 'abc'))
print(re.fullmatch(re_str, 'aaabc'))

2. +(匹配1次或者多次)

匹配一个字符串开头是a,结束是b,中间至少一个数字

re_str = r'a\d+b'
re_str = r'a\d\d*b'
print(re.fullmatch(re_str, 'a89b'))

3. ?(0次或1次)

练习：写一个正则表达式，能够匹配一个整数字符串

283、-834、+823、9、-23

re_str = r'[-+]?\d+'
print(re.fullmatch(re_str, '-7890283024'))

4. {}

{N} - 匹配N次
{M,N} - 匹配至少M次，最多N次
{M,} - 匹配至少M次
{,N} - 匹配最多N次

• == {0,}

• == {1,}
  ? == {0,1}

re_str = r'\d{4}'
print(re.fullmatch(re_str, '8273'))

re_str = r'\d{2,4}'
print(re.fullmatch(re_str, '889'))

re_str = r'[xyz]{,3}'
print(re.fullmatch(re_str, 'xy'))

练习: 写一个正则表达式判断密码是否符号要求：密码由数字和字母组成，并第一个字符是大写字母，长度是6-12位

re_str = r'[A-Z][a-zA-Z\d]{5,11}'

5.非贪婪

1)贪婪 - 匹配次数不确定的时候尽可能多的匹配 （上面次数不确定的符号都是贪婪的）
2)非贪婪 - 匹配次数不确定的时候尽可能少的匹配 (上面次数不确定的符号后面加?就会变成非贪婪)
*? - 0次或多次, 尽可能少
+? - 1次或多次, 尽可能少
?? - 0次或1次, 尽可能少
{N,M}?
{M,}?
{,N}?

re_str = r'a+'
print(re.search(re_str, 'baaaac'))

re_str = r'a+?'
print(re.search(re_str, 'baaaac'))

re_str = r'a.*b'
print(re.search(re_str, 'a12bmnb===='))     # match='a12bmnb'

re_str = r'a.*?b'
print(re.search(re_str, 'a12bmnb===='))    # match='a12b'

5.分之和分组

1 |(分之)

正则1|正则2 - 先用正则1进行匹配，如果匹配失败再用正则2匹配（正则1和正则2中只要有一个匹配成功就成功，两个失败了才失败）
注意: 如果正则1匹配成功了，不会再使用正则2去匹配

匹配一个字符串，是abc或者xyz

'abc', 'xyz'

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

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

re_str = r'x{3}|y{3}123'
print(re.fullmatch(re_str, 'yyy123'))

2.()-分组

将部分正则作为一个整体
1.整体区分
re_str = r'(xxx|yyy)[A-Z]{2}[a-z]{2}\d{2}'
2.整体操作
re_str = r'(\d{2}[a-zA-Z]{2}){3}'
3.整体重复
\M - 重复前面第M个分组匹配到的内容

# re_str = r'xxx[A-Z]{2}[a-z]{2}\d{2}|yyy[A-Z]{2}[a-z]{2}\d{2}'
re_str = r'(xxx|yyy)[A-Z]{2}[a-z]{2}\d{2}'
print(re.fullmatch(re_str, 'yyyASjk23'))

# '88js82ll67hj'
# re_str = r'\d{2}[a-zA-Z]{2}\d{2}[a-zA-Z]{2}\d{2}[a-zA-Z]{2}'
re_str = r'(\d{2}[a-zA-Z]{2}){3}'
print(re.fullmatch(re_str, '88js82ll67hj'))

# 89abc89, 11abc11
re_str = r'(\d\d)abc\1'
print(re.fullmatch(re_str, '90abc90'))

re_str = r'(\d{3})([a-z]{2})\2\1\2'
print(re.fullmatch(re_str, '234bnbn234bn'))