Python 正则表达式

Python正则表达式操作指南:https://wiki.ubuntu.org.cn/Python正则表达式操作指南
菜鸟教程 之 python 正则表达式:http://www.runoob.com/python/python-reg-expressions.html
python 官网正则文档:https://docs.python.org/zh-cn/3.11/library/re.html

1、正则表达式基础

1.1. Python 正则表达式 "元字符、语法"

正则表达式是用于处理字符串的强大工具,大部分编程语言都提供有正则处理字符串的功能。正则表达式的语法都是一样的,区别只在于不同的编程语言实现支持的语法数量不同。

下图展示了使用正则表达式进行匹配的流程: 

re_simple

正则表达式的大致匹配过程是:依次拿出表达式和文本中的字符比较,如果每一个字符都能匹配,则匹配成功;一旦有匹配不成功的字符则匹配失败。如果表达式中有量词或边界,这个过程会稍微有一些不同,但也是很好理解的,看下图中的示例以及自己多使用几次就能明白。

下图列出了 Python 支持的正则表达式元字符和语法:   

1.2. 数量词的 "贪婪、非贪婪"

正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的(在少数语言里也可能是默认非贪婪),总是尝试匹配尽可能多的字符;非贪婪的则相反,总是尝试匹配尽可能少的字符。

例如:正则表达式 "ab*" 如果用于查找 "abbbc",将找到"abbb"。

           而如果使用非贪婪的数量词"ab*?",将找到"a"。

示例:abc123def123ghi123

贪婪匹配

  • :abc.*?
  • :abc.*123

非贪婪匹配:adc.*?123

1.3. 转义字符 \

与大多数编程语言相同,正则表达式里使用"\"作为转义字符,这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\",那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\":前两个和后两个分别用于在编程语言里转义成反斜杠,转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题,这个例子中的正则表达式可以使用r"\\"表示。同样,匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串,你再也不用担心是不是漏写了反斜杠,写出来的表达式也更直观。

1.4. 匹配模式

正则表达式提供了一些可用的匹配模式,比如忽略大小写、多行匹配等

  • re.I (即 IGNORECASE):忽略大小写(括号内是完整写法,下同)
  • re.M (即 MULTILINE):多行模式,改变'^'和'$'的行为(参见上图)
  • re.S (即 DOTALL):点任意匹配模式,改变'.'的行为
  • re.L (即 LOCALE):使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
  • re.U (即 UNICODE):使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性
  • re.X (即 VERBOSE):详细模式。这个模式下正则表达式可以是多行,忽略空白字符,并可以加入注释。

2、Python 的 re 模块

Python 的 re 模块说明

"."      Matches any character except a newline.
"^"      Matches the start of the string.
"$"      Matches the end of the string or just before the newline at
         the end of the string.
"*"      Matches 0 or more (greedy) repetitions of the preceding RE.
         Greedy means that it will match as many repetitions as possible.
"+"      Matches 1 or more (greedy) repetitions of the preceding RE.
"?"      Matches 0 or 1 (greedy) of the preceding RE.
*?,+?,?? Non-greedy versions of the previous three special characters.
{m,n}    Matches from m to n repetitions of the preceding RE.
{m,n}?   Non-greedy version of the above.
"\\"     Either escapes special characters or signals a special sequence.
[]       Indicates a set of characters.
         A "^" as the first character indicates a complementing set.
"|"      A|B, creates an RE that will match either A or B.
(...)    Matches the RE inside the parentheses.
         The contents can be retrieved or matched later in the string.
