正则表达式的入门用法及Python中的正则表达式

目录

正则表达式的简单入门

Python中的正则表达式

---

  

正则表达式的简单入门

正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。

正则表达式是由普通字符（例如字符 a 到 z）以及特殊字符（称为"元字符"）组成的文字模式。模式描述在搜索文本时要匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。

我尽量的在捋明白当下内容时不涉及还没学到的内容。当然我在写博客的时候已经稍微明白一些了，无法客观地站在一个完全的小白的角度来逐层分解。

普通字符

普通字符包括没有显式指定为元字符的所有可打印和不可打印字符。这包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号。

非打印字符

字符	描述
\cx	匹配由x指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。
\f	匹配一个换页符。等价于 \x0c 和 \cL。
\n	匹配一个换行符。等价于 \x0a 和 \cJ。
\r	匹配一个回车符。等价于 \x0d 和 \cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。注意 Unicode 正则表达式会匹配全角空格符。
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t	匹配一个制表符。等价于 \x09 和 \cI。
\v	匹配一个垂直制表符。等价于 \x0b 和 \cK。

特殊字符

即在正则表达式中不能单纯作为普通字符，而拥有特定功能或者可以替代其他字符的某些字符

对于这些字符如果我们想取他们的字面意思应在其之前使用转义字符反斜杠“\”

特别字符	描述
$	匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 '\n' 或 '\r'。要匹配 $ 字符本身，请使用 \$。
( )	标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 \( 和 \)。
*	匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 \*。
+	匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+。
.	匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 \. 。
[	标记一个中括号表达式的开始。要匹配 [，请使用 \[。
?	匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 \?。
\	将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\\' 匹配 "\"，而 '\(' 则匹配 "("。
^	在一个表达式开头中时，表示匹配输入字符串的开始位置；在方括号表达式中时，表示除了该方括号表达式中的字符集合，即“非”。要匹配 ^ 字符本身，请使用 \^。
{	标记限定符表达式的开始。要匹配 {，请使用 \{。
|	指明两项之间的一个选择。要匹配 |，请使用 \|。

限定符

限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。

字符	描述
*	匹配前面的子表达式零次或多次。例如，'zo*' （zo需至少出现0次）能匹配 "z"（因为"z"中出现了0次"zo"） 以及 "zoo"。* 等价于{0,}。
+	匹配前面的子表达式一次或多次。例如，'zo+'（zo需至少出现一次）能匹配 "zo" 以及 "zoo"，但不能匹配 "z"，因为"z"中并没有出现至少一次 "zo"。+ 等价于 {1,}。
?	匹配前面的子表达式零次或一次。例如，'do(es)?'（匹配do后面出现一次es或出现0次es的字符串，即匹配do或does） 可以匹配 "do" 、 "does" 中的 "does" 、 "doxy"（出现了do） 中的 "do" 。? 等价于 {0,1}。
{n}	n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' （匹配"oo"）不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
{n,}	n 是一个非负整数。至少匹配n 次。例如，'o{2,}' （匹配至少出现两次"o"的字符串，如"oo"、"ooo"、"oooo"……）不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
{n,m}	m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" （匹配"o"、"oo"、"ooo"）将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。

PS：关于小括号()、中括号[]、花括号{}做一下总结

() 一个子表达式，在该范围内单独表达某种字符串。表达式中有几个()就有几个相应的匹配子字符串。()本身不匹配任何东西，也不限制匹配任何东西，只是把括号内的内容作为同一个表达式来处理。

例如(ab){1,3}，就表示ab一起连续出现最少1次，最多3次。如果没有括号的话，ab{1,3},就表示a，后面紧跟的b出现最少1次，最多3次。

[]是定义匹配的字符范围。比如[abcde]匹配abcde中的任意一个，[abcdefghijklmnopqrstuvwxyz]匹配任意小写字母，等价于[a-z]，即"-"段横杠表示在某某范围内，[1-9]表示匹配数字1到9一次， [a-zA-Z0-9] 表示相应位置的字符要匹配一个英文字符或一个数字。特殊字符写在[]会被当成普通字符来匹配。例如[(a)]，会匹配(、a、)、这三个字符。

{}一般用来表示匹配的长度，比如 \s{3} 表示匹配三个空格，\s{1,3}表示匹配一到三个空格。

(0-9) 匹配 '0-9′ 本身。 [0-9]* 匹配数字（注意后面有 *，可以为空，即零个或多个）[0-9]+ 匹配数字（注意后面有 +，不可以为空，即至少出现一次）{1-9} 写法错误。

[0-9]{0,9} 表示长度为 0 到 9 的数字字符串。

一些例子：

[1-9][0-9]* //匹配一串数字，第一个数字不可以是0，即匹配大于1的所有整数 
[1-9][0-9]+ //匹配一串数字，至少是一个两位数，且开头第一个数字不可以是0，即匹配大于10的所有整数 
[1-9][0-9]？//匹配1~99的数字 
[1-9][0-9]{0,1} //匹配1~99的数字 
[0-9]{1,2} //匹配0~99的数字

 

关于贪婪匹配和非贪婪匹配

贪婪匹配：匹配尽可能多的内容

非贪婪匹配：只要出现第一个符合的内容即停止匹配

例子：

<H1>Chapter 1 - 介绍正则表达式</H1>

针对上面一行字符串，如果我们要匹配"<"和">"中的内容，则

贪婪匹配：“<H1>Chapter 1 - 介绍正则表达式</H1>”

非贪婪匹配：“<H1>”

*、+ 限定符都是贪婪的，因为它们会尽可能多的匹配文字，在它们的后面加上一个?就可以实现非贪婪或最小匹配。

如同样一上面的字符串举例，匹配"<"">"之间内容的代码为

 

<.*> //此时为贪婪匹配，会得到<H1>Chapter 1 - 介绍正则表达式</H1>，因为会尽可能多的匹配所有符合条件的内容，即字面意思的贪婪

<.*?> //此时为非贪婪匹配，会得到<H1>，当第一次出现代表结束的符号">"时即停止匹配，因为已经满足条件了

 

" .* "：   "."即匹配除换行符 \n 之外的任何单字符，

             "*"即匹配前面的字符或子表达式零次或多次

所以".*"是以贪婪模式匹配任意多个除了换行符以外的字符。但".*？"是以非贪婪模式匹配任意多个除了换行符以外的字符。

Cats are smarter than dogs and humans
(.*) smarter (.*?) .*

上面的例子中（.*）是贪婪模式，而且后面有【空格】smarter【空格】……，所以他会一直匹配直到出现第一次【空格】smarter【空格】，然后后面是    （.*?）【空格】.*           ，此时（.*?）为非贪婪模式进行匹配，所以当她后面出现第一个【空格】时即停止匹配，所以（.*?）匹配了smarter【空格】后面的than，而再后面的【空格】dogs……由   .*   匹配。如果此时把表达式换为

(.*) smarter (.*) .*

则【空格】smarter【空格】后面的（.*）将匹配到最后一个空格之前的所有内容，即他将匹配than dogs and，因为and后面的空格是本句中最后一个空格。

定位符

定位符用来描述字符串或单词的边界，能够将正则表达式的查找目标固定到行首或行尾。

字符	描述
^	匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与 \n 或 \r 之后的位置匹配。
$	匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与 \n 或 \r 之前的位置匹配。
\b	匹配一个单词边界，即字与空格间的位置。
\B	非单词边界匹配。

注意！限定符和定位符不能一起使用，即不能将两者搭配。

关于上面定位符的使用实例：

^Chapter [1-9][0-9]{0,1}$ //查找以Chapter为开头，以1~99数字为结尾的字符串，中间有空格 
^Chapter$ //精确匹配，只匹配单词Chapter，就不匹配包含该单词的句子了，因为该句子中并不仅仅包含该单词

关于单词边界的描述：

单词的边界即每个“单词”（无论是不是一个完整的单词只要是一连串的无空格的字符串）与两边空格之间的位置；非单词边界即其他任意位置。

例如：

\bCha //可以匹配Cha开头的所有单词 
ter\b //可以匹配以ter为结尾的所有单词 
\Bapt //可以匹配不处在单词边界上的所有apt，比如chapter的apt，但无法匹配aptitude中的apt，因为他在边界上

 

运算符的优先级：

正则表达式从左到右进行计算，并遵循优先级顺序，这与算术表达式非常类似。

相同优先级的从左到右进行运算，不同优先级的运算先高后低。下表从最高到最低说明了各种正则表达式运算符的优先级顺序：

运算符	描述
\	转义符
(), (?:), (?=), []	圆括号和方括号
*, +, ?, {n}, {n,}, {n,m}	限定符
^, $, \+任何元字符、任何字符	定位点和序列（即：位置和顺序）
|	替换，"或"操作 字符具有高于替换运算符的优先级，使得"m|food"匹配"m"或"food"。若要匹配"mood"或"food"，请使用括号创建子表达式，从而产生"(m|f)ood"。

 

 

匹配规则：

模式：是一组描述字符串特征的字符，是正则表达式最基本的元素，往往用特殊的字符表示一个范围内的字符、重复出现，或上下文。上面的匹配例子（大概）都是模式（吧？）

字符簇：（好像）就是一个中括号包括里面的东西

 

一些小例子：

字符簇	描述
^[^0-9][0-9]$	第一个字符不能是数字第二个字符必须是数字的两字符字符串
[^a-z]	除了小写字母以外的所有字符
[^\\\/\^]	除了(\)(/)(^)之外的所有字符，"\\"表示转义后的"\"，"\/"表示转义后的"/"，"\^"表示转义后的"^"
[^\"\']	除了双引号(")和单引号(')之外的所有字符
^[a-zA-Z_]$	所有的字母和下划线
^a$	字母a
^a{4}$	aaaa
^a{2,4}$	aa,aaa或aaaa
^a{1,3}$	a,aa或aaa
^a{2,}$	包含多于两个a的字符串
^a{2,}	如：aardvark和aaab，但apple不行
a{2,}	如：baad和aaa，但Nantucket不行
\t{2}	两个制表符
.{2}	任意的两个字符
^[a-zA-Z0-9_]{1,}$	所有包含一个以上的字母、数字或下划线的字符串
^[1-9][0-9]{0,}$	所有的正整数
^\-{0,1}[0-9]{1,}$	所有的整数

还有一个比较麻烦的例子：

^[-]?[0-9]+\.?[0-9]+$

表示所有浮点数。"^[-]?"表示开头出现一次或零次"-"负号（正数和负数），"[0-9]+"表示是匹配至少一次数字（小数点前面必须要有一位数字的，不然怎么是浮点数），"\.?"转义后的"."出现一次或零次（毕竟整数从某种意义上也算浮点数），"[0-9]+$"匹配小数点后面的任意位数字，并且以该任意个数字结尾。

PS：

"？"与{0，1}等价

"* "与{0，}等价

"+ "与{1，}等价

 

替换和分组：

所谓替换即“或”，具体表现是就是在两者中间匹配任意一个都可以，例如：

Chapter|Section //匹配 Chapter 或 Section

但是注意

^Chapter|Section [1-9][0-9]{0,1}$

并不会如大家所愿匹配成"Chapter [数字]"或"Session [数字]"，而是Chapter或Session [数字]，

如果要匹配成理想的亚子，应该这样写

^(Chapter|Section) [1-9][0-9]{0,1}$

 

所谓分组

@@@asd090***

1、@@@[a-z]{3}[0-9]{3}\*\*\*

2、(@@@)([a-z]{3})([0-9]{3})(\*\*\*)

上面两个表达式匹配的内容完全相同，只不过第二句多了几个括号将“@@@”、“字母”、“数字”、“***”分割开了但是小括号将匹配后的字符串进行了分组，每个小括号为一组，即上面有小括号那一次匹配中共有四组，而没有使用小括号的表达式没有分组情况。我个人觉得只有在后面需要用group、groups时这个分组的功能才有用。

(@@@)、(asd)、(090)、(***)

当然如果表达式是这样的，即只在最两边加了括号，则只有一个分组即它本身

(@@@[a-z]{3}[0-9]{3}\*\*\*)

 此外，Python等语言还有自己的分组命名机制，可以对各个分组进行命名，后面会涉及。

其他例子：

正则表达式	描述
/\b([a-z]+) \1\b/gi	一个单词连续出现的位置。
/(\w+):\/\/([^/:]+)(:\d*)?([^# ]*)/	将一个URL解析为协议、域、端口及相对路径。
/^(?:Chapter|Section) [1-9][0-9]{0,1}$/	定位章节的位置。
/[-a-z]/	a至z共26个字母再加一个-号。
/ter\b/	可匹配chapter，而不能匹配terminal。
/\Bapt/	可匹配chapter，而不能匹配aptitude。
/Windows(?=95 |98 |NT )/	可匹配Windows95或Windows98或WindowsNT，当找到一个匹配后，从Windows后面开始进行下一次的检索匹配。
/^\s*$/	匹配空行。
/\d{2}-\d{5}/	验证由两位数字、一个连字符再加 5 位数字组成的 ID 号。
/<\s*(\S+)(\s[^>]*)?>[\s\S]*<\s*\/\1\s*>/	匹配 HTML 标记。

综上所述，无论是分析一个正则表达式要匹配什么内容还是写一个正则表达式，要点就是从浅到深由小到大，一层一层的分析或者写。

 

元字符

没啥可说的，看看就行，因为我觉得常用的在前面都介绍了，剩下的的瞄几眼就OK

字符	描述
\	将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，'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' 在内的任何字符，请使用像"(.|\n)"的模式。
(pattern)	匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 '\(' 或 '\)'。
(?:pattern)	匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y|ies) 就是一个比 'industry|industries' 更简略的表达式。
(?=pattern)	正向肯定预查（look ahead positive assert），在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，"Windows(?=95|98|NT|2000)"能匹配"Windows2000"中的"Windows"，但不能匹配"Windows3.1"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)	正向否定预查(negative assert)，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如"Windows(?!95|98|NT|2000)"能匹配"Windows3.1"中的"Windows"，但不能匹配"Windows2000"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?<=pattern)	反向(look behind)肯定预查，与正向肯定预查类似，只是方向相反。例如，"(?<=95|98|NT|2000)Windows"能匹配"2000Windows"中的"Windows"，但不能匹配"3.1Windows"中的"Windows"。
(?<!pattern)	反向否定预查，与正向否定预查类似，只是方向相反。例如"(?<!95|98|NT|2000)Windows"能匹配"3.1Windows"中的"Windows"，但不能匹配"2000Windows"中的"Windows"。
x|y	匹配 x 或 y。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。
[xyz]	字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。
[^xyz]	负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'、'l'、'i'、'n'。
[a-z]	字符范围。匹配指定范围内的任意字符。例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	匹配非单词边界。'er\B' 能匹配 "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	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\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 匹配版权符号 (?)。

 

Python中的正则表达式

上面的内容让门学会了正则表达式本身的用法和基本的匹配规则。我们可以在任何支持正则表达式的语言中使用。

我主要介绍一下Python中的基本用法。

Python自从1.5版本之后引入了正则表达式模块“re”，使用时需要先

import re

下面逐一介绍在python中常用的几种函数。

re.match函数

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none；如果在起始位置匹配成功，则返回_sre.SRE_Match object这样一个对象，其中包含所匹配字符串的起止位置和该目标字符串。

函数语法：

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

函数参数说明：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。在最后一小节由详细介绍

匹配成功re.match方法返回一个匹配的对象，否则返回None。

例如：

text1 = "f123"
text2 = "123f"
print(re.match("[a-z]", text1)) # 匹配成功，打印 <_sre.SRE_Match object; span=(0, 1), match='f'>
print(re.match("[a-z]", text2)) # 匹配失败，打印 None。因为小写字母并不位于起始位置

对于match返回的匹配对象，span表示匹配到的定位（对于match永远是span=(0, *)，*为字符串长度），match表示匹配成功的字符是什么。

我们可以使用group(number) 或 groups() 来获取匹配成功后返回的对象中的内容。

匹配对象方法	描述
group(number)	如果正则表达式中使用了（）小括号则该方法中的number有效。该方法可以根据小括号获得分组，number中的数字表示取第几组。如果不填参数或填“0”，则返回整个匹配对象，此时表达式中有没有用小括号分组无所谓都可以使用。group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()	返回一个包含所有小组字符串的元组，从 1 到 所含的小组号，即groups()=(group(1), group(2), group(3)……)。

js_def = "@@@asd090***"
print(re.match("@@@[a-z]{3}[0-9]{3}\*\*\*", js_def).group())
print(re.match("(@@@)([a-z]{3})([0-9]{3})(\*\*\*)", js_def).group())
print(re.match("(@@@)([a-z]{3})([0-9]{3})(\*\*\*)", js_def).group(1,2))
print(re.match("(@@@)([a-z]{3})([0-9]{3})(\*\*\*)", js_def).groups())

re.search方法

re.search 扫描整个字符串并返回第一个成功的匹配。

函数语法：

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

函数参数说明：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。在最后一小节由详细介绍

匹配成功re.search方法返回一个匹配的对象，跟re.match一样都是_sre.SRE_Match object，否则返回None。

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

匹配对象方法	描述
group(num=0)	匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()	返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

换句话说就是用法和match方法几乎完全相同，只是match只能从字符串的起始位置匹配，search才是真正意义上我们平时理解的的在字符串中任意位置匹配。

例子：

1、

text = "Cats are smarter than dogs and humans"
print(re.search("are", text))

打印结果：

2、上面那个探索贪婪模式的例子（注意空格）

text = "Cats are smarter than dogs and humans"
print(re.search("(.*) smarter (.*) (.*)", text).groups())
print(re.search("(.*) smarter (.*?) (.*)", text).groups())

打印结果：

3、可以在匹配的结果后面直接调用span来查看匹配的长度。

print(re.search('www', 'www.runoob.com').span()) #(0, 3)
print(re.search('com', 'www.runoob.com').span()) #(11, 14)

 接下来填一个之前留下的坑

Python命名分组机制

(?P<name>正则表达式)  #name是一个合法的标识符

在一般的正则表达式中，一个括号内的内容作为一个小组。

([a-z]*)(23333)

可以通过下面的语句为其在python语言中命名并取出

(?P<letter>[a-z]*)(?P<number>23333)
group("letter")
group("number")

看一个例子

s = "ip='230.192.168.78',version='1.0.0'"
print(re.search(r"ip='(?P<ip_address>\d+\.\d+\.\d+\.\d+).*", s).group('ip_address')) #'230.192.168.78'
 
phone = "123-719796895"
res=re.search(r"(?P<quhao>\d+)-(?P<num>\d+)", phone)
print(res.group('quhao')) #'123'
print(res.group('num')) #'719796895'

re.findall方法

re.findall 扫描整个字符串并以列表的形式返回所有匹配成功的子串。

函数语法：

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

函数参数说明：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。在最后一小节由详细介绍

匹配成功re.search方法返回一个list，其中包含了所有匹配成功的子串。但是，没有group可以用了。

还有另一种findall的用法后面学完compile再说

检索和替换

Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。

语法：

re.sub(pattern, repl, string, count=0, flags=0)

函数参数说明：

参数	描述
pattern	匹配的正则表达式
repl	替换的字符串，也可为一个函数
string	要匹配的字符串。
count	模式匹配后替换的最大次数，默认 0 表示替换所有的匹配

实例：

phone = "2004-959-559 # 这是一个国外电话号码"
 
# 删除字符串中的 Python注释 
num = re.sub("\#.*$", "", phone)
print(num) # 2004-959-559
 
# 删除非数字(-)的字符串 
num = re.sub('\D', "", phone)
print(num) # 2004959559

此处需要额外说一下参数pattern：

在正则表达式中反斜杠加数字（\N）对应着该表达式中使用小括号分好的组（我不知道在别的函数中是不是也可以这么用）
比如\6，表示匹配本表达式中的第6个group
意味着，pattern中，前面肯定是存在对应的，第6个group，然后你后面也才能去引用
比如，想要处理：

this is tonysure's blog and he is not a famous bloger.

现在要把is is tonysure's blog and he is not换成tonysure is

则就可以这样的re.sub实现替换：

text = "this is tonysure's blog and he is not a famous bloger."

replacedStr = re.sub(r"th(is)(.*)\1 not", "tonysure is", text )
#此句中 r 表示去掉反斜杠的转移机制
print (replacedStr) #tonysure is a famous bloger.

表达式pattern中使用小括号分了两组，第一组是（is），第二组是第一个is到not的所有内容，\1取了第一组的内容，也就是说如果不适用\1，则句子变为

replacedStr = re.sub(r"th(is)(.*)(is) not", "tonysure is", text )

同样如果换为

replacedStr = re.sub(r"(th)(is)(.*)\2 not", "tonysure is", text )

与原句表达相同。

参数repl：

如果repl是字符串的话，其中的任何反斜杠转义字符，都会被处理的。

即：

\n：会被处理为对应的换行符；

\r：会被处理为回车符；

其他不能识别的转移字符，则只是被识别为普通的字符。比如\j，会被处理为j这个字母本身；

双反斜杠\\加数字表示默认分组（也可以在前面加r，只用单反斜杠就够了）；

反斜杠加g以及尖括号<>内一个名字，即：\g<named group>，匹配命了名的组，

text = "this is tonysure's blog and he is not a famous bloger."

replacedStr = re.sub(r"th(is)(.*)\1 not", "\\1", text )
replacedStr = re.sub(r"th(is)(.*)\1 not", r"\1", text )
replacedStr = re.sub(r"th(?P<test_name>is)(.*)\1 not", "\g<test_name>", text )
#全都打印 is a famous bloger.
print (replacedStr) #

如果被匹配的是个函数：

# 将匹配的数字乘以 2
def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)
 
s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s))

#A46G8HFD1134

这是菜鸟上给的例子，确实可以跑，但是之前不知道(?P<value>\d+)可以一次性把句子中所有的数字匹配出来而且统一分组命名为value

re.compile 函数

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。

语法格式为：

re.compile(pattern[, flags])

函数参数说明：

参数	描述
pattern	匹配的正则表达式
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。在最后一小节由详细介绍

将上面使用过的大部分例子使用compile函数进行改写

patter = re.compile("(@@@)([a-z]{3})([0-9]{3})(\*\*\*)")
print(patter.match("@@@asd090***").groups())

patter = re.compile("(.*) smarter (.*) (.*)")
print(patter.match("Cats are smarter than dogs and humans").groups())

patter = re.compile("(.*) smarter (.*?) (.*)")
print(patter.match("Cats are smarter than dogs and humans").groups())

patter = re.compile("\#.*$")
number1 = patter.sub("" ,"2004-959-559 # 这是一个国外电话号码")
print(number1)

patter = re.compile('\D')
number2 = patter.sub("", str(number1))
print(number2)

inputStr = "hello crifan, nihao crifan"
patter = re.compile(r"([a-z].*) (\w+), nihao \2")
replacedStr = patter.sub("crifanli", inputStr)
print (replacedStr) #crifanli

text = "this is tonysure's blog and he is not a famous bloger."
patter = re.compile(r"th(?P<test_name>is)(.*)\1 not",)
replacedStr = patter.sub("\g<test_name>", text )
#此句中 r 表示去掉反斜杠的转移机制
print (replacedStr) #

patter = re.compile('(?P<value>\d+)')
s = 'A23G4HFD567'
print(patter.sub(double, s))

 打印结果如下：

re.compile.findall函数：

回来填之前埋下的另一个坑，findall的另一个版本。其实使用效果差不多。

语法格式为：

findall(string[, pos[, endpos]])

函数参数说明：
 

参数	描述
string	待匹配的字符串。
pos	可选参数，指定字符串的起始位置，默认为 0。
endpos	可选参数，指定字符串的结束位置，默认为字符串的长度。

直接贴例子吧我觉得到现在应该算挺简单的了

pattern = re.compile(r'\d+')   # 查找数字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)
 
print(result1)
print(result2)
#['123', '456']
#['88', '12']

re.finditer

和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

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

函数参数说明：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。在最后一小节由详细介绍

it = re.finditer(r"\d+","12a32bc43jf3") 
for match in it: 
    print (match.group() )
#12 
#32 
#43 
#3

re.split

split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：

re.split(pattern, string[, maxsplit=0, flags=0])

参数：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
maxsplit	分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。在最后一小节由详细介绍

正则表达式修饰符 - 可选标志

就是之前说的flag标志位，正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响 ^ 和 $
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

我把我需要学的东西写的差不多了，可能不是很全可能很浅薄不深刻，但是希望对看完的你有所帮助。感谢阅读。