re模块的方法总结

不管现实多么惨不忍睹,都要持之以恒地相信,这只是黎明前短暂的黑暗而已。不要惶恐眼前的难关迈不过去,不要担心此刻的付出没有回报,别再花时间等待天降好运。真诚做人,努力做事!你想要的,岁月都会给你。re模块的方法总结,希望对大家有帮助,欢迎收藏,转发!站点地址:www.bmabk.com,来源:原文

re模块的方法总结

一,查找

1:match

匹配string 开头,成功返回Match object, 失败返回None,只匹配一个。

 示例:

1 s="abc221kelvin4774"
2 print(re.match("ab",s)) #<re.Match object; span=(0, 2), match='ab'>
3 print(re.match("kelvin",s)) #None

 

2:findall

在string中查找所有 匹配成功的组, 即用括号括起来的部分。返回list对象,每个list item是由每个匹配的所有组组成的list。

示例:

1 res1=re.findall("\d+","sd223dfar5621ff3f")
2 print(res1) #['223', '5621', '3']

3:search

在string中进行搜索,成功返回Match object, 失败返回None, 只匹配一个。

示例:

1 ret1=re.search("a\d+b","eaa1b4gha12das")
2 print(ret1.group()) # a1b

 

4:finditer

在string中查找所有 匹配成功的字符串, 返回iterator,每个item是一个Match object。

示例:

 1 import re
 2 
 3 p1 = re.compile(r'\d+')
 4 a_str = 'one1two2three3four4'
 5 
 6 #正则对象的split方法,使用正则匹配进行分割字符串
 7 #以列表的形式返回
 8 print(p1.split(a_str)) #['one', 'two', 'three', 'four', '']
 9 
10 #正则对象的findall方法,来查找符合对象的字符串
11 #最后是以列表的形式返回
12 print (p1.findall(a_str)) #['1', '2', '3', '4']
13 
14 for i in p1.finditer(a_str):
15         print (i.group())
16 
17 #1
18 #2
19 #3
20 #4

 

二,字符串处理的扩展 :split切割;sub/subn替换

1:split切割

1 s = 'alex|taibai|egon|'
2 print(s.split('|'))
3 s = 'alex83taibai40egon25'
4 ret = re.split('\d+',s)
5 print(ret)
6 
7 结果:
8 ['kelvin', 'bob', 'siri', '']
9 ['kelvin', 'bob', 'siri', '']

2:sub:替换,谁 旧的 新的 替换次数

 1 ret1 = re.sub('\d+','*','kelvin83bob40siri25') #如果不指定替换个数,则全部替换
 2 print(ret1)
 3 
 4 ret2 = re.sub('\d+','*','kelvin83bob40siri25',2) #如果指定了替换个数,则替换前指定个数个
 5 print(ret2)
 6 
 7 ret3 = re.sub('\d+','*','kelvin83bob40siri25',4) #如果指定了替换个数,且个数大于符合匹配条件个数,则全部匹配
 8 print(ret3)
 9 
10 #输出结果:
11 #kelvin*bob*siri*
12 #kelvin*bob*siri25
13 #kelvin*bob*siri*

3:subn:返回一个元组,第二个元素是替换的次数

1 ret = re.subn('\d+','*','kelvin83bob40siri25')
2 print(ret)
3 
4 #结果:
5 #('kelvinHbobHsiriH', 3)

 

三,re模块的进阶:时间/空间

1:compile:节省你使用正则表达式解决问题的时间

作用:编译 正则表达式 编译成 字节码,在多次使用的过程中,不会多次编译

1 ret = re.compile('\d+')   # 已经完成编译了
2 print(ret)  # re.compile('\\d+')
3 print(type(ret))  # <class 're.Pattern'>
4 res = ret.findall('kelvin83bob40siri25')
5 print(res)   # ['83', '40', '25']
6 res = ret.search('sjkhk172按实际花费928')
7 print(res.group())  # 172 

2:finditer:节省你使用正则表达式解决问题的空间/内存

 

