AI 助理
备案控制台
开发者社区 大数据 文章 正文

正则表达式（三）：python re模块

2018-07-10 837
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 以下示例所使用 python 版本为： 3.7python 提供 re 模块，来满足正则表达式的使用。在开始介绍 re 模块之前，首先说明一下两个小内容：转义字符 \转义字符作用是使得字符失去原本的意思，去表示另外一个作用。

以下示例所使用 python 版本为： 3.7

python 提供 re 模块，来满足正则表达式的使用。在开始介绍 re 模块之前，首先说明一下两个小内容：

  1. 转义字符 \

转义字符作用是使得字符失去原本的意思，去表示另外一个作用。例如字符 d 表示一个普通的字符 d， 加 \ 转义后 \d 表示数字，字符 s 经转义后，\s 表示空白字符。

如果要匹配转义符号 \ 本身，则需要表达为 \\ 。而在编程语言中要表达两个转义符号 \\，则需要对每个转义符号进行转义，即形式为 \\\\，需要四个转义符号才能完成用于匹配一个转义符号 \ 的正则表达式。

为了减弱转义字符使用上的麻烦，能够将使用者的注意力集中在正则表达式的编写上，这里推荐所有的正则表达式开头使用 r 字符开头，表示正则内容作为原始字符串输入到 re 模块的使用中。即编程环境中 r'\\' 直接作为正则表达式使用，来完成对字符 \ 的匹配。

示例：

import re

reg = r'\\'
str = '\\'    #转义符号，str实际值为\

if re.match(reg,str):
    print('match {}'.format(str))
------------------------
运行结果：
match \
  1. Pattern、Match对象

在re模块中使用正则表达式完成字符串处理有两种方式：

  • 在 python 中可以直接使用 re 模块生成 Match 对象，完成字符串处理。
    示例：
import re

reg = r'abc'
str = 'abc'

mattern = re.match(reg,str)
print(mattern .group())
------------------------
运行结果：
abc
  • 使用 re 模块生成 Pattern 对象，然后使用 Pattern 对象生成 Match 对象，完成字符串处理。
    示例：
import re

reg = r'abc'
str = 'abc'

pattern = re.compile(reg)
match = pattern.match(str)
print(match.group())
------------------------
运行结果：
abc

这两种方式执行效果基本一样，观察 re 模块源代码：

模块： \Python37\Lib\re.py

# --------------------------------------------------------------------
# public interface

def match(pattern, string, flags=0):          #第一种方式
    """Try to apply the pattern at the start of the string, returning
    a Match object, or None if no match was found."""
    return _compile(pattern, flags).match(string)

def compile(pattern, flags=0):                #第二种方式
    "Compile a regular expression pattern, returning a Pattern object."
    return _compile(pattern, flags)

# --------------------------------------------------------------------
# internals

_cache = {}  # ordered!

_MAXCACHE = 512
def _compile(pattern, flags):
    # internal: compile pattern
    if isinstance(flags, RegexFlag):
        flags = flags.value
    try:
        return _cache[type(pattern), pattern, flags]         #从缓存字典中查询
    except KeyError:
        pass
    if isinstance(pattern, Pattern):
        if flags:
            raise ValueError(
                "cannot process flags argument with a compiled pattern")
        return pattern
    if not sre_compile.isstring(pattern):
        raise TypeError("first argument must be string or compiled pattern")
    p = sre_compile.compile(pattern, flags)
    if not (flags & DEBUG):
        if len(_cache) >= _MAXCACHE:
            # Drop the oldest item
            try:
                del _cache[next(iter(_cache))]
            except (StopIteration, RuntimeError, KeyError):
                pass
        _cache[type(pattern), pattern, flags] = p         #添加到缓存字典中
    return p

观察源码可知， re 模块提供的 compile 函数和 match 函数，都需要先通过 _compile(pattern, flags) 函数生成一个 Pattern 对象，区别在于 match 函数直接在生成 Pattern 对象后调用了 match 函数。
观察 _compile(pattern, flags) 函数体可知，首先会从缓存字典中查询是否已经存在 Pattern 对象，存在则返回，不存在则生成该 Pattern 对象，添加到缓存字典后返回。

