多重继承+定制类(str/iter/getitem/getattr/call/枚举类/type创建类/元类)

#-----------------------------多重继承----------------------------#
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 Dog2(Mammal,Runnable):
    pass
class Bat(Mammal,Flyable):
    pass
#-------------------------------MixIn------------------------------#
#在设计类的继承关系时，通常，主线都是单一继承下来的，例如，Ostrich继承自Bird。
#但是，如果需要“混入”额外的功能，通过多重继承就可以实现
#比如，让Ostrich除了继承自Bird外，再同时继承Runnable。这种设计通常称之为MixIn。
#MixIn的目的就是给一个类增加多个功能，这样，在设计类的时候，
#我们不需要复杂而庞大的继承链，只要选择组合不同的类的功能，就可以快速构造出所需的子类
#我们把Runnable和Flyable改为RunnableMixIn和FlyableMixIn
class RunnableMixIn(object):  #可以跑
    def run(self):
        Print('Running……')
class FlyableMixIn(object):   #可以飞
    def fly(self):
        Print('Flying……')
class CarnivorousMixIn(object): #食肉动物
    pass
class HerbivoresMixIn(object):# 植食动物
    pass
#多重继承
class Dog3(Mammal, RunnableMixIn, CarnivorousMixIn):
    pass

#-------------------------------str------------------------------#
class Student(object):
    def __init__(self, name):
        self.name = name
print(Student('Michael'))  #<__main__.Student object at 0x000001DFF027F8D0>

class Student(object):
    def __init__(self,name):
        self.name=name
    def __str__(self):   #定义该方法可以在打印类的对象的时候将调用该方法
        return 'Student object (name: %s)' %self.name
    __repr__ = __str__   #该方法与__str__类似，只是是为调试服务的
print(Student('Michale'))  #Student object (name: Michale)
#-------------------------------iter------------------------------#
#如果一个类想被用于for ... in循环，类似list或tuple那样，就必须实现一个__iter__()方法，该方法返回一个迭代对象，
#然后，Python的for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环。
class Fib(object):
    def __init__(self):
        self.a,self.b=0,1
    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------------------------------#
#要表现得像list那样按照下标取出元素，需要实现__getitem__()方法：
class Fib(object):
    def __getitem__(self, n):
        a, b = 1, 1
        for x in range(n):
            a, b = b, a + b
        return a
f=Fib()
print(f[0],f[100])  # 1  573147844013817084101
#------------切片-------------#
#__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
            step=n.step
            if start is None:
                start=0         
            if step is None:
                step=1
            a,b=1,1
            L=[]
            for x in range(stop):
                if a>=start and x%step==0:
                    L.append(a)
                a,b=b,a+b
            return L

f=Fib()
print(f[10])    #89
print(f[0:5])    #[1, 1, 2, 3, 5]
print(f[0:20:2])  #[1, 2, 5, 13, 34, 89, 233, 610, 1597, 4181]
#-------------------------------getattr------------------------------#
#当调用不存在的属性时，比如score，Python解释器会试图调用__getattr__(self, 'score')
#来尝试获得属性，这样，我们就有机会返回score的值
class Student(object):

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

    def __getattr__(self, attr):
        if attr=='score':
            return 99
        if attr=='age':
            return lambda: 25   #返回的是函数
        raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)

s=Student()
print(s.name)  #Michael
print(s.score)  #99
print(s.age())   #25
#print(s.abc)  #AttributeError: 'Student' object has no attribute 'abc'
#--------------链式调用---------------#
#首先是调用Chain().status，该类没有这个属性，就调用__getattr__，
#并且返回/status，这也是一个字符串路径，然后可以继续调用下去
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__
print(Chain().status.user.timeline.list)  #/status/user/timeline/list
#-------------------------------call------------------------------#
#一个对象实例可以有自己的属性和方法，当我们调用实例方法时，我们用instance.method()来调用。
#在Python中，也可以直接在实例本身上调用。
#任何类，只需要定义一个__call__()方法，就可以直接对实例进行调用。
class Student(object):
    def __init__(self, name):
        self.name = name
    def __call__(self):
        print('My name is %s.' % self.name)
    #可以为call函数传入参数，但是有参数和无参数的函数不能同时调用，不能实现类似C++中的重载
    def __call__(self,number):  
        print('The name of Number %  is % s.' % (number,self.name))
