正则表达式基础

最新推荐文章于 2023-05-01 17:49:17 发布

stiinput

最新推荐文章于 2023-05-01 17:49:17 发布

阅读量139

点赞数

分类专栏： Python知识集文章标签：正则表达式

本文链接：https://blog.csdn.net/Z_qin007/article/details/126572584

版权

Python知识集专栏收录该内容

20 篇文章 2 订阅

订阅专栏

文章目录

正则表达式

正则表达式

一、定义

正则表达式是使用一系列特殊符号从字符串中匹配内容。
正则表达式就是记录文本规则的代码。
正则表达式是独立于所有语言的语法，所有语言中正则表达式的语法是相同的，只是使用方式不一样。
[字符](正则表达式30分钟入门教程 (deerchao.cn))：计算机软件处理文字时最基本的单位。

二、正则表达式的方法及匹配符

注意：正则表达式不是转义字符，在写正则表达式时**，在正则表达式前面添加 r 或者 R **。

正则表达式中的核心函数支持：


compile(pattern, flags=0)	编译正则表达式返回正则表达式对象
match(pattern, string, flags=0)	用正则表达式匹配字符串，成功返回匹配对象，否则返回None
search(pattern, string, flags=0)	搜索字符串中第一次出现正则表达式的模式，成功返回匹配对象否则返回None
split(pattern, string, maxsplit=0, flags=0)	用正则表达式指定的模式分隔符拆分字符串返回列表
sub(pattern,repl, string, count=0, flags=0)	用指定的字符串替换原字符串中与正则表达式匹配的模式，可以用count指定替换的次数
fullmatch(pattern, string, flags=0)	match函数的完全匹配（从字符串开头到结尾）版本
findall(pattern, string, flags=0)	查找字符串所有与正则表达式匹配的模式，返回字符串的列表
finditer(pattern, string, flags=0)	查找字符串所有与正则表达式匹配的模式返回一个迭代器
purge()	清除隐式编译的正则表达式的缓存
re.I / re.IGNORECASE	忽略大小写匹配标记
re.M / re.MULTILINE	多行匹配标记

1.正则表达式的方法

有fullmatch、findall、split、sub、search、match等几种。
- fullmatch：查看整个字符串是否符合正则表达式。成立返回一个对象，不成立返回None。
- findall：
  - 方法一：将字符串中所有符合正则表达式的规则的结果匹配出来，如果不符合返回的永远是列表[ ]。
  - 方法二：如何正则表达式中出现分组，会先按照正则表达式匹配结果，再将符合分组中正则表达式的结果提取。
- split：按照正则表达式的规则切割字符串。
- sub：将符合正则表达式的字符串替换为新的字符串。
- search：查找字符串中第一个符合正则表达式的结果：None
- match：查看字符串的开头是否符合正则表达式的规则。None

2.正则表达式方法的用法

2.1 re.match()：查看字符串的开头是否符合正则表达式的规则，不符合返回None。

 import re
 
 str1 = 'a,b.c'
 re_str = 'a,'
 print(re.match(re_str, str1))
 # <re.Match object; span=(0, 2), match='a,'>

2.2 re.search()：查找字符串中第一个符合正则表达式的结果：不符合返回None。

 re_str = '[a-z]'
 print(re.search(re_str, str1
 # <re.Match object; span=(0, 1), match='a'>

2.3 re.split()：按照正则表达式的规则切割字符串。

 re_str = '[,.]'
 print(re.split(re_str, str1))
 # ['a', 'b', 'c']

2.4 re.sub()：将符合正则表达式的字符串替换为新的字符串。

 print(re.sub('[,.]', '', str1))
 # abc

3.常用的正则表达式总结

正则表达式的方法中常用的是：findall、split、sub
不常用的是：match、search、fullmatch

4.正则表达式的匹配类符号

匹配类符号有哪些

4.1 元字符

\b：匹配单词的开始或结束。
. ：匹配除换行符以外的任意字符。
\d：匹配0~9数字。
\D：匹配非数字。
\s：匹配任意的空白符号（空格，\n，\t、\v等）
\S：匹配非空白符号。
\w：匹配数字、字母、下划线、中文、朝鲜语中的任意一个。

4.2 元字符的用法

a) . ：匹配除换行符以外的任意字符。

import re
# fullmatch的用法：fullmatch(正则表达式， 字符串)
'''
用来判断字符串是否完全符合正则表达式的规则。
成立返回一个对象，不成立返回None。
'''
re_str = 'a.b'
str1 = 'acb'
result = re.fullmatch(re_str, str1)
print(result)
# <re.Match object; span=(0, 3), match='acb'>
# 匹配对象；匹配字符串下标；匹配字符串；

b) \d：匹配0~9数字。

