python 正则表达式

最新推荐文章于 2023-07-29 23:22:06 发布
最新推荐文章于 2023-07-29 23:22:06 发布
阅读量175 收藏 1
点赞数
分类专栏： Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/poblg/article/details/103598309
版权

Python中字符串前面加上 r 表示原生字符串

“r”是“raw”的简写。意思是“未加工的，原料”。因此，不难想象，在python字符串前面，表示“按原样输出字符串”，也就是说字符串里的元素，原来什么样子，还是什么样子，不变。python不会去对一些符号转义。

正则表达式r"\n"表示一个换行符。

^

匹配字符串的起始部分

$

匹配字符串的终止部分

.

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

[...]

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

[^...]

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

re*

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

re+

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

re?

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

re{n}

精确匹配 n 个前面表达式。例如， o{2} 不能匹配 "Bob" 中的 "o"，但是能匹配 "food" 中的两个 o。

re{n,}

匹配 n 个前面表达式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。"o{1,}" 等价于 "o+"。"o{0,}" 则等价于 "o*"。

re{n, m}

匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式。例如 [a-z]{3,5}，如果超过了n-m的范围，则匹配不到任何东西，例子：re_str = r'[a-z]{2,5}'；fullmatch(re_str, 'aajkse')；则匹配不到，因为'aajkse'查过了5个字符。

 

匹配最少n次，最多m次。(m>n)

a| b

匹配a或b

(re)

匹配括号内的表达式，也表示一个组

(?imx)

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

 

此处编译选项’i’ 等价于IGNORECASE ，L 等价于 LOCAL ，m 等价于 MULTILINE ，s 等价于 DOTALL ，u 等价于 UNICODE ， x 等价于 VERBOSE 。

请注意它们的大小写。在使用时可以只指定一部分，比如只指定忽略大小写，可写为 ‘(?i)’，要同时忽略大小写并使用多行模式，可以写为 ‘(?im)’。

另外要注意选项的有效范围是整条规则，即写在规则的任何地方，选项都会对全部整条正则式有效。

(?-imx)

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

(?: re)

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

 

findall函数，就是说在正则匹配里，如果有分组，就仅仅匹配分组里面的内容，然后返回这个组的列表; 如果有多个分组，那就把每一个分组看成一个单位，组合为一个元组，然后返回一个含有多个元组的列表。

 

(qq|163|126) ---> 这样单独的括号就为捕获组

(?:qq|163|126) ---> 这样在原有分组里加上?: 就把捕获组转变为一个非捕获组

 

所以，?: 白话的意思就是不把分组当分组

 

(?imx: re)

在括号中使用i, m, 或 x 可选标志

(?-imx: re)

在括号中不使用i, m, 或 x 可选标志

