python面向对象-计算器_通过分析上段程序结果,进一步修改程序,考虑基于面向对象技术的计算器程序。使用类-优快云博客

本文详细介绍了计算器类的设计过程，包括基本的算术运算、数据类型检查、使用装饰器进行代码优化，以及如何添加语音播报功能增强用户体验。通过逐步改进，展示了如何从简单功能到复杂功能的迭代开发。
摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >
# 计算器，实现一些基本的操作，加减乘除以及打印结果操作
class Caculate:
    __result = 0  # 操作类属性，通过类名Caculate或者用类方法传递类名
    @classmethod
    def first_value(cls, v):
        cls.__result = v
    @classmethod
    def jia(cls, n):
        cls.__result += n
    @classmethod
    def jian(cls, n):
        cls.__result -= n
    @classmethod
    def cheng(cls, n):
        cls.__result *= n
    @classmethod
    def chu(cls, n):
        cls.__result /= n

    @classmethod
    def show(cls):
        print("计算的结果是：%d" % cls.__result)
Caculate.first_value(3)
Caculate.jia(34)
Caculate.jian(34)
Caculate.show()


class Caculate:
    def __init__(self, num):
        self.__result = num

    def jia(self, n):
        self.__result += n

    def jian(self, n):
        self.__result -= n

    def cheng(self, n):
        self.__result *= n

    def chu(self, n):
        self.__result /= n

    def show(self):
        print("计算的结果是：%d" % self.__result)
c1 = Caculate(2)
c1.jia(6)
c1.jia(34)
c1.jian(34)
c1.show()

class Caculate:
    def checkNum(self, num):
        if not isinstance(num, int):
            raise TypeError("当前的数据类型有问题应该是一个整型数据")
    def __init__(self, num):
        self.checkNum(num)
        self.__result = num

    def jia(self, n):
        self.checkNum(n)
        self.__result += n

    def jian(self, n):
        self.checkNum(n)
        self.__result -= n

    def cheng(self, n):
        self.checkNum(n)
        self.__result *= n

    def chu(self, n):
        self.checkNum(n)
        self.__result /= n

    def show(self):
        print("计算的结果是：%d" % self.__result)
c1 = Caculate(2)
c1.jia(6)
c1.jia(34)
c1.jian(34)
c1.show()

# 使用装饰器优化
class Caculate:
    def __checkNum_zsq(func):  # 私有对象,不让外界调用，在外界没有用
        def inner(self, n):  # 外界接受的加法方法会替换成这个要保证和加法方法形式一样
            if not isinstance(n, int):
                raise TypeError("当前的数据类型有问题应该是一个整型数据")
            return func(self, n)
        return inner
    @__checkNum_zsq
    def __init__(self, num):
        self.__result = num

    @__checkNum_zsq
    def jia(self, n):
        self.__result += n

    @__checkNum_zsq
    def jian(self, n):
        self.__result -= n

    @__checkNum_zsq
    def cheng(self, n):
        self.__result *= n

    @__checkNum_zsq
    def chu(self, n):
        self.checkNum(n)
        self.__result /= n
    def show(self):
        print("计算的结果是：%d" % self.__result)
c1 = Caculate(2)
c1.jia(6)
c1.jia(4)
c1.jian(34)
c1.show()

# 语音播报
import win32com.client
class Caculate:
    def __say(self, word):
        # 创建一个播报对象
        speaker = win32com.client.Dispatch("SAPI.SpVoice")
        # 通过这个播报器对象去播放相对应的语音字符串
        speaker.Speak(word)

    def __checkNum_zsq(func):  # 私有对象,不让外界调用，在外界没有用
        def inner(self, n):  # 外界接受的加法方法会替换成这个要保证和加法方法形式一样
            if not isinstance(n, int):
                raise TypeError("当前的数据类型有问题应该是一个整型数据")
            return func(self, n)
        return inner
    @__checkNum_zsq
    def __init__(self, num):
        self.__say(num)
        self.__result = num

    @__checkNum_zsq
    def jia(self, n):
        self.__say(n)
        self.__result += n

    @__checkNum_zsq
    def jian(self, n):
        self.__say(n)
        self.__result -= n

    @__checkNum_zsq
    def cheng(self, n):
        self.__say(n)
        self.__result *= n

    @__checkNum_zsq
    def chu(self, n):
        self.__say(n)
        self.__result /= n
    def show(self):
        # 创建一个播报对象
        self.__say("计算的结果是：%d" % self.__result)
c1 = Caculate(2)
c1.jia(6)
c1.jia(4)
c1.jian(34)
c1.show()


