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

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

正则表达式概述

思考

  • 场景:胖子老板在写字板写了一大堆东西,判断是否存在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呀。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

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

    前面篇章讲到了如何匹配单个字符,但是却不能完美解决胖子老板提出的这个问题。那么当然就要继续增加技能点,来解决这个问题啦。

    Devops海洋的渔夫
  • Python 正则表达式(匹配分组)

    我们在查询东西的时候不一定就是查一样,可能还会想要同时查询另一样东西。那么前面的只是讲述了匹配查询一样的情况。

    Devops海洋的渔夫
  • Python 正则表达式(匹配开头结尾)

    Devops海洋的渔夫
  • Intent组件

    Android页面之间的跳转可以分为几类,比如有A和B两个页面,从A页面直接跳转到B页面,这样的跳转比较简单,或者从A页面跳转到B页面但是需要传送数据。在And...

    水击三千
  • 阿布扎比警方将使用人工智能来解决行人安全

    本报讯阿布扎比消息---阿布扎比警方正在对人行横道使用人工智能(AI)进行全面研究以加强行人过人行横道的安全性。 ? 阿布扎比警察局紧急事务部门主任Ali Kh...

    企鹅号小编
  • 使用Tensorflow和公共数据集构建预测和应用问题标签的GitHub应用程序

    GH-Archive通过从GitHub REST API中摄取大部分这些事件,从GitHub记录大量数据。这些事件以GSON格式从GitHub发送到GH-Arc...

    代码医生工作室
  • 云计算、IoT和SDN为企业网带来最大的问题

    根据Kentik发布的一份新报告,云计算的采用仍然是造成网络复杂性的最令人烦恼的因素。该调查报告是基于参加Cisco Live 2017大会的203名IT专业人...

    SDNLAB
  • 记录下改滚动条样式的css

    @media (min-width: 768px) {     ::-webkit-scrollbar {       ...

    龙泉寺扫地僧
  • 5G为何先用于商用

    5G网络是第五代移动通信网络,其峰值理论传输速度可达每秒数十Gb,比4G网络的传输速度快数百倍。举例来说,一部1G超高画质电影可在3秒之内下载完成。简单从定义上...

    齿轮易创说互联网
  • 【Python环境】监督学习之KNN算法

    1、ipython是一个python的交互式shell,比默认的python shell好用得多,支持变量自动补全,自动缩进,支持bash shell命令,内置...

    陆勤_数据人网

扫码关注云+社区

领取腾讯云代金券

玩转腾讯云 有奖征文活动