3_python进阶—正则表达式

最新推荐文章于 2024-06-21 09:36:39 发布

少云清

最新推荐文章于 2024-06-21 09:36:39 发布

阅读量424

点赞数

分类专栏： Python专栏文章标签： python 正则表达式开发语言

本文链接：https://blog.csdn.net/brawly/article/details/127201521

版权

Python专栏专栏收录该内容

58 篇文章 3 订阅

订阅专栏

一、正则表达式概述

正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。

二、re模块操作（匹配、取值）

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

re.match( ) 能够匹配出以xxx开头的字符串

2.1 re模块的使用过程

#coding=utf-8

# 导入re模块
import re

# 使用match方法进行匹配操作
# 正则表达式，你制定的规则
# 要匹配的字符串，用户输入的内容
result = re.match(正则表达式,要匹配的字符串)

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

2.2 re模块示例(匹配以itcast开头的语句)

# coding=utf-8

import re

result = re.match(r"itcast", "itcast.cn")

print(result)   # <re.Match object; span=(0, 6), match='itcast'>
s = result.group()
print(s)   # itcast

三、匹配单个字符

字符	功能
.	匹配任意1个字符（除了\n） \n表示换行
[ ]	匹配[ ]中列举的字符
\d	匹配数字，即0-9 ；一个 \d 等价于一位数字
\D	匹配非数字，即不是数字
\s	匹配空白，即空格，或 tab键
\S	匹配非空白
\w	匹配单词字符，即a-z、A-Z、0-9、_
\W	匹配非单词字符

3.1 .

# 方法一
import re
ret = re.match(r"t.o", "two")
print(ret.group())   # two

# 方法二
import re
print(re.match(r"t.o", "two").group())  # two

3.2 [ ]

import re

# 如果hello的首字符小写，那么正则表达式需要小写的h
ret = re.match(r"h","hello Python")
print(ret.group())   # h


ret1 = re.match(r"速度与激情[12345678]", "速度与激情1")
print(ret1.group())  # 速度与激情1


ret2=re.match(r"速度与激情[1-8]", "速度与激情1")
print(ret2.group())   # 速度与激情1


ret3 = re.match(r"速度与激情[1-36-8]", "速度与激情7")   # 1-3,6-8
print(ret3.group())  # 速度与激情7

3.3 \d

一个\d等价于一位数字

import re

# 使用\d进行匹配
ret = re.match(r"嫦娥\d号", "嫦娥1号发射成功")
print(ret.group())    # 嫦娥 1 号

3.4 \s

import re

print(re.match(r"速度与激情 \d", "速度与激情 1").group())
# 速度与激情 1

print(re.match(r"速度与激情\s\d", "速度与激情 1").group())
# 速度与激情 1

print(re.match(r"速度与激情\s\d", "速度与激情\t1").group())   # \t代表tab键
# 速度与激情    1

3.5 \w

慎用，还包括中文

import re

ret = re.match(r"速度与激情\w", "速度与激情e")
print(ret.group())   # 速度与激情e


ret = re.match(r"速度与激情\w", "速度与激情哈")
print(ret.group())   # 速度与激情哈

四、匹配多个字符

匹配多个字符的相关格式

字符	功能
*	匹配前一个字符出现0次或者无限次，即可有可无
+	匹配前一个字符出现1次或者无限次，即至少有1次
?	匹配前一个字符出现1次或者0次，即要么有1次，要么没有
{m}	匹配前一个字符出现m次
{m,n}	匹配前一个字符出现从m到n次

4.1 * （重要）

如果想要换行，一个字符串应该怎么做？
如果一个字符串里面很长，有可能出现很多换行，那么可以采用三个双引号，三个双引号之间写数据。三个双引号和三个双引号实质上字符串。

import re

html_content = """fdsf
kasdjfkjasdkfjkasdjfjahsdufhawufhausdhfuahsdf
asdjfhjjasdhf
asdfasd'fas
df
asd"""

# 比配不到换行后的，如果想要匹配换行后的，添加re.S
print(re.match(r".*", html_content).group())             # fdsf
print(re.match(r".*", html_content, re.S).group())

# fdsf
# kasdjfkjasdkfjkasdjfjahsdufhawufhausdhfuahsdf
# asdjfhjjasdhf
# asdfasd'fas
# df
# asd

4.2 +

import re

print(re.match(r".+", "a").group())     # a
print(re.match(r".+", "ab").group())    # ab

4.3 ?

import re

print(re.match(r"021-\d{8}", "021-12345678").group())         # 021-12345678

# ?号前面的一个可有可无，有只能是1个
print(re.match(r"021-?\d{8}", "02112345678").group())         # 02112345678
print(re.match(r"021-?\d{8}", "021-12345678").group())        # 021-12345678
print(re.match(r"\d{3,4}-?\d{7,8}", "0532-1234567").group())   # 0532-1234567

