正则表达式：

re模块

-- match -- search -- findall -- split -- sub

基本语法

正则表达式：

正则表达式：

匹配一系列符合某个语法规则的字符串

作用：

• 验证文本的合法性
• 字符串搜索
• 字符串替换、匹配等

使用场景：

• 匹配以'1' 开头的字符串 '100'
• 匹配以数字开头的字符串 '200' '90'
• 使用' '对字符串进行分割："1 name_1 90"
• 使用' '或":"对字符串进行分割："1 name_1:90"
• 匹配有效的xml:<book>python</book>

s1 = '100'
s1.startswith('1')  #True

s2 = '200'
s2[0].isdigit() #True
s2[0:2].isdigit() #True

s3= "1 zhangsan 90"
s3.split()   #['1', 'zhangsan', '90']

re模块

import re 
compile(pattern,flags = 0) #返回pattern对象  pattern：正则表达式字符串
match(pattern,string,flags=0) #从头匹配，返回match对象 

m = re.match(r'\d',"10d") #1 
m.group()  #"1"

match对象

match对象	说明
m.start()/m.end()	匹配开始和结束时的索引
m.span()	匹配索引开始结束组成元组
m.group()	匹配的字符串
m.groups()	包含所有子组的元组
m.groupdict()	返回匹配的所有命名子组的字典

flag属性

flag	描述
re.I	匹配对大小写不敏感
re.L	做本地化识别匹配
re.M	多行匹配，改变'^'和'$'的行为
re.S	点任意匹配模式，改变'.'的行为
re.U	根据Unicode字符集解析字符
re.X	正则表达式可以是多行，忽略空白字符，并可以加入注释

m = re.match(r'a','Abc',re.I) #A

f正则表达式语法

字符	匹配
.	匹配任意字符(除了\n)
[...]	匹配字符集
\	转义符：\\ \. \*
\d/\D	匹配数字/非数字
\s/\S	匹配空白/非空白字符,空白字符包含：空格，tab,\n,\r,\s
\w/\W	匹配单词字符[a-zA-Z0-9]/非单词字符

m = re.match(r".",'123') #1
m = re.match(r".",'A23') #A
m = re.match(r".",'a23') #a
m = re.match(r".",'\n23') #不匹配
m = re.match(r".",'\r23') #\r
m = re.match(r".",'\n23',re.S) #\n
m = re.match(r"[1234567890]",'12') #1
m = re.match(r"[1234567890]",'02') #0
m = re.match(r"[0-9]",'02') #0
m = re.match(r"[0-9]",'42') #4
m = re.match(r"[a-z]",'abc') #a
m = re.match(r"[a-zA-Z0-9]",'0bc') #0
m = re.match(r"\.",'.42') #.
m = re.match(r"\D",'a2') #a
m = re.match(r"\s",' m2') #
m = re.match(r"\s",'\nm2') #
m = re.match(r"\S",'aam2') #a
m = re.match(r"\S",'\rm2') #不匹配
m = re.match(r"\w",'a2') #a
m = re.match(r"\w",'22') #2
m = re.match(r"\w",'#2') #不匹配
m = re.match(r"\W",'#2') # #
m = re.match(r"\W",'\r2') #\r
m = re.match(r"\d\w[a-z]",'40aabc') #40a
m = re.match(r"\d\w[a-z]",'40Aabc') #不匹配

正则表达式语法

字符	匹配
*	匹配前一个字符0次或无限次
+	匹配前一个字符1次或无限次
？	匹配前一个字符0次或1次
{m}/{m,n}	匹配前一个字符m次或m到n次
*?/+?/??	匹配模式变为非贪婪(尽可能少匹配字符)

m=re.match(r'\d*','123') #123
m=re.match(r'\d*','123abc') #123
m=re.match(r'\d*','a123abc') #不匹配
m=re.match(r'\d+','123abc') #123
m=re.match(r'\d*','123456abc') #123456

匹配0-99
十位：1-9
个位：0-9 \d

m=re.match(r'[1-9]?\d','0') #0
m=re.match(r'[1-9]?\d','100') #10
m=re.match(r'[1-9]?\d','19') #19
m=re.match(r'[1-9]?\d$','19') #19

匹配密码：字符+下划线 6-10位

m = re.match(r'\w[\w_]{5,9}','1234567890') #1234567890
m = re.match(r'\w[\w_]{5,9}','12345678901') #1234567890
m = re.match(r'\w[\w_]{5,9}$','12345678901') #不匹配
m = re.match(r'\w[\w_]{5,9}','a_12345678') #a_12345678
m = re.match(r'\w[\w_]{5,9}$','a_12') #不匹配
m= re.match(r'\w*?','100')  #*?非贪婪模式 返回空格
m= re.match(r'\w+?','100')  #*?非贪婪模式 返回1
m= re.match(r'\w*?','100')  #??非贪婪模式 返回空格

re模块常用方法

• search(pattern,string,flags = 0)
  查找整个字符串返回第一个匹配的对象、
  查找0-99之间数字字符串

• findall(pattern,string,flags=0)
  查找所有匹配，返回匹配对象组成的列表
  s="zhang:80,li:90,sun:40,zhao:70"
  计算给定学生的总分，平均分

