python3 正则表达式

一.正则表达式

1.正则表达式 (Regular Expression) 又称 RegEx, 是用来匹配字符的一种工具. 在一大串字符中寻找你需要的内容.

2.正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配

3.re 模块使 Python 语言拥有全部的正则表达式功能

4.它常被用在很多方面, 比如网页爬虫, 文稿整理, 数据筛选等等.

 

二.简单的匹配

import re
# regular expression
pattern1 = "dog"
pattern2 = "cat"
pattern3 = "bird"
string = "dog runs to cat"

#如果匹配成功，返回一个匹配的对象，没找到则返回none
#re.span方法显示匹配的位置
#group(num) 或 groups() 来获取匹配表达式

#re.match:匹配string初始位置
#re.match(pattern, string, flags=0)
#pattern:匹配的正则表达式;string要匹配的字符串;flags标志位，用于控制正则表达式的匹配方式
print(re.match(pattern1, string))
print(re.match(pattern1, string).span())#span函数显示匹配的位置
print(re.match(pattern1, string).group())#groop方法获取正则表达式
print(re.match(pattern2, string))
print(re.match(pattern3, string))
print('*'*50)

# re.search(pattern,string, flags=0)匹配整个string：在string中查找pattern
print(re.search(pattern1, string))  # <_sre.SRE_Match object; span=(12, 15), match='cat'>
print(re.search(pattern2, string))  #
print(re.search(pattern2, string).span())
print(re.search(pattern2, string).group())
print('*'*50)

#findall(pattern, string, flags=0)在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表
# 注意： match 和 search 是匹配一次,匹配到结束，findall 匹配所有，匹配完结束
print(re.findall(r"ran", "run ran ran ran"))
print(re.search(r"ran", "run ran ran ran"))
print(re.findall(r"(run|ran)", "run ran ran ran")) # | : or
print(re.search(r"(run|ran)", "run ran ran ran"))
print('*'*50)

#finditer(pattern, string, flags=0) 和findall类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回
r=re.finditer(r"(run|ran)", "run ran ren ran")
print(r)
for i in r:
    print(i.group())
-------------------------------------------------
<_sre.SRE_Match object; span=(0, 3), match='dog'>
(0, 3)
dog
None
None
**************************************************
<_sre.SRE_Match object; span=(0, 3), match='dog'>
<_sre.SRE_Match object; span=(12, 15), match='cat'>
(12, 15)
cat
**************************************************
['ran', 'ran', 'ran']
<_sre.SRE_Match object; span=(4, 7), match='ran'>
['run', 'ran', 'ran', 'ran']
<_sre.SRE_Match object; span=(0, 3), match='run'>
**************************************************
<callable_iterator object at 0x058E8470>
run
ran
ran

 

三.灵活匹配

import re
# multiple patterns 灵活匹配：匹配潜在的多个可能性文字，可用【】将可能的字符囊括起来
ptn = r"r[au]n"       # ("run" or "ran")
#建立一个正则的规则:我们在 pattern 的 “” 前面需要加上一个 r 用来表示这是正则表达式, 而不是普通字符串.
print(re.search(ptn, "dog runs to cat"))# <_sre.SRE_Match object; span=(4, 7), match='run'>

#括号 [] 中还可以是以下这些或者是这些的组合. 比如 [A-Z] 表示的就是所有大写的英文字母. [0-9a-z] 表示可以是数字也可以是任何小写字母
print(re.search(r"r[A-Z]n", "dog runs to cat"))
print(re.search(r"r[a-z]n", "dog runs to cat"))
print(re.search(r"r[0-9]n", "dog r2ns to cat"))
print(re.search(r"r[0-9a-z]n", "dog runs to cat"))
-----------------------------
<_sre.SRE_Match object; span=(4, 7), match='run'>
None
<_sre.SRE_Match object; span=(4, 7), match='run'>
<_sre.SRE_Match object; span=(4, 7), match='r2n'>
<_sre.SRE_Match object; span=(4, 7), match='run'>

 

四.sub替换

import re

#re.sub(pattern, repl, string, count=0)通过正则表达式匹配上一些形式的字符串然后再替代掉这些字符串.
#repl : 替换的字符串，也可为一个函数。count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
print(re.sub(r"r[au]ns", "catches", "dog runs to cat"))

# repl可以是一个函数。将匹配的数字乘于 2
def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)
s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s))
--------------------------------------------
dog catches to cat
A46G8HFD1134

 

五.compile编译正则表达式

import re
#compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供match()和search()这两个函数使用
#使用 compile 过后的正则, 来对这个正则重复使用
#先将正则表达式 compile为一个变量, 比如 compiled_re, 然后直接使用这个 变量compiled_re 来重复使用
compiled_re = re.compile(r"r[ua]n")
print(compiled_re.search("dog ran to cat"))
print(compiled_re.findall("run ran ran"))
------------------------------------------------------
<_sre.SRE_Match object; span=(4, 7), match='ran'>
['run', 'ran', 'ran']

 

六.split分割

import re
#split 方法按照能够匹配的子串将字符串分割后返回列表
#split(pattern, string, maxsplit=0, flags=0)
#maxsplit分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
#flags标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
print(re.split(r"[,;\.]", "a;b,c.d;e"))
print(re.split('\W+', ' runoob, runoob, runoob.', 1))
------------------------------------------------------
['a', 'b', 'c', 'd', 'e']
['', 'runoob, runoob, runoob.']

 

七.正则表达式修饰符(flags)：正则表达式可以包含一些可选标志修饰符来控制匹配的模式。

多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志

import re
print(re.search(r"r[A-Z]n", "dog runs to cat"))
print(re.search(r"r[A-Z]n", "dog runs to cat",flags=re.I))
------------------------------------------------------------------------
None
<_sre.SRE_Match object; span=(4, 7), match='run'>

 

 八.正则表达式模式：

模式字符串使用特殊的语法来表示一个正则表达式：

1.字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。

2.多数字母和数字前加一个反斜杠时会拥有不同的含义。

3.标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。

4.反斜杠本身需要使用反斜杠转义。

实例：