(?aiLmsux) The letters set the corresponding flags defined below.
(?:...)  Non-grouping version of regular parentheses.
(?P<name>...) The substring matched by the group is accessible by name.
(?P=name)     Matches the text matched earlier by the group named name.
(?#...)  A comment; ignored.
(?=...)  Matches if ... matches next, but doesn't consume the string.
(?!...)  Matches if ... doesn't match next.
(?<=...) Matches if preceded by ... (must be fixed length).
(?<!...) Matches if not preceded by ... (must be fixed length).
(?(id/name)yes|no) Matches yes pattern if the group with id/name matched,
                   the (optional) no pattern otherwise.


\number  Matches the contents of the group of the same number.
\A       Matches only at the start of the string.
\Z       Matches only at the end of the string.
\b       Matches the empty string, but only at the start or end of a word.
\B       Matches the empty string, but not at the start or end of a word.
\d       Matches any decimal digit; equivalent to the set [0-9] in
         bytes patterns or string patterns with the ASCII flag.
         In string patterns without the ASCII flag, it will match the whole
         range of Unicode digits.
\D       Matches any non-digit character; equivalent to [^\d].
\s       Matches any whitespace character; equivalent to [ \t\n\r\f\v] in
         bytes patterns or string patterns with the ASCII flag.
         In string patterns without the ASCII flag, it will match the whole
         range of Unicode whitespace characters.
\S       Matches any non-whitespace character; equivalent to [^\s].
\w       Matches any alphanumeric character; equivalent to [a-zA-Z0-9_]
         in bytes patterns or string patterns with the ASCII flag.
         In string patterns without the ASCII flag, it will match the
         range of Unicode alphanumeric characters (letters plus digits
         plus underscore).
         With LOCALE, it will match the set [0-9_] plus characters defined
         as letters for the current locale.
\W       Matches the complement of \w.
\\       Matches a literal backslash.

re 模块支持的方法
match        从 "字符串开头" 位置进行匹配
fullmatch    从 "字符串开头到结尾" 进行匹配。
search       搜索符合正则表达式的字符串
sub          替换字符串中符合正则表达式的字符串
subn         和 sub 相同
split        使用 "符合正则表达式的字符串" 分割字符串
findall      找出所有符合正则表达式的字符串
finditer     同 findall,但是返回的是 迭代器
compile      编译 "正则表达式" 成为一个 Pattern object.
purge        清除正则表达式缓存
escape       反斜杠字符串中的所有非字母数字。

除purge和escape之外的每个函数都可以接受可选的'flags'参数
由以下一个或多个模块常量组成,由"|"连接。
A, L, and U are mutually exclusive.
A  ASCII       对字符串的 patterns, 设置 \w, \W, \b, \B, \d, \D 匹配对应的ASCII字符类别。
               (而不是整个Unicode类别,这是默认的)。
               对于字节模式,这个标志是唯一可用的行为,不需要指定。
I  IGNORECASE  忽略大小进行匹配
L  LOCALE      根据当前区域设置\w, \W, \b, \B
M  MULTILINE   "^" 匹配行首(即换行符之后)。"$" 匹配行尾
S  DOTALL      "." 匹配任何字符, 包括 "换行符"
X  VERBOSE     忽略空格和注释。想了解更多,查看 RE's.
U  UNICODE     仅用于兼容性。 忽略 string patterns (默认), 同时禁用 bytes patterns.
 

使用 re 模块

Python 通过 re 模块提供对正则表达式的支持。

re 模块的使用有两种方式

  • 方式 1:直接先将正则表达式的字符串形式编译为 Pattern 实例,然后使用 Pattern实例处理文本并获得匹配结果(一个Match实例),最后使用Match实例获得信息,进行其他的操作。
            re.compile(string[,flag])     # 返回 pattern 对象。pattern 可以理解为一个匹配模式,那么我们怎么获得这个匹配模式呢?很简单,我们需要利用 re.compile 方法就可以。
  • 方式 2:直接使用 re.findall( pattern, 要匹配的字符串) 这种形式,findall 可以换成 re 支持的任何函数。
            # 以下为匹配所用函数
            re.match(pattern, string[, flags])
            re.search(pattern, string[, flags])
            re.split(pattern, string[, maxsplit])
            re.findall(pattern, string[, flags])
            re.finditer(pattern, string[, flags])
            re.sub(pattern, repl, string[, count])
            re.subn(pattern, repl, string[, count])

 match(string[, pos[, endpos]])     |  re.match(pattern, string[, flags])
 search(string[, pos[, endpos]])    |  re.search(pattern, string[, flags])
 split(string[, maxsplit])                 |  re.split(pattern, string[, maxsplit])
 findall(string[, pos[, endpos]])      |  re.findall(pattern, string[, flags])
 finditer(string[, pos[, endpos]])     |  re.finditer(pattern, string[, flags])
 sub(repl, string[, count])               |  re.sub(pattern, repl, string[, count])
 subn(repl, string[, count])             |  re.sub(pattern, repl, string[, count])

方式 1 使用 示例:

# encoding: UTF-8
import re
 
# 将正则表达式编译成Pattern对象
pattern = re.compile(r'hello')
 
# 使用Pattern匹配文本,获得匹配结果,无法匹配时将返回None
match = pattern.match('hello world!')
 
if match:
    # 使用Match获得分组信息
    print match.group()
 
### 输出 ###
# hello
import re
line = "Cats are smarter than dogs"
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
if matchObj:
    print "matchObj.group() : ", matchObj.group()
    print "matchObj.group(1) : ", matchObj.group(1)
    print "matchObj.group(2) : ", matchObj.group(2)
else:
    print "No match!!"
以上实例执行结果如下:
matchObj.group() : Cats are smarter than dogs
matchObj.group(1) : Cats
matchObj.group(2) : smarter
import re
import requests

headers = {
    "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6",
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) "
                  "Chrome/112.0.0.0 Safari/537.36 Edg/112.0.1722.34"
}

