一、简介

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. XML与JSON的区别

    JSON和XML的比较 ◆可读性 JSON和XML的可读性可谓不相上下,一边是简易的语法,一边是规范的标签形式,很难分出胜负. ◆可扩展性 XML天生有很好的扩展性,JSON当然也有,没有什么是XML ...

  2. 【手撸一个ORM】第八步、查询工具类

    一.实体查询 using MyOrm.Commons; using MyOrm.DbParameters; using MyOrm.Expressions; using MyOrm.Mappers; ...

  3. Spring Security 5中的默认密码编码器

    1.概述 在Spring Security 4中,可以使用内存中身份验证以纯文本格式存储密码. 对版本5中的密码管理过程进行了重大改进,为密码编码和解码引入了更安全的默认机制.这意味着如果您的Spri ...

  4. hashMap的具体实现

    HashMap是Java中的一个重要的数据结构! 与HashMap更重要的一个数据结构是HashTable,其中最重要的区别是HashTable传说中是线程安全的(之所以说他是传说是因为我并没有去理解 ...

  5. git忽略已经被提交的文件

    git忽略已经被提交的文件 git rm --cached logs/xx.log 然后更新 .gitignore 忽略掉目标文件, 最后 git commit -m "We really ...

  6. SpringMVC02 AbstractController And MultiActionController

    1.AbstractController 若处理器继承自AbstractController类,那么该控制器就具有了一些新功能.因为AbstractControll类还继承自一个父类WebConten ...

  7. HubbleDotNet 使用类

    using System; using System.Collections.Generic; using System.Linq; using System.Text; using Hubble.S ...

  8. iOS 容联离线消息推送

    容联 SDK 是包含离线消息推送的.首先我们要在控制台上传P12证书,(生产证书和开发证书),(证书的配置这里就不多说了)只能有一个证书是生效中的 生产证书需要打包成 ipa 包才能测试离线推送 然后 ...

  9. DatabaseMetaData类

    DatabaseMetaData类是java.sql包中的类,利用它可以获取我们连接到的数据库的结构.存储等很多信息.如: 1.数据库与用户,数据库标识符以及函数与存储过程.         2.数据 ...

  10. JavaScript判断图片是否已经加载完毕的方法汇总

    在网上有很多关于判断图片是否已经加载完毕的文章,但是有的浏览器并不适合,下面小编给大家分享一些有关JavaScript判断图片是否已经加载完毕方法汇总,具体内容如下所示: 一.onload事件 通过监 ...