Python正则表达式

1. 正则表达式介绍

正则表达式是由一些字符和特殊符号组成的字符串
能按照某种模式匹配一系列有相同特征的字符串

2. 正则表达式中的符号

符号	描述
literal	匹配字面值
re1\|re2	匹配re1或re2
.	匹配任意字符(除\n)
^	匹配字符串起始部分
$	匹配字符串终止部分
*	匹配0次或多次前面出现的正则表达式
+	匹配1次或多次前面出现的正则表达式
?	匹配0次或1次前面出现的正则表达式
{N}	匹配N次前面出现的正则表达式
{M，N}	匹配M到N次前面出现的正则表达式
[…]	匹配来自字符集中任意单一字符
[…x-y…]	匹配x~y范围中任意单一字符
[^…]	不匹配次字符集中出现的字符
(*\|+\|?\|{})?	用于匹配上面重复出现符号的非贪婪版本(*、+、？、{})
(…)	匹配封闭的正则表达式，然后另存为子组

3. 正则表达式中的特殊字符

特殊字符	描述
\d	匹配任意十进制数字
\D	与\d相反
\w	匹配任何字母数字字符
\W	与\w相反
\s	匹配任何空格字符
\S	与\s相反
\b	匹配任何单词边界
\B	与\b相反
\N	匹配已保存的子组N
\c	逐字匹配任何特殊字符c，转义
\A	匹配字符串的起始
\Z	匹配字符串的结束

4. 正则表达式中的拓展表示法

拓展表示法	描述
(?iLmsux)	在正则表达式中嵌入一个或者多个特殊“标记”参数或者通过函数/方法
(?:…)	表示一个匹配不用保存的分组
(?P<name>…)	像一个仅由name标识而不是数字ID标识的正则分组匹配
(?P=name)	在同一字符串中匹配由(?P<name)分组的之前文本
(?#…)	表示注释，所有内容都被忽视
(?=…)	匹配条件是如果…出现在之后的位置，而不使用输入字符串；称作正向前视断言
(?!…)	匹配条件是如果…不出现在之后的位置，而不使用输入字符串；称作负向前视断言
(?<=…)	匹配条件是如果…出现在之后的位置，而不使用输入字符串；称作正向后视断言
(?<!…)	匹配条件是如果…不出现在之后的位置，而不使用输入字符串；称作负向后视断言
(?(id/name)Y\|N)	如果分组所提供的id或者name存在，就返回正则表达式的条件匹配Y，如果不存在，就返回N；\|N是可选项

5.贪婪模式和非贪婪模式

贪婪模式：在整个表达式匹配成功的前提下，尽可能多的匹配
非贪婪模式：在整个表达式匹配成功的前提下，以最少的匹配字符

默认为贪婪模式

# 贪婪模式
re: ab.+g
    abcgdefg --> abcgdefg
# 非贪婪模式
re: ab.+?g
    abcgdefg --> abcg

6. 身份证号、电子邮箱正则表达式匹配

# 身份证号
方法1: \d{17}([0-9]|X)
方法2: (\d{6})(\d{4})((\d{2})(\d{2}))\d{2}\d{1}([0-9]|X)
方法3: ^(\d{6})(\d{4})(\d{2})(\d{2})(\d{3})([0-9]|X)$ 
# 电子邮箱
方法1: [a-zA-Z0-9_-]+@[z-aA-Z0-9-]+(\.[a-zA-Z0-9-]+)*(\.[a-zA-Z]{2,5})
方法2: [\w!#$%&'*+/=?^_`{|}~-]+(?:\.[\w!#$%&'*+/=?^_`{|}~-]+)*@(?:[\w](?:[\w-]*[\w])?\.)+[\w](?:[\w-]*[\w])?
      
# 其它常用正则表达式
URL:https://tool.oschina.net/regex/#

7. 在python中使用正则表达式

7.1 re模块（下面flags）

属性	描述
re.l,re.LGNORECASE	不区分大小写的匹配
re.L,re.LOCALE	根据所使用的本地语言环境通过\w,\W,\b,\B,\s,\S实现匹配
re.M,re.MULTILINE	^和$分别匹配目标字符串中行的起始和结尾，而不是严格匹配整个字符串本身的起始和结尾
re.S,re.DOTALL	“.”点号通常匹配除了\n换行符之外的所有单个字符；该标记“.”点号能够匹配全部字符
re.X,re.VERBOSE	通过反斜线转义，否则所有空格加上#（以及在该行中所有后续文字）都被忽视，除非在一个字符类中或者允许注释并且提高可读性

7.2 函数

Re compile(pattern,flags=0) 不是必须的
MatchObj/None Re.match(string)如果匹配失败返回None,不能用flags,==从开头开始找，没找到就不找了==

MatchObj/None match(pattern,string,flags=0) 如果匹配失败返回None,==从开头开始找，没找到就不找了==

import re
re=re.compile(r'hello')
print(re) --> re.compile('hello')
print(type(re)) --> <class 're.Pattern'>
result=re.match("hello world")
print(result) --> <re.Match object; span=(0, 5), match='hello'>
print(type(result)) --> <class 're.Match'>
print(re.match("Hello world")) --> None

List Re.findall(string) 不能使用flags

List findall(pattern,string[,flags])

import re
list=re.findall(r'[a-zA-Z]+',"one1 two2 three3 four4")
print(list) --> ['one', 'two', 'three', 'four']
print(type(list)) --> <class 'list'>

MatchObj/None Re.search(string)如果没找到返回None,不能用flags,==从开头开始找，没找到就向后面找==

MatchObj/None search(pattern,string,flags=0)如果没找到返回None,==从开头开始找，没找到就不找了==

import re
result=re.search(r'world',"Hello world")
print(result) --> <re.Match object; span=(6, 11), match='world'>
print(type(result)) --> <class 're.Match'>

string MactchObj.group([num])
Tuple MatchObj.grounps()

Dict MatchObj.groupdict()

import re
matchObj=re.search(r'(\d{6})(\d{4})((\d{2})(\d{2}))\d{2}\d{1}([0-9]|X)',"425643200001013458")
matchObj.group() --> '425643200001013458'
matchObj.group(2) --> '2000'
matchObj.groups() --> ('425643', '2000', '0101', '01', '01', '8')

matchObj=re.search(r'(\d{6})(?P<year>\d{4})(?P<month>\d{2})(?P<day>\d{2})(\d{2})(\d{1})([0-9]|X)',"425643200001013458") 
matchObj.groups() --> ('425643', '2000', '01', '01', '34', '5', '8')
matchObj.groupdict() --> {'year': '2000', 'month': '01', 'day': '01'}

List split(pattern,string,max=0)
List Re.split(string,max=0)
String Re.sub(replace,string,max=0)

String sub(pattern,repalce/function/pattern,string,max=0)

import re
list=re.split(r'[a-zA-Z]',"one1two2three3")
type(list) --> <class 'list'>
list --> ['', '', '', '1', '', '', '2', '', '', '', '', '3']
list=re.split(r'\d+',"one1two2three3") 
list --> ['one', 'two', 'three', '']
list=re.split(r'\d+',"one1two2three3",2)
list --> ['one', 'two', 'three3']
string=re.sub(r'\d',"#","one1two2three3")
string --> 'one#two#three#'
# 正则表达式换位
string=re.sub(r'(\w+) (\w+)',r'\2 \1',"hello python")
string --> 'python hello'
# 正则表达式改变内容
string=re.sub(r'(\w+) (\w+)',lambda m: m.group(2).upper()+' '+m.group(1),"hello python")
string --> 'PYTHON hello'