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编译器用‘’（反斜杠）来表示字符串常量中的转义字符。

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

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

例如：

>>> string='this is a
normal string'
>>> print string
this is a
normal string                   #不使用r,
在字符串中代表一个换行符
>>> rawstring=r'this is a
normal string'
>>> print rawstring
this is a
normal string           #使用r,
在字符串中就是

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']