一、简介

1.1、相关链接

官方文档：

Python2：https://docs.python.org/2/library/re.html

Python3：https://docs.python.org/3/library/re.html

HOWTO：

Python2：https://docs.python.org/2/howto/regex.html

Python3：https://docs.python.org/3/howto/regex.html

二、函数详解

2.1、正则匹配的基本事项

  • 函数中使用参数标识：

参数

描述

pattern

匹配的正则表达式

string

要匹配的字符串。

flags

标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
  • 函数中flags取值：

Flag

Meaning

DOTALL, S

Make . match any character, including newlines

使 . 匹配包括换行在内的所有字符

IGNORECASE, I

Do case-insensitive matches

使匹配对大小写不敏感

LOCALE, L

Do a locale-aware match

做本地化识别（locale-aware）匹配

MULTILINE, M

Multi-line matching, affecting ^ and $

多行匹配，影响 ^ 和 $

VERBOSE, X

Enable verbose REs, which can be organized more cleanly and understandably.

该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

UNICODE, U

Makes several escapes like \w, \b, \s and \d dependent on the Unicode character database.

根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
  • 正则表达式的通配符表示含义：

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

字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。

多数字母和数字前加一个反斜杠时会拥有不同的含义。

标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。

反斜杠本身需要使用反斜杠转义。

由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r'\t'，等价于 '\\t')匹配相应的特殊字符。

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

模式

描述

^

匹配字符串的开头

$

匹配字符串的末尾。

.

匹配除了换行符(\n)的任意字符，当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

匹配字母数字及下划线，等价于'[A-Za-z0-9_]'。

\W

匹配非字母数字及下划线，等价于 '[^A-Za-z0-9_]'。

\s

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

\S

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

\d

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

\D

匹配任意非数字，等价于 [^0-9]。

\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个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

2.2、常用函数

以下是re模块常用的七个函数：

函数名

含义

实例

re.compile()

将正则表达式模式编译成一个正则表达式对象，它可以用于匹配使用它的match ()和search ()方法，如下所述。

可以通过指定flags值修改表达式的行为。值可以是任何以下变量，使用组合 OR （ |运算符）。

但使用re.compile()和保存所产生的正则表达式对象重用效率更高时该表达式会在单个程序中多次使用。

语法：compile(pattern, flags=0)

>>> s = '[a-z]+\d*'

>>> a = re.compile(s)

>>> a

<_sre.SRE_Pattern object at 0x0000000003308738>

>>> type(a)

<type '_sre.SRE_Pattern'>

>>> b = a.match('a123')

>>> b.group()

'a123'

等价于：

>>> b = re.match('[a-z]+\d*', 'a123')

>>> b.group()

'a123'

re.escape()

返回的字符串与所有非字母数字带有反斜杠；这是有用的如果你想匹配一个任意的文本字符串，在它可能包含正则表达式元字符

简单理解：把字符串按照可能会是正则表达式来理解，这样就需要把特殊字符都转义。这样才能方便匹配时精确匹配每个字符。

字符'[a-z]'这个字符串可以看作是正则表达式的模式，这样就不能作为被匹配的字符串。如果想把这个字符串作为被匹配的模式就需要转义这些特殊字符。print(re.escape('[a-z]'))

\[a\-z\]

语法：escape(pattern)

>>> s = 'abc.|123'

>>> print s

abc.|123

>>> print(re.escape(s))

abc\.\|123

re.findall()

作为一个字符串列表，在字符串中，返回所有非重叠匹配的模式。该字符串是从左到右扫描的，匹配按照发现的顺序返回。如果一个或多个组是本模式中，返回一个列表的群体 ；如果该模式具有多个组，这将是元组的列表。空匹配包含在结果中，除非他们接触到另一场匹配的开头。

返回一个匹配的所有内容的列表。如果没有匹配内容则返回空列表。

在 1.5.2 版本新。

2.4 版本中的更改：添加可选的标志参数。

语法：findall(pattern, string, flags=0)

>>> a = 'abc,123.abc.123'

>>> s = '[a-z]+'

>>> r = re.findall(s,a)

>>> r

['abc', 'abc']

re.match()

