Python正则表达式
在说Python正则表达式的运用前先讲下正则表达式的一些知识，方面大家理解。
正则表达式
正则表达式描述了一种字符串匹配的模式，可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。正则表达式的应用很常见，像手机号、身份证、邮箱的校验以及应对日常编程开发遇到的文本处理工作。
普通字符、非打印字符和特殊字符：
普通字符：
普通字符包括没有显式指定为元字符的所有可打印和不可打印字符。这包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号。
非打印字符：
非打印字符也可以是正则表达式的组成部分。
| 字符 | 描述 |
|---|---|
| \cx | 匹配由x指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 ‘c’ 字符。记法：control x—>控制某字符 |
| \f | 匹配一个换页符。等价于 \x0c 和 \cL。记法：页–叶 leaf—>f |
| \n | 匹配一个换行符。等价于 \x0a 和 \cJ。 记法：行—line—>n |
| \r | 匹配一个回车符。等价于 \x0d 和 \cM。 记法：回车—>回去—>return—>r |
| \s | 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。注意 Unicode 正则表达式会匹配全角空格符。记法：空白—>天是白的—>sky---->s |
| \S | 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。 |
| \t | 匹配一个制表符。等价于 \x09 和 \cI。 记法：表格—>table—>t |
| \v | 匹配一个垂直制表符。等价于 \x0b 和 \cK。记法：垂直—>vertical—>v |
特殊字符：
所谓特殊字符，就是一些有特殊含义的字符
许多元字符要求在试图匹配它们时特别对待。若要匹配这些特殊字符，必须首先使字符"转义"，即，将反斜杠字符\放在它们前面。下表列出了正则表达式中的特殊字符：
| 特别字符 | 描述 |
|---|---|
| $ | 匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 ‘\n’ 或 ‘\r’。要匹配 $ 字符本身，请使用 \$。 |
| ( ) | 标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 \( 和 \)。 |
| * | 匹配前面的子表达式零次或多次。要匹配 * 字符，请使用\*。记法：0*1 =0 |
| + | 匹配前面的子表达式一次或多次。要匹配 + 字符，请使用\+。记法：0+1 = 1 |
| . | 匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 \.。 |
| [ | 标记一个中括号表达式的开始。要匹配 [，请使用 \[。 |
| ? | 匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 \?。 |
| \ | 将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， ‘n’ 匹配字符 ‘n’。’\n’ 匹配换行符。序列 ‘\’ 匹配 “”，而 ‘(’ 则匹配 “(”。 |
| ^ | 匹配输入字符串的开始位置（除非在方括号表达式中使用），当该符号在方括号表达式中使用时，表示不接受该方括号表达式中的字符集合。要匹配 ^ 字符本身，请使用 \^。 |
| { | 标记限定符表达式的开始。要匹配 {，请使用 \{。 |
| | | 指明两项之间的一个选择。要匹配 |，请使用\|。 |
元字符：
限定符
限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。有 ***** 或 + 或 ? 或 {n} 或 {n,} 或 {n,m} 共6种。
| 字符 | 描述 |
|---|---|
| * | 匹配前面的子表达式零次或多次。例如，zo* 能匹配 “z” 以及 “zoo”。*** 等价于{0,}**。 |
| + | 匹配前面的子表达式一次或多次。例如，‘zo+’ 能匹配 “zo” 以及 “zoo”，但不能匹配 “z”。+ 等价于 {1,}。 |
| ? | 匹配前面的子表达式零次或一次。例如，“do(es)?” 可以匹配 “do” 、 “does” 中的 “does” 、 “doxy” 中的 “do” 。? 等价于 {0,1}。 |
| {n} | n 是一个非负整数（>=0）。匹配前面的表达式确定的 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?’。请注意在逗号和两个数之间不能有空格。 |
举几个例子：
/[1-9][0-9]*/：匹配大于0的所有数字
/[1-9][0-9]?/：匹配1-99的所有数字，等价于/[1-9][0-9]{0,1}/
`*、+ 限定符都是贪婪的，因为它们会尽可能多的匹配文字，只有在它们的后面加上一个?就可以实现非贪婪或最小匹配。
定位符
即定位正则表达式匹配的位置。定位符与限定符不能一起使用！
| 字符 | 描述 |
|---|---|
| ^ | 匹配输入字符串开始的位置。 |
| $ | 匹配输入字符串结尾的位置。 |
| \b | 匹配一个单词边界。正则表达式利用了单词边界是单词和空格之间的位置来进行匹配，例如/\bABC/是在单词的开始处查找匹配项，/ABC\b/实在单词结尾处开始查找匹配项，因此\b需要注意匹配位置。 |
| \B | 匹配非单词边界。非单词边界，那么就是单词的内部（中间部分），例如/\BAbcd/会匹配单词sdAbcdefg中的Abcd。因此\B不关心匹配位置，只要在单词内部就行。 |
其他元字符
| 字符 | 描述 |
|---|---|
| [abc] | 字符集合，匹配所包含的任意一个字符。并不是匹配abc哦！ |
| [^abc] | 匹配未包含的任意一个字符。 |
| [a-z] | 匹配指定范围内的任意字符。（若要匹配连字符-，需要将-放在中括号开头或结尾，即[-a-z]或[a-z-） |
| [^a-z] | 匹配任何不在指定范围内的任意字符。 |
| \d | 匹配一个数字字符。 |
| \D | 匹配一个非数字字符。小技巧，往往变为大写的元字符都是对小写取非 |
| \w | 匹配字母、数字、下划线。等价于'[A-Za-z0-9_]' |
| \W | 匹配非字母、数字、下划线。等价于'[^A-Za-z0-9_]' |
| \xn | 匹配 n，其中 n 为十六进制转义值，即\x43匹配’C’。 |
| \num | 匹配 num，其中 num 是一个正整数。例如，’(.)\1’ 匹配两个连续的相同字符。 |
| (?imx:) | 在括号中使用i, m, 或 x 可选标志 |
| (?-imx: ) | 在括号中不使用i, m, 或 x 可选标志 |
运算符优先级：
正则表达式从左到右进行计算。
| 运算符 | 描述 |
|---|---|
| \ | 转义符 |
| (), (?: ), (?=), [] | 圆括号和方括号 |
| *, +, ?, {n}, {n,}, {n,m} | 限定符 |
| ^, $, \任何元字符、任何字符 | 定位点和序列 |
| | | 选择操作符 |
实例：
^[a-zA-Z0-9_]{1,}$ // 所有包含一个以上的字母、数字或下划线的字符串
^[1-9][0-9]{0,}$ // 所有的正整数,等价于 ^[1-9][0-9]*$
^\-{0,1}[0-9]{1,}$ // 所有的整数,等价于^\-{0,1}[0-9]+$
^[-]?[0-9]+\.?[0-9]+$ // 所有的浮点数
/(\w+):\/\/([^/:]+)(:\d*)?([^# ]*)/ //将一个URL解析为协议、域、端口及相对路径。
/<\s*(\S+)(\s[^>]*)?>[\s\S]*<\s*\/\1\s*>/ //匹配 HTML 标记。
分组与捕获
- 分组可以分为两种形式：捕获组和非捕获组
捕获组：
捕获组可以从左到右计算其开括号来编号：(a)((b)(c(d)))
那么(a)在时第一个括号，分为组1，其次为((b)(c(d)))、(b)、(c(d))、(d)，而组(a)((b)(c(d)))为组0，组零始终代表整个表达式。
之所以这样命名捕获组是因为在匹配中，保存了与这些组匹配的输入序列的每个子序列。捕获的子序列稍后可以通过 Back 引用（反向引用） 在表达式中使用，也可以在匹配操作完成后从匹配器检索。
非捕获组：
以 (?) 开头的组是纯的非捕获组，它不捕获文本 ，也不针对组合计进行计数。
相比较捕获组，非捕获组不会将匹配到的内容存放起来，节省了内存。
- (?:pattern)：匹配Pattern字符，不捕获文本，不将匹配到的字符存储到内存中,也就是说这是一个非获取匹配。
industr(?:y|ies)可以匹配industry或industries，等价于industry|industries
- (?=pattern)：零宽度正先行断言。仅当子表达式 pattern在此位置的右侧匹配时才继续匹配，即在任何匹配pattern的字符串开始处匹配查找字符串
- (?!pattern)：零宽度负先行断言。仅当子表达式pattern不在此位置的右侧匹配时才继续匹配，即在任何不匹配pattern的字符串开始处匹配查找字符串。
- (?<=pattern)：零宽度正后发断言。仅当子表达式pattern在此位置的左侧匹配时才继续匹配，与零宽度正先行断言类似，只是方向相反。
- (?<!pattern)：零宽度负后发断言。仅当子表达式pattern不在此位置的左侧匹配时才继续匹配，与零宽度负先行断言类似，只是方向相反。
因此上述1、3对应，2、4对应。
举个例子：
(?<!4)56(?=9)：匹配后面的文本56前面不能是4，后面必须是9组成。因此，可以匹配如下文本 5569 ，与4569不匹配。
(?<=[^c]a)\d*(?=bd)：匹配包含在字符a和b之间的数字，但是这个a之前的字符不能是c；b后面的字符必须是d。
模式修正符
则表达式中常用的模式修正符有i、g、m、s、x、e等。它们之间可以组合搭配使用。
| 修正符 | 描述 |
|---|---|
| I | 不区分大小写的匹配，例如/abc/i可以与abc或aBC或ABc等匹配 |
| g | 表示全局匹配 |
| M | 将字符串视为多行,不管是那行都能匹配(multiple line) |
| S | 将字符串视为单行,换行符作为普通字符(single line) |
| X | 将模式中的空白忽略 |
| A | 强制从目标字符串开头匹配 |
| D | 如果使用$限制结尾字符,则不允许结尾有换行，例/abc/D不能与"adshabc\n"匹配 |
| U | 只匹配最近的一个字符串，不重复匹配，类似于非贪婪? |
| e | 配合函数preg_replace()使用 |
Python正则表达式使用
Python的re模块使 拥有全部的正则表达式功能。
compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。
正则表达式处理函数
-
re.match(pattern, string, flags=0)：re.match 尝试从字符串的起始位置匹配一个模式
- pattern：匹配的正则表达式
- string：要匹配的字符串
- flags：标志位，用于控制正则表达式的匹配方式，即修饰符
若匹配成功，则返回一个匹配的对象，否则返回None
可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
方法 描述 group(num=0) 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。 groups() 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。 看一个实例：
import re str = 'Hey Gril ! I love you so much!' match = re.match(r'(.*) love (.*?) .*',str,re.M|re.I) #()捕获组 if match: #如果捕获到了 print ("group(0) : ", match.group()) #如前面所讲，捕获组0代表整个表达式,默认值为0 print ("group(1) : ", match.group(1)) #打印捕获组1 print ("group(2) : ", match.group(2)) #打印捕获组2 ''' group(0) : Hey Gril ! I love you so much! group(1) : Hey Gril ! I group(2) : you ''' -
re.search(pattern, string, flags=0)：re.search 扫描整个字符串并返回第一个成功的匹配。
参数通上re.match()
同上我们也可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
import re print(re.match('you','I love you')) #找不到，因为只能从起始位置可以找 print(re.search('you','I love you')) #可以找到，因为时搜索整个字符串 print(re.search('you','I love you').span()) ''' None <re.Match object; span=(7, 10), match='you'> (7, 10) '''import re str = 'Hey Gril ! I love you so much!' match = re.search(r'(.*) love (.*?) .*',str,re.M|re.I) if match: #如果捕获到了 print ("group(0) : ", match.group()) #如前面所讲，捕获组0代表整个表达式，默认值为0 print ("group(1) : ", match.group(1)) #打印捕获组1 print ("group(2) : ", match.group(2)) #打印捕获组2 '' group(0) : Hey Gril ! I love you so much! group(1) : Hey Gril ! I group(2) : you ''' -
re.sub(pattern, repl, string, count=0, flags=0)：用于替换字符串中的匹配项
- pattern：正则表达式中的模式字符串。
- repl ：替换的字符串，也可以为一个函数
- string：要被查找替换的原始字符串
- count：模式匹配后替换的最大次数，默认值为0，表示替换所有匹配
- flags：编译时用的匹配模式，数字形式
例子：
import re str = "110-119-120 #紧急电话" num = re.sub(r'#.*$',"",str) print(num) num = re.sub(r'\D', "",str) print(num) ''' 110-119-120 110119120 ''' -
re.compile(pattern[, flags])：compile 函数用于编译正则表达式，生成一个正则表达式re.RegexObject对象，提供给match() 和 search() 函数使用。
- pattern：一个字符串形式的正则表达式
- flags：匹配模式
import re pattern = re.compile(r'\d+') m = pattern.match('one12twothree34four') print(m) m = pattern.match('one12twothree34four',2,10) print(m) m = pattern.match('one12twothree34four',3,10) print(m) print(m.group(0)) print(m.start(0))# 获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引） print(m.end(0))# 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1） print(m.span(0))# 方法返回 (start(group), end(group)) ''' None None <re.Match object; span=(3, 5), match='12'> 12 3 5 (3, 5) ''' -
re.findall(string, pos, endpos)：从字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。
- string：待匹配字符串
- pos：可选参数，指定字符串的起始位置，默认为0
- endpos：可选参数，指定字符串的结束位置，默认为字符串的长度
import re pattern = re.compile(r'[a-z]+') m1 = pattern.findall('one12twothree34four') print(m1) m2= pattern.findall('one12twothree34four',4,10) print(m2) ''' ['one', 'twothree', 'four'] ['twoth'] ''' -
re.finditer(pattern, string, flags=0)：在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。是以迭代器返回
参数同
re.match()import re pattern = re.compile(r'[a-z]+') m1 = pattern.finditer('one12twothree34four') for i in m1: print(i.group()) print('-------------') m2= pattern.finditer('one12twothree34four',4,10) for i in m2: print(i.group()) ''' one twothree four ------------- twoth ''' -
**re.split(pattern, string[, maxsplit=0, flags=0])：**按照能够匹配的子串将字符串分割后返回列表
- pattern：匹配的正则表达式
- string：要匹配的字符串
- maxsplit：分隔次数，默认为0，不限制次数，有就分割
- flags：匹配方式
import re print(re.split(r'[0-1]+','one12twothree34four')) print(re.split(r'o','one12twothree34four')) ''' ['one', '2twothree34four'] ['', 'ne12tw', 'three34f', 'ur'] '''