面向过程的设计思路

1，设计一个计算器，实现一些基本的操作，加减乘除运算，以及打印结果操作

  • 定义一个变量来存储每次运算的结果 ```python result = 0

def first_value(v): global result result = v # 接收每次运算输入的第一个数值

def jia(n): global result result += n

def jian(n): global result result -= n

def cheng(n): global result result *= n

def show(): print(‘计算的结果为：%d’ %result)

first_value(1) jia(5) jian(3) cheng(6) show()

  1. <a name="d096e49f"></a>
  2. # 面向对象的设计思路
  3. <a name="2bac1f38"></a>
  4. ## 通过【类属性】来操作运算结果
  6. - 通过类名来访问
  7. ```python
  8. class Caculator:
  9.     __result = 0                    # 为了不让外界操作这个类属性，即定义一个私有属性
  11.     @classmethod
  12.     def first_values(cls,v):        # 定义类方法，调用类属性，传递一个类名就可以了，这里使用了参数cls
  13.         cls.__result = v
  15.     @classmethod
  16.     def jia(cls,n):
  17.         cls.__result += n
  19.     @classmethod
  20.     def jian(cls,n):
  21.         cls.__result -= n
  23.     @classmethod
  24.     def cheng(cls,n):
  25.         cls.__result *= n
  27.     @classmethod
  28.     def show(cls):                    # 由于最终要打印计算结果，且结果保存在私有属性中，外界无法访问，所以在内部提供一个方法来访问该私有属性
  29.         print('计算的结果为：%d' %cls.__result)
  31. Caculator.first_values(10)
  32. Caculator.jia(5)
  33. Caculator.jian(3)
  34. Caculator.cheng(6)
  35. Caculator.show()

上述代码存在的问题：

  • result是一个类属性，类属性是依赖类对象存在的，在内存中，每个类只会存在一份，所以只能计算一份结果，无法同时进行多个表达式的运算；

  • 另外，当其他多个对象调用这个类属性的时候，调用和修改都是同一个属性的值，所以最终计算得到的结果都是同一个值；

    通过【实例化】来操作运算结果

  • 通过实例化对象来操作计算的结果，就是将result变成一个实例属性，一个实例就是一个计算器，不同的实例就是不同的计算器 ```python class Caculator:

    def init(self,num):

    1.   self.__result = num             # 初始化，输入计算前第一个数值

    def jia(self,n):

    1.   self.__result += n

    def jian(self,n):

    1.   self.__result -= n

    def cheng(self,n):

    1.   self.__result *= n

    def show(self):

    1.   print('计算的结果为：%d' %self.__result)

c1 = Caculator(5) # c1计算器
c1.jia(5) c1.jian(3) c1.cheng(6) c1.show()

c2 = Caculator(6) # c2计算器
c2.jia(1) c2.jian(3) c2.cheng(6) c2.show()

  2. - 容错处理（对n和num进行判断，是否为整形）
  3. ```python
  4. class Caculator:
  5.     def check_num(self,num):            # 单独写一个方法，用于判断输入的数值是否为数值型
  6.         if not isinstance(num,int):
  7.             raise TypeError("当前这个数据有问题，应该为一个数值类型")
  9.     def __init__(self,num):
  10.         self.check_num(num)             # 调用容错处理的方法
  11.         self.__result = num           
  13.     def jia(self,n):
  14.         self.check_num(n)               # 调用容错处理的方法
  15.         self.__result += n
  17.     def jian(self,n):
  18.         self.check_num(n)               # 调用容错处理的方法
  19.         self.__result -= n
  21.     def cheng(self,n):
  22.         self.check_num(n)               # 调用容错处理的方法
  23.         self.__result *= n
  25.     def show(self):
  26.         print('计算的结果为：%d' %self.__result)
  28. c1 = Caculator(2)
  29. c1.jia(6)
  30. c1.jian(4)
  31. c1.cheng(5)
  32. c1.show()

  • 上述容错处理的代码中，在方法中又调用了容错处理的方法，破坏了原来的代码的单一原则，原本每个方法只负责加减乘除的操作，现在又增加了额外的功能，即破坏了代码

    容错处理装饰器

    ```python class Caculator: def __check_num_zsq(func): # 重点，定义私有装饰器，避免外界调用或修改 

    1.   def inner(self,n):                                                # 重点，这里接收的参数和被装饰的方法所接收的参数一致
    2.       if not isinstance(n,int):
    3.           raise TypeError("当前这个数据有问题，应该为一个数值类型")
    4.       return func(self,n)                                            # 执行方法，这里就是执行下面加减乘除的方法
    5.   return inner

    @check_num_zsq def init__(self,num):

    1.   self.__result = num

    @__check_num_zsq def jia(self,n):

    1.   self.__result += n

    @__check_num_zsq def jian(self,n):

    1.   self.__result -= n

    @__check_num_zsq def cheng(self,n):

    1.   self.__result *= n

    def show(self):

    1.   print('计算的结果为：%d' %self.__result)

c1 = Caculator(2) c1.jia(6) c1.jian(4) c1.cheng(5) c1.show()

  1. <a name="23c709c4"></a>
  2. ## 嵌入播报功能
  4. - 如何嵌入
  5. ```python
  6. import win32com.client
  8. class Caculator:
  9.     def __say(self,word):                                   # 单独定义一个播报方法，播报的word = n或是num
  10.         speaker = win32com.client.Dispatch("SAPI.SpVoice")    # 1，创建一个播报器对象        
  11.         speaker.Speak(word)                                    # 2，通过播报器对象，直接播放相对应的语音字符串
  13.     def __check_num_zsq(func):                # 重点，定义私有装饰器，避免外界调用或修改                                    
  14.         def inner(self,n):                    # 重点，这里接收的参数和被装饰的方法所接收的参数一致
  15.             if not isinstance(n,int):
  16.                 raise TypeError("当前这个数据有问题，应该为一个数值类型")
  17.             return func(self,n)                # 执行方法，这里就是执行下面加减乘除的方法
  18.         return inner
  20.     @__check_num_zsq
  21.     def __init__(self,num):
  22.         self.__say(num)
  23.         self.__result = num              
  25.     @__check_num_zsq
  26.     def jia(self,n):
  27.         self.__say(n)
  28.         self.__result += n
  30.     @__check_num_zsq
  31.     def jian(self,n):
  32.         self.__say(n)
  33.         self.__result -= n
  35.     @__check_num_zsq
  36.     def cheng(self,n):
  37.         self.__say(n)
  38.         self.__result *= n
  40.     def show(self):
  41.         self.__say('计算的结果为：%d' %self.__result)
  42.         print('计算的结果为：%d' %self.__result)
  44. c1 = Caculator(2)
  45. c1.jia(6)
  46. c1.jian(4)
  47. c1.cheng(5)
  48. c1.show()

