Python 正则表达式(匹配单个字符) - 寻找香烟smoke的故事

仅供学习,转载请注明出处

正则表达式概述

思考

  • 场景:胖子老板在写字板写了一大堆东西,判断是否存在smoke的语句,判断正确就可以送你一包烟。

  • 内容如下:

jkashdjkahskdjhaksjhdsmokejasdhjashdjhasd

这一串东西肉眼一看还算简单。中间的确有一个。

然后胖子老板不算数,继续给了一个升级版本,如下:

ajsdlka;sjd;lkjas;dlkujqoiueioujasldkasjlkdasdljkhalalksj;dla,msdmnas;lkdkasmdkl;amsx,.asjdklsomkeaskldjkalsjdklasmd,mxznjhsaioduoiwuasdjhkljasmnxnlkjsxhjalsdnkjlasbldkjnasdjnajsldnajlskdsmokeasjdlka;sjd;lkjasd;lkjasd

问在这里面有多少个smoke?


Python 正则表达式(匹配单个字符) - 寻找香烟smoke的故事_第1张图片
真是无情

那么有上面好办法来解决这个问题呢?

答复就是使用正则表达式来进行匹配查询。

那么下面先来补补正则表达式的内容。

re模块操作

在Python中需要通过正则表达式对字符串进行匹配的时候,可以使用一个模块,名字为re

基本的使用方法如下:

    #coding=utf-8

    # 导入re模块
    import re

    # 使用match方法进行匹配操作
    result = re.match(正则表达式,要匹配的字符串)

    # 如果上一步匹配到数据的话,可以使用group方法来提取数据
    result.group()
Python 正则表达式(匹配单个字符) - 寻找香烟smoke的故事_第2张图片
好啦,知道基本方法啦

下面来简单测试使用一下。

In [1]: import re                                                                                                                                                      

In [2]: result = re.match("smoke","ajksdhjkashdsmokeasjdljkasjd")                                                                                                      

In [3]: result.group()                                                                                                                                                 
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in 
----> 1 result.group()

AttributeError: 'NoneType' object has no attribute 'group'

In [4]:                                                                                                                                                                

In [4]: result = re.match("smoke","smokeaskdljalksdj")                                                                                                                 

In [5]: result.group()                                                                                                                                                 
Out[5]: 'smoke'

In [6]:  

可以简单地看出,re模块的这个match方法只能匹配出smoke开头的内容,不然就匹配不出来。

如果胖子老板鬼头一点,就不把smoke放最前面,那不就是找不出来?

看来是要再增加些技能点了。

匹配单个字符

正则表达式如果要找到对应的字符,就需要逐个字符或者类型去匹配,那么当然就有对应的匹配字符。

正则表达式的单字符匹配:

字符 功能
. 匹配任意1个字符(除了\n)
[ ] 匹配[ ]中列举的字符
\d 匹配数字,即0-9
\D 匹配非数字,即不是数字
\s 匹配空白,即 空格,tab键
\S 匹配非空白
\w 匹配单词字符,即a-z、A-Z、0-9、_
\W 匹配非单词字符

使用上面的这些字符就可以对应匹配出不同的字符组合,那么先来逐个测试使用一下。

使用 . ,匹配任意1个字符(除了\n)

In [7]: result = re.match(r".","smokeaskdljalksdj")                                                                                                                    

In [8]: result.group()                                                                                                                                                 
Out[8]: 's'

In [9]: result = re.match(r".","asdasdsmokeaskdljalksdj")                                                                                                              

In [10]: result.group()                                                                                                                                                
Out[10]: 'a'

In [11]:                                                                                                                                                               

In [11]: result = re.match(r".","!asdasdsmokeaskdljalksdj")                                                                                                            

In [12]: result.group()                                                                                                                                                
Out[12]: '!'

In [13]: result = re.match(r".","/asdasdsmokeaskdljalksdj")                                                                                                            

In [14]: result.group()                                                                                                                                                
Out[14]: '/'

