流畅python学习笔记:第十一章:抽象基类

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了流畅python学习笔记:第十一章:抽象基类相关的知识,希望对你有一定的参考价值。

__getitem__实现可迭代对象。要将一个对象变成一个可迭代的对象,通常都要实现__iter__。但是如果没有__iter__的话,实现了__getitem__也可以实现迭代。我们还是用第一章扑克牌的例子来看下
class FrenchDeck:
    ranks=[str(n) for n in range(2,11)] + list(‘JQKA‘)
    suits=‘spades diamonds clubs hearts‘.split()
    def __init__(self):
        self._cards=[Card(rank,suit) for suit in self.suits for rank in self.ranks]
    def __len__(self):
        return len(self._cards)
    def __getitem__(self, position):
        return self._cards[position]

if __name__ == "__main__":
    deck=FrenchDeck()
    for d in deck:
        print d
E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter11.py
Card(rank=‘2‘, suit=‘spades‘)
Card(rank=‘3‘, suit=‘spades‘)
Card(rank=‘4‘, suit=‘spades‘)
Card(rank=‘5‘, suit=‘spades‘)
Card(rank=‘6‘, suit=‘spades‘)
Card(rank=‘7‘, suit=‘spades‘)
Card(rank=‘8‘, suit=‘spades‘)
Card(rank=‘9‘, suit=‘spades‘)
Card(rank=‘10‘, suit=‘spades‘)
Card(rank=‘J‘, suit=‘spades‘)
Card(rank=‘Q‘, suit=‘spades‘)
Card(rank=‘K‘, suit=‘spades‘)
Card(rank=‘A‘, suit=‘spades‘)
Card(rank=‘2‘, suit=‘diamonds‘)
Card(rank=‘3‘, suit=‘diamonds‘)
Card(rank=‘4‘, suit=‘diamonds‘)
Card(rank=‘5‘, suit=‘diamonds‘)
Card(rank=‘6‘, suit=‘diamonds‘)
Card(rank=‘7‘, suit=‘diamonds‘)
Card(rank=‘8‘, suit=‘diamonds‘)
Card(rank=‘9‘, suit=‘diamonds‘)
Card(rank=‘10‘, suit=‘diamonds‘)
Card(rank=‘J‘, suit=‘diamonds‘)
Card(rank=‘Q‘, suit=‘diamonds‘)
Card(rank=‘K‘, suit=‘diamonds‘)
Card(rank=‘A‘, suit=‘diamonds‘)
Card(rank=‘2‘, suit=‘clubs‘)
Card(rank=‘3‘, suit=‘clubs‘)
Card(rank=‘4‘, suit=‘clubs‘)
Card(rank=‘5‘, suit=‘clubs‘)
Card(rank=‘6‘, suit=‘clubs‘)
Card(rank=‘7‘, suit=‘clubs‘)
Card(rank=‘8‘, suit=‘clubs‘)
Card(rank=‘9‘, suit=‘clubs‘)
Card(rank=‘10‘, suit=‘clubs‘)
Card(rank=‘J‘, suit=‘clubs‘)
Card(rank=‘Q‘, suit=‘clubs‘)
Card(rank=‘K‘, suit=‘clubs‘)
Card(rank=‘A‘, suit=‘clubs‘)
Card(rank=‘2‘, suit=‘hearts‘)
Card(rank=‘3‘, suit=‘hearts‘)
Card(rank=‘4‘, suit=‘hearts‘)
Card(rank=‘5‘, suit=‘hearts‘)
Card(rank=‘6‘, suit=‘hearts‘)
Card(rank=‘7‘, suit=‘hearts‘)
Card(rank=‘8‘, suit=‘hearts‘)
Card(rank=‘9‘, suit=‘hearts‘)
Card(rank=‘10‘, suit=‘hearts‘)
Card(rank=‘J‘, suit=‘hearts‘)
Card(rank=‘Q‘, suit=‘hearts‘)
Card(rank=‘K‘, suit=‘hearts‘)
Card(rank=‘A‘, suit=‘hearts‘)

从输出结果可以看到,通过for d in deck迭代的方式也能遍历整个_card数组。迭代器环境会先尝试__iter__方法,在尝试__getitem__.也就是如果对象不支持迭代协议,就会尝试索引运算。迭代环境是通过调用内置函数iter去尝试__iter__方法来实现的,这种方法返回一个迭代器对象,如果提供Python就会重复调用这个迭代器对象的next方法,知道发生StopIteration异常,如果没找到这类__iter__方法,Python就会改用__getitem__机制,通过偏移量重复索引,直至发生IndexError异常

但是这个FrenchDeck有个问题:无法洗牌,从上面的结果来看,发票的顺序都是按照每个花色依次排列好的。那么如何洗牌了。这就需要用到随机数的方法了
我们用random.shuffle的方法来做随机数:
list=[1,2,3]
random.shuffle(list)
print list
得到的结果是[3, 2, 1]
Shuffle的实现代码如下:
if random is None:
    random = self.random
_int = int
for i in reversed(xrange(1, len(x))):
    # pick an element in x[:i+1] with which to exchange x[i]
   
j = _int(random() * (i+1))
    x[i], x[j] = x[j], x[i]
其实也比较简单,就是通过产生随机数来颠倒列表中的排列。那么是否可以根据这个函数来对扑克牌进行随机排列呢。我们来试下:
deck=FrenchDeck()
random.shuffle(deck)
for d in deck:
    print d
E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter11.py
Traceback (most recent call last):
  File "E:/py_prj/fluent_python/chapter11.py", line 32, in <module>
    random.shuffle(deck)
  File "E:\python2.7.11\lib\random.py", line 291, in shuffle
    x[i], x[j] = x[j], x[i]
AttributeError: FrenchDeck instance has no attribute ‘__setitem__‘
提示没有实现__setitem__, 为什么会错误呢。在Traceback里面已经写得很清楚了,因为:x[i], x[j] = x[j], x[i]。__getitem__是在deck[i]的时候调用,但是要赋值的时候比如deck[i]=value的时候得调用__setitem__
因此我们需要加上__setitem__:
def __setitem__(self, key, value):
    self._cards[key]=value
再次运行得到结果如下:可以看到扑克牌完全是随机排列的了
E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter11.py
Card(rank=‘10‘, suit=‘diamonds‘)
Card(rank=‘3‘, suit=‘hearts‘)
Card(rank=‘4‘, suit=‘diamonds‘)
Card(rank=‘A‘, suit=‘clubs‘)
Card(rank=‘4‘, suit=‘spades‘)
Card(rank=‘K‘, suit=‘clubs‘)
Card(rank=‘8‘, suit=‘clubs‘)
Card(rank=‘2‘, suit=‘clubs‘)
Card(rank=‘8‘, suit=‘hearts‘)
Card(rank=‘7‘, suit=‘diamonds‘)
Card(rank=‘5‘, suit=‘hearts‘)
Card(rank=‘10‘, suit=‘hearts‘)
Card(rank=‘6‘, suit=‘hearts‘)
Card(rank=‘Q‘, suit=‘clubs‘)
Card(rank=‘J‘, suit=‘hearts‘)
Card(rank=‘10‘, suit=‘spades‘)
Card(rank=‘9‘, suit=‘spades‘)
Card(rank=‘2‘, suit=‘diamonds‘)
Card(rank=‘2‘, suit=‘spades‘)
Card(rank=‘10‘, suit=‘clubs‘)
Card(rank=‘3‘, suit=‘clubs‘)
Card(rank=‘5‘, suit=‘spades‘)
Card(rank=‘5‘, suit=‘clubs‘)
Card(rank=‘Q‘, suit=‘hearts‘)
Card(rank=‘3‘, suit=‘diamonds‘)
Card(rank=‘J‘, suit=‘spades‘)
Card(rank=‘7‘, suit=‘spades‘)
Card(rank=‘8‘, suit=‘spades‘)
Card(rank=‘6‘, suit=‘spades‘)
Card(rank=‘Q‘, suit=‘diamonds‘)
Card(rank=‘9‘, suit=‘diamonds‘)
Card(rank=‘8‘, suit=‘diamonds‘)
Card(rank=‘4‘, suit=‘clubs‘)
Card(rank=‘6‘, suit=‘diamonds‘)
Card(rank=‘9‘, suit=‘clubs‘)
Card(rank=‘K‘, suit=‘spades‘)
Card(rank=‘4‘, suit=‘hearts‘)
Card(rank=‘J‘, suit=‘diamonds‘)
Card(rank=‘5‘, suit=‘diamonds‘)
Card(rank=‘6‘, suit=‘clubs‘)
Card(rank=‘A‘, suit=‘spades‘)
Card(rank=‘9‘, suit=‘hearts‘)
Card(rank=‘K‘, suit=‘diamonds‘)
Card(rank=‘7‘, suit=‘clubs‘)
Card(rank=‘A‘, suit=‘hearts‘)
Card(rank=‘Q‘, suit=‘spades‘)
Card(rank=‘A‘, suit=‘diamonds‘)
Card(rank=‘J‘, suit=‘clubs‘)
Card(rank=‘3‘, suit=‘spades‘)
Card(rank=‘2‘, suit=‘hearts‘)
Card(rank=‘7‘, suit=‘hearts‘)
Card(rank=‘K‘, suit=‘hearts‘)
抽象基类:
抽象基类的作用类似于JAVA中的接口。在接口中定义各种方法,然后继承接口的各种类进行具体方法的实现。抽象基类就是定义各种方法而不做具体实现的类,任何继承自抽象基类的类必须实现这些方法,否则无法实例化。
那么抽象基类这样实现的目的是什么呢? 假设我们在写一个关于动物的代码。涉及到的动物有鸟,狗,牛。首先鸟,狗,牛都是属于动物的。既然是动物那么肯定需要吃饭,发出声音。但是具体到鸟,狗,牛来说吃饭和声音肯定是不同的。
需要具体去实现鸟,狗,牛吃饭和声音的代码。概括一下抽象基类的作用:定义一些共同事物的规则和行为。
来看下具体的代码实现,定义一个抽象基类的简单方法如下: 首先在Dog,Bird,Cow都继承自Animal。 在Animal中定义了eat和voice两个方法
任何从Animal中继承的子类都必须实现eat和voice方法。否则调用的时候会报错class Animal(object):

    def eat(self):
        raise NotImplementedError
    def voice(self):
        raise NotImplementedError

class Dog(Animal):
    def voice(self):
        print ‘wow....‘

class
Bird(Animal):
    def voice(self):
        print ‘jiji....‘

class
Cow(Animal):
    def voice(self):
        print ‘Oh.....‘

if
__name__ == "__main__":
    d=Dog()
    d.voice()
d.eat()
执行结果如下, voice可以正常执行,但是eat却报错了
E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter11.py
wow....
Traceback (most recent call last):
  File "E:/py_prj/fluent_python/chapter11.py", line 54, in <module>
    d.eat()
  File "E:/py_prj/fluent_python/chapter11.py", line 33, in eat
    raise NotImplementedError
NotImplementedError
这样实现有个缺点,就是只有子类调用eat方法的时候才会报错。子类是可以正常实例化的。但是你能够想象鸟,狗,牛不会吃饭么? 如果不会吃饭那肯定不算是动物了。所以正常的实现应该是如果没有实现eat方法,实例化就应该是失败的。那么这里就要用到抽象基类的一般使用方法.代码修改如下:
Import abc
class Animal(object):
    __metaclass__ = abc.ABCMeta
    @abc.abstractmethod
    def eat(self):
        return
   
@abc.abstractmethod
    def voice(self):
        return
if __name__ == "__main__":
    d=Dog()
