正则表达式不只有在Python里面有,基本上所有的语言都会用到。
Re(Regular Expression)用来匹配字符串文本,个人觉得非常好用。
只要记住一些常用的表达式,其他的不懂是时候可以进行查找,毕竟只re只是个工具啦。
1,Python操作示例
在Python中需要通过正则表达式对字符串进行匹配的时候,可以使用一个模块,名字为re
#coding=utf-8
导入 re 模块
# 使用match方法进行匹配操作
result = re.match(正则表达式,要匹配的字符串) # 返回的是跨度
In [1]: import re
In [2]: string = "hello world! this is a test."
In [3]: result = re.match('hello',string)
In [4]: result
Out[4]: <_sre.SRE_Match object; span=(0, 5), match='hello'>
# 如果上一步匹配到数据的话,可以使用group方法来提取数据
result.group(x) 表示匹配的第几个数据
In [5]: result.group(0)
Out[5]: 'hello'
re.match是用来进行正则匹配检查的方法,若字符串匹配正则表达式,则match方法返回匹配对象(Match Object),否则返回None(注意不是空字符串”“)。
匹配对象Macth Object具有group方法,用来返回字符串的匹配部分。
注意: re.match() 能够匹配出以xxx开头的字符串
2,常用字符匹配
字符 | 功能 |
---|---|
. | 匹配任意1个字符(除了\n) |
[ ] | 匹配[ ]中列举的字符 |
\d | 匹配数字,即0-9 |
\D | 匹配非数字,即不是数字 |
\s | 匹配空白,即 空格,tab键 |
\S | 匹配非空白 |
\w | 匹配单词字符,即a-z、A-Z、0-9、_ |
\W | 匹配非单词字符 |
还有一些其他的,这里只是列举了常用的。
示例1: .
#coding=utf-8
import re
ret = re.match(".","a")
ret.group()
ret = re.match(".","b")
ret.group()
ret = re.match(".","M")
ret.group()
示例2:[ ]
import re
# 如果hello的首字符小写,那么正则表达式需要小写的h
ret = re.match("h","hello Python")
ret.group()
# 如果hello的首字符大写,那么正则表达式需要大写的H
ret = re.match("H","Hello Python")
ret.group()
# 大小写h都可以的情况
ret = re.match("[hH]","hello Python")
ret.group()
ret = re.match("[hH]","Hello Python")
ret.group()
# 匹配0到9第一种写法
ret = re.match("[0123456789]","7Hello Python")
ret.group()
# 匹配0到9第二种写法
ret = re.match("[0-9]","7Hello Python")
ret.group()
示例3:\d
#coding=utf-8
import re
# 普通的匹配方式
ret = re.match("嫦娥1号","嫦娥1号发射成功")
print ret.group()
ret = re.match("嫦娥2号","嫦娥2号发射成功")
print ret.group()
ret = re.match("嫦娥3号","嫦娥3号发射成功")
print ret.group()
# 使用\d进行匹配
ret = re.match("嫦娥\d号","嫦娥1号发射成功")
print ret.group()
ret = re.match("嫦娥\d号","嫦娥2号发射成功")
print ret.group()
ret = re.match("嫦娥\d号","嫦娥3号发射成功")
print ret.group()
其他符号可以参照这种自己练习下。我就不一一列举了。
3,原始字符串
那么问题来了,如果我们想匹配 . \ 类似这样的特殊符号怎么办?当然是转义啦,比如用 反斜杠 \ 。举个栗子:
>>> mm = "c:\\a\\b\\c"
>>> mm
'c:\\a\\b\\c'
>>> print(mm)
c:\a\b\c
>>> re.match("c:\\\\",mm).group()
'c:\\'
>>> ret = re.match("c:\\\\",mm).group()
>>> print(ret)
c:\
>>> ret = re.match("c:\\\\a",mm).group()
>>> print(ret)
c:\a
>>> ret = re.match(r"c:\\a",mm).group()
>>> print(ret)
c:\a
>>> ret = re.match(r"c:\a",mm).group()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
提示一下经测试,在Python3.6.1或更高版本中,直接使用re.match(‘c:\’,mm) 会报错,提示 TypeError(“first argument must be string or compiled pattern 。
说明:
python中字符串前面加上 r 表示原生字符串,
与大多数编程语言相同,正则表达式里使用”\”作为转义字符,这就可能造成反斜杠困扰。假如你需要匹配文本中的字符”\”,那么使用编程语言表示的正则表达式里将需要4个反斜杠”\”:前两个和后两个分别用于在编程语言里转义成反斜杠,转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。
Python里的原生字符串很好地解决了这个问题,有了原始字符串,你再也不用担心是不是漏写了反斜杠,写出来的表达式也更直观。
总之,你使用 r 就对了。
4,常用的数量匹配
匹配多个字符的相关格式
字符 | 功能 |
---|---|
* | 匹配前一个字符出现0次或者无限次,即可有可无 |
+ | 匹配前一个字符出现1次或者无限次,即至少有1次 |
? | 匹配前一个字符出现1次或者0次,即要么有1次,要么没有 |
{m} | 匹配前一个字符出现m次 |
{m,} | 匹配前一个字符至少出现m次 |
{m,n} | 匹配前一个字符出现从m到n次 |
示例1:*
需求:匹配出,一个字符串第一个字母为大小字符,后面都是小写字母并且这些小写字母可有可无
#coding=utf-8
import re
ret = re.match("[A-Z][a-z]*","Mm")
ret.group()
ret = re.match("[A-Z][a-z]*","Aabcdef")
ret.group()
示例2:+
需求:匹配出,变量名是否有效
#coding=utf-8
import re
ret = re.match("[a-zA-Z_]+[\w_]*","name1")
ret.group()
ret = re.match("[a-zA-Z_]+[\w_]*","_name")
ret.group()
ret = re.match("[a-zA-Z_]+[\w_]*","2_name")
ret.group()
示例3:?
需求:匹配出,0到99之间的数字
#coding=utf-8
import re
ret = re.match("[1-9]?[0-9]","7")
ret.group()
ret = re.match("[1-9]?[0-9]","33")
ret.group()
ret = re.match("[1-9]?[0-9]","09")
ret.group()
示例4:{m}
需求:匹配出,8到20位的密码,可以是大小写英文字母、数字、下划线
#coding=utf-8
import re
ret = re.match("[a-zA-Z0-9_]{6}","12a3g45678")
ret.group()
ret = re.match("[a-zA-Z0-9_]{8,20}","1ad12f23s34455ff66")
ret.group()
老规矩,其他的自己去练练。
5,表示边界的匹配
字符 | 功能 |
---|---|
^ | 可用来当做脱字符,也可用来匹配开头(根据位置而定) |
$ | 匹配字符串结尾 |
\b | 匹配一个单词的边界 |
\B | 匹配非单词边界 |
允许我懒一下下,实在是切来切去太麻烦了。你们将就看下好了。。不给栗子了就。
6,分组形式的匹配
字符 | 功能 |
---|---|
(ab) | 将括号中字符作为一个分组 |
\num | 引用分组num匹配到的字符串 |
(?P< name>) | 分组起别名 |
(?P=name) | 引用别名为name分组匹配到的字符串 |
这里讲下后面两个,因为当你在做网站的时候会经常用到,用来匹配url链接参数。
比如:需求:匹配出< html>< h1>www.baicu.com< /h1>< /html>
string = "<html><h1>www.baicu.com</h1></html>"
ret = re.match(r"<(?P<name1>\w*)><(?P<name2>\w*)>.*</(?P=name2)></(?P=name1)>", "string")
ret.group()
结果:
Out[87]: '<html><h1>www.baicu.com</h1></html>'
In [88]: pattern = re.compile("<(?P<name1>\w*)><(?P<name2>\w*)>.*</(?P=name2)><
...: /(?P=name1)>")
In [89]: pattern.match(string)
Out[89]: <_sre.SRE_Match object; span=(0, 35), match='<html><h1>www.baicu.com</h
1></html>'>
可见,前面的(?P\w*)与(?P\w*)的作用是匹配到对应字符串只有给它起一个别名,分别为 name1 name2 当你在后面需要用到前面匹配到的字符串时,只需要使用对应的别名就可以了 即:(?P=name1) (?P=name2) 。如果你们做网站后台的话,会很方便。
我前面使用过Django,就用到了这个。所以这里提下。
7,贪婪与非贪婪模式
什么叫贪婪?我打个比方,不然不好解释。
In [99]: string = "112233456"
In [100]: a = re.match('1*',string)
In [101]: a
Out[101]: <_sre.SRE_Match object; span=(0, 2), match='11'>
In [102]:
所谓贪婪就是它会尽可能多的匹配满足要求的字符。比如上面这个例子,不管你一开始有多少个1,它都会给你匹配出来。加入我们只想匹配一个呢?在后面加个?就可以了。
在Python中,默认为贪婪模式, 而 ? 为非贪婪字符。
In [104]: a = re.match('1+?',string)
In [105]: a
Out[105]: <_sre.SRE_Match object; span=(0, 1), match='1'>
8,正则表达式的常用方法
前面已经提到了一些了。
- search()
- match()
- findall()
sub ()
search()跟match()使用方法一样,唯一的区别在于,match只能从头开始找。
findall(regex,string)返回一个符合匹配要求的列表。
sub()用来将符合替换符合正则表达式的字符串。
# 匹配到997之后,将其替换为998
ret = re.sub(r"\d+", '998', "a = 997")
Conclusion:
就这么多了吧,毕竟全部记住也是需要时间的,多练习多看才是硬道理。