Python面向对象高级编程(__slots__、多继承、定制类)-6

一、使用__slots__

1. 创建class的实例后,可以给该实例绑定任何属性和方法，这还少动态语言的灵活性。s.set_age = MethodType(set_age, s)
2. 针对于单个实例绑定的方法，对于其他实例不起效，给class绑定才能对所有实例起效。Student.set_score = set_score
3. 可以使用__slots__变量来限制class实例能添加的属性。
4. 使用__slots__需要注意的是定义的属性仅对当前类实例起作用，对继承的子类是不起作用的。除非在子类中也定义__slots__,这样子类实例允许定义的属性就是自身的__slots__加上父类的__slots__

>>> class Student(object):
...     __slots__ = (‘name‘, ‘age‘) 
... 
>>> s = Student() # 创建新的实例
>>> s.name = ‘Michael‘ # 绑定属性‘name‘
>>> s.age = 25 # 绑定属性‘age‘
>>> s.score = 99 # 绑定属性‘score‘
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: ‘Student‘ object has no attribute ‘score‘
e ‘score‘

二、使用@property

1. @property为内置的装饰器，负责把一个方法变成属性进行调用。
2. 常规操作：

#常规操作
class Student(object):

    def get_score(self):
         return self._score

    def set_score(self, value):
        if not isinstance(value, int):
            raise ValueError(‘score must be an integer!‘)
        if value < 0 or value > 100:
            raise ValueError(‘score must between 0 ~ 100!‘)
        self._score = value
        
>>> s = Student()
>>> s.set_score(60) # ok!
>>> s.get_score()
60
>>> s.set_score(9999)
Traceback (most recent call last):
  ...
ValueError: score must between 0 ~ 100!

• 把一个getter方法变成属性，只需要加上@property就可以了，此时property本身又创建了另一个装饰器@score.setter,负责把setter方法变成属性。于是，我们就拥有了一个可控的属性操作：

#使用@property
class Student(object):

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError(‘score must be an integer!‘)
        if value < 0 or value > 100:
            raise ValueError(‘score must between 0 ~ 100!‘)
        self._score = value
        
>>> s = Student()
>>> s.score = 60 # OK，实际转化为s.set_score(60)
>>> s.score # OK，实际转化为s.get_score()
60
>>> s.score = 9999
Traceback (most recent call last):
  ...
ValueError: score must between 0 ~ 100!

• 当然也可以定义只读属性，只定义getter方法，不定义setter方法就是一个只读属性：

class Student(object):

    @property
    def birth(self):
        return self._birth

    @birth.setter
    def birth(self, value):
        self._birth = value

    @property
    def age(self):
        return 2015 - self._birth

• 实例：

class Screen(object):
    @property
    def width(self):
        return self._width
    @width.setter
    def width(self, width):
        self._width = width
    @property
    def height(self):
        return self._height
    @height.setter
    def height(self, height):
       self._height = height
    @property
    def resolution(self):
        return self._width * self._height
s = Screen()
s.width = 1024
s.height = 768
print(‘resolution =‘, s.resolution)
if s.resolution == 786432:
    print(‘测试通过!‘)
else:
    print(‘测试失败!‘)

三、多继承

1. 通过多重继承，一个子类就可以同时获得多个父类的所有功能
2. MixIn的目的就是给一个类增加多个功能，这样在设计类的时候，我们优先考虑通过多继承来组合多个MinIn的功能，而不是设计多层次的复杂的继承关系。
3. 只允许单一继承的语言（Java）不能使用MixIn

四、定制类

1. __str__:

#没有使用__str__
>>> class Student(object):
...     def __init__(self, name):
...         self.name = name
...
>>> print(Student(‘Michael‘))
<__main__.Student object at 0x109afb190>

#使用__str__
>>> class Student(object):
...     def __init__(self, name):
...         self.name = name
...     def __str__(self):
...         return ‘Student object (name: %s)‘ % self.name
...
>>> print(Student(‘Michael‘))
Student object (name: Michael)

• 直接敲变量，发现结果还是不够好看

>>> s = Student(‘Michael‘)
>>> s
<__main__.Student object at 0x109afb310>

• 因为直接显示变量调用的不是__str__()，而是__repr__(),两者的区别是__str__()返回用户看到的字符串，而__repr__()返回程序开发者看到的字符串，也就是说，__repr__()是为调试服务的。
• 解决办法是再定一个__repr__()。但是通常两者的代码是一样的,所以偷懒写法：

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

2. __iter__:

• 如果一个类想被用于for...in循环，类似list或tuple那样，就必须实现一个__iter__()方法，该方法返回一个迭代对象，然后Python的for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值，直到遇到StopIteration错误时退出。

3. __getitem__:

• 可以像list那样按照下标去除元素，需要实现该方法。

4. __getattr__:

• 如果调用类的方法或属性时，如果不存在，就会报错。
• 如果要避免这个错误，除了可以加上一个score属性外，Python还有另一个机制，那就是写一个__getattr__方法，动态返回一个属性。

class Student(object):
    def __init__(self):
        self.name = ‘Michael‘
    def __getattr__(self, attr):
        if attr = ‘score‘:
            return 99

5. __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.

• 怎么判断一个变量是对象还是函数呢？通过callable()函数，就可以了。

五、使用枚举

• 枚举类型，即通过继承Enum类，来完成。value属性则是自动赋给成员的int常量，默认从1开始计数。
• 枚举类型定义一个class类型，然后，每个常量都是class的唯一实例。

from enum import Enum, unique
Month = Enum(‘Month‘, (‘Jan‘, ‘Feb‘, ‘Mar‘, ‘Apr‘, ‘May‘, ‘Jun‘, ‘Jul‘, ‘Aug‘, ‘Sep‘, ‘Oct‘, ‘Nov‘, ‘Dec‘))
for name, member in Month.__members__.items():
    print(name, ‘=>‘, member, ‘,‘, member.value)

@unique
class Weekday(Enum):
    Sun = 0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

day1 = Weekday.Mon
print(day1)
print(Weekday.Tue)
print(Weekday[‘Tue‘])
print(Weekday.Tue.value)

out:
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
Weekday.Mon
Weekday.Tue
Weekday.Tue
2

六、使用元类

1. type()

• 动态语言和静态语言最大的不同，就是函数和类的定义，不是编译时定义，而是运行时动态创建的。
• type()函数可以查看一个类型或变量的类型，Hello是一个class，它的类型就是type(),而h是一个实例，它的类型就是classHello
• 我们说class的定义是运行时动态创建的，而创建class的方法就是使用type()函数
• type()函数即可以返回一个对象的类型，又可以创建出新的类型，比如我们可以通过type()函数创建出Hello类，而无需通过class Hello(oject)...的定义:

>>> Hello = type(‘Hello‘, (object,), dict(hello=fn)) # 创建Hello class
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<class ‘type‘>
>>> print(type(h))
<class ‘__main__.Hello‘>

2. metaclass