python笔记-正则表达式常用函数

1、re.findall()函数

语法：re.findall(pattern,string,flags=0) ——> list(列表)

列出字符串中模式的所有匹配项，并作为一个列表返回。如果无匹配，则返回空列表！

与re.search()不一样的地方：

re.findall返回的是列表，re.search返回文本
re.findall匹配多个值，re.search只要匹配到就返回，只匹配一个值

>>> import re

>>> re.findall(r"ab","abcaaaab")

['ab', 'ab']               #匹配的值作为一个列表范围

2、re.compile()函数

语法：re.compile(pattern,flags=0) ——> pattern object

根据包含正则表达式的字符串创建模式对象，可以实现更有效率地匹配！用了re.compile以后，正则对象会得到保留，这样在需要多次运用这个正则对象的时候，效率会有较大的提升

此外，re.cpmpile() 可以通过接受可选的属性，常用来实现不同的特殊功能和语法变更。

2.1 例1：使用re.compile(pattern)对正则表达式进行编译

>>> import re

>>> s=r"^010-\d{8}$"

>>> re.findall(s,"010-12345678")

['010-12345678']

>>> p_tel=re.compile(s)                                            #对s这个正则表达式创建模式对象p_tel

>>> p_tel

<_sre.SRE_Pattern object at 0x7f3ab3776d78>

>>> p_tel.findall("010-12345678")           #经过compile转换的正则表达式对象也能用于普通的re函数，跟上面的re.findall(s,"010-12345678")一样的效果

['010-12345678']

2.2 使用re.compile(pattern)进行编译,不区分大小写

>>> import re

>>> s=r"hello"

>>> greeting=re.compile(s,re.I)    #re.I 属性让正则表达式忽略大小写！

>>> greeting.findall("HELLO")

['HELLO']

>>> greeting.findall("hello")

['hello']

>>> greeting.findall("hEllo")

['hEllo']

2.3 为什么正则匹配模式前面加 "r"

禁止转义！反斜杠不会被任何特殊方式处理。

Python编译器用‘\’（反斜杠）来表示字符串常量中的转义字符。

如果反斜杠后面跟着一串编译器能够识别的特殊字符，那么整个转义序列将被替换成对应的特殊字符（例如，‘\n’将被编译器替换成换行符）

本质上来讲，使用r，你在告诉编译器完全不要去干涉你的字符串

例如：

>>> string='this is a\nnormal string'

>>> print string

this is a

normal string                   #不使用r,\n在字符串中代表一个换行符

>>> rawstring=r'this is a\nnormal string'

>>> print rawstring

this is a\nnormal string           #使用r,\n在字符串中就是\n

3、re.match()函数

语法：re.match(pattern, string, flags=0) ——> match object or None

在字符串的开始位置匹配正则！如果无匹配，则返回 None 。

>>> import re

>>> s=r"abc"

>>> com=re.compile(s)

>>> com.match("abcdef")                          #abc在开始的位置，可以匹配

<_sre.SRE_Match object at 0x7f3ab3480cc8>

>>> print com.match("hhhabc")                    #abc不在开始的位置，不可以匹配

None

3.1 使用group()-返回匹配的数据

>>> import re

>>> s=r"abc"

>>> com=re.compile(s)

>>> com.match("abcddddd").group()   #使用group()返回匹配的对象

'abc'

4、re.search()函数

语法：re.search(pattern, string, flags=0) ——> match object or None

re.search函数会在字符串内查找模式匹配,只要找到第一个匹配然后返回，如果字符串没有匹配，则返回None

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

>>> import re

>>> s=r"abc"

>>> com=re.compile(s)

>>> com.search("abcdef")

<_sre.SRE_Match object at 0x7f3ab3480cc8>

>>> com.search("hhhabc")

<_sre.SRE_Match object at 0x7f3ab3480d30>         #与re.match的区别：无论在哪个位置都能匹配

4.1 使用group()-返回匹配的数据

>>> import re

>>> s=r"abc"

>>> com=re.compile(s)

