正则表达式概述

什么是正则表达式

    正则表达式：(Regular Expression)，是一些有特殊的字符和符号组成的字符串，主要用来进行高级的文本搜索、匹配、替代等功能。

第一个正则表达式

    通过定义一个简单的正则表达式，然后在目标字符串中进行查询匹配的操作，完成第一个程序的编写，同时对于正则表达式又一个初步的了解和认知。

# 引入正则表达式模块
import re
# 目标字符串
s = 'food foo tonight'
# 正则表达式
r = r'foo'
# 在目标字符串中查询符合正则表达式的字符
res = re.findall(r, s)
# 打印结果 查询到两个数据# ['foo', 'foo']
print(res)

Syntax of Regex(正则表达式操作语法)

Base Syntax

    正则表达式的核心就是匹配，匹配用到的也是字符串，对于正则表达式的理解就需要对正则表达式的语法有一个比较良好的熟悉度。下面针对正则表达式的常见操作，分成三个部分进行了简要描述，对正则表达式语法先有一个全面的了解。

基本正则语法

# coding:utf-8
import re

target = '''Are you new to Django or to programming? This is the place to start!
From scratch: Overview | Installation
Tutorial: Part 1: Requests and responses | Part 2: Models and the admin site
| Part 3:
Views and templates | Part 4: Forms and generic views | Part 5: Testing |
Part 6:
Static files | Part 7: Customizing the admin site
Advanced Tutorials: How to write reusable apps | Writing your first patch
for Django
'''

# 基本语法：字符匹配
reg1 = r"to"
print(re.findall(reg1, target))
# ['to', 'to', 'to', 'to', 'to', 'to', 'to']

# 基本语法：或者匹配
reg2 = r"Django|Part"
print(re.findall(reg2, target))
# ['Django', 'Part', 'Part', 'Part', 'Part', 'Part', 'Part', 'Part', 'Django']

# 基本语法：开头匹配
reg3 = r"^Are"
print(re.findall(reg3, target))
# ['Are']

# 基本语法：结尾匹配
reg4 = r"Django$"
print(re.findall(reg4, target))
# ['Django']

# 基本语法：任意字符匹配
reg5 = r"Ho."
print(re.findall(reg5, target))
# ['How']

# 基本语法：范围匹配?，匹配一个字符出现了0次或1次
reg6 = r"pr?"
print(re.findall(reg6, target))
# ['pr', 'p', 'p', 'p', 'p', 'p', 'p']

# 基本语法：范围匹配+，匹配一个字符出现了1次或n次
reg7 = r"pr+"
print(re.findall(reg7, target))
# ['pr']

# 基本语法：范围匹配*，匹配一个字符出现了0次或n次
reg8 = r"pr*"
print(re.findall(reg8, target))
# ['pr', 'p', 'p', 'p', 'p', 'p', 'p']

# 基本语法：范围匹配{m}，匹配一个字符出现了m次
"""
范围匹配：
{m,n}:匹配一个字符至少出现m次，至多出现n此
{m,}:匹配一个字符至少出现m次，至多不限
{,n}:匹配一个字符至多出现n次，至少不限
"""
reg9 = r"l{2}"
print(re.findall(reg9, target))
# ['ll']

# 基本语法：范围匹配[0-9]，匹配出现了一个0-9之间的数字
reg10 = r"[0-9]+"
print(re.findall(reg10, target))
# ['1', '2', '3', '4', '5', '6', '7']

# 基本语法：范围匹配[a-z]([A-Z])，匹配出现了一个a-z(A-Z)之间的小写(大写)字母
reg11 = r"[a-z]{10}"
print(re.findall(reg11, target))
# ['programmin', 'nstallatio', 'ustomizing']

# 基本语法：范围匹配[a-zA-Z0-9_]，匹配一个字母、数字或下划线
reg12 = r"[a-zA-Z0-9_]{10}"
print(re.findall(reg12, target))
# ['programmin', 'Installati', 'Customizin']

分组查询

# coding:utf-8
import re

target = '''
<img src="./images/1.jpg"/>
<img src="./images/2.jpg"/>
<img src="./images/3.jpg"/>
<img src="./images/4.jpg"/>
<img src="./images/5.jpg"/>'''

# 正则表达式中添加分组语法
reg = r'<img\s+src="(.*)"/>'

res = re.finditer(reg, target)
for r in res:
    # print(r.group())
    print(r.group(1))

正则表达式：元字符

# coding:utf-8
import re

# 目标字符串
target = """Django community 11445 people, 164 countries, 3845 packages and projects."""

# 元字符：\d，匹配任意一个[0-9]的数字
reg1 = r"\d+"
print(re.findall(reg1, target))
# ['11445', '164', '3845']

# 元字符：\s，匹配任意一个空白字符
reg2 = r"\s+"
print(re.findall(reg2, target))
# [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']

