re 模块
import re
str = “aabbcc”
searchObj = re.search(r’[,.!?，。！？]’, str)
if searchObj:
print(“错误”)
else:
print(“Nothing found!!”)
"""
通配符：
*: 代表任意多个字符
?: 代表单个字符
.: 当前目录
..: 当前目录的上一级目录
[0-9]: 单个字符为 0~9
[a-z]:
[A-Z]
[A-Za-z]
[0-9A-Za-Z]
[[:digit:]]:单个数字
[[:upper:]]:单个大写字符
[[:lower:]]:单个小写字符
[[:space:]]:单个空格
获取当前目录下以一个数字开头以. 任意结尾的文件
glob.glob(‘./[0-9].*’)
以任意多个字符开头以.gif 结尾的文件
glob.glob(‘*.txt’)
以任意单个字符开头以.gif 结尾的文件
glob.glob(‘?.txt’)
任意目录下的以任意多个字符开头以.txt 结尾的文件，采用递归方式
glob.glob(‘**/*.txt’, recursive=True)
当前目录下的所有目录，采用递归方式
glob.glob(‘./**/’, recursive=True)
import os
import glob
files1 = [file for file in os.listdir(‘.’) if file.endswith(‘.conf’)]
获取当前目录所有以.conf 结尾的文件;
files2= glob.glob(‘./*.conf’)
print(files1)
print(files2)
"""
"""
正则表达式的常用方法
match 方法：
match 尝试从字符串的起始位置开始匹配
如果起始位置没有匹配成功， 返回 None;
如果起始位置匹配成功， 返回一个对象， 通过 group 方法获取匹配的内容;
"""
re:regular express 正则表达式
aObj = re.match(r’we’, ‘wetoshello’)
print(aObj)
print(aObj.group())
\d 单个数字
\D \d 的取反 , 除了数字之外
bObj = re.match(r’\d’, ‘1westos’)
if bObj:
print(bObj.group())
bObj = re.match(r’\D’, ‘_westos’)
if bObj:
print(bObj.group())
findall 方法：
findall 会扫描整个字符串， 获取匹配的所有内容;
res = re.findall(r’\d\d’, ‘阅读数为 2 点赞数为 10’)
print(res)
search 方法：
search 会扫描整个字符串， 只返回第一个匹配成功的内容的 SRE 对象;
resObj = re.search(r’\d’, ‘阅读数为 8 点赞数为 10’)
if resObj:
print(resObj.group())
"""
正则表达式的特殊字符类
字符类:
[ ] 匹配括号内多个字符中的任意一个字符
[^] 表示匹配除了括号内的任意一个字符
[pP]ython
westos[pP]
[aeiou]
[a-z]：匹配任意一个小写字母
[A-Z]：匹配任意一个大写字母
[a-zA-Z0-9]：匹配任意一个小写或大写字母或数字
[^aeiou]
[^0-9]：匹配除了数字的任意一个字符
特殊字符类:
.: 匹配除了 \n 之外的任意字符； [.\n]
\d: digit–(数字)， 匹配一个数字字符， 等价于 [0-9]
\D: 匹配一个非数字字符， 等价于 [^0-9]
\s: space(广义的空格: 空格, \t, \n, \r), 匹配单个任何的空白字符;
\S: 匹配除了单个任何的空白字符;
\w: 字母数字或者下划线, [a-zA-Z0-9_]
\W: 除了字母数字或者下划线, [^a-zA-Z0-9_]
: 在 [] 前面表示以什么开头，在 [] 里面表示除括号内字符之外的任意一个字符: 以什么开头
$: 以什么结尾
$: 以什么结尾
"""
import re
匹配数字
pattern = r’\d’
pattern = r’[0-9]’
string = “hello_1$%”
print(re.findall(pattern, string))
匹配字母数字或者下划线
pattern = r’\w’
pattern = r’[a-zA-Z0-9_]’
string = “hello_1$%”
print(re.findall(pattern, string))
匹配除了字母数字或者下划线;
pattern = r’\W’
pattern = r’[^a-zA-Z0-9_]’
string = “hello_1$%”
print(re.findall(pattern, string))
匹配除了 \n 之外的任意字符； [.\n]
print(re.findall(r’.’, ‘hello westos\n\t%$’))
"""
北美电话号码的合法性
问题描述:
北美电话的常用格式:(eg: 2703877865)
前 3 位: 第一位是区号以 29 开头 , 第 2 位是 08, 第三位数字可任意;
中间三位数字: 第一位是交换机号, 以 2~9 开头, 后面两位任意
最后四位数字: 数字不做限制;
传统正则
pattern = r’[2-9][0-8]\d[2-9]\d\d\d\d\d\d’
可以利用重复符号的方式
pattern = r’[2-9][0-8]\d[2-9]\d{6}’
"""
import re
def is_valid(pattern,tel):
telObj=re.search(pattern,tel)
if telObj:
print(‘%s 合法’ %(tel))
else:
print(‘%s 不合法’ %(tel))
if name == ‘main’:
pattern = r’[2-9][0-8]\d[2-9]\d{6}’
is_valid(pattern,‘2777777777’)
is_valid(pattern,‘1777777777’)
"""
指定字符出现的次数
匹配字符出现次数:
: 代表前一个字符出现 0 次或者无限次； \d, .*
+: 代表前一个字符出现一次或者无限次; d+
?: 代表前一个字符出现 1 次或者 0 次； 假设某些字符可省略， 也可以不省略的时候使用，即去贪婪
123
第二种方式:
{m}: 前一个字符出现 m 次;
{m,}: 前一个字符至少出现 m 次; * == {0,}; + ==={1,}
{m,n}: 前一个字符出现 m 次到 n 次; ? === {0,1}
"""
import re
代表前一个字符出现 0 次或者无限次：*
d ,.
print(re.findall(r’\d*‘, ‘234’))
print(re.findall(r’.’, ‘hello223%’))
print(re.findall(r’d’, ‘ddhello223%’))
代表前一个字符出现一次或者无限次：+
d+
print(re.findall(r’d+‘, ‘‘))
print(re.findall(r’d+’, ‘dddderrttt’))
print(re.findall(r’\d+’, ‘阅读数: 8976 点赞数:900’))
代表前一个字符出现 1 次或者 0 次：?
假设某些字符可省略， 也可以不省略的时候使用
2019-10
print(re.findall(r’\d+-?\d+‘, ‘2019-10’))
print(re.findall(r’\d+-?\d+‘, ‘201910’))
print(re.findall(r’\d{4}-?\d{1,}‘, ‘2019-1’))
print(re.findall(r’\d{4}-?\d{1,2}‘, ‘2019-10’))
print(re.findall(r’\d+-?\d+’, ‘201910’))
编译正则表达式
当需要匹配大量数据时，采用现编译正则表达式可以节省大量的时间
转义的实现:
+ , ? , (), *, . 一定要转义
()—有自己的用法， 对 () 进行转义
. —有自己的用法， 对. 进行转义
"""
要求：北美电话号码的格式为：
1234567890
123-456-7890
123.456.7890
123 456 7890
(123) 456 7890
"""
import random
import re
import time
def timeit(f):
def wrapper(*args, **kwargs):
start_time = time.time()
res = f(*args, **kwargs)
end_time = time.time()
print(“%s 执行时间: %fs” % (f.name, end_time - start_time))
return res
return wrapper
def createPhone():
with open(‘phoneText.txt’, ‘w’) as f:
for i in range(1000000):
# 生成一个随机的电话号码;
phone = "".join([str(random.randint(0, 9)) for i in range(10)])
f.write(phone + ‘\n’)
@timeit
def use_compile():
pattern = r"(?[2-9][0-8]\d)?[-.\s]?[2-9]\d{2}[-.\s]?\d{4}"
compilePattern = re.compile(pattern)
with open('phoneText.txt') as f:
for line in f:
phone = line.rstrip()
res = re.search(compilePattern, phone)
if res:
return True
return False
@timeit
def no_compile():
pattern = r"(?[2-9][0-8]\d)?[-.\s]?[2-9]\d{2}[-.\s]?\d{4}"
# pattern = r’\d{10}’
with open(‘phoneText.txt’) as f:
for line in f:
phone = line.rstrip()
res = re.search(pattern, phone)
if res:
return True
return False
if name == ‘main’:
# createPhone()
no_compile()
use_compile()
正则表达式之分组操作
表示分组
| : 匹配 | 左右任意一个表达式即可;
(ab): 将括号中的字符作为一个分组
\num: 引用分组第 num 个匹配到的字符串
(?P): 分组起别名
(?P=name) : 引用分组的别名
import re
print(re.findall(r’westos|hello’, “hellowestos”))
进行分组的时候， findall 方法只返回分组里面的内容;
print(re.findall(r’(http|https)(.+)’, ‘http_hello’))
search
sreObj = re.search(r’(http|https)(.+)’, ‘http_hello’)
if sreObj:
# group 方法会返回匹配的所有内容;
print(sreObj.group())
# groups 方法返回分组里面的内容;
print(sreObj.groups())
需求: 获取标签里面的文字, 并判断标签是否成对出现?
htmlStr = “
welcome to westos!
”pattern = r’<(\w+)><(\w+)>(.+)</\2></\1>’
print(re.findall(pattern, htmlStr))
print(re.findall(pattern, htmlStr)[0][2])
需求: 分组起别名?
htmlStr = “
welcome to westos!
”pattern = r’<(?P\w+)><(?P\w+)>(?P.+)’
r’</(?P=SecondTag)></(?P=FirstTag)>’
print(re.findall(pattern, htmlStr))
sreObj = re.search(pattern, htmlStr)
if sreObj:
print(sreObj.group())
print(sreObj.groups())
print(sreObj.groupdict())
print(sreObj.groupdict()[‘Text’])
练习之 URL 合法性验证
问题描述:
检查某段给定的文本是否是一个符合需要的 URL；
思路:
1). 检查 URL 是否以 web 浏览器普遍采用的通信协议方案开头: http, https, ftp file
2). 协议后面紧跟 ://
3). 协议后面字符任意;
import re
def isUrl(url):
pattern = re.compile(r’^(http|https|ftp|file)://.+$’)
resObj = re.search(pattern, url)
if resObj:
return True
return False
if name == ‘main’:
print(isUrl(‘file:///tmp’))
print(isUrl(‘http://www.baidu.com’))
print(isUrl(‘https://www.baidu.com’))
print(isUrl(‘ftp://www.baidu.com’))
北美电话号码的格式化
"""
统一格式为:
(123) 456-7890
"""
位置分组的使用
import re
def isPhone(phone):
pattern = r"(?([2-9][0-8]\d))?[-.\s]?([2-9]\d{2})[-.\s]?(\d{4})"
res = re.search(pattern, phone)
if res:
info = res.groups() # 返回的是元组
formatPhone = “(%s) %s-%s” %(info[0], info[1], info[2])
print(formatPhone)
return True
return False
print(isPhone(‘777-777-7777’))
print(isPhone(‘(777) 777 7890’))
命名分组的使用
import re
def isPhone(phone):
pattern = r"(?(?P[2-9][0-8]\d))?[-.\s]?(?P[2-9]\d{2})"
r"[-.\s]?(?P\d{4})"
res = re.search(pattern, phone)
if res:
info = res.groupdict()
formatPhone = “(%s) %s-%s” %(info[‘firstNum’],
info[‘secondNum’], info[‘thirdNum’])
print(formatPhone)
return True
return False
print(isPhone(‘777-777-7777’))
print(isPhone(‘(777) 777 7890’))
匹配日期
“““
\1: 代表的是一定要与第一个分组的内容保持一致， 否则不匹配;
\d{4}(-|/|.)\d{1,2}\1\d{1,2}
“““
import re
date = ‘2019-10-10’
pattern = r’\d{4}(-|/|.)\d{1,2}\1\d{1,2}’
reObj = re.search(pattern, date)
if reObj:
print(reObj.group())
print(reObj.groups())
匹配用户名
字符串是否包含中文 [] 表示匹配方括号的中任意字符，\u4e00 是 Unicode 中汉字的开始，\u9fa5 则是 Unicode 中汉字的结束
import re
user = ‘西安邮电大学 123’
pattern = r’[\w-\u4e00-\u9fa5]+’
print(re.findall(pattern, user))
#**************************************************************************************
"""
正则表达式
正则表达式 (Regular Expression) 是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为 "元字符"）。
正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。
"""
re 模块操作
1. re 模块的使用过程
coding=utf-8
导入 re 模块
import re
使用 match 方法进行匹配操作
result = re.match #(正则表达式, 要匹配的字符串)
如果上一步匹配到数据的话，可以使用 group 方法来提取数据
result.group()
- re 模块示例
import re
匹配以 life 开头的语句
result = re.match(“life”, “life is sort,you need python!”)
print(result.group())
- 说明
re.match() 能够匹配出以 xxx 开头的字符串
"""
匹配单个字符
. 匹配任意 1 个字符（除了 \n）
[] 匹配 [] 中列举的字符
\d 匹配数字，即 0-9
\D 匹配非数字，即不是数字
\s 匹配空白，即 空格，tab 键
\S 匹配非空白
\w 匹配单词字符，即 a-z、A-Z、0-9、_
\W 匹配非单词字符
"""
1: . 示例
import re
. 的使用
匹配单个字符
char = re.match(‘.’, ‘M’)
print(char.group())
匹配一段文字
resultString = re.match(“s.ort”, “short is long!”)
print(resultString.group())
2: [] 示例
import re
如果 hello 的首字符小写，那么正则表达式需要小写的 h
ret = re.match(“h”, “hello Python”)
print(ret.group())
如果 hello 的首字符大写，那么正则表达式需要大写的 H
ret = re.match(“H”, “Hello Python”)
print(ret.group())
大小写 h 都可以的情况
ret = re.match(“[hH]”, “hello Python”)
print(ret.group())
ret = re.match(“[hH]”, “Hello Python”)
print(ret.group())
ret = re.match(“[hH]ello Python”, “Hello Python”)
print(ret.group())
匹配 0 到 9 第一种写法
ret = re.match(“[0123456789]Hello Python”, “7Hello Python”)
print(ret.group())
匹配 0 到 9 第二种写法
ret = re.match(“[0-9]Hello Python”, “7Hello Python”)
print(ret.group())
匹配 0 到 3，5 到 9 这个区间的数字
ret = re.match(“[0-35-9]Hello Python”, “7Hello Python”)
print(ret.group())
下面这个正则不能够匹配到数字 4，因此 ret 为 None
ret = re.match(“[0-35-9]Hello Python”, “4Hello Python”)
print(ret.group())
3: \d 示例
import re
普通的匹配方式
ret = re.match(“人间大炮 1 级”, “人间大炮 1 级准备”)
print(ret.group())
ret = re.match(“人间大炮 2 级”, “人间大炮 2 级准备”)
print(ret.group())
ret = re.match(“人间大炮 3 级”, “人间大炮 3 级准备”)
print(ret.group())
使用 \d 进行匹配
ret = re.match(“人间大炮 \d 级”, “人间大炮 1 级准备”)
print(ret.group())
ret = re.match(“人间大炮 \d 级”, “人间大炮 2 级准备”)
print(ret.group())
ret = re.match(“人间大炮 \d 级”, “人间大炮 3 级准备”)
print(ret.group())
4: \D 示例
import re
ret1 = re.match(‘人间大 \D1 级准备’, “人间大炮 1 级准备”)
ret2 = re.match(‘人间大 \D2 级准备’, “人间大炮 2 级准备”)
ret3 = re.match(‘人间大 \D3 级准备’, “人间大炮 3 级准备”)
print(ret1.group())
print(ret2.group())
print(ret3.group())
5: \s 示例
import re
\s 示例
ret1 = re.match(‘人间大炮 \s1 级准备’, “人间大炮 1 级准备”)
ret2 = re.match(‘人间大炮 \s2 级准备’, “人间大炮 2 级准备”)
ret3 = re.match(‘人间大炮 \s3 级准备’, “人间大炮 3 级准备”)
print(ret1.group())
print(ret2.group())
print(ret3.group())
6: \S 示例
import re
\S 示例
ret1 = re.match(‘\S 间大炮 1 级准备’, “人间大炮 1 级准备”)
ret2 = re.match(‘\S 间大炮 2 级准备’, “人间大炮 2 级准备”)
ret3 = re.match(‘\S 间大炮 3 级准备’, “人间大炮 3 级准备”)
print(ret1.group())
print(ret2.group())
print(ret3.group())
7: \w 示例
import re
ret1 = re.match(‘\w 人间大炮 \w 级准备’, “a 人间大炮 1 级准备”)
ret2 = re.match(‘\w 人间大炮 \w 级准备’, “b 人间大炮 2 级准备”)
ret3 = re.match(‘\w 人间大炮 \w 级准备’, “c 人间大炮 3 级准备”)
print(ret1.group())
print(ret2.group())
print(ret3.group())
8: \W 示例
import re
ret1 = re.match(‘\W 人’, “！人间大炮 1 级准备”)
ret2 = re.match(‘\W 人’, “@人间大炮 2 级准备”)
ret3 = re.match(‘\W 人’, “# 人间大炮 3 级准备”)
print(ret1.group())
print(ret2.group())
print(ret3.group())
"""
匹配多个字符
- 匹配前一个字符出现 0 次或者无限次，即可有可无
- 匹配前一个字符出现 1 次或者无限次，即至少有 1 次
? 匹配前一个字符出现 1 次或者 0 次，即要么有 1 次，要么没有
{m} 匹配前一个字符出现 m 次
{m,n} 匹配前一个字符出现从 m 到 n 次
"""
1.* 示例
import re
ret = re.match(“[A-Z][a-z]*”,“M”)
print(ret.group())
ret = re.match(“[A-Z][a-z]*”,“MnnM”)
print(ret.group())
ret = re.match(“[A-Z][a-z]*”,“Aabcdef”)
print(ret.group())
2.+ 示例
import re
names = [“name1”, “_name”, “2_name”, “name”]
for name in names:
ret = re.match(“[a-zA-Z_]+[\w]*”,name)
if ret:
print(“变量名 %s 符合要求” % ret.group())
else:
print(“变量名 %s 非法” % name)
3.? 示例
import re
ret = re.match(“[1-9]?[0-9]”, “7”)
print(ret.group())
ret = re.match(“[1-9]?\d”, “33”)
print(ret.group())
ret = re.match(“[1-9]?\d”, “09”)
print(ret.group())
4.{m}示例 {m,n} 示例
import re
ret = re.match(“[a-zA-Z0-9_]{6}”,“12a3g45678”)
print(ret.group())
ret = re.match(“[a-zA-Z0-9_]{8,20}”,“1ad12f23s34455ff66”)
print(ret.group())
练习：
题目 1：匹配出 163 的邮箱地址，且 @符号之前有 4 到 20 位，例如 hello@163.com
import re
email = ‘hello@163.com’
result = re.match(r’.{4,20}@’, email)
print(result.group())
"""
匹配开头结尾
^ 匹配字符串开头
$ 匹配字符串结尾
"""
示例
需求：匹配 163.com 的邮箱地址
import re
email_list = [“xiaoWang@163.com”, “xiaoWang@163.comheihei”, “.com.xiaowang@qq.com”]
for email in email_list:
ret = re.match(“[\w]{4,20}@163.com$”, email)
if ret:
print(“%s 是符合规定的邮件地址, 匹配后的结果是:%s” % (email, ret.group()))
else:
print(“%s 不符合要求” % email)
"""
匹配分组
| 匹配左右任意一个表达式
(ab) 将括号中字符作为一个分组
\num 引用分组 num 匹配到的字符串
(?P) 分组起别名
(?P=name) 引用别名为 name 分组匹配到的字符串
"""
1.| 示例
需求：匹配出 0-100 之间的数字
import re
ret = re.match(“[1-9]?\d”,“8”)
print(ret.group()) # 8
ret = re.match(“[1-9]?\d”,“78”)
print(ret.group()) # 78
不正确的情况
ret = re.match(“[1-9]?\d”,“08”)
print(ret.group()) # 0
修正之后的
ret = re.match(“[1-9]?\d$”,“08”)
if ret:
print(ret.group())
else:
print(“不在 0-100 之间”)
添加 |
ret = re.match(“[1-9]?\d$|100”,“8”)
print(ret.group()) # 8
ret = re.match(“[1-9]?\d$|100”,“78”)
print(ret.group()) # 78
ret = re.match(“[1-9]?\d$|100”,“08”)
print(ret.group()) # 不是 0-100 之间
ret = re.match(“[1-9]?\d$|100”,“100”)
print(ret.group()) # 100
2.() 示例
需求：匹配出 163、126、qq 邮箱
import re
ret = re.match(“\w{4,20}@163.com”, “test@163.com”)
print(ret.group()) # test@163.com
ret = re.match(“\w{4,20}@(163|126|qq).com”, “test@126.com”)
print(ret.group()) # test@126.com
ret = re.match(“\w{4,20}@(163|126|qq).com”, “test@qq.com”)
print(ret.group()) # test@qq.com
ret = re.match(“\w{4,20}@(163|126|qq).com”, “test@gmail.com”)
if ret:
print(ret.group())
else:
print(“不是 163、126、qq 邮箱”) # 不是 163、126、qq 邮箱
不是以 4、7 结尾的手机号码 (11 位)
import re
tels = [“13100001234”, “18912344321”, “10086”, “18800007777”]
for tel in tels:
ret = re.match(r’1\d{9}[0-35-68-9]’, tel)
if ret:
print(“%s 符合不是以 4、7 结尾的手机号码要求” % ret.group())
else:
print(“%s 不符合” % tel)
提取区号和电话号码
import re
phoneNum = “010-12345678”
[^-]匹配以 - 开头的所有字符串
ret = re.match(’([^-])-(\d+)’,phoneNum)
print(ret.group())
print(ret.group(1))
print(ret.group(2))
3.\ 示例
需求：匹配出hh
import re
htmls = [“hh”, “hh”]
for html in htmls:
ret = re.match(r"<([a-zA-Z])>\w</\1>“, html)
if ret:
print(”%s 是符合要求的 html 标签 " % ret.group())
else:
print(“%s 不是符合要求的 html 标签”% html)
4.(?P) (?P=name) 示例
import re
s = ‘1102231990xxxxxxxx’
res = re.search(‘(?P\d{3})(?P\d{3})(?P<born_year>\d{4})’,s)
print(res.groupdict())
此分组取出结果为：
{‘province’: ‘110’, ‘city’: ‘223’, ‘born_year’: ‘1990’}
"""
re 模块的高级用法
match
re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match() 就返回 none。
函数语法：
re.match(pattern, string, flags=0) 函数参数说明：
参数 / 描述
pattern 匹配的正则表达式
string 要匹配的字符串。
flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
匹配成功 re.match 方法返回一个匹配的对象，否则返回 None。
我们可以使用 group(num) 或 groups() 匹配对象函数来获取匹配表达式。
匹配对象方法 / 描述
group(num=0) 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups() 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
"""
示例 1：
import re
print(re.match(‘www’, ‘www.baidu.com’).span()) # 在起始位置匹配
print(re.match(‘com’, ‘www.baidu.com’)) # 不在起始位置匹配
示例 2：
import re
line = “Cats are smarter than dogs”
matchObj = re.match(r’(.) are (.?).*’, line, re.M | re.I)
if matchObj:
print("matchObj.group() :", matchObj.group())
print("matchObj.group(1) :", matchObj.group(1))
print("matchObj.group(2) :", matchObj.group(2))
else:
print(“No match!!”)
"""
search
re.search 扫描整个字符串并返回第一个成功的匹配。
函数语法：
re.search(pattern, string, flags=0)
函数参数说明：
参数 / 描述
pattern 匹配的正则表达式
string 要匹配的字符串。
flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
匹配成功 re.search 方法返回一个匹配的对象，否则返回 None。
我们可以使用 group(num) 或 groups() 匹配对象函数来获取匹配表达式。
匹配对象方法 / 描述
group(num=0) 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups() 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
"""
示例 1：
import re
print(re.search(‘www’, ‘www.runoob.com’).span()) # 在起始位置匹配
print(re.search(‘com’, ‘www.runoob.com’).span()) # 不在起始位置匹配
示例 2：
import re
line = “Cats are smarter than dogs”;
searchObj = re.search(r’(.) are (.?).*’, line, re.M | re.I)
if searchObj:
print("searchObj.group() :", searchObj.group())
print("searchObj.group(1) :", searchObj.group(1))
print("searchObj.group(2) :", searchObj.group(2))
else:
print(“Nothing found!!”)
小练习
需求：匹配出文章阅读的次数
import re
sting1 = “阅读次数为 9999”
result = re.search(r"\d+", sting1)
print(result.group())
"""
re.match 与 re.search 的区别
re.match 只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回 None；
而 re.search 匹配整个字符串，直到找到一个匹配。
"""
"""
findall
在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。
注意： match 和 search 是匹配一次 findall 匹配所有。
语法格式为：
findall(string[, pos[, endpos]])
参数 / 参数描述
string 待匹配的字符串。
pos 可选参数，指定字符串的起始位置，默认为 0。
endpos 可选参数，指定字符串的结束位置，默认为字符串的长度。
"""
示例 1：
import re
pattern = re.compile(r’\d+’) # 查找数字
result1 = pattern.findall(‘runoob 123 google 456’)
result2 = pattern.findall(‘run88oob123google456’, 0, 10)
print(result1)
print(result2)
小练习
需求：统计出 python、c、c++ 相应文章阅读的次数
import re
stingVlue = “python = 9999, c = 7890, c++ = 12345”
ret = re.findall(r"\d+", stingVlue)
print(ret)
"""
finditer
和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
语法格式：
re.finditer(pattern, string, flags=0)
参数 / 描述
pattern 匹配的正则表达式
string 要匹配的字符串。
flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
"""
示例 1：
import re
it = re.finditer(r"\d+", “12a32bc43jf3”)
for match in it:
print(match.group())
小练习
需求：统计出 python、c、c++ 相应文章阅读的次数
import re
stingVlue = “python = 9999, c = 7890, c++ = 12345”
rets = re.finditer(r"\d+", stingVlue)
for ret in rets:
print(ret.group())
"""
sub 将匹配到的数据进行替换
Python 的 re 模块提供了 re.sub 用于替换字符串中的匹配项。
语法：
re.sub(pattern, repl, string, count=0, flags=0)
参数 / 参数描述
pattern 正则中的模式字符串。
repl 替换的字符串，也可为一个函数。
string 要被查找替换的原始字符串。
count 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
"""
示例 1：
import re
phone = “2004-959-559 # 这是一个国外电话号码”
删除字符串中的 Python 注释
num = re.sub(r’#.*$’, "", phone)
print("电话号码是:", num)
删除非数字 (-) 的字符串
num = re.sub(r’\D’, "", phone)
print("电话号码是 :", num)
小练习：
import re
def add(temp):
strNum = temp.group()
num = int(strNum) + 1
return str(num)
ret = re.sub(r"\d+", add, “python = 997”)
print(ret)
ret = re.sub(r"\d+", add, “python = 99”)
print(ret)
"""
split 根据匹配进行切割字符串，并返回一个列表
split 方法按照能够匹配的子串将字符串分割后返回列表
语法
re.split(pattern, string[, maxsplit=0, flags=0])
参数 / 描述
pattern 匹配的正则表达式
string 要匹配的字符串。
maxsplit 分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
"""
示例 1：
import re
ret = re.split(‘\W+’, ‘runoob, runoob, runoob.’)
print(ret)
小练习：
import re
ret = re.split(r":|", “info:xiaoZhang 33 shandong”)
print(ret)
"""
compile
compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match()和 search() 这两个函数使用。
语法格式为： re.compile(pattern[, flags])
参数 / 参数描述
pattern 一个字符串形式的正则表达式
flags 可选，表示匹配模式，比如忽略大小写，多行模式等
flags 参数：
re.I 忽略大小写
re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
re.M 多行模式
re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
re.X 为了增加可读性，忽略空格和 # 后面的注释
在上面，当匹配成功时返回一个 Match 对象，其中：
方法 / 方法描述
group([group1,…]) 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group()或 group(0)；
start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；
end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引 +1），参数默认值为 0；
span([group]) 方法返回 (start(group), end(group))。
"""
示例 1：
import re
pattern = re.compile(r’\d+’)
ret = pattern.match(‘one12twothree34four’, 3, 10) # 从’1’的位置开始匹配，正好匹配 )
print(ret.group())
"""
贪婪和非贪婪
Python 里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；
非贪婪则相反，总是尝试匹配尽可能少的字符。
在 "*“,”?“,”+“,”{m,n}" 后面加上？，使贪婪变成非贪婪。
"""
示例 1：
s=“This is a number 234-235-22-423”
r=re.match(“.+(\d+-\d+-\d+-\d+)”,s)
r.group(1)
‘4-235-22-423’
r=re.match(“.+?(\d+-\d+-\d+-\d+)”,s)
r.group(1)
‘234-235-22-423’
"""
正则表达式模式中使用到通配字，那它在从左到右的顺序求值时，会尽量“抓取”满足匹配最长字符串，
在我们上面的例子里面，“.+”会从字符串的启始处抓取满足模式的最长字符，其中包括我们想得到的第一个整型字段的中的大部分，
“\d+”只需一位字符就可以匹配，所以它匹配了数字“4”，而“.+”则匹配了从字符串起始到这个第一位数字 4 之前的所有字符。
解决方式：非贪婪操作符“？”，这个操作符可以用在 "*“,”+“,”?" 的后面，要求正则匹配的越少越好。
"""
示例 2：
re.match(r"aa(\d+)“,“aa2343ddd”).group(1)
‘2343’
re.match(r"aa(\d+?)”,“aa2343ddd”).group(1)
‘2’
re.match(r"aa(\d+)ddd",“aa2343ddd”).group(1)
‘2343’
re.match(r"aa(\d+?)ddd",“aa2343ddd”).group(1)
‘2343’
"""
r 的作用
说明
Python 中字符串前面加上 r 表示原生字符串，
与大多数编程语言相同，正则表达式里使用 "" 作为转义字符，这就可能造成反斜杠困扰。
假如你需要匹配文本中的字符 ""，那么使用编程语言表示的正则表达式里将需要 4 个反斜杠""：前两个和后两个分别用于在编程语言里转义成反斜杠，
转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。
Python 里的原生字符串很好地解决了这个问题，有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。
"""
示例 1：
mm = “c:\a\b\c”
‘c:\a\b\c’
print(mm)
c:\a\b\c
re.match(“c:\\”,mm).group()
‘c:\’
ret = re.match(“c:\\”,mm).group()
print(ret)
c:
ret = re.match(“c:\\a”,mm).group()
print(ret)
c:\a
ret = re.match(r"c:\a",mm).group()
print(ret)
c:\a
ret = re.match(r"c:\a",mm).group()
Traceback (most recent call last):
File “”, line 1, in
AttributeError: ‘NoneType’ object has no attribute ‘group’
"""
正则表达式修饰符 - 可选标志
正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。
多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：
修饰符 / 描述
re.I 使匹配对大小写不敏感
re.L 做本地化识别（locale-aware）匹配
re.M 多行匹配，影响 ^ 和 $
re.S 使 . 匹配包括换行在内的所有字符
re.U 根据 Unicode 字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
"""
"""
正则表达式的 ()[] {} 有不同的意思。
()是为了提取匹配的字符串。表达式中有几个 () 就有几个相应的匹配字符串。
(\s*) 表示连续空格的字符串。
[] 是定义匹配的字符范围。比如 [a-zA-Z0-9] 表示相应位置的字符要匹配英文字符和数字。[\s*] 表示空格或者号。
{} 一般用来表示匹配的长度，比如 \s{3} 表示匹配三个空格，\s[1,3] 表示匹配一到三个空格。
(0-9) 匹配 ’0-9′ 本身。 [0-9] 匹配数字（注意后面有 *，可以为空）[0-9]+ 匹配数字（注意后面有 +，不可以为空）{1-9} 写法错误。
[0-9]{0,9} 表示长度为 0 到 9 的数字字符串。
"""
实不相瞒，我看到一本关于正则的书，砖头一样厚 ~~~