4.4 {m}

import re

print(re.match(r"\d{11}", "12345678901").group())   # 12345678901
print(re.match(r"\d{11}", "1234567890").group())    # AttributeError: 'NoneType' object has no attribute 'group'

4.5 {m,n}

import re

# 匹配前面的\d有多少个，d{1,3}有3次
print(re.match(r"速度与激情\d{1,3}", "速度与激情123").group())   # 速度与激情123
print(re.match(r"速度与激情\d{1,3}", "速度与激情1").group())     # 速度与激情1
print(re.match(r"速度与激情\d{1,3}", "速度与激情12").group())    # 速度与激情1

五、匹配开头结尾

字符	功能
^	匹配字符串开头
$	匹配字符串结尾

5.1 $

import re


def main():
    names = ["age", "_age", "1age", "age1", "a_age", "age_1_", "age!", "a#123", "__________"]
    for name in names:
        # ret = re.match(r"[a-zA-Z_][a-zA-Z0-9_]*", name)
        # ^规定开头  $规定结尾
        # python中的match默认是从头开始判断的所以，在match中可以不写^，但是match不会判断结尾，所以
        # 当需要以xxx结尾的时候 还需要写上$
        ret = re.match(r"^[a-zA-Z_][a-zA-Z0-9_]*$", name)
        if ret:
            print("变量名:%s 符合要求....通过正则匹配出来的数据是:%s" % (name, ret.group()))
        else:
            print("变量名:%s 不符合要求...." % name)


if __name__ == "__main__":
    main()
    
    
# 变量名:age 符合要求....通过正则匹配出来的数据是:age
# 变量名:_age 符合要求....通过正则匹配出来的数据是:_age
# 变量名:1age 不符合要求....
# 变量名:age1 符合要求....通过正则匹配出来的数据是:age1
# 变量名:a_age 符合要求....通过正则匹配出来的数据是:a_age
# 变量名:age_1_ 符合要求....通过正则匹配出来的数据是:age_1_
# 变量名:age! 不符合要求....
# 变量名:a#123 不符合要求....
# 变量名:__________ 符合要求....通过正则匹配出来的数据是:__________

5.2 匹配163.com的邮箱地址

import re


def main():
   email = input("请输入一个邮箱地址:")
   # 如果在正则表达式中需要用到了某些普通的字符，比如 . 比如? 等，仅仅需要在他们前面添加一个 反斜杠进行转义
   ret = re.match(r"[a-zA-Z_0-9]{4,20}@163\.com$", email)
   if ret:
      print("%s符合要求...." % email)
   else:
      print("%s不符合要求...." % email)


if __name__ == "__main__":
   main()

六、匹配分组

字符	功能
\|	匹配左右任意一个表达式
(ab)	将括号中字符作为一个分组
`\num`	引用分组num匹配到的字符串
`(?P<name>)`	分组起别名
(?P=name)	引用别名为name分组匹配到的字符串

6.1 | (|前面整个表达式，或者后面整个表达式)

import re

print(re.match(r"[a-zA-Z0-9_]{4,20}@163|126\.com$", "laowang@163.com").group())
# laowang@163

print(re.match(r"[a-zA-Z0-9_]{4,20}@163|126\.com$", "126.com").group())
# 126.com

6.2 ( )

仅仅将126或者163分为两部分 (163|126)

pyimport re

print(re.match(r"[a-zA-Z0-9_]{4,20}@(163|126)\.com$", "126.com").group())
# AttributeError: 'NoneType' object has no attribute 'group'


print(re.match(r"[a-zA-Z0-9_]{4,20}@(163|126)\.com$", "laowang@126.com").group())
# laowang@126.com

6.2.1 （）单独取出小括号里面的值

匹配出要求的邮箱来，这个邮箱通过规范之后，把163还是126还是qq把东西取出来，统计用户用的哪一个多。
在正则表达式匹配成功的前提下，如果想单独取出某一个或者某一部分数据来，那么就把那一部分的数据的两边加上（），那么将来在这个正则表达式通过的情况下，那么可以单独取这个（）里面的数，而不是取整体的值。、
有几个（），group( )里面的数字就有几个；想要取第一个（）中的东西，写group(1)；想要取第二个（）里面的东西，写group(2)。

import re

print(re.match(r"[a-zA-Z0-9_]{4,20}@(163|126)\.com$", "laowang@163.com").group(1))
# 163
print(re.match(r"[a-zA-Z0-9_]{4,20}@(163|126)\.com$", "laowang@163.com").group(2))
# IndexError: no such group

print(re.match(r"([a-zA-Z0-9_]{4,20})@(163|126)\.com$", "laowang@163.com").group(1))
# laowang
print(re.match(r"([a-zA-Z0-9_]{4,20})@(163|126)\.com$", "laowang@163.com").group(2))
# 163
print(re.match(r"([a-zA-Z0-9_]{4,20})@(163|126)\.com$", "laowang@163.com").group(3))
# IndexError: no such group

