您的位置:时时app平台注册网站 > 编程知识 > re模块【时时app平台注册网站】

re模块【时时app平台注册网站】

2019-12-06 10:51

1.split  切割

三、re模块中常用功能函数

1、compile()

编写翻译正则表达式格局,再次回到贰个目的的形式。(能够把这个常用的正则表达式编写翻译成正则表明式对象,那样能够拉长一点功用。)

格式:

re.compile(pattern,flags=0)

pattern: 编写翻译时用的表明式字符串。

flags 编写翻译标识位,用于改良正则表达式的合营形式,如:是不是区分朗朗上口写,多行相称等。常用的flags有:

标志
含义
re.S(DOTALL)
使.匹配包括换行在内的所有字符
re.I(IGNORECASE)
使匹配对大小写不敏感
re.L(LOCALE)
做本地化识别(locale-aware)匹配,法语等
re.M(MULTILINE)
多行匹配,影响^和$
re.X(VERBOSE)
该标志通过给予更灵活的格式以便将正则表达式写得更易于理解
re.U
根据Unicode字符集解析字符,这个标志影响w,W,b,B

 

时时app平台注册网站 1

import re
tt = "Tina is a good girl, she is cool, clever, and so on..."
rr = re.compile(r'w*oow*')
print(rr.findall(tt))   #查找所有包含'oo'的单词
执行结果如下:
['good', 'cool']

时时app平台注册网站 2

2、match()

决定RE是不是在字符串刚初步的岗位相配。//注:那几个点子并不是截然合营。当pattern停止时若string还大概有剩余字符,依旧视为成功。想要完全合作,能够在表明式末尾加上面界相称符'$'

格式:

re.match(pattern, string, flags=0)

print(re.match('com','comwww.runcomoob').group())
print(re.match('com','Comwww.runcomoob',re.I).group())
执行结果如下:
com
com

3、search()

 格式:

re.search(pattern, string, flags=0)

re.search函数会在字符串内寻觅方式相称,只要找到第三个相称然后回来,借使字符串未有相配,则赶回None。

print(re.search('dcom','www.4comrunoob.5com').group())
执行结果如下:
4com

