每天开心一点

Python--类的设计

2017-11-30 16:15:00    六月    775    来源： http://blog.csdn.net/gavin_john/article/details/50729802
类的设计

这里讨论Python的OOP的设计问题，也就是如何使用类来对有用的对象进行建模。将编写Python中常用的OOP设计模式，例如，继承、组合、委托和工厂。另外介绍一些类设计的概念，例如伪私有属性、多继承等。

================================================================================

Python和OOP

Python的OOP实现与Java类似，可以概括为三个概念：

1.【继承】继承是基于Python中的属性查找(在X.name表达式中)
2.【多态】在X.method方法中，method的意义取决于X的类型
3.【封装】方法和运算符实现行为，数据隐藏默认是一种惯例

================================================================================

OOP和继承：“是一个”关系


举例说明：披萨店团队可以通过文件employees.py中的四个类来定义。最通用的类Employee提供共同行为，例如，加薪(giveRaise)和打印(__repr__)。员工有两种，所以Employee有两个子类：Chef和Server(厨师和服务员)。这两个子类都会覆盖继承的work方法来打印更具体的信息。最后，披萨机器人是由更具体的类来模拟：PizzaRobot是一种Chef，也是一种Employee。以OOP术语来看，这些关系为“是一个”(is-a)链接：机器人是一个主厨，而主厨是一个员工。代码编写如下：

[python] view plain copy print ?
  1. #File employees.py   
  2.   
  3. class  Employee:  
  4.      def  __init__( self ,name,salary =  0 ):  
  5.          self .name = name  
  6.          self .salary = salary  
  7.      def  giveRaise( self ,percent):  
  8.          self .salary =  self .salary + ( self .salary * percent)  
  9.      def  work( self ):  
  10.          print ( self .name, 'does stuff' )  
  11.      def  __repr__( self ):  
  12.          return   '<Employee : name = %s , salary = %s>' %( self .name, self .salary)  
  13.   
  14. class  Chef(Employee):  
  15.      def  __init__( self ,name):  
  16.         Employee.__init__( self ,name, 50000 )  
  17.      def  work( self ):  
  18.          print ( self .name, "makes food" )  
  19.   
  20. class  Server(Employee):  
  21.      def  __init__( self ,name):  
  22.         Employee.__init__( self ,name, 40000 )  
  23.      def  work( self ):  
  24.          print ( self .name, 'interfaces with customer' )  
  25.   
  26. class  PizzaRobot(Chef):  
  27.      def  __init__( self ,name):  
  28.         Chef.__init__( self ,name)  
  29.      def  work( self ):  
  30.          print ( self .name, 'makes pizza' )  
  31.   
  32.   
  33. if  __name__ ==  '__main__' :  
  34.     bob = PizzaRobot( 'bob' )  
  35.      print (bob)  
  36.     bob.work()  
  37.     bob.giveRaise(. 2 )  
  38.      print (bob)  
  39.      print ()  
  40.   
  41.      for  klass  in  Employee,Chef,Server,PizzaRobot:  
  42.         obj = klass(klass.__name__)  
  43.         obj.work()  
运行结果如下：

[python] view plain copy print ?
  1. <Employee : name = bob , salary =  50000 >  
  2. bob makes pizza  
  3. <Employee : name = bob , salary =  60000.0 >  
  4.   
  5. Employee does stuff  
  6. Chef makes food  
  7. Server interfaces with customer  
  8. PizzaRobot makes pizza  
可以看到，bob是一个PizzaRobot，但是打印的时候，依然显示是Employee，从结果看不出他具体属于哪一类员工，这时候可以修改Employee类中的__repr__方法如下：

[python] view plain copy print ?
  1. def  __repr__( self ):  
  2.          return   '<%s : name = %s , salary = %s>' %( self .__class__.__name__, self .name, self .salary)  
其中，self.__class__.__name__，可以返回实例所属类的名称，修改之后执行结果如下：
[python] view plain copy print ?
  1. <PizzaRobot : name = bob , salary =  50000 >  
  2. bob makes pizza  
  3. <PizzaRobot : name = bob , salary =  60000.0 >  
  4.   
  5. Employee does stuff  
  6. Chef makes food  
  7. Server interfaces with customer  
  8. PizzaRobot makes pizza  
================================================================================

OOP和组合：“有一个”关系