由此可知，直接使用 re 模块的 match 函数来生成 Match 对象，和使用 re 模块的 compile 函数生成 Pattern 对象，然后再利用 match 函数生成 Match 对象完成字符串处理，这两种方式都是首先调用 _compile(pattern, flags) 函数生成一个Pattern对象，然后再使用该 Pattern 对象的 match 函数生成 Match 对象。

所以两种方式基本相同，区别只在于当 Pattern 对象多次使用时，第一种方式会存在多次查询缓存操作，且缓存字典容量是有限制的，超出后会删除最先添加的 Pattern 对象，所以推荐所有的正则中都使用构造的 Pattern 对象来完成字符串处理。

下面列出 Pattern 对象中使用到的函数：
函数名 作用
match(string, pos=0, endpos=-1) 在指定范围内，从指定的起始位置开始匹配，得到匹配对象则返回
search(string, pos=0, endpos=-1) 在指定范围内，从任意位置开始匹配，得到匹配对象则返回
findall(string, pos=0, endpos=-1) 在指定范围内，返回所有匹配结果构成的列表
finditer(string, pos=0, endpos=-1) 在指定范围内，返回所有匹配对象构成的迭代器
split(string, maxsplit=0) 按照指定的分割次数，返回分割得到的结果列表
sub(repl, string, count=0) 按照指定的替换规则和替换次数，返回替换后的结果
subn(repl, string, count=0) 按照指定的替换规则和替换次数，返回替换后的结果和替换次数构成的元组
  • match 函数

match 函数返回指定范围内，从指定起始位置开始匹配到的对象。使用过程中只有三点需要注意一下：
1. 可以指定匹配的范围，默认范围是 0 到 len(str)
2. 匹配是从指定的起始位置开始的，也就是固定了开始位置
3. 匹配成功则返回，也就是只返回一个匹配对象

示例：

import re

reg = r'\d'
pattern = re.compile(reg)

str1 = 'a1b2c3'

match1 = pattern.match(str1)
match2 = pattern.match(str1,1)

print('match1 = {}'.format(match1))
if match1:
    print('match1 matched = {}'.format(match1.group()))

print('match2 = {}'.format(match2))
if match2:
    print('match2 matched = {}'.format(match2.group()))
运行结果：
match1 = None
match2 = <re.Match object; span=(1, 2), match='1'>
match2 matched = 1
  • search 函数

search 函数返回指定范围内，从任意起始位置开始匹配到的对象。使用过程中只有三点需要注意一下：
1. 可以指定匹配的范围，默认范围是 0 到 len(str)
2. 匹配是从范围内的任意起始位置开始的，也就是不固定开始位置
3. 匹配成功则返回，也就是只返回一个匹配对象

示例：

import re

reg = r'\d'
pattern = re.compile(reg)

str1 = 'a1b2c3'

match1 = pattern.search(str1)

print('match1 = {}'.format(match1))
if match1:
    print('match1 matched = {}'.format(match1.group()))
运行结果：
match1 = <re.Match object; span=(1, 2), match='1'>
match1 matched = 1

比较 match 和 search 函数的使用：两个函数都是一次匹配，得到结果则返回 (None 或 Match 对象)，区别在于 match 函数从指定的起始位置开始匹配，search 函数从指定范围内的任意位置开始。

  • findall 函数

findall 函数返回指定范围内，所有匹配结果构成的列表。使用过程中只有两点需要注意一下：
1. 可以指定匹配的范围，默认范围是 0 到 len(str)
2. 返回的是一个列表，元素是 str 对象，而非 Match 对象

示例：

import re

reg = r'\d'
pattern = re.compile(reg)

str1 = 'a1b2c3'

match1 = pattern.findall(str1)

print('match1 = {}'.format(match1))
for element in match1:
    print('element = {}'.format(element))
运行结果：
match1 = ['1', '2', '3']
element = 1
element = 2
element = 3
  • finditer 函数