*注:match和search黄金时代旦相称成功,正是二个match object对象,而match object对象有以下措施:

  • group(卡塔尔(英语:State of Qatar) 重临被 RE 相配的字符串
  • start(卡塔尔国 再次回到相配起来的职位
  • end(卡塔尔国 重临相配甘休的职责
  • span(卡塔尔(قطر‎ 再次来到一个元组包括匹配 (开头,甘休卡塔尔(قطر‎ 的岗位
  • group(卡塔尔国重回re全体合作的字符串,能够三回输入多个组号,对应组号相配的字符串。

a. group()再次回到re全部合作的字符串,
b. group (n,m卡塔尔国重临组号为n,m所相称的字符串,若是组号不设有,则赶回indexError十分
c.groups()groups(卡塔尔(قطر‎方法重回二个含有正则表明式中全部小组字符串的元组,从 1 到所含的小组号,平日groups(卡塔尔无需参数,再次回到三个元组,元组中的元正是正则表明式中定义的组。 

时时app平台注册网站 3

import re
a = "123abc456"
 print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0))   #123abc456,返回整体
 print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1))   #123
 print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2))   #abc
 print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3))   #456
###group(1) 列出第一个括号匹配部分,group(2) 列出第二个括号匹配部分,group(3) 列出第三个括号匹配部分。###

时时app平台注册网站 4

4、findall()

re.findall遍历相称,能够拿走字符串中装有相称的字符串,再次来到一个列表。

 格式:

re.findall(pattern, string, flags=0)

p = re.compile(r'd ')
print(p.findall('o1n2m3k4'))
执行结果如下:
['1', '2', '3', '4']

时时app平台注册网站 5

import re
tt = "Tina is a good girl, she is cool, clever, and so on..."
rr = re.compile(r'w*oow*')
print(rr.findall(tt))
print(re.findall(r'(w)*oo(w)',tt))#()表示子表达式 
执行结果如下:
['good', 'cool']
[('g', 'd'), ('c', 'l')]

时时app平台注册网站 6

5、finditer()

 搜索string,重返多少个各类访问每叁个协作结果(Match对象)的迭代器。找到 RE 相称的装有子串,并把它们作为八个迭代器再次来到。

格式:

re.finditer(pattern, string, flags=0)

时时app平台注册网站 7

iter = re.finditer(r'd ','12 drumm44ers drumming, 11 ... 10 ...')
for i in iter:
    print(i)
    print(i.group())
    print(i.span())
执行结果如下:
<_sre.SRE_Match object; span=(0, 2), match='12'>
12
(0, 2)
<_sre.SRE_Match object; span=(8, 10), match='44'>
44
(8, 10)
<_sre.SRE_Match object; span=(24, 26), match='11'>
11
(24, 26)
<_sre.SRE_Match object; span=(31, 33), match='10'>
10
(31, 33)

时时app平台注册网站 8

6、split()

根据可以同盟的子串将string分割后回来列表。

能够行使re.split来分割字符串,如:re.split(r's ', text卡塔尔(英语:State of Qatar);将字符串按空格分割成二个单词列表。

格式:

re.split(pattern, string[, maxsplit])

maxsplit用于指定最大分割次数,不点大将全数细分。

print(re.split('d ','one1two2three3four4five5'))
执行结果如下:
['one', 'two', 'three', 'four', 'five', '']

7、sub()

选用re替换string中每多少个相配的子串后赶回替换后的字符串。

格式:

re.sub(pattern, repl, string, count)

时时app平台注册网站 9

import re
text = "JGood is a handsome boy, he is cool, clever, and so on..."
print(re.sub(r's ', '-', text))
执行结果如下:
JGood-is-a-handsome-boy,-he-is-cool,-clever,-and-so-on...

其间第2个函数是替换后的字符串;本例中为'-'

第两个参数指替换个数。默以为0,表示每种相配项都替换。

时时app平台注册网站 10

re.sub还同意选用函数对匹配项的轮番实行理并答复杂的管理。

如:re.sub(r's', lambda m: '[' m.group(0) ']', text, 0卡塔尔;将字符串中的空格' '替换为'[ ]'。

import re
text = "JGood is a handsome boy, he is cool, clever, and so on..."
print(re.sub(r's ', lambda m:'[' m.group(0) ']', text,0))
执行结果如下:
JGood[ ]is[ ]a[ ]handsome[ ]boy,[ ]he[ ]is[ ]cool,[ ]clever,[ ]and[ ]so[ ]on...

8、subn()

 再次来到替换次数

格式:

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

时时app平台注册网站 11

print(re.subn('[1-2]','A','123456abcdef'))
print(re.sub("g.t","have",'I get A,  I got B ,I gut C'))
print(re.subn("g.t","have",'I get A,  I got B ,I gut C'))
执行结果如下:
('AA3456abcdef', 2)
I have A,  I have B ,I have C
('I have A,  I have B ,I have C', 3)

时时app平台注册网站 12

    4

二、正则表明式中常用的字符含义

1、普通字符和10个元字符:

普通字符
匹配自身
abc
abc
.
匹配任意除换行符"n"外的字符(在DOTALL模式中也能匹配换行符
a.c
abc
转义字符,使后一个字符改变原来的意思
a.c;a\c
a.c;ac
*
匹配前一个字符0或多次
abc*
ab;abccc
匹配前一个字符1次或无限次
abc
abc;abccc
?
匹配一个字符0次或1次
abc?
ab;abc
^
匹配字符串开头。在多行模式中匹配每一行的开头 ^abc
abc
$
匹配字符串末尾,在多行模式中匹配每一行的末尾 abc$
abc
| 或。匹配|左右表达式任意一个,从左到右匹配,如果|没有包括在()中,则它的范围是整个正则表达式
abc|def
abc
def
{} {m}匹配前一个字符m次,{m,n}匹配前一个字符m至n次,若省略n,则匹配m至无限次
ab{1,2}c
abc
abbc
[]
字符集。对应的位置可以是字符集中任意字符。字符集中的字符可以逐个列出,也可以给出范围,如[abc]或[a-c]。[^abc]表示取反,即非abc。
所有特殊字符在字符集中都失去其原有的特殊含义。用反斜杠转义恢复特殊字符的特殊含义。
a[bcd]e
abe
ace
ade
 
()
被括起来的表达式将作为分组,从表达式左边开始没遇到一个分组的左括号“(”,编号 1.
分组表达式作为一个整体,可以后接数量词。表达式中的|仅在该组中有效。
(abc){2}
a(123|456)c
abcabc
a456c

此处供给重申一下反斜杠的作用:

  • 反斜杠前边跟元字符去除新鲜效果;(将在特殊字符转义成平日字符)
  • 反斜杠前边跟日常字符实现特殊功用;(即预约义字符)
  • 引用序号对应的字组所相称的字符串。

    a=re.search(r'(tina)(fei)haha2','tinafeihahafei tinafeihahatina').group() print(a) 结果: tinafeihahafei

2、预约义字符集(能够写在字符集[...]中) 

d
数字:[0-9]
abc
a1c
D
非数字:[^d]
aDc
abc
s
匹配任何空白字符:[<空格>trnfv]
asc
a c
S 非空白字符:[^s]
aSc
abc
w
匹配包括下划线在内的任何字字符:[A-Za-z0-9_]
awc
abc
W
匹配非字母字符,即匹配特殊字符
aWc
a c
A
仅匹配字符串开头,同^ Aabc
abc
Z
仅匹配字符串结尾,同$
abcZ
abc
b
匹配w和W之间,即匹配单词边界匹配一个单词边界,也就是指单词和空格间的位置。例如, 'erb' 可以匹配"never" 中的 'er',但不能匹配 "verb" 中的 'er'。 babcb
ab!bc
空格abc空格
a!bc
B
[^b]
aBbc
abc

时时app平台注册网站 13

这里需要强调一下b的单词边界的理解:
w = re.findall('btina','tian tinaaaa')
print(w)
s = re.findall(r'btina','tian tinaaaa')
print(s)
v = re.findall(r'btina','tian#tinaaaa')
print(v)
a = re.findall(r'btinab','tian#tina@aaa')
print(a)
执行结果如下:
[]
['tina']
['tina']
['tina']

时时app平台注册网站 14

3、特殊分组用法:

(?P<name>)
分组,除了原有的编号外再指定一个额外的别名 (?P<id>abc){2}
abcabc
(?P=name)
引用别名为<name>的分组匹配到字符串 (?P<id>d)abc(?P=id)
1abc1
5abc5
<number>
引用编号为<number>的分组匹配到字符串 (d)abc1
1abc1
5abc5

    6

一、简介

正则表明式本人是风华正茂种小型的、中度职业化的编制程序语言,而在python中,通过内嵌集成re模块,程序媛们得以直接调用来贯彻正则相配。正则表明式方式被编写翻译成蓬蓬勃勃类别的字节码,然后由用C编写的相称引擎实行。

是从第0个职责相配成功的,所以结果为:<re.Match object; span=(0, 1卡塔尔(قطر‎, match='1'>

四、一些在乎点

1、re.match与re.search与re.findall的区别:

re.match只相称字符串的启幕,就算字符串起头不符合正则表达式,则匹配失利,函数重返None;而re.search相称整个字符串,直到找到五个同盟。

时时app平台注册网站 15

a=re.search('[d]',"abc33").group()
print(a)
p=re.match('[d]',"abc33")
print(p)
b=re.findall('[d]',"abc33")
print(b)
执行结果:
3
None
['3', '3']

时时app平台注册网站 16

2、贪婪相称与非贪婪相配

*?, ?,??,{m,n}?    前面的*, ,?等都以名缰利锁匹配,也正是拼命三郎相称,前面加?号使其形成惰性相称

时时app平台注册网站 17

a = re.findall(r"a(d ?)",'a23b')
print(a)
b = re.findall(r"a(d )",'a23b')
print(b)
执行结果:
['2']
['23']

时时app平台注册网站 18

a = re.match('<(.*)>','<H1>title<H1>').group()
print(a)
b = re.match('<(.*?)>','<H1>title<H1>').group()
print(b)
执行结果:
<H1>title<H1>
<H1>

时时app平台注册网站 19

时时app平台注册网站 20

时时app平台注册网站 21

a = re.findall(r"a(d )b",'a3333b')
print(a)
b = re.findall(r"a(d ?)b",'a3333b')
print(b)
执行结果如下:
['3333']
['3333']
#######################
这里需要注意的是如果前后均有限定条件的时候,就不存在什么贪婪模式了,非匹配模式失效。

时时app平台注册网站 22

 3、用flags时相遇的小坑

print(re.split('a','1A1a2A3',re.I))#输出结果并未能区分大小写
这是因为re.split(pattern,string,maxsplit,flags)默认是四个参数,当我们传入的三个参数的时候,系统会默认re.I是第三个参数,所以就没起作用。如果想让这里的re.I起作用,写成flags=re.I即可。 

search:相称到就赶回二个变量,通过group取相称到的首先个值,相称不到就再次回到None,group会报错

五、正则的小施行

1、相称电话号码

p = re.compile(r'd{3}-d{6}')
print(p.findall('010-628888'))

2、匹配IP

re.search(r"(([01]?d?d|2[0-4]d|25[0-5]).){3}([01]?d?d|2[0-4]d|25[0-5].)","192.168.1.1")

* *

2.sub 替换,再次回到字符串,sub(正则表明式,新的字符,原字符串,替换次数卡塔尔(قطر‎不写替换次数暗许全部交换

1 import re
2 ret = re.search("d ","6a4d6a4f6a4s8f")
3 print(ret)#得到的是一个内存地址
4 print(ret.group())#通过ret.group()获取真正的结果

import re   #先导入re模块

1 import re#第一步,引入模块
2 ret = re.findall("d ","akhua5fsas6as456a")#第二步,调用模块函数
3 print(ret)

    8

1 import re
2 ret = re.search("d ","jasgfajgfaf")
3 print(ret)
4 print(ret.group())

 

如:

split:再次回到列表,规行矩步正则准绳切割,暗中认可相称到的剧情会被切除**

3.subn  交流,和sub一样,只是重回的结果是叁个元组,元组中第贰个因素为轮流的次数

search:只非常从左到右的第二个,得到的不是直接的结果,而是贰个变量,通过那么些变量的group方法来得到结果,若无相配到,会回来None,使用group会报错

结果为:None

将正则表明式编写翻译成字节码,再次来到三个对象的方式,在三番若干遍运用的长河中,不会频频编写翻译(能够把常用的正则表明式编写翻译成正则表明式对象,那样能够压实一点效用卡塔尔

不是从第0个地点相称成功的,所以结果为:None,况且黄金时代旦执行ret.group(卡塔尔国会报错

  re.compile(pattern卡塔尔(英语:State of Qatar)  pattern:编写翻译时用的表明式字符串

1 import re
2 s = "6f46sf16af1a"
3 ret = re.subn("d","A",s)
4 print(ret)

      #span代表的是找到的结果的目录,match表示找到的结果

    4

1 import re
2 s = "6a84sf6a8f4"
3 ret = re.finditer("d",s)
4 for i in ret:
5     print(i.group())

结果为:6

compile:编写翻译三个正则表明式,用那一个结果去search,match,findall,fingiter,能够节省时间

    8

结果都为:['a', 'b', 'c', 'd', '']

compile  节省使用正则表达式消亡难点的时日

finditer  节省使用正则表明式清除难题的上空/内部存款和储蓄器

查找:

1 import re
2 ret = re.match("d ","f1a6sf4")
3 print(ret)
4 print(ret.group())

回到的结果为:['5','6','456']

finditer:再次回到一个迭代器,所有的结果都在此个迭代器中,需求经过for循环加group的款型取值,能省掉内部存款和储蓄器

字符串管理的恢弘:替换,切割

结果为:('AfAAsfAAafAa', 6)

   AttributeError: 'NoneType' object has no attribute 'group'

总结:

sub/subn:替换,依据正则法则去找寻要被沟通的源委,subn重临的是元组,第三个值是被更动的次数

         a = re.findall("相称准则","要合营的字符串"卡塔尔(英语:State of Qatar)  #其次部,调用模块函数

findall:再次回到列表,找到全部的同盟项

         以列表方式再次来到相称到的字符串

re模块的进级:时间/空间

finall:相称全部,每意气风发项都是列表中的二个因素

寻找字符串,找到全部相符正则表达式的结果并雄居二个迭代器中,最终回到的是一个迭代器,能够用for循环来查阅结果

match:从头初阶相配,约等于search中的正则表达式加上贰个^

结果为:['6','8','4','6','8','4','6','4']

match:也就是search的正则表明式中加了多个^,如果从第0个岗位相配成功,则重返值,不然重回   None,group会报错

1 import re
2 ret = re.match("d ","1fa6sf4")
3 print(ret)
4 print(ret.group())

    6

1 import re
2 s = "a1b1c1d1"
3 print(s.split("1"))#字符串切割
4 
5 ret = re.split("d",s)#re模块的切割
6 print(ret)

  二个模块只会被导入二遍,不管奉行了有一些次import,这样可防止止导入模块被叁遍又一回的实行

                  1

结果为:AAasAasAAfAaAsfA

结果为:<re.Match object; span=(0, 1), match='6'>,

1 import re
2 s = "65as1as51f3a5sf1"
3 ret = re.sub("d","A",s)
4 print(ret)

re模块的据守:

1 import re
2 ret = re.findall("d","68a4f6a84f6a4sf")
3 print(ret)

     如:  import re  #第一步,引入re模块

    也便是说,match只会从字符串的第0个职位上马相称,相称成功的话就再次来到值,如若不是从起首地点相称成功的话就回来None

本文由时时app平台注册网站发布于编程知识,转载请注明出处:re模块【时时app平台注册网站】

关键词: