第十一章 正则表达式

目录

一、正则表达式

1.1 正则表达式的工作流程

1.2 正则表达式模式

1.3 特殊表达式含义

1.3.1 .(点)

1.3.2 \(反斜杠)

1.3.3 [...]方括号

1.3.4 [^...]取反

1.3.5 \d匹配数字

1.3.6 \D匹配非数字

1.3.7 \s匹配任一空白字符

1.3.8 \S匹配任一非空白字符

1.3.9 \w匹配一个字母或数字或下划线

1.3.10 \W匹配非字母或数字或下划线

1.3.11 *(星号)匹配一个字符0次或1次或多次

1.3.12 +(加号)匹配一个字符1次或多次

1.3.13 ?(问号)匹配一个字符0次或1次

1.3.14 {}限定匹配次数

1.3.15 ^(托字符)

1.3.16 $(美元符)

1.3.17 \A仅匹配字符串的开始

1.3.18 \Z匹配字符串结束

1.3.19 \b匹配一个单词的边界

1.3.20 \B匹配非单词边界

1.3.21 |(或)

1.3.22 (...)分组

1.4 编译正则表达式

1.4.1 步骤

1.4.2 re.compile(pattern, flags=0)

1.5 patter对象的属性及方法

1.5.1 flags属性

1.5.2 groups属性

1.5.3 groupindex属性

1.5.4 patter.match()方法

1.5.5 re.match()方法

1.5.6 pattern.search()方法

1.5.7 re.search()方法

1.5.8 findall()方法

1.5.9 pattern.findall()方法

1.5.10 re.findall()方法

1.5.11 finditer()方法

1.5.12 patter.finditer()方法

1.5.13 re.finditer()方法

1.5.14 pattern.split()方法

1.5.15 re.split()方法

1.5.16 pattern.sub()方法

1.5.17 re.sub()方法

1.5.18 pattern.subn()方法

1.5.19 re.subn()方法

1.6 match对象的属性及方法

1.6.1 string属性

1.6.2 re属性

1.6.3 pos属性

1.6.4 endpos属性

1.6.5 lastindex属性

1.6.6 lastgroup属性

1.6.7 group()方法

1.6.8 groups()方法

1.6.9 start()方法

1.6.10 end()方法

1.6.11 span()方法

1.6.12 expand()方法

1.6.13 groupdict()方法

1.7 正则的贪婪性

1.8 正则表达式的修饰符

1.8.1 re.I

1.8,2 re.M

1.8.3 re.S

1.8.4 re.X

1.9 无名分组

1.10 有名分组

1.11 后向引用

1.12 前向肯定断言和后向肯定断言

1.13 前向否定断言和后向否定断言

二、课堂练习

1、使用match找出字符串中的5个数字 

2、匹配1个ip

---

一、正则表达式

正则表达式（regular expression）是一个特殊的字符序列，本身也是一个字符型，描述了一种字符串匹配的模式，可用来检查一个串是否含有某种子串。可以做精确匹配，模糊匹配，进行字符串替换，切割，尤其是在造数据，分析日志时用的非常多。

python中处理正则表达式的模块是re模块，正则表达式由一些普通字符和一些元字符组成，普通字符包括大小写字母、数字和打印符号，而元字符是具有特殊含义的字符。

1.1 正则表达式的工作流程

拿正则表达式依次和字符串或者文本中的字符串做比较，如果每一个字符都匹配，则匹配成功，只要有一个匹配不成功的字符，则匹配不成功

1.2 正则表达式模式

模式字符串使用特殊的语法来表示一个正则表达式：

• 字母和数字匹配它们自身；
• 多数字母和数字前加一个反斜杠（\）时会有特殊含义；
• 特殊的标点符号，只有被转义以后才能匹配自身；
• 反斜杠本身要用反斜杠来转义

  注意：

1. 由于正则表达式通常版本反斜杠等特殊字符，所以最好使用原始字符串来表示他们。如：r’\d’等价于’\\d’，表示匹配一个数字
2. 正则表达式中数量词默认都是贪婪的，会尽可能多的去匹配满足的字符串，但是如果在后面加上问号’?’，就可以屏蔽贪婪模式，表示匹配尽可能少的字符。如：’xyyyyzs’,使用正则’xy*’,就会得到'xyyyy'，如果使用’xy*?’,会得到'x'

>>> import re
>>> p = re.compile("xy*")
>>> result = p.match("xyyyyzs")
>>> result.group()
'xyyyy'
>>> p = re.compile("xy*?")
>>> result = p.match("xyyyyzs")
>>> result.group()
'x'

1.3 特殊表达式含义