1 ret = re.finditer('\d+','kelvin83bob40siri25')
2 for i in ret:
3     print(i.group())
4 
5 #结果:
6 #'83'
7 #'40'
8 #'25'

 

四,小结

(1)findall:返回列表,找所有的匹配项

(2)search:匹配就返回一个变量,通过group取匹配到的第一个值,不匹配就返回None,group会报错

(3)match:相当于search的正则表达式中加了个'^'

(4)spilt:返回列表,按照正常规则切割,默认匹配到的内容会被切掉

(5)sub/subn:替换,按照正则规则去寻找要被替换掉的内容,subn返回元组,第二个值是替换的次数

(6)compile:编译一个正则表达式,用这个结果去search,match,findall,finditer能够节省时间

(7)finditer:返回一个迭代器,所有的结果都在这个迭代器中,需要通过循环+group的形式取值,能够节省内存

 

 五,分组在re模块中的使用

引例:

 1 s = '<a>wahaha</a>'  # 标签语言 html 网页
 2 ret = re.search('<(\w+)>(\w+)</(\w+)>',s)
 3 print(ret.group())  # 所有的结果
 4 print(ret.group(1)) # 数字参数代表的是取对应分组中的内容
 5 print(ret.group(2))
 6 print(ret.group(3))
 7 
 8 #结果:
 9 #<a>wahaha</a>
10 #a
11 #wahaha
12 #a

 

 1.为了findall也可以顺利取到分组中的内容,有一个特殊的语法,就是优先显示分组中的内容

1 s = '<a>wahaha</a>'
2 ret = re.findall('(\w+)',s)
3 print(ret)
4 ret = re.findall('>(\w+)<',s)
5 print(ret)
6 
7 #结果:
8 #['a', 'wahaha', 'a']
9 #['wahaha']

 

2.取消分组优先(?:正则表达式)

1 ret = re.findall('\d+(?:\.\d+)?','1.234*4')
2 print(ret)
3 
4 #结果:
5 #['1.234', '4']

3.关于分组

对于正则表达式来说 有些时候我们需要进行分组,来整体约束某一组字符出现的次数
(\.[\w]+)?

对于python语言来说 分组可以帮助你更好更精准的找到你真正需要的内容
<(\w+)>(\w+)</(\w+)>

 4.切割split(使用分组切割可以保留切割点)

1 ret = re.split('\d+','alex83taibai40egon25')
2 print(ret)
3 ret = re.split('(\d+)','alex83taibai40egon25aa')
4 print(ret)
5 
6 #结果:
7 #['alex', 'taibai', 'egon', '']
8 #['alex', '83', 'taibai', '40', 'egon', '25', '']

 5:分组命名(?P<分组名>正则表达式)

1 s = '<a>wahaha</a>'
2 ret = re.search('>(?P<con>\w+)<',s)
3 print(ret.group(1))
4 print(ret.group('con'))
5 
6 #结果:
7 #wahaha
8 #wahaha

 

6.使用前面的分组,要求使用这个名字的分组和前面同名分组中的内容匹配的必须一致 

 

 1 s = '<a>wahaha</a>'
 2 pattern = '<(\w+)>(\w+)</(\w+)>'
 3 ret = re.search(pattern,s)
 4 print(ret.group(1) == ret.group(3))
 5 
 6 #结果:
 7 #True
 8 
 9 s = '<a>wahaha</b>'
10 pattern = '<(?P<tab>\w+)>(\w+)</(?P=tab)>'
11 ret = re.search(pattern,s)
12 print(ret)
13 
14 #结果:
15 #None
16 
17 
18 s = '<a>wahaha</a>'
19 pattern = '<(?P<tab>\w+)>(\w+)</(?P=tab)>'
20 ret = re.search(pattern,s)
21 print(ret)
22 
23 #结果:
24 #<_sre.SRE_Match object; span=(0, 13), match='<a>wahaha</a>'>

 六,使用正则表达式的技巧

