python3正则表达式

1,判断手机号

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import re

'''
给你一串字符串,判断是否是手机号

'''
#普通的方法
def chekPhone(str):
if len(str) !=11:
return False
elif str[0] != "1":
return False
elif str[1:2] !="3" and str[1:2] !="8" and str[1:2] !="7":
return False

for i in range(3,11):
if str[i] <"0" or str[i]> "9":
return False

return True



print(chekPhone("17312584561"))
print(chekPhone("139125845f61"))
print(chekPhone("1391258g456"))
print(chekPhone("13912f84561"))

2,正则概述和re模块简介

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
import re

'''
python自1.5以后增加了re的模块。提供了正则表达式模式
re模块使python语言拥有了全部的正则表达式功能
'''

#re模块简介
r'''
re.match函数
原型: match(pattern, string, flags = 0)
patter: 匹配的正则表达式
string: 要匹配的字符串
flags: 标志位,用于控制正则表达式的匹配方式 值如下:
re.I 忽略大小写
re.L 做本地化识别
re.M 多行匹配,影响^和$
re.S 是匹配包括换行符在内的所有字符
re.U 根据Unicode字符集解析字符,\w \W \b \B
re.X 使我们以更灵活的格式理解正则表达式
参数:
功能:尝试从字符串的起始位置匹配一个模式,如果不是起始位置匹配成功的话,返回None
'''

#www.baidu.com
print(re.match("www","www.baidu.com").span())
print(re.match("www","ww.baidu.com"))
print(re.match("www","baidu.www.com"))
print(re.match("www","wwW.baidu.com"))
print(re.match("www","www.baidu.com" ,flags=re.I))
#扫描整个字符串,返回从起始位置成功的匹配

print("------------------")
'''
re.search函数
原型: search(pattern, string, flags = 0)
patter: 匹配的正则表达式
string: 要匹配的字符串
flags: 标志位,用于控制正则表达式的匹配方式
功能: 扫描整个字符串,并返回第一个成功的匹配
'''
print(re.search("yichen","good man is yichen! yichen is nice "))

print("------------")
'''
re.findall函数
原型: findall(pattern, string, flags = 0)
patter: 匹配的正则表达式
string: 要匹配的字符串
flags: 标志位,用于控制正则表达式的匹配方式
功能: 扫描整个字符串,并返回结果列表

'''
print(re.findall("yichen","good man is yichen! Yichen is nice "))
print(re.findall("yichen","good man is yichen! Yichen is nice ",flags=re.I))

3,正则表达式的元字符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
import re

print("---------匹配单个字符与数字-----------")
r'''
. 匹配除换行符以外的任意字符
[0-9] []是字符集合,表示匹配方括号中所包含的任意一个字符
[yichen] 匹配'y','i','c','h','e','n'中的任意一个字符
[a-z] 匹配任意一个小写字母
[A-Z] 匹配任意一个大写字母
[0-9a-zA-Z] 匹配任意一个的数字和字母
[0-9a-zA-Z_] 匹配任意一个的数字、字母和下划线
[^yichen] 匹配除了yichen这几个字母以外的所有字符,中括号里的^称为托字符,表示不匹配集合中的字符
[^0-9] 匹配所有的非数字字符
\d 匹配所有的数字,效果同[0-9]
[^\d] 匹配所有的非数字字符,效果同[^0-9]
\D 匹配非数字字符,效果同[^0-9]
\w 匹配数字,字母和下划线,效果同[0-9a-zA-Z_]
\W 匹配非数字,字母和下划线,效果同 [^0-9a-zA-Z_]
\s 匹配任意的空白符(空格,换行, 回车,换页,制表) 效果同[ \f\n\r\t]
\S 匹配任意的非空白符,效果同[^ \f\n\r\t]

'''
print(re.search(".", "yichen is a good man "))
print(re.search("[0-9]", "yichen is a good man 6 "))
print(re.search("[yichen]", "yichen is a good man 6 "))
print(re.findall("[^yichen]", "yichen is a good man 6 "))
print(re.findall("[^\d]", "yichen is a good man 6 "))
print(re.findall("\D", "yichen is a good man 6 "))
print(re.findall("\w", "_yichen is a good man 6 "))

print("---------锚字符(边界字符)----------")

r'''
^ 行首匹配,和在[]里的^不是一个意思
$ 行尾匹配
\A 匹配字符串开始,他和^的区别是,\A只匹配整个字符串的开头,即时在re.M模式下也不会匹配它行的行首
\Z 匹配字符串结束,他和$的区别是,\Z只匹配整个字符串的结束,即时在re.M模式下也不会匹配它行的行尾

\b 匹配一个单词的边界,也就是值单词和空格间的位置 'er\b'可以匹配never,不能匹配nerverr
\B 匹配非单词的边界,
'''
print(re.findall("yichen$", "yichen is a good man"))
print(re.findall("^yichen", "yichen is a good man\nyichen is a good man",re.M))
print(re.findall("\Ayichen", "yichen is a good man\nyichen is a good man",re.M))

print(re.findall("man$", "yichen is a good man\nyichen is a good man",re.M))
print(re.findall("man\Z", "yichen is a good man\nyichen is a good man",re.M))

#\b
print(re.findall(r"er\b", "never"))
print(re.findall(r"er\b", "neverr"))
print(re.findall(r"\ber", "ernever"))

