前言

一、python正则表达式的应用领域有哪些？

1、概念

• 正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这
  些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一
  种过滤逻辑（可以用来做检索，截取或者替换操作）。

• 正则表述式用于搜索、替换和解析字符串。正则表达式遵循一定的语法规则，使用非常
  灵活，功能强大。使用正则表达式编写一些逻辑验证非常方便，例如电子邮件地址格式的验
  证。

• 正则表达式是对字符串（包括普通字符（例如，a 到z 之间的字母）和特殊字符）操作
  的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规
  则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑，正则表达式是一种文
  本模式，模式描述在搜索文本时要匹配一个或多个字符串。

2、作用

1. 给定的字符串是否符合正则表达式的过滤逻辑（称作“匹配”）。
2. 可以通过正则表达式，从字符串中获取我们想要的特定部分。
3. 还可以对目标字符串进行替换操作。

二、python中正则表达式re模块的使用

• Python 语言通过标准库中的re 模块支持正则表达式。re 模块提供了一些根据正则表达
  式进行查找、替换、分隔字符串的函数，这些函数使用一个正则表达式作为第一个参数。re
  模块常用的函数如下表所示。

1、re模块常用的函数表格及概念

• match 方法
• re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，
  match()就返回None。语法格式如下：

import re
re.match(pattern, string, flags=0)

• 匹配字符串是正则表达式中最常用的一类应用。也就是设定一个文本模式，然后判断另
  外一个字符串是否符合这个文本模式。
  如果文本模式只是一个普通的字符串，那么待匹配的字符串和文本模式字符串在完全相
  等的情况下，match 方法会认为匹配成功。如果匹配成功，则match 方法返回匹配的对象，
  然后可以调用对象中的group 方法获取匹配成功的字符串，如果文本模式就是一个普通的字
  符串，那么group 方法返回的就是文本模式字符串本身。

• 其中，匹配符“[]”可以指定一个范围，例如：“[ok]”将匹配包含“o”或“k”的字
  符。同时“[]”可以与\w、\s、\d 等标记等价。例如，[0-9a-zA-Z]等价于\w,[^0-9] 等价于\D。

• 如果要匹配电话号码，需要形如“\d\d\d\d\d\d\d\d\d\d\d”这样的正则表达式。其中表现
  了11 次“\d”，表达方式烦琐。而且某些地区的电话号码是8 位数字，区号也有可能是3
  位或4 位数字，因此这个正则表达式就不能满足要求了。正则表达式作为一门小型的语言，
  还提供了对表达式的一部分进行重复处理的功能。例如，“*”可以对正则表达式的某个部
  分重复匹配多次。这种匹配符号称为限定符。下表列出了正则表达式中常用的限定符。

• 利用{}可以控制符号重复的次数。

• 原生字符串
  在大多数编程语言相同，正则表达式里使用“\”作为转义字符，这就可以能造成反斜
  杠困扰。

• 假如你需要匹配文本中的字符“\”，那么使用编程语言表示的正则表达式里将需要4
  个反斜杠：前面两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反
  斜杠后再在正则表达式里转义成一个反斜杠。Python 里的原生字符串很好地解决了这个问
  题，使用Python 的 “r” 前缀。例如匹配一个数字的“\d”可以写成r“\d”。有了原生字符串，
  再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。
  
  

	注意：^与[^m]中的“^”的含义并不相同，后者“^”表示“除了….”的意思

• search() 方法:
  search 在一个字符串中搜索满足文本模式的字符串。语法格式如下：

re.search(pattern, string, flags=0)

• match 与search 的区别
  re.match 只匹配字符串的开始，如果字符串开始不符合正则表达式，
  则匹配失败，函数返回None；
  而re.search 匹配整个字符串，直到找到一个匹配。

• 匹配多个字符串
  search 方法搜索一个字符串，要想搜索多个字符串，如搜索aa、bb 和cc，最简单的方
  法是在文本模式字符串中使用择一匹配符号（|）。择一匹配符号和逻辑或类似，只要满足
  任何一个，就算匹配成功。

• 分组
  如果一个模式字符串中有用一对圆括号括起来的部分，那么这部分就会作为一组，可以
  通过group 方法的参数获取指定的组匹配的字符串。当然，如果模式字符串中没有任何用圆
  括号括起来的部分，那么就不会对待匹配的字符串进行分组。

• 使用分组要了解如下几点：
  □ 只有圆括号括起来的部分才算一组，如果模式字符串中既有圆括号括起来的部分，

