Python学习笔记十五（正则表达式）

正则表达式

什么是正则表达式

正则表达式，又称规则表达式。通常被用来检索、替换那些符合某个规则的文本。

Python 中使用re 模块做正则匹配

匹配一个字符

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

# . 匹配任意1个字符（除了\n）
import re

# 根据正则表达式从头匹配对应的字符串数据
# . 匹配任意1个字符（除了\n）

# 测试匹配\n
match_obj = re.match("t.o", "t\no")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

# 测试匹配0个字符
match_obj = re.match("t.o", "to")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

# 测试匹配任意一个字符
match_obj = re.match("t.o", "tao")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("t.o", "t1o")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("t.o", "t o")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")


# 运行结果:
# 匹配失败
# 匹配失败
# 匹配结果为 tao
# 匹配结果为 t1o
# 匹配结果为 t o
匹配[ ]中列举的任意一个字符

# [ ]   匹配[ ]中列举的字符
import re

# 根据正则表达式从头匹配对应的字符串数据
# [\na1, ]  匹配[ ]中列举的任意一个字符

# 测试匹配不在[]中的字符
match_obj = re.match("[\na1, ]", "n")
if match_obj:
    print("匹配结果为", repr(match_obj.group()))
else:
    print("匹配失败")

# 测试匹配\n\n
match_obj = re.match("[\na1, ]", "\n\n")
if match_obj:
    print("匹配结果为", repr(match_obj.group()))
else:
    print("匹配失败")

# 测试匹配\n
match_obj = re.match("[\na1, ]", "\n")
if match_obj:
    print("匹配结果为", repr(match_obj.group()))
else:
    print("匹配失败")

match_obj = re.match("[\na1, ]", "a")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("[\na1, ]", ",")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("[\na1, ]", " ")
if match_obj:
    print("匹配结果为", repr(match_obj.group()))
else:
    print("匹配失败")
    
match_obj = re.match("[中]", "中")
if match_obj:
    print("匹配结果为",  match_obj.group())
else:
    print("匹配失败")

# 运行结果:
# 匹配失败
# 匹配结果为 '\n'
# 匹配结果为 '\n'
# 匹配结果为 a
# 匹配结果为 ,
# 匹配结果为 ' ' 
# 匹配结果为 中
\d 匹配数字，即0-9

# \d  匹配数字，即0-9
import re

# 根据正则表达式从头匹配对应的字符串数据
# \d  匹配任意一个数字，即0-9中的一个

# 测试匹配不是数字的字符
match_obj = re.match("\d", "n")
if match_obj:
    print("匹配结果为",  match_obj.group())
else:
    print("匹配失败")

