"阅读目录 re 模块中常用功能函数正则表达式正则表达式本身是一种小型的、高度专业化的编程语言，而在 python 中，通过内嵌集成 re 模块，程序员们可以直接调用来实现正则匹配。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。 [图片] 正则表达式是用来匹配处理字符串的 ...."

someone1
AI专业者开发社区 1 号成员
AI开发者社区 • 0 回帖 • 10 浏览 • 5 个月前

Python--re模块

阅读目录

re 模块中常用功能函数

正则表达式

正则表达式本身是一种小型的、高度专业化的编程语言，而在 python 中，通过内嵌集成 re 模块，程序员们可以直接调用来实现正则匹配。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。

正则表达式是用来匹配处理字符串的 python 中使用正则表达式需要引入 re 模块

如：

import re #第一步，要引入 re 模块

a = re.findall("匹配规则", "要匹配的字符串") #第二步，调用模块函数

以列表形式返回匹配到的字符串

如：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入 re 模块
a = re.findall("匹配规则", "这个字符串是否有匹配规则的字符")   #第二步，调用模块函数
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配规则']

View Code

^ 元字符

字符串开始位置与匹配规则符合就匹配，否则不匹配

匹配字符串开头。在多行模式中匹配每一行的开头

^ 元字符如果写到 [] 字符集里就是反取

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入 re 模块
a = re.findall("^ 匹配规则", "匹配规则这个字符串是否匹配")   #字符串开始位置与匹配规则符合就匹配，否则不匹配
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配规则']

View Code

[^a-z] 反取，匹配出除字母外的字符，^ 元字符如果写到字符集里就是反取

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入 re 模块
a = re.findall("[^a-z]", "匹配 s 规则这 s 个字符串是否 s 匹配 f 规则则 re 则则则")   #反取，匹配出除字母外的字符
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹', '配', '规', '则', '这', '个', '字', '符', '串', '是', '否', '匹', '配', '规', '则', '则', '则', '则', '则']

View Code

$ 元字符

字符串结束位置与匹配规则符合就匹配，否则不匹配

匹配字符串末尾，在多行模式中匹配每一行的末尾

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入 re 模块
a = re.findall("匹配规则 $", "这个字符串是否匹配规则")   #字符串结束位置与匹配规则符合就匹配，否则不匹配
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配规则']

View Code

* 元字符

需要字符串里完全符合，匹配规则，就匹配，（规则里的* 元字符）前面的一个字符可以是 0 个或多个原本字符

匹配前一个字符 0 或多次，贪婪匹配前导字符有多少个就匹配多少个很贪婪

如果规则里只有一个分组，尽量避免用 * 否则会有可能匹配出空字符串

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入 re 模块
a = re.findall("匹配规则 *", "这个字符串是否匹配规则则则则则")   #需要字符串里完全符合，匹配规则，就匹配，（规则里的 * 元字符）前面的一个字符可以是 0 或多个原本字符
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配规则则则则则']

View Code

+ 元字符

需要字符串里完全符合，匹配规则，就匹配，（规则里的+ 元字符）前面的一个字符可以是 1 个或多个原本字符

匹配前一个字符 1 次或无限次，贪婪匹配前导字符有多少个就匹配多少个很贪婪

#!/usr/bin/env python
# -*- coding:gbk -*-
import re   #第一步，要引入 re 模块
a = re.findall("匹配 +", "匹配配配配配规则这个字符串是否匹配规则则则则则")   #需要字符串里完全符合，匹配规则，就匹配，（规则里的 + 元字符）前面的一个字符可以是 1 个或多个原本字符
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配配配配配', '匹配']

View Code

? 元字符，和防止贪婪匹配

需要字符串里完全符合，匹配规则，就匹配，（规则里的? 元字符）前面的一个字符可以是 0 个或 1 个原本字符

匹配一个字符 0 次或 1 次