也有没有被圆括号括起来的部分，那么只会将被圆括号括起来的部分算作一组，其
它的部分忽略。
□ 用group 方法获取指定组的值时，组从1 开始，也就是说，group(1)获取第1 组的
值，group(2)获取第2 组的值，以此类推。
□ groups 方法用于获取所有组的值，以元组形式返回。所以除了使用group(1)获取第
1 组的值外，还可以使用groups()[0]获取第1 组的值。获取第2 组以及其它组的值
的方式类似。

• re 模块中其他常用的函数
• sub 和subn 搜索与替换
  sub 函数和subn 函数用于实现搜索和替换功能。这两个函数的功能几乎完全相同，都是
  将某个字符串中所有匹配正则表达式的部分替换成其他字符串。用来替换的部分可能是一个
  字符串，也可以是一个函数，该函数返回一个用来替换的字符串。sub 函数返回替换后的结
  果，subn 函数返回一个元组，元组的第1 个元素是替换后的结果，第2 个元素是替换的总
  数。语法格式如下：

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

• compile 函数
  compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供match()
  和search() 这两个函数使用。语法格式为：

re.compile(pattern[, flags])

• findall 函数
  在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，
  则返回空列表。语法格式如下：

findall(pattern, string, flags=0)

注意：match 和search 是匹配一次findall 匹配所有

• finditer 函数
  和findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭
  代器返回。

• split 函数
  split 函数用于根据正则表达式分隔字符串，也就是说，将字符串与模式匹配的子字符串
  都作为分隔符来分隔这个字符串。split 函数返回一个列表形式的分隔结果，每一个列表元素
  都是分隔的子字符串。语法格式如下：

re.split(pattern, string[, maxsplit=0, flags=0])

• 贪婪模式和非贪婪
  贪婪模式指Python 里数量词默认是贪婪的，总是尝试匹配尽可能多的字符。非贪婪模
  式与贪婪相反，总是尝试匹配尽可能少的字符，可以使用"*","?","+","{m,n}"后面加上？，使
  贪婪变成非贪婪

2、引入re库

import re			

三、re代码实例展示

• 01match方法的使用

import re
s='hello python'
pattern='hello'
o=re.match(pattern,s)
print(o)
print(dir(o))
print(o.group()) #返回匹配的字符串
print(o.span())
print(o.start())
print('flags参数的使用')
s='hello python'
pattern='Hello'
o=re.match(pattern,s,flags=re.I)
print(o)
print(o.group())

• 02常用字符的使用

'''
.	匹配任意一个字符（除了\n）
[]	匹配列表中的字符
\w	匹配字母、数字、下划线，即a-z,A-Z,0-9,_
\W	匹配不是字母、数字、下划线
\s	匹配空白字符,即空格（\n,\t）
\S	匹配不是空白的字符
\d	匹配数字,即0-9
\D	匹配非数字的字符
'''
import re
print('--------.的使用--------')
s='a'
s='A'
s='8'
s='_'
s='\n'
pattern='.'
o=re.match(pattern,s)
print(o)
print('---------\d的使用------------')
s='0'
s='5'
s='9'
s='a'
pattern='\d'
o=re.match(pattern,s)
print(o)
print('---------\D的使用------------')
s='0'
# s='5'
s='9'
s='a'
pattern='\D'
o=re.match(pattern,s)
print(o)
print('--------\s的使用-----------')
s=' '
s='\n'
s='\t'
s='_'
pattern='\s'
o=re.match(pattern,s)
print(o)
print('--------\S的使用-----------')
s=' '
s='\n'
s='\t'
s='_'
pattern='\S'
o=re.match(pattern,s)
print(o)
print('---------\w的使用------------')
s='z'
s='A'
s='8'
s='_'
s='#'
pattern='\w'
o=re.match(pattern,s)
print(o)

print('---------\W的使用------------')
s='z'
# s='A'
s='8'
s='_'
s='#'
s='+'
pattern='\W'
o=re.match(pattern,s)
print(o)
print('---------[]的使用----------')
pattern='[2468]'
s='2'
s='3'
s='4'
s='6'
# s='8'
o=re.match(pattern,s)
print(o)

• 03匹配手机号码

import re
# pattern='\d\d\d\d\d\d\d\d\d\d\d'
pattern='1[35789]\d\d\d\d\d\d\d\d\d'
s='13456788765'
o=re.match(pattern,s)
print(o)

