039 Python语法之正则表达式

本文主要是介绍039 Python语法之正则表达式，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

正则的基本语法

语法	说明	表达式实例	匹配的字符串
字符	-	-	-
一般的字符	abc等任意你写的字符串	“abc”	“abc”
.	匹配任意除了换行符"\n"之外的字符	“.”	“a”
\	转义字符	“a\.c”	“a.c”
[…]	多个字符选一个	“a[bcd]e”	“abe” “ace” “ade”
字符集
\d	数字0-9,等价于正则[0-9]	“a\\dc”	“a1c”
\D	非数字其他字符	\D	“a” “b” “c”
\s	空白字符[空格\t\r\n\f\v]	“a\sc”	“a c” “a\tc” “a\r\nc”
\S	非空白字符[^\s]	“a\Sc”	“abc”
\w	字母数字下划线[A-Za-z0-9_],包括中文,不匹配标点符号	“a\wc”	“abc” “a_c” “a1c”
\W	非字母数字下划线[^A-Za-z0-9_],包括空白字符,不包括中文,匹配标点符号	“a\Wc”	“a c” “a你c”
数量词
*	匹配它前面一个字符0或无限次	"abc*	“ab” “abc” “abccccc”
+	匹配它前面一个字符1或无限次	“abc*”	“abc” “abcccc”
?	匹配它前面一个字符0或1次	“abc?”	“ab” “abc”
{m}	匹配它前面一个字符m次	“ab{2}c”	“abbc”
{m, n}	匹配它前面一个字符m-n次	“ab{1,2}c”	“abc” “abbc”
*? +? ?? {m, n}?	使数量变成非贪婪模式	“ab{1,2}c”	“abc” “abbc”
边界匹配
^	匹配行的开头	^abc	abc
$	匹配行的末尾	abc$	abc
\A	匹配字符串开头	\Aabc	abc
\Z	匹配字符串末尾	abc\Z	abc
\b	匹配\w\W之间,后面碰见空白字符或者符号就匹配,只匹配字母,不匹配数字和中文	a\b!bc	a!bc
\B	非\b[^\b],后面不需要跟上分隔符	a\Bbc	abc
逻辑分组
|	左右任意一个	“abc | bcd”	“abc” “bcd”
(…)	分组,下标从1开始	“(abc){2}” “(abc)\1”	“abcabc”
<num>	引用编号为的分组匹配到的字符串	“(name)(id)\1\2”	“nameidnameid”
(?P…)	分组,除了原有的编号之外再指定一个别名	“(?Pabc){2}”	“abcabc”
(?P=name)	引用别名为的分组匹配到的字符串	“(?P\d)abc(?P=id)”	1abc5
特殊构造
(?:…)	(…)的不分组版本,后面可以接数量词	(?:abc){2}	abcabc
(?iLmsux)	?后面的每一个字符都是一种匹配模式	(?i)abc	AbC
(?#…)	正则表达式的注释	abc(?#comment)123	abc123
(?=…)	之后的字符串内容需要匹配表达式才能成功匹配,括号内的是规则,不参与匹配内容	a(?=\d)	后面是数字的 a字符串(a1)
(?!..)	之后的字符串内容需要不匹配表达式才能成功匹配,括号内的是规则,不参与匹配内容	a(?!\d)	后面不是数字的 a字符串(ab)
(?<=…)	之前的字符串内容需要匹配表达式才能成功匹配,括号内的是规则,不参与匹配内容	a(?<=\d)	前面是数字的 a字符串(1a)
(?<!..)	之前的字符串内容不匹配表达式才能成功匹配,括号内的是规则,不参与匹配内容	a(?<!\d)	前面不是数字的 a字符串(ba)
(?(id/name)yes-pattern|nopattern)	-暂时不写,后面理解了再写上去-	(\d)abc(?(1)\d|abc)	-

贪婪与非贪婪模式

1. Python中的数量词默认是贪婪模式的,总是默认尝试匹配更多的字符,非贪婪模式则是尽可能少的匹配字符

贪婪模式的例子

pat = re.compile("ab*")
str1 = pat.findall("abbbbbbbbb")
print(str1)---------------
['abbbbbbbbb']

非贪婪模式的例子

pat = re.compile("ab*?")
str1 = pat.findall("abbbbbbbbb")
print(str1)---------------
['a']

反斜杠的困扰

1. 表示\d可以用r"\d"代替"\\d"
2. 表示\可以用r"\\“替代”\\\\"

re模块-正则的七个方法

match(pat, orginStr[, flag])

m = re.match(pat, orginStr[, flag])
m.string

match方法解释

1. 从原始字符串第一个字符开始,匹配正则的规则
2. 如果不是从第一个字符开始就匹配不到
3. 参数1：正则表达式
4. 参数2：原始的字符串
5. 参数3：匹配模式(可选参数)

match方法返回值的属性

1. m.string: 匹配时使用的文本
2. m.re: 匹配时使用的Pattern对象
3. m.pos: 文本中正则表达式开始搜索的索引
4. m.endpos: 文本中正则表达式结束搜索的索引
5. m.lastindex: 最后一个被捕获的分组在文本中的索引
6. m.lastgroup: 最后一个被捕获的分组的别名

match方法返回值的方法

1. re.group(group1…)：获得一个或多个分组截获的字符串;指定多个参数时将以元组形式返回,group1可以是编号,也可以是别名
2. re.groups([default])：以元组的形式返回全部分组捕获的字符串,如果没有找到返回default设置的值,默认返回None
3. groupdict([default])：返回以有别名的组的别名为键、以该组截获的子串为值的字典，没有别名的组不包含在内
4. start([group])：返回指定的组截获的子串在string中的起始索引(子串第一个字符的索引).group默认值为0
5. end([group])：返回指定的组截获的子串在string中的结束索引(子串最后一个字符的索引+1).group默认值为0
6. span([group])：返回(start(group),end(group))
7. expand(template)：将匹配到的分组代入template中然后返回

search()

compile

pat = re.compile("ab*?")    # 得到一个正则表达式的对象

compile(pat[,flag])

1. 第一个参数是正则表达式
2. 第二个参数是匹配模式

compile匹配模式

模式	详解
re.I/re.IGNORECASE	忽略大小写
re.M/re.MULTILINE	多行模式,改变’^‘和’$'的行为
re.S(re.DOTALL)	点任意匹配模式，改变’.'的行为
re.L(re.LOCALE)	使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
re.U(re.UNICODE)	使预定字符类 \w \W \b \B \s \S \d \D
re.X(re.VERBOSE)	详细模式,可以是多行,忽略空白字符,可以加入注释

escape(str)

re.escape("\d")  --> \\d

escape方法详解

1. 用于将元字符串进行转义后再返回
2. 感觉没有半点用

findall()

split()

sub()\subn()

purge()：清空缓存中的正则表达式,等待验证,有点坑

re.purge() --> 返回值是None

Pattern对象

pattern = re.compile("正则表达式")

Pattern对象的属性

1. pattern: 编译时用的表达式字符串
2. flags: 编译时用的匹配模式,数字形式
3. groups: 表达式中分组的数量
4. groupindex: 以表达式中有别名的组的别名为键、以该组对应的编号为值的字典,没有别名的组不包含在内

Pattern对象的方法

1. match(string[, pos[, endpos]]) | re.match(pattern, string[, flags])

1. 从第一个字符开始匹配
2. string是要匹配的字符串
3. pos是起始匹配的位置
4. endpos：终止匹配的位置
5. 返回值是一个Match对象

match方法例子

import re
p = re.compile(r'(\w+) (\w+)(?P<sign>.*)', re.DOTALL)print("p.pattern:", p.pattern)
print("p.flags:", p.flags)
print("p.groups:", p.groups)
print("p.groupindex:", p.groupindex)### output ###
# p.pattern: (\w+) (\w+)(?P<sign>.*)
# p.flags: 16
# p.groups: 3
# p.groupindex: {'sign': 3}

2. search(string[, pos[, endpos]]) | re.search(pattern, string[, flags])

1. 从字符整个字符串开始搜索匹配
2. string是要匹配的字符串
3. pos是起始匹配的位置
4. endpos：终止匹配的位置
5. 返回值是一个Match对象

search方法例子

# encoding: UTF-8 
import re # 将正则表达式编译成Pattern对象 
pattern = re.compile(r'world') # 使用search()查找匹配的子串，不存在能匹配的子串时将返回None 
# 这个例子中使用match()无法成功匹配 
match = pattern.search('hello world!') if match: # 使用Match获得分组信息print match.group()### 输出 ###
# world

3. split(string[, maxsplit]) | re.split(pattern, string[, maxsplit])

1. 从字符整个字符串开始搜索匹配
2. string：要匹配的字符串
3. maxsplit：指定最大分割次数，不指定将全部分割
4. 返回值是一个分割的列表

split方法例子

import rep = re.compile(r'\d+')
list1 = p.split('one1two2three3four4')
print(list1)### output ###
# ['one', 'two', 'three', 'four', '']

4. findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags])