# 元字符：\b，匹配任意一个数字/字母/下划线
reg3 = r"\w{5}"
print(re.findall(reg3, target))
# ['Djang', 'commu', '11445', 'peopl', 'count', 'packa', 'proje']

# 元字符：，匹配任意一个单词的边界
reg4 = r"\ban."
print(re.findall(reg4, target))
# ['and']

正则表达式：零宽断言

# coding:utf-8
import re

# 目标字符串
target = 'aahelloworldbbhellojerryjerryup'

# 零宽断言：正向前视断言
reg1 = r'.{2}hello(?=world)'
res = re.finditer(reg1, target)
for r in res:
    print(r.group())        # aahello

reg2 = r'.{2}hello(?!world)'
res = re.finditer(reg2, target)
for r in res:
    print(r.group())        # bbhello

reg3 = r'(?<=hello)jerry.{2}'
res = re.finditer(reg3, target)
for r in res:
    print(r.group())        # jerryje

reg4 = r'(?<!hello)jerry.{2}'
res = re.finditer(reg4, target)
for r in res:
    print(r.group())        # jerryup

贪婪匹配 & 懒惰匹配

    贪婪模式和懒惰模式(非贪婪模式)是在正则操作过程中，需要严格注意的一个问题，如果操作不当的话很容易在匹配过程中得到非正常数据或者垃圾数据。

什么是贪婪和非贪婪模式

贪婪模式：在正则表达式匹配成功的前提下，尽可能多的匹配结果数据
非贪婪模式：在正则表达式匹配成功的前提下，尽可能少的匹配结果数据

贪婪和非贪婪模式

# coding:utf-8
import re

target = "<div>hello</div><p>world</p><div>regular expression</div>"

# 正则表达式：贪婪匹配
reg = re.compile(r"<div>.*</div>")
# 查询数据
res = reg.search(target)
print(res.group())
# <div>hello</div><p>world</p><div>regular expression</div>

# 正则表达式：懒惰匹配（非贪婪匹配）
reg = re.compile(r"<div>.*?</div>")
# 查询数据
res = reg.search(target)
print(res.group())
# <div>hello</div>

pyhton中的正则

re正则模块

python中通过标准库re模块对于正则表达式进行良好的技术支持。

为什么使用正则表达式

    正则表达式本身就是对于字符串的高效处理，尽管字符串本身也内置了一些操作函数，但是相对于较为复杂的需求，通过正则表达式的操作更加灵活并且效率更高。
    正则表达式在程序中的主要应用，有以下几个方面：
        匹配：测试一个字符串是否符合正则表达式语法，返回 True 或者 False
        获取：从目标字符串中，提取符合正则表达式语法的字符数据
        替换：在目标字符串中查询符合正则语法的字符，并替换成指定的字符串
        分割：按照符合正则表达式的语法字符对目标字符串进行分割

创建正则表达式的方式

    python中有两种方式可以创建正则表达式的匹配对象，两种方式使用都较为广泛，具体满足开发人员所在的团队的开发规范即可。

隐式创建：通过一个普通字符串，直接创建正则表达式
要求：必须通过re模块的函数调用才能正常编译执行

import re

# 创建一个正则表达式
reg = r"\bfoo\b"

# 从目标字符串中提取数据
result = re.findall(reg, target_str)

显式创建：通过内建函数compile()编译创建一个正则表达式对象
要求：可以通过调用该类型的方法，完成字符串的操作

import re
pattern = re.compile("\\bfoo\\b")
pattern.findall(target_str)

简要操作案例

# coding:utf-8
import re

target = "helloworldhelloregexp"

# 1.函数
reg1 = r"(?<=hello).{3}"
print(re.findall(reg1, target))
# ['wor', 'reg']

# 2.对象
reg2 = re.compile(r"(?<=hello).{3}")
print(reg2.findall(target))
# ['wor', 'reg']

re模块常用方法

常用方法

简单示例

# coding:utf-8
import re

target = "helloworldhellojerryhelloregularexpression"

# 定义正则表达式
reg = r"hello"

# findall()
print(re.findall(reg, target))
# ['hello', 'hello', 'hello']

# finditer()
res = re.finditer(reg, target)
for r in res:
    print(r.group())
# hello
# hello
# hello

# search()
res = re.search(reg, target)
print(res)
# <_sre.SRE_Match object; span=(0, 5), match='hello'>

# match()
res = re.match(reg, target)
print(res)
# <_sre.SRE_Match object; span=(0, 5), match='hello'>

# sub()
res = re.sub(reg, "**", target)
print(res)
# **world**jerry**regularexpression

# subn()
res = re.subn(reg, "**", target)
print(res)
# ('**world**jerry**regularexpression', 3)

# split()
res = re.split(reg, target)
print(res)
# ['', 'world', 'jerry', 'regularexpression']