播报装饰器 - 仅播报数字

  1. import win32com.client
  3. class Caculator:
  4.     def __say_zsq(func):                    # 重点，定义私有装饰器，避免外界调用或修改
  5.         def inner(self,n):
  6.             speaker = win32com.client.Dispatch("SAPI.SpVoice")            
  7.             speaker.Speak(n)
  8.             return func(self,n)    
  9.         return inner                                
  11.     def __check_num_zsq(func):                # 重点，定义私有装饰器，避免外界调用或修改                                    
  12.         def inner(self,n):                    # 重点，这里接收的参数和被装饰的方法所接收的参数一致
  13.             if not isinstance(n,int):
  14.                 raise TypeError("当前这个数据有问题，应该为一个数值类型")
  15.             return func(self,n)                # 执行方法，这里就是执行下面加减乘除的方法
  16.         return inner
  18.     @__check_num_zsq                        
  19.     @__say_zsq                              # 先验证，后播报 
  20.     def __init__(self,num):
  21.         self.__result = num              
  23.     @__check_num_zsq
  24.     @__say_zsq 
  25.     def jia(self,n):
  26.         self.__result += n
  28.     @__check_num_zsq
  29.     @__say_zsq 
  30.     def jian(self,n):
  31.         self.__result -= n
  33.     @__check_num_zsq
  34.     @__say_zsq 
  35.     def cheng(self,n):
  36.         self.__result *= n
  38.     def show(self):
  39.         # self.__say('计算的结果为：%d' %self.__result)
  40.         print('计算的结果为：%d' %self.__result)
  42. c1 = Caculator(2)
  43. c1.jia(6)
  44. c1.jian(4)
  45. c1.cheng(5)
  46. c1.show()