还有一个功能是可以防止贪婪匹配，详情见防贪婪匹配

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入 re 模块
a = re.findall("匹配规则?", "匹配规这个字符串是否匹配规则则则则则")   #需要字符串里完全符合，匹配规则，就匹配，（规则里的? 元字符）前面的一个字符可以是 0 个或 1 个原本字符
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配规', '匹配规则']

View Code

{} 元字符, 范围

需要字符串里完全符合，匹配规则，就匹配，（规则里的 {} 元字符）前面的一个字符，是自定义字符数，位数的原本字符

{m} 匹配前一个字符 m 次，{m,n} 匹配前一个字符 m 至 n 次，若省略 n，则匹配 m 至无限次

{0,} 匹配前一个字符 0 或多次, 等同于 * 元字符
{+,} 匹配前一个字符 1 次或无限次, 等同于 + 元字符
{0,1} 匹配前一个字符 0 次或 1 次, 等同于? 元字符

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入 re 模块
a = re.findall("匹配规则 {3}", "匹配规这个字符串是否匹配规则则则则则")   #{m} 匹配前一个字符 m 次，{m,n} 匹配前一个字符 m 至 n 次，若省略 n，则匹配 m 至无限次
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配规则则则']

View Code

[] 元字符, 字符集

需要字符串里完全符合，匹配规则，就匹配，（规则里的 [] 元字符）对应位置是[] 里的任意一个字符就匹配

字符集。对应的位置可以是字符集中任意字符。字符集中的字符可以逐个列出，也可以给出范围，如 [abc] 或[a-c]。[^abc]表示取反，即非 abc。
所有特殊字符在字符集中都失去其原有的特殊含义。用 \ 反斜杠转义恢复特殊字符的特殊含义。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入 re 模块
a = re.findall("匹配 [a,b,c] 规则", "匹配 a 规则这个字符串是否匹配 b 规则则则则则")   #需要字符串里完全符合，匹配规则，就匹配，（规则里的 [] 元字符）对应位置是 [] 里的任意一个字符就匹配
print(a)  #以列表形式返回匹配到的字符串

View Code

[^]非，反取，匹配出除 [^] 里面的字符，^ 元字符如果写到字符集里就是反取

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入 re 模块
a = re.findall("[^a-z]", "匹配 s 规则这 s 个字符串是否 s 匹配 f 规则则 re 则则则")   #反取，匹配出除字母外的字符
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹', '配', '规', '则', '这', '个', '字', '符', '串', '是', '否', '匹', '配', '规', '则', '则', '则', '则', '则']

View Code

反斜杠后边跟普通字符实现特殊功能；（即预定义字符）

预定义字符是在字符集和组里都是有用的

\d 匹配任何十进制数，它相当于类 [0-9]

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入 re 模块
a = re.findall("\d", "匹配规则这 2 个字符串 3 是否匹配规则 5 则则则 7 则")   #\d 匹配任何十进制数，它相当于类 [0-9]
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['2', '3', '5', '7']

View Code

\d+ 如果需要匹配一位或者多位数的数字时用

#!/usr/bin/env python
# -*- coding:gbk -*-
import re   #第一步，要引入 re 模块
a = re.findall("\d+", "匹配规则这 2 个字符串 134444 是否匹配规则 5 则则则 7 则")   #\d+ 如果需要匹配一位或者多位数的数字时用
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['2', '134444', '5', '7']

View Code

\D 匹配任何非数字字符，它相当于类 [^0-9]

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入 re 模块
a = re.findall("\D", "匹配规则这 2 个字符串 3 是否匹配规则 5 则则则 7 则")   #\D 匹配任何非数字字符，它相当于类 [^0-9]
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹', '配', '规', '则', '这', '个', '字', '符', '串', '是', '否', '匹', '配', '规', '则', '则', '则', '则', '则']

View Code