如果在字符串的开头的零个或更多字符匹配这个正则表达式，将返回相应的作法实例。返回没有如果，则该字符串与模式不匹配请注意这是不同于零长度匹配。

简单理解：就是从字符串的开始做正则匹配。能匹配到的最大位置返回。返回的对象用group/groups方法读取。可以不匹配到字符串的末尾。但是字符串的开始必须匹配，否则返回空字符串。

语法：match(pattern, string, flags=0)

>>> s = '[a-z]*'

>>> a = 'test123'

>>> b = re.match(s,a)

>>> b.group()

'test'

>>> a = '123abc'

>>> b = re.match(s,a)

>>> b.group()

''

re.search()

扫描字符串寻找第一个匹配位置，在此正则表达式产生的匹配，并返回相应的MatchObject实例。如果没有字符串中的位置匹配模式返回空 。

可选的第二个参数pos给索引在字符串中搜索在哪里开始；它将默认为0。这并不完全等于切片的字符串 ； ' ^'模式字符匹配在真正开始的字符串和位置刚换行，但不是一定是在开始搜索的索引。

可选参数endpos限制了多远的字符串将被搜索 ；它将，如果字符串是endpos个字符长，因此，只有从pos到字符endpos - 1将搜索匹配项。如果endpos小于pos，没有比赛会发现，否则，如果rx是已编译的正则表达式对象， rx.search （字符串， 0， 50)相当于rx.search （字符串 [： 50]， 0)。

注意：如果查找字符时用*则会默认匹配0个对应的字符。这样就会返回空字符串。

语法：search(pattern, string, flags=0)

>>> s = '\d*'

>>> a = 'abc123,31'

>>> s = re.search(s,a)

>>> s.group()

''

>>> s.span()

(0, 0)

>>> s = '\d+'

>>> s = re.search(s,a)

>>> s.span()

(3, 6)

>>> s.group()

'123'

re.split()

将字符串拆分的模式的匹配项。如果在模式中使用捕获括号，则然后也作为结果列表的一部分返回的文本模式中的所有组。如果maxsplit不为零，顶多maxsplit分裂发生，并且该字符串的其余部分将作为列表的最后一个元素返回。（不兼容性说明： 在原始的 Python 1.5 版本中， maxsplit被忽略。这已被固定在以后的版本。）

语法：split(pattern, string, maxsplit=0, flags=0)

>>> text = """Ross McFluff: 834.345.1254 155 Elm Street

... Ronald Heathmore: 892.345.3428 436 Finley Avenue

... Frank Burger: 925.541.7625 662 South Dogwood Way

... Heather Albrecht: 548.326.4584 919 Park Place"""

>>> entries = re.split("\n+", text)

>>> entries

['Ross McFluff: 834.345.1254 155 Elm Street',

'Ronald Heathmore: 892.345.3428 436 Finley Avenue',

'Frank Burger: 925.541.7625 662 South Dogwood Way',

'Heather Albrecht: 548.326.4584 919 Park Place']

>>> [re.split(":? ", entry, 3) for entry in entries]

[['Ross', 'McFluff', '834.345.1254', '155 Elm Street'],

['Ronald', 'Heathmore', '892.345.3428', '436 Finley Avenue'],

['Frank', 'Burger', '925.541.7625', '662 South Dogwood Way'],

['Heather', 'Albrecht', '548.326.4584', '919 Park Place']]

>>> [re.split(":? ", entry, 4) for entry in entries]

[['Ross', 'McFluff', '834.345.1254', '155', 'Elm Street'],

['Ronald', 'Heathmore', '892.345.3428', '436', 'Finley Avenue'],

['Frank', 'Burger', '925.541.7625', '662', 'South Dogwood Way'],

['Heather', 'Albrecht', '548.326.4584', '919', 'Park Place']]

re.sub()

Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl. 如果pattern没有被找到， string不变。repl 可以是一个字符串或一个函数；如果是一个字符串, 任何反斜杠转义都会实现。那就是，\n会转化成一个换行符，\r 会转化成一个回车，等等。 未知的转义字符例如 \j不做处理。

