re正则表明式模块,Python正则表达式
分类:计算机编程

正则表明式 为高端的文本方式相称、收取、与/或文本格局的找出和替换作用提供了底蕴。轻松地说,正则表达式(简称为 regex)是有个别由字符和特殊符号组成的字符串,它们描述了格局的重复可能公布多少个字符,于是正则表明式能依据某种格局相配大器晚成多如牛毛有日常性子的字符串。换句话说,它们能够包容三个字符串……生机勃勃种只好协作叁个字符串的正则表明式形式是很单调而且毫无效用的,不是吧?Python 通过规范库中的 re 模块来援助正则表达式

Python正则表达式,

正则表明式为高档的文件情势相称、收取、与/或文本情势的找出和替换功用提供了底子。通过标准库中的re模块来支撑正则表明式。

正则表明式的特种字符列表

特殊字符 描述
. 匹配所有字符串,除n以外
- 表示范围[0-9]
* 匹配前面的子表达式零次或多次。要匹配 * 字符,请使用 *。
匹配前面的子表达式一次或多次。要匹配 字符,请使用
^ 匹配字符串开头
$ 匹配字符串结尾
转义字符, 使后一个字符改变原来的意思,如果字符串中有字符*需要匹配,可以*
? 匹配前一个字符串0次或1次
{m} 匹配前一个字符m次
{n,m} 匹配前一个字符n到m次
d 匹配数字,等于[0-9]
D 匹配非数字,等于[^0-9]
w 配字母和数字,等于[A-Za-z0-9]
W 匹配非英文字母和数字,等于[^A-Za-z0-9]
s 匹配空白字符
S 匹配非空白字符
A 匹配字符串开头
Z 匹配字符串结尾
b 匹配单词的词首和词尾,单词被定义为一个字母数字序列,因此词尾是用空白符或非字母数字符来表示的
B 与b相反,只在当前位置不在单词边界时匹配
(?P 分组,除了原有编号外在指定一个额外的别名
[] 是定义匹配的字符范围。比如 [a-zA-Z0-9] 表示相应位置的字符要匹配英文字符和数字。[s*]表示空格或者*号

大范围的正则表达式符号和特殊字符

表示法 描述 正则表达式示例
符号    
re1|re2 匹配正则表达式re1或者re2 foo|bat
. 匹配任何字符(除了n之外) b.b
^ 匹配字符串的起始部分 ^Dear
$ 匹配字符串的终止部分 /bin/*sh$
* 匹配0次或者多次前面出现的正则表达式 [A-Za-z0-9]*
匹配1次或者多次前面出现的正则表达式 [a-z] .com
? 匹配0次或者1次前面出现的正则表达式 goo?
{N} 匹配N次前面出现的正则表达式 [0-9]{3}
{M,N} 匹配M-N次前面出现的正则表达式 [0-9]{5,9}
[...] 匹配来自字符集的任意单一字符 [aeiou]
[...x-y...]

匹配x-y范围内的任意单一字符

[0-9]
[^...] 不匹配此字符集中出现的任何一个字符,包括某一范围的字符(如果在此字符集中出现) [^aeiou]
(...) 匹配封闭的正则表达式,然后另存为子组 ([0-9]{3})?
特殊字符    
d 匹配任何十进制数字,与[0-9]一致(D与d相反,不匹配任何非数值型的数字) datad .txt

w

匹配任何字母数字字符,与[A-Za-z0-9]相同(与W)相反 [A-Za-z]w
s 匹配任何空格字符,与[ntrvf]相同(与S相反) ofshe
b 匹配任何单词边界(B相反) bTheb
A(Z) 匹配字符串的起始(结束) ADear
     

    如若问号紧跟在其余利用密闭操作符的相称前边,它将直接须要正则表明式引擎匹配尽恐怕少的次数。

    尽只怕少的次数是怎么意思?当情势相配使用分组操作符时,正则表明式引擎将准备“摄取”相配该格局的尽量多的字符。那平常被可以称作贪婪相配。问号须要正则表达式引擎去“偷懒”,要是有比相当的大或许,就在当下的正则表明式中尽只怕少地相配字符,留下尽也许多的字符给后边的格局(要是存在)。

    当使用正则表达式时,生龙活虎对圆括号能够实现以下大肆二个(可能三个)功用:

  • 对正则表明式举办分组;
  • 匹配子组

 

广大的正则表明式属性

函数/方法 描述
仅仅是re模块  
compile 使用任何可选的标记来编译正则表达式的模式,然后返回一个正则表达式对象
re模块函数和正则表达式对象的方法  
match 尝试使用带有可选的标记的正则表达式的模式来匹配字符串。如果匹配成功,就返回匹配对象;如果失败,就返回None
search 使用可标记搜索字符串中第一次出现的正则表达式。如果匹配成功,就返回匹配对象;如果失败就返回None
findall 查找字符串中所有(非重复)出现的正则表达式模式,并返回一个匹配对象
finditer 与findall()函数相同,但返回的不是一个列表,而是一个迭代器。对于每一次匹配,迭代器都返回一个匹配对象。
split 根据正则表达式的模式分隔符,split函数将字符串分割为列表,然后返回成功匹配的列表,分隔符最多操作MAX次(默认分割所有匹配成功的位置)
re模块函数和正则表达式对象的方法  
sub 使用repl替换所有正则表达式的模式在字符串中出现的位置,除非定义count,否则就将替换所有出现的位置
purge() 消除隐式编译的正则表达式
常用的匹配对象  
group 返回整个匹配对象,或者编号为num的特定子组
groups 返回一个包含所有匹配子组的元祖(没有成功,返回空元组)
groupdict 返回一个包含所有匹配的命名子组的字典,所有的子组名称作为字典的键
常用的模块属性  
re.I 不区分大小写的匹配

 

Python的re正则表达式模块提供的秘技

re.match(pattern, string, flags=0)      #从字符串的起始位置匹配,如果起始位置匹配不成功的话,match()就返回none
re.search(pattern, string, flags=0)     #扫描整个字符串并返回第一个成功的匹配
re.findall(pattern, string, flags=0)    #找到RE匹配的所有字符串,并把他们作为一个列表返回
re.finditer(pattern, string, flags=0)   #找到RE匹配的所有字符串,并把他们作为一个迭代器返回
re.sub(pattern, repl, string, count=0, flags=0) #替换匹配到的字符串

协作对象以致group(卡塔尔和groups(卡塔尔(英语:State of Qatar)方法

  成功调用match(卡塔尔(قطر‎和search(卡塔尔(英语:State of Qatar)重临的靶子。

  group(卡塔尔(英语:State of Qatar)要么回到整个配成对象,要么依据须要再次来到特定子组。groups()则仅重临贰个包括唯风华正茂可能全部子组的元组。若无子组的要求,那么当group(卡塔尔(英语:State of Qatar)依旧再次来到整个相配时,groups(卡塔尔重回二个空元组。

 

函数参数表达:

pattern: 相称的正则表明式 string:要同盟的字符串
flags: 标识为,用于调节正则表明式的相配格局,如:是还是不是区分轻重缓急写,多行匹配等等。
repl: 替换的字符串,也可看成三个函数
count: 格局相配后替换的最大次数,暗许0表示替换所有相配

import re

m = re.match(r'f..', r'begin fool hello') # match 从字符串的开始位置进行搜索,如果需从字符串任意位置进行搜索,需使用下文中的search方法
if m is not None:
    print('found : '   m.group())
else:
    print('not found!')

not found!

选取match()方法相称字符串

  match()函数试图从字符串的前奏部分对情势张开相称。

>>> re.match('foo','foo').group()
'foo'

>>> re.match('foo','food on match').group()
'foo'

>>> re.match('foo','fodo on match').group()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group‘

 

search(卡塔尔(قطر‎函数不但会寻找情势在字符串中首先次面世的职责,何况严刻地对字符串从左到右搜索。
m = re.search(r'foo', 'beginfool hello')
if m is not None:
    print('found : '   m.group())
else:
    print('not found...')

found : foo

接纳search()在八个字符串中搜索方式(寻找与协作的相比较)

search()和match()的做事机制完全意气风发致,分裂之处在于search会用它的字符串参数,在随便地点对给定正则表达式格局搜索第二遍现身匹配的事态。

>>> re.match('foo','sea food').group()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'

>>> re.search('foo','sea food').group()
'foo'

  

合作任何单个字符串
anyend = '.end'
m = re.match(anyend, 'bend') # 点号匹配‘b’
if m is not None: print(m.group())

bend

m = re.match(anyend, 'end') # 不匹配任何字符串
if m is not None: print(m.group())

m = re.match(anyend, 'nbend') # 除了'n'之外的任何字符串
if m is not None: print(m.group())

m = re.match(anyend, 'The end.') # 点号匹配‘ end’
if m is not None: print(m.group())

相配多少个字符串

>>> bt = 'bat|bet|bit'
>>> re.match(bt,'bat').group()
'bat'
>>> 
>>> re.match(bt,'bit').group()
'bit'
>>> 
>>> re.match(bt,'blt').group()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
>>> 
>>> re.match(bt,'he bit me').group()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
>>> 
>>> re.search(bt,'he bit me').group()
'bit'

 

gorup(卡塔尔(英语:State of Qatar)和groups(卡塔尔(英语:State of Qatar)方法的选用
m = re.match(r'(w{3})-(d{3})', 'abc-123')
if m is not None:
    print('m.group(): '   m.group())
    print('m.group(1): '   m.group(1))
    print('m.group(2): '   m.group(2))
    print('m.groups(): '   str(m.groups()))

m.group(): abc-123
m.group(1): abc
m.group(2): 123
m.groups(): ('abc', '123')

findall(卡塔尔(قطر‎查询字符串中某些正则表明式方式全部的非重复出现处境。这与 search(卡塔尔在举行字符串寻找时好像,但与 match(卡塔尔和 search(卡塔尔的分裂之处在于,findall(卡塔尔国总是回到一个列表。若是findall(卡塔尔国未有找到相配的少年老成对,就回来贰个空驶列车表,但只要同盟成功,列表将包含全数成功的相配部分(从左向右按现身顺序排列)。

re.findall('car', 'car')
re.findall('car', 'scary')
re.findall('car', 'carry the brcardi to the car')

['car']
['car']
['car', 'car', 'car']

合营任何单个字符

>>> anyend = '.end'
>>> re.match(anyend,'bend').group()
'bend'
>>> 
>>> re.match(anyend,'end').group()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
>>> 
>>> re.match(anyend,'nend').group()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
>>> 
>>> re.search('.end','The end.').group()
' end'
>>> 

  

finditer(卡塔尔国和findall(卡塔尔重临的相配字符串比较,finditer(卡塔尔在极其对象中迭代.
s = 'This and that.'
re.findall(r'(thw )', s, re.I)
iter = re.finditer(r'(thw )', s, re.I)
[g.group() for g in iter] # findall 返回一个列表,而finditer返回一个迭代器
iter

['This', 'that']
<callable_iterator at 0x594a780>
[]

有八个函数/方法用于落实搜索和替换到效:sub(卡塔尔(英语:State of Qatar)和 subn(卡塔尔(英语:State of Qatar)。两个差相当的少相近,都以将某字符串中具备相称正则表明式的局地开展某种情势的轮番。用来替换的片段平常是二个字符串,但它也可能是一个函数,该函数重回二个用来替换的字符串。subn(卡塔尔(英语:State of Qatar)和 sub(卡塔尔同样,但 subn(卡塔尔(英语:State of Qatar)还重回多个象征替换的总额,替换后的字符串和象征替换总的数量的数字一齐作为一个具备三个因素的元组重临。

print(re.sub('X', 'Mr. Iceman', 'attn: XnnDear X,n'))
print(re.subn('X', 'Mr. Iceman', 'attn: XnnDear X,n'))

attn: Mr. Iceman 
Dear Mr. Iceman,
('attn: Mr. IcemannnDear Mr. Iceman,n', 2)

re 模块和正则说明式的对象方法 split(卡塔尔(قطر‎对于相对应字符串的劳作章程是近乎的,但是与区划二个坚持住字符串比较,它们基柳盈瑄则表明式的方式分隔字符串,为字符串分隔成效丰裕一些相当的威力。

假使给定分隔符不是利用特殊符号来合作多种形式的正则表达式,那么 re.split(卡塔尔(قطر‎与str.split(卡塔尔(قطر‎的做事办法同样

re.split(':', 'str1:str2:str3')

DATA = (
    'Mountain View, CA 94040',
    'Sunnyvale, CA',
    'Los Altos, 94023',
    'Cupertino 95014',
    'Palo Alto CA'
)

for item  in DATA:
    print( re.split(', |(?= (?:d{5}|[A-Z]{2})) ', item))

['str1', 'str2', 'str3']

['Mountain View', 'CA', '94040']
['Sunnyvale', 'CA']
['Los Altos', '94023']
['Cupertino', '95014']
['Palo Alto', 'CA']

import os
import re

with os.popen('tasklist /nh', 'r') as f:
    for line in list(f)[:5]:
        # print(re.split(r'ss |t', line.rstrip())) #pid 和会话名未分解
        print(re.findall(r'([w.] (?: [w.] )*)ss*(d )s(w )ss*(d )ss*([d,] sK)', line.strip()))

[]
[('System Idle Process', '0', 'Services', '0', '24 K')]
[('System', '4', 'Services', '0', '2,852 K')]
[('smss.exe', '364', 'Services', '0', '1,268 K')]
[('csrss.exe', '612', 'Services', '0', '6,648 K')]

正如以意气风发平安无事示例截止本文,它以差别的艺术利用正则表达式来操作字符串。首先应用该脚本为正则表明式演习创立随机数据,然后将调换的多寡提取此中的数字和邮箱地址

from random import randrange, choice
from string import ascii_lowercase as lc
from datetime import datetime
import time
import re

result_data = []

# gen data
tlds = ('com', 'cn', 'edu', 'net', 'gov', 'org')
for i in range(randrange(4, 9)):
    max_seconds = int(datetime.now().timestamp())
    dtint = randrange(max_seconds)
    #dtstr = str(datetime.fromtimestamp(dtint))
    dtstr = ctime(dtint)
    llen = randrange(4, 8)
    login = ''.join(choice(lc) for j in range(llen))
    dlen = randrange(llen, 13)
    dom = ''.join(choice(lc) for j in range(dlen))
    result_data.append('%s::%s@%s.%s::%d-%d-%d' % (dtstr, login, dom, choice(tlds), dtint, llen, dlen))

#print(result_data)

#test re
re_patt = '^(w{3}).*::(?P<email>w @w .w )::(?P<number>d -d -d )'
for item in result_data:
    m = re.match(re_patt, item)
    if m is not None:
        print('*'*30)
        print(item)
        print("Email: "   m.group('email'))
        print('Number: '   m.group('number')) 

******************************
Tue Jan 28 15:34:09 1992::kzyoqsl@vwtddarzlyw.edu::696584049-7-11
Email: kzyoqsl@vwtddarzlyw.edu
Number: 696584049-7-11
******************************
Thu Dec 23 22:35:52 1971::igqiuz@xiruxcy.org::62346952-6-7
Email: igqiuz@xiruxcy.org
Number: 62346952-6-7
******************************
Sat Jan 25 11:26:50 2003::etutgz@yvpfclzx.com::1043465210-6-8
Email: etutgz@yvpfclzx.com
Number: 1043465210-6-8
******************************
Wed Sep 28 23:37:34 1977::qxvuebc@bawmmefljm.com::244309054-7-10
Email: qxvuebc@bawmmefljm.com
Number: 244309054-7-10
******************************

开创字符集[]

>>> re.match('[cr][23][dp][o2]','c3po').group()
'c3po'
>>> 
>>> re.match('[cr][23][dp][o2]','c2do').group()
'c2do'
>>> 
>>> re.match('r2d2|c3po','c2do').group()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
>>> 
>>> re.match('r2d2|c3po','r2d2').group()
'r2d2'
>>> 

  

重新、特殊字符以至分组

>>> re.match('(www)-(ddd)','abc-123').group()
'abc-123'
>>> re.match('(www)-(ddd)','abc-123').group(1)
'abc'
>>> re.match('(www)-(ddd)','abc-123').group(2)
'123'
>>> re.match('(www)-(ddd)','abc-123').groups()
('abc', '123')
>>> 

 

>>> m = re.match('ab','ab')    #没有子组
>>> m.group()                         #完整匹配
'ab'
>>> m.groups()                       #所有子组
>>> 
>>> m = re.match('(ab)','ab')    
>>> m.group()
'ab'
>>> m.groups()
('ab',)
>>> 
>>> m= re.match('(a)(b)','ab')
>>> m.group()
'ab'
>>> m.group(1)            # 子组1
'a'
>>> m.group(2)            #子组2
'b'
>>> m.groups()
('a', 'b')
>>> 
>>> m = re.match('(a(b))','ab')
>>> m.group()
'ab'
>>> m.group(1)
'ab'
>>> m.group(2)
'b'
>>> m.groups()
('ab', 'b')
>>> 

 

相称字符串的起始和末段以致单词边界

>>> m = re.search('^the','the end.')
>>> m.group()
'the'
>>> 
>>> m = re.search('^the','end. the')
>>> m.group()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
>>> 
>>> m = re.search(r'bthe','is the yes')
>>> m.group()
'the'
>>> 
>>> m = re.search(r'bthe','isthe yes')      #有边界
>>> m.group()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
>>> 
>>> m = re.search(r'Bthe','isthe yes')      #没有边界
>>> m.group()
'the'

  

动用findall()和finditer()查找每二遍面世的职分

findall()查询字符串中某些正则表明式格局全体的非重复现身的境况。总再次回到多个列表。

>>> re.findall('car','car')
['car']
>>> re.findall('car','scary')
['car']
>>> re.findall('car','carry the barcardi to car')
['car', 'car', 'car']
>>> 

 

动用sub()和subn()搜索与替换

  两个差十分少生机勃勃致,都以将某字符串中具备相配正则表明式的生龙活虎部分进行某种情势的轮番。用来替换的一些习以为常是一个字符串,但它也许有可能是三个函数,该函数重返五个用来替换的字符串。subn()和sub()同样,不过subn()还回到二个表示替换的总和,替换后的字符串和表示替换总数的数字相仿一同作为叁个颇负八个元素的元组重临。

>>> re.sub('X','Mr.Smith','atten:XnnDear X,n')
'atten:Mr.SmithnnDear Mr.Smith,n'
>>> re.subn('X','Mr.Smith','atten:XnnDear X,n')
('atten:Mr.SmithnnDear Mr.Smith,n', 2)
>>> 
>>> re.sub('[ae]','X','abcdef')
'XbcdXf'
>>> re.subn('[ae]','X','abcdef')
('XbcdXf', 2)
>>> 

 

在节制方式上选拔split(卡塔尔国分割字符串

  假使你不想为每一趟格局的面世都分割字符串,就足以由此为max参数设定多少个值(非零)来制订最大分割数。

  要是给定分隔符不是选拔特殊符号来协作多种形式的正则表明式,那么re.split(卡塔尔(قطر‎与str.split(卡塔尔工作方法肖似,例子如下

>>> re.split(':','str1:str2:str3')
['str1', 'str2', 'str3']

  

正则表明式为高端的公文格局相配、收取、与/或文本情势的寻觅和替换作用提供了底子。通过标准库中的re模块来支撑正...

本文由pc28.am发布于计算机编程,转载请注明出处:re正则表明式模块,Python正则表达式

上一篇:Python中itertools模块用法详解 下一篇:没有了
猜你喜欢
热门排行
精彩图文
  • 那些年【深入.NET平台和C#编程】
    那些年【深入.NET平台和C#编程】
    一、深入.NET框架 ArrayList (非泛型集合  using System.Collections;) public void Text1(){ ArrayList al = new ArrayList (); al.Add ("刘德化");       //添加元素 al.Add ("张学友
  • 碰着搭建
    碰着搭建
    Appium是移动端的自动化测试工具,类似于前面所说的Selenium,利用它可以驱动Android、iOS等设备完成自动化测试,比如模拟点击、滑动、输入等操作,其官方
  • Django中的CBV和FBV示例介绍
    Django中的CBV和FBV示例介绍
    Django中的CBV和FBV Django中的CBV和FBV示例介绍,djangocbvfbv示例 前言 本文主要给大家介绍了关于Django中CBV和FBV的相关内容,分享出来供大家参考学习,下面话不
  • 将Log4net的配置配置到的独立文件中,Log4Net日志插
    将Log4net的配置配置到的独立文件中,Log4Net日志插
  • Python面向对象编程思想
    Python面向对象编程思想
    Python中的类(一) 1.面向过程编程:计算机通过一系列指令来一步一步完成任务。 面向对象编程——Object OrientedProgramming,简称OOP,是一种程序设计思想。