\s 匹配任何空白字符，它相当于类 [\t\n\r\f\v]

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入 re 模块
a = re.findall("\s", "匹配规则   这 2 个字符串 3 是否匹 \n 配规则 5 则则则 7 则")   #\s 匹配任何空白字符，它相当于类 [\t\n\r\f\v]
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['',' ',' ','\n']

View Code

\S 匹配任何非空白字符，它相当于类 [^\t\n\r\f\v]

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入 re 模块
a = re.findall("\S", "匹配规则   这 2 个字符串 3 是否匹 \n 配规则 5 则则则 7 则")   #\S 匹配任何非空白字符，它相当于类 [^\t\n\r\f\v]
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹', '配', '规', '则', '这', '2', '个', '字', '符', '串', '3', '是', '否', '匹', '配', '规', '则', '5', '则', '则', '则', '7', '则']

View Code

\w 匹配包括下划线在内任何字母数字字符，它相当于类 [a-zA-Z0-9_]

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re   #第一步，要引入 re 模块
a = re.findall('\w',"https://www.cnblogs.com/")  #\w 匹配包括下划线在内任何字母数字字符，它相当于类 [a-zA-Z0-9_]
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['h', 't', 't', 'p', 's', 'w', 'w', 'w', 'c', 'n', 'b', 'l', 'o', 'g', 's', 'c', 'o', 'm']

View Code

\W 匹配非任何字母数字字符包括下划线在内，它相当于类 [^a-zA-Z0-9_]

import re   #第一步，要引入 re 模块
a = re.findall('\W',"https://www.cnblogs.com/")  #\w 匹配包括下划线在内任何字母数字字符，它相当于类 [a-zA-Z0-9_]
print(a)  #以列表形式返回匹配到的字符串
#打印出 [':', '/', '/', '.', '.', '/']

View Code

() 元字符，分组

也就是分组匹配，() 里面的为一个组也可以理解成一个整体

如果 ()后面跟的是特殊元字符如 (adc)* 那么 * 控制的前导字符就是 () 里的整体内容，不再是前导一个字符

列 1

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re   #第一步，要引入 re 模块
#也就是分组匹配，() 里面的为一个组也可以理解成一个整体
a = re.search("(a4)+", "a4a4a4a4a4dg4g654gb")   #匹配一个或多个 a4
b = a.group()print(b)
#打印出 a4a4a4a4a4

View Code

列 2

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re   #第一步，要引入 re 模块
#也就是分组匹配，() 里面的为一个组也可以理解成一个整体
a = re.search("a(\d+)", "a466666664a4a4a4dg4g654gb")# 匹配 (a) (\d0-9 的数字) (+ 可以是 1 个到多个 0-9 的数字 )
b = a.group()print(b)
#打印出 a466666664

View Code

| 元字符，或

| 或，或就是前后其中一个符合就匹配

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re   #第一步，要引入 re 模块
a = re.findall(r"你 | 好", "a4a4a 你 4aabc4a4dgg 好 dg4g654g")   #| 或，或就是前后其中一个符合就匹配
print(a)
#打印出 ['你', '好']

View Code

r 原生字符

将在 python 里有特殊意义的字符如 \b，转换成原生字符（就是去除它在 python 的特殊意义），不然会给正则表达式有冲突，为了避免这种冲突可以在规则前加原始字符 r

re 模块中常用功能函数

正则表达式有两种书写方式，一种是直接在函数里书写规则，

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re   #第一步，要引入 re 模块
a = re.findall("匹配规则", "这个字符串是否有匹配规则的字符")   #第二步，调用模块函数
print(a)  #以列表形式返回匹配到的字符串
#打印出 ['匹配规则']

View Code

match() 函数（以后常用）

match，从头匹配一个符合规则的字符串，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回 None
match(pattern, string, flags=0)
# pattern：正则模型
# string ：要匹配的字符串
# falgs ：匹配模式

