python学习笔记(七) - 面向对象高级编程

一. 为类动态添加属性和方法：

1. 动态给一个实例添加属性和方法：

给一个实例绑定的方法，对另一个实例是不起作用的。

class Student(object):
    pass

s = Student()
s.name = 'Michael' # 动态给实例绑定一个属性
print s.name

def set_age(self, age): # 定义一个函数作为实例方法
    self.age = age
    
from types import MethodType
s.set_age = MethodType(set_age, s, Student) # 给实例绑定一个方法
s.set_age(25) # 调用实例方法
print s.age # 测试结果

2. 动态给一个类添加属性和方法：

class Student(object):
    pass

s = Student()
from types import MethodType

def set_score(self, score):
    self.score = score
    
Student.set_score = MethodType(set_score, None, Student)
s.set_score(100)
print s.score

二. 使用__slots__

使用__slots__可以限制class能添加的属性：

class Student(object):
    __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称

s = Student() # 创建新的实例
s.name = 'Michael' # 绑定属性'name'
s.age = 25 # 绑定属性'age'

注意：__slots__定义的属性仅对当前类起作用，对继承的子类是不起作用的。

三. 使用@property

@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)
print s.score # OK，实际转化为s.get_score()

四. 多重继承：

python允许使用多重继承，例如：Dog继承了Animal和Runnable

class Animal(object):
    pass

class Runnable(object):
    def run(self):
        print('Running...')
        
class Dog(Animal, Runnable):
    pass

五. 定制类：

1. __str__

相当于java中的toString

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)

2. __iter__

如果一个类想变成list或tuple可以被循环（for .. in），那么必须实现__iter__方法，该方法返回一个迭代对象，并不断调用该迭代对象的next()方法拿到循环的下一个值：

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 n in Fib():
    print n

3. __getitem__

通过下标获取元素，需要实现__getitem__

class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1 # 初始化两个计数器a，b
    
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]

4. __getattr__

想要动态返回一个属性，需要实现__getattr__

如：调用不存在的属性score时，python会试图调用__getattr__(self, 'score')来尝试获得属性

class Student(object):

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

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

s = Student()
print s.name  # 'Michael'
print s.score  # 99

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

六. 使用元类：

1. type()

type() 函数可以查看一个类的类型或一个变量的类型

type() 函数也可以创建出新的类型：比如创建一个Hello类

def fn(self, name='world'): # 先定义函数
    print('Hello, %s.' % name)

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

要创建一个class对象，type()函数依次传入3个参数：

1) class的名称

2) 继承的父类集合，注意python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法

3) class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上

2. metaclass

元类 - 估计这个东东和java的class类似，不深究。