# 测试匹配数字
match_obj = re.match("\d", "0")
if match_obj:
    print("匹配结果为",  match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("\d", "5")
if match_obj:
    print("匹配结果为",  match_obj.group())
else:
    print("匹配失败")
    
match_obj = re.match("\d", "9")
if match_obj:
    print("匹配结果为",  match_obj.group())
else:
    print("匹配失败")


# 运行结果:
# 匹配失败
# 匹配结果为 0
# 匹配结果为 5
# 匹配结果为 9
\D 匹配非数字的任意一个字符

# \D    匹配非数字的任意一个字符，即字符、符号等非数字的字符
import re

# 测试匹配是数字的字符
match_obj = re.match("\D", "5")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

# 测试匹配\D
match_obj = re.match("\D", "a")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("\D", " ")
if match_obj:
    print("匹配结果为", repr(match_obj.group()))
else:
    print("匹配失败")

match_obj = re.match("\D", "中")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("\D", ",")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

# 运行结果:
# 匹配失败
# 匹配结果为 a
# 匹配结果为 ' '
# 匹配结果为 中
# 匹配结果为 ,
\s 匹配空白

# \s    匹配空白字符，即 空格，tab键、换行符\n、回车\r、\v、\f、\b
import re

match_obj = re.match("\s", "中")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("\s", ",")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

# 测试匹配
match_obj = re.match("\s", " ")
if match_obj:
    print("匹配结果为", repr(match_obj.group()))
else:
    print("匹配失败")

match_obj = re.match("\s", "\t")
if match_obj:
    print("匹配结果为", repr(match_obj.group()))
else:
    print("匹配失败")

# 运行结果:
# 匹配失败
# 匹配失败
# 匹配结果为 ' '
# 匹配结果为 '\t'
\S 匹配非空白

# \S    匹配任意非空白字符一个,即匹配字母，数字，符号、汉字
import re

match_obj = re.match("\S", " ")
if match_obj:
    print("匹配结果为", repr(match_obj.group()))
else:
    print("匹配失败")

match_obj = re.match("\S", "\t")
if match_obj:
    print("匹配结果为", repr(match_obj.group()))
else:
    print("匹配失败")

match_obj = re.match("\S", "中")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("\S", ",")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("\S", "a")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("\S", "2")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")
# 运行结果:
# 匹配失败
# 匹配失败
# 匹配结果为 中
# 匹配结果为 ,
# 匹配结果为 a
# 匹配结果为 2
\w 匹配任意单词字符一个

# \w    匹配任意单词字符一个，即a-z、A-Z、0-9、_、汉字
import re

match_obj = re.match("\w", ",")
if match_obj:
    print("匹配结果为", repr(match_obj.group()))
else:
    print("匹配失败")

match_obj = re.match("\w", "\t")
if match_obj:
    print("匹配结果为", repr(match_obj.group()))
else:
    print("匹配失败")

match_obj = re.match("\w", "中")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("\w", "a")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("\w", "Z")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("\w", "9")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("\w", "_")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")
# 运行结果:
# 匹配失败
# 匹配失败
# 匹配结果为 中
# 匹配结果为 a
# 匹配结果为 Z
# 匹配结果为 9
# 匹配结果为 _
\W 匹配任意一个非单词字符

# \W    匹配任意一个非单词字符
import re

match_obj = re.match("\W", "中")
if match_obj:
    print("匹配结果为", repr(match_obj.group()))
else:
    print("匹配失败")

match_obj = re.match("\W", "a")
if match_obj:
    print("匹配结果为", repr(match_obj.group()))
else:
    print("匹配失败")

match_obj = re.match("\W", "\r")
if match_obj:
    print("匹配结果为", repr(match_obj.group()))
else:
    print("匹配失败")

match_obj = re.match("\W", " ")
if match_obj:
    print("匹配结果为", repr(match_obj.group()))
else:
    print("匹配失败")

match_obj = re.match("\W", ",")
if match_obj:
    print("匹配结果为", match_obj.group())
else:
    print("匹配失败")

# 运行结果:
# 匹配失败
# 匹配失败
# 匹配结果为 '\r'
# 匹配结果为 ' '
# 匹配结果为 ,

匹配多位字符

字符 功能
* 匹配前一个字符出现0次或者无限次
+ 匹配前一个字符出现1次或者无限次
? 匹配前一个字符出现1次或者0次
{m} 匹配前一个字符出现m次
{m,n} 匹配前一个字符出现从m到n次
* 匹配*前面的表达式零次或多次

# * 匹配*前面的表达式零次或多次

import re

match_obj = re.match("ta*o", "to")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("ta*o", "tao")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("ta*o", "taaaao")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

# 组合使用
match_obj = re.match("t.*o", "t1中_o")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("t\D*o", "t中qwer_\no")
if match_obj:
    print(repr(match_obj.group()))
else:
    print("匹配失败")

# 运行结果：
# to
# tao
# taaaao
# t1中_o
# 't中qwer_\no'
+ 匹配+前面的表达式一次或多次

# + 匹配+前面的表达式一次或多次
import re

match_obj = re.match("ta+o", "to")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("ta+o", "tao")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("ta+o", "taaaao")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

# 组合使用
match_obj = re.match("t.+o", "t1中_o")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("t\D+o", "t中qwer_\no")
if match_obj:
    print(repr(match_obj.group()))
else:
    print("匹配失败")

# 运行结果：
# 匹配失败
# tao
# taaaao
# t1中_o
# 't中qwer_\no'
? 匹配?前面的表达式零次或一次

# ? 匹配?前面的表达式零次或一次

import re

match_obj = re.match("ta?o", "to")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("ta?o", "tao")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("ta?o", "taaaao")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

# 组合使用
match_obj = re.match("t.?o", "t1中_o")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("t\D?o", "t中qwer_\no")
if match_obj:
    print(repr(match_obj.group()))
else:
    print("匹配失败")

# 运行结果：
# to
# tao
# 匹配失败
# 匹配失败
# 匹配失败
{m} 匹配{m}前的表达式必须出现m次

# {m} m 是一个非负整数， 匹配{m}前的表达式必须出现m次,加强版?。
import re

match_obj = re.match("ta{0}o", "to")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("ta{1}o", "tao")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("ta{3}o", "taaaao")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

# 组合使用
match_obj = re.match("t.{3}o", "t1中_o")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("t\D{3}o", "t中qwer_\no")
if match_obj:
    print(repr(match_obj.group()))
else:
    print("匹配失败")

# 运行结果：
# to
# tao
# 匹配失败
# t1中_o
# 匹配失败
{m,n} 匹配{m,n}前的表达式最少 m 次且最多 n 次

# {m,n} m 和 n 均为非负整数，其中m <= n,匹配{m,n}前的表达式最少 m 次且最多 n 次,阉割版*.

import re

match_obj = re.match("ta{1,5}o", "to")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("ta{1,5}o", "tao")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("ta{1,5}o", "taaaao")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

# 组合使用
match_obj = re.match("t.{1,5}o", "t1中_o")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("t\D{1,5}o", "t中qwer_\no")
if match_obj:
    print(repr(match_obj.group()))
else:
    print("匹配失败")

# 运行结果：
# 匹配失败
# tao
# taaaao
# t1中_o
# 匹配失败
{m,} 匹配{m,n}前的表达式至少m 次,至多无上限

# {m,}  ，m是一个非负整数,匹配{m,n}前的表达式至少m 次,至多无上限，削弱版*。

import re

match_obj = re.match("ta{1,}o", "to")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("ta{1,}o", "tao")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("ta{1,}o", "taaaao")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

# 组合使用
match_obj = re.match("t.{1,}o", "t1中_o")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("t\D{1,}o", "t中qwer_\no")
if match_obj:
    print(repr(match_obj.group()))
else:
    print("匹配失败")

# 运行结果：
# 匹配失败
# tao
# taaaao
# t1中_o
# 匹配失败

匹配开头结尾

字符 功能
^ 匹配字符串开头
$ 匹配字符串结尾
\b 匹配一个单词边界，也就是指单词和空格间的位置。
\B 匹配非单词边界。 

# ^ 匹配字符串开头
# $ 匹配字符串结尾
# \b 匹配一个单词边界，也就是指单词和空格间的位置。
# \B 匹配非单词边界。

import re

# -------  ^  --------------
match_obj = re.match("^I", "I am DragonFang")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("^a", "I am DragonFang")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

# -------  g  --------------
match_obj = re.match(".{14}g$", "I am DragonFang")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match(".{4}g$", "I am DragonFang")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")


# -------  \b  --------------
match_obj = re.match("playing\\b", "playing")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("play\\b", "playing")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")


# -------  \B  --------------
match_obj = re.match("playing\\B", "playing")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")
match_obj = re.match("play\\B", "playing")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

# 运行结果：
# I
# 匹配失败
# I am DragonFang
# 匹配失败
# playing
# 匹配失败
# 匹配失败
# play

匹配分组

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

# | 匹配左右任意一个表达式

import re

match_obj = re.match("12|34", "1234")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("12..|34", "1234")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("\D|12", "1234")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")
  
# 运行结果：  
# 12
# 1234
# 12
() 将括号中的表达式作为一个分组
 
# ()    将括号中的表达式作为一个分组

import re

match_obj = re.match("(12)(34)", "1234")
if match_obj:
    print(match_obj.group())
    print(match_obj.group(0))
    print(match_obj.group(1))
    print(match_obj.group(2))
else:
    print("匹配失败")

print("- "*10)  # 分割线

match_obj = re.match("(12..)(34)", "1234")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败") 
    
# 运行结果：
# 1234
# 1234
# 12
# 34
# - - - - - - - - - - 
# 匹配失败
\num 引用 分组num 匹配到的字符串

# \num  引用分组num匹配到的字符串

import re

match_obj = re.match("15269996999", "15269996999")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

print("- " * 10)
match_obj = re.match("152[69{3}]{2}", "15269996999")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match("152(69{3}){2}", "15269996999")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")


print("- " * 10)
match_obj = re.match("152(69{3})\\1", "15269996999")
if match_obj:
    print(match_obj.group())
    print(match_obj.group(1))
else:
    print("匹配失败")

# 运行结果：
# 15269996999
# - - - - - - - - - -
# 15269
# 15269996999
# - - - - - - - - - -
# 15269996999
# 6999

(?P<name>) 分组起别名

(?P=name) 引用别名为name分组匹配到的字符串


# (?P<name>) 分组起别名
# (?P=name) 引用别名为name分组匹配到的字符串

# (?P<name>) 分组起别名
# (?P=name) 引用别名为name分组匹配到的字符串

import re

# 虽然有两对 () ,但是 只有一个分组
match_obj = re.match("152(?P<name>69{3})(?P=name)", "15269996999")
if match_obj:
    print(match_obj.group())
    print(match_obj.group(1))
else:
    print("匹配失败")

print("- " * 10)

# 有两个分组
match_obj = re.match("""152(?P<name>51)(?P<name2>88)(?P=name)(?P=name2)""", "15251885188")
if match_obj:
    print(match_obj.group())
    print(match_obj.group(1))
    print(match_obj.group(2))
else:
    print("匹配失败")


# 运行结果：
# 15269996999
# 6999
# - - - - - - - - - - 
# 15251885188
# 51
# 88
数字

import re

# 纯数字
match_obj = re.match("^[0-9]*$", "15269996999")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

# 纯数字  [0-9] <==> \d
match_obj = re.match("^\d*$", "15269996999")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")
    
# 运行结果：
# 15269996999
# 15269996999
  
# 数字：^[0-9]*$
# n位的数字：^\d{n}$
# 至少n位的数字：^\d{n,}$
# m-n位的数字：^\d{m,n}$
# 零和非零开头的数字：^(0|[1-9][0-9]*)$
# 非零开头的最多带两位小数的数字：^([1-9][0-9]*)+(\.[0-9]{1,2})?$
# 带1-2位小数的正数或负数：^(\-)?\d+(\.\d{1,2})$
# 正数、负数、和小数：^(\-|\+)?\d+(\.\d+)?$
# 有两位小数的正实数：^[0-9]+(\.[0-9]{2})?$
# 有1~3位小数的正实数：^[0-9]+(\.[0-9]{1,3})?$
# 非零的正整数：^[1-9]\d*$ 或 ^([1-9][0-9]*){1,3}$ 或 ^\+?[1-9][0-9]*$
# 非零的负整数：^\-[1-9][]0-9"*$ 或 ^-[1-9]\d*$
# 非负整数：^\d+$ 或 ^[1-9]\d*|0$
# 非正整数：^-[1-9]\d*|0$ 或 ^((-\d+)|(0+))$
# 非负浮点数：^\d+(\.\d+)?$ 或 ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$
# 非正浮点数：^((-\d+(\.\d+)?)|(0+(\.0+)?))$ 或 ^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$
# 正浮点数：^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ 或 ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
# 负浮点数：^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ 或 ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$
# 浮点数：^(-?\d+)(\.\d+)?$ 或 ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$
汉字

import re

# 纯汉字
match_obj = re.match("^[\\u4e00-\\u9fa5]*$", "天行健君子自强不息")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

# \w 包含 [\\u4e00-\\u9fa5]
match_obj = re.match("^\w*$", "天行健君子自强不息")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

    # 运行结果：
    # 天行健君子自强不息
    # 天行健君子自强不息
英文或数字

import re

# 英文或数字
match_obj = re.match("^[A-Za-z0-9]*$", "DragonFang2018")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

# \w 包含 [A-Za-z0-9]
match_obj = re.match("^\w*$", "DragonFang2018")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

    # 运行结果：
    # DragonFang2018
    # DragonFang2018

# 长度为3-20的所有字符：^.{3,20}$
# 由26个英文字母组成的字符串：^[A-Za-z]+$
# 由26个大写英文字母组成的字符串：^[A-Z]+$
# 由26个小写英文字母组成的字符串：^[a-z]+$
# 由数字和26个英文字母组成的字符串：^[A-Za-z0-9]+$
# 由数字、26个英文字母或者下划线组成的字符串：^\w+$ 或 ^\w{3,20}$
# 中文、英文、数字包括下划线：^[\u4E00-\u9FA5-Za-z0-9_]+$
# 中文、英文、数字但不包括下划线等符号：^[\u4E00-\u9FA5-Za-z0-9]+$ 或 ^[\u4E00-\u9FA5-Za-z0-9]{2,20}$
# 可以输入含有^%&',;=?$\"等字符：[^%&',;=?$\x22]+
# 禁止输入含有~的字符：[^~\x22]+

re模块的其它用法

re.search（）扫描整个字符串并返回第一个成功的匹配


import re
 
match_obj = re.match("君\w*$", "天行健,君子自强不息")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")
 
match_obj = re.search("君\w*$", "天行健,君子自强不息")
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

    # 运行结果：
    # 匹配失败
    # 君子自强不息
re.match() 与 re.search()
  • re.match() 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
  • re.search 扫描整个字符串并返回第一个成功的匹配，匹配不成功，则返回None。
  • 参数
  • re.match(pattern, string, flags=0) 与 re.search(pattern, string, flags=0)
  • pattern 匹配的正则表达式
  • string 要匹配的字符串
  • flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等

flags 标志位

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

re.sub() 替换字符串中的匹配项


# re.sub(pattern, repl, string, count=0, flags=0)
# 替换字符串中的匹配项
# 参数：
# pattern : 正则中的模式字符串。
# repl : 替换的字符串，也可为一个函数。
# string : 要被查找替换的原始字符串。
# count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

import re

phone = "0539-8757567 # 这是一个座机号码"

# 删除字符串中的 Python注释 
num = re.sub(r'#.*$', "", phone)
print("电话号码是: ", num)

# 删除非数字(-)的字符串 
num = re.sub(r'\D', "", phone)
print("电话号码是 : ", num)


def add(match_obj):
    # 获取匹配的结果
    result = match_obj.group()
    value = int(result) + 1
    return str(value)


result = re.sub("\d+", add, "浏览量:100")

print("结果为: ", result)

# 运行结果：
# 电话号码是:  0539-8757567 
# 电话号码是 :  05398757567
# 结果为:  浏览量:101

findall() 查找整个字符串中所有匹配的项


# findall(pattern, string, flags=0)
# 在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表
# 参数：
# pattern : 正则中的模式字符串。
# string : 待匹配的字符串。
# flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

import re

result = re.findall("\d+", "本市有医院30所，学校27所，饭店150家")
print(result)

# 对比，search 类似于 削弱版的 findall
result = re.search("\d+", "本市有医院30所，学校27所，饭店150家")
print(result.group())

# 运行结果：
# ['30', '27', '150']
# 30

re.split() 按照匹配将字符串分割


# re.split(pattern, string[, maxsplit=0, flags=0])
# 按照能够匹配的子串将字符串分割后返回列表
# 参数：
# pattern : 正则中的模式字符串。
# string : 待匹配的字符串。
# maxsplit： 分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
# flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

import re
result = re.split("，", "本市有医院30所，学校27所，饭店150家",1)
print(result)

result = re.split("\d+", "本市有医院30所，学校27所，饭店150家" )
print(result)

result = re.split("，", "本市有医院30所，学校27所，饭店150家")
print(result)

# 对比，findall 类似于 削弱版的 split
result = re.findall("\d+", "本市有医院30所，学校27所，饭店150家")
print(result)


# 运行结果：
# ['本市有医院30所', '学校27所，饭店150家']
# ['本市有医院', '所，学校', '所，饭店', '家']
# ['本市有医院30所', '学校27所', '饭店150家']
# ['30', '27', '150']

贪婪与非贪婪

Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；
非贪婪则相反，总是尝试匹配尽可能少的字符。
在"*","?","+","{m,n}"后面加上？，使贪婪变成非贪婪。


result = re.match(".*", "I am DragonFang")
print(result.group())

result = re.match(".*?", "I am DragonFang")
print(repr(result.group()))

# 运行结果：
# I am DragonFang
# ''

非贪婪，尽可能少的匹配。

  • * 0次 或者多次，*? 0次；
  • ？0次 或者1次， ?? 0次；
  • + 1次 或者 多次， +? 1次；
  • {m,n} 至少m次 至多n次，{m,n}? m次；
  • {m,} 至少m次 至多不限，{m,}? m次

r的作用


import re

my_str = "c:\\user\\DragonFang\\Desktop"  
pattern1 = "c:\\\\user\\\\DragonFang\\\\Desktop"
pattern2 = r"c:\\user\\DragonFang\\Desktop"

match_obj = re.match(pattern1, my_str)
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

match_obj = re.match(pattern2, my_str)
if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

print("- " * 20)
print("my_str ", my_str)
print("pattern1 ", pattern1)
print("pattern2 ", pattern2)

print("my_str ", repr(my_str))
print("pattern1 ", repr(pattern1))
print("pattern2 ", repr(pattern2))

# 运行结果：
# c:\user\DragonFang\Desktop
# c:\user\DragonFang\Desktop
# - - - - - - - - - - - - - - - - - - - - 
# my_str  c:\user\DragonFang\Desktop
# pattern1  c:\\user\\DragonFang\\Desktop
# pattern2  c:\\user\\DragonFang\\Desktop
# my_str  'c:\\user\\DragonFang\\Desktop'
# pattern1  'c:\\\\user\\\\DragonFang\\\\Desktop'
# pattern2  'c:\\\\user\\\\DragonFang\\\\Desktop'

r的作用：在字符串中一个反斜杠就是一个真正的反斜杠

到此结 DragonFangQy 2018.5.4

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 205,132评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 87,802评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,566评论 0赞 338
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,858评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,867评论 5赞 368
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,695评论 1赞 282
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,064评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,705评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 42,915评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,677评论 2赞 323
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,796评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,432评论 4赞 322
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,041评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,992评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,223评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,185评论 2赞 352
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,535评论 2赞 343

推荐阅读更多精彩内容

  • 细说python正则表达式
    python的re模块--细说正则表达式 可能是东半球最详细最全面的re教程,翻译自官方文档,因为官方文档写的是真...
    立而人阅读 22,833评论 4赞 46
  • Python中的正则表达式(re)
    Python中的正则表达式(re) import rere.match #从开始位置开始匹配，如果开头没有则无re...
    BigJeffWang阅读 7,050评论 0赞 99
  • Python正则表达式re模块手册
    re模块手册 本模块提供了和Perl里的正则表达式类似的功能，不关是正则表达式本身还是被搜索的字符串，都可以...
    喜欢吃栗子阅读 3,977评论 0赞 13
  • 30分钟学会正则表达式
    推荐几个正则表达式编辑器 Debuggex ：https://www.debuggex.com/ PyRegex：...
    木易林1阅读 11,458评论 9赞 151
  • 未完待续
    一部作品之所以是好的作品，是因为能触动人内心最柔软的地方。不需要华丽的辞藻修饰，只要有真情流露。 今天又看了一遍电...
    安忆今阅读 261评论 0赞 1