re_str = 'a\d\dc'
str2 = 'a12c'
# str2 = 'abcc'
result1 = re.fullmatch(re_str, str2)
print(result1)
# <re.Match object; span=(0, 4), match='a12c'>
# None

c) \D：匹配非数字。

re_str = 'a\D\Dc'
str2 = 'abcc'
str2 = 'a12c'
result1 = re.fullmatch(re_str, str2)
print(result1)
# <re.Match object; span=(0, 4), match='abcc'>
# None

d) \s：匹配任意的空白符号（空格，\n，\t、\v)等。转义字符长度为1

re_str = 'a\sb'
str4 = 'a\nb'
result2 = re.fullmatch(re_str, str4)
print(result2)
# <re.Match object; span=(0, 3), match='a\nb'>

e) \S：匹配非空白符号。

re_str = 'a\Sb'
str4 = 'acb'
result2 = re.fullmatch(re_str, str4)
print(result2)
# <re.Match object; span=(0, 3), match='acb'>

f) \w：匹配数字、字母、下划线、中文、朝鲜语。

re_str = 'a\wb'
# str5 = 'a1b'
# str5 = 'a_b'
# str5 = 'aBb'
# str5 = 'abb'
str5 = 'a我b'
result5 = re.fullmatch(re_str,str5)
print(result5)
# <re.Match object; span=(0, 3), match='a1b'>
# <re.Match object; span=(0, 3), match='a_b'>
# <re.Match object; span=(0, 3), match='aBb'>
# <re.Match object; span=(0, 3), match='abb'>
# <re.Match object; span=(0, 3), match='a我b'>

4.3 字符类

字符集[ ]：从[ ] 的字符集中匹配一个符号。

字符集规则：
- -连接的是范围，-左边必须小于右边，-不能出现在字符集开头或结尾，不然表示-自己。

常见的字符集有：


[a - z]	表示匹配小写字母中的任意一个
[A - Z]	表示匹配大写字母中的任意一个
[0 - 9]	表示匹配0 - 9中的任意一个数字
[\u4e00 - \u9fa5]	匹配任意一个汉字
[a - zA - Z]	匹配任意一个字母
[0 - 9a - zA - Z\u4e00 - \u9fa5]	匹配数字、字母、汉字中的任意一个
[012345678 - ]	匹配0 - 8、 - 中的任意一个符号

[^ 字符集]：匹配不在字符集中的元素；这样样式字符集规则没有变，必须在字符集的最开头添加 ^ 。

4.4 字符类的用法

字符集[ ]：从[ ] 的字符集中匹配一个符号。

re_str = '[a-zA-Z][a-zA-Z]'
str5 = 'az'
result5 = re.fullmatch(re_str, str5)
print(result5)
# <re.Match object; span=(0, 2), match='az'>

[^ 字符集]：匹配不在字符集中的元素；这样样式字符集规则没有变，必须在字符集的最开头添加 ^ 。

# [a-z^A-Z] 匹配这三种类型的字符：小写字母 ^ 大写字母中的一种。
re_str = '[^a-zA-Z][a-zA-Z][a-z^A-Z]'
str6 = '1z^'
result6 = re.fullmatch(re_str,str6)
print(result6)
# <re.Match object; span=(0, 3), match='1z^'>

4.5 重复

?：匹配 0次或1次 (重复0次或1次)。
+：匹配一次或多次(重复一次或更多次)。
*：匹配任意次数(重复0次或更多次)。
{M, N} 的变式匹配：
{M}：匹配M次。
{N}：匹配N次。
{M, N}：最少匹配M次，最多匹配N次。
{M, }：最少匹配M次。
{, N}：最多匹配N次，最少匹配0次。