url = "https://movie.douban.com/top250"
response = requests.get(url, headers=headers)
response.encoding = 'utf-8'
# print(response.text)
page_source = response.text

# 编写正则表达式
# re.S 可以让正则中的.匹配换行符
obj = re.compile(
    r'<div class="item">.*?<span class="title">(?P<name>.*?)</span>.*?<p class="">.*?导演: (?P<dao>.*?)&nbsp;.*?<br>',
    re.S
)

# 进行正则匹配
result = obj.finditer(page_source)
for item in result:
    name = item.group("name")
    dao = item.group("dao")
    print(name)

方式 2 使用 示例:

import re

test_string = """
<div>
    <div>
        <span class="title">黑客帝国</span>
    </div>
</div>
"""

result_1 = re.finditer(r'<div>.*?<span class="title">(?P<bie_name>.*?)</span>', test_string, re.S)
print(result_1)
for item in result_1:
    print(item.group("bie_name"))

# re.S 表示匹配任何字符,包括换行
result_2 = re.findall(r'<div>.*?<span class="title">(?P<pipei_name>.*?)</span>', test_string, re.S)
print(result_2)

result_3 = re.findall(r'<div>.*?<span class="title">(?P<bie_name>.*?)</span>', test_string)
print(result_3)

result_4 = re.findall(r'<div>[\S\s]*?<span class="title">(.*?)</span>', test_string)
print(result_4)

re.compile(strPattern[, flag]):