1.用法:你要匹配的内容太没有特点,容易和你不想匹配的内容混在一起

 1 # 精准的取到整数 过滤掉小数
 2 ret=re.findall(r"\d+\.\d+|\d+","1-2*(60+(-40.35/5)-(-4*3))")
 3 print(ret)
 4 ret=re.findall(r"\d+\.\d+|(\d+)","1-2*(60+(-40.35/5)-(-4*3))")
 5 ret.remove('')
 6 print(ret)
 7 
 8 #结果:
 9 #['1', '2', '60', '40.35', '5', '4', '3']
10 #['1', '2', '60', '5', '4', '3']

 ***正则表达式如果写的足够好的话,能够最大限度的简化我们的操作

 2.正则表达式的重要程度

(1)掌握练习中的所有内容
(2)能够看懂常用的正则表达式
(3)并且能够做出一些公司特异性要求的修改

 

 

正则表达式中的特殊字符总结:

特殊字符有:

'.'
    (点号。)在默认模式下,匹配除换行以外的任意字符.如果 DOTALL 标志被指定, 则匹配包括换行符在内的所有字符.
'^'
    (脱字符号。)在默认模式下匹配字符串的起始位置, 在MULTILINE模式下也匹配换行符之后的位置.
'$'
    匹配字符串的末尾或者字符串末尾换行符之前的位置,在MULTILINE模式下还匹配换行符之前的位置。foo既匹配‘foo’也匹配‘foobar’,但是foo$只匹配‘foo’。更有趣的是,正常情况下foo.$只匹配'foo1\nfoo2\n' ‘foo2’,但是在MULTILINE模式下还能匹配‘foo1’;在'foo\n'中搜索单个$将找到两个(空的)匹配:一个是换行符之前,一个是字符串的末尾。
'*'
    匹配前面重复出现的正则表达式零次或多次,尽可能多的匹配。ab*将匹配‘a’、‘ab’或‘a’ 后面跟随任意数目的‘b’。
'+'
    引起生成的RE匹配1个或多个前导的RE,尽可能多的匹配。ab+将匹配‘a’之后跟随任意多个数目不为零的‘b’,它将不能匹配单纯的一个‘a’。
'?'
    引起生成的RE匹配0个或1个前导的RE。ab?将匹配‘a’或者‘ab’。
*?, +?, ??
    '*'、'+'和'?'限定符是贪婪的; 它们匹配尽可能多的文本。有时这个行为不是想要的;如果用正则表达式<.*>来匹配'<H1>title</H1>',它将匹配完整的字符串,而不会只是'<H1>'。在限定符之后加上'?'将使得匹配以非贪婪的或最小的方式进行;因为它将匹配尽可能少的字符。在刚才的表达式中使用.*?将只匹配'<H1>'。
{m}
    表示精确匹配前面的正则表达式的m个拷贝;较少的匹配将导致整个表达式不能匹配。例如,a{6}将精确匹配6个'a'字符,5个将不能匹配。
{m,n}
    引起生成的正则表达式匹配前导正则表达式的m到n个重复,尝试匹配尽可能多的重复。例如,a{3,5}将匹配3到5个'a'字符。省略m表示下界为0,省略n表示上界无限大。举个例子,a{4,}b将匹配aaaab或一千个'a'字符后跟随一个b,但不能匹配aaab。逗号不可以省略,否则该修改符将与前面的形式混淆。
{m,n}?
    例如,对于6个字符的字符串'aaaaaa',a{3,5}将匹配5个'a'字符,而a{3,5}?将只匹配3个字符。