带参数的装饰器 - 符号和数字

  1. import win32com.client
  3. class Caculator:
  4.     def create_say(word = ''):           # 定义一个函数，接收一个参数，函数内部就是一个装饰器，最终将这个装饰器返回
  5.         def __say_zsq(func):             # 装饰器                                      
  6.             def inner(self,n):
  7.                 speaker = win32com.client.Dispatch("SAPI.SpVoice")            
  8.                 speaker.Speak(word + str(n))
  9.                 return func(self,n)    
  10.             return inner
  11.         return __say_zsq                 # 将函数内部的装饰器返回出去                            
  13.     def __check_num_zsq(func):                                                    
  14.         def inner(self,n):                    
  15.             if not isinstance(n,int):
  16.                 raise TypeError("当前这个数据有问题，应该为一个数值类型")
  17.             return func(self,n)                
  18.         return inner
  20.     @__check_num_zsq                        
  21.     @create_say()                              
  22.     def __init__(self,num):
  23.         self.__result = num              
  25.     @__check_num_zsq
  26.     @create_say('加') 
  27.     def jia(self,n):
  28.         self.__result += n
  30.     @__check_num_zsq
  31.     @create_say('减去') 
  32.     def jian(self,n):
  33.         self.__result -= n
  35.     @__check_num_zsq
  36.     @create_say('乘以')
  37.     def cheng(self,n):
  38.         self.__result *= n
  40.     def show(self):
  41.         # self.__say('计算的结果为：%d' %self.__result)
  42.         print('计算的结果为：%d' %self.__result)
  44. c1 = Caculator(2)
  45. c1.jia(6)
  46. c1.jian(4)
  47. c1.cheng(5)
  48. c1.show()

输出结果调用播报器

  1. import win32com.client
  3. class Caculator:
  4.     def create_say(word = ''):           # 定义一个函数，接收一个参数，函数内部就是一个装饰器，最终将这个装饰器返回
  5.         def __say_zsq(func):             # 装饰器                                      
  6.             def inner(self,n):
  7.                 speaker = win32com.client.Dispatch("SAPI.SpVoice")            
  8.                 speaker.Speak(word + str(n))
  9.                 return func(self,n)    
  10.             return inner
  11.         return __say_zsq                 # 将函数内部的装饰器返回出去                            
  13.     def __check_num_zsq(func):                                                    
  14.         def inner(self,n):                    
  15.             if not isinstance(n,int):
  16.                 raise TypeError("当前这个数据有问题，应该为一个数值类型")
  17.             return func(self,n)                
  18.         return inner
  20.     @__check_num_zsq                        
  21.     @create_say()                              
  22.     def __init__(self,num):
  23.         self.__result = num              
  25.     @__check_num_zsq
  26.     @create_say('加') 
  27.     def jia(self,n):
  28.         self.__result += n
  30.     @__check_num_zsq
  31.     @create_say('减去') 
  32.     def jian(self,n):
  33.         self.__result -= n
  35.     @__check_num_zsq
  36.     @create_say('乘以')
  37.     def cheng(self,n):
  38.         self.__result *= n
  40.     def show(self):
  41.         speaker = win32com.client.Dispatch("SAPI.SpVoice")            
  42.         speaker.Speak('计算的结果为：%d' %self.__result)
  43.         print('计算的结果为：%d' %self.__result)
  45. c1 = Caculator(2)
  46. c1.jia(6)
  47. c1.jian(4)
  48. c1.cheng(5)
  49. c1.show()
  1. import win32com.client
  4. class Caculator:
  5.     def __check_num_zsq(func):                                                    
  6.         def inner(self,n):                    
  7.             if not isinstance(n,int):
  8.                 raise TypeError("当前这个数据有问题，应该为一个数值类型")
  9.             return func(self,n)                
  10.         return inner
  13.     def __say(self,word):                # 单独写一个播报器            
  14.         speaker = win32com.client.Dispatch("SAPI.SpVoice")            
  15.         speaker.Speak(word)
  18.     def __create_say(word = ''):         # 定义一个函数，接收一个参数，函数内部就是一个装饰器，最终将这个装饰器返回
  19.         def __say_zsq(func):             # 装饰器                                      
  20.             def inner(self,n):
  21.                 self.__say(word + str(n))
  22.                 return func(self,n)    
  23.             return inner
  24.         return __say_zsq                 # 将函数内部的装饰器返回出去
  26.     @__check_num_zsq                        
  27.     @__create_say()                              
  28.     def __init__(self,num):
  29.         self.__result = num              
  31.     @__check_num_zsq
  32.     @__create_say('加') 
  33.     def jia(self,n):
  34.         self.__result += n
  36.     @__check_num_zsq
  37.     @__create_say('减去') 
  38.     def jian(self,n):
  39.         self.__result -= n
  41.     @__check_num_zsq
  42.     @__create_say('乘以')
  43.     def cheng(self,n):
  44.         self.__result *= n
  46.     def show(self):
  47.         self.__say('计算的结果为：%d' %self.__result)
  48.         print('计算的结果为：%d' %self.__result)
  50. c1 = Caculator(2)
  51. c1.jia(6)
  52. c1.jian(4)
  53. c1.cheng(5)
  54. c1.show()