结果如下,代码无法实例化,提示没有实现eat方法。这样就完美的达到了我们的目的。
E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter11.py
Traceback (most recent call last):
  File "E:/py_prj/fluent_python/chapter11.py", line 56, in <module>
    d=Dog()
TypeError: Can‘t instantiate abstract class Dog with abstract methods eat
 
完整代码修改如下class Animal(object):
    __metaclass__ = abc.ABCMeta
    @abc.abstractmethod
    def eat(self):
        return
   
@abc.abstractmethod
    def voice(self):
        return

class
Dog(Animal):
    def voice(self):
        print ‘wow....‘
    def
eat(self):
        print ‘Dog eat....‘

class
Bird(Animal):
    def voice(self):
        print ‘jiji....‘
    def
eat(self):
        print ‘Bird eat....‘

class
Cow(Animal):
    def voice(self):
        print ‘Oh.....‘
    def
eat(self):
        print ‘Cow eat....‘

if
__name__ == "__main__":
    d=Dog()
    b=Bird()
    c=Cow()
    d.voice()
    d.eat()
    b.voice()
    b.eat()
    c.voice()
    c.eat()
E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter11.py
wow....
Dog eat....
jiji....
Bird eat....
Oh.....
Cow eat....
除了继承,还有一种注册的方法可以将类和抽象基类关联起来:Animal.register(Cat)
class Cat(object):
    def voice(self):
        print ‘miao.....‘
    def
eat(self):
        print ‘Cat eat....‘

Animal.register(Cat)

if __name__ == "__main__":
    c=Cat()
    c.eat()
    c.voice()
E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter11.py
Cat eat....
miao...
继承和注册这两种方法有什么区别呢:区别在于通过继承能够看到继承抽象基类的所有类,而用注册的方法却看不到。
for sc in Animal.__subclasses__():
    print sc.__name__
E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter11.py
Dog
Bird
Cow
执行结果里面,只有Dog,Bird,Cow并没有Cat
最后介绍一种抽象子类的注册方式:__subclasshook__
class Animal(object):
    __metaclass__ = abc.ABCMeta
    @abc.abstractmethod
    def eat(self):
        return
   
@abc.abstractmethod
    def voice(self):
        return
   
@classmethod
    def __subclasshook__(cls, c):
        if cls is Animal:  :⑴
            if any("eat" in cat.__dict__ for cat in c.__mro__):⑵
                return True    
        return NotImplementedError  ⑶
 
class Cat(object):
    def voice(self):
        print ‘miao.....‘
    def
eat(self):
        print ‘Cat eat....‘
 
if __name__ == "__main__":
    c=Cat()
    print isinstance(Cat(),Animal)
    print Animal.__subclasshook__(Cat)
E:\python2.7.11\python.exe E:/py_prj/fluent_python/chapter11.py
True
True
(1)首先判断cls是否属于Animal,在这里__subclasshook__被classmethod修饰,证明是一个对象的方法,因此cls肯定等于Animal
(2)首先得到c.__mro__. 当调用isinstance(Cat(),Animal)或者Animal.__subclasshook__(Cat)的时候,c就是Cat,c.__mro__就是得到Cat以及Cat的父类。c.__mro__=(<class ‘__main__.Cat‘>, <type ‘object‘>)。  然后看下在Cat以及Cat的父类object的属性中是否有eat方法的实现,这里可以用eat或者voice方法来判断。如果是,则返回True
(3)否则返回NotImplementedError























































































































以上是关于流畅python学习笔记:第十一章:抽象基类的主要内容,如果未能解决你的问题,请参考以下文章

我的学习之路_第十一章_字符流

《JAVA编程思想》学习笔记——第十一章 持有对象

o'Reill的SVG精髓(第二版)学习笔记——第十一章

JavaScript DOM编程艺术-学习笔记(第十章第十一章)

[core java学习笔记][第十一章异常断言日志调试]

python全栈开发学习目录