简单理解：按照规则pattern匹配字符串string，匹配的字符串按照规则repl来替换。替换后和原来字符串组合返回。repl可以使字符串也可以是函数。

语法：sub(pattern, repl, string, count=0, flags=0)

>>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):',

...        r'static PyObject*\npy_\1(void)\n{',

...        'def myfunc():')

'static PyObject*\npy_myfunc(void)\n{'

>>> def dashrepl(matchobj):

...     if matchobj.group(0) == '-': return ' '

...     else: return '-'

>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')

'pro--gram files'

>>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)

'Baked Beans & Spam'

2.2、函数汇总

注意：python3中新增一个函数：

re.fullmatch()，这个函数和re.match()的不同之处是需要全部匹配才能返回字符串。如果没有全部匹配则返回空。

序号

函数名

作用

实例

1

re.DEBUG

显示正则表达式的调试信息

>>> s = '\d\W'

>>> r = re.compile(s, re.DEBUG)

in

category category_digit

in

category category_not_word

2

re.DOTALL

使'.'特殊字符匹配任何字符，包括换行 ；如果没有此标志， '.'将匹配除换行符的任何内容。

>>> s = '.*'

>>> r = re.match(s,'a.123\nabc')

>>> r.group()

'a.123'

>>> r = re.match(s,'a.123\nabc',re.DOTALL)

>>> r.group()

'a.123\nabc'

3

re.I

测试和re.IGNORECASE作用相同是re.IGNORECASE的简写模式

>>> r = re.match('a*','aA',re.I)

>>> r.group()

'aA'

4

re.IGNORECASE

执行不区分大小写的匹配 ；如[A-Z]表达式将太匹配小写字母。这不被受当前的区域设置。

>>> r = re.match('a*','aA',re.IGNORECASE)

>>> r.group()

'aA'

5

re.L

和re.LOCALE作用相同。是re.LOCALE简写模式

6

re.LOCALE

使用当前环境的\w, \W, \b, \B, \s and \S

7

re.M

8

re.MULTILINE

当指定时，模式字符' ^'匹配字符串的开头以及每个行的开头（紧接每个换行符）； 模式字符'$'匹配字符串的末尾以及每一行的结尾（紧靠每个换行符之前）。

默认情况下， '^'只匹配字符串的开始，'$'只匹配字符串的末尾和字符串末尾换行符（如果有的话）之前的位置

9

re.S

作用和re.DOTALL相同。使'.'特殊字符匹配任何字符，包括换行 ；如果没有此标志， '.'将匹配除换行符的任何内容。

>>> s = '.*'

>>> r = re.match(s,'a.123\nabc')

>>> r.group()

'a.123'

>>> r = re.match(s,'a.123\nabc',re.S)

>>> r.group()

'a.123\nabc'

10

re.Scanner

11

re.T

12

re.TEMPLATE

13

re.U

和re.UNICODE作用相同

14

re.UNICODE

使得\w, \W, \b, \B, \d, \D, \s和 \S 取决于UNICODE定义的字符属性

15

re.VERBOSE

此标志允许您编写正则表达式，看起来更好。在模式中的空白将被忽略，除非当在字符类或者前面非转义反斜杠，和，当一条线包含一个'#'既不在字符类中或由非转义反斜杠，从最左侧的所有字符之前，这种'#'通过行末尾将被忽略。

这意味着两个以下正则表达式匹配的对象，一个十进制数是相同的功能：

a = re.compile(r"""\d +  # the integral part

\.    # the decimal point

\d *  # some fractional digits""", re.X)

b = re.compile(r"\d+\.\d*")

16

re.X

17

re._MAXCACHE

18

re.__all__

19

re.__class__()

20

re.__delattr__()

21

re.__dict__

22

re.__doc__

23

re.__file__

24

re.__format__()

25

re.__getattribute__()

26

re.__hash__()

27

re.__init__()

28

re.__name__

29

re.__new__()

30

re.__package__

31

re.__reduce__()

32

re.__reduce_ex__()

33

re.__repr__()

34

re.__setattr__()

35

re.__sizeof__()

36

re.__str__()

37

re.__subclasshook__()

38

re.__version__

39

re._alphanum

