百度松果菁英班——机器学习实践二：简单计算器实现

最新推荐文章于 2024-07-27 12:20:46 发布

杜若南星

最新推荐文章于 2024-07-27 12:20:46 发布

阅读量1.1k

点赞数 19

分类专栏：百度松果菁英班课程学习文章标签： python 开发语言笔记机器学习算法百度经验分享

本文链接：https://blog.csdn.net/qq_63349644/article/details/137436303

版权

百度松果菁英班课程学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

本文介绍了如何使用Python编写一个计算器，包括计算函数、判断元素是数字还是运算符的函数、处理算式成列表以及决策函数来决定栈的操作。通过正则表达式处理算式，展示了如何在AIStudio星河社区中的机器学习项目中应用这些技术。

摘要由CSDN通过智能技术生成

飞桨AI Studio星河社区-人工智能学习与实训社区

🦐将计算器抽象成几个函数

弹栈时计算两个数字和运算符组成的算式结果的函数。
判断元素是数字还是运算符的函数。
把算式处理成列表形式的函数。如：-1-2*((-2+3)+(-2/2))应该处理成：[-1, - , 2, * , (, (, -2, +, 3, ), +, (, -2, /, 2, ), )] 。
决策函数，决定应该是入栈，弹栈运算，还是弹栈丢弃。
主函数，遍历算式列表，计算最终结果。

🦐编写计算器的各个函数

🐡导入库

import re

re是用于处理正则表达式的模块。正则表达式是一种强大的工具，用于在字符串中搜索、匹配和替换文本模式。

🐡1计算函数（calculate）

def calculate(n1, n2, operator):
    '''
    :param n1: float
    :param n2: float
    :param operator: + - * /
    :return: float
    '''
    result = 0
    if operator == "+":
        result = n1 + n2
    if operator == "-":
        result = n1 - n2
    if operator == "*":
        result = n1 * n2
    if operator == "/":
        result = n1 / n2
    return result

传入两个数字，一个运算符，根据运算符不同返回相应结果。即计算加减乘除

🐡2判断元素成分函数（is_operator）

# 判断是否是运算符，如果是返回True
def is_operator(e):
    '''
    :param e: str
    :return: bool
    '''
    opers = ['+', '-', '*', '/', '(', ')']
    return True if e in opers else False

🐡3算式处理成列表函数（formula_format）

# 将算式处理成列表，解决-是负数还是减号
def formula_format(formula):
    # 去掉算式中的空格
    formula = re.sub(' ', '', formula)
    # 以 '横杠数字' 分割， 其中正则表达式：(\-\d+\.?\d*) 括号内：
    # \- 表示匹配横杠开头； \d+ 表示匹配数字1次或多次；\.?表示匹配小数点0次或1次;\d*表示匹配数字1次或多次。
    formula_list = [i for i in re.split('(\-\d+\.?\d*)', formula) if i]
 
    # 最终的算式列表
    final_formula = []
    for item in formula_list:
        # 第一个是以横杠开头的数字（包括小数）final_formula。即第一个是负数，横杠就不是减号
        if len(final_formula) == 0 and re.search('^\-\d+\.?\d*$', item):
            final_formula.append(item)
            continue
 
        if len(final_formula) > 0:
            # 如果final_formal最后一个元素是运算符['+', '-', '*', '/', '('], 则横杠数字不是负数
            if re.search('[\+\-\*\/\(]$', final_formula[-1]):
                final_formula.append(item)
                continue
        # 按照运算符分割开
        item_split = [i for i in re.split('([\+\-\*\/\(\)])', item) if i]
        final_formula += item_split
    return final_formula

formula = re.sub(' ', '', formula)将空格替换为空字符，即实现去掉空字符
formula_list = [i for i in re.split('(\-\d+\.?\d*)', formula) if i]根据指定的正则表达式模式对字符串进行分割，并返回一个列表；if i用于确定i是否是空字符，for i in ……是遍历表达式中的所有i，最前边的i是对i的简单保留
re.search('^\-\d+\.?\d*$', item)在字符串中搜索指定的正则表达式模式，并返回第一个匹配到的结果
将item放入final_formula中：
- 如果 final_formula 列表为空且 item 是以横杠开头的数字（即负数），则将 item 加入 final_formula。
- 如果 final_formula 列表不为空，且 final_formula 最后一个元素是运算符（'+', '-', '*', '/', '('）则说明横杠数字不是负数，直接将 item 加入 final_formula。
- 否则，将 item 按照运算符进行再次分割，并将分割后的结果加入 final_formula。