1. 从开头到末尾匹配字符串
2. string是要匹配的字符串
3. pos是起始匹配的位置
4. endpos：终止匹配的位置
5. 返回一个找寻到的列表

findall方法例子

import rep = re.compile(r'\d+')
list1 = p.findall('one1two2three3four4')
print(list1)### output ###
# ['1', '2', '3', '4']

5. finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags])

1. 过滤出想要的数据，返回值是一个迭代器

finditer方法例子

import rep =re.compile(r'\d+')
for m in p.finditer('one1two2three3four4'):print m.group()### output ###
# 1 2 3 4

6. sub(repl, string[, count]) | re.sub(pattern, repl, string[, count])

1. 利用repl字符串替换原有string字符串
2. 第一个参数repl：要替换的字符串
3. 第二个参数string：原始字符串
4. 第三个参数count：count用于指定最多替换次数,不指定时全部替换
5. 返回值：返回一个字符串

sub方法例子

import rep = re.compile(r'(\w+) (\w+)')
s = 'i say, hello world!'print p.sub(r'\2 \1', s)def func(m):return m.group(1).title() + ' ' + m.group(2).title()print p.sub(func, s)### output ###
# say i, world hello!
# I Say, Hello World!

7. subn(repl, string[, count]) | re.sub(pattern, repl, string[, count])

