Day7面向对象高级编程2/3

多重继承

class Animal(object):
    pass

class Mammal(Animal):
    pass

class Bird(Animal):
    pass

class Dog(Mammal):
    pass

class Bat(Mammal):
    pass

class Parrot(Bird):
    pass

class Ostrich(Bird):
    pass

class Runnable(object):
    def run(self):
        print('Running...')

class Flyable(object):
    def fly(self):
        print('Flying...')

class Dog(Mammal, Runnable):
    pass

class Bat(Mammal,Flyable):
    pass

通过多重继承，一个子类就可以同时获得多个父亲的所有功能。

MixIn

在设计类的继承关系时，通常，主线都是单一继承下来的，例如，Ostrich继承自Bird。但是，如果需要“混入”额外的功能，通过多重继承就可以实现，比如，让Ostrich除了继承自Bird外，再同时继承Runnable。这种设计通常称之为MixIn。
为了更好地看出继承关系，我们把Runnable和Flyable改为RunnableMixIn和FlyableMixIn。类似的，你还可以定义出肉食动物CarnivorousMixIn和植食动物HerbivoresMixIn，让某个动物同时拥有好几个MixIn:

class Dog(Mammal, RunnableMixIn, CarnivorousMixIn):
    pass

MixIn的目的就是给一个类增加多个功能，这样，在设计类的时候，我们优先考虑通过多重继承来组合多个MixIn的功能，而不是设计多层次的复杂的继承关系。
编写一个多进程模式的TCP服务，定义如下：

class MyTCPServer(TCPServer, ForkingMixIn):
    pass

编写一个多线程模式的UDP服务，定义如下：

class MyUDPServer(UDPServer, ThreadingMixIn):
    pass

如果你打算搞一个更先进的协程模型，可以编写一个CoroutineMixIn：

class MyTCPServer(TCPServer, CoroutineMixIn):
    pass

这样一来，我们不需要复杂而庞大的继承链，只要选择组合不同的类的功能，就可以快速构造出所需的子类。

---

定制类

>>> class Student(object):
...     def __init__(self, name):
...         self.name = name
...
>>> print(Student('Innove'))
<__main__.Student object at 0x060D6B90>

打印出一堆<__main__.Student object at 0x060D6B90>，不好看。
怎么才能打印得好看呢？只需要定义好__str__()方法，返回一个好看的字符串就可以了：

>> class Student(object):
...     def __init__(self, name):
...         self.name = name
...     def __str__(self):
...         return 'Student object (name: %s)' % self.name
...
>>> print(Student('Innove'))
Student object (name: Innove)

但是量不用print，打印出来的实例还是不好看：

 s = Student('Innove')
>>> s
<__main__.Student object at 0x0599D8B0>

class Student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'Student object (name=%s)' % self.name
    __repr__ = __str__

>>> s = Student('Innove')
>>> s
Student object(name:Innove)

__ iter__

class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1 # 初始化两个计数器a，b

    def __iter__(self):
        return self # 实例本身就是迭代对象，故返回自己

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b # 计算下一个值
        if self.a > 1000: # 退出循环的条件
            raise StopIteration()
        return self.a # 返回下一个值

>>> for n in Fib():
    print(n)

    
1
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987

__ getitem__

__getitem__方法可以按照下标取出元素。

class Fib(object):
    def __getitem__(self,n):
        a , b = 1 , 1
        for x in range(n):
            a, b = b, a + b
        return a

>>> Fib()[24]
75025
>>> Fib()[197]
107168651819712326877926895128666735145224

__getitem__()传入的参数可能是一个int，也可能是一个切片对象slice，如果要切片需要做判断：

class Fib(object):
    def __getitem__(self,n):
        if isinstance(n,int):
            a , b = 1 , 1
            for x in range(n):
                a, b = b, a + b
            return a

        if isinstance(n,slice):
            start = n.start
            stop = n.stop
            if start is None:
                start = 0
            a, b = 1, 1
            L = []
            for x in range(stop):
                if x >= start:
                    L.append(a)
                a, b = b, a + b
            return L

>>> f[3:8]
[3, 5, 8, 13, 21]
>>> f[3:8:2]
[3, 5, 8, 13, 21]

