精华内容
下载资源
问答
  • python普通计算器
    2021-03-15 09:40:21

    摘要

    最近更新时间:2021.02.07(等待更新全部功能,定时优化更新,CSDN手机APP显示代码不全,为提供更好的阅读请用电脑打开)
    本文类型:实践应用类(非知识讲解)
    不同于网络上的python制作计算器的方法,本文使用先易后难的方式制作自定义版计算器,使读者能够了解每一步代码的意义,通过制作计算器大致了解tkinter库的强大。
    一、本文知识点:1.python,2.python tkinter界面编程。
    二、本文结构:1.先简略介绍知识点,2.按完整段的方式贴出复制后可直接运行的调试代码,方便读者调试贴出的每段代码
    三、本文方法实现方

    更多相关内容
  • Python简单计算器实现

    千次阅读 2022-03-09 16:44:12
    简单计算器实现

    Python简单计算器实现

    不同于普通前缀表达式和后缀表达式的实现方法,将算式转换为前缀或后缀表达式,存入一个栈中,当弹出运算符时判断是否需要运算。
    本方法采用两个栈,运算符栈和运算数栈,无需转换表达式为前缀或后缀表达式

    抽象出几个函数:

    (1)弹栈时计算‘两个数字和运算符组成的算式’结果的函数。

    (2)判断元素是数字还是运算符的函数。

    (3)把算式处理成列表形式的函数。如:’-1-2*((-2+3)+(-2/2))’ 应该处理成:[’-1’, ‘-’, ‘2’, ‘*’, ‘(’, ‘(’, ‘-2’, ‘+’, ‘3’, ‘)’, ‘+’, ‘(’, ‘-2’, ‘/’, ‘2’, ‘)’, ‘)’] 。

    (4)决策函数,决定应该是入栈,弹栈运算,还是弹栈丢弃。

    (5)主函数,遍历算式列表,计算最终结果。

    导入需要的包

    import re
    

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

    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
    

    判断是否是运算符,如果是返回True

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

    将算式处理成列表,解决-是负数还是减号

    # 将算式处理成列表,解决-是负数还是减号
    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
    

    决策函数,决定应该是入栈,弹栈运算,还是弹栈丢弃。

    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
    

    主函数,遍历算式列表,计算最终结果。

    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
    

    测试一下

    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])
    

    运行结果

    算式: 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2))
    计算结果: 2776672.6952380957
    
    展开全文
  •  2、关于如何讲普通的表达式转换成后缀表达式,以及如何处理后缀表达式并计算出结果的具体算法描述不在此叙述了,书上有详细的说明。 二、简易计算器 使用说明 使用该计算器类的简单示例如下: # usage c = ...
  • 个性计算器(可不断加挂功能模块实现个性化)(python实现)

    Python 官网 https://www.python.org/


      这里,才 python 前沿。可惜是英文原版。所以,我要练习英文阅读。🧐🧐


      自学并不是什么神秘的东西,一个人一辈子自学的时间总是比在学校学习的时间长,没有老师的时候总是比有老师的时候多。

                —— 华罗庚



    练习:个性计算器


    1. 计算器主界面
    2. 菜单显示
    3. 退出菜单
    4. 菜单确认
    5. 简单计算器
    6. 加挂其她功用
    7. 完整代码

      看到大佬博文《【C语言】计算器》,诱发我也想 py 一个。
      设想:我还不会 gui 界面编码,就只能码个程序 print Menus 的了。
      鉴于 python 有 eval() 内置函数,她可以把字符串转化为代码语句并执行,所以“计算器”的简单计算直接输入四则混合运算的式子(数学表达式)就可以了。input() 接收输入字符串,直接调用 eval() 计算输出结果,实现简单的“四则混合运算”。
      对于乘方开方对数三角函数等高级计算,就需加载 python 的 math 的相应方法。还可以做一些个性计算,比如圆周长面积、长方体表面积体积(正方体是特殊的长方体,可以不单列)……可以尽情释放您的思绪。🤪🤪
      对于写代码样式,我更喜欢函数式编程。当然采用自定义函数编写功能模块了。

      通过一天的“业余”调试,我炼的 python 版“计算器”,基本可以上“笔记”了。🤗🤗


    回首页


    计算器主界面

    在这里插入图片描述
    代码

    def main():
        '''计算器主执行代码块'''    
        while True: # 菜单列印和确认死循环,不主动退出就一直执行循环。
            clear() 
            menu_show() # 屏幕打印菜单。
            is_menu() # 菜单选择。
    

    回首页


    菜单列印

      这次不象以前练习,设计为动态菜单列表。如需添加菜单项,只需把菜单项字符串放在列表相应位置就好。
    (注意:增加菜单后,记得到“菜单确认”模块修改 range() 合法菜单选择范围,不然无法选中新增菜单序号。并增添相应的 elif 选项。)

    代码

    def menu_show():
        '''菜单打印模块,无需参数传递'''
        menus = ('简单计算', '素数查找', '退出') # 这次不象以前练习,设计为动态菜单列表。如需添加菜单项,只需把菜单项字符串放在列表相应位置就好。(注意:增加菜单后,记得到“菜单确认”模块修改 range() 合法菜单选择范围,不然无法选中新增菜单序号。并增添相应的 elif 选项。)
        print(f"\n\n{color(1, 'f_green')}{'':*^41}\n{'星月计算器':^36}\n{'(Stars&Moon Calculator)':^42}\n{'【':>10}{localtime_show()}】\n{'':-^41}{color(0)}")
        for k,i in enumerate(menus): # 遍历枚举函数 enumerate() ,方便列印菜单序号。
            if i != '退出':
                print(f"\n{k+1:>16}. {i}")
            else:
                exit_s = f" {0}. {i} "
                print(f"\n{'':>13}{exit_s:=^13}")
        print(f"\n{color(1, 'f_green')}{'':-^41}\n{'Author:Dream-elf_cq':^41}{'(梦幻精灵_cq)':^37}\n{'':*^41}{color(0)}")
    

    回首页


    退出菜单

    在这里插入图片描述

    代码

    if menu == 0: # 0. 退出
            clear() 
            print(f"{cut_line()}{color(' 欢迎下次使用“星月计算器” ', 'f_purple'):=^39}{cut_line()}")
            exit() 
    

    回首页


    菜单确认

    def is_menu():
        '''菜单确认'''
        while True:
            try: # 菜单选择错误捕获。
                menu = int(input(f"\n\n{'菜单选择:':>12}"))
                if menu not in range(3): # 合法菜单选择序号范围设定。
                    error_show()
                    input(f"\n{'错误类型:没有此项菜单!':-^29}")
                break
            except Exception as error:
                error_show() 
                input(f"\n错误类型:{error}")
        # 菜单项增加后,就得增加一个 elif 。
        if menu == 0: # 0. 退出
            exit() 
        elif menu == 1: # 1. 简单计算器
            less_count()
        elif menu == 2: # 2. 素数查找
            find_primes()
    

    回首页


    简单计算器

      虽言简单计算器,但只要是符合 python 规范的表达式,都能有结果输出。
      这,足见 eval() 之强了吧。🤪🤪

    在这里插入图片描述

    注意:由于 {}、[ ] 在python 中另有定义,所以在本“计算器”中输入计算表达式, {}、[ ] 皆用成对的 () 替代,不影响结果输出(这也符合 python 规范)。所以,我规定了“计算器”的“计算表达式”字符集,超出范围报错重输。

    如:

    ------简单计算器(数学四则混合运算)-------

    计算表达式输入:(2*(6-(2+2)))

        结果:4.0000
    

    另:本“计算器”从 python “脱模”而来,所以“计算表达式”“无视”空格的存在(英文空格)。
    如:

    在这里插入图片描述

      虽然三种写法一样,但我建议第一种( python 风格的“标准”写法);千万别写成第三种,虽然也能得相同结果,但看着“别扭”不是。😜
      还可以完成乘方开方等“高级”一点儿的操作。😜😜

    在这里插入图片描述

      计算 3 的平方、16 的平方根、81 的四次方根。(求 n 次方根,不要写成 “16 ** 1/2”、“81 ** 1/4”,那样就成了“16 的一次方除以 2 ”、“81 的一次方除以 4 ”。)

    代码

    def less_count(): # 虽言简单计算器,但只要是符合 python 规范的表达式,都能有结果输出。这,足见 eval() 之强了吧。🤪🤪
        s = '''简单计算器(数学四则混合运算)'''
        
        def in_rules():
            '''解析计算表达式合规符号集群'''
            rules = [] # 计算表达式字符规则列表
            rules.extend([str(i) for i in range(10)]) # 10 个数字。
            rules.extend(list(' +-*/()')) # 运算符号。
            rules.extend([chr(i) for i in range(65,91)]) # 英文大写字母。
            rules.extend([chr(i) for i in range(97,123)]) # 英文小写字母。
            return tuple(rules)
            
        #print(f"\n\n计算表达式合法字符集:\n")
        #print(*in_rules()) # * 号打破“容器”(tuple)元素列印。(打印 in_rules 后注释掉了。)
        while True:
            in_s = input(f"\n\n{s:-^28}\n\n\n{'计算表达式输入:'}")
            if in_s == '':
                return 
            for i in list(in_s):
                if i not in in_rules():
                    error_show()
                    input(f"\n{'错误类型:输入非法字符!':-^29}")
            else:
                break          
        input(f"\n\n{'结果:':>12}{eval(in_s):.4f}\n\n{'':*^41}") # 我设定 eval() 函数计算数学表达式结果为四位小数({:.4f}),可自行更改。
        less_count() # 自调用,“另类”替代循环。
    

    回首页

    加载更多功用



    素数查找


    菜单

    在这里插入图片描述
    效果

    在这里插入图片描述

    代码

    def find_primes():
        s = '''素数查找'''
    
        clear() 
        gui_head()
        
        def isprime(n): # 内层函数
            '''素数判定'''
            for i in range(2, n):
                if n%i == 0:
                    return # 非素数,返回 None 。
            return n # 是素数,返回该数。
                
        while True:
            try: # 输入素数限定范围错误捕获。
                in_s = input(f"\n\n{s:-^37}\n\n\n{'输入范围(10~500):':>12}")
                if in_s == '':
                    return 
                in_num = int(in_s)
                if in_num not in range(10, 501):
                    error_show()
                    input(f"\n{'错误类型:输入超出范围!':-^29}")
                else:
                    break
            except Exception as error:
                error_show() 
                input(f"\n错误类型:{error}")
        primes = [str(i) for i in range(2, in_num+1) if isprime(i)] # 用内层函数解析给定范围的素数。
        input(f"\n\n从 2 到 {in_num}的素数有:\n\n{','.join(primes)}\n\n{'':*^41}")
        return in_s
    

    回首页


    长方体计算


    菜单
    在这里插入图片描述
    效果

    在这里插入图片描述

    代码

    def cuboid():
        s = '''长方体相关计算'''
        clear() # 清屏调用。
        gui_head() # 计算器界面头调用。
        while True:
            try: # 输入素数限定范围错误捕获。
                in_s = input(f"\n\n{s:-^34}\n\n\n{'输入棱长(a b c):':>12}").strip()
                if in_s == '':
                    return 
                abc_list = [float(i) for i in in_s.split(' ')]            
                flag = False # 输入错误循环标识。
                for i in abc_list:
                    if i <= 0:
                        error_show()
                        input(f"\n{'错误类型:棱长为 Zero or Negative !':^31}")
                        flag = True
                        break
                if flag is True:
                    continue
                a, b, c = abc_list
                break
            except Exception as error:
                error_show() 
                input(f"\n错误类型:{error}")
    
        c12 = round(4 * (a + b + c), 2) # 棱长和。
        s6 = round(2 * (a*b + a*c + b*c), 2) #表面积。
        v = round(a * b * c, 2) #体积。
        input(f"{cut_line()}{'长方体:':>12}{a:>6}×{b}×{c}\
    \n\n{'棱长和:':>12}{color(str(c12), 'f_green'):>22}\
    \n\n{'表面积:':>12}{color(str(s6), 'f_green'):>22}\
    \n\n{'体积:':>13}{color(str(v), 'f_green'):>22}{cut_line()}")
        return in_s
    

    回首页


    圆计算

      圆计算模块,可以根据输入的半径,输出直径和面积。面积所用π,是取的math模块中的常数pi,用于普通计算,已足够精确,结果保留两位小数(用round()取约)。

    在这里插入图片描述

    在命令行模式下试炼,看到 math.pi 取值,已有15位小数,对于普通计算已然“精益求精”。😀😀

    菜单

    在这里插入图片描述

    效果

    在这里插入图片描述

    代码

    def circle():
        s = '''圆计算'''
        clear() # 清屏调用。
        gui_head() # 计算器界面头调用。
        while True:
            try: # 输入素数限定范围错误捕获。
                in_s = input(f"\n\n{s:-^38}\n\n\n{'输入半径:':>12}").strip()
                if in_s == '':
                    return
                r = float(in_s)
                if r <= 0:
                    error_show()
                    input(f"\n{'错误类型:半径为 Zero or Negative !':^31}")
                    continue
                break
            except Exception as error:
                error_show() 
                input(f"\n错误类型:{error}")
        input(f"{cut_line()}{'圆:':>16}{'R  = ':>9}{r:>4}\
    \n\n{'直径:':>16}{color(str(2*r), 'f_green'):>22}\
    \n\n{'半径:':>16}{color(str(r), 'f_green'):>22}\
    \n\n{'面积:':>16}{color(str(round(math.pi * r**2, 2)), 'f_green'):>22}{cut_line()}")
        return in_s
    

    回首页


    其她功用

      py计算器,还可以加挂其她功用模块,只需将功用模块加入 calculator_py.py 文件,前在 menu_show() 中menus列表加入菜单显示字符 ,在ismenu() 中加入功用模块的调用语句就好。😋

        elif menu == 4: # 4. 圆
            while True: # 功能模块循环。
                clear() # 清屏。
                if not circle(): # 功能模块函数返回''为真。
                    break # 输入'',退出功能模块。
    

    回首页

    完整 Python 代码


      我的解题思路,已融入代码注释,博文中就不再赘述。

    (如果从语句注释不能清楚作用,请评论区留言指教和探讨。🤝)

    #!/sur/bin/env python 
    # coding: utf-8 
    
    '''
    filename = calculator_py.py
    author = '梦幻精灵_cq'
    '''
    
    # 看到大佬博文看到大佬博文《【C语言】计算器》,诱发我也想 py 一个。设想:我还不会 gui 界面编码,就只能码个程序 print Menus 的了。
    # 鉴于 python 有 eval() 内置函数,她可以把字符串转化为代码语句并执行,所以“计算器”的简单计算直接输入四则混合运算的式子(数学表达式)就可以了。input() 接收输入字符串,直接调用 eval() 计算输出结果,实现简单的“四则混合运算”。
    # 对于乘方开方对数三角函数等高级计算,就需加载 python 的 math 的相应方法。还可以做一些个性计算,比如圆周长面积、长方体表面积体积(正方体是特殊的长方体,可以不单列)……可以尽情释放您的思绪。
    # 对于写代码样式,我更喜欢函数式编程。当然采用自定义函数编写功能模块了。
    
    import math # 加载数学模块。
    from time import localtime # 从 time 模块加载当前时间数组获取函数 localtime()。
    from mypythontools import color, cut_line, wait, clear # 从自码工具模块中载入颜色输出控制工具 color
    
    
    def main():
        '''计算器主执行代码块'''    
        while True: # 菜单列印和确认死循环,不主动退出就一直执行循环。
            clear() 
            menu_show() # 屏幕打印菜单。
            is_menu() # 菜单选择。
    
    
    def localtime_show():
        '''当前时间列印'''
        t = localtime() # 获取当前时间数组。
        return f"{t[3]:2d}:{t[4]:2d} {t[0]}年{t[1]:2d}月{t[2]:2d}日" # 为了齐整,我设置了当前时间格式化字符串中,时、分、月、日分别用两个英文字符位。
    
    
    def error_show():
        '''错误提示打印'''
        print(f"\n\n{'输入错误!':=^36}")
    
    
    def gui_head():
        '''计算器界面头'''
        print(f"\n\n{color(1, 'f_green')}{'':*^41}\n{'星月计算器':^36}\n{'(Stars&Moon Calculator)':^42}\n{'【':>10}{localtime_show()}】\n{'':-^41}{color(0)}")
    
    
    def gui_tail():
        '''计算器界面尾'''
        print(f"\n{color(1, 'f_green')}{'':-^41}\n{'Author:Dream-elf_cq':^41}{'(梦幻精灵_cq)':^37}\n{'':*^41}{color(0)}")
    
    
    def menu_show():
        '''菜单打印模块,无需参数传递'''
        menus = ('简单计算', '素数查找', '长方体计算', '圆计算', '退出') # 这次不象以前练习,设计为动态菜单列表。如需添加菜单项,只需把菜单项字符串放在列表相应位置就好。(注意:增加菜单后,记得到“菜单确认”模块修改 range() 合法菜单选择范围,不然无法选中新增菜单序号。并增添相应的 elif 选项。)
        clear() # 清屏。
        gui_head() # 界面头调用。
        for k,i in enumerate(menus): # 遍历枚举函数 enumerate() ,方便列印菜单序号。
            if i != '退出':
                print(f"\n{k+1:>16}. {i}")
            else:
                exit_s = f" {0}. {i} "
                print(f"\n{'':>13}{exit_s:=^13}")
        gui_tail() # 界面尾调用。
    
    
    def is_menu():
        '''菜单确认'''
        while True:
            try: # 菜单选择错误捕获。
                menu = int(input(f"\n\n{'菜单选择:':>12}"))
                if menu not in range(5): # 合法菜单选择序号范围设定。
                    error_show()
                    input(f"\n{'错误类型:没有此项菜单!':-^29}")
                break
            except Exception as error:
                error_show() 
                input(f"\n错误类型:{error}")
        # 菜单项增加后,就得增加一个 elif 。
        if menu == 0: # 0. 退出
            clear()
            print(f"{cut_line()}{color(' 欢迎下次使用“星月计算器” ', 'f_purple'):=^39}{cut_line()}")
            exit() 
        elif menu == 1: # 1. 简单计算器
            while True:
                clear() 
                if not less_count():
                    break 
    
        elif menu == 2: # 2. 素数查找
            while True:
                clear() 
                if not find_primes():
                    break 
     
        elif menu == 3: # 3. 长方体
            while True:
                clear() 
                if not cuboid():
                    break 
    
        elif menu == 4: # 4. 圆
            while True:
                clear() 
                if not circle():
                    break 
    
    
    # ---======== 下面是,计算器功能函数 ========---
    
    def less_count(): # 虽言简单计算器,但只要是符合 python 规范的表达式,都能有结果输出。这,足见 eval() 之强了吧。🤪🤪
        s = '''简单计算器(数学四则混合运算)'''
    
        clear() 
        gui_head()
    
        def in_rules():
            '''解析计算表达式合规符号集群'''
            rules = [] # 计算表达式字符规则列表
            rules.extend([str(i) for i in range(10)]) # 10 个数字。
            rules.extend(list(' +.-*/()')) # 运算符号。
            rules.extend([chr(i) for i in range(65,91)]) # 英文大写字母。
            rules.extend([chr(i) for i in range(97,123)]) # 英文小写字母。
            return tuple(rules)
            
        #print(f"\n\n计算表达式合法字符集:\n")
        #print(*in_rules()) # * 号打破“容器”(tuple)元素列印。(打印 in_rules ,只需去除前面的注释标识符。)
        while True:
            in_s = input(f"\n\n{s:-^28}\n\n\n{'计算表达式输入:'}")
            if in_s == '':
                return 
            for i in list(in_s):
                if i not in in_rules():
                    error_show()
                    input(f"\n{'错误类型:输入非法字符!':-^29}")
            else:
                break
    
        try:
            input(f"\n\n{'结果:':>12}{eval(in_s):.4f}\n\n{'':*^41}") # 我设定 eval() 函数计算数学表达式结果为四位小数({:.4f}),可自行更改。
        except Exception as error:
            error_show() 
            input(f"\n错误类型:{error}")
        return in_s
    
    
    def find_primes():
        s = '''素数查找'''
    
        clear() 
        gui_head()
        
        def isprime(n): # 内层函数
            '''素数判定'''
            for i in range(2, n):
                if n%i == 0:
                    return # 非素数,返回 None 。
            return n # 是素数,返回该数。
                
        while True:
            try: # 输入素数限定范围错误捕获。
                in_s = input(f"\n\n{s:-^37}\n\n\n{'输入范围(10~500):':>12}")
                if in_s == '':
                    return 
                in_num = int(in_s)
                if in_num not in range(10, 501):
                    error_show()
                    input(f"\n{'错误类型:输入超出范围!':-^29}")
                else:
                    break
            except Exception as error:
                error_show() 
                input(f"\n错误类型:{error}")
        primes = [str(i) for i in range(2, in_num+1) if isprime(i)] # 用内层函数解析给定范围的素数。
        input(f"\n\n从 2 到 {in_num}的素数有:\n\n{','.join(primes)}\n\n{'':*^41}")
        return in_s
    
    
    def cuboid():
        s = '''长方体相关计算'''
        clear() # 清屏调用。
        gui_head() # 计算器界面头调用。
        while True:
            try: # 输入素数限定范围错误捕获。
                in_s = input(f"\n\n{s:-^34}\n\n\n{'输入棱长(a b c):':>12}").strip()
                if in_s == '':
                    return 
                abc_list = [float(i) for i in in_s.split(' ')]            
                flag = False # 输入错误循环标识。
                for i in abc_list:
                    if i <= 0:
                        error_show()
                        input(f"\n{'错误类型:棱长为 Zero or Negative !':^31}")
                        flag = True
                        break
                if flag is True:
                    continue
                a, b, c = abc_list
                break
            except Exception as error:
                error_show() 
                input(f"\n错误类型:{error}")
    
        c12 = round(4 * (a + b + c), 2) # 棱长和。
        s6 = round(2 * (a*b + a*c + b*c), 2) #表面积。
        v = round(a * b * c, 2) #体积。
        input(f"{cut_line()}{'长方体:':>12}{a:>6}×{b}×{c}\
    \n\n{'棱长和:':>12}{color(str(c12), 'f_green'):>22}\
    \n\n{'表面积:':>12}{color(str(s6), 'f_green'):>22}\
    \n\n{'体积:':>13}{color(str(v), 'f_green'):>22}{cut_line()}")
        return in_s
    
    
    def circle():
        s = '''圆计算'''
        clear() # 清屏调用。
        gui_head() # 计算器界面头调用。
        while True:
            try: # 输入素数限定范围错误捕获。
                in_s = input(f"\n\n{s:-^38}\n\n\n{'输入半径:':>12}").strip()
                if in_s == '':
                    return
                r = float(in_s)
                if r <= 0:
                    error_show()
                    input(f"\n{'错误类型:半径为 Zero or Negative !':^31}")
                    continue
                break
            except Exception as error:
                error_show() 
                input(f"\n错误类型:{error}")
        input(f"{cut_line()}{'圆:':>16}{'R  = ':>9}{r:>4}\
    \n\n{'直径:':>16}{color(str(2*r), 'f_green'):>22}\
    \n\n{'半径:':>16}{color(str(r), 'f_green'):>22}\
    \n\n{'面积:':>16}{color(str(round(math.pi * r**2, 2)), 'f_green'):>22}{cut_line()}")
        return in_s
    
    
    
    # Stars&Moon Calculayor 主执行代码:
    if __name__ == '__main__': # 本 *.py 文档作为模块调用,不执行后续语句。
        main() # 调用 calculator_py 主程序代码块。
    
      本 *.py 文件,可以在其他代码中作为模块调用。
    
    



    回首页

    上一篇:求偶数和、阈值分割和求差( list 对象的两个基础小题 )

    下一篇:练习:班里有人和我同生日难吗?(概率probability、蒙特卡洛随机模拟法)


    我的HOT博:

    推荐条件 点阅破千

    回首页


    老齐漫画头像

    精品文章:

    来源:老齐教室


    回首页

    Python 入门指南【Python 3.6.3】


    好文力荐:


    CSDN实用技巧博文:


    展开全文
  • 使用 python 实现的一个多功能的科学计算器,可以切换普通计算器和科学计算器,功能包括四则远算、三角函数、进制转换、阶乘、开方,对指数和解方程等,包括归零删除等操作,非常实用,代码注释清楚便于学习。
  • 接下来,我们给这个计算器加上 GUI 界面: 二、TK 图形化界面 Tkinter 是 Python 的标准 GUI 库,且内置在了 Python 的安装包中。也就是说,我们只需输入这么一行: import tkinter as tk 就可以开始 GUI 编程啦~ ...

    目录

    前言

    一、算法实现

    二、TK 图形化界面

    三、一元二次方程计算器 - 完整代码

    参考资料


    前言

    一元二次方程想必大家都不陌生。在中学时,我们学过求根公式:

    x = \frac{-b\pm\sqrt{b^2-4ac}}{2a}

    当 b² - 4ac 大于零时,方程有两个解;等于零时有一个解;小于零时则无解。

    那么就把数学公式变成代码!我们说干就干。


    一、算法实现

    首先导入要用到的数学库 math

    import math

    知识点:连续输入多个 float 型数字

    a,b,c = map(float,input("对于方程a^2x+bx+c=0, \n请输入a,b,c(空格隔开):").split())
    # Tips: 可以通过.split(',') 将输入的分隔符改为逗号

    通过求根公式解方程

    k = b*b-4*a*c
    
    # 知识点:if 判断语句的使用
    if k < 0 :
    
       print('方程无解')
    
    # 注意,逻辑'等于'是两个等号,一个等号代表赋值
    elif k == 0 :
    
       x = -b/(2*a)
    
       # 知识点:通过 %.2f 使输出的数保留两位小数
       print('方程的解为:x1=x2=%.2f' % x)
    
    else :
       x1 = (-b+math.sqrt(k))/(2*a)
       x2 = (-b-math.sqrt(k))/(2*a)
    
       print('\n方程的解为: x1=%.2f, x2=%.2f' % (x1,x2))

    运行结果展示:

    算法部分就完成了。但是,运行要依靠命令行输入数字,对普通用户还是不太友好。

    接下来,我们给这个计算器加上 GUI 界面:


    二、TK 图形化界面

    Tkinter 是 Python 的标准 GUI 库,且内置在了 Python 的安装包中。也就是说,我们只需输入这么一行:

    import tkinter as tk

    就可以开始 GUI 编程啦~ 接下来,我们先搭一个简单的计算器界面

    创建一个窗口,我们输入:

    window = tk.Tk() # 创建窗口
    
    window.title('计算器') # 窗口的标题
    
    window.geometry('800x400') # 窗口的大小(也可以不指定)
    
    window.mainloop() # 窗口运行起来,要放在结尾哦

    一个基本的窗口就搭建起来了~

    在窗口上显示一行字:

    k = tk.Label(window,text='请输入一个数字:',font=('Arial',12)) # 文字label
    k.grid() # 固定文字的位置

    再增加一个输入框:

    x = tk.Entry(window) # 输入框
    x.grid()

     再放一个按钮:

    # 先定义一个点击按钮时触发的函数
    def cal():
        a = float(x.get()) # 从输入框中读取一个 float 变量
        b = a + 1
    # 定义一个按钮
    b1 = tk.Button(window,text='计算',command=cal)
    b1.grid()

     当然,我们还需要一个显示计算结果的地方:

    def cal():
        a = float(x.get()) # 从输入框中读取一个 float 变量
        b = a + 1
        c.set(b) # 注意,在这个函数里插了一行
    c = tk.StringVar() # 字符串变量
    # 把计算结果显示出来
    l = tk.Label(window,textvariable=c,font=('Arial',12))
    l.grid()

    这时候我们输入一个数,点击“计算”,就能得到这个数+1的数啦~

    一个简单的计算“+1”的计算器就建好了。

    但是,这个这几个文字和框竖着排成了一列,有些不太规整。

    # 把上面几行用于排版的代码改一下:
    k.grid(row=0,column=0,sticky='w')
    x.grid(row=1,column=0)
    b1.grid(row=1,column=1,padx=20)
    l.grid(row=3,column=0,sticky='w')


    三、一元二次方程计算器 - 完整代码

    在第二章,我们基本搭建了一个界面。接下来,我们将第一章中的算法打包进去

    先放运行结果:

     接下来是完整代码

    import tkinter as tk
    import math
    
    window = tk.Tk() # 创建窗口
    window.title('一元二次方程计算器') # 窗口的标题
    # window.geometry('800x400') # 窗口的大小(也可以不指定)
    
    # 一些界面元素
    # grid 是一个格点,决定元素显示哪里
    # columnspan 横跨多列格点,rowspan 同理
    # padx pady ipadx ipady 调整分别调整外边距和内边距
    # sticky = E 靠右 W 靠左
    
    k = tk.Label(window,text='请输入一元二次方程的参数:',font=('Arial',12)) # 文字label
    k.grid(row=0,column=0,columnspan=3,sticky='w',padx=10,pady=10)
    
    x02 = tk.Entry(window) # 输入框
    x02.grid(row=1,column=0,padx=10)
    
    p1 = tk.Label(window,text=' x² + ',font=('Arial',12))
    p1.grid(row=1,column=1)
    
    x01 = tk.Entry(window)
    x01.grid(row=1,column=2)
    
    p2 = tk.Label(window,text=' x + ',font=('Arial',12))
    p2.grid(row=1,column=3)
    
    x00 = tk.Entry(window)
    x00.grid(row=1,column=4)
    
    p3 = tk.Label(window,text=' = 0',font=('Arial',12))
    p3.grid(row=1,column=5)
    
    # 一元二次方程计算函数(点击按钮后执行)
    def cal():
        a = float(x02.get())
        b = float(x01.get())
        c = float(x00.get())
    
        k = b*b-4*a*c
        g = -c/b
    
        if a == 0:
            resu.set('方程的解为: x = %.2f' % g)
    
        if k < 0 :
            resu.set('方程无解')
    
        elif k == 0 :
            x = -b/(2*a)
            resu.set('方程的解为: x1 = x2 = %.2f' % x)
    
        else :
            x1 = (-b+math.sqrt(k))/(2*a)
            x2 = (-b-math.sqrt(k))/(2*a)
            resu.set('方程的解为: x1 = %.2f   x2 = %.2f' % (x1,x2))
        
    # 按钮
    b1 = tk.Button(window,text='计算',width=10,command=cal)
    b1.grid(row=1,column=6,padx=20)
    
    # 结果显示
    resu = tk.StringVar() # 字符串变量
    l = tk.Label(window,textvariable=resu,font=('Arial',12))
    l.grid(row=3,column=0,sticky='w',columnspan=3,padx=10)
    
    window.mainloop() # 窗口运行起来,要放在结尾哦

    参考资料

    【Python】Tkinter教程_木子欢儿的博客-CSDN博客

    Python Tkinter Grid布局管理器详解 - 箬笠蓑衣 - 博客园 (cnblogs.com)

    如何设置 Tkinter 文本输入控件的高度和宽度 | D栈 - Delft Stack

    展开全文
  • 这是一个普通版的计算器,具体可浏览:https://blog.csdn.net/baidu_37611158/article/details/113624654(利用python和tkinter制作自定义功能的计算器)
  • _init__(self):#生成一个窗口对象self.window = self.tk.Tk()#命名窗口对象的显示titleself.window.title('计算器')#设置窗口的大小se...
  • Python计算器

    2020-11-26 09:37:58
    Python计算器让非编程的人员能够体验到Python乐趣的一款计算软件,用这种基础实例的方式来为普罗大众进行相关编程知识上面的解释,这款软件仅仅也只是作为一个框架,如果你是相关的编程人员能够自主的在上面进行扩展...
  • \+ 匹配+ \\\\ 匹配\ 等于 r“\\" r是代表原生字符,不需要python转义就传入re 反斜杠后跟普通字符实现特殊功能 \d 代表数字0-9 [0-9] \D 代表非数字0-9 [^0-9] \s 代表匹配空白字符[\t\n\r\f\v] \S 代表匹配非空白...
  • 一个计算器,可以进行一些基本的运算,高级的运算也有一点, 如使用期间有问题,欢迎提问!每周五准时回答
  • 一、用Python做了一个简单的计算器,包括两个数的和、差、乘积、商、整除。 程序要求: # 用户输入两个数字,第一行打印出两个数字的和, # 第二行打印出两个数字的差,第三行打印出两个数字的乘积, # 第四行...
  • 虽然目前Python学的还是半吊子,不过还是决定写一点简单的代码来模拟金融计算器的功能。突然想到随着学习的深入,没准真的就能自己开发出来一款功能齐全的金融计算器了呢。不过今天还是老老实实地写最基础的代码,也...
  • python tkinter模块做基础计算器
  • 打开属性表-文件-按属性选择-value=1: 再选择name字段,进行字段计算器计算,每一类都要进行这样的操作,在处理大数据的时候会很麻烦,浪费很多时间,今天分享给大家一个快速分类赋值方法,用到的是python语言:...
  • GUI_Calculator1 该存储库是“ Python中的图形用户界面计算器”。 GUI代表图形用户界面,创建具有GUI功能的计算器python有很多模块... Main.py包含该项目的完整代码,它在一个界面中同时具有科学和普通计算器模式。
  • 工资计算器

    2021-02-15 04:20:57
    工资计算器 test1是功能模块,test2.py是主要功能。 输入excel列['订单号','系列','长度','2.5mm','FP','分段','U槽/管材','内铝网','内抽','外抽”,“中控锁”,“撑杆”,“门”,“附加”,“附加价格...
  • 原博文2017-12-10 21:08 −1 import tkinter 2 import tkinter.messagebox 3 import math 4 class JSQ: 567 def __init__(self): 8 #创建主界面 9 self.root = tkinter......相关推荐2019-09-28 21:13 −Python pyth...
  • 本篇博客讲述如何通过目前最流行的Python Web框架Django制作一个完整的项目实例:在线计算器。该实例前端采用Bootstrap框架完成界面设计和制作,该实例同时支持响应式设计,可以适应手机浏览。具体执行流程为:用户...
  • 二、简单实用的Python计算器 一、Python对中文的支持 在Python中,可以在各种编码间相互转换。 如果在交互式命令中使用中文,即便不做处理,一般也不会出现乱码。 如果在“.py”文件中使用了中文,则需要在文件...
  • ))) #替换时需要在前面加入正号,并对s进行check操作 ret = re.search(patter_kuohao, s) return s s3 = ''.join(["(", s3, ")"]) print(float(bracket(s3))) 以上即用不超过50行代码实现了计算器的主要功能。...
  • Python 完成普通计算器的功能 1. 删除或取消变量 pv = 22 r = 0.1 n = 5 del(n) print(n) 结果: NameError: name 'n' is not defined 2.加减乘除 s=3.09+2.1*5.2-3/0.56 print(s) 结果 8.652857142857144 ...
  • 两位数计算器

    2021-02-25 08:00:19
    两位数计算器具有两个基本运算的两个数字计算器:加法,减法,乘法和除法。 仍在进行中,但效果很好。 是最后的项目。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,336
精华内容 1,734
热门标签
关键字:

python普通计算器