正则表达式

概述

正则表达式30分钟快速入门

正则表达式是文本处理极为重要的技术,用它可以对字符串按照某种规则进行检索,替换

基本语法

元字符

重点说明: 元字符匹配的都是一个字符

代码	说明	举例
.	匹配除换行符外的任意一个字符
[abc] /[a-z]	匹配中括号内出现的任意一个字符 /匹配a-z之间任意的一个字符
[^abc]	匹配去除括号内出现的任意字符
\b	匹配单词的边界	\bm,以m开头的字符例如m\b 以m结尾的字符
\B	不匹配单词的边界	t\B 包含t的单词但是不以t结尾的t字符，例如 write \Bb不以b开头的含有b的单词，例如able
\d	[0-9]匹配1位的字符
\D	[^0-9]匹配1位非数字
\s	匹配1位空白字符，包括换行符、制表符、空格 [ \f\r\n\t\v]
\S	匹配1位非空白字符
\w	匹配[a-zA-Z0-9_]，包括中文的字
\W	匹配\w之外的字符
[^abc]	中括号内的^ 表示除了中扩号内的都可以匹配

转义

凡是在正则表达式中有特殊意义的符号，如果想使用它的本意，请使用\转义。
反斜杠自身，得使用\
\r、\n还是转义后代表回车、换行

重复匹配

代码	说明	举例
*	表示前面的正则表达式会重复0次或多次	y\w* 单词中y后面可以有非空白字符
+	表示前面的正则表达式重复至少1	y\w+ 单词中y后面至少有一个非空白字符
?	表示前面的正则表达式会重复0次或1次	y\w? 单词中y后面至多有一个非空白字符可是1或者是0
{n}	重复固定的n次	y\w{1} 单词中y后面只能有一个非空白字符
{n,}	重复至少n次	y\w{1,} 等价 y\w+至少一次 y\w{0,} 等价 y\w*至少0次 y\w{0,1} 等价 y\w?至多1次
{n,m}	重复n到m次	y\w{1,10} 单词中y后面至少1个，至多10个非空白字符
x\|y	匹配x或者y字符	wood took foot food 使用 w\|food 或者(w\|f)ood

分组

