一、正则表达式
1.什么是正则表达式
正则就是一个用来做字符串匹配的工具，通过不同的符号匹配不同的字符。
2.python 对正则表达式的支持
通过 re 模块，通过相应支持的正则表达式的方法
fullmatth（正则表达式， 字符串） -----用正则表达式来和指定字符串进行匹配，
如果匹配成功，就返回匹配对象；
如果匹配失败，就返回 None 。
python 中的正则表达式是写在字符串中间的，但是一般情况下，会在最前面加 r/R
例如:
from re import fullmatch
def main():
# 0.普通字符（代表字符本身）
re_str = r'adc'
result = fullmatch(re_str, 'adc')
print(result)
# 1. . 匹配任意字符
# 匹配一个字符串,只有三个字符,第一个字符是 a ,第二个字符是任意字符,第三个字符是 c
re_str = r'a.c' # 注意:一个点代表一个字符; 不能匹配 \n
result = fullmatch(re_str, 'a&c')
print(result)
# 2.\w(匹配字母,数字,下划线)
# 注意:也可以匹配中文(ASCLL表以外的字符);一个 \w 只能匹配一个字符
# 匹配一个字符串,第一,二个字符是字母,数字,下划线或中文;第三个字符是任意字符,第五,六,七为字符'adc'
re_str = r'\w\w..adc'
result = fullmatch(re_str, '阿勒34adc')
print(result)
# 3.\s(匹配空白字符)
# 所有能产生空白的字符,包括空格,制表符,换行
# 匹配一个字符串,前两个字符是字母,数字,下划线或中文;第三个字符是空白;第五,六,七为字符'adc'
re_str = r'\w\w\s\sadc'
result = fullmatch(re_str, '啊嘞\t adc')
print(result)
# 4.\d(匹配数字字符)
# 匹配一个字符串,前三个字符是数字字符,后两个字符为任意字符
re_str = r'\d\d\d..'
result = fullmatch(re_str, '123%^')
print(result)
# 5.\b(检查单词边界)
# a.检查正则表达式中 \b 所在的位置是否是单词边界
# b.单词边界:所有的可以将两个单词区分开的符号都是单词边界,例如;空格、缩进、标点符号(单词开头或者结尾)等
# c.\b 不是匹配符号,就不会匹配出一个字符,只是检测所在的位置是否满足要求
# 匹配一个字符串的内容是 'and are' 并且要求字符 'a' 的前面是单词边界
re_str = r'and\b adc'
result = fullmatch(re_str, 'and adc')
print(result)
# 6.^(检查字符串开头)
# 匹配一个字符串是三个数字字符,并且字符所在位置是字符串开头
re_str = r'^\d\d\d'
result = fullmatch(re_str, '123')
print(result)
# 7.$(检查字符串结尾)
# 匹配一个字符串是三个数字字符,并且字符所在位置是字符串结尾
re_str = r'\d\d\d$'
result = fullmatch(re_str, '123')
print(result)
# 8.\B(检查非单词边界)
# 匹配一个字符串是四个数字字符,并且字符所在位置是字符串结尾
re_str = r'\d\d\d\B.'
result = fullmatch(re_str, '1234')
print(result)
# 9.\W(匹配非数字,字母,下划线,中文)
# 10.\S(匹配非空白字符)
# 11.\D(匹配非数字字符)
# 12.[字符集](匹配字符集中的任意一个字符)
# 注意:一个[]代表一个字符
# a.普通用法:
# [字符集] -----匹配字符集中的任意一个字符
# 匹配一个字符串,第一个字符是 adc 中的其中一个,后面的字符是 123
re_str = r'[adc]123'
result = fullmatch(re_str, 'a123')
print(result)
# b.表示范围
# [字符1 - 字符2] -----匹配 字符1 到 字符2 中所有的字符(要求 字符1 的编码值要小于 字符2 的编码值)
# [1-9] -----数字 1 到 9
# [a-z] -----小写字母
# [A-Z] -----大写字母
# [a-zA-Z] -----所有字母
# [\da-zA-Z_] -----数字,字母,下划线
# 匹配一个字符串,第一个字符是数字 0 到 9 的其中一个,中间两个是任意数字,最后的字符是 a 到 z 的其中一个
re_str = r'[0-9]\d\d[a-z]'
result = fullmatch(re_str, '123a')
print(result)
# 13.[^字符集](匹配没在字符集中的其它任意字符)
# 注意: ^ 放在[]的最前面才表示匹配不在字符集中的其它任意字符, ^ 不放在[]的最前面就不是字符本身
# 匹配一个字符串,第一个字符只要不是 adc 中的任意一个,其它都行,后面是 123
re_str = r'[^adc]123'
result = fullmatch(re_str, 'b123')
print(result)
# 匹配一个字符串,第一个字符只要不是 1 到 9 中的任意一个,其它都行,后面是 123
re_str = r'[^adc]123'
result = fullmatch(re_str, 'b123')
print(result)
# 匹配一个字符串,第一个字符是 1 到 9 和 ^ 中的任意一个,后面是 123
re_str = r'[adc^]123'
result = fullmatch(re_str, '^123')
print(result)
# 14.转义符号
# a.正则中也可以在特殊符号前,加 '\' 来对符号进行转义
# b.除了在[]有特殊意义的符号,其它符号放在[]中也是不是符号本身
# - 在[]中的两个字符之间表示谁到谁,如果要表示它本身,就不要放在两个字符之间(放在两端)
# ^ 在[]中最前面有特殊意义,如果要表示它本身,就不要放在最前面
# ] 在[]中表示,如果要表示它本身,就在前面加 \
# 注意:转义字符是字符串中的概念;转义符号是正则表达式里的概念
# 匹配一个字符串,第一,二个字符
re_str = r'^\d\d\.\s\s'
result = fullmatch(re_str, '12. \t')
print(result)
print(fullmatch(r'[.]', 'k'))
pass
if __name__ == '__main__':
main()
运行结果:
<_sre.SRE_Match object; span=(0, 3), match='adc'>
<_sre.SRE_Match object; span=(0, 3), match='a&c'>
<_sre.SRE_Match object; span=(0, 7), match='阿勒34adc'>
<_sre.SRE_Match object; span=(0, 7), match='啊嘞\t adc'>
<_sre.SRE_Match object; span=(0, 5), match='123%^'>
<_sre.SRE_Match object; span=(0, 7), match='and adc'>
<_sre.SRE_Match object; span=(0, 3), match='123'>
<_sre.SRE_Match object; span=(0, 3), match='123'>
<_sre.SRE_Match object; span=(0, 4), match='1234'>
<_sre.SRE_Match object; span=(0, 4), match='a123'>
<_sre.SRE_Match object; span=(0, 4), match='123a'>
<_sre.SRE_Match object; span=(0, 4), match='b123'>
<_sre.SRE_Match object; span=(0, 4), match='b123'>
<_sre.SRE_Match object; span=(0, 4), match='^123'>
<_sre.SRE_Match object; span=(0, 5), match='12. \t'>
None
二、匹配次数
1. * (匹配 0 或 n 次)
字符* -----指定的字符出现 0 次或多次(这里的字符可以是正则符号也可以是普通字符)
a* -----a 出现0 次或多次
\d* -----任意数字 出现0 次或多次
[a-z]* -----任意小写字母出现0 次或多次
在 123 之前有 0 个或多个 a
2.+(匹配 1 次或多次)
3.?(匹配 0 次或 1 次)
4.{}
{M, N} -----匹配 M 到 N 次(最大 M 次,最大 N 次)
{M,} -----匹配最少 M 次
{, N} -----匹配最多 N 次
{N} -----匹配 N 次
例如:
from re import fullmatch
def main():
# 1. *(匹配 0 或 n 次)
# 字符* -----指定的字符出现 0 次或多次(这里的字符可以是正则符号也可以是普通字符)
# a* -----a 出现0 次或多次
# \d* -----任意数字 出现0 次或多次
# [a-z]* -----任意小写字母出现0 次或多次
# 在 123 之前有 0 个或多个 a
re_str = r'a*123'
print(fullmatch(re_str, 'aaaaaaaaaaa123'))
print(fullmatch(re_str, '123'))
# 在 123 之前有 0 个或多个任意小写字母
re_str = r'[a-z]*123'
print(fullmatch(re_str, 'adchhh123'))
print(fullmatch(re_str, '123'))
# 2.+(匹配 1 次或多次)
re_str = r'a+123'
print(fullmatch(re_str, 'aaaaaaaaaaa123'))
print(fullmatch(re_str, 'a123'))
# 3.?(匹配 0 次或 1 次)
re_str = r'a\+?123'
print(fullmatch(re_str, 'a+123'))
print(fullmatch(re_str, 'a123'))
# re_str = r'[+-]?[1-9]\d*]'
re_str = r'[+-]?[1-9]\d[0-9]\d*'
print(fullmatch(re_str, '-123'))
# 4.{}
# {M, N} -----匹配 M 到 N 次(最大 M 次,最大 N 次)
# {M,} -----匹配最少 M 次
# {, N} -----匹配最多 N 次
# {N} -----匹配 N 次
print(fullmatch(r'\d{6,16}', '123456'))
if __name__ == '__main__':
main()
运行结果:
<_sre.SRE_Match object; span=(0, 14), match='aaaaaaaaaaa123'>
<_sre.SRE_Match object; span=(0, 3), match='123'>
<_sre.SRE_Match object; span=(0, 9), match='adchhh123'>
<_sre.SRE_Match object; span=(0, 3), match='123'>
<_sre.SRE_Match object; span=(0, 14), match='aaaaaaaaaaa123'>
<_sre.SRE_Match object; span=(0, 4), match='a123'>
<_sre.SRE_Match object; span=(0, 5), match='a+123'>
<_sre.SRE_Match object; span=(0, 4), match='a123'>
<_sre.SRE_Match object; span=(0, 4), match='-123'>
<_sre.SRE_Match object; span=(0, 6), match='123456'>
三、分之和分组
1. | :分之
表达式1 | 表达式2 | 表达式3 -----先使用 表达式1 进行匹配,匹配成功就直接成功;
匹配不失败就用 表达式2 再匹配,以此类推;里面的表达式都失败才匹配失败
2.():分组
a.分组 -----将()里面的内容看成一个整体
(adc){2} -----adcadc
adc{2} -----adcc
b.分组重复 -----在有分组的正则表达式中可以在分组的后面通过 (数字) 来重复前面第 数字 个分组匹配到的内容
(\d{3})adc\1 -----258adc258
例如:
from re import fullmatch
def main():
re_str = r'[a-z]{5}|\d{3}'
print(fullmatch(re_str, '147'))
print(fullmatch(re_str, 'adcbe'))
re_str = r'(adc){2}'
print(fullmatch(re_str, 'adcadc'))
re_str = r'(45)a(78)dc\2\1{2}'
print(fullmatch(re_str, '45a78dc784545'))
if __name__ == '__main__':
main()
运行结果:
<_sre.SRE_Match object; span=(0, 3), match='147'>
<_sre.SRE_Match object; span=(0, 5), match='adcbe'>
<_sre.SRE_Match object; span=(0, 6), match='adcadc'>
<_sre.SRE_Match object; span=(0, 13), match='45a78dc784545'>