符号	含义	举例
一般字符（匹配自身）
.（点）	匹配除换行符之外的任意一个字符，DOTALL模式中可以匹配换行符	a.c可以匹配abc
\（反斜杠）	转义一个特殊的字符，使这个字符表示原来字面上的意思。如"\$"，表示原字符$，而不是正则表达式中表示匹配行尾的意思。	a\.c匹配a.c
预定义字符集（可以写在[]中）
[...] 方括号	匹配括号中出现的任意单个字符	a[123]b匹配a1b、a2b、a3b、a12b等
[^...]	不匹配方括号中列出的单个字符（注意只能针对单个字符）	[^ab]匹配除a和b之外的字符
\d	匹配中任意一个数字，范围为[0-9]	a\dc可以匹配a1c、a2c等
\D	匹配任意一个非数字字符，等价于[^\d]	1\D2可匹配1a2
\s	匹配任意一个空白字符：[<空格>\t\r\n\v\f]	a\sf匹配a f
\S	匹配任意一个非空白字符，等价于[^\s]	a\Sg匹配agg等
\w	匹配一个字母或数字，字符范围：[A-Za-z0-9]	1\wt可以匹配1at等
\W	非单词字符，等价于[^\w]	a\Wb可以匹配a@b等
数量字符集（用在字符或分组符(...)之后，非贪婪匹配*? +?）
*（星号）	匹配前一个字符0次1次或多次	abc*可以匹配ab、abc、abcc等
+（加号）	匹配前一个字符1次或多次	cde+可匹配cde、cde等
?（问号）	匹配前一个字符0次或1次	fgh?匹配结果fg、fgh
{m}	匹配前一个字符m次	qc{3}匹配结果qccc
{m,n}	匹配前一个字符m到n次 {m,}匹配前一个字符至少m次 {,n}匹配前一个字符0到n次，最多n次	1{2,5}ac匹配结果11ac、111ac、1111ac、11111ac
边界匹配符
^（托字符）	匹配字符串开头，如果是多行则匹配每一行的开头。在[...]中，^表示否定，如非字母[^a-zA-Z]，非数字[^0-9]	^123匹配123 a[^0-9]b可匹配aab等
$（美元符）	匹配字符串或一行的结尾，如果是多行则匹配每一行的结尾	abc$匹配abc
\A	匹配字符串开始，如果存在换行，将字符当作一个整体	\A12AC匹配12AC
\b	匹配单词的边界，一个\w和\W间的范围，顺序可逆	\bst匹配a test中的'st'，但不匹配'tester'中的''st
\B	[^\b]，表示匹配非单词边界	\Bst可以匹配'tester'而不能匹配'test'
\Z	匹配字符串结束，如果存在换行，将字符当作一个整体	abt\Z匹配abt
逻辑匹配符
|（或）	|或匹配符，表达左右正则表达式任意匹配一个。如果左边的表达式匹配上了，匹配结束，不再匹配右边的表达式。该符号一般放在()中使用，如果没在圆括号中则它的范围是整个正则表达式。	(12|34)匹配12或34
分组匹配
(...)	后向引用。用()括起来的正则表达式将被作为一个分组，从正则表达式的左边依次算起，有多少个左括号'('，就有多少个分组，分组的编码从1依次加1，无论是括号中嵌套括号。并且分组表达式作为一个整体，后可接数量词。	(xyz){2}满足xyzxyz x(12|34)y匹配x12y或x34y
\<number>	引用分组匹配到的分组编号为<number>的字符串	如：\1...\9
(?P<name>...)	命名分组，除了默认的分组编号外再指定一个别名分组 注意：P是大写
(?P=name)	引用别名为name的分组匹配，这个是在正则表达式中引用，表示匹配重复的字符串，也可以使用编号引用。 注意：P是大写
特殊匹配符（不能作为分组使用）
(?:...) 类似 (...), 但是不表示一个组
(?!pattern)	前向否定断言语法，表示否定开头。只能用在正则表达式的开头，pattern是匹配模式，它后面的内容需要不匹配该正则表达式才匹配成功。
(?<!pattern)	后向否定断言语法，表示否定结尾，前面的内容需要不匹配该pattern模式才匹配成功。
(?=pattern)	前向肯定断言语法，需要匹配pattren模式才能匹配成功，表示肯定前面的字符内容。
(?<=pattern)	后向肯定断言语法，需要匹配pattern模式才能匹配成功，表示肯定后面的字符内容。
(?#...)	#后面的内容将被作为注释而忽略

总结：
1、正则前面必须加r，这样\d \s \w \b才会有特殊正则含义
2、如果不加r，\d \s \w \b全部会被当做\+字母去匹配，失去了正则模糊匹配的功能

>>> print(re.match(r"a\b","a"))#\b当做边界去匹配
<re.Match object; span=(0, 1), match='a'>
>>> print(re.match("a\b","a"))#此时匹配不到结果
None
>>> print(re.match("a\b","a\b"))#\b当做\+b去匹配，没有匹配边界的能力
<re.Match object; span=(0, 2), match='a\x08'>