#电话号码   区号-座机号  010-3762266   0342-8776262

• 04重复数量符号

'''
* :0次或多次
?:0次或1次
+:至少1次
{m}:重复m次
{m,n}:重复m到n次
{m}：至少重复m次
'''
import re
print('--------*的使用------------')
pattern='\d*'
s='123qwe'
s='123456qwe'
s='qwe'
o=re.match(pattern,s)
print(o)

print('--------+的使用------------')
pattern='\d+'
# s='123qwe'
# s='1qwe'
# s='123456qwe'
s='qwe'
o=re.match(pattern,s)
print(o)

print('--------?的使用------------')
pattern='\d?'
s='123qwe'
s='1qwe'
s='123456qwe'
s='qwe'
o=re.match(pattern,s)
print(o)

print('---------{m}-----------')
pattern='\d{2}'
pattern='\d{3}'
pattern='\d{4}'
s='123qwe'
o=re.match(pattern,s)
print(o)

print('---------{m,n}-----------')
pattern='\d{2,5}'
s='123qwe'
s='123456qwe'
s='qwe'
o=re.match(pattern,s)
print(o)

print('---------{m,}-----------')
pattern='\d{2,}'
s='123qwe'
s='123456qwe'
s='qwe'
o=re.match(pattern,s)
print(o)

• 05重复数量限定符的使用

import re
print('------案例1------')
#匹配出一个字符串首字母为大写字符，后边都是小写字符，这些小写字母可有可无
pattern='[A-Z][a-z]*'
s='Hello'
s='HEllo'
o=re.match(pattern,s)
print(o)

print('------案例2------')
#匹配出有效的变量名 （字母 、数字 下划线 ，而且数字不能开头）
# pattern='[a-zA-Z_][a-zA-Z0-9_]*'
pattern='[a-zA-Z_]\w*'
s='userName'
s='age'
s='a'
s='_qwe'
# s='3er'
o=re.match(pattern,s)
print(o)
print('-------案例3----------')
#匹配出1-99直接的数字
pattern='[1-9]\d?'
s='2'
s='99'
s='100'
s='0'
o=re.match(pattern,s)
print(o)
print('----------案例4--------------')
#匹配出一个随机密码8-20位以内  (大写字母 小写字母 下划线 数字)
pattern='\w{8,20}'
s='123456789'
s='abc123qwe_'
s='1234567#'
o=re.match(pattern,s)
print(o)

• 06转义字符的使用

print('d:\\a\\b\\c')
print('\nabc')
print('\\nabc')
print('\t123')
print('\\t123')

import re
s='\\t123'
# pattern='\\\\t\d*'
pattern=r'\\t\d*'
o=re.match(pattern,s)
print(o)

s='\\\\t123'
# pattern='\\\\\\\\t\d*'
pattern=r'\\\\t\d*'
o=re.match(pattern,s)
print(o)

• 07边界字符的使用

import re
#匹配QQ邮箱  5-10位数字
qq='8656707@qq.com'
qq='8656707@qq.com.cn'
qq='8656707@qq.com.126.com'
# pattern='[1-9]\d{4,9}@qq.com'
pattern=r'[1-9]\d{4,9}@qq.com$'
o=re.match(pattern,qq)
print(o)
print('----------^开始------------')
# s='hello world'
s='hello python'
s='hepython'
pattern=r'^hello.*'
o=re.match(pattern,s)
print(o)
print('-------\\b匹配单词的左边界------------')
pattern=r'.*\bab'
s='12345 abc'
o=re.match(pattern,s)
print(o)
print('-------\\b匹配单词的右边界------------')
pattern=r'.*ab\b'
s='12345 abc'
s='12345 ab'
o=re.match(pattern,s)
print(o)
print('-------\\B匹配非单词的边界------------')
pattern=r'.*ab\B'
s='12345 abc'
s='12345 ab'
o=re.match(pattern,s)
print(o)

• 08search方法的使用

import re
pattern='hello'
s='hello python'
# m=re.search(pattern,s)
m=re.match(pattern,s)
print(m)
print(m.group())
print('-------macth和search的区别----------')
pattern='love'
s='I love you'
m=re.match(pattern,s)
print('使用match进行匹配',m)
o=re.search(pattern,s)
print('使用search进行匹配',o)

• 09匹配多个字符

import re
pattern='aa|bb|cc'
s='aa'
o=re.match(pattern,s)
print(o)

