20212218 实验二《Python程序设计》实验报告-百木园

# 20212218 2021-2022-2 《Python程序设计》实验二报告

课程：《Python程序设计》
班级： 2122
姓名：林思凡
学号：20212218
实验教师：王志强
实验日期：2022年4月5日
必修/选修：公选课

## 1.实验内容
运用老师上课讲的知识，外加上CSDN查找并潜心钻研的拓展知识，完成一个简易计算器
计算器功能如下：
- 进行单次普通二元运算，运算符包括+、-、*、/、%、//、**等
- 进行单词普通复数运算，运算符包括+、-、*、/
- 进行一串四则运算的结果输出（这是在CSDN上学的，绝对不是无条件照抄，每一步都理解了，花了我相当长时间）

## 2. 实验过程及结果
- 第一步，构造整体框架，包括普通计算、复数计算和四则运算三个方面。

- 第二步，完成普通运算框架搭建，这一步王老师在课堂上已有所提及，我在此基础上进行了完善，提高了此程序的容错率。

比如，输入/、%、//运算符时，若除数为0则会报错。因此加入if条件判断语句避免除数为0的情况。

- 第三步，完成复数运算框架搭建，这一步与普通运算的框架搭建方法大同小异，只不过要记住复数要引用complex()函数，且复数的形式为a+bj，而非a+bi。

- 第四步，开始搭建四则运算框架（结果如图），这一步花费了整个程序%80的时间，在此展开叙述

- 4-1，首先引入re模块的findall()函数，将字符串形式的四则运算式子分隔字符，储存在一个列表中。

- 4-2，将四则运算式子中小括号内的式子进行运算，然后删去括号。

- 4-3，计算四则运算式子中的乘除运算。

- 4-4，计算四则运算式子中的加减运算。

- 4-5，框架搭建完毕，开始进行细化和完善。

- 4-5-1，运用if条件控制语句，避免出现两个运算符同时出现的情况，如\"2+(-3)\"去除括号之后会变成2+-3，这时需要去掉加号。

- 第五步，整体框架搭建完成，开始进行整体细化。比如运用while语句给每一个部分做一个返回键和退出键。程序到这里基本完成。

成品完整程序如下（会托管到码云）：

import re