#\B
print("-----\B------")
print(re.findall(r"er\B", "neverr"))
print(re.findall("\Ber", "erneverr"))

print("----------匹配多个字符-----------")

'''
说明: 下方的x、y、z均为假设的普通字符,n、m为负整数,不是正则表达式的元字符
(xyz) 匹配小括号内的xyz(作为一个整体去匹配)
x? 匹配0个或者1一个x
x* 匹配0个或者任意多个x (.*表示匹配0个或者任意多个字符(换行符除外))
x+ 匹配至少一个x
x{n} 匹配确定的n个x(n是一个非负整数)
x{n,} 匹配至少n个x
x{n,m} 匹配至少n个最多m个x 。注意:n <= m
x|y |表示或,匹配的是x或y


'''
print(re.findall(r"(yichen)", "yichengood yi a good man ,yichen is a nice man"))
print(re.findall(r"a?", "aaaaaaba")) #非贪婪匹配(尽可能的少匹配)
print(re.findall(r"a*","aaaaaba")) #贪婪匹配(尽可能的多匹配)
print(re.findall(r"a+","aaaaaba")) #贪婪匹配(尽可能的多匹配)
print(re.findall(r"a{3}","aaaaabaaaaaaa"))
print(re.findall(r"a{3,}","aaaaabaaaaaaa"))
print(re.findall(r"a{3,6}","aaaaabaaaaaaa"))
print(re.findall(r"((y|Y)ichen)","yichen--Yichen"))

#需求,提取yichen******man,
str = "yichen is a good man! yichen is a nice man! yihen is a very handsome man"
print(re.findall(r"^yichen.*man$", str))

print("------------特殊--------------")

'''
*? +? x? 最少匹配 通常都是尽可能的多的匹配,可以使用这种解决贪婪匹配
'''
print(re.findall(r"^yichen.*?man$", str))
#注释: /* part1 */ /* part2 */
print(re.findall(r"/\*.*\*/", r"/* part1 */ /* part2 */ "))

print(re.findall(r"/\*.*?\*/", r"/* part1 */ /* part2 */ "))

4,re模块深入与分组提取

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
import re


'''
字符串切割

'''

str1 = "yichen is a good man"
print(str1.split(" "))
print(re.split(r" +", str1))

'''
re.finditer函数
原型: finditer(pattern, string, flags = 0)
patter: 匹配的正则表达式
string: 要匹配的字符串
flags: 标志位,用于控制正则表达式的匹配方式
功能: 与findall类似,扫描整个字符串,返回的是一个迭代器
'''

str2 = "yichen is a good man! yichen is a nice man! yichen is a handsome man"

d = re.finditer(r"(yichen)", str2)

while True:
try:
n = next(d)

print(d)
except StopIteration as e:
break


'''
字符串的替换和修改
re.sub(pattern,repl,string,count=0)
re.subn(pattern,repl,string,count=0)
pattern: 正则表达式(规则)
repl: 指定的用来替换的字符串
string: 目标字符串
count: 最多替换次数
功能:在目标字符串中以正则表达式的规则匹配字符串,再把他们替换成指定的字符串,可以指定替换的次数,如果不指定
,替换所有的匹配字符串

区别: 前者返回一个被替换的字符串,后者返回一个元组,第一个元素是被替换的字符串,第二个元素表示被替换的次数

'''
str3 ="yichen is a good good good man"
print(re.sub(r"(good)","nice", str3))
print(type(re.sub(r"(good)","nice", str3)))
#re.subn()
print(re.subn(r"(good)","nice", str3))
print(type(re.subn(r"(good)","nice", str3)))

'''
分组:
概念:除了简单的判断是否匹配之外,正则表达式还有提取子串的功能,用()表示的就是分组。

'''

str4 = "010-53247654"
m = re.match(r"(?P<first>\d{3})-(\d{8})",str4)
print(m)
#使用序号获取对应组的信息,group(0)一直代表的原始字符串
print(m.group(0))
print(m.group(1))
print(m.group("first"))
print(m.group(2))
#查看匹配的各组的情况
print(m.groups())


'''
编译: 当我们使用正则表达式时,re模块会干两件事
1、编译正常表达式,如果正则表达式本身不合法,会报错
2、用编译后的正则表达式去匹配对象
re.complie(pattern, flags =0)
pattern :要编译的正则表达式

'''
pat = r"1(([3578]\d)|(47))\d{8}$"
print(re.match(pat,"18318821925"))
#编译成正则对象
re_telephon = re.compile(pat)
string ="18318821925"
res = re_telephon.match(string) #只要字符串就行了,不需要表达式了。
print(res)

re_QQ = re.compile(r"^[1-9]\d{1,9}$")
print(re_QQ.search("1378373554"))
#re模块调用
#re对象调用
#re.match()
re_telephon.match(string)
#re.search()
re_telephon.search(string)
#re.findall()
re_telephon.findall(string)
#re.finditer()
re_telephon.finditer(string)
#re.split()
re_telephon.split(string)
#re.sub()
#re_telephon.sub(repl ,string ,count =0) #正则表达式少了,只需要填写新的字符串和需要修改的字符串
#re.subn()
#re_telephon.subn(repl ,string ,count =0)

评论


:D 一言句子获取中...

加载中,最新评论有1分钟缓存...