s='bb'
o=re.match(pattern,s)
print(o)

s='my name is cc'
o=re.search(pattern,s)
o=re.match(pattern,s)
print(o)
print('匹配0-100之间所有的数字')
#匹配0-100之间所有的数字  0-99|100
pattern=r'[1-9]?\d$|100$'
s='1'
s='11'
s='99'
s='100'
s='1000'
o=re.match(pattern,s)
print(o)

• 10择一匹配符合列表使用差异

import re
# pattern=r'[xyz]'
# s='y'
# o=re.match(pattern,s)
# print('使用列表[]:',o)
#
# pattern=r'x|y|z'
# s='y'
# o=re.match(pattern,s)
# print('择一匹配符|：',o)
# print('字符集（[]）和择一匹配符(|)的用法，及它们的差异')
# pattern=r'[ab][cd]'
# s='ac'
# s='ab'
# o=re.match(pattern,s)
# print(o)
# pattern=r'ab[cd]'
# # s='ab'
# # s='abc'
# s='abd'
# o=re.match(pattern,s)
# print(o)
pattern='ab|cd'
# s='abc'
# s='abd'
# s='cd'
s='ad'
s='ac'
o=re.match(pattern,s)
print(o)

• 11匹配分组

'''
(ab)	将括号中的字符作为一个分组
\num	引用分组num匹配到的字符串
(?p<name>)	分别起组名
(?p=name)	引用别名为name分组匹配到的字符串
'''
import re
print('匹配座机号码')
#匹配座机号码 区号{3,4}-电话号码{5,8}  010-43222   0432-447727
pattern=r'\d{3,4}-[1-9]\d{4,7}$'
pattern=r'(\d{3,4})-([1-9]\d{4,7}$)'
s='010-786545'
o=re.match(pattern,s)
print(o)
print(o.group())
print(o.group(1))
print(o.group(2))
# print(o.groups())
# print(o.groups()[0])
# print(o.groups()[1])
print('匹配出网页标签内的数据')
# pattern=r'<.+><.+>.+</.+></.+>'
pattern=r'<(.+)><(.+)>.+</\2></\1>'
# s='<html><head>head部分</head></html>'
s='<html><title>head部分</head></body>'
o=re.match(pattern,s)
print(o)
#<body><h1><div><div></div></div></h1></body>
print('(?P<name>)	分别起组名')
pattern=r'<(?P<k_html>.+)><(?P<k_head>.+)>.+</(?P=k_head)></(?P=k_html)>'
s='<html><head>head部分</head></html>'
s='<html><title>head部分</head></body>'
o=re.match(pattern,s)
print(o)

• 12其他函数的使用

import re
print('--------sub-------------')
phone='2004-959-559 # 这是一个国外电话号码'
#将phone中的注释去掉
pattern=r'#.*$'
result=re.sub(pattern,'',phone)
print('sub:',result)
pattern=r'#\D*'
result=re.sub(pattern,'',phone)
print('sub:',result)
print('---------subn-----------')
result=re.subn(pattern,'',phone)
print(result)
print(result[0])
print(result[1])
print('---------compile------------')
s='first123 line'
pattern=r'\w+'
regex=re.compile(pattern)
o=regex.match(s)
print(o)
print('---------findall-------------')
s='first 1 second 2 third 3'
pattern=r'\w+'
result=re.findall(pattern,s)
print(result)
print('---------finditer-------------')
s='first 1 second 2 third 3'
pattern=r'\w+'
result=re.finditer(pattern,s)
print(result)
for i in result:
    print(i.group(),end='\t')
print()
print('----------split-------------')
s='first 11 second 22 third 33'
pattern=r'\d+'
result=re.split(pattern,s)
print(result)
result=re.split(pattern,s,maxsplit=2)
print(result)

• 13贪婪模式和非贪婪模式

import re
v = re.match(r'(.+)(\d+-\d+-\d+)','This is my tel:133-1234-1234')
print('----------贪婪模式---------')
print(v.group(1))
print(v.group(2))
print('----------非贪婪模式---------')
v = re.match(r'(.+?)(\d+-\d+-\d+)','This is my tel:133-1234-1234')
print(v.group(1))
print(v.group(2))
print('-------实例2--------')
print('贪婪模式')
v= re.match(r'abc(\d+)','abc123')
print(v.group(1)) #123
#非贪婪模式
print('非贪婪模式')
v= re.match(r'abc(\d+?)','abc123')
print(v.group(1)) #1

总结