6.3 \number

import re

html_str = "<h1>hahahah</h2>"
print(re.match(r"<\w*>.*</\w*>", html_str).group())
# <h1>hahahah</h2>

# \1 取正则里面第一组分组的值，即(\w*)里面的值
print(re.match(r"<(\w*)>.*</\1>", html_str).group())
# AttributeError: 'NoneType' object has no attribute 'group'

html_str2 = "<body><h1>hahahah</h1></body>"
print(re.match(r"<(\w*)><(\w*)>.*</\2></\1>", html_str2).group())
# <body><h1>hahahah</h1></body>

6.4 `(?P<name>)` `(?P=name)`

import re

html_str2 = "<body><h1>hahahah</h1></body>"

# 分组起的别名p1
print(re.match(r"<(?P<p1>\w*)><(?P<p2>\w*)>.*</(?P=p2)></(?P=p1)>", html_str2).group())
# <body><h1>hahahah</h1></body>

七、re模块的高级用法

7.1 search

match是从头匹配

search 是不会从头开始匹配，但是只要匹配到一个符合它的要求的数据的地方，那么就匹配到了。

import re

# 需求：匹配出文章阅读的次数
ret = re.search(r"\d+", "阅读次数为 9999")
print(ret.group())
# 9999

# search从字符串中开始拿着正则去匹配，匹配到第一个之后，它就把这个数据返回，不会再匹配了
print(re.search(r"\d+", "阅读次数为 9999, 点赞数为:100").group())
# 9999

7.2 findall

直接返回数据，返回是列表，不用group

import re

# 需求：统计出python、c、c++相应文章阅读的次数
ret = re.findall(r"\d+", "python = 9999, c = 7890, c++ = 12345")
print(ret)
# ['9999', '7890', '12345']

7.3 sub 将匹配到的数据进行替换

import re

# 需求：将匹配到的阅读次数加1
# sub(正则,数据,字符串)，先拿正则匹配字符串，然后将数据替换字符串中的数字，即998代替997，然后返回整个字符串
ret = re.sub(r"\d+", '998', "python = 997")
print(ret)
# python = 998

print(re.sub(r"\d+", '998', "python = 997, c++ = 1024"))
# python = 998, c++ = 998

7.3.1 sub支持函数的调用

import re

def add(temp):
    strNum = temp.group()    # 997
    num = int(strNum) + 1
    return str(num)

# 先拿正则表达式匹配字符串，匹配到则调用add函数，调用函数的时候会把匹配出来的对象传递到函数的参数中，
# 想取数，匹配那个值  对象.group()取值，之后想干什么干什么，之后返回新的字符串，返回是什么替换什么
ret = re.sub(r"\d+", add, "python = 997")
print(ret)   # 998

ret = re.sub(r"\d+", add, "python = 99")
print(ret)   # 100

7.4 split 根据匹配进行切割字符串，并返回一个列表

import re

# 需求：切割字符串“info:xiaoZhang 33 shandong”
# 按照 冒号和空格  切割
ret = re.split(r":| ", "info:xiaoZhang 33 shandong")
print(ret)

# ['info', 'xiaoZhang', '33', 'shandong']

八、Python贪婪和非贪婪

Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），

贪婪：总是尝试匹配尽可能多的字符；

非贪婪：总是尝试匹配尽可能少的字符。

8.1 贪婪变成非贪婪

在"*","?","+","{m,n}"后面加上？，使贪婪变成非贪婪。

import re

s = "This is a number 234-235-22-423"
r = re.match(r".+(\d+-\d+-\d+-\d+)", s)
print(r.group(1))
# 4-235-22-423

r = re.match(r".+?(\d+-\d+-\d+-\d+)", s)
print(r.group(1))
# 234-235-22-423

正则表达式模式中使用到通配字，那它在从左到右的顺序求值时，会尽量“抓取”满足匹配最长字符串，在我们上面的例子里面，“.+”会从字符串的启始处抓取满足模式的最长字符，其中包括我们想得到的第一个整型字段的中的大部分，“\d+”只需一位字符就可以匹配，所以它匹配了数字“4”，而“.+”则匹配了从字符串起始到这个第一位数字4之前的所有字符。

九、r的作用

Python中字符串前面加上 r 表示原生字符串。

与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符 " \ “，那么使用编程语言表示的正则表达式里将需要4个反斜杠”\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。

Python里的原生字符串很好地解决了这个问题，有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。

>>> mm = "c:\\a\\b\\c"
>>> ret = re.match(r"c:\\a",mm).group()
>>> print(ret)
c:\a
    
>>> ret = re.match("c:\\\\a",mm).group()
>>> print(ret)
c:\a

少云清

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录