m = re.search(r'\d+','zhang 89 li 90') #89
m = re.search(r'[1-9]?\d+','zhang 90') #90
m = re.search(r'[1-9]?\d+','zhang 0') #0
m = re.search(r'[1-9]?\d+','zhang 99') #99
m = re.search(r'[1-9]?\d+','zhang 199') #19

m= re.findall(r'\d','a1b2c3') #['1','2','3']
m= re.findall(r'\d','a12b22c33') #['12','22','33']

s='zhang:80,li:90,sun:40,zhao:70'
m = re.findall(r'[1-9]?\d',s) #['80','90','40','70']
r = map(int,m)
list(r) #[80,90,40,70]
print sum(r),sum(r)/len(r)

re模块

• split(pattern,string,maxsplit=0,flags=0)
  将表达式匹配位置分割并组成列表
  maxsplit是分离的次数，默认0，不限制次数
  如果字符串不能匹配，将会返回整个字符串的列表
  '1,zhang:80'解析：[1,zhang,80]

• sub(pattern,repl,string,count=0,flags=0)
  repl是字符串，使用该字符串替代匹配的字符串
  repl是函数，函数参数接收匹配match对象，使用repl返回的字符串代替匹配字符串
  count:替代的次数

m=re.split(r'\d','a1b2c3') #['a','b','c',' ']
m=re.split(r'\d','a1b2c3d') m #['a','b','c','d']

s='1,zhang:90'
m=re.split(r'[,:]',s) #['1','zhang','90']

s = 'password:123456'
m = re.sub(r'd','*',s) #'password:******'

s='zhao:90,li:80,sun:40,qian:59'
def mysub(match):
    s = match.group()  
    score = int(s)
    if score >= 60:
        return "pass"
    else:
        return"nopass"
m = re.sub(r'[1-9]?\d',mysub,s)
print m ##zhao:pass,li:pass,sun:nopass,qian:nopass

正则表达式语法

字符	匹配
^	匹配开头，支持多行
$	匹配结尾，支持多行
\A	匹配单行开头
\Z	匹配单行结尾

m = re.match(r'\d+','123d') #123
m = re.match(r'\d+','d123d') #不匹配
m = re.match(r'\d+$','123d') #不匹配
m = re.search(r'\d+$','1234') #1234

m = re.search('\d+','d123d') #123
m = re.search('^\d+','d123d') #不匹配
m = re.search('^\d+','123d') #123
m = re.search('^\d+$','123d') #不匹配
m = re.search('^\d+$','1234') #1234
m = re.search('^\d+$','1234') #1234

m = re.search('^\d+$','1234d\n456\n678',re.MULTILINE) #1234

邮箱的匹配：
用户名
-- 长度6-15
-- 开头：a-zA-Z0-9
-- 剩下的字符：[\w_]@xx.com
-- xx -- [\w] 2-6位

m = re.match(r'\w[\w_]{5,14}@[\w]{2,6}\.com','pythontest@163.com') #pythontest@163.com

m = re.match(r'\w[\w_]{5,14}@[\w]{2,6}\.com$','pythontest@163.com') #pythontest@163.com

正则表达式语法

字符	匹配
|	匹配|左右任意一个表达式
(...)(...)	括号中的表达式作为分组，编号默认加1
\<num>	引用编号num的分组匹配到的字符串;
(?P<name>)	分组起别名:(?P<name>\d)
(?P=name)	引用别名为name的分组匹配到的结果
(?:...)	不分组

m = re.match(r'ab|bc','bcd') #bc
m = re.match(r'[1-9]?\d$','0') #0
m = re.match(r'[1-9]?\d$','99') #99
m = re.match(r'[1-9]?\d$|100','100') #100

m = re.match(r'([1-9]?\d$)|100','100') #100  #100
m.group()  #'100'
m.groups()  #(None,'100')

m = re.match('(\d)\w','1a') #1a
m.groups() #('1',)

s='1 li 12'
m = re.match(r'(\d{1,2}) ([a-zA-Z]{2,20}) ([1-9]?\d|100)',s)  
m.groups() #('1','li','12')

#需要的格式 #2aaaa2
m = re.match(r'(\d)\w+(\d)','1001') 
m.groups()  #('1','1')

m = re.match(r'(\d)\w+(\d)','1002') #能匹配上，但是不符合规则

m = re.match(r'(\d)\w+(\1)','1001')  #这里的意思就是引用编号匹配前面的值
m.groups()  #('1','1')

m = re.match(r'(\d)\w+(\1)','2aa2')   #"2aa2"
m.groups()  #('2','2')

匹配<book>...</book>
m = re.match(r'<(\w{4})>\w+</(\1)>','<html>djdkljdl</html>') 

m = re.match(r'(?P<id>\d)\w+(\1)','2aa2') #这里是给\d起了别名
m.groups() # ('2','2')
m.groupdict() #{'id':'2'}

s = 'i li 12'
m = re.match(r'(?P<id>\d{1,2}) (?P<name>[a-zA-Z]{2,20}) (?P<score>[1-9]?\d|100)',s)
m.groupdict() #{'id':'1','name':'li','score':'12'}

m = re.match(r'(?P<id>\d)\w+(?P=id)','2aa2')  #2aa2

m = re.match(r'(?:\d){2}','12')  #12
m.groups() #()

m = re.match(r'\w(?:\d){2}','d12')  #d12
m.groups() #()