注意：match() 函数与 search() 函数基本是一样的功能，不一样的就是match() 匹配字符串开始位置的一个符合规则的字符串，search() 是在字符串全局匹配第一个合规则的字符串

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#无分组
origin = "hello egon bcd egon lge egon acd 19"
r = re.match("h\w+", origin)    #match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回 None
print(r.group())     # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups())    # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了 key 的组结果
#输出结果
# hello     匹配到的全部拿出来
# ()        没有分组所以为空
# {}        没分组部分定义了 key 的组所以为空
# 有分组
# 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
r = re.match("h(\w+)", origin)   #match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回 None
print(r.group())     # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups())    # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了 key 的组结果
#输出结果
# hello         匹配到的全部拿出来
# ('ello',)     有分组，在匹配到的字符串中拿出分组的部分
# {}            没分组部分定义了 key 的组所以为空
# 有两个分组定义了 key
# 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
r = re.match("(?P<n1>h)(?P<n2>\w+)", origin)   #?P<> 定义组里匹配内容的 key(键)，<> 里面写 key 名称，值就是匹配到的内容
print(r.group())     # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups())    # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了 key 的组结果
#输出结果
# hello                         匹配到的全部拿出来
# ('h', 'ello')                 有分组，在匹配到的字符串中拿出分组的部分
# {'n1': 'h', 'n2': 'ello'}     有定义了 key 的组所以，将定义了 key 的组里的内容以字典形式拿出来

View Code

?P<n1> #?P<> 定义组里匹配内容的 key(键)，<> 里面写 key 名称，值就是匹配到的内容（只对正则函数返回对象的有用）

取出匹配对象方法

只对正则函数返回对象的有用

group() # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来，有参取匹配到的第几个如 2
groups() # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
groupdict() # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了 key 的组结果

search() 函数
search, 浏览全部字符串，匹配第一符合规则的字符串，浏览整个字符串去匹配第一个，未匹配成功返回 None
search(pattern, string, flags=0)
# pattern：正则模型
# string ：要匹配的字符串
# falgs ：匹配模式

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#无分组
origin = "hello alex bcd alex lge alex acd 19"
r = re.search("a\w+", origin)    #search 浏览全部字符串，匹配第一符合规则的字符串，浏览整个字符串去匹配第一个，未匹配成功返回 None
print(r.group())     # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups())    # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了 key 的组结果
#输出结果
# alex     匹配到的全部拿出来
# ()        没有分组所以为空
# {}        没分组部分定义了 key 的组所以为空
# 有分组
# 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
r = re.search("a(\w+).*(\d)", origin)
print(r.group())     # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups())    # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了 key 的组结果
#输出结果
# alex bcd alex lge alex acd 19       匹配到的全部拿出来
# ('lex', '9')     有分组，在匹配到的字符串中拿出分组的部分
# {}            没分组部分定义了 key 的组所以为空
# 有两个分组定义了 key
# 为何要有分组？提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
r = re.search("a(?P<n1>\w+).*(?P<n2>\d)", origin)   #?P<> 定义组里匹配内容的 key(键)，<> 里面写 key 名称，值就是匹配到的内容
print(r.group())     # 获取匹配到的所有结果，不管有没有分组将匹配到的全部拿出来
print(r.groups())    # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分的结果
print(r.groupdict()) # 获取模型中匹配到的分组结果，只拿出匹配到的字符串中分组部分定义了 key 的组结果
#输出结果
# alex bcd alex lge alex acd 19                         匹配到的全部拿出来
# ('lex', '9')                 有分组，在匹配到的字符串中拿出分组的部分
# {'n1': 'lex', 'n2': '9'}     有定义了 key 的组所以，将定义了 key 的组里的内容以字典形式拿出来

View Code

findall() 函数（以后常用）

findall(pattern, string, flags=0)
# pattern：正则模型
# string ：要匹配的字符串
# falgs ：匹配模式

浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中，未匹配成功返回空列表