finditer 函数返回指定范围内，所有匹配对象构成的迭代器。使用过程中只有两点需要注意一下：
1. 可以指定匹配的范围，默认范围是 0 到 len(str)
2. 返回的是一个迭代器，元素是 Match 对象

示例：

import re

reg = r'\d'
pattern = re.compile(reg)

str1 = 'a1b2c3'

match1 = pattern.finditer(str1)

print('match1 = {}'.format(match1))
for element in match1:
    print('element = {}'.format(element.group()))
运行结果：
match1 = <callable_iterator object at 0x0000000002CA0550>
element = 1
element = 2
element = 3

比较 findall 和 finditer 函数的使用：两个函数都是获取所有匹配内容，区别在于 findall 函数返回的是一个列表，元素类型是 str，finditer 函数返回的是一个迭代器，元素类型是 Match 。

  • split 函数

split 函数返回根据指定分割次数，分割后得到的结果列表。使用过程中只有两点需要注意一下：
1. 可以指定分割次数，默认值 0 表示全分割
2. 返回的是一个列表，元素是 str 对象

示例：

import re

reg = r'\d'
pattern = re.compile(reg)

str1 = 'a1b2c3'

match1 = pattern.split(str1)

print('match1 = {}'.format(match1))
for element in match1:
    print('element = {}'.format(element))
运行结果：
match1 = ['a', 'b', 'c', '']
element = a
element = b
element = c
element =
  • sub 函数

sub 函数根据指定替换规则和替换次数，返回替换后内容。使用过程中只有三点需要注意一下：
1. 可以指定替换次数，默认值 0 表示全替换
2. 返回的是一个 str 对象
3. 指定的替换规则可以是 str 对象，可以是一个函数，也可以是分组的引用

示例：

import re

def fun(match):
    return match.group()[::-1]

reg = r'(\d)(\d)'
pattern = re.compile(reg)

str1 = 'a12b34c56'

match1 = pattern.sub('__',str1)
match2 = pattern.sub(fun,str1)
match3 = pattern.sub(r'\2\1',str1)

print('match1 = {}'.format(match1))
print('match2 = {}'.format(match2))
print('match3 = {}'.format(match3))
运行结果：
match1 = a__b__c__
match2 = a21b43c65
match3 = a21b43c65
  • subn 函数

subn 函数根据指定替换规则和替换次数，返回替换后内容和替换次数构成的元组。使用过程中只有三点需要注意一下：
1. 可以指定替换次数，默认值 0 表示全替换
2. 返回的是一个 str 对象和 int 对象构成的元组
3. 指定的替换规则可以是 str 对象，可以是一个函数，也可以是分组的引用

示例：

import re

def fun(match):
    return match.group()[::-1]

reg = r'(\d)(\d)'
pattern = re.compile(reg)

str1 = 'a12b34c56'

match1 = pattern.subn('__',str1,1)
match2 = pattern.subn('__',str1,2)


print('match1 = {}'.format(match1))
print('match2 = {}'.format(match2))
运行结果：
match1 = ('a__b34c56', 1)
match2 = ('a__b__c56', 2)

比较 sub 和 subn 函数的使用：两个函数都是替换匹配内容，区别在于 sub 函数返回的是一个 str 对象，subn 函数返回的是替换后 str 对象和替换次数 int 对象构成的元组。

下面列出 Match 对象中常到的函数：
函数名 作用
group(*args) 返回指定的分组匹配的结果
groups(default=None) 返回所有分组匹配结果构成的元组
span(group=0) 返回由指定分组匹配结果区间的首尾两个下标值构成的元组
start(group=0) 返回指定分组匹配结果区间的首下标值
end(group=0) 返回指定分组匹配结果区间的尾下标值
  • group、groups、span、start、end 函数

以上这几个函数作为常用函数，使用方式较为简单：
1. group：返回指定分组匹配的内容，参数为零或者默认值时，返回整个正则表达式匹配结果；参数为多个分组时，返回分组匹配结果构成的元组
2. groups：返回分组匹配结果构成的元组
3. span：返回指定分组匹配结果区间的首尾两个下标值（左闭右开）构成的元组，默认情况下匹配整个正则表达式匹配结果的首尾两个下标值
4. start：返回指定分组匹配结果区间的首下标
5. end：返回指定分组匹配结果区间的尾下标

