根据计算优先级,先计算内部括号里面的运算,并用计算结果的字符串形式替换原表达式,直到没有括号运算符;
然后匹配乘法和除法的运算因子,按从左往右的顺序依次更新计算结果,最后处理加减法运算。
Tips: 需要特别注意对输入的检测和修正(如多余空格、非法输入)和浮点数的匹配
import
re
import
functools
def
checkInput
(formula)
:
"""检测输入合法与否,是否包含字母等非法字符"""
return
not
re.search(
"[^0-9+\-*/.()\s]"
,formula)
def
formatInput
(formula)
:
"""标准化输入表达式,去除多余空格等"""
formula = formula.replace(
' '
,
''
)
formula = formula.replace(
'++'
,
'+'
)
formula = formula.replace(
'+-'
,
'-'
)
formula = formula.replace(
'-+'
,
'-'
)
formula = formula.replace(
'--'
,
'+'
)
return
formula
def
mul_divOperation
(s)
:
"""乘法除法运算"""
s = formatInput(s)
sub_str = re.search(
'(\d+\.?\d*[*/]-?\d+\.?\d*)'
, s)
while
sub_str:
sub_str = sub_str.group()
if
sub_str.count(
'*'
):
l_num, r_num = sub_str.split(
'*'
)
s = s.replace(sub_str, str(float(l_num)*float(r_num)))
else
:
l_num, r_num = sub_str.split(
'/'
)
s = s.replace(sub_str, str(float(l_num) / float(r_num)))
s = formatInput(s)
sub_str = re.search(
'(\d+\.?\d*[*/]\d+\.?\d*)'
, s)
return
s
def
add_minusOperation
(s)
:
"""加法减法运算
思路:在最前面加上+号,然后正则匹配累加
s = formatInput(s)
s =
'+'
+ s
tmp = re.findall(
'[+\-]\d+\.?\d*'
, s)
s = str(functools.reduce(
lambda
x, y:float(x)+float(y), tmp))
return
s
def
compute
(formula)
:
"""无括号表达式解析"""
ret = formatInput(formula)
ret = mul_divOperation(ret)
ret = add_minusOperation(ret)
return
ret
def
calc
(formula)
:
"""计算程序入口"""
has_parenthesise = formula.count(
'('
)
if
checkInput(formula):
formula = formatInput(formula)
while
has_parenthesise:
sub_parenthesise = re.search(
'\([^()]*\)'
, formula)
if
sub_parenthesise:
formula = formula.replace(sub_parenthesise.group(), compute(sub_parenthesise.group()[
1
:-
1
]))
else
:
print(
'没有括号了...'
)
has_parenthesise =
False
ret = compute(formula)
print(
'结果为:'
)
return
ret
else
:
print(
"输入有误!"
)
if
__name__ ==
'__main__'
:
s =
"99+(1+2=(8)-(7+9))"
print(eval(
'1.5 - 2.4 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )'
))
print(calc(
'1.5 - 2.4 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )'
))
print( calc(
"1 - 2 * ( (60-30 +(-9-2-5-2*3-5/3-40*4/2-3/5+6*3) * (-9-2-5-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )"
))
实现目标: 1. 正确处理加减乘除及括号优先级 2. 保证结果无误,可用eval() 测试 3.练习正则表达式使用#coding utf-8""" 用正则表达式实现四则运算表达式解析器思路:根据计算优先级,先计算内部括号里面的运算,并用计算结果的字符串形式替换原表达式,直到没有括号运算符;然后匹配乘法和除法的运算因子,按从左往右的顺序依次更...
strs = '1(2(3(4(5(67)6)7)8)9)0'
reg1 = re.compile('([()])∗') #一对括号
reg2 = re.compile('([()]|\([()]∗)*\)') #两对括号
reg3 = re.compile('([()]|\([()]∗|([()]|\([()]∗)*\))*\)') #三层
#匹配成对括号
正则表达式
def getReg(self, count, bracket = '()'):
leftBracket = br
首先说
正则表达式
是什么?
正则表达式
,又称正规表示式、正规表示法、正规表达式、规则表达式、常规表示法(英语:Regular Expression,在代码中常简写为regex、regexp或RE),计算机科学的一个概念。
正则表达式
使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。在很多文本编辑器里,
正则表达式
通常被用来检索、替换那些匹配某个模式的文本。
许多程序设计语言都支持利用
正则表达式
进行字符串操作。例如,在Perl中就内建了一个功能强大的
正则表达式
引擎。
正则表达式
这个概念最初是由Unix中的工具软件(例如sed和grep)普及开的。
正则表达式
通常缩写成“regex”,单数有
Python
基础:
四则运算
四则运算
就是我们所熟悉的数学加减乘除,
Python
里的加减乘除和我们现实中数学里的加减乘除是一样的,但是也会有些许差别,因为
Python
里的数字毕竟是分类型的,下面我们举个例子来说一下:
>>> 1 + 2
>>> 1.0 + 2
>>> 1.0 + 2.0
从这个例子里我们可以看出,运算符( + , - ,× ,/ )两侧只要有一个是浮点数,那么运算结果就是浮点数,只有整数 + 整数才是整数。但是,
首先,什么叫
正则表达式
(Regular Expression)?
例如我们要判断字符串”adi_e32fv,Ls”里面是否含有子串”e32f”,又例如我们在一个含百万个姓名的txt文件中找姓“王”,名字以“五”结尾的名字,然后打印出来。结果为:“王五”、“王小五”、“王大五”、“王小小五”……
以前我们是使用字符串函数来查找的,但是代码
实现
起来会很复杂。如今用
正则表达式
只需要一句 re.findall(‘王.*?五’,txt1) 就可以了!
正则表达式
是写网络爬虫的最基本的知识,可以用
正则表达式
在html中搜集
regex_parser
这是一个
正则表达式
解析器
,是用JavaScript编写的,是一种学习练习-如果您需要解析JavaScript中的
正则表达式
,则您当然应该使用内置的,而不是此
实现
。
该库
实现
了回溯并使用从您提供的
正则表达式
文本构造解析树。 解析树封装在regex对象中,并由parse.compile()函数返回。 regex对象公开了match()方法,该方法可用于根据表达式测试字符串值。 匹配结果包含在具有matches属性的对象中,该对象设置为true或false指示匹配是否成功。
var regex, match;
regex = parser.compile('abc+');
match = regex.match('abccc'); // match.matches = true
match = regex.match('abcd'); // match.matc
正则表达式
是一个特殊的字符序列,它能帮助你方便的检查一个字符串是否与某种模式匹配。
Python
自1.5版本起增加了re 模块,它提供 Perl 风格的
正则表达式
模式。
re 模块使
Python
语言拥有全部的
正则表达式
功能。
compile 函数根据一个模式字符串和可选的标志参数生成一个
正则表达式
对象。该对象拥有一系列方法用于
正则表达式
匹配和替换。
re 模块也提供了与这些方法功能完全一致的函数,这些函数使用一个模式字符串做为它们的第一个参数。
python
正则表达式
的使用(实验代码),具体代码如下所示:
import re\ndata='''12345 2019-05-20 13:
<h3>回答1:</h3><br/>
Python
中的re模块提供了一种用于处理
正则表达式
的工具。其中,compile函数可以将
正则表达式
编译为一个正则对象,从而提高
正则表达式
的效率。
compile函数的语法如下:
re.compile(pattern, flags=0)
其中,参数pattern代表要编译的
正则表达式
,flags代表可选的标志位,用于控制
正则表达式
的匹配方式。
使用compile函数可以将多次使用的
正则表达式
进行编译,从而提高程序的效率。在实际开发中,如果需要对一个字符串进行多次匹配操作,建议使用compile函数预编译
正则表达式
。
例如,假设要匹配所有以字母开头、后跟数字的字符串,可以使用如下代码:
```
python
import re
# 编译
正则表达式
pattern = re.compile(r"[a-zA-Z]\d+")
# 匹配字符串
result = pattern.findall("A123 B456 C789")
print(result) # 输出: ['A123', 'B456', 'C789']
在上面的代码中,首先使用compile函数编译了
正则表达式
r"[a-zA-Z]\d+",然后使用findall方法匹配字符串"A123 B456 C789",返回了所有符合条件的子串。
总之,compile函数是一个非常有用的
正则表达式
工具,可以提高
正则表达式
的效率,减少不必要的匹配操作,从而在实际开发中发挥作用。
<h3>回答2:</h3><br/>在
Python
中,re模块是用于
正则表达式
操作的标准库。而re中的compile函数是用于将字符串形式的
正则表达式
编译成一个
正则表达式
对象,以便在之后的匹配中可以直接使用该对象。
使用compile函数编译
正则表达式
可以提高匹配效率,特别是在需要重复匹配同一个表达式时。因为每次使用
正则表达式
匹配都需要重新构建
正则表达式
的解析树,而使用compile函数编译
正则表达式
就可以把解析树缓存起来,在需要匹配时可以直接调用缓存的解析树,从而提高了匹配效率。
具体使用方法,可以先使用compile函数将
正则表达式
编译成一个对象,然后使用该对象的match、search、findall等方法进行匹配操作。例如:
import re
pattern = re.compile(r'\d+') # 编译
正则表达式
result = pattern.findall('hello123world456') # 使用编译后的
正则表达式
对象进行匹配
print(result) # ['123', '456']
另外需要注意的是,使用compile函数编译的
正则表达式
对象是可以重复使用的,因此在需要多次匹配同一个表达式时,可以先编译成对象,然后重复调用该对象的方法进行匹配操作,可以避免重复编译的影响。
<h3>回答3:</h3><br/>在
Python
中,re模块可以用来处理
正则表达式
。compile()函数是re模块的一个方法,它可以将一个
正则表达式
串编译成一个pattern对象,这个对象可以再次被用来处理字符串。
使用re.compile()函数的一个主要原因是它可以提高代码的执行效率。如果需要多次使用同一
正则表达式
,如果每次都要编译一遍,就会浪费很多时间。如果编译一次之后,将pattern对象保存在一个变量中,就可以在需要时多次使用,提高了程序的运行速度。
compile()函数有两个参数:pattern和flags。其中,pattern表示要编译的
正则表达式
字符串,flags是一个可选的参数,用来指定
正则表达式
的匹配模式。flags可以是一组位标志,也可以是具体的某个标志。
注意,使用re.compile()创建的pattern对象只支持基本的
正则表达式
语法。如果需要使用进阶的语法,比如lookahead或lookbehind,就必须使用re模块中的其他函数。
下面是一个使用compile()函数的
简单
示例:
import re
pattern = re.compile(r'\d+') # 匹配所有数字
text = 'there are 123 apples'
match = pattern.search(text)
if match:
print(match.group()) # 输出 123
上面的代码首先用compile()函数创建了一个
正则表达式
对象,表示匹配所有数字。然后它在文本中搜索这个对象,如果匹配成功,就通过group()方法输出匹配的文本。
总之,compile()函数是
Python
中
正则表达式
的重要组成部分。它可以将需要多次使用的
正则表达式
对象编译成pattern对象,从而提高程序的效率。使用compile()函数还可以更方便地管理
正则表达式
,使得代码更加易读易维护。