python re 正则表达式

  正则表达式是用于字符串搜索、匹配、替换的常见方法，而它实际上就是一个特殊的字符序列，用来帮助你方便的检查一个字符串是否与某种模式匹配。 Python中re包是专门用来处理正则表达式的相关操作，我参考了一些资料整理了re包中所有的函数应用，仅供参考！

 

 说明：以下所有函数均是（均可）re.funcname()，也就是说正则表达式具有两种编程手法，使用方式基本相同，但是函数参数略有不同，使用时注意就好！

• 方法1

  ​ re.function();

• 方法2

  ​ obj = re.compile();

  ​ obj.funcname();

compile()

  compile()函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换，所谓一系列方法即是包括下面要介绍的所有函数，而下面所有函数又可以通过re.funcname()调用，这一点要非常注意！

re.compile(pattern='regex_exp', flags=re.I)

• pattern : 一个字符串形式的正则表达式
• flags : 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：
  
  1. re.I 忽略大小写
  2. re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
  3. re.M 多行模式
  4. re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
  5. re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
  6. re.X 为了增加可读性，忽略空格和 # 后面的注释

# match()函数尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none

>>>import re


# 实例1
>>> pattern = re.compile(r'\d+')                    # 用于匹配至少一个数字
>>> m = pattern.match('one12twothree34four')        # 查找头部，没有匹配
>>> print m
None

>>> m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配

>>> print m                                         # 返回一个 Match 对象
<_sre.SRE_Match object at 0x10a42aac0>

# 用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)
>>> m.group(0)   # 可省略 0
'12'

# 用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0
>>> m.start(0)   # 可省略 0
3

# 用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0
>>> m.end(0)     # 可省略 0
5

 # (start(group), end(group))
>>> m.span(0)    # 可省略 0
(3, 5)



# 实例2
# 该例子中正式引入分组概念，注意理解
>>> pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I)
>>> m = pattern.match('Hello World Wide Web')

>>> m.group(0)                            # 返回匹配成功的整个子串
'Hello World'
>>> m.span(0)                             # 返回匹配成功的整个子串的索引
(0, 11)


>>> m.group(1)                            # 返回第一个分组匹配成功的子串
'Hello'
>>> m.span(1)                             # 返回第一个分组匹配成功的子串的索引
(0, 5)

>>> m.group(2)                            # 返回第二个分组匹配成功的子串
'World'
>>> m.span(2)                             # 返回第二个分组匹配成功的子串
(6, 11)

>>> m.groups()                            # 等价于 (m.group(1), m.group(2), ...)
('Hello', 'World')

match()

  如前所述，re.match()尝试从字符串的起始位置匹配一个模式，如果匹配成功则返回一个Match对象，反之返回none

import re
print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配  (0,3)
print(re.match('com', 'www.runoob.com'))         # 不在起始位置匹配 None

fullmatch()

  这个好理解，要求完全匹配

import re

s = '234d'
matched = re.fullmatch('\d+', s, 0)
if matched:
    print(matched.group())
else:
    print('not matched')

 # not matched

search()

  re.search 扫描整个字符串并返回第一个成功的匹配(Match对象)，否则返回None

line = "Cats are smarter than dogs"
searchObj = re.search(r'(.*) are (.*?) .*', line, re.M | re.I)
# print(type(searchObj))  # Match对象
if searchObj:
    # 这是第二个提到分组的例子
    # 分组是对匹配结果的一个分组，体现在正则表达式的（）上，一个（）代表建立一个分组
    print("searchObj.group() : ", searchObj.group())
    print("searchObj.group(1) : ", searchObj.group(1))
    print("searchObj.group(2) : ", searchObj.group(2))
else:
    print("Nothing found!!")


# searchObj.group() :  Cats are smarter than dogs
# searchObj.group(1) :  Cats
# searchObj.group(2) :  smarter

sub()

  sub()函数用于字符串替换，原型：re.sub(pattern, repl, string, count=0, flags=0),说明一下，count是指模式匹配后替换的最大次数，默认 0 表示替换所有的匹配；repl（replace）表示替换的字符串，也可为一个函数。

# repl 作为一个字符串
import re

num = "2018-08-17"
new_num = re.sub(r"\D", "", num, count=0)
print(new_num)

# 20180817

# repl作为一个函数 

# 将匹配的数字乘以 2
def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)

s = 'A23G4HFD567'
new_str = re.sub(r'(?P<value>\d+)', double, s)
print(new_str)
# A46G8HFD1134

subn

subn()函数基本同sub()函数，唯一不同点是subn()还会返回替代次数，例子如下：

s = 'A23G4HFD567'
n = re.subn(r'(?P<value>\d+)', '', s)
print(n)

# ('AGHFD', 3) 返回一个tuple。根据具体情境选用sub() or subn()

findall()

  在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表，而上面提到的match()、search()函数匹配一次且返回对象为Match或None.

s = 'A23G4HFD567'
# flags其实和上面一样，不过这里我用的是 int类型数来表示
# 具体对应关系，我...也记不住！
print(re.findall(r'\d+', s, flags=0))

# ['23', '4', '567']

finditer()

  和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回，具有更好的性能。

s = 'A23G4HFD567'
iter = re.finditer(r'\d+', s, flags=0)

for match in iter:
    print(match.group())

# 23
# 4
# 567

split()

  split 方法按照能够匹配的子串将字符串分割后返回列表，在很多其他语言也有这个函数，如C#，java。在函数中，maxsplit表示分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。

import re
s = 'A23G4HFD567N'
res = re.split(r'\d+', s, maxsplit=2, flags=0)
print(res)

# ['A', 'G', 'HFD567N']

escape()

  可以对字符串中所有可能被解释为正则运算符的字符进行转义的应用函数。如果字符串很长且包含很多特殊技字符，而你又不想输入一大堆反斜杠，例子：

s = 'A23G4HFD567N'

# Escape all the characters in pattern except ASCII letters, numbers and '_'.
# re.escape('www.python.org')  # 返回值 str

res = re.findall(re.escape('*+.py'), "jw.pyji w.py.f")
print(res)

# ['w.py', 'w.py']

purge()

  无参函数，用于清空缓存中的正则表达式，用于末尾，就好比其他语言中的close()、flush()，用来做相应的收尾工作。

Match Object

  Match对象在前面的例子中已经有例子了，提出来主要是为了更全面、更清晰。re.match()和re.search()函数如果匹配成功都会返回一个match对象，这里主要看看Match对象的一些方法应用。

import re

s = '234d567gg'
matched = re.search(r'(\d+)\w(\d+)', s, flags=0)

if matched:
    print(matched.groups())  # ('234', '567')

    print(matched.group())  # 234d567
    print(matched.group(1))  # 234
    print(matched.group(2))  # 567

    print(matched.span())  # (0,7)
    print(matched.start(0))  # 0
    print(matched.end(0))  # 7

    print(matched.expand(r'\2 \1'))  # 567 234 type is str
    # 注意这下面的用法 python3.6及以上才有的
    print(matched[0])  # 234d567
    print(matched[1])  # 234
    print(matched[2])  # 567

    # 属性
    print(matched.pos)  # 0
    print(matched.endpos)  # 7
    print(matched.string)  # 234d567
    print(matched.re)  # 返回的是regular expression object
    print(matched.lastindex)  # 2,这个2指的是 matched[i]
    print(matched.lastgroup)  # None