python正则表达式

正则表达式基础

语法

• 普通字符：

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

  • [ABC]：匹配 [...] 中的所有字符，例如 [aeiou] 匹配字符串 "google runoob taobao" 中所有的 e o u a 字母

  • ¹：匹配除了 [...] 中字符的所有字符，例如 ² 匹配字符串 "google runoob taobao" 中除了 e o u a 字母的所有字母

  • [A-Z]：[A-Z] 表示一个区间，匹配所有大写字母，[a-z] 表示所有小写字母

  • . ：匹配除换行符**（\n、\r）之外的任何单个字符，相等于[ ^\n\r]**

  • [\s\S]：匹配所有。\s 是匹配所有空白符，包括换行，\S 非空白符，不包括换行

  • \w：匹配字母、数字、下划线。等价于 [A-Za-z0-9_]

• 非打印字符：

• • 非打印字符也可以是正则表达式的组成部分。下表列出了表示非打印字符的转义序列

  • \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

• 特殊字符：

• • $：匹配输入字符串的结尾位置。要匹配 **** 字符本身，请使用 \$

  • ( )：标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 ( 和 )

  • *****：匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 *

  • +：匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 +

  • . ：匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 .

  • [：标记一个中括号表达式的开始。要匹配 [，请使用 [

  • ?：匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 ?

  • \：将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\' 匹配 ""，而 '(' 则匹配 "("

  • ^：匹配输入字符串的开始位置，除非在方括号表达式中使用，当该符号在方括号表达式中使用时，表示不接受该方括号表达式中的字符集合。要匹配 ^ 字符本身，请使用 ^

  • {：标记限定符表达式的开始。要匹配 {，请使用 {

  • |：指明两项之间的一个选择。要匹配 |，请使用 |

• 限定符：

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

  • ：匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。**** 等价于 {0,}

  • +：匹配前面的子表达式一次或多次。例如，zo+ 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}

  • ?：匹配前面的子表达式零次或一次。例如，do(es)? 可以匹配 "do" 、 "does"、 "doxy" 中的 "do" 。? 等价于 {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?。请注意在逗号和两个数之间不能有空格

• 定位符：

• • 定位符能够将正则表达式固定到行首或行尾。它们还能够创建这样的正则表达式，这些正则表达式出现在一个单词内、在一个单词的开头或者一个单词的结尾。
  • ^：匹配输入字符串开始的位置
  • ****：匹配输入字符串结尾的位置
  • \b：匹配一个单词边界，即字与空格间的位置
  • \B：非单词边界匹配
  • 注意：不能将限定符与定位符一起使用。由于在紧靠换行或者单词边界的前面或后面不能有一个以上位置，因此不允许诸如 ^* 之类的表达式

• 选择：

• • 用圆括号 () 将所有选择项括起来，相邻的选择项之间用 | 分隔

修饰符/标记

• 标记也称为修饰符，正则表达式的标记用于指定额外的匹配策略。

  标记不写在正则表达式里，标记位于表达式之外，格式如下

  /pattern/flags
  

• i：ignore - 不区分大小写，

• g：global - 全局匹配

• m：multiline - 多行匹配

• s：特殊字符圆点 . 中包含换行符 \n

元字符（重要）

下表包含了元字符的完整列表以及它们在正则表达式上下文中的行为

运算符优先级

下表从最高到最低说明了各种正则表达式运算符的优先级顺序

匹配规则

基本模式匹配

一切从最基本的开始。模式，是正则表达式最基本的元素，它们是一组描述字符串特征的字符。模式可以很简单，由普通的字符串组成，也可以非常复杂，往往用特殊的字符表示一个范围内的字符、重复出现，或表示上下文。例如：

^once

这个模式包含一个特殊的字符 ^，表示该模式只匹配那些以 once 开头的字符串。例如该模式与字符串 "once upon a time" 匹配，与 "There once was a man from NewYork" 不匹配。正如如 ^ 符号表示开头一样，**** 符号用来匹配那些以给定模式结尾的字符串。

bucket$

这个模式与 "Who kept all of this cash in a bucket" 匹配，与 "buckets" 不匹配。字符 ^ 和 **$\ast \ast 同时使用时，表示精确匹配（字符串与模式一样）。例如：‘‘{‘}^{b}ucket$

只匹配字符串 **"bucket"**。如果一个模式不包括 **^** 和 **$**，那么它与任何包含该模式的字符串匹配。例如模式：

once

与字符串

There once was a man from NewYork Who kept all of his cash in a bucket.

是匹配的。

在该模式中的字母 **(o-n-c-e)** 是字面的字符，也就是说，他们表示该字母本身，数字也是一样的。其他一些稍微复杂的字符，如标点符号和白字符（空格、制表符等），要用到转义序列。所有的转义序列都用反斜杠 **\\** 打头。制表符的转义序列是 **\t**。所以如果我们要检测一个字符串是否以制表符开头，可以用这个模式：

^\t

类似的，用 **\n** 表示**"新行"**，**\r** 表示回车。其他的特殊符号，可以用在前面加上反斜杠，如反斜杠本身用 **\\\\** 表示，句号 **.** 用 **\\.** 表示，以此类推。

#### 字符簇

在 INTERNET 的程序中，正则表达式通常用来验证用户的输入。当用户提交一个 FORM 以后，要判断输入的电话号码、地址、EMAIL 地址、信用卡号码等是否有效，用普通的基于字面的字符是不够的。

所以要用一种更自由的描述我们要的模式的办法，它就是字符簇。要建立一个表示所有元音字符的字符簇，就把所有的元音字符放在一个方括号里：

[AaEeIiOoUu]

这个模式与任何元音字符匹配，但只能表示一个字符。用连字号可以表示一个字符的范围，如：

[a-z] // 匹配所有的小写字母 [A-Z] // 匹配所有的大写字母 [a-zA-Z] // 匹配所有的字母 [0-9] // 匹配所有的数字 [0-9.-] // 匹配所有的数字，句号和减号 [ \f\r\t\n] // 匹配所有的白字符

同样的，这些也只表示一个字符，这是一个非常重要的。如果要匹配一个由一个小写字母和一位数字组成的字符串，比如 "z2"、"t6" 或 "g7"，但不是 "ab2"、"r2d3" 或 "b52" 的话，用这个模式：

^[a-z][0-9]

尽管 **[a-z]** 代表 26 个字母的范围，但在这里它只能与第一个字符是小写字母的字符串匹配。

前面曾经提到^表示字符串的开头，但它还有另外一个含义。当在一组方括号里使用 **^** 时，它表示"**非**"或"**排除**"的意思，常常用来剔除某个字符。还用前面的例子，我们要求第一个字符不能是数字：

^[^0-9][0-9]

这个模式与 "&5"、"g7"及"-2" 是匹配的，但与 "12"、"66" 是不匹配的。下面是几个排除特定字符的例子：

⁴ //除了小写字母以外的所有字符 ⁵ //除了()(/)(^)之外的所有字符 ⁶ //除了双引号(")和单引号(')之外的所有字符

特殊字符 **.**(点，句号)在正则表达式中用来表示除了"新行"之外的所有字符。所以模式 **^.5$** 与任何两个字符的、以数字5结尾和以其他非"新行"字符开头的字符串匹配。模式 **.** 可以匹配任何字符串，**换行符（\n、\r）除外**。

PHP的正则表达式有一些内置的通用字符簇，列表如下：

| 字符簇       | 描述                                |
| :----------- | :---------------------------------- |
| [[:alpha:]]  | 任何字母                            |
| [[:digit:]]  | 任何数字                            |
| [[:alnum:]]  | 任何字母和数字                      |
| [[:space:]]  | 任何空白字符                        |
| [[:upper:]]  | 任何大写字母                        |
| [[:lower:]]  | 任何小写字母                        |
| [[:punct:]]  | 任何标点符号                        |
| [[:xdigit:]] | 任何16进制的数字，相当于[0-9a-fA-F] |



#### 确定重复出现

到现在为止，你已经知道如何去匹配一个字母或数字，但更多的情况下，可能要匹配一个单词或一组数字。一个单词有若干个字母组成，一组数字有若干个单数组成。跟在字符或字符簇后面的花括号({})用来确定前面的内容的重复出现的次数。

| 字符簇           | 描述                            |
| :--------------- | :------------------------------ |
| ^[a-zA-Z_]$      | 所有的字母和下划线              |
| ^[[:alpha:]]{3}$ | 所有的3个字母的单词             |
| ^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}             | 所有的两个字符                  |

这些例子描述了花括号的三种不同的用法。一个数字 **{x}** 的意思是**前面的字符或字符簇只出现x次** ；一个数字加逗号 **{x,}** 的意思是**前面的内容出现x或更多的次数** ；两个数字用逗号分隔的数字 **{x,y}** 表示 **前面的内容至少出现x次，但不超过y次**。我们可以把模式扩展到更多的单词或数字：

^[a-zA-Z0-9_]{1,}$//所有包含一个以上的字母、数字或下划线的字符{串}^{[}1-9][0-9]0,$ // 所有的正整数 ^-{0,1}[0-9]{1,}$//所有的整{数}^{[}-]?[0-9]+\dot{?}[0-9]+$ // 所有的浮点数

最后一个例子不太好理解，是吗？这么看吧：以一个可选的负号 (**[-]?**) 开头 (**^**)、跟着1个或更多的数字(**[0-9]+**)、和一个小数点(**\.**)再跟上1个或多个数字**([0-9]+**)，并且后面没有其他任何东西(**$**)。下面你将知道能够使用的更为简单的方法。

特殊字符 **?** 与 **{0,1}** 是相等的，它们都代表着： **0个或1个前面的内容** 或 **前面的内容是可选的** 。所以刚才的例子可以简化为：

^-?[0-9]{1,}.?[0-9]{1,}$‘‘‘特殊字符\ast \ast \ast \ast \ast 与\ast \ast 0,\ast \ast 是相等的，它们都代表着\ast \ast 0个或多个前面的内容\ast \ast 。最后，字符\ast \ast +\ast \ast 与\ast \ast 1,\ast \ast 是相等的，表示\ast \ast 1个或多个前面的内容\ast \ast ，所以上面的4个例子可以写成：‘‘{‘}^{[}a-zA-Z0-9_{]}+$ // 所有包含一个以上的字母、数字或下划线的字符串 ^[1-9][0-9]* // 所有的正整数 ^-?[0-9]+ // 所有的整数 ^[-]?[0-9]+(.[0-9]+)? // 所有的浮点数

当然这并不能从技术上降低正则表达式的复杂性，但可以使它们更容易阅读



## python re模块



```python
import re

re.match函数

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match() 就返回 none

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

函数参数说明：

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

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

import re

### match 实例
print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配
print(re.match('com', 'www.runoob.com'))         # 不在起始位置匹配

# 输出为
# (0, 3)
# None

### group 实例
line = "Cats are smarter than dogs"
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
if matchObj:
   print "matchObj.group() : ", matchObj.group()
   print "matchObj.group(1) : ", matchObj.group(1)
   print "matchObj.group(2) : ", matchObj.group(2)
else:
   print "No match!!"

# 输出为
# matchObj.group() :  Cats are smarter than dogs
# matchObj.group(1) :  Cats
# matchObj.group(2) :  smarter

re.research 函数

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

函数语法：

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

函数参数说明：

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

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

import re

# search实例
print(re.search('www', 'www.runoob.com').span())  # 在起始位置匹配
print(re.search('com', 'www.runoob.com').span())  # 不在起始位置匹配

# 输出为
# (0, 3)
# (11, 14)

# group实例
line = "Cats are smarter than dogs";
searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)
if searchObj:
   print "searchObj.group() : ", searchObj.group()
   print "searchObj.group(1) : ", searchObj.group(1)
   print "searchObj.group(2) : ", searchObj.group(2)
else:
   print "Nothing found!!"

# 输出为
# searchObj.group() :  Cats are smarter than dogs
# searchObj.group(1) :  Cats
# searchObj.group(2) :  smarter

re.match与re.search的区别

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配

re.sub 检索和替换

语法：

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

参数：

• pattern : 正则中的模式字符串。
• repl : 替换的字符串，也可为一个函数。
• string : 要被查找替换的原始字符串。
• count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

import re

phone = "2004-959-559 # 这是一个国外电话号码"

# 删除字符串中的 Python注释 
num = re.sub(r'#.*', "", phone)
print "电话号码是: ", num

# 删除非数字(-)的字符串 
num = re.sub(r'\D', "", phone)
print "电话号码是 : ", num

# 输出为
# 电话号码是:  2004-959-559 
# 电话号码是 :  2004959559

repl 参数可以是一个函数

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

# 输出为
# A46G8HFD1134

re.compile

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

re.compile(pattern[, flags])

参数：

• pattern : 一个字符串形式的正则表达式
• flags : 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：
  1. re.I 忽略大小写
  2. re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
  3. re.M 多行模式
  4. re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
  5. re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
  6. re.X 为了增加可读性，忽略空格和 # 后面的注释

>>>import re
>>> pattern = re.compile(r'\d+')                    # 用于匹配至少一个数字
>>> m = pattern.match('one12twothree34four')        # 查找头部，没有匹配
>>> print m
None
>>> m = pattern.match('one12twothree34four', 2, 10) # 从'e'的位置开始匹配，没有匹配
>>> print m
None
>>> m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配
>>> print m                                         # 返回一个 Match 对象
<_sre.SRE_Match object at 0x10a42aac0>
>>> m.group(0)   # 可省略 0
'12'
>>> m.start(0)   # 可省略 0
3
>>> m.end(0)     # 可省略 0
5
>>> m.span(0)    # 可省略 0
(3, 5)

findall

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表

注意： match 和 search 是匹配一次 findall 匹配所有

参数：

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

import re
 
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']