re模块
re模块
正则表达式
| 模式 | 描述 |
|---|---|
| ^ | 匹配字符串的开头 |
| $ | 匹配字符串的末尾。 |
| . | 匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。 |
| [...] | 用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k' |
| [^...] | 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。 |
| re* | 匹配0个或多个的表达式。 |
| re+ | 匹配1个或多个的表达式。 |
| re? | 匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式 |
| re | 匹配n个前面表达式。例如，"o{2}"不能匹配"Bob"中的"o"， 但是能匹配"food"中的两个o。 |
| re | 精确匹配n个前面表达式。例如，"o{2,}"不能匹配"Bob"中的"o"， 但能匹配"foooood"中的所有o。"o{1,}"等价于"o+"。"o{0,}"则等价于"o*"。 |
| re | 匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式 |
| a| b | 匹配a或b |
| (re) | 匹配括号内的表达式，也表示一个组 |
| (?imx) | 正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。 |
| (?-imx) | 正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。 |
| (?: re) | 类似 (...), 但是不表示一个组 |
| (?imx: | re) 在括号中使用i, m, 或 x 可选标志 |
| (?-imx: | re) 在括号中不使用i, m, 或 x 可选标志 |
| (?#...) | 注释. |
| (?= re) | 前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。 但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。 |
| (?! re) | 前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功。 |
| (?> re) | 匹配的独立模式，省去回溯。 |
| \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个分组的内容。 |
| \10 | 匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。 |
re常用函数
| 方法/属性 | 作用 |
|---|---|
| re.compile(pattern[, flags]) | 编译正则表达式，生成一个正则表达式（ Pattern ）对象， 供 match() 和 search() 这两个函数使用 |
| re.match(pattern, string, flags=0) | 从字符串的起始位置匹配， 如果起始位置匹配不成功的话，match()就返回none |
| re.search(pattern, string, flags=0) | 扫描整个字符串并返回第一个成功的匹配 |
| re.findall(pattern, string, flags=0) | 找到RE匹配的所有字符串，并把他们作为一个列表返回 |
| re.finditer(pattern, string, flags=0) | 找到RE匹配的所有字符串，并把他们作为一个迭代器返回 |
| re.sub(pattern, repl, string, count=0, flags=0) | 替换匹配到的字符串 |
python正则表达式flags标志位
| 标志 | 作用 |
|---|---|
| re.I | 使匹配对大小写不敏感 |
| re.L | 做本地化识别（locale-aware）匹配 |
| re.M | 多行匹配，影响 ^ 和 $ |
| re.S | 使 . 匹配包括换行在内的所有字符 |
| re.U | 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B. |
| re.X | 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。 |
例
#!/usr/bin/python3
# -*- conding:utf-8 -*-
import re
# 匹配电话号码（\d\d\d-\d\d\d\d-\d\d\d\d）
phonenum = re.compile(r'\d\d\d-\d\d\d\d-\d\d\d\d')
mo = phonenum.search('My number is 123-1234-1234')
print('电话：%s'%mo.group())
# 利用括号分组 （\d\d\d)-(\d\d\d\d-\d\d\d\d）
phonenum = re.compile(r'(\d\d\d)-(\d\d\d\d-\d\d\d\d)')
mo = phonenum.search('My number is 123-1234-1234')
print('group():\n电话：%s\n区号：%s\n号码：%s'% (mo.group(0),mo.group(1),mo.group(2)))
print('groups():\n区号：%s\n电话：%s'%mo.groups())
#用管道匹配多个分组(希望匹配多个表达式中的一个)
phonenum = re.compile(r'\d{3}-\d{4}-\d{4}|\d{8}') #匹配123-1234-1234或12345678格式的字符串
mo = phonenum.search('123-1234-1234 12345678')
print("管道匹配：\n电话：%s"%mo.group())
mo = phonenum.search('12345678 123-1234-1234')
print("管道匹配：\n电话：%s"%mo.group())
phonenum = re.compile(r'131(-\d{4}-\d{4}|\d{5})') #匹配123-1234-1234 或 12312345格式的字符串（123开头）
mo = phonenum.search('131-1234-1234')
print("管道匹配：\n电话：%s"%mo.group())
mo = phonenum.search('13112345')
print("管道匹配：\n电话：%s\n号码：%s"%(mo.group(),mo.group(1)))
#'?'（0或1）次匹配
phonenum = re.compile(r'131(-)?\d{4}(-)?\d{4}')
mo = phonenum.search('1311234-1234')
print("?:\n%s"%mo.group())
# ‘*’（0或多）次匹配
phonenum = re.compile(r'131(-)*\d{4}(-)*\d{4}(-)*')
mo = phonenum.search('1311234--1234---------------')
print('*:\n%s'%mo.group())
#'+'(1或多)次匹配
phonenum = re.compile(r'131(-)+\d{4}(-)+\d{4}(-)+')
mo = phonenum.search('131131-1234--1234-')
print('*:\n%s'%mo.group())
# “{}”匹配特定次数
phonenum = re.compile(r'131-\d{4}-\d{4}')
mo = phonenum.search('131131-1234-1234-')
print('{}:\n%s'%mo.group())
# "?"设置非贪心匹配
test = re.compile(r'(Ha){3,5}')
mo = test.search('HaHaHaHaHaHa')
print('贪心匹配：\n%s'%mo.group())
test = re.compile(r'(Ha){3,5}?')
mo = test.search('HaHaHaHaHaHa')
print('非贪心匹配：\n%s'%mo.group())
# findall()方法
phonenum = re.compile(r'\d{3}-\d{4}-\d{4}')
mo = phonenum.findall('123-1234-1234 789-5678-5678')
print('findall():\n%s'%mo)
phonenum = re.compile(r'(\d{3})-(\d{4})-(\d{4})')
mo = phonenum.findall('123-1234-1234 789-5678-5678')
print('findall():\n%s'%mo)
# []匹配分类字符
test = re.compile(r'[aeiouAEIOU]')
mo = test.findall('Holle World!')
print('[]:\n%s'%mo)
# '.'通配符(除换行之外的任意一个字符)
test = re.compile(r'.at')
mo = test.findall('The cat in the hat sat on the flat mat.')
print('".":\n%s'%mo)
# 不区分大小写匹配
test = re.compile(r'test', re.I)
mo = test.findall('test TEST Test tesT')
print('re.I不区分大小写：\n%s'%mo)
# sub()方法替换字符串
test = re.compile(r'Agent \w+')
mo = test.sub('#######','Agent 12345')
print("sub替换：\n%s"%mo)
# 复杂的的正则表达式
test = re.compile(r'''(
(\d{3}\(\d{3}\))? #area code
(\s|-|\.)? #separator
\d{3} #first 3 digits
(\s|-|\.) #separator
\d{4} #last 4 digits
(\s*(ext|x|ext.)\s*\d{2,5})? #extension
)''',re.VERBOSE)
mo = test.search('(123).123 1234 ext 12')
print(mo.group()
结果：
电话：123-1234-1234
group():
电话：123-1234-1234
区号：123
号码：1234-1234
groups():
区号：123
电话：1234-1234
管道匹配：
电话：123-1234-1234
管道匹配：
电话：12345678
管道匹配：
电话：131-1234-1234
管道匹配：
电话：13112345
号码：12345
?:
1311234-1234
*:
1311234--1234---------------
*:
131-1234--1234-
{}:
131-1234-1234
贪心匹配：
HaHaHaHaHa
非贪心匹配：
HaHaHa
findall():
['123-1234-1234', '789-5678-5678']
findall():
[('123', '1234', '1234'), ('789', '5678', '5678')]
[]:
['o', 'e', 'o']
".":
['cat', 'hat', 'sat', 'lat', 'mat']
re.I不区分大小写：
['test', 'TEST', 'Test', 'tesT']
sub替换：
#######
.123 1234 ext 12