1. 利用repl字符串替换原有string字符串和上面的方法相比多一个返回次数
2. 第一个参数repl：要替换的字符串
3. 第二个参数string：原始字符串
4. 第三个参数count：count用于指定最多替换次数,不指定时全部替换
5. 返回值是一个元组形式的：(找到的字符串,出现次数)

subn方法例子

import rep = re.compile(r'(\w+) (\w+)')
s = 'i say, hello world!'p.subn(r'\2 \1', s)
print()def func(m):return m.group(1).title() + ' ' + m.group(2).title()print p.subn(func, s)### output ###
# ('say i, world hello!', 2)
# ('I Say, Hello World!', 2)

常见的正则表达式

QQ表达式

"[1-9]\\d{4,10}"

QQ号规则

1. 首先扣扣号开头不能为0；
2. QQ号必须大于5且小于11(或12,13,QQ号最长位)

手机号表达式

# 平常手机号
"1[34578]\\d{9}"# 手机号码后5位相同
"1[34578]\\d{4}(\\d)\\1{4}"

手机号码规则

1. 手机号位数为11位
2. 开头为1,第二位为3或4或5或7或8

邮箱表达式

"[a-zA-Z0-9_-]+\@(?:[a-zA-Z0-9_-]+\.)+[a-z]{2,4}"

邮箱规则

1. @符号前面的可以为字母,数字,下划线,中划线,或’.’
2. @后面的可以是xxx.com、xxx.cn、xxx.com.cn

用户名表达式

"[a-zA-z]\\w{0,9}"

用户名规则

1. 必须以字母开头，长度在10位以内

密码表达式

".{6,16}"

密码规则

1. 任意字符，6~16位

这篇关于039 Python语法之正则表达式的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---