组合涉及把其他对象嵌入容器对象内，并使用其容器方法。组合反映了各组成部分之间的关系，通常称为“有一个”（has-a）关系。
接着上边的例子，既然我们已经有了员工，就把他们放到我们披萨店。披萨店是一个组合对象，有个烤炉，也有服务员和主厨这些员工。当顾客来店里下单时，店里的组件就会开始行动：服务员接单，主厨制作披萨，等等。看下边的例子pizzashop.py.

[python] view plain copy print ?
  1. #File pizzashop.py   
  2.   
  3. from  employees  import  PizzaRobot,Server  
  4.   
  5. class  Customer:  
  6.      def  __init__( self ,name):  
  7.          self .name = name  
  8.      def  order( self ,server):  
  9.          print ( self .name, 'orders from' ,server)  
  10.      def  pay( self ,server):  
  11.          print ( self .name, 'pays for item to' ,server)  
  12.   
  13. class  Oven:  
  14.      def  bake( self ):  
  15.          print ( 'oven bakes' )  
  16.   
  17. class  PizzaShop:  
  18.      def  __init__( self ):  
  19.          self .server = Server( 'Pat' )  #组合其他对象   
  20.          self .chef = PizzaRobot( 'Bob' )  #一个名叫Bob的机器人主厨   
  21.          self .oven = Oven()  
  22.   
  23.      def  order( self ,name):  
  24.         customer = Customer(name)  
  25.         customer.order( self .server)  
  26.          self .chef.work()  
  27.          self .oven.bake()  
  28.         customer.pay( self .server)  
  29.   
  30. if  __name__ ==  '__main__' :  
  31.     scene = PizzaShop()  
  32.     scene.order( 'Homer' )  #模拟Homer的订单   
  33.      print ( '...' )  
  34.     scene.order( 'Shaggy' )  #模拟Shaggy的订单   
这里，PizzaShop是类的容器和控制器。当执行这个模块时，我们的披萨店处理了两份订单：一份来自Hommer，另一份来自Shaggy。
[python] view plain copy print ?
  1. Homer orders  from  <Server : name = Pat , salary =  40000 >  
  2. Bob makes pizza  
  3. oven bakes  
  4. Homer pays  for  item to <Server : name = Pat , salary =  40000 >  
  5. ...  
  6. Shaggy orders  from  <Server : name = Pat , salary =  40000 >  
  7. Bob makes pizza  
  8. oven bakes  
  9. Shaggy pays  for  item to <Server : name = Pat , salary =  40000 >  
================================================================================
OOP和委托：“包装”对象

所谓“委托”，通常就是指控制器对象内嵌其他对象，而把运算请求传给那些对象。
在Python中，委托通常是以__getattr__钩子方法实现的，因为这个方法会拦截对不存在属性的读取，包装类可以使用__getattr__把任意读取转发给被包装的对象。包装类包有被包装对象的接口，而且自己也可以增加其他运算。

例如，考虑下例：
[python] view plain copy print ?
  1. >>>  class  wrapper:  
  2.      def  __init__( self ,object):  
  3.          self .wrapped = object  
  4.      def  __getattr__( self ,attrname):  
  5.          print ( 'Trace:' ,attrname)  
  6.          return  getattr( self .wrapped,attrname)  
__getattr__会获得属性名称字符串。这个程序利用getattr内置函数，以变量名字符串从包裹对象取出属性：getattr（X,N）就像是X.N，只不过N是表达式，可在运行时计算出字符串，而不是变量。事实上，getattr(X,N)类似于X.__dict__[N]。

你可以使用这个模块包装类的做法，管理任何带有属性的对象的存取：列表、字典甚至是类和实例。在这里，wrapper类只是在每个属性读取时打印跟踪消息，并把属性请求委托给嵌入的对象wrapped
[python] view plain copy print ?
  1. >>> x = wrapper([ 1 , 2 , 3 ])  
  2. >>> x.append( 4 )  
  3. Trace: append  
  4. >>> x.wrapped  
  5. [ 1 ,  2 ,  3 ,  4 ]  
  6. >>>   
  7. >>> x = wrapper({ 'a' : 1 , 'b' : 2 })  
  8. >>> x.keys()  
  9. Trace: keys  
  10. dict_keys([ 'b' ,  'a' ])  
实际的效果就是以包装类内额外的代码来增强被包装的对象的整个接口。我们可以利用这种方式记录方法调用，把方法调用转给其他或定制的逻辑等。
================================================================================
类的伪私有属性——变量名压缩

