正则不区分大小写_python正则表达式(re)的应用

正则表达式是一种特殊的字符序列，可以帮助您轻松检查字符串是否与某种模式匹配。从 1.5 版开始添加了 re 模块，它提供了 Perl 风格的正则表达式模式。

目录

正则表达式简介

典型的搜索和替换操作要求您提供与预期搜索结果相匹配的精确文本。虽然此技术可能足以完成静态文本的简单搜索和替换任务，但它缺乏灵活性，并且使用这种方法搜索动态文本会变得困难，甚至不可能。

通过使用正则表达式，您可以：

例如，您可能需要搜索整个网站，删除过时的内容并替换某些 HTML 格式标记。在这种情况下，您可以使用正则表达式来确定每个文件中是否出现该内容或 HTML 格式标记。此过程将受影响的文件列表缩小到包含需要删除或更改的内容的文件。然后，您可以使用正则表达式删除过时的内容。最后，您可以使用正则表达式搜索和替换标记。

正则表达式语法

正则表达式（）描述一种字符串匹配模式（），可用于检查字符串是否包含某个子字符串、替换匹配的子字符串、或者从字符串中提取满足某个条件的子字符串等。

例如：

构建正则表达式的方式与创建数学表达式的方式相同。也就是说，您可以使用各种元字符和运算符将较小的表达式组合起来以创建较大的表达式。正则表达式的组成部分可以是单个字符、字符集、字符范围、字符选择或所有这些组成部分的任意组合。

正则表达式是由常用字符（例如字符 a 到 z）和特殊字符（称为“元字符”）组成的文本模式。模式描述搜索文本时要匹配的一个或多个字符串。正则表达式充当模板，用于将字符模式与要搜索的字符串进行匹配。

模式描述

匹配字符串的开头

匹配字符串的结尾。

匹配除换行符之外的任意字符。当指定 re. 标签时，它将匹配包括换行符在内的任意字符。

[...]

用来表示一组字符，单独列出：[amk] 匹配 'a'、'm' 或 'k'

[...]

不在 [] 中的字符：[^abc] 匹配除 a、b、c 之外的字符。

匹配 0 个或多个表达式。例如，zo* 匹配“z”和“zoo”。* 相当于 {0,}。

匹配 1 个或多个表达式。例如，“zo+”匹配“zo”和“zoo”，但不匹配“z”。+ 相当于 {1,}。

以非贪婪方式匹配前面正则表达式定义的 0 个或 1 个片段。例如，“do(es)?”匹配“do”、“does 中的 does”以及“doxy 中的 do”。? 相当于 {0,1}。

{n}

匹配前一个表达式的 n 个出现。例如，“o{2}”与“Bob”中的“o”不匹配，但与“food”中的两个 o 匹配。

{ n,}

精确匹配前面的 n 个表达式。例如，“o{2,}”无法匹配“Bob”中的“o”，但可以匹配“”中的所有 o。“o{1,}”相当于“o+”。“o{0,}”相当于“o*”。

{ n, m }

匹配前一个正则表达式定义的片段 n 至 m 次，贪婪模式

a | b

匹配 a 或 b

（关于）

匹配括号内的表达式，也代表一个组

（？imx）

正则表达式包含三个可选标志：i、m 或 x。仅括号内的区域会受到影响。

（？-IMX）

关闭 i、m 或 x 可选标志的正则表达式仅影响括号内的区域。

（？： 关于）

类似于(...)，但不代表某个群体

（？imx：回复）

在括号中使用 i、m 或 x 可选标志

（？-imx：重新）

不要在括号中使用 i、m 或 x 可选标志

（？#...）

笔记。

（？= 回复）

前瞻正定界符。如果包含的正则表达式（用 ... 表示）在当前位置成功匹配，则成功，否则失败。但是一旦尝试了包含的表达式，匹配引擎就不会再前进；模式的其余部分将在定界符的右侧尝试。

（？！ 关于）

负向前查找分隔符。与正分隔符相反；如果所包含的表达式在字符串中的当前位置无法匹配，则成功。

（？> 回复）

匹配独立模式，消除回溯。

\w

匹配数字、字母和下划线

\W

匹配非字母数字字符和下划线

\s

匹配任何空格字符，相当于 [\t\n\r\f]。

\S

匹配任何非空白字符

\d

匹配任意数字，相当于[0-9]。

\D

匹配任何非数字

\A

匹配字符串的开头

\Z

匹配字符串的结尾。如果有换行符，则只匹配换行符之前的结束字符串。

\z