40

re._cache

41

re._cache_repl

42

re._compile()

43

re._compile_repl()

44

re._expand()

45

re._locale

46

re._pattern_type()

47

re._pickle()

48

re._subx()

49

re.compile()

将正则表达式模式编译成一个正则表达式对象，它可以用于匹配使用它的match ()和search ()方法，如下所述。

可以通过指定flags值修改表达式的行为。值可以是任何以下变量，使用组合 OR （ |运算符）。

但使用re.compile()和保存所产生的正则表达式对象重用效率更高时该表达式会在单个程序中多次使用。

语法：compile(pattern, flags=0)

>>> s = '[a-z]+\d*'

>>> a = re.compile(s)

>>> a

<_sre.SRE_Pattern object at 0x0000000003308738>

>>> type(a)

<type '_sre.SRE_Pattern'>

>>> b = a.match('a123')

>>> b.group()

'a123'

等价于：

>>> b = re.match('[a-z]+\d*', 'a123')

>>> b.group()

'a123'

50

re.copy_reg

帮助提供pickle/cPickle的可扩展性。

51

re.error()

正则表达式异常，当一个字符串传递给这里的函数之一时引发的异常不是有效的正则表达式 （例如，它可能包含不匹配的括号） 或其他一些错误在编译或匹配过程中发生的时。如果一个字符串包含不匹配的一种模式，它永远不会是一个错误。

52

re.escape()

返回的字符串与所有非字母数字带有反斜杠；这是有用的如果你想匹配一个任意的文本字符串，在它可能包含正则表达式元字符

简单理解：把字符串按照可能会是正则表达式来理解，这样就需要把特殊字符都转义。这样才能方便匹配时精确匹配每个字符。

字符'[a-z]'这个字符串可以看作是正则表达式的模式，这样就不能作为被匹配的字符串。如果想把这个字符串作为被匹配的模式就需要转义这些特殊字符。print(re.escape('[a-z]'))

\[a\-z\]

语法：escape(pattern)

>>> s = 'abc.|123'

>>> print s

abc.|123

>>> print(re.escape(s))

abc\.\|123

53

re.findall()

作为一个字符串列表，在字符串中，返回所有非重叠匹配的模式。该字符串是从左到右扫描的，匹配按照发现的顺序返回。如果一个或多个组是本模式中，返回一个列表的群体 ；如果该模式具有多个组，这将是元组的列表。空匹配包含在结果中，除非他们接触到另一场匹配的开头。

返回一个匹配的所有内容的列表。如果没有匹配内容则返回空列表。

在 1.5.2 版本新。

2.4 版本中的更改：添加可选的标志参数。

语法：findall(pattern, string, flags=0)

>>> a = 'abc,123.abc.123'

>>> s = '[a-z]+'

>>> r = re.findall(s,a)

>>> r

['abc', 'abc']

54

re.finditer()

返回一个迭代器符合MatchObject情况 在 RE模式字符串中的所有非重叠的匹配。该字符串是扫描的左到右，和按发现的顺序返回匹配。空匹配包含在结果中，除非他们接触的另一个匹配的开头。

新版本 2.2 中的。

2.4 版本中的更改：添加可选的标志参数。

>>> a = 'testestest'

>>> s = 'test'

>>> r = re.finditer(s,a)

>>> c = r.next()

>>> c.group()

'test'

>>> c = r.next()

>>> c.group()

'test'

>>> c = r.next()

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

StopIteration

>>> text = "He was carefully disguised but captured quickly by police."

>>> for m in re.finditer(r"\w+ly", text):

...     print '%02d-%02d: %s' % (m.start(), m.end(), m.group(0))

07-16: carefully

40-47: quickly

55

re.match()

如果在字符串的开头的零个或更多字符匹配这个正则表达式，将返回相应的作法实例。返回没有如果，则该字符串与模式不匹配请注意这是不同于零长度匹配。

简单理解：就是从字符串的开始做正则匹配。能匹配到的最大位置返回。返回的对象用group/groups方法读取。可以不匹配到字符串的末尾。但是字符串的开始必须匹配，否则返回空字符串。

语法：match(pattern, string, flags=0)