Python支持变量名压缩的概念，让类内的某些变量局部化，但名称压缩并无法阻止类外部代码对它的读取，这种功能主要是为了避免实例内的命名空间的冲突，而不是限制变量名的读取。因此，压缩的变量名最好称为“伪私有”。

当然，伪私有属性是高级且完全可选的功能，但由于你可能在其他人的代码中看见这个功能，所以即使不用，多少还得留意。

【变量名压缩的工作方式是这样的：class语句内开头有两个下划线，但结尾没有两个下划线的变量名，会自动扩张，从而包含了所在类的名称。】
例如，像Spam类内__X这样的变量名会自动变成_Spam__X:原始的变量名会在头部加入一个下划线，然后是所在类的名称。因为修改后的变量名包含了所在类的名称，相当于变得独特。不会和同一层次中其他类所创建的类似变量名冲突。

变量名压缩只发生在class语句内，而且只针对开头有两个下划线的变量名。

为什么要使用伪私有属性，举例如下：
一个程序员编写的一个类，他认为属性X在该实例中：

[python] view plain copy print ?
  1. class  C1:  
  2.      def  meth1( self ): self .X =  88   
  3.      def  meth2( self ): print ( self .X)  
另一个程序员独立作业，也写了这样一个类，他有同样的假设：
[python] view plain copy print ?
  1. class  C2:  
  2.      def  metha( self ): self .X =  99   
  3.      def  methb( self ): print ( self .X)  
如果这两个类混合在相同的类树中时，问题就产生了：
[python] view plain copy print ?
  1. class  C3(C1,C2):...  
  2. I = C3()  
因为C1和C2中的变量名都是X，所以I中只能有一个X，取决于最后一个赋值的是哪个类，这样就使得其中一个数据被无缘无故丢掉了。

为了保证属性会属于使用它的类，可在类中任何地方使用，将变量名前加上两个下划线：
[python] view plain copy print ?
  1. >>>  class  C1:  
  2.      def  meth1( self ): self .__X =  88   
  3.      def  meth2( self ): print ( self .__X)  
  4.   
  5.       
  6. >>>  class  C2:  
  7.      def  metha( self ): self .__X =  99   
  8.      def  methb( self ): print ( self .__X)  
  9.   
  10.       
  11. >>>  class  C3(C1,C2): pass   
  12.   
  13. >>> I = C3()  
  14. >>> I.meth1();I.metha()  
  15. >>>  print (I.__dict__)  
  16. { '_C1__X' :  88 ,  '_C2__X' :  99 }  
这样，X属性就会扩张，从而包含它的类的名称，然后才加到实例中。查看其命名空间字典可以看到变量变成了_C1__X和_C2__X。

但这并不是真正的私有，你依然可以使用扩张后的变量名，例如，I._C1__X = 77
================================================================================

多重继承：“混合”类

在class语句中，首行括号内可以列出一个以上的超类。当这么做时，就是在使用所谓的【多重继承】。

搜索属性时，Python会由左至右搜索首行中的超类，直到找到相符者。

通常来说，多重继承是建模属于一个集合以上的对象的好办法。例如，一个人可以是工程师、作家、音乐家等，因此，可继承这些集合的特性。

================================================================================

类是对象：通用对象的工厂

[python] view plain copy print ?
  1. >>>  def  factory(aClass,*args):  
  2.      return  aClass(*args)  
  3.   
  4. >>>  class  Spam:  
  5.      def  doit( self ,message):  
  6.          print (message)  
  7.   
  8. >>>  class  Person:  
  9.      def  __init__( self ,name,job):  
  10.          self .name = name  
  11.          self .job = job  
  12.   
  13. >>> obj1 = factory(Spam)  
  14. >>> obj2 = factory(Person, 'Guido' , 'gurr' )  
在这段代码中， 我们定义了一个对象生成器函数，称为factory。它预期传入的是类对象，还有该类构造函数的一个或多个参数。
然后定义了两个类，并将其传给factory函数以产生两者的实例。这就是Python中编写工厂函数所需要做的事。它适用于任何类以及任何构造函数参数。

这类工厂可以将代码和动态配置对象的构造细节隔离开，也许以后会用到。

最后编辑：六月 于 2017-12-22 08:28:58

发表评论