没有对负数和step参数的处理。

__ getattr__

Python的一个机制，写一个getattr()方法，动态返回一个属性。

class Student(object):

    def __init__(self):
        self.name = 'Innove'

    def __getattr__(self,attr):
        if attr == 'score':
            return 77

>>> Student().score
77
>>> Student().name
'Innove'

也可以返回函数:

class Student(object):

    def __getattr__(self, attr):
        if attr=='age':
            return lambda: 22

>>> Student().age()    #注意调用方式
25

任意调用如Student().abc都会返回None，这是因为我们定义的__getattr__默认返回就是None。要让class只响应特定的几个属性，我们就要按照约定，抛出AttributeError的错误：

class Student(object):

    def __getattr__(self, attr):
        if attr=='age':
            return lambda: 25
        raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)

利用完全动态的__getattr__，我们可以写出一个链式调用：

class Chain(object):

    def __init__(self, path=''):
        self._path = path

    def __getattr__(self, path):
        return Chain('%s/%s' % (self._path, path))

    def __str__(self):
        return self._path

    __repr__ = __str__

>>> Chain().status.user.timeline.list
'/status/user/timeline/list'

__ call__

任何类，只需要定义一个__call__()方法，就可以直接对实例进行调用。

class Student(object):
    def __init__(self, name):
        self.name = name

    def __call__(self):
        print('My name is %s.' % self.name)

>>> s = Student('Michael')
>>> s() # self参数不要传入
My name is Michael.

__call__()还可以定义参数。对实例进行直接调用就好比对一个函数进行调用一样，所以你完全可以把对象看成函数，把函数看成对象，因为这两者之间本来就没啥根本的区别。
那么，怎么判断一个变量是对象还是函数呢？其实，更多的时候，我们需要判断一个对象是否能被调用，能被调用的对象就是一个Callable对象，比如函数和我们上面定义的带有__call__()的类实例：

>>> callable(Student())
True
>>> callable(max)
True
>>> callable([1, 2, 3])
False
>>> callable(None)
False
>>> callable('str')
False

通过callable()函数，我们就可以判断一个对象是否是“可调用”对象。

return Chain('%s/%s'% (self._path,attr))这句话表示返回Chain类的一个对象
Chain().a('mike').b.c.e.f，这句话总共执行了7次函数。
这句话相当于以下几句

ch=Chain()
a=Chain.a
amike=a()
b=aminke.b
c=b.c
e=c.e
f=c.f
print(f)

1. 第一次，Chain()，这个和其他类一样，调用Chain类的构造函数，返回一个Chain类的对象，假设命名为ch，path=''；
2. 第二次，对ch变量调用他的a属性，因为不存在，调用__getattr__函数，返回一个Chain对象，这个时候里面的path就是''+'/'+'a'='/a'
3. 第三次把a对象当做函数调用，参数是'mike'，显然函数不存在，调用__call__方法，参数传进去，并且将新对象返回，这个时候返回的还是一个Chain的对象，path='/a'+':'+'mike'='/a:mike'
4. 同第二步
5. 同第二步
6. 同第二步
7. 同第二步
8. 打印输出对象的path，为'/a:mike/b/c/e/f'

---

class Chain(object):
    def __init__(self,path=""):
        self._path = path
    def __getattr__(self,path):
        return Chain("%s/%s" %(self._path,path))    #返回实例并将path传入
    def __call__(self,path):
        return Chain("%s/%s" %(self._path,path))
    def __str__(self):
        return self._path
    __repr__ = __str__
    
print(Chain().a.b.user("Michael").c.d)

代码执行流程：
Chain()创建一个实例，并且 path初始默认为"" ，Chain().a 时，类中并没有 a 属性，Python解析器调用 getattr函数 --> __getattr__(self,path='a'),
并返回一个Chain实例，然后把/a 赋值给 path 传入，继续b,因为同样没有b 属性，执行getattr函数，将/a/b传入，
然后.user(“Michael”)，先会执行getattr返回Chain实例，但是因为有()括号在，所以返回的是Chain()，
这个就会调用call函数了，然后把“Michael”作为path传入，然后call函数就返回了/a/b/user/Michael，剩下的类同。