在外界使用输出结果(描述器)

  1. import win32com.client
  4. class Caculator:
  5.     def __check_num_zsq(func):                                                    
  6.         def inner(self,n):                    
  7.             if not isinstance(n,int):
  8.                 raise TypeError("当前这个数据有问题，应该为一个数值类型")
  9.             return func(self,n)                
  10.         return inner
  13.     def __say(self,word):
  14.         speaker = win32com.client.Dispatch("SAPI.SpVoice")            
  15.         speaker.Speak(word)
  17.     def __create_say(word = ''):           # 定义一个函数，接收一个参数，函数内部就是一个装饰器，最终将这个装饰器返回
  18.         def __say_zsq(func):             # 装饰器                                      
  19.             def inner(self,n):
  20.                 self.__say(word + str(n))
  21.                 return func(self,n)    
  22.             return inner
  23.         return __say_zsq                 # 将函数内部的装饰器返回出去
  25.     @__check_num_zsq                        
  26.     @__create_say()                              
  27.     def __init__(self,num):
  28.         self.__result = num              
  30.     @__check_num_zsq
  31.     @__create_say('加') 
  32.     def jia(self,n):
  33.         self.__result += n
  35.     @__check_num_zsq
  36.     @__create_say('减去') 
  37.     def jian(self,n):
  38.         self.__result -= n
  40.     @__check_num_zsq
  41.     @__create_say('乘以')
  42.     def cheng(self,n):
  43.         self.__result *= n
  45.     def show(self):
  46.         self.__say('计算的结果为：%d' %self.__result)
  47.         print('计算的结果为：%d' %self.__result)
  49.     @property                       # 在外界使用输出结果(描述器)
  50.     def result(self):
  51.         return self.__result
  53. c1 = Caculator(2)
  54. c1.jia(6)
  55. c1.jian(4)
  56. c1.cheng(5)
  57. c1.show()
  59. print(c1.result)                    # 以调用属性的方式调用方法

return self

  1. import win32com.client
  4. class Caculator:
  5.     def __check_num_zsq(func):                                                    
  6.         def inner(self,n):                    
  7.             if not isinstance(n,int):
  8.                 raise TypeError("当前这个数据有问题，应该为一个数值类型")
  9.             return func(self,n)                
  10.         return inner
  13.     def __say(self,word):
  14.         speaker = win32com.client.Dispatch("SAPI.SpVoice")            
  15.         speaker.Speak(word)
  17.     def __create_say(word = ''):           # 定义一个函数，接收一个参数，函数内部就是一个装饰器，最终将这个装饰器返回
  18.         def __say_zsq(func):             # 装饰器                                      
  19.             def inner(self,n):
  20.                 self.__say(word + str(n))
  21.                 return func(self,n)    
  22.             return inner
  23.         return __say_zsq                 # 将函数内部的装饰器返回出去
  25.     @__check_num_zsq                        
  26.     @__create_say()                              
  27.     def __init__(self,num):
  28.         self.__result = num 
  31.     @__check_num_zsq
  32.     @__create_say('加') 
  33.     def jia(self,n):
  34.         self.__result += n
  35.         return self                      # 返回实例本身 
  37.     @__check_num_zsq
  38.     @__create_say('减去') 
  39.     def jian(self,n):
  40.         self.__result -= n
  41.         return self                      # 返回实例本身 
  43.     @__check_num_zsq
  44.     @__create_say('乘以')
  45.     def cheng(self,n):
  46.         self.__result *= n
  47.         return self                      # 返回实例本身 
  49.     def show(self):
  50.         self.__say('计算的结果为：%d' %self.__result)
  51.         print('计算的结果为：%d' %self.__result)
  53.     def clear(self):
  54.         self.__result = 0
  55.         return self
  57.     @property                            # 在外界使用输出结果(描述器)
  58.     def result(self):
  59.         return self.__result
  61. c1 = Caculator(2)
  62. c1.jia(6).jian(4).cheng(5).jia(20).clear().jia(100)             # 链式编程
  63. c1.show()
  65. print(c1.result)                        # 以调用属性的方式调用方法