python 正则表达式

cacique

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

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


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


    

  • 
^ 匹配字符串开始位置。
    • 

  • 
$ 匹配字符串结束位置。
    • 

  • 
\b 匹配一个单词边界。
    • 

  • 
\d 匹配一个数字。
    • 

  • 
\D 匹配一个任意的非数字字符。
    • 

  • 
x? 匹配可选的x字符。换句话说，就是0个或者1个x字符。
    • 

  • 
x* 匹配0个或更多的x。
    • 

  • 
x+ 匹配1个或者更多x。
    • 

  • 
x{n,m} 匹配n到m个x，至少n个，不能超过m个。
    • 

  • 
(a|b|c) 匹配单独的任意一个a或者b或者c。
    • 

  • 
(x) 这是一个组，它会记忆它匹配到的字符串。你可以用re.search返回的匹配对象的groups()函数来获取到匹配的值。
    • 

  • 
[sxz] 的意思是： “s、 x 或 z”，但只匹配其中之一。
    • 

  • 
[^abc] 的意思是：“ 除了a、 b 或 c 之外的任何字符”。
    • 



pa = r\'\*(.+)\*\'


re.sub(pa,r\'<em>\l</em>\',s)


此时 正则表达式会匹配尽可能多的 * *之间所有的字符  例如*dddd* 将变为<em>dddd</em>  *dd**ss*将变为<em>dd**ss</em>


pa = r\'\*(.+?)\*\'


此时 正则表达式会匹配尽可能少的 * *之间所有的字符   例如*dddd* 将变为<em>dddd</em>  *dd**ss*将变为<em>dd</em><em>ss</em>






            

            
        

	    
	    
    


 
                    
            
                

                  
 
        

	 
        

            

                                
分类：
 
                                                                
技术点：

                                            

        

        
相关文章：

        

      
            
 
                    
    
                                            

               
   
         

    


  






 
          

    
猜你喜欢 

        
    
                        

   
 



    
相关资源 

        
    
              
                            

   

   
    

     
相似解决方案 

         
    
                          

    

  
   

    

 
   

    
热门标签  

    

                    Java
                        Python
                        linux
                        javascript
                        Mysql
                        C#
                        Docker
                        算法
                        前端
                        SpringBoot
                        Redis
                        Vue
                        spring
                        设计模式
                        .net core
                        .net
                        kubernetes
                        c++
                        数据库
                        数据结构
                        大数据
                        js
                        机器学习
                        微服务
                        Android
                        Go
                        程序员
                        面试
                        JVM
                        ASP.net core
                        云原生
                        人工智能
                        后端
                        PHP
                        git
                        CSS
                        golang
                        k8s
                        Nginx
                        Django
                        mybatis
                        深度学习
                        多线程
                        React
                        架构
                        devops
                        爬虫
                        云计算
                        Spring Boot
                        LeetCode