🐡4决策函数（decision）

def decision(tail_op, now_op):
    '''
    :param tail_op: 运算符栈的最后一个运算符
    :param now_op: 从算式列表取出的当前运算符
    :return: 1 代表弹栈运算，0 代表弹运算符栈最后一个元素， -1 表示入栈
    '''
    # 定义4种运算符级别
    rate1 = ['+', '-']
    rate2 = ['*', '/']
    rate3 = ['(']
    rate4 = [')']
 
    if tail_op in rate1:
        if now_op in rate2 or now_op in rate3:
            # 说明连续两个运算优先级不一样，需要入栈
            return -1
        else:
            return 1
 
    elif tail_op in rate2:
        if now_op in rate3:
            return -1
        else:
            return 1
 
    elif tail_op in rate3:
        if now_op in rate4:
            return 0   # ( 遇上 ) 需要弹出 (，丢掉 )
        else:
            return -1  # 只要栈顶元素为(，当前元素不是)都应入栈。
    else:
        return -1

如果栈顶运算符是加法或减法，当前运算符是乘法、除法或左括号，说明当前运算符的优先级高，需要入栈，返回 -1。
如果栈顶运算符是乘法或除法，当前运算符是左括号，说明当前运算符的优先级高，需要入栈，返回 -1。
如果栈顶运算符是左括号，当前运算符是右括号，说明括号内的表达式已经计算完毕，应该弹出左括号，返回 0。
其他情况下，当前运算符应该入栈，返回 -1。

🐡5主函数（final_calc）

def final_calc(formula_list):
    num_stack = []       # 数字栈
    op_stack = []        # 运算符栈
    for e in formula_list:
        operator = is_operator(e)
        if not operator:
            # 压入数字栈
            # 字符串转换为符点数
            num_stack.append(float(e))
        else:
            # 如果是运算符
            while True:
                # 如果运算符栈等于0无条件入栈
                if len(op_stack) == 0:
                    op_stack.append(e)
                    break
 
                # decision 函数做决策
                tag = decision(op_stack[-1], e)
                if tag == -1:
                    # 如果是-1压入运算符栈进入下一次循环
                    op_stack.append(e)
                    break
                elif tag == 0:
                    # 如果是0弹出运算符栈内最后一个(, 丢掉当前)，进入下一次循环
                    op_stack.pop()
                    break
                elif tag == 1:
                    # 如果是1弹出运算符栈内最后两个元素，弹出数字栈最后两位元素。
                    op = op_stack.pop()
                    num2 = num_stack.pop()
                    num1 = num_stack.pop()
                    # 执行计算
                    # 计算之后压入数字栈
                    num_stack.append(calculate(num1, num2, op))
    # 处理大循环结束后 数字栈和运算符栈中可能还有元素 的情况
    while len(op_stack) != 0:
        op = op_stack.pop()
        num2 = num_stack.pop()
        num1 = num_stack.pop()
        num_stack.append(calculate(num1, num2, op))
 
    return num_stack, op_stack

判断当前元素是数字还是运算符：
- 是数字，压入数字列表
- 是运算符
  - 如果运算符栈为0那直接压入
  - 不为0，调用决策函数判断栈中操作符和当前操作符的关系
    - 如果是-1，直接压入
    - 如果是0，弹出左括号并进入下一个循环（因为该情况证明本轮符号是)，弹出栈中的(后就不用再有操作了）
    - 如果是1，弹出两个数和运算符进行计算，然后将计算结果压入到

如果处理大循环结束后运算符栈和数字栈内还有元素，那么就直接取出数字和操作符计算并加入数字栈

🐡6main函数

if __name__ == '__main__':
    formula = input('请输入：\n')
    # formula = "1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2))"
    print("算式：", formula)
    formula_list = formula_format(formula)
    result, _ = final_calc(formula_list)
    print("计算结果：", result[0])