注意：一旦匹配成，再次匹配，是从前一次匹配成功的，后面一位开始的，也可以理解为匹配成功的字符串，不在参与下次匹配

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#无分组
r = re.findall("\d+\w\d+", "a2b3c4d5")    #浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中
print(r)
#输出结果
#['2b3', '4d5']
#注意：匹配成功的字符串，不在参与下次匹配, 所以 3c4 也符合规则但是没匹配到

View Code

注意：如果没写匹配规则，也就是空规则，返回的是一个比原始字符串多一位的，空字符串列表

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#无分组
r = re.findall("", "a2b3c4d5")    #浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中
print(r)
#输出结果
#['','','','','','','','','']
#注意：如果没写匹配规则，也就是空规则，返回的是一个比原始字符串多一位的，空字符串列表

View Code

注意：正则匹配到空字符的情况，如果规则里只有一个组，而组后面是 * 就表示组里的内容可以是 0 个或者多过，这样组里就有了两个意思，一个意思是匹配组里的内容，二个意思是匹配组里 0 内容（即是空白）所以尽量避免用 * 否则会有可能匹配出空字符串

注意：正则只拿组里最后一位，如果规则里只有一个组，匹配到的字符串里在拿组内容是，拿的是匹配到的内容最后一位

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("(a)*", origin)   
print(r)
#输出结果 ['','','','','','','a','','','','','','','','','a','','','','','','','','','a','','','','','a','','','','','','']

View Code


无分组：匹配所有合规则的字符串，匹配到的字符串放到一个列表中

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
#无分组
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("a\w+", origin)    #浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中
print(r)
#输出结果
#['alex', 'alex', 'alex', 'acd']
#匹配所有合规则的字符串，匹配到的字符串放到一个列表中

View Code

有分组：只将匹配到的字符串里，组的部分放到列表里返回，相当于 groups() 方法

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("a(\w+)", origin)    #有分组：只将匹配到的字符串里，组的部分放到列表里返回
print(r)
#输出结果
#['lex', 'lex', 'lex', 'cd']

View Code

多个分组：只将匹配到的字符串里，组的部分放到一个元组中，最后将所有元组放到一个列表里返

相当于在 group() 结果里再将组的部分，分别，拿出来放入一个元组，最后将所有元组放入一个列表返回

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("(a)(\w+)", origin)    #多个分组：只将匹配到的字符串里，组的部分放到一个元组中，最后将所有元组放到一个列表里返回
print(r)
#输出结果
#[('a', 'lex'), ('a', 'lex'), ('a', 'lex'), ('a', 'cd')]

View Code

分组中有分组：只将匹配到的字符串里，组的部分放到一个元组中，先将包含有组的组，看作一个整体也就是一个组，把这个整体组放入一个元组里，然后在把组里的组放入一个元组，最后将所有组放入一个列表返回

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.findall("(a)(\w+(e))", origin)    #分组中有分组：只将匹配到的字符串里，组的部分放到一个元组中，先将包含有组的组，看作一个整体也就是一个组，把这个整体组放入一个元组里，然后在把组里的组放入一个元组，最后将所有组放入一个列表返回
print(r)
#输出结果
#[('a', 'le', 'e'), ('a', 'le', 'e'), ('a', 'le', 'e')]

View Code

?: 在有分组的情况下 findall()函数，不只拿分组里的字符串，拿所有匹配到的字符串，注意?: 只用于不是返回正则对象的函数如 findall()

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
b = re.findall("a(?:\w+)",origin) #?: 在有分组的情况下，不只拿分组里的字符串，拿所有匹配到的字符串，注意?: 只用于不是返回正则对象的函数如 findall()
print(b)
#输出
# ['alex', 'alex', 'alex', 'acd']

View Code

split() 函数

根据正则匹配分割字符串，返回分割后的一个列表

split(pattern, string, maxsplit=0, flags=0)

# pattern：正则模型

# string ：要匹配的字符串

# maxsplit：指定分割个数

