python正则表达式

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

 

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 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            该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

 

正则表达式模式

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

字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。多数字母和数字前加一个反斜杠时会拥有不同的含义。标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。反斜杠本身需要使用反斜杠转义。由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r'/t'，等价于'//t')匹配相应的特殊字符。

下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。

模式                    描述

^                          匹配字符串的开头

$                          匹配字符串的末尾。

.                            匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。

[...]                       用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'

[^...]                     不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。

re*                      匹配0个或多个的表达式。

re+                      匹配1个或多个的表达式。

re?                      匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式

re{ n}

re{ n,}                 精确匹配n个前面表达式。

re{ n, m}             匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式

a| b                     匹配a或b

(re) G                 匹配括号内的表达式，也表示一个组

(?imx)                正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。

(?-imx)               正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。

(?: re)                 类似 (...), 但是不表示一个组

(?imx: re)          在括号中使用i, m, 或 x 可选标志

(?-imx: re)        在括号中不使用i, m, 或 x 可选标志

(?#...)                注释.

(?= re)             前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。

(?! re)              前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功

(?> re)             匹配的独立模式，省去回溯。

\w                      匹配字母数字

\W                     匹配非字母数字

\s                      匹配任意空白字符，等价于 [\t\n\r\f].

\S                      匹配任意非空字符

\d                      匹配任意数字，等价于 [0-9].

\D                     匹配任意非数字

\A                     匹配字符串开始

\Z                     匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。c

\z                     匹配字符串结束

\G                    匹配最后匹配完成的位置。

\b                     匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。

\B                     匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。

\n, \t,               等. 匹配一个换行符。匹配一个制表符。等

\1...\9              匹配第n个分组的子表达式。

\10                   匹配第n个分组的子表达式，如果它经匹配。否则指的是八进制字符码的表达式。

 

正则表达式实例

 

字符匹配

实例              描述

python         匹配 "python".

字符类

实例             描述

[Pp]ython     匹配 "Python" 或 "python"

rub[ye]         匹配 "ruby" 或 "rube"

[aeiou]         匹配中括号内的任意一个字母

[0-9]              匹配任何数字。类似于 [0123456789]

[a-z]               匹配任何小写字母

[A-Z]              匹配任何大写字母

[a-zA-Z0-9]   匹配任何字母及数字

[^aeiou]        除了aeiou字母以外的所有字符

[^0-9]              匹配除了数字外的字符

特殊字符类

实例              描述

.                    匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。

\d                 匹配一个数字字符。等价于 [0-9]。

\D                 匹配一个非数字字符。等价于 [^0-9]。

\s                  匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。

\S                 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。

\w                 匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。

\W                匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。

 

正则表达式包含一个元字符(metacharacter)的列表，列表值如下:    . ^ $ * + ? { [ ] \ | ( )

　  1.元字符([ ]),它用来指定一个character class。所谓character classes就是你想要匹配的字符(character)的集合.字符(character)可以单个的列出，也可以通过"-"来分隔两个字符来表示一个范围。例如，[abc]匹配a，b或者c当中任意一个字符，[abc]也可以用字符区间来表示---[a-c].如果想要匹配单个大写字母，你可以用[A-Z]。

     元字符(metacharacters)在character class里面不起作用，如[akm$]将匹配"a","k","m","$"中的任意一个字符。在这里元字符(metacharacter)"$"就是一个普通字符。

    2.元字符[^]. 你可以用补集来匹配不在区间范围内的字符。其做法是把"^"作为类别的首个字符；其它地方的"^"只会简单匹配 "^"字符本身。例如，[^5] 将匹配除 "5" 之外的任意字符。同时，在[ ]外，元字符^表示匹配字符串的开始，如"^ab+"表示以ab开头的字符串。

    3. 元字符(\),元字符backslash。做为 Python 中的字符串字母，反斜杠后面可以加不同的字符以表示不同特殊意义。它也可以用于取消所有的元字符，这样你 就可以在模式中匹配它们了。例如，如果你需要匹配字符 "[" 或 "\"，你可以在它们之前用反斜杠来取消它们的特殊意义： \[ 或 \\

    4.元字符($),匹配字符串的结尾或者字符串结尾的换行之前。（在MULTILINE模式下，"$"也匹配换行之前）

   正则表达式"foo"既匹配"foo"又匹配"foobar",而"foo$"仅仅匹配"foo".

    5.元字符(*),匹配0个或多个

    6.元字符(?)，匹配一个或者0个

    7.元字符(+), 匹配一个或者多个

    8,元字符(|), 表示"或"，如A|B，其中A，B为正则表达式，表示匹配A或者B

    9.元字符({})

    10.元字符(  "( )" ),用来表示一个group的开始和结束。

   比较常用的有(REs),(?P<name>REs),这是无名称的组和有名称的group，有名称的group，可以通过matchObject.group(name)获取匹配的group，而无名称的group可以通过从1开始的group序号来获取匹配的组，如matchObject.group(1)。

   11．元字符(.)

　元字符“.”在默认模式下，匹配除换行符外的所有字符。在DOTALL模式下，匹配所有字符，包括换行符。

下面一些re用法：

re.search(string[, pos[, endpos]])

　扫描字符串string，查找与正则表达式匹配的位置。如果找到一个匹配就返回一个MatchObject对象(并不会匹配所有的)。如果没有找到那么返回None。

　第二个参数表示从字符串的那个位置开始，默认是0

　第三个参数endpos限定字符串最远被查找到哪里。默认值就是字符串的长度。.

>>> m=re.search("abcd", '1abcd2abcd')

>>> m.group()  #找到即返回一个match object，然后根据该对象的方法，查找匹配到的结果。

'abcd'

>>> m.start()

1

>>> m.end()

5

　>>> re.findall("abcd","1abcd2abcd")

['abcd', 'abcd']

 

re.findall(pattern, string[, flags])

　以list的形式返回string中所有与pattern匹配的不重叠的字符串。String从左向右扫描，匹配的返回结果也是以这个顺序。

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

找到 RE 匹配的所有子串，并把它们作为一个迭代器返回。这个匹配是从左到右有序地返回。如果无匹配，返回空列表。

>>> it = re.finditer(r"\d+","12a32bc43jf3") 

>>> for match in it: 

              print match.group()

12 

32 

43 

3

finditer返回了一个可调用的对象，使用 for i in finditer()的形式，

可以一个一个的得到匹配返回的 Match对象。这在对每次返回的对象进

行比较复杂的操作时比较有用。

下面接受group的内容：

group([group1,…])

　 返回匹配到的一个或者多个子组。如果是一个参数，那么结果就是一个字符串，如果是多个参数，那么结果就是一个参数一个item的元组。group1的默认值为0(将返回所有的匹配值).如果groupN参数为0，相对应的返回值就是全部匹配的字符串，如果group1的值是[1…99]范围之内的,那么将匹配对应括号组的字符串。如果组号是负的或者比pattern中定义的组号大，那么将抛出IndexError异常。如果pattern没有匹配到，但是group匹配到了，那么group的值也为None。如果一个pattern可以匹配多个，那么组对应的是样式匹配的最后一个。另外，子组是根据括号从左向右来进行区分的。

　>>> m=re.match("(\w+) (\w+)","abcd efgh, chaj")

　>>> m.group()            # 匹配全部

　'abcd efgh'

　>>> m.group(1)     # 第一个括号的子组.

　'abcd'

　>>> m.group(2)

　'efgh'

　>>> m.group(1,2)           # 多个参数返回一个元组

　('abcd', 'efgh')

　>>> m=re.match("(?P<first_name>\w+) (?P<last_name>\w+)","sam lee")

>>> m.group("first_name")  #使用group获取含有name的子组

'sam'

>>> m.group("last_name")

'lee'

 

　下面把括号去掉

　>>> m=re.match("\w+ \w+","abcd efgh, chaj")

　>>> m.group()

　'abcd efgh'

　>>> m.group(1)

　Traceback (most recent call last):

   File "<pyshell#32>", line 1, in <module>

   m.group(1)

　IndexError: no such group

 

　If a group matches multiple times, only the last match is accessible:

   如果一个组匹配多个，那么仅仅返回匹配的最后一个的。

　>>> m=re.match(r"(..)+","a1b2c3")

　>>> m.group(1)

　'c3'

　>>> m.group()

　'a1b2c3'

　Group的默认值为0，返回正则表达式pattern匹配到的字符串

 

　>>> s="afkak1aafal12345adadsfa"

　>>> pattern=r"(\d)\w+(\d{2})\w"

　>>> m=re.match(pattern,s)

　>>> print m

　None

　>>> m=re.search(pattern,s)

　>>> m

　<_sre.SRE_Match object at 0x00C2FDA0>

　>>> m.group()

　'1aafal12345a'

　>>> m.group(1)

　'1'

　>>> m.group(2)

　'45'

　>>> m.group(1,2,0)

　('1', '45', '1aafal12345a')

groups([default])

　返回一个包含所有子组的元组。Default是用来设置没有匹配到组的默认值的。Default默认是"None”,

　>>> m=re.match("(\d+)\.(\d+)","23.123")

　>>> m.groups()

　('23', '123')

　>>> m=re.match("(\d+)\.?(\d+)?","24") #这里的第二个\d没有匹配到，使用默认值"None"

　>>> m.groups()

　('24', None)

　>>> m.groups("0")

　('24', '0')