s=Student('Michale')  
#s()   #My name is Michale.
s2=Student('Anna')
s2(1001) #The name of Number  1001 is Anna.
#通过callable()函数，我们就可以判断一个对象是否是“可调用”对象
print(callable(Student('Bob')))  #True
print(callable(abs))             #True
print(callable([1,2,4]))         #False

#-------------------------------枚举类------------------------------#
#枚举类型有类Enum，定义一个实例，就可以引用一个常量或者枚举它所有的成员
#value属性是自动赋给成员的int常量，默认从1开始计数。
from enum import Enum
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
for name, member in Month.__members__.items():  #__members__.可以把值重复的成员也遍历出来
    print(name, '=>', member, ',', member.value)
#Jan => Month.Jan , 1
#Feb => Month.Feb , 2
#Mar => Month.Mar , 3
#Apr => Month.Apr , 4
#May => Month.May , 5
#Jun => Month.Jun , 6
#Jul => Month.Jul , 7
#Aug => Month.Aug , 8
#Sep => Month.Sep , 9
#Oct => Month.Oct , 10
#Nov => Month.Nov , 11
#Dec => Month.Dec , 12
#-------如果需要更精确地控制枚举类型，可以从Enum派生出自定义类
from enum import Enum, unique
#定义枚举时，成员名称不允许重复　
class Color(Enum):
    red = 1
    #red = 2  #TypeError: Attempted to reuse key: 'red'
#默认情况下，不同的成员值允许相同。但是两个相同值的成员，第二个成员的名称被视作第一个成员的别名　
class Color(Enum):
    red = 1
    red_alias = 1
#如果枚举中存在相同值的成员，在通过值获取枚举成员时，只能获取到第一个成员
print(Color(1))  #Color.red


@unique   #帮助我们检查保证没有重复值
class Weekday(Enum):
    Sun = 0 # Sun的value被设定为0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6
#访问方法：既可以用成员名称引用枚举常量，又可以直接根据value的值获得枚举常量
day1=Weekday.Mon
print(day1) #Weekday.Mon
print(Weekday.Tue)  #Weekday.Tue
print(Weekday.Tue.value)  #2
print(day1==Weekday.Mon)  #True 可进行等值比较，不能进行大小比较
print(Weekday(1))      #Weekday.Mon
print(day1==Weekday(1))  #True
for name, member in Weekday.__members__.items():
    print(name, '=>', member, ',', member.value)
#Sun => Weekday.Sun , 0
#Mon => Weekday.Mon , 1
#Tue => Weekday.Tue , 2
#Wed => Weekday.Wed , 3
#Thu => Weekday.Thu , 4
#Fri => Weekday.Fri , 5
#Sat => Weekday.Sat , 6
#枚举支持迭代器，可以遍历枚举成员
for day in Weekday:
    print(day)   #Weekday.Sun  Weekday.Mon   Weekday.Tue   Weekday.Wed  Weekday.Thu   Weekday.Fri   Weekday.Sat
#-------------------------------type（）------------------------------#
#type()函数可以创建出新的类型，比如，通过type()函数创建出Hello类，而无需通过class Hello(object)...的定义
#type()函数允许我们动态创建出类来，动态语言本身支持运行期动态创建类，这和静态语言有非常大的不同
def fn(self, name='world'): # 先定义函数
    print('Hello, %s.' % name)
Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class  类名称 继承父类集合  class的方法名称与函数绑定

#-------------------------------元类  metaclass------------------------------#
#当我们定义了类以后，就可以根据这个类创建出实例，所以：先定义类，然后创建实例。
#但是如果我们想创建出类呢？那就必须根据metaclass创建出类，所以：先定义metaclass，然后创建类。
#连接起来就是：先定义metaclass，就可以创建类，最后创建实例。
#metaclass允许你创建类或者修改类。换句话说，你可以把类看成是metaclass创建出来的“实例”。