本节大纲：

  1. 表达式的输入及检查、格式化
  2. 怎么样进行匹配最里面的括号以及操作数的匹配
  3. 如何实现表达式的四则运算
  4. 完整代码展示

在我们学习re模块之后，通常的练习就是利用所学相关知识来写一个计算器

那么，现在我们开始理一下思路：

1.表达式的输入及检查、格式化

1.1 输入

首先呢，我们肯定要让用户先输入一个表达式

strs = input()

1.2 检查

之后，我们要做的就是检查所输入内容的合法性，这里我们用一个函数来封装

def check_str(s):  # 检查字符串是否合法

    flag = True  # 初始化假设字符串合法

    if s.count("(") != s.count(")"):  # 检查（）是否个数相等

        flag = False

    if re.search("[a-zA-Z]", s):  # 检查是否出现了非法字符

        flag = False

    #    print("该表达式的合法性为：%s" % flag)

    return flag

所相应的匹配程序

    while not check_str(strs):

        print("非法表达式！请重新输入")

        strs = input()

测试结果：

IN:(1+1

OUT:非法表达式！请重新输入

IN:1+2p

OUT:非法表达式！请重新输入

IN:2+3
OUT:

当然，在上述代码中，非法字符的检测并不完善，这肯定需要改善，具体思路为：

在我们输入表达式的时候，所输入的字符无非就如下几种情况：

  1. 数字  1~9
  2. 运算符号  + - * /
  3. 左右括号  (  )
  4. 空格  “ ”

所以我们只需做出相应的匹配即可

1.3 格式化

接下来我们要做的就是将表达式格式化---为了匹配的准确性

def format_str(s):  # 格式化字符串

    s = s.replace(" ", "")

    s = s.replace("++", "+")

    s = s.replace("+-", "-")

    s = s.replace("-+", "-")

    s = s.replace("--", "+")

    s = s.replace("/+", "/")

    s = s.replace("*+", "*")

    #    print("该表达式格式化后的结果为：%s" % s)

    return s

2.怎么样进行匹配最里面的括号以及操作数的匹配

2.1.最里面的括号

为什么要匹配最里面的括号呢？

当然是为了优先级啊

那么怎么匹配呢？

import re

strs = input()

ret = re.search("\([^()]+\)", strs)

if ret:

    print(ret.group())

else:

    print(ret)

测试结果：

IN：(1+(1+(1+1)))

OUT:(1+1)
IN:1+1

OUT:None

2.2 操作数的匹配

我们的日常使用中操作数不仅仅只是整形，还有浮点型，所以我们需要考虑的就要多一点

# -*-coding:utf-8 -*-

import re

s = input()

ret = re.search("(?P<num1>\d+(?:\.\d+)?)(?P<sign>[*/])(?P<num2>[+-]?\d+(?:\.\d+)?)", s)

if ret:

    print("exp:%s"%ret.group())

    print("num1:%s"%ret.group("num1"))

    print("sign:%s"%ret.group("sign"))

    print("num2:%s"%ret.group("num2"))

else:

    print(ret)

测试结果：

IN：1*1

OUT:exp:1*1

    num1:1

    sign:*

    num2:1    
IN:1.3/3.2

OUT:exp:1.3/3.2

    num1:1.3

    sign:/

    num2:3.2

3.四则运算

3.1 乘除法

在我们传递完最里面括号的内容后，我们要不断的匹配，计算，替换，直至最后没有括号

思路：

先一直循环，然后不断匹配符合要求的表达式，进行运算，替换，再匹配，直至匹配不到表达式，退出循环

# -*-coding:utf-8 -*-

import re

def div_mul(s):  # 进行表达式中乘或除的计算

    while True:

        ret = re.search("(?P<num1>\d+(?:\.\d+)?)(?P<sign>[*/])(?P<num2>[+-]?\d+(?:\.\d+)?)", s)  # 匹配乘或除的式子，

        # 第二个操作数可以匹配符号，防止比如 1*-3匹配不到

        # 第一个操作数没有匹配符号是因为防止 1-2*-3 --> 1  (-2*-3) --> 1 6 -->在下一个函数中成为 1+6 --> 7  的错误结果

        # ret = re.search("(?P<num1>\d+(?:\.\d+)?)(?P<sign>[*/])(?P<num2>\d+(?:\.\d+)?)", s)

        # if not ret:

        #     ret = re.search("(?P<num1>\d+(?:\.\d+)?)(?P<sign>[*/])(?P<num2>[+-]?\d+(?:\.\d+)?)", s)

        if ret:  # 如果ret不为空就代表表达式中含有加或减的式子

            exp = ret.group()  # 把表达式分离开来

            num1 = ret.group("num1")  # 操作数1

            num2 = ret.group("num2")  # 操作数2

            sign = ret.group("sign")  # 运算符号

            if sign == "*":  # 乘法

                result = float(num1) * float(num2)

            if sign == "/":  # 除法

                result = float(num1) / float(num2)

            print("{}{}{}={}".format(num1, sign, num2, result))  # 运行结果的打印

            s = s.replace(exp, str(result))  # 将计算结果替代表达式

        else:  # 如果ret为空就代表该表达式中已经没有乘或除的式子了，就跳出循环

            break

    s = format_str(s)  # 格式化该字符串中的输出结果

    return s

s = input()

print(div_mul(s))

测试结果：

IN:1+3*2-7*2

OUT:3*2=6.0

    7*2=14.0

    1+6.0-14.0

3.2 加减法

思路：

将表达式中所有的数字分割为 一个操作数加上它前面的符号，最后对这些数进行统一的相加

# -*-coding:utf-8 -*-

import re

import functools




def add_sub(s):  # 进行表达式中加或减的计算

    result = 0  # 先定义一个求和的总变量为0

    if re.search("[+-]", s):

        ret = re.findall("[+/-]?\d+(?:\.\d+)?", s)  # 只匹配一个数字以及该数字前的符号，最后进行相加

        print(ret)  # 打印所匹配的内容，即所有要相加的数

        result = str(functools.reduce(lambda x, y: float(x) + float(y), ret))  # 进行各个数的相加

        print(result)

        s = s.replace(s, result)  # 将计算结果替代表达式

    return s

s = input()

print(add_sub(s))

测试结果：

IN:1-2+3.2+1.7-5.2

OUT:['1', '-2', '+3.2', '+1.7', '-5.2']

    -1.2999999999999998

    -1.2999999999999998

在这我们的四则运算也准备好了，最后我们要做的就是如何把表达式合理的送如四则运算中。

还是不断的进行运算、替换

值得一提的是，算完之后，我们要记得去其括号，进行下一个（）的匹配

    while re.search("\(", strs):  # 如果还有（）就进入循环

        ret = re.search("\([^()]+\)", strs)  # 匹配最里面的（）

        if (ret):

            exp = ret.group()  # 进行表达式的分离

            print(exp)

            result = calc(exp)  # 进行表达式的计算

            strs = strs.replace(exp, result)  # 表达式与结果的替换

            strs = format_str(strs)  # 格式化

            print(strs)

4.完整代码展示：

# -*- coding: UTF-8 -*-

import re

import functools

def format_str(s):  # 格式化字符串

    s = s.replace(" ", "")

    s = s.replace("++", "+")

    s = s.replace("+-", "-")

    s = s.replace("-+", "-")

    s = s.replace("--", "+")

    s = s.replace("/+", "/")

    s = s.replace("*+", "*")

    #    print("该表达式格式化后的结果为：%s" % s)

    return s

def check_str(s):  # 检查字符串是否合法

    flag = True  # 初始化假设字符串合法

    if s.count("(") != s.count(")"):  # 检查（）是否个数相等

        flag = False

    if re.search("[a-zA-Z]", s):  # 检查是否出现了非法字符

        flag = False

    #    print("该表达式的合法性为：%s" % flag)

    return flag

def div_mul(s):  # 进行表达式中乘或除的计算

    while True:

        ret = re.search("(?P<num1>\d+(?:\.\d+)?)(?P<sign>[*/])(?P<num2>[+-]?\d+(?:\.\d+)?)", s)  # 匹配乘或除的式子，

        # 第二个操作数可以匹配符号，防止比如 1*-3匹配不到

        # 第一个操作数没有匹配符号是因为防止 1-2*-3 --> 1  (-2*-3) --> 1 6 -->在下一个函数中成为 1+6 --> 7  的错误结果

        # ret = re.search("(?P<num1>\d+(?:\.\d+)?)(?P<sign>[*/])(?P<num2>\d+(?:\.\d+)?)", s)

        # if not ret:

        #     ret = re.search("(?P<num1>\d+(?:\.\d+)?)(?P<sign>[*/])(?P<num2>[+-]?\d+(?:\.\d+)?)", s)

        if ret:  # 如果ret不为空就代表表达式中含有加或减的式子

            exp = ret.group()  # 把表达式分离开来

            num1 = ret.group("num1")  # 操作数1

            num2 = ret.group("num2")  # 操作数2

            sign = ret.group("sign")  # 运算符号

            if sign == "*":  # 乘法

                result = float(num1) * float(num2)

            if sign == "/":  # 除法

                result = float(num1) / float(num2)

            print("{}{}{}={}".format(num1, sign, num2, result))  # 运行结果的打印

            s = s.replace(exp, str(result))  # 将计算结果替代表达式

        else:  # 如果ret为空就代表该表达式中已经没有乘或除的式子了，就跳出循环

            break

    s = format_str(s)  # 格式化该字符串中的输出结果

    return s

def add_sub(s):  # 进行表达式中加或减的计算

    result = 0  # 先定义一个求和的总变量为0

    if re.search("[+-]", s):

        ret = re.findall("[+/-]?\d+(?:\.\d+)?", s)  # 只匹配一个数字以及该数字前的符号，最后进行相加

        print(ret)  # 打印所匹配的内容，即所有要相加的数

        result = str(functools.reduce(lambda x, y: float(x) + float(y), ret))  # 进行各个数的相加

        print(result)

        s = s.replace(s, result)  # 将计算结果替代表达式

    return s

def calc(s):  # 进行表达式的计算

    s = div_mul(s)

    s = add_sub(s)

    # s = s.replace("(", "")#去括号

    # s = s.replace(")", "")

    s = s.strip("()")  # 去括号

    print("该表达式计算后的结果为：%s" % s)

    return s

def main():

    strs = input()

    while not check_str(strs):

        print("非法表达式！请重新输入")

        strs = input()

    strs = format_str(strs)

    while re.search("\(", strs):  # 如果还有（）就进入循环

        ret = re.search("\([^()]+\)", strs)  # 匹配最里面的（）

        if (ret):

            exp = ret.group()  # 进行表达式的分离

            print(exp)

            result = calc(exp)  # 进行表达式的计算

            strs = strs.replace(exp, result)  # 表达式与结果的替换

            strs = format_str(strs)  # 格式化

            print(strs)

    strs = calc(strs)

    print(strs)

main()

print(eval("1-2*((60-30 +(9-2*5/3+7/3*99/4*2998+10*568/14)*(-40 / 5))-(-4*3)/(16-3*2))"))

# 1-2*((60-30 +(9-2*5/3+7/3*99/4*2998+10*568/14)*(-40 / 5))-(-4*3)/(16-3*2))

# 2776672.6952380957

运行结果：

IN: 1-2*((60-30 +(9-2*5/3+7/3*99/4*2998+10*568/14)*(-40 / 5))-(-4*3)/(16-3*2))

OUT:(9-2*5/3+7/3*99/4*2998+10*568/14)

    2*5=10.0

    10.0/3=3.3333333333333335

    7/3=2.3333333333333335

    2.3333333333333335*99=231.00000000000003

    231.00000000000003/4=57.75000000000001

    57.75000000000001*2998=173134.50000000003

    10*568=5680.0

    5680.0/14=405.7142857142857

    ['9', '-3.3333333333333335', '+173134.50000000003', '+405.7142857142857']

    173545.88095238098

    该表达式计算后的结果为：173545.88095238098

    1-2*((60-30+173545.88095238098*(-40/5))-(-4*3)/(16-3*2))

    (-40/5)

    40/5=8.0

    ['-8.0']

    -8.0

    该表达式计算后的结果为：-8.0

    1-2*((60-30+173545.88095238098*-8.0)-(-4*3)/(16-3*2))

    (60-30+173545.88095238098*-8.0)

    173545.88095238098*-8.0=-1388367.0476190478

    ['60', '-30', '-1388367.0476190478']

    -1388337.0476190478

    该表达式计算后的结果为：-1388337.0476190478

    1-2*(-1388337.0476190478-(-4*3)/(16-3*2))

    (-4*3)

    4*3=12.0

    ['-12.0']

    -12.0

    该表达式计算后的结果为：-12.0

    1-2*(-1388337.0476190478+12.0/(16-3*2))

    (16-3*2)

    3*2=6.0

    ['16', '-6.0']

    10.0

    该表达式计算后的结果为：10.0

    1-2*(-1388337.0476190478+12.0/10.0)

    (-1388337.0476190478+12.0/10.0)

    12.0/10.0=1.2

    ['-1388337.0476190478', '+1.2']

    -1388335.8476190479

    该表达式计算后的结果为：-1388335.8476190479

    1-2*-1388335.8476190479

    2*-1388335.8476190479=-2776671.6952380957

    ['1', '+2776671.6952380957']

    2776672.6952380957

    该表达式计算后的结果为：2776672.6952380957

    2776672.6952380957

    2776672.6952380957

在这，为了比对运算结果是否正确，笔者特地拿了 eval 进行计算，显然测试后：两结果相同

最新文章

  1. 学习javascript数据结构(一)——栈和队列
  2. 基于Dubbo框架构建分布式服务（二）
  3. RABBITMQ（小总结 持续更新...
  4. poj 3352Road Construction（无向双连通分量的分解）
  5. Quartz任务调度器
  6. 删除ecshop登录后台看到的系统信息
  7. 转: Div与table的区别
  8. Python和Django在Windows上的环境搭建
  9. [转载]GDB十分钟教程
  10. TP框架多表联查
  11. intellj idea maven 无效的目标发行版: 1.8
  12. TensorFlow 深度学习笔记 从线性分类器到深度神经网络
  13. 怎么限制Google自己主动调整字体大小
  14. hive支持sql大全
  15. SIM卡信息的管理
  16. Redis中的数据对象
  17. mongodb 在windows下面进行分片
  18. 使用ACR122U NFC读卡器对M1卡进行读写操作（可以读写中文）
  19. solr索引报错(java.lang.OutOfMemoryError：GC overhead limit exceeded)
  20. 引入CSS的三种方式

热门文章

  1. SpringCloud及其组件详解
  2. UML——状态图
  3. Java 复习整理day08
  4. Effective Java读书笔记--类和接口
  5. Flink-v1.12官方网站翻译-P007-Data Pipelines &amp; ETL
  6. Web APP和原生 APP的不同
  7. 通过SignalR技术整合即时通讯(IM)在.NET中应用落地
  8. zoj2112 Dynamic Rankings （主席树 || 树套树）
  9. AT1219 歴史の研究 回滚莫队
  10. JavaScript函数console、this关键字