#正则

元字符

表达式	匹配
.	小数点可以匹配除了换行符\n以外的任意一个字符
\|	逻辑或操作符
[]	匹配字符集中的一个字符
[^]	对字符集求反，也就是上面的反操作。尖号必须在方括号里的最前面
-	定义[]里的一个字符区间，例如[a-z]
\	对紧跟其后的一个字符进行转义
()	对表达式进行分组，将圆括号内的内容当做一个整体，并获得匹配的值

转义字符\

把原本的意义去掉。 “.”任意-----“\.”
添加意义 “t”-----“\t”制表符

表达式	匹配
\r, \n	匹配回车和换行符
\t	匹配制表符
\\	匹配斜杠\
\^	匹配^符号
\$	匹配$符号
\.	匹配小数点.

预定义匹配字符

表达式	匹配
\d	任意一个数字，0~9中的任意一个
\w	任意一个字母或数字或下划线，也就是A~Z,a~z,0~9,_ 中的任意一个
\s	空格、制表符、换页符等空白字符的其中任意一个
\D	\d的反集，也就是非数字的任意一个字符，等同于[^\d]
\W	\w的反集，也就是[^\w]
\S	\s的反集，也就是[^\s]

#\d 匹配数字0-9

a= re.findall("\d","red84")

#print(a) #['8', '4']

#\D \d相反，\d不要的，\D要

a= re.findall("\D","red84")

#print(a) #['r', 'e', 'd']

#\w 匹配字母、数字、下划线

b= re.findall("\w","red84\nred79")

#print(b) #['r', 'e', 'd', '8', '4', 'r', 'e', 'd', '7', '9']

#\W \w的相反

b= re.findall("\W","red84\nred79")

#print(b) #['\n']

#\s 匹配空格、换行符、制表符

c = re.findall("\s","red84\nred79")

#print(c) #['\n']

#\S \s相反

c = re.findall("\S","red84\nred79")

print(c) #['r', 'e', 'd', '8', '4', 'r', 'e', 'd', '7', '9']

重复匹配

表达式	匹配
{n}	表达式重复n次，比如\d{2}相当于\d\d,a{3}相当于aaa
{m,n}	表达式至少重复m次，最多重复n次。比如ab{1,3}可以匹配ab或abb或abbb
{m,}	表达式至少重复m次，比如\w\d{2,}可以匹配a12,_1111,M123等等
?	匹配表达式0次或者1次，相当于{0,1}，比如a[cd]?可以匹配a,ac,ad
+	表达式至少出现1次，相当于{1,}，比如a+b可以匹配ab,aab,aaab等等
*	表达式出现0次到任意次，相当于{0,}，比如\^*b可以匹配b,^^^b等等

#{n} 匹配字符出出现n次

a = re.findall("l{2}","yellow")

#print(a) #['ll']

#{m,n} 匹配最少m次，最多n次

b= re.findall("l{2,4}","I like you,yellow,alllow,allll")

#print(b) #['ll', 'lll', 'llll']

#{m,} 至少是m次上不封顶

c= re.findall("l{2,}","yellow,alll,allll,alllll")

#print(c) #['ll', 'lll', 'llll', 'lllll']

#? 匹配0和1次

d = re.findall("l?","like,yellow")

#print(d) #['l', '', '', '', '', '', '', 'l', 'l', '', '', '']

#+ 至少出现1次

e = re.findall("l+","like,yellow")

#print(e) #['l', 'll']

# * 出现0次到任意次

f = re.findall("l*","like,yellow")

print(f) #['l', '', '', '', '', '', '', 'll', '', '', '']

位置匹配

表达式	匹配
^	在字符串开始的地方匹配，符号本身不匹配任何字符
$	在字符串结束的地方匹配，符号本身不匹配任何字符
\b	匹配一个单词边界，也就是单词和空格之间的位置，符号本身不匹配任何字符
\B	匹配非单词边界，即左右两边都是\w范围或者左右两边都不是\w范围时的字符缝隙

# ^ 开头

a = re.findall("^1","18539334875")

print(a) #['1']

# $ 结尾

b = re.findall("X$","44456789098765432X")

print(b) #['X']

贪婪模式/非贪婪模式

“贪婪模式”总是尝试匹配尽可能多的字符；

“非贪婪模式”则相反，总是匹配尽可能少的字符

a = re.findall(".","apple,orange,banaba")

print(a) #['a', 'p', 'p', 'l', 'e', ',', 'o', 'r', 'a', 'n', 'g', 'e', ',', 'b', 'a', 'n', 'a', 'b', 'a']

b = re.findall("^a","apple,orange,banaba")

print(b) #['a']

#re模块

定义

re模块是python独有的匹配字符串的模块，该模块中提供的很多功能是基于正则表达式实现的