示例：

import re

reg = r'(\d)(\d)'
pattern = re.compile(reg)

str1 = 'a12b'

match1 = pattern.search(str1)

print('group 1 = {}'.format(match1.group(1)))
print('span 1 = {}'.format(match1.span(1)))
print('start 1 = {}'.format(match1.start(1)))
print('end 1 = {}'.format(match1.end(1)),end='\n\n')

print('group 2 = {}'.format(match1.group(2)))
print('span 2 = {}'.format(match1.span(2)))
print('start 2 = {}'.format(match1.start(2)))
print('end 2 = {}'.format(match1.end(2)),end='\n\n')

print('groups = {}'.format(match1.groups()))
print('span = {}'.format(match1.span()))
print('start = {}'.format(match1.start()))
print('end = {}'.format(match1.end()),end='\n\n')

print('group 1,2 = {}'.format(match1.group(1,2)))
运行结果：
group 1 = 1
span 1 = (1, 2)
start 1 = 1
end 1 = 2

group 2 = 2
span 2 = (2, 3)
start 2 = 2
end 2 = 3

groups = ('1', '2')
span = (1, 3)
start = 1
end = 3

group 1,2 = ('1', '2')
Pattern 用作模式处理，Match 用作分组结果提取

比较以上 Pattern 和 Match 两种对象的使用方式，可以发现 Pattern 对象作用如其名称所示，是一种体现正则表达式规则的对象，也就是体现为一种文本模式。其所提供的诸多函数，如： find、search、match 等等，都是拿自身的规则以不同的方式去处理目标文本。而 Match 对象则是对分组结果的操作，Match 对象提供的函数则都是对结果以不同方式的提取，如：groups、span等，获取匹配分组结果的各项数据。

文章标签：
Python
缓存
机器学习/深度学习
分布式计算
关键词：
Python正则表达式
Python模块
Python re
正则表达式模块
Python正则表达式RE模块
登天蚂蚁
目录
相关文章
vohelon
|
6天前
|
Python
在Python中，可以使用内置的`re`模块来处理正则表达式
在Python中，可以使用内置的`re`模块来处理正则表达式
vohelon
19 5
爱专研的技术土狗
|
11天前
|
数据采集 Web App开发 iOS开发
如何使用 Python 语言的正则表达式进行网页数据的爬取？
使用 Python 进行网页数据爬取的步骤包括：1. 安装必要库（requests、re、bs4）；2. 发送 HTTP 请求获取网页内容；3. 使用正则表达式提取数据；4. 数据清洗和处理；5. 循环遍历多个页面。通过这些步骤，可以高效地从网页中提取所需信息。
爱专研的技术土狗
23 1
kaixin321-44007
|
16天前
|
Java 程序员 开发者
Python的gc模块
Python的gc模块
kaixin321-44007
16 2
Ly001122
|
19天前
|
数据采集 Web App开发 JavaScript
python-selenium模块详解！！！
Selenium 是一个强大的自动化测试工具，支持 Python 调用浏览器进行网页抓取。本文介绍了 Selenium 的安装、基本使用、元素定位、高级操作等内容。主要内容包括：发送请求、加载网页、元素定位、处理 Cookie、无头浏览器设置、页面等待、窗口和 iframe 切换等。通过示例代码帮助读者快速掌握 Selenium 的核心功能。
Ly001122
62 5
张志凌
|
23天前
|
Python
SciPy 教程 之 SciPy 模块列表 7
`scipy.constants` 模块提供了常用的时间单位转换为秒数的功能。例如，`constants.hour` 返回 3600.0 秒，表示一小时的秒数。其他常用时间单位包括分钟、天、周、年和儒略年。
张志凌
17 6
张志凌
|
20天前
|
Python
SciPy 教程 之 SciPy 模块列表 13
SciPy教程之SciPy模块列表13：单位类型。常量模块包含多种单位，如公制、二进制（字节）、质量、角度、时间、长度、压强、体积、速度、温度、能量、功率和力学单位。示例代码展示了如何使用`constants`模块获取零摄氏度对应的开尔文值（273.15）和华氏度与摄氏度的转换系数（0.5556）。
张志凌
17 1
Ly001122
|
21天前
|
XML 前端开发 数据格式
超级详细的python中bs4模块详解
Beautiful Soup 是一个用于从网页中抓取数据的 Python 库，提供了简单易用的函数来处理导航、搜索和修改分析树。支持多种解析器，如 Python 标准库中的 HTML 解析器和更强大的 lxml 解析器。通过简单的代码即可实现复杂的数据抓取任务。本文介绍了 Beautiful Soup 的安装、基本使用、对象类型、文档树遍历和搜索方法，以及 CSS 选择器的使用。
Ly001122
52 1
张志凌
|
22天前
|
Python
SciPy 教程 之 SciPy 模块列表 9
SciPy教程之常量模块介绍，涵盖多种单位类型，如公制、质量、角度、时间、长度、压强等。示例展示了如何使用`scipy.constants`模块查询不同压强单位对应的帕斯卡值，包括atm、bar、torr、mmHg和psi。
张志凌
13 1
张志凌
|
22天前
|
Python
SciPy 教程 之 SciPy 模块列表 8
SciPy教程之常量模块单位类型介绍。该模块包含多种单位，如公制、质量、角度、时间、长度、压强、体积、速度、温度、能量、功率和力学单位。示例展示了部分长度单位的转换值，例如英寸、英尺、海里等。
张志凌
14 1
张志凌
|
18天前
|
Python
SciPy 教程 之 SciPy 模块列表 16
SciPy教程之SciPy模块列表16 - 单位类型。常量模块包含多种单位，如公制、质量、角度、时间、长度、压强、体积、速度、温度、能量、功率和力学单位。示例代码展示了力学单位的使用，如牛顿、磅力和千克力等。
张志凌
15 0