# flags ：匹配模式

按照一个字符将全部字符串进行分割

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.split("a", origin) #根据正则匹配分割字符串
print(r)
#输出结果 ['hello', 'lex bcd', 'lex lge', 'lex', 'cd 19']
#根据 a 进行分组

View Code

将匹配到的字符串作为分割标准进行分割

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex 2acd 19"
r = re.split("a\w+", origin) #根据正则匹配分割字符串
print(r)
#输出结果 ['hello', 'bcd', 'lge', '2', '19']
#将匹配到的字符串作为分割标准进行分割

View Code

sub() 函数

替换匹配成功的指定位置字符串

sub(pattern, repl, string, count=0, flags=0)

# pattern：正则模型

# repl ：要替换的字符串

# string ：要匹配的字符串

# count ：指定匹配个数

# flags ：匹配模式

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
r = re.sub("a","替换",origin) #替换匹配成功的指定位置字符串
print(r)
#输出
# hello 替换 lex bcd 替换 lex lge 替换 lex 替换 cd 19

View Code

subn() 函数

替换匹配成功的指定位置字符串, 并且返回替换次数，可以用两个变量分别接受

subn(pattern, repl, string, count=0, flags=0)

# pattern：正则模型

# repl ：要替换的字符串

# string ：要匹配的字符串

# count ：指定匹配个数

# flags ：匹配模式

#!/usr/bin/env python
# -*- coding:utf8 -*-
import re
origin = "hello alex bcd alex lge alex acd 19"
a,b = re.subn("a","替换",origin) #替换匹配成功的指定位置字符串, 并且返回替换次数，可以用两个变量分别接受
print(a)
print(b)
#输出
# hello 替换 lex bcd 替换 lex lge 替换 lex 替换 cd 19
# 4

View Code

元字符表

.	需要字符串里完全符合，匹配规则，就匹配，（规则里的.元字符）可以是任何一个字符，匹配任意除换行符"\n"外的字符(在DOTALL模式中也能匹配换行符)	a.c	abc
\	1.反斜杠后边跟元字符去除特殊功能；（即将特殊字符转义成普通字符），2.反斜杠后边跟普通字符实现特殊功能；（即预定义字符），3.\2引用序号对应的字组	a\.c;a\\c	a.c;a\c
*	需要字符串里完全符合，匹配规则，就匹配，（规则里的*元字符）前面的一个字符可以是0个或多个原本字符，匹配前一个字符0或多次，贪婪匹配前导字符有多少个就匹配多少个很贪婪，如果规则里只有一个分组，尽量避免用*否则会有可能匹配出空字符串	abc*	ab;abccc
+	需要字符串里完全符合，匹配规则，就匹配，（规则里的+元字符）前面的一个字符可以是1个或多个原本字符，匹配前一个字符1次或无限次，贪婪匹配前导字符有多少个就匹配多少个很贪婪	abc+	abc;abccc
?	需要字符串里完全符合，匹配规则，就匹配，（规则里的?元字符）前面的一个字符可以是0个或1个原本字符，匹配一个字符0次或1次，还有一个功能是可以防止贪婪匹配，详情见防贪婪匹配	abc?	ab;abc
^	字符串开始位置与匹配规则符合就匹配，否则不匹配，匹配字符串开头。在多行模式中匹配每一行的开头，^ 元字符如果写到 [] 字符集里就是反取	^abc	abc
$	字符串结束位置与匹配规则符合就匹配，否则不匹配，匹配字符串末尾，在多行模式中匹配每一行的末尾	abc$	abc
\|	\|或，或就是前后其中一个符合就匹配	abc\|def	abc def
{}	需要字符串里完全符合，匹配规则，就匹配，（规则里的 {} 元字符）前面的一个字符，是自定义字符数，位数的原本字符，{m}匹配前一个字符m次，{m,n}匹配前一个字符m至n次，若省略n，则匹配m至无限次，{0,} 匹配前一个字符 0 或多次, 等同于 * 元字符，{+,} 匹配前一个字符 1 次或无限次, 等同于 + 元字符，{0,1} 匹配前一个字符 0 次或 1 次, 等同于? 元字符	ab{1,2}c	abc abbc
[]	需要字符串里完全符合，匹配规则，就匹配，（规则里的 [] 元字符）对应位置是[]里的任意一个字符就匹配，字符集。对应的位置可以是字符集中任意字符。字符集中的字符可以逐个列出，也可以给出范围，如[abc]或[a-c]。[^abc]表示取反，即非abc。所有特殊字符在字符集中都失去其原有的特殊含义。用\反斜杠转义恢复特殊字符的特殊含义。	a[bcd]e	abe ace ade
()	也就是分组匹配，()里面的为一个组也可以理解成一个整体，如果()后面跟的是特殊元字符如 (adc)* 那么*控制的前导字符就是()里的整体内容，不再是前导一个字符	(abc){2} a(123\|456)c	abcabc a456c

