python 正则表达式

最新推荐文章于 2024-11-13 17:26:18 发布

aipuchai0633

最新推荐文章于 2024-11-13 17:26:18 发布

阅读量99

点赞数

文章标签： python

原文链接：http://www.cnblogs.com/cacique/archive/2012/02/23/2365368.html

版权

字符串的替换（非正则表达式）

>>> s = '100 NORTH MAIN ROAD'
>>> s.replace('ROAD', 'RD.') 
'100 NORTH MAIN RD.'

>>> s = '100 NORTH BROAD ROAD'
>>> s.replace('ROAD', 'RD.')  
'100 NORTH BRD. RD.'            #replace()会替换全部ROAD 为 RD.

#如果想只替换最后一个ROAD 
>>> s[:-4] + s[-4:].replace(s)
'100 NORTH BROAD RD.'

正则表达式方式

>>> s = '100 NORTH BROAD ROAD'
>>> import re
>>> re.sub('ROAD$', 'RD.', s)     # ROAD$ 中 $标明字符串的结尾 即最后一个单词
'100 NORTH BROAD RD.'       
>>> re.sub('ROAD$', 'RD.', s)
'100 NORTH BROAD RD.' 

>>> s = '100 BROAD'
>>> re.sub('ROAD$', 'RD.', s)
'100 BRD.' 
>>> re.sub('\\bROAD','RD',s)       
#‘\b’意思是“在右边必须有一个分隔符”   为了使起作用 必须加一转义符'\'
'100 BROAD'
>>> re.sub(r'\bROAD$', 'RD.', s)   
#也可以这样  前面添加一个字符‘r’。它告诉python，字符串中没有任何字符需要转义

#但 如果要替换的字符不在最后 如
>>> s = '100 BROAD ROAD APT. 3'
>>> re.sub(r'\bROAD\b','RD.',s)    #ROAD前后都加‘\b’表示前后都有一分隔符  即为一单独的单词
'100 BROAD RD. APT. 3'

正则表达式检测罗马数字是否合法

在罗马数字中，有七个不同的数字可以以不同的方式结合起来表示其他数字。

I = 1
V = 5
X = 10
L = 50
C = 100
D = 500
M = 1000

罗马数字表示规则（点击查看）

`正则表达式的匹配`

千位的匹配

>>> import re
>>> pattern = '^M?M?M?$'             
# '^' 表示从字符串头部开始  '$'表示一直到字符串结尾  即匹配整个字符串 ?表示M是可选的
>>> re.search(pattern, 'M')     
<_sre.SRE_Match object at 0106FB58>
>>> re.search(pattern, 'MM')    
<_sre.SRE_Match object at 0106C290>

re模块最基本的方法是search()函数。它使用正则表达式来匹配字符串（M）。如果成功匹配，search()返回一个匹配对象。如果没有匹配到，search()返回None。

检查百位数

百位有不同的表达方式。

100 = C
200 = CC
300 = CCC
400 = CD
500 = D
600 = DC
700 = DCC
800 = DCCC
900 = CM

因此有四种匹配方式

CM
CD
0-3个C
D + 0-3 C

>>> import re
>>> pattern = '^M?M?M?(CM|CD|D?C?C?C?)$'  
>>> re.search(pattern, 'MCM')             
<_sre.SRE_Match object at 01070390>
>>> re.search(pattern, 'MD')              
<_sre.SRE_Match object at 01073A50>

>>> re.search(pattern, 'MCMC')    
#匹配失败 第一个M匹配成功 第二第三个匹配失败 然后匹配CM 成功  之后结束 还剩一个C 无法匹配

使用语法{n,m}简化表达式

pattern = '^M?M?M?$' ==== pattern = '^M{0,3}$' 意思是“匹配字符串开始，然后是任意的0到3个M字符，再是字符串结尾”。

0 3 可以是任意数字 0表示最低匹配次数 3表示最多匹配次数

检查十位和个位

pattern = '^M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)$' #十位匹配

pattern = '^M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)(IX|IV|V?I?I?I?)$' #个位匹配

使用{n,m}的语法来替代上面的写法会是什么样子呢？下面的例子展示了这种新的语法。

pattern = '^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$'

松散正则表达式

