本文介绍了Python面向对象编程的高级特性，包括slots的使用、@property装饰器、多重继承和MixIn、定制类、枚举类以及元类的概念和应用。通过这些特性，可以更加灵活地设计和组合类的功能，例如使用__slots__限制属性，@property实现属性的访问控制，利用MixIn实现功能复用，自定义__str__、__iter__等方法增强类的行为，以及通过元类控制类的创建行为。
面向对象高级编程
数据封装、继承和多态只是面向对象程序设计中最基础的3个概念。在Python中，面向对象还有很多高级特性, 多重继承、定制类、元类等概念
slots
当我们定义了一个class，创建了一个class的实例后，我们可以给该实例绑定任何属性和方法，这就是动态语言的灵活性
给一个实例绑定的方法，对另一个实例是不起作用的
动态语言可以通过运行时给class绑定方法的属性: class.method=method. 实例均可以使用
限制class绑定的属性使用__slots__
- __slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的
- 子类定义__slots__,子类实例允许定义的属性就是自身的__slots__加上父类的__slots__
class Student(object):
pass
def set_age(self, age):
self.age = age
lance = Student()
# 实例绑定属性
lance.name='lance'
print(lance.name)
# 实例绑定方法
from types import MethodType
lance.set_age=MethodType(set_age,lance)
lance.set_age(55)
print(lance.age)
# 实例lance绑定的属性对于tom实例不生效
tom = Student();
# print(tom.name) # 报错
# 给类绑定方法, 对以后的实例均生效
Student.set_age=set_age;
tom.set_age(45)
print(tom.age)
class Student(object):
__slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称
plus = Student();
plus.age=18;
# plus.score=19; # 不能绑定score属性
使用@property
既能检查参数，又可以用类似属性这样简单的方式来访问类的变量: @property装饰器
@property 标注getter, @@birth.setter 标注setter
# @property
class Teacher(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
proTea = Teacher();
proTea.score = 60 # OK，实际转化为s.set_score(60)
print(proTea.score) # OK，实际转化为s.get_score()
# proTea.score = 999 # 设置时未通过校验报错
# 只读属性 不提供@score.setter方法
class Student(object):
@property
def birth(self):
# 属性名为_birth, 实例访问birth; 二者不能相同
return self._birth
@birth.setter
def birth(self, value):
self._birth = value
@property
def age(self):
return 2015 - self._birth
# 属性的方法名不要和实例变量重名
class Student(object):
# 方法名称和实例变量均为birth:
@property
def birth(self):
return self.birth
# s.birth时，首先转换为方法调用，在执行return self.birth时，又视为访问self的属性，
# 于是又转换为方法调用，造成无限递归，最终导致栈溢出报错RecursionError。
多重继承
给动物加上Runnable和Flyable的功能，只需要先定义好Runnable和Flyable的类
class Runnable(object):
def run(self):
print('Running...')
class Flyable(object):
def fly(self):
print('Flying...')
#对于需要Runnable功能的动物，就多继承一个Runnable，例如Dog：
class Dog(Mammal, Runnable):
pass
#对于需要Flyable功能的动物，就多继承一个Flyable，例如Bat：
class Bat(Mammal, Flyable):
pass
#通过多重继承，一个子类就可以同时获得多个父类的所有功能。
MixIn
类似于java接口, 提供功能选项, 需要就进行继承. MixIn的目的就是给一个类增加多个功能，这样，在设计类的时候，我们优先考虑通过多重继承来组合多个MixIn的功能，而不是设计多层次的复杂的继承关系。不需要复杂而庞大的继承链，只要选择组合不同的类的功能，就可以快速构造出所需的子类。
Python自带了TCPServer和UDPServer这两类网络服务，而要同时服务多个用户就必须使用多进程或多线程模型，这两种模型由ForkingMixIn和ThreadingMixIn提供。通过组合，我们就可以创造出合适的服务来。
比如，编写一个多进程模式的TCP服务，定义如下：
from socketserver import UDPServer, TCPServer,ThreadingMixIn,CoroutineMixIn ,ForkingMixIn
class MyTCPServer(TCPServer, ForkingMixIn):
pass
# 编写一个多线程模式的UDP服务，定义如下：
class MyUDPServer(UDPServer, ThreadingMixIn):
pass
# 如果你打算搞一个更先进的协程模型，可以编写一个CoroutineMixIn：
class MyTCPServer(TCPServer, CoroutineMixIn):
pass
定制类
- __str__方法类似java object的toString()方法, 直接打印实例时,调用__repr__方法
class School():
def __init__(self,name):
self.name=name;
def __str__(self):
return "school instance name %s" % self.name;
__repr__ = __str__
print(School("河北师大附中"))
s = School("zs")
- iter__方法返回一个迭代对象,Python的for循环就会不断调用该迭代对象的__next()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环。
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 > 100000: # 退出循环的条件
raise StopIteration()
return self.a # 返回下一个值
for i in Fib():
print(i)
- __getitem__像list那样按照下标取出元素; 实现切片需要判断输入是索引还是对象, 并且需要自己实现负数和step操作
class Fib(object):
def __getitem__(self, n):
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
# 使用下标访问
print(Fib()[30])
# __getitem__()传入的参数可能是一个int，也可能是一个切片对象slice，所以要做判断
class Fib(object):
def __getitem__(self, n):
if isinstance(n, int): # n是索引
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
if isinstance(n, slice): # n是切片
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
# 切片(__getitem__切片没有进行负数和step参数处理)
print(Fib()[0:5])
- setitem()方法，把对象视作list或dict来对集合赋值。
- 最后，还有一个__delitem__()方法，用于删除某个元素
class Student(object):
def __init__(self):
self.name = 'Michael'
def __getattr__(self, attr):
if attr=='score':
return 99
- getattr__方法动态返回一个属性 或者函数;
只有在没有找到属性的情况下，才调用__getattr，已有的属性，比如name，不会在__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__
print(Chain().status.user.timeline.list) # '/status/user/timeline/list'
- __call__方法获取实例的属性和方法
class Student(object):
def __init__(self, name):
self.name = name
def __call__(self):
print('My name is %s.' % self.name)
s = Student('Michael')
print(s()) # My name is Michael.
完全可以把对象看成函数，把函数看成对象; 如果你把对象看成函数，那么函数本身其实也可以在运行期动态创建出来，因为类的实例都是运行期创建出来的; 我们需要判断一个对象是否能被调用，能被调用的对象就是一个Callable对象 使用callable判断是对象还是函数
>>> callable(Student())
True
>>> callable(max)
True
>>> callable([1, 2, 3])
False
>>> callable(None)
False
>>> callable('str')
False
使用枚举类
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():
print(name, '=>', member, ',', member.value)
更精确地控制枚举类型，可以从Enum派生出自定义类：
from enum import Enum, unique
# @unique装饰器可以帮助我们检查保证没有重复值。
@unique
class Weekday(Enum):
Sun = 0 # Sun的value被设定为0
Mon = 1
Tue = 2
Wed = 3
Thu = 4
Fri = 5
Sat = 6
# 访问
>>> day1 = Weekday.Mon
>>> print(day1)
Weekday.Mon
>>> print(Weekday.Tue)
Weekday.Tue
>>> print(Weekday['Tue'])
Weekday.Tue
>>> print(Weekday.Tue.value)
2
>>> print(day1 == Weekday.Mon)
True
>>> print(day1 == Weekday.Tue)
False
>>> print(Weekday(1))
Weekday.Mon
>>> print(day1 == Weekday(1))
True
>>> Weekday(7)
Traceback (most recent call last):
...
ValueError: 7 is not a valid Weekday
>>> for name, member in Weekday.__members__.items():
... print(name, '=>', member)
使用元类
type()
函数既可以返回一个对象的类型，又可以创建出新的类型，比如，我们可以通过type()函数创建出Hello类，而无需通过class Hello(object)…的定义：
要创建一个class对象，type()函数依次传入3个参数：
- class的名称；
- 继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法；
- class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上。
通过type()函数创建的类和直接写class是完全一样的，因为Python解释器遇到class定义时，仅仅是扫描一下class定义的语法，然后调用type()函数创建出class。
# 元类
from hello import Hello
h = Hello()
h.hello() # Hello,world
print(type(Hello)) # <class 'type'>
print(type(h)) # <class 'hello.Hello'>
# 使用type()创建class
def fn(self, name='world'): # 先定义函数
print('Hello, %s.' % name)
Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class
h = Hello()
h.hello() # Hello,world
print(type(Hello)) # <class 'type'>
print(type(h)) # <class 'hello.Hello'>
metaclass
除了使用type()动态创建类以外，要控制类的创建行为，还可以使用metaclass。
metaclass，直译为元类，简单的解释就是：
当我们定义了类以后，就可以根据这个类创建出实例，所以：先定义类，然后创建实例。
但是如果我们想创建出类呢？那就必须根据metaclass创建出类，所以：先定义metaclass，然后创建类。
连接起来就是：先定义metaclass，就可以创建类，最后创建实例。
所以，metaclass允许你创建类或者修改类。换句话说，你可以把类看成是metaclass创建出来的“实例”。
定义ListMetaclass，按照默认习惯，metaclass的类名总是以Metaclass结尾，以便清楚地表示这是一个metaclass：
metaclass是类的模板，所以必须从type类型派生：
class ListMetaclass(type):
def __new__(cls, name, bases, attrs):
attrs['add'] = lambda self, value: self.append(value)
return type.__new__(cls, name, bases, attrs)
# ListMetaclass，我们在定义类的时候还要指示使用ListMetaclass来定制类，传入关键字参数metaclass：
class MyList(list, metaclass=ListMetaclass):
pass
指示Python解释器在创建MyList时，要通过ListMetaclass.new()来创建，在此，我们可以修改类的定义，比如，加上新的方法，然后，返回修改后的定义。
new()方法接收到的参数依次是：
- 当前准备创建的类的对象；
- 类的名字；
- 类继承的父类集合；
- 类的方法集合。
总会遇到需要通过metaclass修改类定义的。ORM就是一个典型的例子。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