热门文章

最新文章

  • 1
    正则表达式实现条件替换功能
  • 2
    js正则表达式语法
  • 3
    学习笔记-5.1.正则表达式1
  • 4
    正则表达式30分钟入门教程-2
  • 5
    正则表达式之awk
  • 6
    Python正则表达式指南中半部
  • 7
    JS的正则表达式1
  • 8
    以前学习笔记整理：正则表达式
  • 9
    C#关于使用正则表达式解析字符串
  • 10
    学习正则表达式在python中的应用
  • 1
    使用Python实现深度学习模型：文本生成与自然语言处理
    116
  • 2
    python类型错误（TypeError）
    58
  • 3
    python属性错误（AttributeError）
    202
  • 4
    python变量未定义（NameError）
    99
  • 5
    Python进行自动化
    63
  • 6
    深度剖析：AJAX、Fetch API如何成为Python后端开发者的最佳拍档！
    90
  • 7
    从零到精通，AJAX与Fetch API让你的Python Web前后端交互无所不能！
    39
  • 8
    颠覆传统！AJAX、Fetch API与Python后端，开启Web开发新篇章！
    37
  • 9
    告别‘老司机’时代，AJAX与Fetch API让你的前端与Python后端无缝对接！
    59
  • 10
    Python数据分析加速器：深度挖掘Pandas与NumPy的高级功能
    45

    • 相关课程

    更多
  • Python爬虫实战
  • Python开发基础入门
  • Python常用数据科学库
  • Python网络爬虫实战
  • Python完全自学手册图文教程
  • Python基础快速入门实战教程

    • 相关电子书

    更多
  • From Python Scikit-Learn to Sc
  • Data Pre-Processing in Python:
  • 双剑合璧-Python和大数据计算平台的结合

    • 相关实验场景

    更多
  • Python新手入门
  • Python入门
  • Python选择及循环结构
  • Python新手入门（Anolis OS）
  • Python网络通信程序典型应用

    • 推荐镜像

    更多
  • python-release
  • nodejs-release
  • libreoffice
    • 下一篇
    阿里云OSS设置跨域访问