代码	说明	举例
(pattem)	使用小括号指定一个子表达式，也叫分组捕获后会自动分配组号从1开始可以改变优先级	wood took foot food (w\|f)ood 得到两个分组一个是w的分组,另外一个是f的分组
\组数字	匹配对应的分组	(very) \1 匹配very very，但捕获的组 group是very
(?:pattern)	如果仅仅为了改变优先级，就不需要捕获分组	(?:w\|f)ood ’industr(?:y\|ies) 等价’industry\|industries
(? exp) (?'name’exp)	命名分组捕获，但是可以通过name访问分组 Python语法必须是(?Pexp)	(?P b)

断言

后面的断言不参与输出,但参与匹配,相当于判断

代码	说明	举例
(?=exp)	零宽度正预测先行断言断言exp一定在匹配的右边出现，也就是说断言后面一定跟个exp	f(?=oo) f后面一定有oo出现
(?<=exp)	零宽度正回顾后发断言断言exp一定出现在匹配的左边出现，也就是说前面一定有个exp前缀	(?<=f)ood、(?<=t)ook分别匹配ood、 ook，ook前一定有 t 出现
负向零宽断言
(?!exp)	零宽度负预测先行断言断言exp一定不会出现在右侧，也就是说断言后面一定不是exp	\d{3}(?!\d)匹配3位数字，断言3位数字后面一定不能是数字 foo(?!d) foo后面一定不是d
(?<!exp)	零宽度负回顾后发断言断言exp一定不能出现在左侧，也就是说断言前面一定不能是exp	(?<!f)ood ood的左边一定不是f

贪婪与非贪婪

默认模式是贪婪模式,也就是尽可能多的匹配更长的字符

非贪婪模式很简单,在重复的符号后面加上一个 ? 问号,就尽量的少匹配了.

代码
*?	匹配任意次,但尽可能的少重复
+?	匹配至少1次,但尽可能的少重复
??	匹配0次或1次,但尽可能的少重复
{n}?	匹配至少n次,但尽可能的少重复
{n,m}?	匹配至少n次,至多m次,但尽可能的少重复

单行模式与多行模式

单行模式：

将原有点的能力增强,去掉了原先换行符,也就是点功能可以匹配任意字符,从头到尾

. 可以匹配所有字符，包括换行符

^ 表示整个字符串的开头，$整个字符串的结尾

多行模式：
. 可以匹配除了换行符之外的字符，多行不影响.点号

^ 表示行首，$行尾，只不过这里的行是每一个行

**默认模式：**可以看做待匹配的文本是一行，不能看做多行，.点号不能匹配换行符，^和$表示行首和行尾，而行首行尾就是整个字符串的开头和结尾

单行模式和多行模式都没勾选在默认模式下没有多行的概念默认模式下,不管文本多少行,都只认为一行,即使有换行符

元字符点不能匹配换行 ,匹配时会被阻隔

单行模式：基本和默认模式一样，只是.点号终于可以匹配任意一个字符包括换行符，这时所有文本就是一个长长的只有一行的字符串。^就是这一行字符串的行首，$就是这一行的行尾。

多行模式：重新定义了行的概念，但不影响.点号的行为，^和$还是行首行尾的意思，只不过因为多行模式可以识别换行

符了。"开始"指的是\n后紧接着下一个字符；"结束"指的是\n前的字符，注意最后一行结尾可以没有\n

简单讲，单行模式只影响.点号行为，多行模式重新定义行影响了^和$

注意：注意字符串中看不见的换行符,\r\n会影响e的测试，e的测试，e的测试，e只能匹配e\ns

举例:

# 现有文本如下
wood
food
feet
在不同模式下匹配的结果分别是什么
^.+$      ^.+ 结果又是什么呢?
单行模式:   woodfoodfeet  #总共14个字符位,算是换行符##分隔符 与前面一样
多行模式    None                                ##分隔符  wood   food  feet #每个单词都是4个字符位
单多行      woodfoodfeet                        ##分隔符   与单行模式一样
默认        None                                ##分隔符   只有一个wood,不能越过换行符

其他补充:

代码	说明	举例
^	以什么开头	^\w任意[a-zA-Z0-9_]开头
$	以什么结尾	$w 匹配以字符w结尾

了解了正则表达式的基本语法之后就可以到python 中应用了.

Python的正则表达式

Python 使用re模块提供了正则表达式的处理能力

定义模式

代码	说明
re.M re,MULTIINE	多行模式
re.S re.DOTALL	单行模式
re.l re.IGNORECASE	忽略大小写
re.X re.VERBOSE	忽略表达式中的空白字符

方法

编译

re.compile( '正则表达式名',flag = 0)
# 返回值是正则表达式对象  缺省值flag  = 0,可以自己设定如,re.M  re.S  或者组合使用   re.M | re.S
# 这里的叠加使用的是字节的异或运算,每一种模式都是2的n次幂,这样在异或运算时不会互相影响

编译的好处就是先行编译,可以提高效率.

单次匹配

可以分类为re.match 和re.search

match 匹配字符从字符的开头匹配,不论正则表达式条件是什么,都是从开头进行匹配

serach 匹配是从头搜索直到第一个匹配

re.fullmatch(‘正则表达式’,目标源,flag = 0) 整个文本的匹配

若先编译后

regex = re.compile( ‘正则表达式名’,re.M| re.S)

regex.match(string[, pos[, endpos]]) 可以匹配从指定位置,或者从指定位置到指定位置结束,返回match对象

同样regex.search(string[, pos[, endpos]]) 也是可以设定开始位置和结束位置,返回match对象

regex.fullmatch(string[, pos[, endpos]]) 用法同上

举例:

import re
s = '''bottle\nbag\nbig\napple'''
for i, c in enumerate(s,1):  # 起始值从1 开始.不然0%10 也等于0,会多打印一行print((i-1,c),end = '\n'if i%10==0 else ' ')
"""打印出字符串索引对应的字符下面用到"""
# match方法
print(re.match('b',s))
>>><_sre.SRE_Match object; span=(0, 1), match='b'>
#返回的是一个match对象,包含了匹配结果,匹配的索引位置
print(re.match('a',s))  # match是从头寻找,找不到
print(re.match('a',s,re.M))# 同样即使是多行,同样是从头匹配,返回None
print(re.match('^a',s,re.S))#同上
print(re.match('^a',s,re.M))#同上
# 先编译,然后使用正则表达式对象
regex = re.compile('a')
print(regex.match(s))  #重头匹配返回None
print(regex.match(s,15))#重15位置开始匹配,能匹配到
>>><_sre.SRE_Match object; span=(15, 16), match='a'>
#search方法
print(re.search('a',s))
>>><_sre.SRE_Match object; span=(8, 9), match='a'>
# 返回的match对象
regex = re.compile('b')
result = regex.search(s, 1)  #重索引1 开始匹配,第1位是o,所以向后匹配
print(8, result) #
regex = re.compile('^b', re.M) # 以b开头的多行模式
result = regex.search(s) # 不管是不是多行，找到就返回
print(8.5, result) # bottle
result = regex.search(s, 8)
print(9, result) # big
# fullmatch方法
result = re.fullmatch('bag', s)#完全匹配bag 因为模式是一行全部文本,所以不匹配
print(10, result)
regex = re.compile('bag')
result = regex.fullmatch(s)
print(11, result)
result = regex.fullmatch(s, 7)# 返回None
print(12, result)
result = regex.fullmatch(s, 7, 10)  # 在设定范围内存在,所以返回bag
print(13, result) # 要完全匹配，多了少了都不行, [7, 10)

全文匹配

import re
re.findall('正则表达式,string ,flag = 0) # 对正个字符串,从左向右匹配,返回所有匹配项的列表
re.finditer('正则表达式',string,flag = 0) # 对整个字符串,从左向右匹配,返回所有匹配项,返回一个迭代器
#先编译
regex=compil('pattern',re.M)
regex.findall(string,[, pos[, endpos]])
regex.finditer(string[, pos[, endpos]])
#可以从设定位置开始按需匹配

敲黑板 :

re.findall 返回的是一个结果表,遍历列表可以打印出匹配的结果

re.finditer 返回的是一个迭代器,用遍历的方法得到的是match 对象

一定要区分二者之间的区别

举例:

# findall方法
result = re.findall('b', s)
print(1, result)
regex = re.compile('^b')
result = regex.findall(s)
print(2, result)
regex = re.compile('^b', re.M)
result = regex.findall(s, 7)
print(3, result) # bag big
regex = re.compile('^b', re.S)
result = regex.findall(s)
print(4, result) # bottle
regex = re.compile('^b', re.M)
result = regex.findall(s, 7, 10)
print(5, result) # bag
# finditer方法
result = regex.finditer(s)
print(type(result))
r = next(result)
print(type(r), r) # Match对象
print(r.start(), r.end(), s[r.start():r.end()])
r = next(result)
print(type(r), r)
print(r.start(), r.end(), s[r.start():r.end()])
#总结
#用regex.finditer(s)返回的迭代器中提取字符索引
reuslt = regex.finditer(s)
r = next(result)
r.start(),r.end(),
#切片得到索引
s[r.start(),r.end()]   #  变可以得到匹配的字符串

匹配替换

re.sub(pattern, replacement, string, count=0, flags=0)
regex.sub(replacement, string, count=0)
使用pattern对字符串string进行匹配，对匹配项使用repl替换。
replacement可以是string、bytes、function。

re.subn(pattern, replacement, string, count=0, flags=0)
regex.subn(replacement, string, count=0)
同sub返回一个元组（new_string， number_of_subs_made）

count 表示替换的次数,默认是全文替换.

举例

# 替换方法
regex = re.compile('b\wg')
result = regex.sub('stydu', s)
print(result) # 被替换后的字符串
>>>
studyttle
studyg
studyg
apple
result = regex.sub('study', s, 1) # 替换1次
regex = re.compile('\s+')
result = regex.subn('\t', s)
print(result) # 被替换后的字符串及替换次数的元组
>>>
('bottle\tbag\tbig\tapple', 3)
# 返回的是一个元组类型

字符串分隔

字符串的分割可以使用split,但是该方法不能对多个字符进行分割

python中使用re.split对字符串进行分割

举例:

import re
s = """
os.path.abspath(path)
normpath(join(os.getcwd(), path)).
"""
result = re.split('\W',s)
# 分割后返回的是一个列表对象

分组

使用小括号的pattern捕获的数据被放到了组group中。
match、search函数可以返回match对象；findall返回字符串列表；finditer返回一个个match对象
如果pattern中使用了分组，如果有匹配的结果，会在match对象中

使用group(N)方式返回对应分组，1到N是对应的分组，0返回整个匹配的字符串，N不写缺省为0
如果使用了命名分组，可以使用group(‘name’)的方式取分组
也可以使用groups()返回所有组
使用groupdict() 返回所有命名的分组

举例:

regex = re.compile('(b\w+)')
result = regex.match(s) # 从头匹配一次
print(type(result))
print(1, 'match', result.groups())
result = regex.search(s, 1) # 从指定位置向后匹配一次
print(2, 'search', r                                                                                                                                                                                                                              esult.groups()) #
# 命名分组
regex = re.compile('(b\w+)\n(?P<name2>b\w+)\n(?P<name3>b\w+)')
result = regex.match(s)print(3, 'match', result)
print(4, result.group(3), result.group(2), result.group(1))
print(5, result.group(0).encode()) # 0 返回整个匹配字符串，即match
print(6, result.group('name2'), result.group('name3'))
print(6, result.groups())
print(7, result.groupdict())
result = regex.findall(s) # 返回什么，有几项？
###############################
**#当正则匹配项中,若存在两个以上分组,那么返回的结果就是将所有的分组封装成一个元组作为一个元素放到列表当中.**
for x in result: # 有分组里面放的东西不一样print(type(x), x)
regex = re.compile('(?P<head>b\w+)')
result = regex.finditer(s)
for x in result:
print(type(x), x, x.group(), x.group('head'))

python学习之 ---正则表达式规则与正则表达式在python的应用相关推荐

小猪的Python学习之旅 —— 6.捋一捋Python线程概念
小猪的Python学习之旅 -- 6.捋一捋Python线程概念标签: Python 引言从刚开始学习Python爬虫的时候,就一直惦记着多线程这个东西, 想想每次下载图片都是单线程,一个下完继续 ...
python教程400集笔记,Python学习中的笔记--集合相关，python笔记--集合
Python学习中的笔记--集合相关,python笔记--集合集合的基本操作一.可修改的集合set 创建集合 var = set() var = {'a','b','c','d'} 成员检测 va ...
python学习网站-有哪些值得推荐的Python学习网站？
======2019.02.04更新======== 更多文章内容,欢迎关注我的微信公众号:云时代的运维开发 #*******前言*******# 学习和关注python有五年多的时间. 收藏了一些不 ...
python学习需要基础吗_要学 Python 需要怎样的基础？
人邮君来补充一点,编程也需要"语感训练"的理论基础.[内附Python语感训练资料] 看似虚无缥缈的"语感",对编程也有用? 在上世纪80年代,有一部BBC推出 ...
我的python学习笔记全集_记录我的Python学习笔记
不想再像以前那样,什么都从头开始学习语法.总结语法,这样反而会过分纠结于语法,耽误了开发,毕竟语言的主要属性是工具,次要的属性是语言本身. 所以还是先熟练使用语言去进行开发,等足够熟悉了,再去研究语言 ...
python学习每日一题【20200226】python实现“分解质因数”的计算
题目: 每日一练(2-26): 题目:将一个整数分解质因数.例如:输入90,打印出90=2*3*3*5 实现方法: 百度百科里对分解质因数的定义: 把一个合数分解成若干个质因数的乘积的形式,即求质因数 ...
Python学习必备：10个奇妙的Python库，看完后我惊呆了
前言 10个奇妙的Python库,看完后我惊呆了! 让我们愉快地开始吧~编程学习资料点击免费领取开发工具 Python版本: 3.6.4 相关模块: socket模块: textblob模块: py ...
python学习软件破解版_Thonny下载-Thonny(Python编程学习软件)v2.2.2官方免费版-ucbug下载站...
Thonny是一款专门针对python初学者开发的编程学习软件.使用一个友好的IDE,为您提供几个有用的学习工具,所有这些都打包成一个直观的GUI,让你更快的熟悉Python编程语言. 功能特点: 容 ...
python编程第5版_正版 Python学习手册(原书第5版) python编程从入门到精通 python入门计算机网络...
上册前言1 部分使用入门章问答环节21 人们为何使用Python21 软件质量22 开发者效率23 Python是一门"脚本语言"吗23 好吧,Python的缺点是什么25 如 ...

python学习之 ---正则表达式规则与正则表达式在python的应用

正则表达式

概述

分类

基本语法

元字符

转义

重复匹配

分组

断言

贪婪与非贪婪

单行模式与多行模式

Python的正则表达式

方法

字符串分隔

分组

python学习之 ---正则表达式规则与正则表达式在python的应用相关推荐

最新文章

热门文章

python学习之 ---正则表达式规则与正则表达式在python的应用

正则表达式

概述

分类

基本语法

元字符

转义

重复匹配

分组

断言

贪婪与非贪婪

单行模式 与多行模式

Python的正则表达式

方法

字符串分隔

分组

python学习之 ---正则表达式规则与正则表达式在python的应用相关推荐

最新文章

热门文章

单行模式与多行模式