>>> com.search("abcddd").group()             #使用group()返回匹配的对象

'abc'

>>> com.search("abcdddabc").group()          #只匹配一个

'abc'

4.2 关于group更多

返回匹配到的一个或者多个子组。如果是一个参数，那么结果就是一个字符串，如果是多个参数，那么结果就是一个参数一个item的元组。

group1的默认值为0(将返回所有的匹配值).如果groupN参数为0，相对应的返回值就是全部匹配的字符串，

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

>>> s=r"(\w+) (\w+)"

>>> com=re.compile(s)

>>> m=com.search("abc def,222")

>>> m.group()   #返回所有的匹配值

'abc def'

>>> m.group(0)    #返回所有的匹配值,默认是0

'abc def'

>>> m.group(1)    #如果group的值是[1…99]范围之内的,那么将匹配对应括号组的字符串

'abc'

>>> m.group(2)

'def'

>>> m.group(1,2)     #如果是一个参数，那么结果就是一个字符串，如果是多个参数，那么结果就是一个参数一个item的元组

('abc', 'def')

>>> m.group(3)

Traceback (most recent call last):

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

IndexError: no such group                       #如果组号是负的或者比pattern中定义的组号大，那么将抛出IndexError异常

还可以把使用别的变量值来代替默认的group(N)中的N，如下写法：

>>> import re

>>> m=re.search(r"(?P<one>\w+) (?P<two>\w+)","abc def,222")   #?P<变量值>写法

>>> m.group("one")

'abc'

>>> m.group("two")

'def'

4.3 关于MatchObject(匹配对象) 方法

re.match和re.search都是返回MatchObject，有如下方法

group()：返回被正则匹配的字符串；
start()：返回匹配开始的位置；
end()：返回匹配结束的位置；
span()：返回一个元组包含匹配（开始，结束）的位置。

5、re.finditer()函数

语法：re.finditer(pattern,string,flags=0) ——> iterator

列出字符串中模式的所有匹配项，并作为一个迭代器返回。

延伸下，什么是iterator？转载：https://www.liaoxuefeng.com

凡是可作用于for循环的对象都是Iterable类型；
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的，例如：

for x in [1, 2, 3, 4, 5]:

    pass

实际上完全等价于：

# 首先获得Iterator对象:

it = iter([1, 2, 3, 4, 5])

# 循环:

while True:

    try:

        # 获得下一个值:

        x = next(it)

    except StopIteration:

        # 遇到StopIteration就退出循环

        break

言归正传，举例如下：

>>> import re

>>> s=r"\d+"

>>> com=re.compile(s)

>>> com.finditer("aa11bb22cc")

<callable-iterator object at 0x7f3ab3499cd0>

>>> it=com.finditer("aa11bb22cc")

>>> for i in it:

...     print i     #返回一个match对象

...     print i.group()   #返回匹配的数据

...

<_sre.SRE_Match object at 0x7f3ab3480d30>

11

<_sre.SRE_Match object at 0x7f3ab3480cc8>

22

6、re.sub()函数

语法:re.sub(pattern, repl, string, count=0, flags=0) ——> string

将字符串中所有 pattern 的匹配项用 repl 替换！

>>> import re

>>> re.sub(r"abc","123","abcdefabc")

'123def123'

7、re.subn()函数

语法:re.subn(pattern, repl, string, count=0, flags=0)

与sub()实现相同的替换作用，但是subn()返回一个元组，其中包含新字符串和替换次数！

>>> import re

>>> re.subn(r"abc","123","abcdefabc")

('123def123', 2)

8、re.split()函数

语法：re.split(pattern, string, maxsplit=0, flags=0) ——> list

根据模式的匹配项来分割字符串！

>>> import re

>>> re.split(r"\d+","aa11bb22cc")  #以正则表达式\d+为分割符

['aa', 'bb', 'cc']

>>> re.split(r"\d","aa11bb22cc")   #以正则表达式\d+为分割符

['aa', '', 'bb', '', 'cc']