# 使用装饰器，不破坏原先代码结构
import win32com.client
class Caculate:
    def __say_zsq_jia(func):
        def inner(self, n):  # 外界接受的加法方法会替换成这个要保证和加法方法形式一样
            # 创建一个播报对象
            speaker = win32com.client.Dispatch("SAPI.SpVoice")
            # 通过这个播报器对象去播放相对应的语音字符串
            speaker.Speak("加%d" % n)
            return func(self, n)
        return inner
    def __say_zsq_init(func):
        def inner(self, n):  # 外界接受的加法方法会替换成这个要保证和加法方法形式一样
            # 创建一个播报对象
            speaker = win32com.client.Dispatch("SAPI.SpVoice")
            # 通过这个播报器对象去播放相对应的语音字符串
            speaker.Speak("加%d" % n)
            return func(self, n)
        return inner
    def __say_zsq_jian(func):
        def inner(self, n):  # 外界接受的加法方法会替换成这个要保证和加法方法形式一样
            # 创建一个播报对象
            speaker = win32com.client.Dispatch("SAPI.SpVoice")
            # 通过这个播报器对象去播放相对应的语音字符串
            speaker.Speak("减去%d" % n)
            return func(self, n)
        return inner
    def __say_zsq_cheng(func):
        def inner(self, n):  # 外界接受的加法方法会替换成这个要保证和加法方法形式一样
            # 创建一个播报对象
            speaker = win32com.client.Dispatch("SAPI.SpVoice")
            # 通过这个播报器对象去播放相对应的语音字符串
            speaker.Speak("乘上%d" % n)
            return func(self, n)
        return inner
    def __say_zsq_chu(func):
        def inner(self, n):  # 外界接受的加法方法会替换成这个要保证和加法方法形式一样
            # 创建一个播报对象
            speaker = win32com.client.Dispatch("SAPI.SpVoice")
            # 通过这个播报器对象去播放相对应的语音字符串
            speaker.Speak("除去%d" % n)
            return func(self, n)
        return inner

    def __checkNum_zsq(func):  # 私有对象,不让外界调用，在外界没有用
        def inner(self, n):  # 外界接受的加法方法会替换成这个要保证和加法方法形式一样
            if not isinstance(n, int):
                raise TypeError("当前的数据类型有问题应该是一个整型数据")
            return func(self, n)
        return inner

    @__checkNum_zsq  # 先验证后播放，谁在外面先执行谁
    @__say_zsq_init
    def __init__(self, num):
        self.__result = num

    @__checkNum_zsq
    @__say_zsq_jia
    def jia(self, n):
        self.__result += n

    @__checkNum_zsq
    @__say_zsq_jian
    def jian(self, n):
        self.__result -= n

    @__checkNum_zsq
    @__say_zsq_cheng
    def cheng(self, n):
        self.__result *= n

    @__checkNum_zsq
    @__say_zsq_chu
    def chu(self, n):
        self.__result /= n

# 使用装饰器，不破坏原先代码结构
import win32com.client
class Caculate:

    def __say(self, word):
        # 创建一个播报对象
        speaker = win32com.client.Dispatch("SAPI.SpVoice")
        # 通过这个播报器对象去播放相对应的语音字符串
        speaker.Speak(word)
    def __creat_say_zsq(word):
        def __say_zsq(func):
            def inner(self, n):  # 外界接受的加法方法会替换成这个要保证和加法方法形式一样
                self.__say(word + str(n))
                return func(self, n)
            return inner
        return __say_zsq

    def __checkNum_zsq(func):  # 私有对象,不让外界调用，在外界没有用
        def inner(self, n):  # 外界接受的加法方法会替换成这个要保证和加法方法形式一样
            if not isinstance(n, int):
                raise TypeError("当前的数据类型有问题应该是一个整型数据")
            return func(self, n)
        return inner

    @__checkNum_zsq  # 先验证后播放，谁在外面先执行谁
    @__creat_say_zsq("")
    def __init__(self, num):
        self.__result = num

    @__checkNum_zsq
    @__creat_say_zsq("加上")
    def jia(self, n):
        self.__result += n
        return self  # 直接返回对象

    @__checkNum_zsq
    @__creat_say_zsq("减去")
    def jian(self, n):
        self.__result -= n
        return self  # 直接返回对象

    @__checkNum_zsq
    @__creat_say_zsq("乘以")
    def cheng(self, n):
        self.__result *= n
        return self  # 直接返回对象

    @__checkNum_zsq
    @__creat_say_zsq("除以")
    def chu(self, n):
        self.__result /= n
        return self  # 直接返回对象
    # @__say_zsq  # show方法与装饰器内部方法不一样不可以装饰
    def show(self):
        self.__say("计算的结果是：%d" % self.__result)
        return self  # 直接返回对象
    # 清零
    def clear(self):
        self.__result = 0
        return self
    @property
    def result(self):
        return self.__result
c1 = Caculate(2)
c1.jia(6).jia(4).jian(34).show()  # 在方法内部再次返回调用实例方法的对象本身c1，链式编程
print(c1.result)  # 使用描述器