常用方法

方法	描述	返回值
compile(pattern)	根据包含正则表达式的字符串创建模式对象	re对象
search(pattern, string)	在字符串中查找。第一个匹配到的对象或者None	返回一个match对象
match(pattern, string)	在字符串的开始处匹配模式。在字符串开头匹配到的对象或者None	返回一个match对象
findall(pattern, string,flags)	列出字符串中模式的所有匹配项	所有匹配到的字符串列表
finditer(pattern, string,flags)	将所有匹配到的项生成一个迭代器	所有匹配到的字符串组合成的迭代器
match.group(index)	将match对象拆分成字符串。不写index默认是0	返回match object中的字符串/元组
match.groups()	将match对象转换成元组	返回由所有分组匹配到的字符串组成的tuple。
match.start(index)	没有参数时，返回匹配到的字符串的起始位置。指定参数（整数）时，返回该分组匹配到的字符串的起始位置	返回int类型
match.end(index)	没有参数时，返回匹配到的字符串的结束位置。指定参数（整数）时，返回该分组匹配到的字符串的结束位置。	返回int类型
match.span(index)	返回一个二元tuple表示匹配到的字符串的范围，即(start, end)	返回元组
split(pattern, string)	根据模式的匹配项来分割字符串	分割后的字符串列表
sub(repl, string,count=0)	将字符串中所有的pat的匹配项用repl替换	完成替换后的新字符串
subn(pat,repl, string)	在替换字符串后，同时报告替换的次数	完成替换后的新字符串及替换次数
escape（string）	将字符串中所有特殊正则表达式字符串转义	转义后的字符串
purge(pattern)	清空正则表达式
template(pattern)	编译一个匹配模板	模式对象
fullmatch(pattern, string)	match方法的全字符串匹配版本	类似match的返回值

代码

查询模块

#compile(pattern)  根据包含正则表达式的字符串创建模式对象    re对象
r = re.compile("[0-9]")
print(r) #返回一个编译正则的re对象

"""
re.IGNORECASE：忽略大小写，同 re.I。
re.MULTILINE：多行模式，改变^和$的行为，同 re.M。
re.DOTALL：点任意匹配模式，让'.'可以匹配包括'\n'在内的任意字符，同 re.S。
re.LOCALE：使预定字符类\w \W \b \B \s \S 取决于当前区域设定，同 re.L。
re.ASCII：使 \w \W \b \B \s \S 只匹配 ASCII 字符，而不是Unicode 字符，同 re.A。
re.VERBOSE：详细模式。
"""
import re
b = re.compile(r"[a-w]",re.I)
a = b.findall("ADbcG")
print(a) #['A', 'D', 'b', 'c', 'G']