flag1 = 1
while flag1 == 1:
    choice = input(\"请选择您想要的计算器类型(0为简单普通计算器、1为复数计算器、2为四则运算计算器、输入E/e退出): \\n\")
    if choice == \"E\" or choice == \"e\":
        break
    if choice == \"0\":
        flag2 = 1
        while flag2 == 1:
            op = input(\"请输入需要做的操作(+、-、*、/、%、//、**、输入e返回上一级、输入E退出):\\n\")
            if op == \"e\":
                break
            if op == \"E\":
                flag1 = 0
                break
            a = int(input(\"请输入操作数a:\"))
            b = int(input(\"请输入操作数b:\"))
            if op == \"+\":
                result = a + b
            elif op == \"-\":
                result = a - b
            elif op == \"*\":
                result = a * b
            elif op == \"/\":
                if b == 0:
                    print(\"除数不能为0!请重新输入!\\n\")
                    continue
                else:
                    result = a / b
            elif op == \"%\":
                if b == 0:
                    print(\"除数不能为0!请重新输入!\\n\")
                    continue
                else:
                    result = a % b
            elif op == \"//\":
                if b == 0:
                    print(\"除数不能为0!请重新输入!\\n\")
                    continue
                else:
                    result = a // b
            elif op == \"**\":
                result = a ** b
            else:
                print(\"输入有误，请重新输入！\\n\")
                continue
            print(a, op, b, \"=\", result)
        

    elif choice == \"1\":
        flag3 = 1
        while flag3 == 1:
            op = input(\"请输入需要做的操作(+、-、*、/、输入e返回上一级、输入E退出):\\n\")
            if op == \"e\":
                break
            if op == \"E\":
                flag1 = 0
                break

            a = complex(input(\"请输入第一个复数(形式为a+bj):\"))
            b = complex(input(\"请输入第二个复数(形式为a+bj):\"))
            result = 0
            if op == \"+\":
                result = a + b
            elif op == \"-\":
                result = a - b
            elif op == \"*\":
                result = a * b
            elif op == \"/\":
                result = a / b
            else:
                print(\"输入有误，请重新输入！\\n\")
            print(a, op, b, \"=\", result)

    if choice == \'2\':
        flag4 = 1
        while flag4 == 1:
            a = input(\"请输入一个四则运算式，我们将为您一步解出答案输入(输入e返回上一级、输入E退出):\\n\")
            if a == \"e\":
                break
            if a == \"E\":
                flag1 = 0
                break

            def division(n):
                list1 = re.findall(\'[\\d\\.]+|\\(|\\+|\\-|\\*|\\/|\\)\', n)
                return list1


            def change(n, m):
                if n[m] == \'-\':
                    if n[m - 1] == \'+\':
                        n[m - 1] = \'-\'
                        del n[m]
                    elif n[m - 1] == \'-\':
                        n[m - 1] = \'+\'
                        del n[m]
                return n


            def senior(n):
                s_count = 0

                for i in n:
                    if i == \'*\':
                        if n[s_count + 1] != \'-\':  
                            n[s_count - 1] = float(n[s_count - 1]) * float(n[s_count + 1])
                            del n[s_count]
                            del n[s_count]
                        elif n[s_count + 1] == \'-\': 
                            n[s_count] = float(n[s_count - 1]) * float(n[s_count + 2])
                            n[s_count - 1] = \'-\'
                            del n[s_count + 1]
                        n = change(n, s_count - 1)
                        return senior(n)

                    elif i == \'/\':
                        if n[s_count + 1] != \'-\':  # 3*2
                            n[s_count - 1] = float(n[s_count - 1]) / float(n[s_count + 1])
                            del n[s_count]
                            del n[s_count]
                        elif n[s_count + 1] == \'-\':  # 3*-2
                            n[s_count] = float(n[s_count - 1]) / float(n[s_count + 2])
                            n[s_count - 1] = \'-\'
                            del n[s_count + 1]
                        n = change(n, s_count - 1)
                        return senior(n)
                    s_count = s_count + 1

                return n


            def junior(n):
                j_count = 0
                if n[0] == \'-\':
                    sum = 0
                else:
                    sum = float(n[0])

                for i in n:
                    if i == \'-\':
                        sum = sum - float(n[j_count + 1])
                    if i == \'+\':
                        sum = sum + float(n[j_count + 1])
                    j_count = j_count + 1

                if sum >= 0:
                    n = [str(sum)]
                else:
                    n = [\'-\', str(-sum)]
                return n


            def calculate(n):
                if \'*\' in n or \'/\' in n:
                    n = senior(n)
                if \'+\' in n or \'-\' in n:
                    n = junior(n)
                return n


            def no_bracket(n):
                left_bracket = 0
                count = 0
                for i in n:
                    if i == \'(\':
                        left_bracket = count
                    if i == \')\':
                        part = n[left_bracket + 1: count]
                        resule_of_part = calculate(part)
                        n = n[: left_bracket] + resule_of_part + n[count + 1:]
                        n = change(n, left_bracket)
                        return no_bracket(n)
                    count = count + 1
                return n

            def main(n):
                n_list = division(n)
                n_list1 = no_bracket(n_list)
                answer = calculate(n_list1)
                if len(answer) == 2:
                    answer = -float(answer[1])
                else:
                    answer = float(answer[0])
                return answer
            b = main(a)
            print(f\"{a} = {b}\")

## 3. 实验过程中遇到的问题和解决过程
- 问题1：查阅代码时，不清楚什么是re模块
- 问题1解决方案：查阅csdn相关资料，了解re模块是一个字符匹配模块，依次拿出表达式和文本中的字符比较，如果每一个字符都能匹配，则匹配成功；一旦有匹配不成功的字符则匹配失败。如果表达式中有量词或边界，这个过程会稍微有一些不同。

- 问题2：查阅代码时，不了解re模块中的findall()函数
- 问题2解决方案：查阅csdn相关资料，了解findall()函数时一条用于多次查找匹配字符的函数，与re模块中的match()和search()不同，后两者只返回第一个匹配的字符。

- 问题3：初次使用re模块的findall()函数时，出现报错TypeError: expected string or bytes-like object
- 问题3解决方案：上CSDN查阅相关报错，发现findall语句参数只能是字符串，然后才返回一个列表；检查自己的程序时发现在参数中引入了列表，改成字符串之后便正常运行。

- 问题4：查阅代码时，不了解递归函数
- 问题4解决方案：查阅csdn相关资料，了解到，递归就是在运行的过程中调用自己。
构成递归需具备的条件：
1、子问题须与原始问题为同样的事，且更为简单；
2、不能无限制地调用本身，须有个出口，化简为非递归状况处理。

- 问题5：测试四则运算时，发现负数会自动转成正数造成计算错误
- 问题5解决方案：多次调试，发现两出问题，第一处是\"或\"条件判断书写存在错误；第二处是在一处计算当中忘记添加负号，改正之后解决，程序运行正常。

## 其他（感悟、思考等）

1. 调试真的非常非常好用！此次程序编写行数为188行。当你面对一大堆代码找不出问题所在时，不要犹豫，进行调试！通过调试，你能洞悉代码每一步的运行情况，运筹帷幄，掌握全局，揪出漏洞，及时填补！

2. 网络是非常好非常好的学习平台，在这里你能够获得程序员大佬们悉心传授的知识，并且受益无穷！本次计算器设计的四则运算部分，就是在我深入剖析大佬的代码之后，恍然大悟才写出来的。

## 参考资料

- [什么是递归，通过这篇文章，让你彻底搞懂递归](https://blog.csdn.net/abcdef314159/article/details/107906395?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164912286116780269818899%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=164912286116780269818899&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-2-107906395.142^v5^pc_search_result_control_group,157^v4^control&utm_term=%E9%80%92%E5%BD%92&spm=1018.2226.3001.4187)

- [python——正则表达式(re模块)详解](https://blog.csdn.net/guo_qingxia/article/details/113979135?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164912120316780274154982%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=164912120316780274154982&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-113979135.142^v5^pc_search_result_control_group,157^v4^control&utm_term=re%E6%A8%A1%E5%9D%97&spm=1018.2226.3001.4187)

- [如何简单地理解Python中的if __name__ == \'__main__\'](https://blog.csdn.net/yjk13703623757/article/details/77918633?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164913249116780271929101%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=164913249116780271929101&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-77918633.142^v5^pc_search_result_control_group,157^v4^control&utm_term=+if+__name__+%3D%3D+__main__%3A&spm=1018.2226.3001.4187)

- [项目3：python实现一个简易计算器](https://blog.csdn.net/a971956955/article/details/81489914?ops_request_misc=&request_id=&biz_id=102&utm_term=python%E8%AE%A1%E7%AE%97%E5%99%A8&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-1-81489914.nonecase&spm=1018.2226.3001.4187)

来源：https://www.cnblogs.com/clarleslinnn/p/16102741.html
本站部分图文来源于网络，如有侵权请联系删除。

20212218 实验二《Python程序设计》实验报告

相关推荐

热门文章