标签：... 多语言 ret 表达 基础 .com 表示法 处理 十进制
正则表达式是一些由字符和特殊符号组成的字符串，用来匹配一系列有相似特征的字符串
python中通过标准库的re模块来支持正则表达式
| 表示法 | 描述 | 实例 |
| foo | 匹配字符串的字面值 | foo |
| re1|re2 | 匹配正则表达式re1或re2 | foo|bar|a |
| . | 匹配任何一个字符（除\n外） | b.b |
| ^ | 匹配字符串起始部分 | ^Dear |
| \A | 同上 | \ADear |
| $ | 匹配字符串终止部分 | /bin/*sh$ |
| \Z | 同上 | |
| * | 匹配0次或者多次前面出现的正则表达式 | [A-Za-z0-9]* |
| + | 匹配1次或者多次前面出现的正则表达式 | [a-z]+\.com |
| ? | 匹配0次或者1次前面出现的正则表达式 | goo? |
| {N} | 匹配N次前面出现的正则表达式 | [0-9]{3} |
| {M,N} | 匹配M~N次前面出现的正则表达式 | [0-9]{5,9} |
| [...] | 匹配来自字符集的任意单一字符 | [aeiou] |
| [..x-y..] | 匹配x~y范围中的任意单一字符 | [0-9],[A-Za-z] |
| [^...] | 不匹配此字符集中出现的任何一个字符，包括某一范围的字符 | [^aeiou],[^A-Za-z-9] |
| (*|+|?|{})? | 匹配上面频繁出现/重复出现符号的非贪婪版本(*,+,?,{}) | .*?[a-z] |
| (...) | 匹配封闭的正则表达式，然后另存为子组 | ([0-9]{3})?,f(oo|u)bar |
| \N | 匹配已保存的子组 | |
| \d | 匹配任何十进制数字，与[0-9]一致 | data\d+.txt |
| \D | 不匹配任何十进制数字 | |
| \w | 匹配任何字母数字字符，与[A-Za-z0-9_]相同 | [A-Za-z_]\w+ |
| \W | 不匹配任何字幕数字字符 | |
| \s | 匹配任何空格字符，与[\n\t\r\v\f]相同 | of\sthe |
| \S | 不匹配任何空格字符 | |
| \b | 匹配任何单词的边界 | \bThe\b |
| \B | 不匹配任何单词的边界 | |
| \c | 逐字匹配任何特殊字符 | \.,\\,\* |
| (?iLmsux) | 在正则表达式中嵌入一个或者多个特殊标记参数 | (?x),(? im) |
| (?....) | 表示一个匹配不用保存的分组 | (?:\w+\.)* |
| (?P<name>...) | 像一个仅由name标识而不是数字ID标识的正则分组匹配 | (?P<data>) |
| (?P=name) | 在同一字符串中匹配由(?P<name)分组的之前文本 | (?P=data) |
| (?#...) | 表示注释，所有内容都被忽略） | (?#comment) |
| (?=...) | 匹配条件是如果...出现在之后的位置，而不适用输入字符串；称作正向前视断言 | |
| (?!...) | 匹配条件是如果...不出现在之后的位置，而不适用输入字符串；称作负向前视断言 | |
| (?<=...) | 匹配条件是如果...出现在之前的位置，而不适用输入字符串；称作正向前视断言 | |
| (?<!...) | 匹配条件是如果...不出现在之前的位置，而不适用输入字符串；称作负向前视断言 | |
| (?(id/name)Y/N) | 如果分组所提供的id或者name存在，就返回正则表达式的条件匹配Y，如果不存在，就返回N | (?(1)y|x) |
几乎任何关于字符串的操作都可以使用正则表达式来完成，使用 python 标准库中的 re 模块。
正则表达式大致分为：
1.元字符
2.模式
3.函数
4.re内置对象用法
5.分组用法
6.环视用法
一、元字符 （参见 python 模块 re 文档）
二、模式
s = ‘hello World!‘
regex = re.compile("hello world!", re.I)
print regex.match(s).group()
#output> ‘Hello World!‘
#在正则表达式中指定模式以及注释
regex = re.compile("(?#注释)(?i)hello world!")
print regex.match(s).group()
#output> ‘Hello World!‘
s = ‘‘‘first line
second line
third line‘‘‘
# ^
regex_start = re.compile("^\w+")
print regex_start.findall(s)
# output> [‘first‘]
regex_start_m = re.compile("^\w+", re.M)
print regex_start_m.findall(s)
# output> [‘first‘, ‘second‘, ‘third‘]
#$
regex_end = re.compile("\w+$")
print regex_end.findall(s)
# output> [‘line‘]
regex_end_m = re.compile("\w+$", re.M)
print regex_end_m.findall(s)
# output> [‘line‘, ‘line‘, ‘line‘]
s = ‘‘‘first line
second line
third line‘‘‘
#
regex = re.compile(".+")
print regex.findall(s)
# output> [‘first line‘, ‘second line‘, ‘third line‘]
# re.S
regex_dotall = re.compile(".+", re.S)
print regex_dotall.findall(s)
# output> [‘first line\nsecond line\nthird line‘]
email_regex = re.compile("[\w+\.]+@[a-zA-Z\d]+\.(com|cn)")
email_regex = re.compile("""[\w+\.]+ # 匹配@符前的部分
@ # @符
[a-zA-Z\d]+ # 邮箱类别
\.(com|cn) # 邮箱后缀 """, re.X)
正则表达式的模式是可以同时使用多个的，在 python 里面使用按位或运算符 | 同时添加多个模式
如 re.compile(‘‘, re.I|re.M|re.S)
每个模式在 re 模块中其实就是不同的数字
print re.I # output> 2 print re.L # output> 4 print re.M # output> 8 print re.S # output> 16 print re.X # output> 64 print re.U # output> 32
三、函数 （参见 python 模块 re 文档）
python 的 re 模块提供了很多方便的函数使你可以使用正则表达式来操作字符串，每种函数都有它自己的特性和使用场景，熟悉之后对你的工作会有很大帮助
给定一个正则表达式 pattern，指定使用的模式 flags 默认为0 即不使用任何模式,然后会返回一个 SRE_Pattern (参见 第四小节 re 内置对象用法) 对象
regex = re.compile(".+")
print regex
# output> <_sre.SRE_Pattern object at 0x00000000026BB0B8>
这个对象可以调用其他函数来完成匹配，一般来说推荐使用 compile 函数预编译出一个正则模式之后再去使用，这样在后面的代码中可以很方便的复用它，当然大部分函数也可以不用 compile 直接使用，具体见 findall 函数
s = ‘‘‘first line
second line
third line‘‘‘
#
regex = re.compile(".+")
# 调用 findall 函数
print regex.findall(s)
# output> [‘first line‘, ‘second line‘, ‘third line‘]
# 调用 search 函数
print regex.search(s).group()
# output> first lin
转义 如果你需要操作的文本中含有正则的元字符，你在写正则的时候需要将元字符加上反斜扛 \ 去匹配自身， 而当这样的字符很多时，写出来的正则表达式就看起来很乱而且写起来也挺麻烦的，这个时候你可以使用这个函数,用法如下
s = ".+\d123"
#
regex_str = re.escape(".+\d123")
# 查看转义后的字符
print regex_str
# output> \.\+\\d123
# 查看匹配到的结果
for g in re.findall(regex_str, s):
print g
# output> .+\d123
参数 pattern 为正则表达式, string 为待操作字符串, flags 为所用模式，函数作用为在待操作字符串中寻找所有匹配正则表达式的字串，返回一个列表，如果没有匹配到任何子串，返回一个空列表。
s = ‘‘‘first line
second line
third line‘‘‘
# compile 预编译后使用 findall
regex = re.compile("\w+")
print regex.findall(s)
# output> [‘first‘, ‘line‘, ‘second‘, ‘line‘, ‘third‘, ‘line‘]
# 不使用 compile 直接使用 findall
print re.findall("\w+", s)
# output> [‘first‘, ‘line‘, ‘second‘, ‘line‘, ‘third‘, ‘line‘]
参数和作用与 findall 一样，不同之处在于 findall 返回一个列表， finditer 返回一个迭代器(参见http://www.cnblogs.com/huxi/archive/2011/07/01/2095931.html )， 而且迭代器每次返回的值并不是字符串，而是一个 SRE_Match (参见 第四小节 re 内置对象用法) 对象，这个对象的具体用法见 match 函数。
s = ‘‘‘first line
second line
third line‘‘‘
regex = re.compile("\w+")
print regex.finditer(s)
# output> <callable-iterator object at 0x0000000001DF3B38>
for i in regex.finditer(s):
print i
# output> <_sre.SRE_Match object at 0x0000000002B7A920>
# <_sre.SRE_Match object at 0x0000000002B7A8B8>
# <_sre.SRE_Match object at 0x0000000002B7A920>
# <_sre.SRE_Match object at 0x0000000002B7A8B8>
# <_sre.SRE_Match object at 0x0000000002B7A920>
# <_sre.SRE_Match object at 0x0000000002B7A8B8>
使用指定正则去待操作字符串中寻找可以匹配的子串, 返回匹配上的第一个字串，并且不再继续找，需要注意的是 match 函数是从字符串开始处开始查找的，如果开始处不匹配，则不再继续寻找，返回值为 一个 SRE_Match (参见 第四小节 re 内置对象用法) 对象，找不到时返回 None
s = ‘‘‘first line
second line
third line‘‘‘
# compile
regex = re.compile("\w+")
m = regex.match(s)
print m
# output> <_sre.SRE_Match object at 0x0000000002BCA8B8>
print m.group()
# output> first
# s 的开头是 "f", 但正则中限制了开始为 i 所以找不到
regex = re.compile("^i\w+")
print regex.match(s)
# output> None
当你在程序中使用 re 模块，无论是先使用 compile 还是直接使用比如 findall 来使用正则表达式操作文本，re 模块都会将正则表达式先编译一下， 并且会将编译过后的正则表达式放到缓存中，这样下次使用同样的正则表达式的时候就不需要再次编译， 因为编译其实是很费时的，这样可以提升效率，而默认缓存的正则表达式的个数是 100, 当你需要频繁使用少量正则表达式的时候，缓存可以提升效率，而使用的正则表达式过多时，缓存带来的优势就不明显了 (参考 《python re.compile对性能的影响》http://blog.trytofix.com/article/detail/13/)， 这个函数的作用是清除缓存中的正则表达式，可能在你需要优化占用内存的时候会用到。
函数类似于 match，不同之处在于不限制正则表达式的开始匹配位置
s = ‘‘‘first line second line third line‘‘‘ # 需要从开始处匹配 所以匹配不到 print re.match(‘i\w+‘, s) # output> None # 没有限制起始匹配位置 print re.search(‘i\w+‘, s) # output> <_sre.SRE_Match object at 0x0000000002C6A920> print re.search(‘i\w+‘, s).group() # output> irst
参数 maxsplit 指定切分次数， 函数使用给定正则表达式寻找切分字符串位置，返回包含切分后子串的列表，如果匹配不到，则返回包含原字符串的一个列表
s = ‘‘‘first 111 line second 222 line third 333 line‘‘‘ # 按照数字切分 print re.split(‘\d+‘, s) # output> [‘first ‘, ‘ line\nsecond ‘, ‘ line\nthird ‘, ‘ line‘] # \.+ 匹配不到 返回包含自身的列表 print re.split(‘\.+‘, s, 1) # output> [‘first 111 line\nsecond 222 line\nthird 333 line‘] # maxsplit 参数 print re.split(‘\d+‘, s, 1) # output> [‘first ‘, ‘ line\nsecond 222 line\nthird 333 line‘]
替换函数，将正则表达式 pattern 匹配到的字符串替换为 repl 指定的字符串, 参数 count 用于指定最大替换次数
s = "the sum of 7 and 9 is [7+9]."
# 基本用法 将目标替换为固定字符串
print re.sub(‘\[7\+9\]‘, ‘16‘, s)
# output> the sum of 7 and 9 is 16.
# 高级用法 1 使用前面匹配的到的内容 \1 代表 pattern 中捕获到的第一个分组的内容
print re.sub(‘\[(7)\+(9)\]‘, r‘\2\1‘, s)
# output> the sum of 7 and 9 is 97.
# 高级用法 2 使用函数型 repl 参数, 处理匹配到的 SRE_Match 对象
def replacement(m):
p_str = m.group()
if p_str == ‘7‘:
return ‘77‘
if p_str == ‘9‘:
return ‘99‘
return ‘‘
print re.sub(‘\d‘, replacement, s)
# output> the sum of 77 and 99 is [77+99].
# 高级用法 3 使用函数型 repl 参数, 处理匹配到的 SRE_Match 对象 增加作用域 自动计算
scope = {}
example_string_1 = "the sum of 7 and 9 is [7+9]."
example_string_2 = "[name = ‘Mr.Gumby‘]Hello,[name]"
def replacement(m):
code = m.group(1)
st = ‘‘
try:
st = str(eval(code, scope))
except SyntaxError:
exec code in scope
return st
# 解析: code=‘7+9‘
# str(eval(code, scope))=‘16‘
print re.sub(‘\[(.+?)\]‘, replacement, example_string_1)
# output> the sum of 7 and 9 is 16.
# 两次替换
# 解析1: code="name = ‘Mr.Gumby‘"
# eval(code)
# raise SyntaxError
# exec code in scope
# 在命名空间 scope 中将 "Mr.Gumby" 赋给了变量 name
# 解析2: code="name"
# eval(name) 返回变量 name 的值 Mr.Gumby
print re.sub(‘\[(.+?)\]‘, replacement, example_string_2)
# output> Hello,Mr.Gumby
作用与函数 sub 一样， 唯一不同之处在于返回值为一个元组，第一个值为替换后的字符串，第二个值为发生替换的次数
这个吧，咋一看和 compile 差不多，不过不支持 +、？、*、｛｝ 等这样的元字符，只要是需要有重复功能的元字符，就不支持，查了查资料，貌似没人知道这个函数到底是干嘛的...
四、re 内置对象用法
属性：
s = ‘Hello, Mr.Gumby : 2016/10/26‘
p = re.compile(‘‘‘(?: # 构造一个不捕获分组 用于使用 |
(?P<name>\w+\.\w+) # 匹配 Mr.Gumby
| # 或
(?P<no>\s+\.\w+) # 一个匹配不到的命名分组
)
.*? # 匹配 :
(\d+) # 匹配 2016
‘‘‘, re.X)
#
print p.flags
# output> 64
print p.groupindex
# output> {‘name‘: 1, ‘no‘: 2}
print p.groups
# output> 3
print p.pattern
# output> (?: # 构造一个不捕获分组 用于使用 |
# (?P<name>\w+\.\w+) # 匹配 Mr.Gumby
# | # 或
# (?P<no>\s+\.\w+) # 一个匹配不到的命名分组
# )
# .*? # 匹配 :
# (\d+) # 匹配 2016
函数：可使用 findall、finditer、match、search、split、sub、subn 等函数
属性：
s = ‘Hello, Mr.Gumby : 2016/10/26‘
m = re.search(‘, (?P<name>\w+\.\w+).*?(\d+)‘, s)
# 本次搜索的结束位置索引
print m.endpos
# output> 28
# 本次搜索匹配到的最后一个分组的别名
# 本次匹配最后一个分组没有别名
print m.lastgroup
# output> None
# 本次搜索匹配到的最后一个分组的索引
print m.lastindex
# output> 2
# 本次搜索开始位置索引
print m.pos
# output> 0
# 本次搜索使用的 SRE_Pattern 对象
print m.re
# output> <_sre.SRE_Pattern object at 0x000000000277E158>
# 列表，元素为元组，包含本次搜索匹配到的所有分组的起止位置 第一个元组为正则表达式匹配范围
print m.regs
# output> ((7, 22), (7, 15), (18, 22))
# 本次搜索操作的字符串
print m.string
# output> Hello, Mr.Gumby : 2016/10/26
函数：
s = ‘Hello, Mr.Gumby : 2016/10/26‘
m = re.search(‘‘‘(?: # 构造一个不捕获分组 用于使用 |
(?P<name>\w+\.\w+) # 匹配 Mr.Gumby
| # 或
(?P<no>\s+\.\w+) # 一个匹配不到的命名分组
)
.*? # 匹配 :
(\d+) # 匹配 2016
‘‘‘,
s, re.X)
# 返回指定分组的结束位置，默认返回正则表达式所匹配到的最后一个字符的索引
print m.end()
# output> 22
# 根据模版返回相应的字符串，类似与 sub 函数里面的 repl， 可使用 \1 或者 \g<name> 来选择分组
print m.expand("my name is \\1")
# output> my name is Mr.Gumby
# 根据提供的索引或名字返回响应分组的内容，默认返回 start() 到 end() 之间的字符串， 提供多个参数将返回一个元组
print m.group()
# output> Mr.Gumby : 2016
print m.group(1,2)
# output> (‘Mr.Gumby‘, None)
# 返回 返回一个包含所有匹配到的命名分组的字典，没有命名的分组不包含在内，key 为组名， value 为匹配到的内容，参数 default 为没有参与本次匹配的命名分组提供默认值
print m.groupdict(‘default_string‘)
# output> {‘name‘: ‘Mr.Gumby‘, ‘no‘: ‘default_string‘}
# 以元组形式返回每一个分组匹配到的字符串，包括没有参与匹配的分组，其值为 default
print m.groups(‘default_string‘)
# output> (‘Mr.Gumby‘, ‘default_string‘, ‘2016‘)
# 返回指定分组的起止未知组成的元组，默认返回由 start() 和 end() 组成的元组
print m.span(3)
# output> (18, 22)
# 返回指定分组的开始位置，默认返回正则表达式所匹配到的第一个字符的索引
print m.start(3)
# output> 18
五、分组用法
python 的正则表达式中用小括号 "(" 表示分组，按照每个分组中前半部分出现的顺序 "(" 判定分组的索引，索引从 1 开始，每个分组在访问的时候可以使用索引，也可以使用别名
s = ‘Hello, Mr.Gumby : 2016/10/26‘
p = re.compile("(?P<name>\w+\.\w+).*?(\d+)(?#comment)")
m = p.search(s)
# 使用别名访问
print m.group(‘name‘)
# output> Mr.Gumby
# 使用分组访问
print m.group(2)
# output> 2016
有时候可能只是为了把正则表达式分组，而不需要捕获其中的内容，这时候可以使用非捕获分组
s = ‘Hello, Mr.Gumby : 2016/10/26‘
p = re.compile("""
(?: # 非捕获分组标志 用于使用 |
(?P<name>\w+\.\w+)
|
(\d+/)
)
""", re.X)
m = p.search(s)
# 使用非捕获分组
# 此分组将不计入 SRE_Pattern 的 分组计数
print p.groups
# output> 2
# 不计入 SRE_Match 的分组
print m.groups()
# output> (‘Mr.Gumby‘, None)
如果你在写正则的时候需要在正则里面重复书写某个表达式，那么你可以使用正则的引用分组功能，需要注意的是引用的不是前面分组的 正则表达式 而是捕获到的 内容，并且引用的分组不算在分组总数中.
s = ‘Hello, Mr.Gumby : 2016/2016/26‘
p = re.compile("""
(?: # 非捕获分组标志 用于使用 |
(?P<name>\w+\.\w+)
|
(\d+/)
)
.*?(?P<number>\d+)/(?P=number)/
""", re.X)
m = p.search(s)
# 使用引用分组
# 此分组将不计入 SRE_Pattern 的 分组计数
print p.groups
# output> 3
# 不计入 SRE_Match 的分组
print m.groups()
# output> (‘Mr.Gumby‘, None, ‘2016‘)
# 查看匹配到的字符串
print m.group()
# output> Mr.Gumby : 2016/2016/
六、环视用法
环视还有其他的名字，例如 界定、断言、预搜索等，叫法不一。
环视是一种特殊的正则语法，它匹配的不是字符串，而是 位置，其实就是使用正则来说明这个位置的左右应该是什么或者应该不是什么，然后去寻找这个位置。
环视的语法有四种，见第一小节元字符，基本用法如下。
s = ‘Hello, Mr.Gumby : 2016/10/26 Hello,r.Gumby : 2016/10/26‘
# 不加环视限定
print re.compile("(?P<name>\w+\.\w+)").findall(s)
# output> [‘Mr.Gumby‘, ‘r.Gumby‘]
# 环视表达式所在位置 左边为 "Hello, "
print re.compile("(?<=Hello, )(?P<name>\w+\.\w+)").findall(s)
# output> [‘Mr.Gumby‘]
# 环视表达式所在位置 左边不为 ","
print re.compile("(?<!,)(?P<name>\w+\.\w+)").findall(s)
# output> [‘Mr.Gumby‘]
# 环视表达式所在位置 右边为 "M"
print re.compile("(?=M)(?P<name>\w+\.\w+)").findall(s)
# output> [‘Mr.Gumby‘]
# 环视表达式所在位置 右边不为 r
print re.compile("(?!r)(?P<name>\w+\.\w+)").findall(s)
# output> [‘Mr.Gumby‘]
高级一些的例子参见《正则基础之——环视(Lookaround)》(http://www.cnblogs.com/kernel0815/p/3375249.html)
标签：... 多语言 ret 表达 基础 .com 表示法 处理 十进制
原文地址：http://www.cnblogs.com/zz27zz/p/7458801.html