这个方法是Pattern类的工厂方法,用于将字符串形式的正则表达式编译为Pattern对象。 第二个参数flag是匹配模式,取值可以使用按位或运算符'|'表示同时生效,比如re.I | re.M。另外,你也可以在regex字符串中指定模式,比如re.compile('pattern', re.I | re.M)与re.compile('(?im)pattern')是等价的。
可选值有:

  • re.I(re.IGNORECASE): 忽略大小写(括号内是完整写法,下同)
  • re.M(MULTILINE): 多行模式,改变'^'和'$'的行为(参见上图)
  • re.S(DOTALL): 点任意匹配模式,改变'.'的行为
  • re.L(LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
  • re.U(UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性
  • re.X(VERBOSE): 详细模式。这个模式下正则表达式可以是多行,忽略空白字符,并可以加入注释。以下两个正则表达式是等价的:
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")

re提供了众多模块方法用于完成正则表达式的功能。这些方法可以使用Pattern实例的相应方法替代,唯一的好处是少写一行re.compile()代码,但同时也无法复用编译后的Pattern对象。这些方法将在Pattern类的实例方法部分一起介绍。如上面这个例子可以简写为:

m = re.match(r'hello', 'hello world!')
print m.group()

re模块还提供了一个方法escape(string),用于将string中的正则表达式元字符如*/+/?等之前加上转义符再返回,在需要大量匹配元字符时有那么一点用。

re.match(pattern, string[, flags])

Match对象是一次匹配的结果,包含了很多关于此次匹配的信息,可以使用Match提供的可读属性或方法来获取这些信息。

属性:

  1. string: 匹配时使用的文本。
  2. re: 匹配时使用的Pattern对象。
  3. pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
  4. endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
  5. lastindex: 最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组,将为None。
  6. lastgroup: 最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组,将为None。

方法:

  1. group([group1, …]): 
    获得一个或多个分组截获的字符串;指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名;编号0代表整个匹配的子串;不填写参数时,返回group(0);没有截获字符串的组返回None;截获了多次的组返回最后一次截获的子串。
  2. groups([default]): 
    以元组形式返回全部分组截获的字符串。相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代,默认为None。
  3. groupdict([default]): 
    返回以有别名的组的别名为键、以该组截获的子串为值的字典,没有别名的组不包含在内。default含义同上。
  4. start([group]): 
    返回指定的组截获的子串在string中的起始索引(子串第一个字符的索引)。group默认值为0。
  5. end([group]): 
    返回指定的组截获的子串在string中的结束索引(子串最后一个字符的索引+1)。group默认值为0。
  6. span([group]): 
    返回(start(group), end(group))。
  7. expand(template): 
    将匹配到的分组代入template中然后返回。template中可以使用\id或\g<id>、\g<name>引用分组,但不能使用编号0。\id与\g<id>是等价的;但\10将被认为是第10个分组,如果你想表达\1之后是字符'0',只能使用\g<1>0。
import re
m = re.match(r'(\w+) (\w+)(?P<sign>.*)', 'hello world!')
 
print "m.string:", m.string
print "m.re:", m.re
print "m.pos:", m.pos
print "m.endpos:", m.endpos
print "m.lastindex:", m.lastindex
print "m.lastgroup:", m.lastgroup
 
print "m.group(1,2):", m.group(1, 2)
print "m.groups():", m.groups()
print "m.groupdict():", m.groupdict()
print "m.start(2):", m.start(2)
print "m.end(2):", m.end(2)
print "m.span(2):", m.span(2)
print r"m.expand(r'\2 \1\3'):", m.expand(r'\2 \1\3')
 
### output ###
# m.string: hello world!
# m.re: <_sre.SRE_Pattern object at 0x016E1A38>
# m.pos: 0
# m.endpos: 12
# m.lastindex: 3
# m.lastgroup: sign
# m.group(1,2): ('hello', 'world')
# m.groups(): ('hello', 'world', '!')
# m.groupdict(): {'sign': '!'}
# m.start(2): 6
# m.end(2): 11
# m.span(2): (6, 11)
# m.expand(r'\2 \1\3'): world hello!

Pattern 对象 --- re.compile(pattern, flags=0)

Pattern 对象是一个编译好的正则表达式,通过Pattern提供的一系列方法可以对文本进行匹配查找。Pattern不能直接实例化,必须使用 re.compile()进行构造。

Pattern 提供了几个可读属性用于获取表达式的相关信息:

  1. pattern: 编译时用的表达式字符串。
  2. flags: 编译时用的匹配模式。数字形式。
  3. groups: 表达式中分组的数量。
  4. groupindex: 以表达式中有别名的组的别名为键、以该组对应的编号为值的字典,没有别名的组不包含在内。
import re
p = re.compile(r'(\w+) (\w+)(?P<sign>.*)', re.DOTALL)
 
print "p.pattern:", p.pattern
print "p.flags:", p.flags
print "p.groups:", p.groups
print "p.groupindex:", p.groupindex
 
### output ###
# p.pattern: (\w+) (\w+)(?P<sign>.*)
# p.flags: 16
# p.groups: 3
# p.groupindex: {'sign': 3}

re.search(pattern, string[, flags])

re.match 与 re.search 的区别

  • re.match 只匹配 字符串的开始,如果字符串开始不符合正则表达式,则匹配失败,函数返回None;即 re.match 自带 ^
  • re.search 匹配 整个字符串,直到找到一个匹配的
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import re

line = "Cats are smarter than dogs";
matchObj = re.match(r'dogs', line, re.M | re.I)
if matchObj:
    print "match --> matchObj.group() : ", matchObj.group()
else:
    print "No match!!"

matchObj = re.search(r'dogs', line, re.M | re.I)
if matchObj:
    print "search --> matchObj.group() : ", matchObj.group()
else:
    print "No match!!"

实例方法 [ | re模块方法]:

  1. match(string[, pos[, endpos]]) | re.match(pattern, string[, flags]): 
    这个方法将从string的pos下标处起尝试匹配pattern;如果pattern结束时仍可匹配,则返回一个Match对象;如果匹配过程中pattern无法匹配,或者匹配未结束就已到达endpos,则返回None。
    pos和endpos的默认值分别为0和len(string);re.match()无法指定这两个参数,参数flags用于编译pattern时指定匹配模式。 
    注意:这个方法并不是完全匹配。当pattern结束时若string还有剩余字符,仍然视为成功。想要完全匹配,可以在表达式末尾加上边界匹配符'$'。 
    示例参见2.1小节。
  2. search(string[, pos[, endpos]]) | re.search(pattern, string[, flags]):
    这个方法用于查找字符串中可以匹配成功的子串。从string的pos下标处起尝试匹配pattern,如果pattern结束时仍可匹配,则返回一个Match对象;若无法匹配,则将pos加1后重新尝试匹配;直到pos=endpos时仍无法匹配则返回None。
    pos和endpos的默认值分别为0和len(string));re.search()无法指定这两个参数,参数flags用于编译pattern时指定匹配模式。
# encoding: UTF-8 
import re 
 
# 将正则表达式编译成Pattern对象 
pattern = re.compile(r'world') 
 
# 使用search()查找匹配的子串,不存在能匹配的子串时将返回None 
# 这个例子中使用match()无法成功匹配 
match = pattern.search('hello world!') 
 
if match: 
    # 使用Match获得分组信息 
    print match.group() 
 
### 输出 ### 
# world

re.split(pattern, string[, maxsplit]):

按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数,不指定将全部分割。

import re
 
p = re.compile(r'\d+')
print p.split('one1two2three3four4')
 
### output ###
# ['one', 'two', 'three', 'four', '']

re.findall(pattern, string[, flags]):

搜索string,以列表形式返回全部能匹配的子串。

import re
 
p = re.compile(r'\d+')
print p.findall('one1two2three3four4')
 
### output ###
# ['1', '2', '3', '4']

re.finditer(pattern, string[, flags]):

搜索 string,返回一个顺序访问每一个匹配结果(Match对象)的迭代器。

import re
 
p = re.compile(r'\d+')
for m in p.finditer('one1two2three3four4'):
    print m.group(),
 
### output ###
# 1 2 3 4

re.sub(pattern, repl, string[, count]):

使用 repl 替换 string 中每一个匹配的子串后返回替换后的字符串。

  • 当 repl 是一个字符串时,可以使用 \id 或 \g、\g 引用分组,但不能使用编号0。
  • 当 repl 是一个方法时,这个方法应当只接受一个参数(Match对象),并返回一个字符串用于替换( 返回的字符串中不能再引用分组 )。
  • count 用于指定最多替换次数,不指定时全部替换。
import re
 
p = re.compile(r'(\w+) (\w+)')
s = 'i say, hello world!'
 
print p.sub(r'\2 \1', s)
 
def func(m):
    return m.group(1).title() + ' ' + m.group(2).title()
 
print p.sub(func, s)
 
### output ###
# say i, world hello!
# I Say, Hello World!
#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import re

phone = "2004-959-559 # This is Phone Number"
# Delete Python-style comments
num = re.sub(r'#.*$', "", phone)
print "Phone Num : ", num
# Remove anything other than digits
num = re.sub(r'\D', "", phone)
print "Phone Num : ", num

# 执行结果如下:
# Phone Num : 2004-959-559
# Phone Num : 2004959559

re.subn(pattern, repl, string[, count]):

返回 ( sub(repl, string[, count]), 替换次数 )。

import re
 
p = re.compile(r'(\w+) (\w+)')
s = 'i say, hello world!'
 
print p.subn(r'\2 \1', s)
 
def func(m):
    return m.group(1).title() + ' ' + m.group(2).title()
 
print p.subn(func, s)
 
### output ###
# ('say i, world hello!', 2)
# ('I Say, Hello World!', 2)

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值