匹配字符串的结尾

\G

匹配上一次匹配完成的位置。

\b

匹配单词边界，即单词和空格之间的位置。例如，'er\b' 可以匹配“never”中的 'er'，但不能匹配“verb”中的 'er'。

\B

匹配非单词边界。'er\B' 与“verb”中的“er”匹配，但不与“never”匹配。

\n、\t 等。

匹配换行符。 匹配制表符，等等。

\1...\9

匹配第 n 组的内容。

\10

如果匹配，则匹配第 n 组的内容。否则，它是八进制字符代码的表达式。

正则表达式示例 示例描述

匹配””。

字符类

示例说明

[Pp]

匹配“”或“”

擦[耶]

匹配“ruby”或“rube”

[哎哟]

匹配括号中的任意字母

[0-9]

匹配任意数字。类似于 []

[阿兹]

匹配任意小写字母

[亚利桑那州]

匹配任意大写字母

[a-zA-Z0-9]

匹配任意字母和数字

[^aeiou]

除 aeiou 字母之外的所有字符

[^0-9]

匹配除数字之外的任意字符

正则表达式 - 修饰符（标记）

标签又称为修饰符，用于在正则表达式中指定额外的匹配策略。

修饰符描述

回

使匹配不区分大小写

重新 L

进行区域感知匹配

重新

多行匹配，影响 ^ 和 $

回

使 . 匹配所有字符，包括换行符

回U

根据字符集解析字符。此标志影响 \w、\W、\b、\B。

重新X

此标志为格式提供了更多灵活性，使正则表达式更易于理解。

正则表达式 - 运算符优先级

正则表达式从左到右进行评估，并遵循优先顺序，与算术表达式非常相似。

优先级相同的运算符从左到右运算，优先级不同的运算符从高到低运算。下表从高到低解释了各种正则表达式运算符的优先级顺序：

操作符描述

逃逸

(), (?:), (?=), []

圆括号和方括号

*、+、？、{n}、{n,}、{n,m}

资格赛

^, $, \任何元字符，任何字符

锚点和序列（即位置和顺序）

替换、“或”运算

字符的优先级高于替换运算符，因此“m|food”可匹配“m”或“food”。要匹配“mood”或“food”，请使用括号创建子表达式，结果为“(m|f)ood”。

正则表达式简介

正则表达式是一个内置库，可以直接导入。

import re

正则表达式方法 re.match 函数

re.match 尝试从字符串的开头匹配模式。如果模式与字符串的开头不匹配，match() 将返回 none。

re.match(pattern, string, flags=0)

参数说明

匹配正则表达式

要匹配的字符串。

旗帜

Flags用于控制正则表达式的匹配方式，比如是否区分大小写、多行匹配等。

import re
print(re.match('www', 'www.baidu.com').span())  # 在起始位置匹配
print(re.match('www', 'www.baidu.com'))
print(re.match('com', 'www.baidu.com'))
>>> (0, 3)
>>> 
>>> None

str.group()

group()用于提取分组的截取字符串，()用于分组，group()和group(0)一样，都是匹配正则表达式的整体结果，group(1)列出第一个括号匹配的部分，group(2)列出第二个括号匹配的部分，group(3)列出第三个括号匹配的部分，如果没有匹配成功，re.()返回None。

import re
ret = re.match("[0-35-9]Hello Python","7Hello Python")
print(ret.group())
>>> 7Hello Python
ret = re.match("([^-]*)-(\d+)","010-4732857398")
print(ret.group())
print(ret.group(1))
print(ret.group(2))
>>> 010-4732857398
>>> 010
>>> 4732857398

re.函数

re. 扫描整个字符串并返回第一个成功的匹配，如果没有匹配则返回 None。

re.match 与 re. 的区别：re.match 只匹配字符串的开头，如果字符串开头与正则表达式不匹配，则匹配失败，函数返回 None ；而 re. 则匹配整个字符串，直到找到匹配项。

import re
ret = re.search(r"\d+", "点击次数为99999")
print(ret.group())
 
>>> 99999

“r” 的作用

import re
mm = "c:\\a\\b\\c"
print(mm)
>>> c:\a\b\c
ret = re.match("c:\\\\",mm).group()
print(ret)
>>> c:\
ret = re.match("c:\\\\a",mm).group()
print(ret)
>>> c:\a
ret = re.match(r"c:\\a",mm).group()
print(ret)
>>> c:\a
ret = re.match(r"c:\a",mm).group()
print(ret)
>>> AttributeError: 'NoneType' object has no attribute 'group'

