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

最新推荐文章于 2019-07-08 23:01:20 发布

DragonFangQy

最新推荐文章于 2019-07-08 23:01:20 发布

阅读量251

点赞数 1

分类专栏： Python 文章标签： python 正则表达式贪婪 re模块

本文链接：https://blog.csdn.net/f704084109/article/details/80160869

版权

Python 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

正则表达式

什么是正则表达式

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

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

DragonFangQy

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Python学习笔记十五（正则表达式）

正则表达式什么是正则表达式正则表达式，又称规则表达式。通常被用来检索、替换那些符合某个规则的文本。Python 中使用re 模块做正则匹配匹配一个字符字符功能 . 匹配任意1个字符（除了\n） [ ] 匹配[ ]中列举的字符 \d 匹配数字，即0-9 \D 匹配非数字，即不是数字 \s 匹配空白，...
复制链接

扫一扫