预定义字符集表，可以写在字符集[...]中

\d	\d 匹配任何十进制数，它相当于类 [0-9]，\d+ 如果需要匹配一位或者多位数的数字时用	a\bc	a1c
\D	\D 匹配任何非数字字符，它相当于类 [^0-9]	a\Dc	abc
\s	\s 匹配任何空白字符，它相当于类 [\t\n\r\f\v]	a\sc	a c
\S	\S 匹配任何非空白字符，它相当于类 [^\t\n\r\f\v]	a\Sc	abc
\w	\w 匹配包括下划线在内任何字母数字字符，它相当于类 [a-zA-Z0-9_]	a\wc	abc
\W	\W 匹配非任何字母数字字符包括下划线在内，它相当于类 [^a-zA-Z0-9_]	a\Wc	a c
\A	仅匹配字符串开头, 同 ^	\Aabc	abc
\Z	仅匹配字符串结尾，同 $	abc\Z	abc
\b	b 匹配一个单词边界，也就是指单词和空格间的位置	\babc\b a\b!bc	空格 abc 空格 a!bc
\B	[^\b]	a\Bbc	abc

特殊分组用法表：只对正则函数返回对象的有用

(?P<name>)

?P<> 定义组里匹配内容的 key(键)，<> 里面写 key 名称，值就是匹配到的内容，在用 groupdict() 方法打印字符串

(?P<id>abc){2}

abcabc

(?P=name)

引用别名为 <name> 的分组匹配到字符串

(?P<id>\d)abc(?P=id)

1abc1

5abc5

\<number>

引用编号为 <number> 的分组匹配到字符串

(\d)abc\1

1abc1

5abc5

正则匹配模式表

标志	含义
re.S(DOTALL)	使. 匹配包括换行在内的所有字符
re.I（IGNORECASE）	使匹配对大小写不敏感
re.L（LOCALE）	做本地化识别（locale-aware) 匹配，法语等
re.M(MULTILINE)	多行匹配，影响 ^ 和 $
re.X(VERBOSE)	该标志通过给予更灵活的格式以便将正则表达式写得更易于理解
re.U	根据 Unicode 字符集解析字符，这个标志影响 \w,\W,\b,\B

正则表达式重点

一、

r 原生字符

二、

正则表达式，返回类型为表达式对象的

如：<_sre.SRE_Match object; span=(6, 7), match='a'>

返回对象的，需要用正则方法取字符串，

方法有

三、

匹配到的字符串里出现空字符

四、

() 分组

注意：分组的意义，就是在匹配成功的字符串中，在提取 () 里，组里面的字符串

五、

?: 在有分组的情况下 findall()函数，不只拿分组里的字符串，拿所有匹配到的字符串，注意?: 只用于不是返回正则对象的函数如 findall()

Python--re模块

re 模块中常用功能函数

相关帖子

随便看看

Python--re模块