首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >Python 正则表达式(匹配单个字符) - 寻找香烟smoke的故事

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

作者头像
Devops海洋的渔夫
发布2019-05-31 10:52:06
1.2K0
发布2019-05-31 10:52:06
举报
文章被收录于专栏:Devops专栏Devops专栏

正则表达式概述

思考

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

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

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

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

问在这里面有多少个smoke?

真是无情

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

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

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

re模块操作

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

基本的使用方法如下:

    #coding=utf-8

    # 导入re模块
    import re

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

    # 如果上一步匹配到数据的话,可以使用group方法来提取数据
    result.group()

好啦,知道基本方法啦

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

In [1]: import re                                                                                                                                                      

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

In [3]: result.group()                                                                                                                                                 
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-3-c8eb6f1e4981> in <module>
----> 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)
<ipython-input-18-c8eb6f1e4981> in <module>
----> 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)
<ipython-input-5-78af6c16457f> in <module>
----> 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)
<ipython-input-21-78af6c16457f> in <module>
----> 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)
<ipython-input-29-78af6c16457f> in <module>
----> 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)
<ipython-input-39-78af6c16457f> in <module>
----> 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)
<ipython-input-49-78af6c16457f> in <module>
----> 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)
<ipython-input-53-78af6c16457f> in <module>
----> 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)
<ipython-input-59-78af6c16457f> in <module>
----> 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)
<ipython-input-61-78af6c16457f> in <module>
----> 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)
<ipython-input-67-78af6c16457f> in <module>
----> 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)
<ipython-input-87-197a2dcee198> in <module>
----> 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)
<ipython-input-88-d6524879a9cc> in <module>
----> 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)
<ipython-input-90-bd6e937cb2ef> in <module>
----> 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呀。

本文参与 腾讯云自媒体分享计划,分享自作者个人站点/博客。
原始发表:2018.12.21 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 正则表达式概述
    • re模块操作
      • 匹配单个字符
        • 使用 . ,匹配任意1个字符(除了\n)
          • 匹配[ ]中列举的字符
            • 匹配数字,即0-9:\d
              • 匹配非数字,即不是数字:\D
                • 匹配空白,即 空格,tab键:\s
                  • 匹配非空白:\S
                    • 匹配单词字符,即a-z、A-Z、0-9、_ :\w
                      • 匹配非单词字符: \W
                      领券
                      问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档