>>> s = '[a-z]*'

>>> a = 'test123'

>>> b = re.match(s,a)

>>> b.group()

'test'

>>> a = '123abc'

>>> b = re.match(s,a)

>>> b.group()

''

56

re.purge()

清除正则表达式缓存。

57

re.search()

扫描字符串寻找第一个匹配位置，在此正则表达式产生的匹配，并返回相应的MatchObject实例。如果没有字符串中的位置匹配模式返回空 。

可选的第二个参数pos给索引在字符串中搜索在哪里开始；它将默认为0。这并不完全等于切片的字符串 ； ' ^'模式字符匹配在真正开始的字符串和位置刚换行，但不是一定是在开始搜索的索引。

可选参数endpos限制了多远的字符串将被搜索 ；它将，如果字符串是endpos个字符长，因此，只有从pos到字符endpos - 1将搜索匹配项。如果endpos小于pos，没有比赛会发现，否则，如果rx是已编译的正则表达式对象， rx.search （字符串， 0， 50)相当于rx.search （字符串 [： 50]， 0)。

注意：如果查找字符时用*则会默认匹配0个对应的字符。这样就会返回空字符串。

语法：search(pattern, string, flags=0)

>>> s = '\d*'

>>> a = 'abc123,31'

>>> s = re.search(s,a)

>>> s.group()

''

>>> s.span()

(0, 0)

>>> s = '\d+'

>>> s = re.search(s,a)

>>> s.span()

(3, 6)

>>> s.group()

'123'

58

re.split()

将字符串拆分的模式的匹配项。如果在模式中使用捕获括号，则然后也作为结果列表的一部分返回的文本模式中的所有组。如果maxsplit不为零，顶多maxsplit分裂发生，并且该字符串的其余部分将作为列表的最后一个元素返回。（不兼容性说明： 在原始的 Python 1.5 版本中， maxsplit被忽略。这已被固定在以后的版本。）

语法：split(pattern, string, maxsplit=0, flags=0)

>>> text = """Ross McFluff: 834.345.1254 155 Elm Street

... Ronald Heathmore: 892.345.3428 436 Finley Avenue

... Frank Burger: 925.541.7625 662 South Dogwood Way

... Heather Albrecht: 548.326.4584 919 Park Place"""

>>> entries = re.split("\n+", text)

>>> entries

['Ross McFluff: 834.345.1254 155 Elm Street',

'Ronald Heathmore: 892.345.3428 436 Finley Avenue',

'Frank Burger: 925.541.7625 662 South Dogwood Way',

'Heather Albrecht: 548.326.4584 919 Park Place']

>>> [re.split(":? ", entry, 3) for entry in entries]

[['Ross', 'McFluff', '834.345.1254', '155 Elm Street'],

['Ronald', 'Heathmore', '892.345.3428', '436 Finley Avenue'],

['Frank', 'Burger', '925.541.7625', '662 South Dogwood Way'],

['Heather', 'Albrecht', '548.326.4584', '919 Park Place']]

>>> [re.split(":? ", entry, 4) for entry in entries]

[['Ross', 'McFluff', '834.345.1254', '155', 'Elm Street'],

['Ronald', 'Heathmore', '892.345.3428', '436', 'Finley Avenue'],

['Frank', 'Burger', '925.541.7625', '662', 'South Dogwood Way'],

['Heather', 'Albrecht', '548.326.4584', '919', 'Park Place']]

59

re.sre_compile

60

re.sre_parse

61

re.sub()

Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl. 如果pattern没有被找到， string不变。repl 可以是一个字符串或一个函数；如果是一个字符串, 任何反斜杠转义都会实现。那就是，\n会转化成一个换行符，\r 会转化成一个回车，等等。 未知的转义字符例如 \j不做处理。

简单理解：按照规则pattern匹配字符串string，匹配的字符串按照规则repl来替换。替换后和原来字符串组合返回。repl可以使字符串也可以是函数。

语法：sub(pattern, repl, string, count=0, flags=0)

>>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):',

...        r'static PyObject*\npy_\1(void)\n{',

...        'def myfunc():')

'static PyObject*\npy_myfunc(void)\n{'