In [15]: result = re.match(r".","1asdasdsmokeaskdljalksdj")                                                                                                            

In [16]: result.group()                                                                                                                                                
Out[16]: '1'

In [17]: result = re.match(r".","\n1asdasdsmokeaskdljalksdj")                                                                                                          

In [18]: result.group()                                                                                                                                                
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in 
----> 1 result.group()

AttributeError: 'NoneType' object has no attribute 'group'

In [19]:       

从结果上来看,. 可以任意匹配所有字符串(除了换行符\n

匹配[ ]中列举的字符

导入re模块

In [1]: import re                                                              

如果hello的首字符小写,那么正则表达式需要小写的h

In [2]: ret = re.match('h',"hello Python")                                     

In [3]: print(ret.group())                                                     
h

# 如果匹配错误,则会报错
In [4]: ret = re.match('H',"hello Python")                                     

In [5]: print(ret.group())                                                     
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in 
----> 1 print(ret.group())

AttributeError: 'NoneType' object has no attribute 'group'

In [6]:  

如果hello的首字符大写,那么正则表达式需要大写的H

In [6]: ret = re.match('H',"Hello Python")                                     

In [7]: print(ret.group())                                                     
H

In [8]:   

大小写h都可以的情况

In [8]: ret = re.match('[hH]',"Hello Python")                                  

In [9]: print(ret.group())                                                     
H

In [10]: ret = re.match('[hH]',"hello Python")                                 

In [11]: print(ret.group())                                                    
h

In [12]: ret = re.match('[hH]ello Python',"hello Python")                      

In [13]: print(ret.group())                                                    
hello Python

In [14]: ret = re.match('[hH]ello Python',"Hello Python")                      

In [15]: print(ret.group())                                                    
Hello Python

In [16]: ret = re.match('[Hh]ello Python',"Hello Python")                      

In [17]: print(ret.group())                                                    
Hello Python

In [18]:                 

匹配0到9第一种写法

# 增加匹配数字7
In [18]: ret = re.match('7[Hh]ello Python',"7Hello Python")                    

In [19]: print(ret.group())                                                    
7Hello Python

In [20]:                                                                       

# 如果匹配数字8会不会报错?
In [20]: ret = re.match('7[Hh]ello Python',"8Hello Python")                    

In [21]: print(ret.group())      # 淡定报错                                              
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in 
----> 1 print(ret.group())

AttributeError: 'NoneType' object has no attribute 'group'
                                                                 
# 那么如何能够同时匹配数字7和8呢?只要用 [] 括号起来就可以的了。
In [22]: ret = re.match('[78][Hh]ello Python',"8Hello Python")                 

In [23]: print(ret.group())                                                    
8Hello Python

# 那么如果想要匹配 0 - 9 所有数字呢?可以如下:
In [24]: ret = re.match('[0123456789][Hh]ello Python',"8Hello Python")         

In [25]: print(ret.group())                                                    
8Hello Python

In [26]: ret = re.match('[0123456789][Hh]ello Python',"1Hello Python")         

In [27]: print(ret.group())                                                    
1Hello Python

# 不过不要误会可以匹配多个字符,是无法匹配 123 的
In [28]: ret = re.match('[0123456789][Hh]ello Python',"123Hello Python")       

In [29]: print(ret.group())           # 不负众望,淡定报错                                         
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in 
----> 1 print(ret.group())

AttributeError: 'NoneType' object has no attribute 'group'

In [30]:                                           

匹配0到9第二种写法

# 刚才使用[0123456789]的写法真是费劲,那么下面使用[0-9]就可以简单写好
In [30]: ret = re.match('[0-9][Hh]ello Python',"8Hello Python")                

In [31]: print(ret.group())                                                    
8Hello Python

In [32]:                                                                       

# 那么如果想要剔除数字7呢?只要中断开来即可。
In [32]: ret = re.match('[0-68-9][Hh]ello Python',"8Hello Python")             

In [33]: print(ret.group())                                                    
8Hello Python

In [34]: ret = re.match('[0-68-9][Hh]ello Python',"0Hello Python")             

In [35]: print(ret.group())                                                    
0Hello Python

In [36]: ret = re.match('[0-68-9][Hh]ello Python',"1Hello Python")             

In [37]: print(ret.group())                                                    
1Hello Python

# 匹配数字7的时候,淡定报错
In [38]: ret = re.match('[0-68-9][Hh]ello Python',"7Hello Python")             

In [39]: print(ret.group())                                                    
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in 
----> 1 print(ret.group())

AttributeError: 'NoneType' object has no attribute 'group'

In [40]:     

匹配数字,即0-9:\d

上面示例使用[0-9]的方式来匹配数字,虽然是可以,但是有时候懒得写,就可以直接用\d来简单写写即可。
一个字,省事呀。

## 使用两个\d来匹配两个数字
In [42]: ret = re.match('蓝利群一包\d\d元',"蓝利群一包17元")                   

In [43]: print(ret.group())                                                    
蓝利群一包17元

In [44]:                                                                       

## 使用一个\d来匹配一个数字
In [44]: ret = re.match('包子\d元',"包子2元")                                  

In [45]: print(ret.group())                                                    
包子2元

In [46]: ret = re.match('包子\d元',"包子0元")                                  

In [47]: print(ret.group())                                                    
包子0元    

# 测试\d能否匹配英文字母a
In [48]: ret = re.match('包子\d元',"包子a元")                                  

In [49]: print(ret.group())          # 淡定报错                                         
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in 
----> 1 print(ret.group())

AttributeError: 'NoneType' object has no attribute 'group'

In [50]:     

匹配非数字,即不是数字:\D

简单来说大写D就是小写d的匹配取反,既然小写d可以匹配0-9,然后大写D肯定就不行啦。

In [50]: ret = re.match('包子\D元',"包子a元")                                  

In [51]: print(ret.group())                                                    
包子a元

In [52]: ret = re.match('包子\D元',"包子1元")                                  

In [53]: print(ret.group())                                                    
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in 
----> 1 print(ret.group())

AttributeError: 'NoneType' object has no attribute 'group'

In [54]:     

匹配空白,即 空格,tab键:\s

# 直接输入一个空格来匹配
In [56]: ret = re.match('包子\d 元',"包子1 元")                                

In [57]:                                                                       

In [57]: print(ret.group())            # 淡定正常                                        
包子1 元

In [58]:                                                                       

# 那么如果输入多个空格,是否能够自动匹配呢?
In [58]: ret = re.match('包子\d 元',"包子1    元")                             

In [59]: print(ret.group())                  # 无情报错                                  
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in 
----> 1 print(ret.group())

AttributeError: 'NoneType' object has no attribute 'group'         

# 那么使用\s能够自动匹配多个空格呢?
In [60]: ret = re.match('包子\d\s元',"包子1    元")                            

In [61]: print(ret.group())                # 淡定不行                                
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in 
----> 1 print(ret.group())

AttributeError: 'NoneType' object has no attribute 'group'

# 淡定增加一个 + 号,用来多个字符匹配,意思就是 + 号前面的 \s 多个进行匹配。
In [62]: ret = re.match('包子\d\s+元',"包子1    元")                           

In [63]: print(ret.group())   # 淡定成功                                                 
包子1    元

In [64]:                       

匹配非空白:\S

## 使用两个大写S来匹配 包子 二字
In [64]: ret = re.match('\S\S\d\s+元',"包子1    元")                           

In [65]: print(ret.group())              # 淡定匹配,那么是不是换行符也可以匹配呢?                                  
包子1    元

# 匹配一下换行符 \n 试试
In [66]: ret = re.match('\S\S\d\s+元',"\n子1    元")                           

In [67]: print(ret.group())          # 其实换行符是空的,而\S是匹配非空,那么当然就报错了。                                          
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in 
----> 1 print(ret.group())

AttributeError: 'NoneType' object has no attribute 'group'

# 测试匹配一下特殊字符看看
In [68]: ret = re.match('\S\S\d\s+元',"@子1    元")                                                                                              

In [69]: print(ret.group())                                                    
@子1    元

In [70]:                                                                       

In [70]: ret = re.match('\S\S\d\s+元',"!@1    元")                                                                                               

In [71]: print(ret.group())                                                    
!@1    元

In [72]:    

匹配单词字符,即a-z、A-Z、0-9、_ :\w

简单一看这个\w就是等价于[0-9a-zA-z_],下面可以测试一下

# 首先测试一下 \w 来匹配 数字、大小写字母,以及下划线
In [78]: re.match('\S\S\d\s+\w元',"!@1    a元").group()                        
Out[78]: '!@1    a元'

In [79]: re.match('\S\S\d\s+\w元',"!@1    A元").group()                        
Out[79]: '!@1    A元'

In [80]: re.match('\S\S\d\s+\w元',"!@1    1元").group()                        
Out[80]: '!@1    1元'

In [81]: re.match('\S\S\d\s+\w元',"!@1    _元").group()                        
Out[81]: '!@1    _元'

In [82]:   

# 再用等价的 [0-9a-zA-Z_] 进行匹配测试
In [82]: re.match('\S\S\d\s+[0-9a-zA-Z_]元',"!@1    1元").group()              
Out[82]: '!@1    1元'

In [83]: re.match('\S\S\d\s+[0-9a-zA-Z_]元',"!@1    9元").group()              
Out[83]: '!@1    9元'

In [84]: re.match('\S\S\d\s+[0-9a-zA-Z_]元',"!@1    a元").group()              
Out[84]: '!@1    a元'

In [85]: re.match('\S\S\d\s+[0-9a-zA-Z_]元',"!@1    B元").group()              
Out[85]: '!@1    B元'

In [86]: re.match('\S\S\d\s+[0-9a-zA-Z_]元',"!@1    _元").group()              
Out[86]: '!@1    _元'

# 测试 \w 能否匹配 感叹号这种特殊字符
In [87]: re.match('\S\S\d\s+\w元',"!@1    !元").group()                        
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in 
----> 1 re.match('\S\S\d\s+\w元',"!@1    !元").group()

AttributeError: 'NoneType' object has no attribute 'group'

In [88]: re.match('\S\S\d\s+[0-9a-zA-Z_]元',"!@1    !元").group()              
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in 
----> 1 re.match('\S\S\d\s+[0-9a-zA-Z_]元',"!@1    !元").group()

AttributeError: 'NoneType' object has no attribute 'group'

In [89]:    

匹配非单词字符: \W

简单来看,大写的W就是取反小写w的范围。那么下面来试试。

# 淡定匹配感叹号,这个小写w是无法匹配滴
In [89]: re.match('\S\S\d\s+\W元',"!@1    !元").group()                        
Out[89]: '!@1    !元'

# 再来测试匹配数字,淡定报错
In [90]: re.match('\S\S\d\s+\W元',"!@1    1元").group()                        
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in 
----> 1 re.match('\S\S\d\s+\W元',"!@1    1元").group()

AttributeError: 'NoneType' object has no attribute 'group'

# 淡定匹配换行符看看,真的可以
In [91]: re.match('\S\S\d\s+\W元',"!@1    \n元").group()                       
Out[91]: '!@1    \n元'

In [92]:      

但是拥有匹配单个字符的技能,还不能满足找到多个字符之中的smoke呀。
下一个篇章,将会继续多个字符的匹配规则讲述。


关注微信公众号,回复【资料】、Python、PHP、JAVA、web,则可获得Python、PHP、JAVA、前端等视频资料。

你可能感兴趣的:(Python 正则表达式(匹配单个字符) - 寻找香烟smoke的故事)