桩函数

该函数用于编译正则表达式并生成正则表达式（）对象以供 match() 和 match() 函数使用。它编译正则表达式模式并返回模式对象。

compile(pattern, flags=0)

import re
pattern = re.compile(r'\d+')
ret= pattern.match('one1266t4othree34four', 3, 10)
print(ret.group())
print(ret.start())
print(ret.end())
print(ret.span())
>>> 1266
>>> 3
>>> 7
>>> (3, 7)

在上文中，当匹配成功时，将返回一个 Match 对象，其中：

group([, …])方法用于获取一个或多个组匹配字符串，当想获取整个匹配子字符串时，可以直接使用group()或者group(0);

start([group])方法用于获取该组匹配的子字符串在整个字符串中的起始位置（子字符串第一个字符的索引），该参数默认值为0。

end([group]) 方法用于获取该组匹配的子字符串在整个字符串中的结束位置（子字符串最后一个字符的索引 + 1）。该参数默认值为 0。

span([group]) 方法返回 (start(group), end(group))

re.函数

在字符串中查找所有与正则表达式匹配的子字符串并返回一个列表。如果未找到匹配项，则返回一个空列表。注意：匹配一次和匹配全部。

import re
ret = re.findall(r"\d+", "python = 52464, PHP = 5246, java = 525")
print(ret)
>>> ['52464', '5246', '525']

re.函数

类似于查找与正则表达式匹配的字符串的所有子字符串并将它们作为迭代器返回。

import re
ret = re.finditer(r"\d+", "423gdfd4352hjb525")
print(ret)
for match in ret:
    print(match.group())
>>> 
>>>
423
4352
525

re.sub 函数

sub写作“”，意思是替换匹配的数据。

语法：re.sub(, repl, , count=0, flags=0)

import re
ret = re.sub(r"\d+", '888', "python = 97")
print(ret)
 
>>> python = 888

import re
def add(temp):
    #int（）参数必须是字符串，类似字节的对象或数字，而不是“re.Match”
    strNum = temp.group()
    num = int(strNum) + 1
    return str(num)
ret = re.sub(r"\d+", add, "python = 99")
print(ret)
ret = re.sub(r"\d+", add, "python = 88")
print(ret)
>>> python = 100
>>> python = 89

re.subn 函数

行为与 sub() 相同，但返回一个元组（字符串，替换次数）

re.subn（，repl，[，count]）

返回：（sub（repl，[，count]），替换次数）

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

re.split 函数

根据匹配项拆分字符串并返回列表。

import re
ret = re.split(r":| ","info:xiaoZhang 33 shandong")
print(ret)
>>> ['info', 'siyueshinidehuangyan', '666', 'xihuan']

贪婪和非贪婪

默认情况下，量词是贪婪的（在某些语言中默认情况下可能是非贪婪的），总是尝试匹配尽可能多的字符；非贪婪则相反，总是尝试匹配尽可能少的字符。

例如，使用正则表达式“ab*”搜索“abbbc”，会找到“abbb”。如果使用非贪婪量词“ab*?”，会找到“a”。

注意：我们一般采用非贪婪模式来提取。

在“*”、“?”、”、“+”、“{m,n}”后添加?，将贪婪改为非贪婪。

import re
s="This is a number 234-235-22-423"
#正则表达式模式中使⽤到通配字，那它在从左到右的顺序求值时，会尽量“抓取”满⾜匹配最⻓字符串，在我们上⾯的例⼦⾥⾯，“.+”会从字符串的启始处抓取满⾜模式的最⻓字符，其中包括我们想得到的第⼀个整型字段的中的⼤部分，“\d+”只需⼀位字符就可以匹配，所以它匹配了数字“4”，⽽“.+”则匹配了从字符串起始到这个第⼀位数字4之前的所有字符
r=re.match(".+(\d+-\d+-\d+-\d+)",s)
print(r.group(1))
#⾮贪婪操作符“？”，这个操作符可以⽤在"*","+","?"的后⾯，要求正则匹配的越少越好
r=re.match(".+?(\d+-\d+-\d+-\d+)",s)
print(r.group(1))
>>> 4-235-22-423
>>> 234-235-22-423

re.match(r"aa(\d+)","aa2343ddd").group(1)
>>> '2343'
re.match(r"aa(\d+?)","aa2343ddd").group(1)
>>> '2'
re.match(r"aa(\d+)ddd","aa2343ddd").group(1)
>>> '2343'
re.match(r"aa(\d+?)ddd","aa2343ddd").group(1)
>>> '2343'