第十五章：面向对象高级编程

一. 使用__slots__

1. 当我们创建一个class实例后，可以给该实例绑定任何属性和方法，但每个实例绑定的属性和方法对另一个实例不起作用，可以给class绑定方法，让所有的实例都可以调用

from types import MethodType

class Dog(object):
    pass

def fn(self,name):  # 该方法一般直接定义在class中，但动态绑定允许我们在程序运行的过程中动态给class加上功能，这在静态语言中很难实现。
    self.name = name

s  =  Dog()
s.fn = MethodType(fn,s)
s.fn("哈哈")
print(s.name) #哈哈

s2 = Dog()
s2.fn("哈哈2") # AttributeError: 'Dog' object has no attribute 'fn'
print(s2.name) # AttributeError错误 （给一个实例绑定的方法，对另一个实例是不起作用的）

Dog.fn = fn  # 为了给所有实例都绑定方法，可以给class绑定方法
s2.fn("哈哈2")
print(s2.name) # AttributeError错误

2. Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性，但是_slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的，除非在子类中也定义__slots__，这样，子类实例允许定义的属性就是自身的__slots__加上父类的__slots__。

class Dog(object):
    __slots__ = ('name','age')


d = Dog()
d.name = '嘎嘎'
print(d.name) # 嘎嘎
d.gender = '男' #AttributeError: 'Dog' object has no attribute 'gender'

二. 使用@property

Python内置的@property装饰器负责把一个方法变成属性调用

class Student(object):

    @property  #把一个getter方法变成属性，只需要加上@property就可以
    def score(self):
        return self._score

    @score.setter #负责把一个setter方法变成属性赋值
    def score(self,value):
        if not isinstance(value,int):
            raise ValueError('score必须是整数')
        if value < 0 or value > 100:
            raise ValueError('score必须 < 0 且 > 100')
        self._score = value



    @property  #只定义getter方法，不定义setter方法就是一个只读属性
    def age(self):
        return self._age


s = Student()
s.score = 70   # 如果直接这么写，会属性暴露出去，且无法控制socre的值是否合法

print(s.score) #70

三. 多重继承

多重继承，一个子类就可以同时获得多个父类的所有功能，也就是说，如果需要“混入”额外的功能，通过多重继承就可以实现，这种设计通常称之为MixIn。

class Animal(object):
    pass

# 大类:
class Mammal(Animal): # 哺乳动物
    pass

class Bird(Animal): #鸟
    pass


class RunnableMixIn(object):  # 能跑
    def run(self):
        print('Running...')


class FlyableMixIn(object):  # 能飞
    def fly(self):
        print('Flying...')



# 各种动物:
class Dog(Mammal,RunnableMixIn): # 狗属于哺乳动物
    pass

class Bat(Mammal,FlyableMixIn): # 蝙蝠属于哺乳动物
    pass

class Parrot(Bird,FlyableMixIn): # 鹦鹉属于鸟
    pass

class Ostrich(Bird,RunnableMixIn): #鸵鸟属于鸟
    pass

d = Dog()

d.run()

四. 定制类

（1）__str__和__repr__

__str__()返回用户看到的字符串，而__repr__()返回程序开发者看到的字符串，__repr__()是为调试服务的，一般两者代码一致。

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

    def __str__(self):  #返回用户看到的字符串
        return "学生的名字是：%s" % self.name
    __repr__ = __str__ # __repr__()返回程序开发者看到的字符串，如果不用print会调用repr
    
s = Student("张甲")

print(s) #学生的名字是：张甲

（2）__iter__

如果一个类想被用于for … in循环，类似list或tuple那样，就必须实现一个__iter__()方法，该方法返回一个迭代对象，for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值

class Test(object):
    def __init__(self):
        self.x = 0

    def __iter__(self):
        return self

    def __next__(self):
        self.x += 2
        if self.x > 10:
            raise StopIteration() # 退出循环的条件
        return self.x


for i in Test():
    print(i)  # 2 4 6 8 10

（3）__getitem__

__iter__只是像list，需要实现getitem方法才可以像list一样通过下标取元素

class Test(object):
    def __init__(self):
        self.x = 0

    def __iter__(self):
        return self

    def __next__(self):
        self.x += 2
        if self.x > 10:
            raise StopIteration() # 退出循环的条件
        return self.x

    def __getitem__(self, item):
        for i in range(item):
            self.x += 2
        return self.x

t = Test()
print(t[3]) # 6

但是__getitem__()传入的参数可能是一个int，也可能是一个切片对象slice，所以要根据各种类型做判断，另外，__setitem__()方法，可以把对象视作list或dict来对集合赋值。__delitem__()方法用于删除某个元素

（4）___getattr____

getattr方法可以当我们调用某个实例不存在的属性或者函数的时候，将其动态返回

class Student(object):
    def __getattr__(self, attr):
        if attr == 'age':
            return lambda: 25

t = Student()

print(t.age()) # 25

（5）__call__

我们可以通过__call__()方法，直接默认调用某个方法，通过callable()函数，我们就可以判断一个对象是否是“可调用”对象

class Student(object):
    def __call__(self, *args, **kwargs):
        print("哈哈")

s = Student()

s() # 哈哈
print(callable(s)) # True

五. 枚举类

枚举类的每个常量都是class的一个唯一实例

from enum import Enum

Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

print(Month.Mar) # Month.Mar

for name,member in Month.__members__.items():
    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派生出自定义类，并通过@unique装饰器帮助我们检查保证没有重复值

from enum import Enum,unique

@unique
class Weekday(Enum):
    Sun = 0  # Sun的value被设定为0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

print(Weekday.Mon) # Weekday.Mon
print(Weekday['Mon']) # Weekday.Mon
print(Weekday(1)) # Weekday.Mon

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
'''

六. 元类

动态语言和静态语言最大的不同，就是函数和类的定义，不是编译时定义的，而是运行时动态创建的。

class Hello(object):
    def hello(self):
        print("Hello，word")

h = Hello()
print(type(h)) # print(type(h)) # 
print(type(Hello)) # <class 'type'>

type函数可以返回一个对象的类型，也可以创建新的类型

def fn():
    print("哈哈")

Hello = type('Hello',(object,),dict(hello =fn))

print(Hello()) #<__main__.Hello object at 0x000001D33543FB80>

metaclass：TODO：没空看，以后用到再学吧

参考资料

[1] 廖雪峰-Python教程