python基础整理笔记（七）

一. python的类属性与实例属性的注意点

 class TestAtt():
     aaa = 10

 def main():
     # case 1
     obj1 = TestAtt()
     obj2 = TestAtt()
     print obj1.aaa, obj2.aaa, TestAtt.aaa

     # case 2
     obj1.aaa += 1
     print obj1.aaa, obj2.aaa, TestAtt.aaa

     # case 3
     TestAtt.aaa += 2
     print obj1.aaa, obj2.aaa, TestAtt.aaa

 if __name__ == '__main__':
     main()

一段示例代码，一个类TestAtt只有一个类对象，然后通过改变其不同对象的属性和类的属性，结果如下：

改变的似乎挺特殊，分析原因如下：

python中的属性获取机制，是从底层的对象到上层中一点点找的；在第一次获取obj1.aaa, obj2.aaa的时候，因为这个类并没有初始化实例的属性，所以其实obj1和obj2并没有aaa这个属性，所以实质上obj1.aaa, obj2.aaa都是TestAtt.aaa。

而对于 case2，obj1.aaa += 1这个操作实际上是给obj1这个实例创建了aaa的属性（以TestAtt.aaa的值再加1），所以从case2来看它的值就单独改变了，而且在case3中也没再受到影响。

现在我把代码修改如下再运行下结果，打印出每个实例的__dict__：

 def main():
     # case 1
     obj1 = TestAtt()
     obj2 = TestAtt()
     print obj1.aaa, obj2.aaa, TestAtt.aaa
     print obj1.__dict__
     print obj2.__dict__

     # case 2
     obj1.aaa += 1
     print obj1.aaa, obj2.aaa, TestAtt.aaa
     print obj1.__dict__
     print obj2.__dict__

     # case 3
     TestAtt.aaa += 2
     print obj1.aaa, obj2.aaa, TestAtt.aaa
     print obj1.__dict__
     print obj2.__dict__

这样看就很明显，可以证明上述的情况。

二. python多重继承注意点：

在python2.7里面有经典类和新式类之分，前者定义时没有明式的继承，后者会继承object类。

在多重继承后寻找属性的时候，二者的行为有一个明显的区别：

经典类是深度优先地搜索——会在条继承链上线搜索到底，再到下一个优先级的继承链上搜索，以此类推。外部的优先级是从左到右。

形式类是广度优先地搜索——在同一代际的继承者们之间按照优先级水平搜索，这一代际搜索不到，再向更上层的父辈里寻找，以此类推。外部的优先级是从左到右。

示例代码如下：

 class A(object):
     def foo(self):
         print "class A" 

 class A1():
     def foo(self):
         print "class A1"  

 class C(A):
     pass

 class C1(A1):
     pass

 class D(A):
     def foo(self):
         print "class D"  

 class D1(A1):
     def foo(self):
         print "class D1"  

 class E(C, D):
     pass

 class E1(C1, D1):
     pass

 e = E()
 e.foo()

 e1 = E1()
 e1.foo()

这里字母后带数字的是经典类，不带的是新式类，然后我们运行一下结果：

证明了上面的说法。

但是我们看看在python3中的表现，一样的代码结果如下：

所以在python3中，其实并没有所谓经典类和形式类的区别了，而且多重继承的顺序统一为深度优先了。

三.  python特殊的继承多个类的特性

在python中，一个类其实可以继承多个不同的类，这在静态语言里面一般是不允许的，因为可能会存在歧义，而在python中解决歧义的方法，是通过确定继承的顺序来解决的，具体的顺序有几种情况，我在上面的章节已经提过了。

这里要说的一种设计思路叫“maxin”，在python中就可以通过继承多个类的方式来实现之。

看看所谓的maxin的定义：

根据stackoverflow里面的说法，使用maxin的场景如下：

• 你希望给一个类提供很多可选的特征(feature).
• 你希望在很多不同的类中使用一个特定的特征(feature).

看着比较抽象...其实这就是一种更好的减少重复代码的模式。举个例子~（这是赖勇浩博客里的一个例子）

比如我们有个基类是fruit，然后有子类apple和banana；fruit有个方法是is_gift_fruit，表示是否可以作为礼物，而apple和banana表现是不一样的，那么实现如下：

 class Fruit(object):
        pass

 class Apple(Fruit):
        def is_gift_fruit(self):
               return True

 class Banana(Fruit):
        def is_gift_fruit(self):
               return False

如果还有增加很多不同水果的子类，那么这个 is_gift_fruit就会显得很不好，重复很多并且不易维护，这时候就可以定义一个新的类，就是为了体现是否可以作为礼物的类。然后用到多继承的方式来实现一样的效果，代码如下：

class Fruit(object):
       pass

class GiftMixin(object):
       def is_gift_fruit(self):
              return True

class NotGiftMixin(object):
       def is_gift_fruit(self):
              return False

class Apple(GiftMixin, Fruit):pass
class Banana(NotGiftMixin, Fruit):pass

有了上述思路，我们就可以继续再添加更多不同的行为，都将他们抽象为新的maxin类，而不用写很多臃肿的，多重继承的中间子类；比如我们可以增加是进口的还是国产的类，是有机的还是转基因的类，示例如下：

 class Fruit(object):
        pass

 class GiftMixin(object):
        def is_gift_fruit(self):
               return True

 class NotGiftMixin(object):
        def is_gift_fruit(self):
               return False

 class NativeMixin(object):
        def Locality(self):
               return 'Native'

 class ForeignMixin(object):
        def Locality(self):
               return 'Foreign'

 class OrganicMixin(object):
        def Organic(self):
               return 'Organic'

 class TransgenosisMixin(object):
        def Transgenosis(self):
               return 'Transgenosis'

 class Apple(GiftMixin, ForeignMixin, OrganicMixin, Fruit):pass
 class Banana(NotGiftMixin, NativeMixin, TransgenosisMixin, Fruit):pass
 class  Pear(NotGiftMixin, NativeMixin, OrganicMixin, Fruit):pass

这样代码就会显得很好看，而且如果还有蔬菜，豆类等等的基类，我们也可以复用上这些maxin的类。