>>> def dashrepl(matchobj):

...     if matchobj.group(0) == '-': return ' '

...     else: return '-'

>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')

'pro--gram files'

>>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)

'Baked Beans & Spam'

62

re.subn()

执行相同的操作，如sub()，但返回一个元组（new_string， number_of_subs_made)。

2.7 版本中的更改：添加可选的标志参数。

语法：subn(pattern, repl, string, count=0, flags=0)

63

re.sys

64

re.template()

2.3、函数返回的MatchObject对象的内置函数

search、match返回对象是MatchObject或者是None。

findall返回对象是列表。列表每个元素都是一个可以匹配的一段子串。

如果是MatchObject则这个对象的内置函数包括：

序号

函数名

作用

1

re.__class__()

2

re.__copy__()

3

re.__deepcopy__()

4

re.__delattr__()

5

re.__doc__

6

re.__format__()

7

re.__getattribute__()

8

re.__hash__()

9

re.__init__()

10

re.__new__()

11

re.__reduce__()

12

re.__reduce_ex__()

13

re.__repr__()

14

re.__setattr__()

15

re.__sizeof__()

16

re.__str__()

17

re.__subclasshook__()

18

re.end()

返回这个对象的内容长度

19

re.endpos

20

re.expand()

21

re.group()

返回对象匹配的内容，这是所有内容。如果匹配的正则表达式分组了，那么这个函数返回的值就是元组，元组每个元素都是匹配的一个子串

22

re.groupdict()

23

re.groups()

如果匹配的正则表达式分组了，那么可以用这个函数返回指定组名的字符串。默认时组0

24

re.lastgroup

最后一个分组内容

25

re.lastindex

26

re.pos

27

re.re

28

re.regs

29

re.span()

返回这个对象匹配的字符串在源字符串的起始和结束的索引值，以元组形式返回

30

re.start()

返回匹配结果的内容匹配到源字符串的起始位置的索引值，返回整型

31

re.string

返回源字符串。

三、注意事项

3.1、match、fullmatch、findall、finditer、search

match是根据传入的正则表达式匹配对应的字符串。并且是从开始字符匹配。匹配到字符不能匹配的位置然后返回匹配的对象。返回的对象是MatchObject或者空。

fullmatch，和match的区别是fullmatch必须是目标字符串从开始到结束全部都匹配这个传入的正则表达式才可以返回匹配对象。否则返回空。返回的对象也是MatchObject对象。

findall，从字符串中从前向后依次查找匹配正则表达式的子串。最后把多个匹配的子串用列表形式返回。列表的每个元素是一个匹配的子串。

finditer，和findall功能相同。但是finditer返回的是一个可迭代对象。可以用next()方法读取。然后再用group方法读取匹配的内容。

search，是从前向后依次扫描整个字符串。返回第一个匹配的子串。匹配位置不一定是开始字符。但是如果用*来表示0-n次重复时需要测试。有时候会返回空字符串。

