都是将某字符串中所有匹配正则表达式的部分进

作者: 编程  发布:2019-11-20
匹配任何单个字符串
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())

Python正则表达式,

正则表达式为高级的文本模式匹配、抽取、与/或文本形式的搜索和替换功能提供了基础。通过标准库中的re模块来支持正则表达式。

search()函数不但会搜索模式在字符串中第一次出现的位置,而且严格地对字符串从左到右搜索。
m = re.search(r'foo', 'beginfool hello')
if m is not None:
    print('found : ' + m.group())
else:
    print('not found...')

found : foo

匹配任何单个字符

>>> 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'
>>> 

  

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) #替换匹配到的字符串

使用findall()和finditer()查找每一次出现的位置

findall()查询字符串中某个正则表达式模式全部的非重复出现的情况。总返回一个列表。

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

 

gorup()和groups()方法的使用
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']

匹配多个字符串

>>> 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'

 

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()和 subn()。两者几乎一样,都是将某字符串中所有匹配正则表达式的部分进行某种形式的替换。用来替换的部分通常是一个字符串,但它也可能是一个函数,该函数返回一个用来替换的字符串。subn()和 sub()一样,但 subn()还返回一个表示替换的总数,替换后的字符串和表示替换总数的数字一起作为一个拥有两个元素的元组返回。

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
******************************

使用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‘

 

正则表达式 为高级的文本模式匹配、抽取、与/或文本形式的搜索和替换功能提供了基础。简单地说,正则表达式(简称为 regex)是一些由字符和特殊符号组成的字符串,它们描述了模式的重复或者表述多个字符,于是正则表达式能按照某种模式匹配一系列有相似特征的字符串。换句话说,它们能够匹配多个字符串……一种只能匹配一个字符串的正则表达式模式是很乏味并且毫无作用的,不是吗?Python 通过标准库中的 re 模块来支持正则表达式

在限定模式上使用split()分割字符串

  如果你不想为每次模式的出现都分割字符串,就可以通过为max参数设定一个值(非零)来制定最大分割数。

  如果给定分隔符不是使用特殊符号来匹配多重模式的正则表达式,那么re.split()与str.split()工作方式相同,例子如下

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

  

正则表达式为高级的文本模式匹配、抽取、与/或文本形式的搜索和替换功能提供了基础。通过标准库中的re模块来支持正...

函数参数说明:

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!

重复、特殊字符以及分组

>>> 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')
>>> 

 

正则表达式的特殊字符列表

特殊字符 描述
. 匹配所有字符串,除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*]表示空格或者*号

匹配字符串的起始和结尾以及单词边界

>>> 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'

  

使用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)
>>> 

 

使用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'

  

常见的正则表达式符号和特殊字符

表示法 描述 正则表达式示例
符号    
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 不区分大小写的匹配

 

创建字符集[]

>>> 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'
>>> 

  

匹配对象以及group()和groups()方法

  成功调用match()和search()返回的对象。

9159.com,  group()要么返回整个匹配对象,要么根据要求返回特定子组。groups()则仅返回一个包含唯一或者全部子组的元组。如果没有子组的要求,那么当group()仍然返回整个匹配时,groups()返回一个空元组。

 

本文由9159.com发布于编程,转载请注明出处:都是将某字符串中所有匹配正则表达式的部分进

关键词:

上一篇:没有了
下一篇:没有了