正则表达式1-2-3

1.5之后增加了re模块,提供了正则表达式

re模块使python语言拥有了全部的表达式功能

import re # -------------re模块-------------

------------------re.match 函数-----------------------

原型:match(pattern, string, flags=0)

pattern：匹配的正则表达式

string: 要匹配的字符串

flags:标志位,用于控制正则表达式的匹配模式

常用前三个:

re.I 忽略大小写

re.S 匹配所有包括换行符在内的所有字符

re.M 多行匹配，影响^和$

# re.L 做本地识别

# re.U 根据Unicode字符集解析字符 影响\w \W \b \B

# re.X 更灵活的格式理解正则表达式

功能: 尝试从字符串起始位置匹配一个模式,如果不是起始位置匹配

成功的话,返回None

www.baidu.com

a = re.match(‘www’, ‘www.baidu.com’)
a1 = re.match(‘wwW’, ‘wwW.baidu.com’, flags=re.I) # 忽略大小写
a2 = re.match(‘www’, ‘www.baidu.com’).span() # 只打印位置
print(a)
print(a1)
print(a2)

#----------------------re.search函数-------------------------

re.search函数

原型:search(pattern, string, flags=0)

参数:

pattern：匹配的正则表达式

string：匹配的字符串

flags：标志位,用于控制正则表达式的匹配模式

功能:扫描整个字符串，并返回第一个成功匹配

Summer is a good man is good summer man

a = re.search(‘summer’, ‘Summer is a good man is good summer man’)
a1 = re.search(‘summer’, ‘Summer is a good man is good summer man’, flags=re.I)
print(a)
print(a1)

re.findall函数

原型:findall(pattern, string, flags=0)

参数:

pattern：匹配的正则表达式

string：匹配的字符串

flags：标志位,用于控制正则表达式的匹配模式

功能:扫描整个字符串，

d = re.findall(‘summer’, ‘Summer is a good man is good summer man’, flags=re.I)
print(d)

import re
print(’----------匹配单个字符与数字-----------’)

换行符除换行符以外的任意字符

[0123456789]

a = re.search(’[0123456789]’, ‘summer is a good man 6’)
a1 = re.search(’.’, ‘summer is a good man 6’)
print(a)
print(a1)

[a-z] 匹配任意小写字母

[A-Z] 匹配任意大写字母

[0-9] 匹配任意数字

[0-9a-zA-Z] 匹配任意数字和字母

[0-9a-zA-Z_] 匹配任意数字，字母和下划线

[^0-9] 匹配所有的非数字字符

print(’---------------------单字符------------------------’)

\d 匹配所有的数字

\D 匹配非数字字符

\w 匹配数字，字母和下划线

\W 匹配非数字、字母下划线

\s 匹配任意的空白符(空格、换行、回车、换页、制表)

\S 匹配任意的非空白符

c = re.findall(’\d’,‘sasas4sas7a4s4a4’)
print©

print(’-----------------锚字符(边界字符)---------------------’)

^ 行首匹配，和[^]里的不是一个意思

$ 行尾匹配

\A 匹配字符串开始，和^区别是，\A只匹配整个字符串的开头

\Z 匹配字符串结束，和^区别是，\A只匹配整个字符串的结束

\b 匹配一个单词的边界，值单词和空格间的位置

\B 匹配非单词边界

print(re.findall(’^summer’, ‘summer is a good man\nsummer is a good nice man’,re.M))
print(re.findall(‘man$’, ‘summer is a good man’))

print(re.findall(’\Asummer’,‘summer is a good man\nsummer is a good nice man’))
print(re.findall(‘summer\Z’,‘summer is a good man\nsummer is a good nice man’))

print(’--------------匹配多个字符--------------------’)

(xyz) 匹配小括号内的xyz(作为一个整体去匹配)

x? 匹配0或1个x

x* 匹配0或任意多个x(.*表示匹配0个或任意多个字符)

x+ 匹配至少一个x

x{n} 匹配确定的n个x(n是一个非负整数)

x{n,} 匹配至少n个x

x{n,m} 匹配至少n个最多m个 注意：n <= m

x|y

print(re.findall(r’a?’, ‘aaaaaa’)) # 一个一个匹配
print(re.findall(r’a*’, ‘aaabmaaa’)) # 多个匹配
print(re.findall(r’a+’, ‘aaaaaabaaaaa’))
print(re.findall(r’a{3}’, ‘aaabaa’))
print(re.findall(r’a{3,}’, ‘aaaaaaabaaaaa’))
print(re.findall(r’a{3,6}’, ‘aaaaaaa’))
print(re.findall(r’((a|A)line)’, ‘aline–Aline’))

提取sunck …man

str = ‘sunck is a good man is a nice man!sunck is a very handsome man’
print(re.findall(r’^sunck(.*?)man$’, str))

print(’----------------特殊--------------------’)

*? +? (xyz)? 最小匹配 通常都是尽可能多的模式，可以使用这种解决贪婪匹配

(?:x)

print(re.findall(r’//.?//’))

p = r’^1[34578]\d{9}$’
str = ‘13754698742’
p1 = re.findall(p, str)
print(p1)

import re

切割字符串

str1 = ‘summer is a good man’
print(re.split(r’ +’, str1)) # 至少一个空格

-------re.finditer 函数---------

原型:findall(pattern, string, flags=0)

参数:

pattern：匹配的正则表达式

string：匹配的字符串

flags：标志位,用于控制正则表达式的匹配模式

功能:扫描整个字符串，返回的是一个迭代器

str2 = ‘summer is a good man is a nice man!summer is a nice man summer is a good’
a = re.finditer(r’summer’,str2)
while True:
try:
p = next(a)
print(a)
except StopIteration as f:
break

字符串的替换和修改

sub(pattern, repl, string, count=0, flags=0)

subn(pattern, repl, string, count=0, flags=0)

pattern:正则表达式

repl：指定的用来替换的字符串

string：目标字符串

count：最多替换次数

flags：re.I等…

功能：在目标字符串中以正则表达式的规则匹配字符串，在吧他们替换成指定的字符串

可以指定替换的次数，不指定提花你所有的字符串

区别

str3 = ‘summer is a good good good man’
print(re.sub(r’(good)’, ‘nice’, str3, count=2)) # 返回值是字符串类型

re.subn() # 返回值是元祖类型 与sub一样 只不过是返回值类型不同

分组

概念:除了简单的判断是否匹配之外，正表达式还有提取子串得我功能

用(一组)表示就是分组

str4 = ‘010-12345689’
m = re.match(r’((\d{3})-(\d{8}))’, str4)
print(m.group(0)) # 0代表的是字符串本身
print(m.group(1))
print(m.group(2)) # 表达式里面有几个括号就只能分几组
print(m.group(3))

查看匹配的各组的情况

print(m.groups())

编译

compile(pattern,flags=0)

pattern:

模块调用

对象调用

re_qq = re.compile(r’¹\d{5,9}$’)
print(re_qq.search(‘4568158462’))

---

1. 1-9 ↩︎