Python正则表达式详解——re库的更多相关文章

  1. python 正则表达式详解

    正则表达式是一个很强大的字符串处理工具,几乎任何关于字符串的操作都可以使用正则表达式来完成,作为一个爬虫工作者,每天和字符串打交道,正则表达式更是不可或缺的技能,正则表达式的在不同的语言中使用方式可能 ...

  2. 【python】详解numpy库与pandas库axis=0，axis= 1轴的用法

    对数据进行操作时,经常需要在横轴方向或者数轴方向对数据进行操作,这时需要设定参数axis的值: axis = 0 代表对横轴操作,也就是第0轴: axis = 1 代表对纵轴操作,也就是第1轴: nu ...

  3. Python正则表达式详解

    我用双手成就你的梦想 python正则表达式 ^ 匹配开始 $ 匹配行尾 . 匹配出换行符以外的任何单个字符,使用-m选项允许其匹配换行符也是如此 [...] 匹配括号内任何当个字符(也有或的意思) ...

  4. 「黑客必备技能」Python正则表达式详解

    说在前面 正则表达式是一个很强大的字符串处理工具,几乎任何关于字符串的操作都可以使用正则表达式来完成,作为一个爬虫工作者,每天和字符串打交道,正则表达式更是不可或缺的技能. 正则表达式在不同的语言中使 ...

  5. python正则表达式详解之Match类及其方法

    1.Match对象简介 match对象通常是由正则表达式对象的match 方法,search 方法等经过匹配之后而产生.可以直接当做bool值使用,如果匹配则相当于True, 如果不匹配,则返回Non ...

  6. Java 正则表达式详解_正则表达式

    body{ font-family: "Microsoft YaHei UI","Microsoft YaHei",SimSun,"Segoe UI& ...

  7. Django url配置 正则表达式详解 分组命名匹配 命名URL 别名 和URL反向解析 命名空间模式

    Django基础二之URL路由系统 本节目录 一 URL配置 二 正则表达式详解 三 分组命名匹配 四 命名URL(别名)和URL反向解析 五 命名空间模式 一 URL配置 Django 1.11版本 ...

  8. python线程详解

    #线程状态 #线程同步(锁)#多线程的优势在于可以同时运行多个任务,至少感觉起来是这样,但是当线程需要共享数据时,可能存在数据不同步的问题. #threading模块#常用方法:'''threadin ...

  9. Linux文本处理三剑客之grep及正则表达式详解

    Linux文本处理三剑客之grep及正则表达式详解 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.Linux文本处理三剑客概述 grep: 全称:"Global se ...

随机推荐

  1. 【Sass初级】嵌套选择器规则

    在CSS中,我们都知道所有代码都在一个“根级别”的选择器中,每个CSS的样式声明都写嵌套的话,那意客味需要写很多的代码. 今天我要带领大家进入到Sass的最基本原则中.这就是所谓的“基础规则(Ince ...

  2. HDU-3072-IntelligenceSystem（tarjan，贪心）

    链接:https://vjudge.net/problem/HDU-3072 题意: 给你n个点,1个点到另一个点连接花费c,但是如果几个点可以相互可达,则这几个点连通花费为0. 求将整个图连通的最小 ...

  3. Mac OS X

    Mac OS X 除了微软自家的Windows平台, .NET Core针对Mac OS以及各种Linux(RHEL.Ubuntu.Debian.Fedora.CentOS和SUSE等)都提供了很好的 ...

  4. 去掉word文档两边的空白

    1.设置-页面布局-页边距,把左边距和右边距的数据设置到最小就好,一般为0.43CM 2.把WORD页面顶部标尺,左右拉到最底,如图: 3.在打印预览里,设置页边距,操作方法同 上述 1,如图:

  5. 牛客网Java刷题知识点之为什么static成员方法不能是抽象方法，其必须实现

    不多说,直接上干货! static修饰的方法我们称之为静态方法,我们通过类名对其进行直接调用.由于它在类加载的时候就存在了,它不依赖于任何实例,所以static方法必须实现,也就是说它不能是抽象方法.

  6. 基于WebSocket和SpringBoot的群聊天室

    引入 普通请求-响应方式:例如Servlet中HttpServletRequest和HttpServletResponse相互配合先接受请求.解析数据,再发出响应,处理完成后连接便断开了,没有数据的实 ...

  7. TCP/IP协议分析含义与功能

    TCP/IP协议模型从更实用的角度出发,形成了高效的四层体系结构,即网络接口层.IP层.传输层和应用层.TCP/IP是一组专业化协议,包括IP.TCP.UDP.ARP.ICMP以及其它的一些被称为子协 ...

  8. 【extjs6学习笔记】1.8 初始： ExtJS命名约定

    Convention for Description Example Class 类名应该在CamelCase中 MyCustomClass 类名应包含字母数字字符. 如果属于技术术语,则允许使用数字 ...

  9. (转)VC得到可用的串口列表

    //枚举串口 //参数:bEnablePort,哪个串口有效,bEnablePort[0]表示COM1,bEnablePort[n-1]表示COMn //返回值:有效的串口个数 int EnumAll ...

  10. 洛谷 P2966 [USACO09DEC]牛收费路径Cow Toll Paths

    题目描述 Like everyone else, FJ is always thinking up ways to increase his revenue. To this end, he has ...