'\'
    对任一特殊字符进行转义(允许您匹配字符(如'*',' ? ',等等),或只是一个特殊的序列;特殊序列在下面讨论。
    如果你不使用原始字符串来表达模式,记住在字符串字面值中Python也使用反斜杠作为转义序列;如果转义序列不能被Python解析器识别,那么结果字符串中包含反斜杠和后面的字符。但是,如果Python会识别所产生的序列,反斜杠应该重复两次。这比较复杂和难以理解,因此强烈建议你为所有即使是最简单的表达式使用原始字符串。
[]
    用来表示一个字符集合。在一个集合中:
        字符可以一个一个列出来,例如[amk]将匹配'a'、'm'或'k'。
        通过给出两个字符并用'-'分隔,可以给出一段范围的字符,例如[a-z]将匹配任意一个小写的ASCII字符,[0-5][0-9]将匹配00到59之间所有的两位数字,[0-9A-Fa-f]将匹配任意一个十六进制数字。如果-被转义(例如[a\-z])或者如果它位于第一个或最后一个字符(例如[a-]),它将只匹配一个字面值'-'。
        在集合内部,特殊字数将失去它们特殊的含义。例如,[(+*)]将匹配字符字面值'('、'+'、'*'或')'。
        在集合中还接受字符类别,例如\w或\S(在下文定义),尽管它们匹配的字符取决于LOCALE或UNICODE模式是否是强制的。
        不在一段范围之内的字符可以通过补集匹配。如果集合的第一个字符是'^',那么所有不在集合中的字符都将被匹配。例如,[^5]将匹配除'5'之外的所有字符,[^^]将匹配除'^'之外的所有字符。^如果不是集合中的第一个字符则没有特殊的含义。
        若要匹配集合中的一个字符字面值']',可以在它前面放一个反斜线或者将它放在集合的开始。例如,[()[\]{}]和[]()[{}]都将匹配一个圆括号。

'|'
    A|B, 此处的 A 和 B 可以是任意的正则表达式, 创建的这个正则表达式要么匹配 A 要么匹配 B. '|'可以用来隔开任意个数的正则表达式,着同样可以用在组里面。 当扫描字符串时,REs 被用'|'从左到右分隔。当一个模式被完全匹配时,这个被匹配的模式就被接受。这意味着一旦 匹配A , B 就不在被尝试, 即使他会产生更长的整体匹配. 换句话说,  '|' 不是贪婪操作符. 匹配符号 '|',用 |, 或者把它包含在组内, 就像是 [|].
(...)
    匹配任何在圆括号内的正则表达式, 并表明分组的开始和结束; 分组的内容在完成匹配后可以提取出来,而且可以在后面的字符串中用特殊的number序列匹配,下面有描述。若要匹配字面值'('或')',请使用( or ),或它们放入字符类的括号中:[(] [)]。
(?...)
    This is an extension notation (a '?' following a '(' is not meaningful otherwise). The first character after the '?' determines what the meaning and further syntax of the construct is. Extensions usually do not create a new group; (?P<name>...) is the only exception to this rule.Following are the currently supported extensions.
(?iLmsux)
    (集合'i', 'L', 'm', 's', 'u', 'x'中的一个或多个字母。)这个分组空字符串;这些字母给真个正则表达式设置相应的标记:re.I(忽略大小写),re.L(依赖区域设置),re.M(多行),re.S(点号匹配所有字符),re.U(依赖Unicode),re.X(详细模式)。(这些标志在模块的内容中讲述)。它用于如果你想要包含这些标志作为正则表达式的一部分,而不是将flag参数传递给re.compile()函数。
    请注意,(?x)标志更改解析表达的方式。它应使用在表达式字符串的开始,或一个或多个空白字符之后。如果在这个标志之前有非空白字符,结果是未定义的。
(?:...)
    括号形式的正则表达式的非匹配版本。匹配括号中的任何正则表达式,但是匹配的子字符串不能在匹配后提取或在模式中引用。
(?P<name>...)
    通过符号组名称name可以访问类似于常规的括号,但由组匹配的子字符串。组名必须是有效的 Python 标识符,并且每个组名必须在正则表达式内只有一次定义。海员象征性的组织也是带编号的组,就好像组未被命名。

 

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

文章由极客之音整理,本文链接:https://www.bmabk.com/index.php/post/187800.html

(0)
小半的头像小半

相关推荐

极客之音——专业性很强的中文编程技术网站,欢迎收藏到浏览器,订阅我们!