python re模块详解,python re模块 字符串匹配

　　元字符是正则表达式中具有特殊意义的特殊字符。本文主要介绍Python中re模块使用的元字符概述。通过示例代码进行了非常详细的介绍，对大家的学习或工作有一定的参考价值。有需要的朋友就跟着下面的边肖学习吧。

　　00-1010类别1:元字符方括号([])字符设置点(。)通配符w和W单词字符匹配d和D字符十进制数字匹配s和S字符空格匹配混合使用 w、 d、S和)转义元字符类别3:定位点$和Z字符串结尾匹配b和B单词匹配类别4:量词*匹配前一个子表达式零次或多次匹配前一个子表达式一次或多次？匹配前一个子表达式零次或一次。*?与第一个元字符精确匹配m次的最小长度匹配{m}正则表达式。{m，n}匹配前一个正则表达式从m到n次{m，n}的任意次重复？仅匹配一次类别5:分组构造和反向引用将组视为单位捕获组，m.groups()捕获组，m.group(n)捕获组，m.group(n1，n2，…)类别6:反向引用num匹配连续相同字符类别7:其他分组结构(？Pnameregex)创建一个捕获组，并将其命名为(？P=name)匹配前一个捕获名称(？regex)创建一个非捕获组来指定匹配类别8的条件：前视和后视断言(？=lookahead_regex)正前瞻性断言(？Lookahead_regex)负的前瞻性断言(？=lookbehind_regex)正向反向断言(？-look behind _ regex-)负向后断言类别9:杂项元字符(？# …)指定注释竖线或竖线()指定一组要匹配的替代元字符。元字符是正则表达式中具有特殊含义的特殊字符，在Python中也不例外。它们用于指示目标对象中前导字符(元字符之前的字符)的外观模式。

　　在正则表达式中，方括号([])中指定的一组字符构成一个字符类。

　　#元字符序列匹配类中的任何单个字符

　　s=foo123bar

　　# 3任意连续字符匹配

　　重新搜索([0-9][0-9][0-9]，s)

　　_sre。SRE _匹配对象；span=(3，6)，match=123

　　重新搜索([0-9][0-9][0-9]， foo456bar )

　　_sre。SRE _匹配对象；span=(3，6)，match=456

　　重新搜索([0-9][0-9][0-9]， 234巴兹)

　　_sre。SRE _匹配对象；span=(0，3)，match=234

　　重新搜索([0-9]

　　[0-9][0-9], qux678)

　　<_sre.SRE_Match object; span=(3, 6), match=678>

　　# 匹配不上的情况

　　>>> print(re.search([0-9][0-9][0-9], 12foo34))

　　None

　　通配符点 ( . ) 元字符匹配除换行符以外的任何字符。

>>> s = foo123bar

　　re模块支持的元字符

　　下面列表都是元字符的描述，对元字符进行分类描述方便记忆。 这个要是看不懂直接看跳过看下面的例子。

　　字符描述将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，‘n’ 匹配字符 n。‘n’ 匹配一个换行符。序列 ‘’ 匹配 而 ( 则匹配 (。^匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 ‘n’ 或 ‘r’ 之后的位置。$匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 ‘n’ 或 ‘r’ 之前的位置。*匹配前面的子表达式零次或多次。例如，zo* 能匹配 z 以及 zoo。* 等价于{0,}。+匹配前面的子表达式一次或多次。例如，‘zo+’ 能匹配 zo 以及 zoo，但不能匹配 z。+ 等价于 {1,}。?匹配前面的子表达式零次或一次。例如，do(es)? 可以匹配 do 或 does 。? 等价于 {0,1}。{n}n 是一个非负整数。匹配确定的 n 次。例如，‘o{2}’ 不能匹配 Bob 中的 ‘o’，但是能匹配 food 中的两个 o。{n,}n 是一个非负整数。至少匹配n 次。例如，‘o{2,}’ 不能匹配 Bob 中的 ‘o’，但能匹配 foooood 中的所有 o。‘o{1,}’ 等价于 ‘o+’。‘o{0,}’ 则等价于 ‘o*’。{n,m}m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，o{1,3} 将匹配 fooooood 中的前三个 o。‘o{0,1}’ 等价于 ‘o?’。请注意在逗号和两个数之间不能有空格。?当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 oooo，‘o+?’ 将匹配单个 o，而 ‘o+’ 将匹配所有 ‘o’。.匹配除换行符（n、r）之外的任何单个字符。要匹配包括 ‘n’ 在内的任何字符，请使用像"(.xy匹配 x 或 y。例如，'z[xyz]字符集合。匹配所包含的任意一个字符。例如， ‘[abc]’ 可以匹配 plain 中的 ‘a’。[^xyz]负值字符集合。匹配未包含的任意字符。例如， ‘[^abc]’ 可以匹配 plain 中的’p’、‘l’、‘i’、‘n’。[a-z]字符范围。匹配指定范围内的任意字符。例如，‘[a-z]’ 可以匹配 ‘a’ 到 ‘z’ 范围内的任意小写字母字符。[^a-z]负值字符范围。匹配任何不在指定范围内的任意字符。例如，‘[^a-z]’ 可以匹配任何不在 ‘a’ 到 ‘z’ 范围内的任意字符。b匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘erb’ 可以匹配"never" 中的 ‘er’，但不能匹配 verb 中的 ‘er’。B匹配非单词边界。‘erB’ 能匹配 verb 中的 ‘er’，但不能匹配 never 中的 ‘er’。cx匹配由 x 指明的控制字符。例如， cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 ‘c’ 字符。d匹配一个数字字符。等价于 [0-9]。D匹配一个非数字字符。等价于 [^0-9]。f匹配一个换页符。等价于 x0c 和 cL。n匹配一个换行符。等价于 x0a 和 cJ。r匹配一个回车符。等价于 x0d 和 cM。s匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ fnrtv]。S匹配任何非空白字符。等价于 [^ fnrtv]。t匹配一个制表符。等价于 x09 和 cI。v匹配一个垂直制表符。等价于 x0b 和 cK。w匹配字母、数字、下划线。等价于’[A-Za-z0-9_]'。W匹配非字母、数字、下划线。等价于 ‘[^A-Za-z0-9_]’。xn匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，‘x41’ 匹配 A。‘x041’ 则等价于 ‘x04’ & 1。正则表达式中可以使用 ASCII 编码。num匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，‘(.)1’ 匹配两个连续的相同字符。n标识一个八进制转义值或一个向后引用。如果 n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。nm标识一个八进制转义值或一个向后引用。如果 nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 nm 将匹配八进制转义值 nm。nml如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。un匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， u00A9 匹配版权符号 (?)。

类别1：匹配单个字符的元字符

方括号( [] ) 字符集

　　指定要匹配的特定字符集。 字符类元字符序列将匹配该类中包含的任何单个字符。

# 元字符序列[artz]匹配任何单个a、r、t或z字符

　　匹配和[a-z]之间的任何小写字母字符。

>>> re.search([a-z], FOObar)

　　匹配和[0-9]之间任何数字字符。

>>> re.search([0-9][0-9], foo123bar)

　　[0-9a-fA-F]匹配任何十六进制数字字符。

>>> re.search([0-9a-fA-f], --- a0 ---)

　　[^0-9]匹配任何不是数字的字符开头的字符。

>>> re.search([^0-9], 12345foo)

　　如果一个^字符出现在字符类中但不是第一个字符则无结果。

>>> re.search([#:^], foo^bar:baz#qux)

　　可以通过用连字符分隔字符来指定字符类中的字符范围，可以将其作为第一个或最后一个字符放置，或者使用反斜杠 ( ) 对其进行转义。

# 直接查找符号

点 ( . ) 通配符

　　匹配除换行符以外的任何单个字符。

>>> re.search(foo.bar, fooxbar)

w 和 W 单词字符匹配

　　w匹配任何字母数字字符，单词字符是大写和小写字母、数字和下划线 ( _) 字符。

　　w 等于 [a-zA-Z0-9_] 。

>>> re.search(w, #(.a$@&)

　　W是相反的。它匹配任何非单词字符。

　　W 等于 [^a-zA-Z0-9_] 。

>>> re.search(W, a_1*3Qb)

d 和 D 字符十进制数字匹配

　　d匹配任何十进制数字字符，等价于[0-9]。

>>> re.search(d, abc4def)

　　D匹配任何不是十进制数字的字符，等价于[^0-9]。

>>> re.search(D, 234Q678)

s 和 S 字符空格匹配

　　s匹配任何空白字符，同时也匹配换行符。

>>> re.search(s, foonbar baz)

　　S匹配任何不是空格的字符。

>>> re.search(S, n foo n )

混合使用 w, W, d, D, s, 和S

　　字符类序列w, W, d, D, s, 和S也可以出现在方括号字符类中。

# [dws]匹配任何数字、单词或空白字符

类别2：转义元字符

反斜杠 ( ) 转义元字符

　　反斜杠会删除元字符的特殊含义。

>>> re.search(., foo.bar)

类别3：锚点

　　不匹配搜索字符串中的任何实际字符，并且在解析期间它们不使用任何搜索字符串。指示搜索字符串中必须发生匹配的特定位置。

　　^ 和 A 字符串的开头匹配项

>>> re.search(^foo, foobar)

$ 和Z 字符串的结尾匹配项

>>> re.search(bar$, foobar)

b 和 B 单词匹配

　　b 必须在单词的开头或结尾。

# 单词开头

　　B 不能在单词的开头或结尾。

>>> print(re.search(rBfooB, foo))

类别4：量词

　　该部分必须出现多少次才能使匹配成功。

* 匹配前面的子表达式零次或多次

>>> re.search(foo-*bar, foobar)

　　匹配2个字符中全部的内容。

>>> re.search(foo.*bar, # foo jklasajk#*(@ bar #)

+ 匹配前面的子表达式一次或多次

>>> print(re.search(foo-+bar, foobar))

? 匹配前面的子表达式零次或一次

>>> re.search(foo-?bar, foobar)

.*?、+?、?? 最小长度匹配

　　加问号则表示为最小长度匹配的懒惰模式。

### + 和 +? 代替了 * 和 *?

{m} 完全匹配m次前面元字符的正则表达式。

>>> print(re.search(x-{3}x, x--x))

{m,n} 匹配前面正则表达式的任意数量的重复从m到n次

>>> for i in range(1, 6):

　　正则表达式匹配说明相同语法< regex > {,n}任何小于或等于的重复次数n< regex > {0,n}< regex > {m,}任何大于或等于的重复次数m----< regex > {,}任意次数的重复< regex > {0,} ， < regex > *

>>> re.search(x{}y, x{}y)

{m,n}? 只匹配一次

　　非贪婪（懒惰）版本 {m,n}。

>>> re.search(a{3,5}, aaaaaaaa)

类别5：分组构造和反向引用

　　分组构造将 Python 中的正则表达式分解为子表达式或组。

• 分组：一个组代表一个单一的句法实体。附加元字符作为一个单元应用于整个组。

• 捕获：一些分组结构还捕获与组中的子表达式匹配的搜索字符串部分。可以通过几种不同的机制检索捕获的匹配项。

　　(<regex>)，定义子表达式或组。

# 括号中的正则表达式仅匹配括号的内容

将组视为一个单元

　　组后面的量词元字符对组中指定的整个子表达式作为一个单元进行操作。

# 元字符+仅适用于字符r，ba随后出现一次或多次r。

　　正则表达式解释匹配说明例子bar+元字符+仅适用于字符’r’。‘ba’随后出现一次或多次’r’bar、barr、barrr等(bar)+元字符+适用于整个字符串’bar’。出现一次或多次’bar’bar、barbar、barbarbar

捕获组，m.groups()

　　返回一个元组，其中包含从正则表达式匹配中捕获的所有组。

>>> m = re.search((w+),(w+),(w+), foo,quux,baz)

捕获组，m.group(<n>)

　　返回包含<n>捕获的匹配项的字符串。

>>> m = re.search((w+),(w+),(w+), foo,quux,baz)

捕获组，m.group(<n1>, <n2>, …)

　　返回一个包含指定捕获匹配序号的元组。

>>> m = re.search((w+),(w+),(w+), foo,quux,baz)

类别6：反向引用

<num> 匹配连续相同字符

>>> regex = r(w+),1

类别7：其他分组结构

(?P<name><regex>) 创建捕获组并命名

>>> m = re.search((?P<w1>w+),(?P<w2>w+),(?P<w3>w+), foo,quux,baz)

(?P=<name>) 匹配先前捕获名的内容

>>> m = re.search(r(w+),1, foo,foo)

(?:<regex>) 创建一个非捕获组

>>> m = re.search((w+),(?:w+),(w+), foo,quux,baz)

指定条件匹配

　　(?(<n>)<yes-regex><no-regex>)

　　(?(<name>)<yes-regex><no-regex>)

# ^(###)?表示搜索字符串可选地以 . 开头###。如果是这样，那么周围的分组括号###将创建一个编号为的组1。否则，不会存在这样的组

类别8：Lookahead 和 Lookbehind 断言

　　根据解析器在搜索字符串中当前位置的后面（左侧）或前面（右侧）来确定 Python 中正则表达式匹配的成功或失败。(?=<lookahead_regex>) 积极前瞻断言

(?=<lookahead_regex>) 积极前瞻断言

# 断言正则表达式解析器当前位置之后的内容必须匹配

(?!<lookahead_regex>) 否定的前瞻断言

# 例子和之前的前瞻积极断言相反

(?<=<lookbehind_regex>) 积极的后向断言

# 断言正则表达式解析器当前位置之前的内容匹配

(?<!–<lookbehind_regex–>) 否定的向后断言

# 例子和之前的向后积极断言相反

类别9：杂项元字符

(?#…) 指定注释

# 正则表达式解析器忽略(?#...)序列中包含的任何内容

竖条或管道 ( ) 指定要匹配的一组备选方案

# 形式的表达式最多匹配一个指定的表达式：<regex1><regex2>...<regexn><regexi>

　　到此这篇关于Python中re模块的元字符使用小结的文章就介绍到这了,更多相关Python中re模块的元字符内容请搜索盛行IT软件开发工作室以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT软件开发工作室！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。