4.6 重复字符的用法

?：匹配 0次或1次 (重复0次或1次)。

import re

re_str = 'a\d?'
str1 = 'a1'
result1 = re.fullmatch(re_str, str1)
print(result1)
# <re.Match object; span=(0, 2), match='a1'>

+：匹配一次或多次(重复一次或更多次)。

import re

str1 = 'a1b3d45f6j7'
# 从这个字符串中将所有的数字匹配出来(连起来的数字多次匹配)
re_str = '[0-9]+'
# re_str = '\d+'
print(re.findall(re_str, str1))
# ['1', '3', '45', '6', '7']

*：匹配任意次数(重复0次或更多次)。

import re

# a、匹配其中数字
str1 = 'a1b3d45f6j7'
print(re.findall('\d*', str1))
# ['', '1', '', '3', '', '45', '', '6', '', '7', '']

# 匹配符合要求的，a-普通匹配符。
print(re.findall('a\d*', str1))
# ['a1']

# b、匹配其中字母
print(re.findall('[a-z]*', str1))
# ['a', '', 'b', '', 'd', '', '', 'f', '', 'j', '', '']

4.7 {M, N} 的变式匹配：

str1 = 'a1b3d45f6j7'
# 从这个字符串中将所有的数字匹配出来
# re_str = '[0-9]{1}'                        # 每次只取一个字符，匹配一次
# re_str = '[0-9]{5}'						# 连续匹配五次，findall不符合条件返回空列表。
# re_str = '[0-9]{1,5}'						# 最少匹配一次，最多匹配五次
# re_str = '[0-9]{1,}'						# 最少匹配一次
re_str = '[0-9]{,5}'						    # 最多匹配五次，最少匹配零次，不符合返回空字符串。
result1 = re.findall(re_str, str1)
print(result1)
# 打印结果为
['1', '3', '4', '5', '6', '7']
[]
['1', '3', '45', '6', '7']
['1', '3', '45', '6', '7']
['', '1', '', '3', '', '45', '', '6', '', '7', '']

4.8 分组和分支

分支： |（或者的关系）
分组：（）
- 能够将同类项提取出来。
- 能够将分组里边的结果取出来。
  - 如果字符串后面再次出现过前面匹配过的结果，可以将前面的结果使用分组包围起来。
  - 可以结合\N（N是数字，代表第N个分组）的语法，可以"将前面第N个分组的结果"重复使用。

4.9 分组或分支正则表达式语法的应用：

分支： |（或者的关系）
- 在之前的匹配符里，我们是这样使用重复匹配符来匹配正则表达式的。然后我们试着简化以下，在写正则表达式的时候直接在字符串中间加上 | 字符分隔开。

import re

str1 = 'abcabd'
# 重复：分别匹配出"abc"和"abd"
re_str = '[a-z]{3}'
print(re.findall(re_str, str1))
# 打印结果为：
['abc', 'abd']
['abc', 'abd']

# 分支：分别匹配出"abc"和"abd"
str1 = 'abcabd'
re_str = 'abc|abd'
result1 = re.findall(re_str, str1)
print(result1)
# ['abc', 'abd']

分组：（)

import re

str1 = 'abcabd'
# re_str = '(ab(c|d))'

# 取得是abca、abbd,但abbd不在字符串里，findall取的是分组（括号里边的）匹配。
re_str = 'ab(ca|bd)'
result1 = re.findall(re_str, str1)
print(result1)
# 打印结果为：
[('abc', 'c'), ('abd', 'd')]
['ca']

# 补充：'(ab(c|d))(abc)'  ->(ab(c|d))是第一个分组，(c|d)第二个分组，(abc)第三个分组。

4.10 分组中的重复操作：()

import re

str2 = '1234==12341234'
# re_str = r'(\d{4})(=)\2\1\1'
re_str = r'(\d{4})(=)\2(\d{4})(\d{4})'
result3 = re.fullmatch(re_str, str2)
print(result3)
# 打印结果为：
<re.Match object; span=(0, 14), match='1234==12341234'>
<re.Match object; span=(0, 14), match='1234==12341234'>