正则表达式，是一个特殊的字符序列，又称规则表达式（英语：Regular Expression，在代码中常简写为regex、regexp 或RE），本质而言是一种小型的，高度专业化的编程语言。
Python 自1.5版本起增加了re 模块，re 模块使Python语言拥有全部的正则表达式功能。

语法

  • 开头结尾 | 模式 | 描述 | | :—-: | :—-: | | ^ | 从整个字符串开头的地方开始匹配 | | $ | 从整个字符串的结尾开始匹配 |
  • 模糊匹配 | 模式 | 描述 | | :—-: | :—-: | | . | 匹配任意字符，除了换行符 | | re? | 重复匹配？号前面0个或1个由前没正则表达式定义的片段，非贪婪方式 | | re | 重复匹配前面0个或多个表达式 | | re+ | 重复匹配+号前面1个或多个表达式 | | a | b | 匹配a或b |
  • 关于括号 | 模式 | 描述 | | :—-: | :—-: | | {} | 表示匹配“{}”前边的字符，制定个数为”{}”里边的数值 | | [] | 表示一个字符集，它常被用来指定一个字符类别，字符可以单个列出，也可以用”-“号分割两个给定字符来表示一个字符区间 | | () | 分组，将括号中的内容当作整体来对待 |
  • “\”反斜杠的应用 | 模式 | 描述 | | :—-: | :—-: | | \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个分组的内容，如果经匹配。否则指的是八进制字符码的表达式 |
  • 其他 | 模式 | 描述 | | :—-: | :—-: | | (?imx) | 正则表达式包含三种可选标志：i,m或x。只影响括号中的区域 | | (?-imx) | 正则表达式关闭i,m或x可选标志，只影响括号中的区域 | | (?:re) | 类似(…)但是不表示一个组 | | (?imx:re) | 在括号中使用i,m或x可选标志 | | (?-imx:re) | 在括号中不使用i,m或x可选标志 | | (?#…) | 注释 | | (?=re) | 前向肯定界定符。如果所含的正则表达式，以…表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。 | | (?!re) | 向前否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功 | | (?>re) | 匹配的独立模式，省去回溯 |

re模块用法

re.(function)(pattern[,flags])
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 为了增加可读性，忽略空格和#后面的注释

  • findall():全部找到，返回的是一个列表

findall(string[,pos[,endpos]])
参数：
 1.string : 待匹配的字符串。
 2.pos : 可选参数，制定字符串的起始位置，默认为0。
 3.endpos : 可选参数，制定字符串的结束位置，默认为字符串的长度。

  1. import re
  2. s = 'helloworld hellobeijing'
  3. ret = re.findall('hello\S+',s)
  4. print(ret)
  5. ['helloworld', 'hellobeijing']
  • finditer()

和findall类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回：
re.finditer(pattern,string,flags=0)
参数：
pattern : 匹配的正则表达式
string : 要匹配的字符串
flags ： 标志位，用于控制正则表达式的匹配方式,如：是否区分大小写，多行匹配等等

  • search()与match() : 返回的是一个对象

re.search/match(pattern,string,flags=0)
参数：
pattern : 匹配的正则表达式
string : 要匹配的字符串
flags ： 标志位，用于控制正则表达式的匹配方式,如：是否区分大小写，多行匹配等等

 可以使用group(num)或groups()匹配对象函数来获取匹配表达式。
匹配方法 | 描述
:-: | :-:
group(num=0)|匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组
groups()|返回一个包含所有小组字符串的元组，从1到所含的小组号
start([group])|方法用于获取分组匹配的字串在整个字符串中的起始位置（子串第一个字符的索引)，参数默认值为0
end([group])|方法用于获取分组匹配的字串在整个字符串中的结束位置（字串最后一个字符的索引+1），参数默认值为0
span([group])|方法返回（start(group),end(group)）

  1. import re
  2. # re.search
  3. ret = re.search('h..','hello hello world')
  4. print(ret) # 输出结果：<_sre.SRE_Match object; span=(0, 3), match='hel'>
  5. ret1 = re.search('h..','hello hello world').group()
  6. print(ret1) # 输出结果：hel 只输出第一个符合条件的结果
  8. # re.match
  9. ret = re.match('asd','asdhskdjfksji')
  10. print(ret) # 输出结果：<_sre.SRE_Match object; span=(0, 3), match='asd'>返回的是一个对象。
  11. ret1 = re.match('asd','asdhskdjfasdksjiasd').group()
  12. print(ret1) # 输出结果：asd 调用.group()方法，只返回匹配的第一个结果。

re.match和re.search的不同点：
 1. re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None
 2.re.search匹配整个字符串，直到找到一个匹配

  1. # re.search
  2. s = 'helloworld hellobeijing'
  3. ret = re.search('hellob\S+',s)
  4. print(ret)
  5. <re.Match object; span=(11, 23), match='hellobeijing'>
  7. # re.match
  8. s = 'helloworld hellobeijing'
  9. ret = re.match('hellob\S+',s)
  10. print(ret)
  11. None
  • split() 分隔符 对比字符串里边的split方法
    split方法按照能够匹配的字串将字符串分割后返回列表，它的使用形式如下：
     re.split(pattern,string[,maxsplit=0,flags=0])

参数 | 描述
:-: | :-:
pattern|匹配的正则表达式
string|要匹配的字符串
maxsplit|分隔次数，maxsplit=1分隔一次，默认为0，不限制次数
flags|标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志

  1. import re
  2. s = 'helloworld hellobeijing'
  3. ret = re.split('hello',s)
  4. print(ret)
  5. ['', 'world ', 'beijing']
  • sub()替换；类似字符串中的replace（）方法。

re.sub用于替换字符串中的匹配项。
语法：
 re.sub(pattern, repl, string, count=0, flags=0)
参数：
 1.pattern：正则中的模式字符串
 2.repl:替换的字符串，也可为一个函数
 3.string：要被查找替换的原始字符串
 4.count：模式匹配后替换的最大次数，默认0，表示替换所有的匹配

  1. import re
  2. s = 'helloworld hellobeijing'
  3. ret = re.sub('hello','goodbye',s)
  4. print(ret)
  5. goodbyeworld goodbyebeijing
  • compile(strPattern[,flag]):
    这个方法是Pattern类的工厂方法，用于将字符串形式的正则表达式编译为Pattern对象

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。
语法格式为：
 re.compile(pattern[, flags])
参数：
 1.pattern : 一个字符串形式的正则表达式
 2.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 为了增加可读性，忽略空格和 # 后面的注释

  1. import re
  2. pattern = re.compile('he.{3}')
  3. pattern.match(s)
  4. <re.Match object; span=(0, 5), match='hello'>