python正则表达式

1、知识点导图

1、正则表达式简单介绍及意义
2、正则表达式的基本语法
3、正则表达式的七种武器
4、正则表达式的常见语法

2、正则表达式的意义

什么是正则表达式

正则表达式并不是Python的一部分。正则表达式是用于处理字符串的强大工具，拥有自己独特的语法以及一个独立的处理引擎，效率上可能不如str自带的方法，但功能十分强大。得
益于这一点，在提供了正则表达式的语言里，正则表达式的语法都是一样的，区别只在于不同的编
程语言实现支持的语法数量不同；但不用担心，不被支持的语法通常是不常用的部分。如果已
经在其他语言里使用过正则表达式，只需要简单看一看就可以上手了。
Python的正则表达式的模块是 ‘re’,它的基本语法规则就是指定一个字符序列

正则表达式的大致匹配过程

依次拿出表达式和文本中的字符比较，如果每一个字符都能匹配，则匹成功；一旦有匹配不
成功的字符则匹配失败。如果表达式中有量词或边界，这个过程会稍微有一些不同，但也是很
好理解的，看下图中的示例以及自己多使用几次就能明白。

3、正则表达式的基本语法

1、 字符

字符	功能
一般字符	匹配自己
\	转义字符
[]	字符集，对应的位置可以使字符集里的任意字符或范围,使用特殊符号需要进行转义
[^]	表示匹配非^后边内容 [^abc]表示匹配非abc的内容
|	将两个规则并列起来，以‘|’连接，表示只要满足其中之一就可以匹配
|	注意 |匹配两边整条规则，加特技需要‘(?: )’包起来，如：I have a (?:dog

2、预定义字符集（可以写在字符集中）

字符	功能
.	匹配除\n外所有字符，加特技需要加S，就可以包括\n了(r‘.+’ , str , re.S)
\d	数字[0-9]
\D	非数字[^\d]
\s	间隔字符[<空格>\t\r\n\f\v]
\S	非空白间隔字符[^\s]
\w	单词字符[a-zA-Z]
\W	非单词字符[^\w]

3、数量词

字符	功能
*	匹配前一个字符0次或者无限次 a*
+	匹配前一个字符1次或者无限次a+
？	匹配前一个字符0次或者1次a?
{m}	匹配前一个字符m次 a{m}
{m-n}	匹配前一个字符m到n次 a{m-n}，最少m次需要{m,}
数量词?	使匹配以非贪婪模式下进行 a*?、a+?

4、边界匹配（不消耗待匹配的字符串中的字符）

字符	功能
^	匹配字符串开头，多行模式下匹配每一行开头^abc

$| 匹配字符串的结尾，多行模式下匹配每一行结尾abc$
\A|仅匹配字符串的开头 \Aabc
\Z|仅匹配字符串的结尾 abc\Z
\b |匹配\w和\W之间的
\B|[^/b]

5、逻辑、分组

字符	功能
|	左右表达式任意匹配一个，默认左边开始
(….)	分组，从表达式左边起，遇到的第一个为1，依次加1
(?P…)	分组除了原名外，增加别名name (?Pabc){2} =abcabc
\	引用分组编号为number的组匹配的字符(\d)abc\1 = 1abc1
(?P = name)	引用别名为name的分组匹配的字符串

贪婪模式的例子

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 re

p = 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 re

p = 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 re

p =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 re

p = 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!

组与Match对象

常见的正则表达式

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

邮箱表达式

"[\w\-\.]+\@(?:[\w\-]+\.)+[a-z]{2,3}"

邮箱规则

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

用户名表达式

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

用户名规则

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

密码表达式

".{6,16}"

密码规则

1. 任意字符，6~16位