松散的正则表达式和普通表达式的区别

空白符被忽略。空格、制表符和回车在正则表达式中并不会匹配空格、制表符、回车。如果你想在正则表达式中匹配他们，可以在前面加一个\来转义。
注释信息被忽略。松散正字表达式中的注释和python代码中的一样，都是以#开头直到行尾。它可以在多行正则表达式中增加注释信息，这就避免了在python代码中的多行注释。他们的工作方式是一样的。

pattern = '^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$' 用松散表达式表示为

pattern = '''
^                   # beginning of string
M{0,3}              # thousands - 0 to 3 Ms
(CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 Cs),
                    #            or 500-800 (D, followed by 0 to 3 Cs)
(XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 Xs),
                    #        or 50-80 (L, followed by 0 to 3 Xs)
(IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 Is),
                    #        or 5-8 (V, followed by 0 to 3 Is)
$                   # end of string
'''

如果要使用松散正则表达式，需要传递一个叫re.VERBOSE的参数

检测时用 re.search(pattern, 'M', re.VERBOSE)

简单案例----电话号码匹配

下面是可能的电话号码格式：

800-555-1212
800 555 1212
800.555.1212
(800) 555-1212
1-800-555-1212
800-555-1212-1234
800-555-1212x1234
800-555-1212 ext. 1234
work 1-(800) 555.1212 #1234

区域码是800，交换码是555，以及最后的后四码是1212。如果还有分机号，那就是1234

>>>phonePattern = re.compile(r'^(\d{3})-(\d{3})-(\d{4})$') #r表示字符串中没有字符需要转义 \d表示任意的数字 \d{3} 则表示任意三个数字中间用-隔开>>>phonePattern.search('800-555-1212').groups()('800', '555', '1212')

匹配成功 search()函数的返回值调用groups()方法。它会返回一个这个正则表达式中定义的所有分组结果组成的元组。

但是只能匹配 类似'800-555-1212' 没有分机号 用-隔开的号码

>>>phonePattern = re.compile(r'^(\d{3})\D+(\d{3})\D+(\d{4})\D+(\d+)$') #\D+ 表示至少一个不是数字的任意字符 \d+表示至少一个任意数字可以匹配#这个表达式可以匹配有分号并且号码间有字符隔开的号码>>>phonePattern.search('800 555 1212 1234').groups()('800', '555', '1212', '1234')>>>phonePattern.search('800-555-1212-1234').groups()('800', '555', '1212', '1234')

>>>phonePattern = re.compile(r'^(\d{3})\D*(\d{3})\D*(\d{4})\D*(\d*)$')

#正则表达式处理电话号码没有分隔符的情况

#\D* 表示不是数字的任意位数的任意字符 \d*表示任意位数的数字

>>>phonePattern.search('800-555-1212').groups()

('800', '555', '1212', '')

>>>phonePattern.search('work 1-(800) 555.1212 #1234') #但是头部有其它非数字字符的号码无法匹配

>>>

>>>phonePattern = re.compile(r'(\d{3})\D*(\d{3})\D*(\d{4})\D*(\d*)$') #去掉^ 跳过无关字符从数字开始匹配>>> phonePattern.search('work 1-(800) 555.1212 #1234').groups()('800', '555', '1212', '1234')>>> phonePattern.search('800-555-1212')('800', '555', '1212', '')>>> phonePattern.search('80055512121234')('800', '555', '1212', '1234')

把它改写成松散正则表达式

>>> phonePattern = re.compile(r'''
                # don't match beginning of string, number can start anywhere
    (\d{3})     # area code is 3 digits (e.g. '800')
    \D*         # optional separator is any number of non-digits
    (\d{3})     # trunk is 3 digits (e.g. '555')
    \D*         # optional separator
    (\d{4})     # rest of number is 4 digits (e.g. '1212')
    \D*         # optional separator
    (\d*)       # extension is optional and can be any number of digits
    $           # end of string
    ''', re.VERBOSE)
>>> phonePattern.search('work 1-(800) 555.1212 #1234').groups()  
('800', '555', '1212', '1234')
>>> phonePattern.search('800-555-1212')                          
('800', '555', '1212', '')

正则表达式一些小的技巧：