python深入之语音播报计算器设计

代码一：普通函数调用

def jia(m, n):
    return m + n
def jian(m, n):
    return m - n
def cheng(m, n):
    return m * n
print(jia(1, 2))
print(jian(3, 2))
print(cheng(4, 5))

每次传入两个数值，调用相关函数进行计算，并输出结果

代码二：面向用户的连续计算，给定初值，每次调用相关函数，输入一个数值

result = 0
def fuzhi(n):
    global result
    result = n
def jia(n):
    global result
    result += n
    return result
def jian(n):
    global result
    result -= n
    return result
def cheng(n):
    global result
    result *= n
    return result
fuzhi(10)
print(jia(5))
print(jian(5))
print(cheng(5))

定义全局变量，对其进行连续操作(10 + 5 - 5) * 5，得出最终结果50

代码三：将函数和初值封装到类中，此时，初值变成类属性，并且不希望其在外面被修改，将其私有化；函数编程类方法

class Calculator(object):
    __result = 0
    @classmethod
    def jia(cls, n):
        cls.__result += n
        return cls.__result
    @classmethod
    def jian(cls, n):
        cls.__result -= n
        return cls.__result
    @classmethod
    def cheng(cls, n):
        cls.result *= n
        return cls.__result
    @classmethod
    def getRes(cls):
        return cls.__result
Calculator.jia(5)
Calculator.jian(2)
Calculator.cheng(2)
print(Calculator.getRes())

使用类来调用相关方法，实现各种计算，并调用输出方法来访问私有属性，输出结果

代码四：由于类属性依赖于类，当该类同时被几次应用时，最终计算结果就会出错，这里将类属性变成实例属性，每个计算实例相互独立；并且加入检查机制，输入必须是整数

class Calculator(object):
    def __check_zsq(func):
        def inner(self, n):
            if not isinstance(n, int):
                raise TypeError("输入数据必须是整数，请重新输入")
            return func(self, n)
        return inner
    @__check_zsq
    def __init__(self, num):
        self.__result = num
    @__check_zsq
    def jia(self, n):
        self.__result += n
        return self.__result
    @__check_zsq
    def jian(self, n):
        self.__result -= n
        return self.__result
    @__check_zsq
    def cheng(self, n):
        self.__result *= n
        return self.__result
    def getRes(self):
        return self.__result
c1 = Calculator(10)
c1.jia(5)
c1.jian(6)
c1.cheng(2)
print(c1.getRes())

这里添加了检查机制，由于每个计算操作都要加入次机制代码，为了不破坏方法的单一职责原则，将检查机制做成装饰器，然后对每个方法进行装饰即可

代码五：加入语音播报功能；使用property来关联获取操作；加入清零操作

import win32com.client
class Calculator(object):
    def __speak(self, n):
        # 创建语音对象
        speak = win32com.client.Dispatch("SAPI.SpVoice")
        # 播报内容
        speak.Speak(n)
    def __say(char=""):
        def __speak_zsq(func):
            def inner(self, n):
                self.__speak(char + str(n))
                return func(self, n)
            return inner
        return __speak_zsq
    def __check_zsq(func):
        def inner(self, n):
            if not isinstance(n, int):
                raise TypeError("输入数据必须是整数，请重新输入")
            return func(self, n)
        return inner
    @__check_zsq
    @__say()
    def __init__(self, num):
        self.__result = num
    @__check_zsq
    @__say("加上")
    def jia(self, n):
        self.__result += n
        return self
    @__check_zsq
    @__say("减去")
    def jian(self, n):
        self.__result -= n
        return self
    @__check_zsq
    @__say("乘以")
    def cheng(self, n):
        self.__result *= n
        return self
    def speak_res(self):
        self.__speak("等于%d" % self.__result)
        return self
    @property
    def getRes(self):
        return self.__result
    def clear(self):
        self.__speak("清零")
        self.__result = 0
        return self
c1 = Calculator(10)
c1.jia(5).jian(1).cheng(25).speak_res().clear().jia(20).cheng(10).speak_res()
print(c1.getRes)

每个方法的操作名称需要在使用时进行播报，所以将播报方法做成返回装饰器的方法，再将各种操作名称传入播报即可；由于关联了获取操作，输出时只需使用属性来表示方法调用；清零操作可使计算器多次使用；由于方法都是实例方法，每次调用都要使用该实例，为了简化，在每个方法最后返回该实例，就可以将方法的调用写成链式形式，即c1.jia(5).jian(1).cheng(25).speak_res().clear().jia(20).cheng(10).speak_res()