阿里面试题: | a,b,c组合索引, 查
569 2023-04-03 04:05:22
正则表达式在线测试: http://tool.chinaz.com/regex
?123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869# ### 正则表达式 - 匹配单个字符
import
re
"""lst = re.findall(正则表达式,字符串)"""
# (1) 预定义字符集
# \d 匹配数字
strvar
=
"sdjfklj234&*(&1"
lst
=
re.findall(
"\d"
,strvar)
print
(lst)
# \D 匹配非数字
strvar
=
"YWERsdf78_&"
lst
=
re.findall(
"\D"
,strvar)
print
(lst)
# \w 匹配字母或数字或下划线 (正则函数中,支持中文的匹配)
strvar
=
"sadf234_^&*%$^$%你好"
lst
=
re.findall(
"\w"
,strvar)
print
(lst)
# \W 匹配非字母或数字或下划线
strvar
=
"sadf234_^&*%$^$%你好"
lst
=
re.findall(
"\W"
,strvar)
print
(lst)
# \s 匹配任意的空白符 ( " " \t \n \r )
strvar
=
" \r "
lst
=
re.findall(
"\s"
,strvar)
print
(lst)
# \S 匹配任意非空白符
strvar
=
" \r 123_*("
lst
=
re.findall(
"\S"
,strvar)
print
(lst)
# \n 匹配一个换行符
strvar
=
"""
今天国庆假期结束了,兄弟们满载 而归,玩的 很困,尽 快调 整.
"""
lst
=
re.findall(r
"\n"
,strvar)
print
(lst)
# \t 匹配一个制表符
lst
=
re.findall(r
"\t"
,strvar)
print
(lst)
# (2) 字符组 [] 匹配出字符组当中列举的字符(默认选一个)
# lst = re.findall("[123]","a1b2c3d4")
# print(lst)
print
(re.findall(
'a[abc]b'
,
'aab abb acb adb'
))
# aab abb acb
print
(re.findall(
'a[0123456789]b'
,
'a1b a2b a3b acb ayb'
))
# a1b a2b a3b
# 优化写法 0123456789 => 0-9
print
(re.findall(
'a[0-9]b'
,
'a1b a2b a3b acb ayb'
))
print
(re.findall(
'a[abcdefg]b'
,
'a1b a2b a3b acb ayb adb'
))
# acb adb
# 优化写法 abcdefg => a-g 表达所有的小写字母 a-z
print
(re.findall(
'a[a-g]b'
,
'a1b a2b a3b acb ayb adb'
))
print
(re.findall(
'a[a-z]b'
,
'a1b a2b a3b acb ayb adb'
))
# acb adb ayb
print
(re.findall(
'a[ABCDEFG]b'
,
'a1b a2b a3b aAb aDb aYb'
))
# aAb aDb
# 优化写法 ABCDEFG => A-G 表达所有的大写字母 A-Z
print
(re.findall(
'a[A-G]b'
,
'a1b a2b a3b aAb aDb aYb'
))
# aAb aDb
print
(re.findall(
'a[A-Z]b'
,
'a1b a2b a3b aAb aDb aYb'
))
# aAb aDb aYb
# 注意点: 不能直接写A-z 中间ascii编码中包含了特殊的符号
print
(re.findall(
'a[A-z]b'
,
'a1b a2b a3b acb ayb adb a[b'
))
# 匹配所有的字母和数字
print
(re.findall(
'a[a-zA-Z0-9]b'
,
'a1b a2b a3b acb ayb adb a[b'
))
print
(re.findall(
'a[0-9a-zA-Z]b'
,
'a-b aab aAb aWb aqba1b'
))
#aab aAb aWb aqb a1b
print
(re.findall(
'a[0-9][*#/]b'
,
'a1/b a2b a29b a56b a456b'
)) # a1
/
b
# ^ 在字符组开头的位置出现代表 除了...的意思
print
(re.findall(
'a[^-+*/]b'
,
"a%b ccaa*bda&bd"
))
#a%b a&b
# 匹配^-\等特殊字符时 ,需要前面加上\进行转义
strvar
=
"a^c a-c a\c"
lst
=
re.findall(r
"a[\^\-\\]c"
,strvar)
print
(lst)
print
(lst[
-
1
])
# 注意点:为了防止转义,在正则表达式中或者要匹配的字符串中,无脑加r实现匹配
strvar
=
r
"a\b"
lst
=
re.findall(r
"a\\b"
,strvar)
print
(lst[
0
])
# ### 正则表达式 - 匹配多个字符
# (1) 量词
import
re
'''1) ? 匹配0个或者1个a '''
print
(re.findall(
'a?b'
,
'abbzab abb aab'
))
# ab b ab ab b ab
'''2) + 匹配1个或者多个a '''
print
(re.findall(
'a+b'
,
'b ab aaaaaab abb'
))
# ab aaaaaab ab
'''3) * 匹配0个或者多个a '''
print
(re.findall(
'a*b'
,
'b ab aaaaaab abbbbbbb'
))
# b ab aaaaaab ab b b b b b b
'''4) {m,n} 匹配m个至n个a '''
# 1 <= a <= 3
print
(re.findall(
'a{1,3}b'
,
'aaab ab aab abbb aaz aabb'
))
#aaab ab aab ab aab
# {2} 代表必须匹配2个a
print
(re.findall(
'a{2}b'
,
'aaab ab aab abbb aaz aabb'
))
# aab aab aab
# {2,} 代表至少匹配2个a
print
(re.findall(
'a{2,}b'
,
'aaab ab aab abbb aaz aabb'
))
# aaab aab aab
# (2) 贪婪匹配 和 非贪婪匹配
"""
贪婪匹配 : 默认向更多次匹配 (回溯算法)
非贪婪匹配: 默认向更少次匹配 (配合?号使用)
回溯算法 : 从左向右进行匹配,直到找到最后一个,再也没有了,回头,返回上一个找到的内容
. 除了\n,匹配所有字符
非贪婪写法: 量词 + ?
"""
# 贪婪匹配(模式)
strvar
=
"刘能和刘老根和刘罗锅111子222子"
lst
=
re.findall(
"刘."
,strvar)
print
(lst)
# lst = re.findall("刘.?",strvar)
lst
=
re.findall(
"刘.?"
,strvar)
print
(lst)
# lst = re.findall("刘.?",strvar)
lst
=
re.findall(
"刘.+"
,strvar)
print
(lst)
# ['刘能和刘老根和刘罗锅111子222子']
lst
=
re.findall(
"刘.*"
,strvar)
print
(lst)
# ['刘能和刘老根和刘罗锅111子222子']
lst
=
re.findall(
"刘.{1,20}"
,strvar)
print
(lst)
# ['刘能和刘老根和刘罗锅111子222子']
lst
=
re.findall(
"刘.*子"
,strvar)
print
(lst)
# 非贪婪匹配(模式)
lst
=
re.findall(
"刘.??"
,strvar)
print
(lst)
# ['刘', '刘', '刘']
lst
=
re.findall(
"刘.+?"
,strvar)
print
(lst)
# 刘能 刘老 刘罗
lst
=
re.findall(
"刘.*?"
,strvar)
print
(lst)
# ['刘', '刘', '刘']
lst
=
re.findall(
"刘.{1,20}?"
,strvar)
print
(lst)
# ['刘能', '刘老', '刘罗']
lst
=
re.findall(
"刘.*?子"
,strvar)
print
(lst)
# (3) 边界符
"""
\b 本身是转义字符 退格,退到光标上一位
\b 在正则中还有边界符的意思
"word"
卡主左边界:\bw
卡主右边界:d\b
"""
strvar
=
"word old fuck"
# 右边界
lst
=
re.findall(r
"d\b"
,strvar)
# ['d', 'd']
lst
=
re.findall(r
".*d\b"
,strvar)
# ['word old']
lst
=
re.findall(r
".*?d\b"
,strvar)
# ['word old']
print
(lst)
# 左边界
lst
=
re.findall(r
"\bw"
,strvar)
lst
=
re.findall(r
"\bw.*"
,strvar)
lst
=
re.findall(r
"\bw.*?"
,strvar)
lst
=
re.findall(r
"\bw.*? "
,strvar)
# 空格在正则表达式中,不能随意加,是参与匹配的.
lst
=
re.findall(r
"\bw\S*"
,strvar)
print
(lst)
# (4) ^ $的使用
"""
^ 写在在字符串的开头,表达必须以某个字符开头
$ 写在在字符串的结尾,表达必须以某个字符结尾
当使用了^ $ 代表要把该字符串看成一个整体
"""
strvar
=
"大哥大嫂大爷"
print
(re.findall(
'大.'
,strvar))
# ['大哥', '大嫂', '大爷']
print
(re.findall(
'^大.'
,strvar))
# ['大哥']
print
(re.findall(
'大.$'
,strvar))
# ['大爷']
print
(re.findall(
'^大.$'
,strvar))
# []
print
(re.findall(
'^大.*?$'
,strvar))
# ['大哥大嫂大爷']
print
(re.findall(
'^大.*?大$'
,strvar))
# []
print
(re.findall(
'^大.*?爷$'
,strvar))
# ['大哥大嫂大爷']
print
(re.findall(
'^g.*? '
,
'giveme 1gfive gay'
))
# giveme
print
(re.findall(
'five$'
,
'aassfive'
))
# [five]
print
(re.findall(
'^giveme$'
,
'giveme'
))
# ['giveme']
print
(re.findall(
'^giveme$'
,
'giveme giveme'
))
# []
print
(re.findall(
'giveme'
,
'giveme giveme'
))
# ['giveme', 'giveme']
print
(re.findall(
"^g.*e"
,
'giveme 1gfive gay'
))
# ['giveme 1gfive']
# ### 匹配分组 ()表达整体
import
re
# (1)分组
print
(re.findall(
'.*?_good'
,
'wusir_good alex_good secret男_good'
))
print
(re.findall(
'(.*?)_good'
,
'wusir_good alex_good secret男_good'
))
# (?:) 代表不优先显示分组里面的内容,只是显示正常匹配到的内容
print
(re.findall(
'(?:.*?)_good'
,
'wusir_good alex_good secret男_good'
))
# (2) | 代表或 , a|b 匹配字符a 或者 匹配字符b .
strvar
=
"abceab"
lst
=
re.findall(
"a|b"
,strvar)
print
(lst)
# 注意点:把不容易匹配到的内容放到前面,把容易匹配到的内容放到后面
strvar
=
"abcdeabc234f"
lst
=
re.findall(
"abcd|abc"
,strvar)
print
(lst)
# (3) 练习
"""
. 可以匹配任意的字符,除了\n
\. 对.进行转义,表达.这个字符本身.
"""
# 匹配小数
strvar
=
"3.... ....4 .3 ...3 1.3 9.89 10"
lst
=
re.findall(r
"\d+\.\d+"
,strvar)
print
(lst)
# 匹配小数和整数
lst
=
re.findall(r
"\d+\.\d+|\d+"
,strvar)
print
(lst)
# 使用分组改造
'''findall优先显示括号里的内容,需要加上?:取消哦优先显示,按照匹配到的内容显示'''
lst
=
re.findall(r
"\d+(?:\.\d+)?"
,strvar)
print
(lst)
# 匹配135或171的手机号
strvar
=
"13566668888 17366669999 17135178392"
lst
=
re.findall(r
"(?:135|171)\d{8}"
,strvar)
print
(lst)
# 优化,只能匹配出一个手机号
strvar
=
"13566668888"
lst
=
re.findall(r
"^(?:135|171)\d{8}$"
,strvar)
print
(lst)
obj
=
re.search(r
"^(135|171)\d{8}$"
,strvar)
print
(obj)
print
(obj.group())
print
(obj.groups())
# 匹配www.baidu.com 或者 www.oldboy.com
"""
findall : 从左到右,匹配出所有的内容,返回到列表
问题是,匹配到的字符串和分组的内容不能同时显示;
search : 从左到右,匹配到一组内容就直接返回,返回的是对象
优点是,可以让匹配到的内容和分组里的内容同时显示;
匹配不到内容时,返回的是None
obj.group() : 获取匹配到的内容
obj.groups(): 获取分组里面的内容
"""
# findall
strvar
=
"www.baidu.com www.oldboy.com www.wangwen.com"
lst
=
re.findall(r
"(?:www)\.(?:baidu|oldboy)\.(?:com)"
,strvar)
print
(lst)
# search
strvar
=
"www.baidu.com www.oldboy.com www.wangwen.com"
obj
=
re.search(r
"(www)\.(baidu|oldboy)\.(com)"
,strvar)
print
(obj)
# 获取匹配到的内容
print
(obj.group())
# 获取分组里面的内容 (推荐)
print
(obj.groups())
# 方法二,可以直接通过下标1来获取分组里面的第一个内容;
print
(obj.group(
1
))
print
(obj.group(
2
))
print
(obj.group(
3
))
# search 练习 : 计算"5*6-7/3"结果 匹配 5*6 或者 7/3
strvar
=
"5*6-7/3"
# strvar = "www.baidu.com www.oldboy.com www.wangwen.com"
obj
=
re.search(r
"\d+[*/]\d+"
,strvar)
res1
=
obj.group()
print
(res1 ,
type
(res1))
# 5*6 <class 'str'>
# 计算结果
a,b
=
res1.split(
"*"
)
res2
=
int
(a)
*
int
(b)
print
(res2)
# 把30替换回原来的字符串中
strvar
=
strvar.replace(res1,
str
(res2))
print
(strvar)
# 以此类推 ...
1.
刘.?? 最后一个问号是非贪婪模式,不是量词
word old fuck w、d、o、d、f、k是边界
lst
=
re.findall(r
"d\b"
,strvar)
# ['d','d']
lst
=
refindall(r
".*d\b"
,strvar)
# ['word old'] 贪婪匹配,匹配到old之后
会继续向后匹配,匹配不到的话,返回前面已经匹配到的内容
print
(lst)
注意: wordoldfuck 这样不行没有边界,r
"d\b"
前面无脑加r,因为\b本身有退格的含义,加r让退格实现,从而使正则的边界的效果生效
# 1、匹配整数或者小数(包括正数和负数)
# 2、匹配年月日日期 格式 2018-12-31
# 3、匹配qq号 5-12 首字符没有0
# 4、11位的电话号码
# 5、长度为8-10位的用户密码 : 包含数字字母下划线
# 6、匹配验证码:4位数字字母组成的
# 7、匹配邮箱地址 邮箱规则 123463922@qq.com 123@abc.com.cn
# @之前必须有内容且只能是字母,数字,下划线(_),减号(-),点(.)
# @符号后面是字母,数字,减号(-),保留121@qq.com.cn 的可能
# 最后一个点(.)之后必须有内容,字母,数字且长度为大于等于2个字节,小于等于6个字节
# 8、从类似
# <a>wahaha</a>
# <b>banana</b>
# <h1>qqxing</h1>
# <h1>q</h1>
# 这样的字符串中,
# 1)匹配出 wahaha,banana,qqxing 内容。
# 2)匹配出 a,b,h1这样的内容
# 9、'1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))'
# 从上面算式中匹配出最内层小括号以及小括号内的表达式
# 10正则小程序:
"""
给你字符串 '1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))' 计算最后结果.
"""
# 1、匹配整数或者小数(包括正数和负数)
[
+
-
]?\d
+
(\.\d
+
)?
# 2、匹配年月日日期 格式 2018-12-31
([
12
]\d{
3
})
-
(
0
?[
1
-
9
]|
1
[
0
-
2
])
-
(
0
?[
1
-
9
]|[
12
]\d|
3
[
01
])
# 0?[1-9]|1\d|2\d|3[01] => 0?[1-9]|[12]\d|3[01]
# 3、匹配qq号 5-12 首字符没有0
[
1
-
9
]\d{
4
,
11
}
# 4、11位的电话号码
1
[
356789
]\d{
9
}
# 5、长度为8-10位的用户密码 : 包含数字字母下划线
\w{
8
,
10
}
if
"数字"
in
strvar
and
"字母"
in
strvar
and
"_"
in
strvar:
return
ok
else
:
return
"格式不对"
# 6、匹配验证码:4位数字字母组成的
[
0
-
9a
-
zA
-
Z]{
4
}
# 7、匹配邮箱地址 邮箱规则 123463922@qq.com 123@abc.com.cn
# @之前必须有内容且只能是字母,数字,下划线(_),减号(-),点(.)
[\w\
-
\.]
+
# @符号后面是字母,数字,减号(-),保留121@qq.com.cn 的可能
@[a
-
zA
-
Z\d\
-
]
+
(\.[a
-
zA
-
Z\d\
-
]
+
)?
# 最后一个点(.)之后必须有内容,字母,数字且长度为大于等于2个字节,小于等于6个字节
\.[a
-
zA
-
Z\d]{
2
,
6
}
#综合:
[\w\
-
\.]
+
@[a
-
zA
-
Z\d\
-
]
+
(\.[a
-
zA
-
Z\d\
-
]
+
)?\.[a
-
zA
-
Z\d]{
2
,
6
}
# 8、从类似
# <a>wahaha</a>
# <b>banana</b>
# <h1>qqxing</h1>
# <h1>q</h1>
# 这样的字符串中,
# 1)匹配出 wahaha,banana,qqxing 内容。
<.
*
?>(.
*
?)<.
*
?>
# 2)匹配出 a,b,h1这样的内容
<(.
*
?)>.
*
?<.
*
?>
# 9、'1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))'
# 从上面算式中匹配出最内层小括号的表达式
import
re
strvar
=
'1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))'
obj
=
re.search(r
"\([^\(\)]+\)"
,strvar)
print
(obj.group())
# 10正则小程序:
"""
给你字符串 '1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))' 计算最后结果.
"""
?123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687import
re
strvar
=
'1-2*((60-30+-8*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))'
# 外面有括号,里面再也没有括号的的表达式就是最里层表达式;
# obj = re.search(r"\([^\(\)]+\)",strvar)
# print(obj.group())
# strvar = '1-2*(-5-6/-2*2)+(40 - 7)'
# 去除多余的符号
def
operate_sign(strvar):
strvar
=
strvar.replace(
"--"
,
"+"
)
strvar
=
strvar.replace(
"++"
,
"+"
)
strvar
=
strvar.replace(
"-+"
,
"-"
)
strvar
=
strvar.replace(
"+-"
,
"-"
)
return
strvar
# 计算表达式的值
def
calc_res(strvar):
if
"/"
in
strvar:
a,b
=
strvar.split(
"/"
)
return
float
(a)
/
float
(b)
elif
"*"
in
strvar:
a,b
=
strvar.split(
"*"
)
return
float
(a)
*
float
(b)
# 匹配计算出对应的表达式
def
calc_exp(strvar):
print
(strvar ,
"strvar ... "
)
# (-5-6/-2*2)
# ### part1 只计算乘除
while
True
:
# 1.写一条正则匹配出乘除
obj
=
re.search(r
"\d+(\.\d+)?[*/][+-]?\d+(\.\d+)?"
,strvar)
if
obj:
# 2.匹配出乘除表达式
res1
=
obj.group()
print
(res1 ,
"res1 ... "
)
# 6/-2 res1 ...
# 2.计算当前表达式的结果
res2
=
calc_res(res1)
print
(res2 ,
"res2 .. "
)
# -3.0 res2 ..
# 3.用结果替换原乘除表达式
strvar
=
strvar.replace(res1,
str
(res2))
print
(strvar ,
"strvar ... 1111"
)
# (-5--3.0*2) strvar ... 1111
else
:
break
# ### part2 只计算加减
# 把表达式当中多余的符号做一个替换
strvar
=
operate_sign(strvar)
print
(strvar,
"2222"
)
# 计算这个表达式+-结果
lst
=
re.findall(
"[+-]?\d+(?:\.\d+)?"
,strvar)
# print(lst)
# 计算累加和
total
=
0
for
i
in
lst:
total
+
=
float
(i)
return
total
# 去除括号
def
remove_bracket(strvar):
while
True
:
obj
=
re.search(r
"\([^\(\)]+\)"
,strvar)
# print(obj)
if
obj:
# 匹配括号里面的表达式
res1
=
obj.group()
print
(res1 ,
"res1 ... ... .. "
)
# (-5-6/-2*2) res1 ... ... ..
# 计算括号里面的表达式
res2
=
calc_exp(res1)
print
(res2,
"res2 ... remove_bracket"
)
# 1.0
# 用计算的结果替换原来的括号
strvar
=
strvar.replace(res1,
str
(res2))
else
:
return
strvar
# print(strvar," strvar ... remove_bracket")
# 主函数统一调用
def
main(strvar):
# 0.先去掉字符串当中出现的空格
# 1.通过正则匹配到最里层小括号
# 2.计算括号里面的数值
# 3.拿算好的数值替换原来的小括号
# 4.循环在去匹配下一个小括号,依次类推 ...
# 先去掉字符串当中出现的空格
strvar
=
strvar.replace(
" "
,"")
print
(strvar)
# 移除表达式中的所有括号
res
=
remove_bracket(strvar)
print
(res ,
"res main ..."
)
# 计算最后一次没有括号的那个表达式的结果
return
calc_exp(res)
res
=
main(strvar)
print
(res)
# print(eval(strvar))
本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注脚本之家的更多内容!
您可能感兴趣的文章: