re模塊之簡單計算器的實現

時間  2021-02-21
標籤 函數 學習 測試 spa code orm blog utf-8 字符串 欄目 Java 简体版
原文   原文鏈接

本節大綱：函數

 

  1. 表達式的輸入及檢查、格式化
  2. 怎麼樣進行匹配最裏面的括號以及操做數的匹配
  3. 如何實現表達式的四則運算
  4. 完整代碼展現

 

在咱們學習re模塊以後，一般的練習就是利用所學相關知識來寫一個計算器學習

那麼，如今咱們開始理一下思路：測試

1.表達式的輸入及檢查、格式化

1.1 輸入

首先呢，咱們確定要讓用戶先輸入一個表達式spa

strs = input()

 

1.2 檢查

以後，咱們要作的就是檢查所輸入內容的合法性，這裏咱們用一個函數來封裝code

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

所相應的匹配程序orm

    while not check_str(strs):
        print("非法表達式！請從新輸入")
        strs = input()

測試結果：blog

IN:(1+1
OUT:非法表達式！請從新輸入
IN:1+2p
OUT:非法表達式！請從新輸入
IN:2+3
OUT:

固然，在上述代碼中，非法字符的檢測並不完善，這確定須要改善，具體思路爲：ip

 在咱們輸入表達式的時候，所輸入的字符無非就以下幾種狀況：utf-8

  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 進行計算，顯然測試後：兩結果相同

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程