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的类。