a = re.compile(r"""\d + # the integral part\. # the decimal point\d * # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")

#search(pattern, string)    在字符串中查找    第一个匹配到的对象或者None
#扫描整个字符串，并返回它找到的第一个匹配（Match object）
r = re.compile("[0-9]")
a = r.search("123abc456")
print(a) #<re.Match object; span=(0, 1), match='1'>

#match(pattern, string) 在字符串开头匹配到的对象或者None      返回一个match对象
r = re.compile("[0-9]")
a = r.match("123abc456")
#a = r.match("123abc456")  #开头不是数字，所以输出None
print(a) #<re.Match object; span=(0, 1), match='1'>

#findall(pattern, string,flags)    列出字符串中模式的所有匹配项    所有匹配到的字符串列表
r = re.compile("[0-9]")
a = r.findall("123abc4567")
print(a) #['1', '2', '3', '4', '5', '6', '7']

#  finditer(pattern, string,flags)    将所有匹配到的项生成一个迭代器   返回一个迭代器
r = re.compile("[0-9]")
a = r.finditer("123abc456")
print(a) #<callable_iterator object at 0x0000020C599BFA88>
print(list(a))
"""
[<re.Match object; span=(0, 1), match='1'>,
<re.Match object; span=(1, 2), match='2'>,
<re.Match object; span=(2, 3), match='3'>,
<re.Match object; span=(6, 7), match='4'>,
<re.Match object; span=(7, 8), match='5'>,
<re.Match object; span=(8, 9), match='6'>]
"""

match相关方法

#match.group(index)将match对象拆分成字符串。不写index默认是0返回match object中的字符串
"""
分组编号从1开始，从左往右，每遇到一个左括号，分组编号+1。
组0总是存在的，它就是整个表达式。
没有参数时，group1默认为0，这时返回整个匹配到的字符串。
"""
#空格不要忘了
r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you")
print(a)  #<re.Match object; span=(0, 6), match='I LOvE'>
print(a.group()) #I LOvE   默认是0
print(a.group(1)) #I
print(a.group(2)) #LOvE
print(a.group(3)) #报错

"""指定多个参数的时候，就返回一个元组
"""
print(a.group(1,2)) #('I', 'LOvE')

r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you")
print(a.groups()) #('I', 'LOvE')

#match.start(index)没有参数时，返回匹配到的字符串的起始位置。指定参数（整数）时，返回该分组匹配到的字符串的起始位置
r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you")
print(a.start()) #0
print(a.start(2)) #2  第二个单词的起始位置是2，下标从0开始

#match.end(index)
r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you")
print(a.end()) #6
print(a.end(2)) #6
print(a.end(1))  #1

r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you")
print(a.span()) #(0, 6)
print(a.span(1)) #(0, 1)
print(a.span(2)) #(2, 6)

拆分

#split(pattern, string)    根据模式的匹配项来分割字符串    分割后的字符串列表
#意思是匹配到大写的字母就拆分
pattern = re.compile(r"[A-Z]+")
m = pattern.split("abcDefgHijkLmnoPqrs")
print(m) #['abc', 'efg', 'ijk', 'mno', 'qrs']

替换

"""
sub(repl, string,count=0)   将字符串中所有的pat的匹配项用repl替换 |完成替换后的新字符串           |
repl可以是一个字符串，也可以是一个函数。
count用于指定最多替换次数，不指定时全部替换。
"""
r = re.compile(r"like", re.I)
#s1 = r.sub(r"love", "I like you, do you like me?")  #I love you, do you love me?
#最多替换1次，所以把一个like替换了
s1 = r.sub(r"love", "I like you, do you like me?",count=1)
print(s1) #I love you, do you like me?


#subn(repl, string) | 在替换字符串后，同时报告替换的次数    | 完成替换后的新字符串及替换次数 |
#同sub()，只不过返回值是一个二元tuple，即(sub函数返回值，替换次数)。
r = re.compile(r"like", re.I)
"""
s1 = r.subn(r"love", "I like you, do you like me?")
print(s1) #('I love you, do you love me?', 2)
"""
s1 = r.subn(r"love", "I like you, do you like me?",count=1)
print(s1) #('I love you, do you like me?', 1)

RE模块：Python编译正则的模块相关推荐

python是什么模块,python中什么是模块
## re模块众多编程语言都为正则表达式的使用设置了标准库,Python也不例外.在Python中使用re模块来操作正则表达式的匹配.下面我们一起学习re模块的用法. ### 使用re还是compi ...
python networkx模块,python复杂网络处理模块networkx
最近开始认真的学习发现一个 python 好玩的模块以下内容为网上的文章整合 networkx在02年5月产生,是用python语言编写的软件包,便于用户对复杂网络进行创建.操作和学习.利用netw ...
pythonurllib模块-Python中的urllib模块使用详解
urllib模块提供的上层接口,使我们可以像读取本地文件一样读取www和ftp上的数据.每当使用这个模块的时候,老是会想起公司产品的客户端,同事用C++下载Web上的图片,那种"痛苦&quo ...
pythonurllib模块-python爬虫之urllib模块和requests模块学习
今天学习了request模块和urllib模块,了解到这两个模块最大的区别就是在爬取数据的时候连接方式的不同.urllb爬取完数据是直接断开连接的,而requests爬取数据之后可以继续复用socke ...
轩小陌的Python笔记-day14 自定义模块、第三方模块、内置模块（部分）
day14 模块课程目标:掌握Python中常用模块的使用方法. 今日概要: 自定义模块(包) 第三方模块内置模块[1/2] 1. 自定义模块 1.1 模块和包 import hashlibdef ...
对于python来说、一个模块就是一个文件-PYTHON中的包和模块
为了更加友好的对python代码进行组织管理,python中出现了包和模块的概念类似生活中整理我们的物品一样,将代码按照不同的功能进行整理整合,可以很大程度的提升代码可读性和代码质量,方便在项目中进 ...
python中的系统模块_python中一些获取系统信息的模块
1.platform模块 python中,platform模块给我们提供了很多方法去获取操作系统的信息如: import platform platform.platform() #获取操作系统名称 ...
编译kernel外部模块
编译kernel外部模块一.说明二.编译外部模块条件语法三.编译脚本编写脚本脚本的几种实现方式四.编译包含头文件 kernel头文件放置规则不同情况,头文件的使用五.编译安装目录( ...
5、python基础了解：模块、dir（）函数、包
文章目录前言一.模块 1.1.模块介绍 1.2.模块详解二. 标准模块三.dir() 函数四.包 python官方文档链接 python官方标准库链接前言余生平,怎一个懒字了得. 一.模 ...

RE模块：Python编译正则的模块

#正则

元字符