(?#...)

注释.

(?= re)

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

(?! re)

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

(?> re)

匹配的独立模式，省去回溯。

(?<=…)

前向界定，括号中’…’代表你希望匹配的字符串的前面应该出现的字符串

要注意的是，前向界定括号中的表达式必须是常值，也即你不可以在前向界定的括号里写正则式。

(?=…)后向界定,括号中的’…’代表你希望匹配的字符串后面应该出现的字符串
(?<!...)前向非界定, 只有当你希望的字符串前面不是’…’的内容时才匹配
(?!...)后向非界定,只有当你希望的字符串后面不跟着’…’内容时才匹配
(?P<name>…)

命名组

(?P’代表这是一个Python的语法扩展’<…>’里面是你给这个组起的名字，比如你可以给一个全部由数字组成的组叫做’num’，它的形式就是’(?P<num>\d+)’

group(name)  来获取相应的匹配值

(?P=name)

调用已匹配的命名组

要注意，再次调用的这个组是已被匹配的组，也就是说它里面的内容是和前面命名组里的内容是一样的

(?(id/name)Y|N) 若前面指定id或name的分区匹配成功则执行yes处的正则，否则执行no处的正则

\w

匹配字母数字及下划线

\W

匹配非字母数字及下划线

\s

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

\S

匹配任意非空字符

\d

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

\D

匹配任意非数字

\A

匹配字符串开始

\Z

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

\z

匹配字符串结束

\G

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

\b

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

\B

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

\n, \t, 等.

匹配一个换行符。匹配一个制表符。等

\1...\9

匹配第n个分组的内容。

re_str = r'([a-z]{3})-(\d{2})\2'
print(re.fullmatch(re_str, 'hsn-2323'))

\2   代表的是第二个分组，并且是匹配后的值一致，例如23，同样需要重复一个23，而不能是其他的两个数字

 

htmlStr = "<html><p>welcome to westos!</p></html>

pattern = r'<(\w+)><(\w+)>(.+)</\2></\1>'     #\2 是指p   \1是指匹配后的html

print(re.findall(pattern, htmlStr))

print(re.findall(pattern, htmlStr)[0][2])

\10

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

 

常用函数

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

函数名

含义

实例

re.compile()

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

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

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

 

将正则规则编译成一个Pattern对象，以供接下来使用。

第一个参数是规则式，第二个参数是规则选项。

返回一个Pattern对象

语法：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()

在目标字符串中查找符合规则的字符串

 

返回结果结果是一个列表，中间存放的是符合规则的字符串。如果没有符合规则的字符串被找到，就返回一个空列表。

语法：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'

 

 

函数汇总

注意：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

LOCAL  字符集本地化。这个功能是为了支持多语言版本的字符集使用环境的，比如在转义符\w，在英文环境下，它代表[a-zA-Z0-9]，即所以英文字符和数字。如果在一个法语环境下使用，缺省设置下，不能匹配"é" 或 "ç"。加上这L选项和就可以匹配了。不过这个对于中文环境似乎没有什么用，它仍然不能匹配中文字符。

 

7

re.M

多行匹配。在这个模式下’^’(代表字符串开头)和’$’(代表字符串结尾)将能够匹配多行的情况，成为行首和行尾标记

>>> s=’123 456\n789 012\n345 678’

>>> rc=re.compile(r’^\d+’)    #匹配一个位于开头的数字，没有使用M选项

>>> rc.findall(s)

['123']             #结果只能找到位于第一个行首的’123’

>>> rcm=re.compile(r’^\d+’,re.M)       #使用 M 选项

>>> rcm.findall(s)

['123', '789', '345']  #找到了三个行首的数字

同样，对于’$’来说，没有使用M选项，它将匹配最后一个行尾的数字，即’678’，加上以后，就能匹配三个行尾的数字456 012和678了.

>>> rc=re.compile(r’\d+$’)

>>> rcm=re.compile(r’\d+$’,re.M)

>>> rc.findall(s)

['678']

>>> rcm.findall(s)

['456', '012', '678']

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对象，这个对象里面有很多函数，他们看起来和re模块的函数非常象，它同样有findall , match , search ,finditer , sub , subn , split 这些函数，只不过它们的参数有些小小的不同。一般说来，re模块函数的第一个参数，即正则规则不再需要了，应为规则就包含在Pattern对象中了，编译选项也不再需要了，因为已经被编译过了。因此re模块中函数的这两个参数的位置，就被后面的参数取代了。

语法：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()

这是个功能比较古怪的函数，它的作用是将字符串中的non-alphanumerics字符（我已不知道该怎么翻译比较好了）用反义字符的形式显示出来。有时候你可能希望在正则式中匹配一个字符串，不过里面含有很多re使用的符号，你要一个一个的修改写法实在有点麻烦，你可以使用这个函数

语法：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()

切片函数。使用指定的正则规则在目标字符串中查找匹配的字符串，用它们作为分界，把字符串切片。

第一个参数是正则规则，第二个参数是目标字符串，第三个参数是最多切片次数

返回一个被切完的子字符串的列表

语法：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()

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

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

 

sub返回一个被替换的字符串

subn返回一个元组，第一个元素是被替换的字符串，第二个元素是一个数字，表明产生了多少次替换。

语法：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()

 

 

正则式中的每个组都有一个序号，它是按定义时从左到右的顺序从1开始编号的。其实，re的正则式还有一个0号组，它就是整个正则式本身。

原来0组就是整个正则式,包括没有被包围到组里面的内容。当获取0组的时候，你可以不写这个参数。m.group(0)和m.group()的效果是一样的

 

函数返回的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

返回源字符串。

 

注意事项

match、fullmatch、findall、finditer、search

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

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

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

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

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

poblg
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python正则表达式的简单测试
qq_16620025的博客
07-24 385
用于简单的测试正则表达式的正确性，顺便爬得一些信息 from urllib import request import re import time class Read_Msg(): def __init__(self, url, regular, sign): self.url = url self.regular = regular ...
自己用python做个regex testor正则测试器
12-21
因为python的正则测试器软件少,网上在线的网站又没网速,所有想自己折腾个,这样也绝对不会出现匹配问题了… 话不多说,直接上代码 # coding:utf-8 from tkinter import * import re def mode_check(_='None'): global mode mode=0 if var_m.get(): mode=mode|re.M if var_d.get(): mode=mode|re.DOTALL if var_i.get(): mode=mode|re.I
Python之正则表达式
Tester_Improve的博客
06-02 344
正则表达式模块:re Python中的所有正则表达式函数都在re模块中 Regex对象: Regex 对象的 search()方法查找传入的字符串， 寻找该正则表达式的所有匹配。如果字符串中没有找到该正则表达式模式， search()方法将返回 None。如果找到了该模式，search()方法将返回一个 Match 对象。 Match 对象有一个 group()方法，它返回被查找字符串中实际匹配的文本（稍后我会解释分组）。 search()方法： Python 中使用正则表达式步骤如下： 1、 用 impo
Python正则表达式
Qwertyuiop2016的博客
04-03 1305
提示 为了避免正则表达式中出现太多的反斜杠，建议使用r字符串，r"\n"表示两个字符\和n，前面不加r则表示一个换行符\n。(正则的\要写成\\，而在Python中，也是一样，这就导致在Python写正则时需要写\\\\四个反斜杠) 语法 特殊字符 .: 在默认模式下匹配除换行的任意字符，如果指定re.DOTALL模式，则匹配包括换行的任意字符 ^: 匹配字符串的开头，re.MULTILINE模式匹配每行的开头 $: 匹配字符串的结尾，re.MULTILINE模式匹配每行的结尾 *: 前
Python正则表达式基础
04-02
Python正则表达式是Python编程语言中的一个强大工具，用于处理和分析文本字符串。它允许开发者通过模式匹配来查找、替换或提取数据，广泛应用于数据清洗、文本挖掘、日志分析等领域。在Python中，正则表达式主要通过...
Python正则表达式匹配数字和小数的方法
01-20
 以上所述是小编给大家介绍的Python正则表达式匹配数字和小数的方法,希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对软件开发网网站的支持！ 如果你觉得本文对你有...
Python 正则表达式
11-17
### Python正则表达式详解 #### 一、正则表达式概述 正则表达式（Regular Expressions）是一种强大的文本处理工具，它能够帮助我们快速地处理字符串中的各种模式匹配问题。例如，验证用户输入是否符合预期的格式，...
Python正则表达式分组概念与用法详解
10-19
主要介绍了Python正则表达式分组概念与用法,结合具体实例形式较为详细的分析了Python正则表达式中分组、引用、断言等概念与相关使用技巧,需要的朋友可以参考下
Python正则表达式教程之二：捕获篇
12-23
在上一篇文中，我们介绍了关于Python正则表达式的基础，那么在这一篇文章里，我们将总结一下正则表达式关于捕获的用法。下面话不多说，来看看详细的介绍吧。  捕获 捕获和分组在正则表达式中有着密切的联系，一般...
Python正则表达式匹配日期与时间的方法
01-20
下面给大家介绍下Python正则表达式匹配日期与时间 #!/usr/bin/env python # -*- coding: utf-8 -*- __author__ = 'Randy' import re from datetime import datetime test_date = '他的生日是2016-12-12 14:34,是个...
python正则表达式.zip
11-06
正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这 些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一 种过滤逻辑（可以用来做检索，截取或者替换...
Python 正则表达式入门（初级篇）
01-20
首先说 正则表达式是什么？ 正则表达式，又称正规表示式、正规表示法、正规表达式、规则表达式、常规表示法（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表达式...
Python中的原生字符串"r"
热门推荐
戴翔的技术博客
01-22 1万+
Python中字符串前面加上 r 表示原生字符串，与大多数编程语言相同，正则表达式里使用”\”作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符”\”，那么使用编程语言表示的正则表达式里将需要4个反斜杠”\”：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。 案例展示： # encoding: utf-8 import re
Python中的r字符串前缀及其用法详解
最新发布
博客
07-29 5086
在Python中，r字符串前缀是一种用于表示原始字符串的特殊前缀。它可以消除转义字符的特殊含义，使字符串中的每个字符都按照字面意义进行解释。r字符串前缀在处理包含特殊字符的字符串、处理正则表达式和处理文件路径时非常有用。但需要注意，r字符串前缀只适用于字符串字面值，不能用于变量或表达式。此外，r字符串前缀只影响字符串本身，不影响字符串中的变量或表达式的解释。希望本篇博客能够帮助你理解r字符串前缀的概念和用法，并在实际的Python编程中能够灵活运用。如果你有任何问题或疑惑，欢迎在评论区留言，我会尽力解答。
Python期末复习选择题Part1
qq_52045638的博客
12-05 2341
期末考试pthon基础知识复习题
Python 正则表达式详解（建议收藏！）
m0_67402341的博客
08-02 1872
正则表达式是对字符串提取的一套规则，我们把这个规则用正则里面的特定语法表达出来，去匹配满足这个规则的字符串。正则表达式具有通用型，不仅python里面可以用，其他的语言也一样适用。python中re模块提供了正则表达式的功能，常用的有四个方法(match、search、findall)都可以用于匹配字符串。...
Python正则表达式入门教程
"Python正则表达式操作指南" Python的正则表达式是通过内置的`re`模块来实现的，这个模块提供了丰富的功能，使得开发者可以方便地处理字符串匹配、查找、替换等任务。本指南主要适用于Python 1.5及后续版本，适合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值