Python 学习笔记7 - 面向对象高级编程

slots —— 限制实例能添加的属性

我们可以给该实例绑定任何属性和方法

class Student(object):
    pass

s = Student()

给实例绑定属性

s.name = 'Michael'
print(s.name)

给实例绑定方法

from types import MethodType

def set_age(self, age):
    self.age = age

s.set_age = MethodType(set_age, s)
s.set_age(25)
s.age

给class绑定方法,则对该类的所有实例都有该方法

def set_score(self, score):
    self.score = score

Student.set_score = set_score

使用slots

试图绑定不在允许列表里的属性将得到 AttributeError 的错误

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

__slots__ 定义的属性仅对当前类实例起作用,对继承的子类是不起作用的

如果在子类中也定义 __slots__ ,子类实例允许定义的属性就是自身的 __slots__ 加上父类的 __slots__

@property —— 把一个方法变成属性调用

class Student(object):

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

    # @property本身又创建了另一个装饰器@score.setter,负责把一个setter方法变成属性赋值
    @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

只定义getter方法,不定义setter方法就是一个只读属性

class Student(object):

    # birth 是可读写属性
    @property
    def birth(self):
        return self._birth

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

    # age 是只读属性
    @property
    def age(self):
        return 2015 - self._birth

多重继承

在设计类的继承关系时,通常,主线都是单一继承下来的,例如,Ostrich继承自Bird。但是,如果需要“混入”额外的功能,通过多重继承就可以实现,比如,让Ostrich除了继承自Bird外,再同时继承Runnable。这种设计通常称之为MixIn。

为了更好地看出继承关系,我们把Runnable和Flyable改为RunnableMixIn和FlyableMixIn

定制类

str() & repr() —— 打印实例的信息

__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)

__repr__() 返回程序开发者看到的字符串,即 __repr__() 是为调试服务的

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

    def __str__(self):
        return 'Student object (name: %s)' % self.name

    # 通常 __str__() 和 __repr__() 代码都是一样的,所以,用偷懒的写法:
    __repr__ = __str__

iter() & next() —— 使一个对象可迭代

__iter__() 方法,该方法返回一个迭代对象,然后,Python的for循环就会不断调用该迭代对象的 __next__() 方法拿到循环的下一个值

class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1

    def __iter__(self):
        # 返回实例本身,因为实例实现了 __next__() 方法,所以是个可迭代对象
        return self
        
    def __next__(self):
        self.a, self.b = self.b, self.a + self.b
        if self.a > 100000:
            raise StopIteration()
        return self.a

getitem() —— 使一个对象能像list那样按照下标取出元素

class Fib(object):
    def __getitem__(self, n):
        # n是索引
        if isinstance(n, int):
            a, b = 1, 1
            for x in range(n):
                a, b = b, a + b
            return a
        # n是切片
        # 这里没有对step参数作处理,也没有对负数作处理
        if isinstance(n, slice):
            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
        
f = Fib()
f[3]
print(f[0:5])
print(f[:10])

如果把对象看成 dict ,__getitem__() 的参数也可能是一个可以作 key 的 object ,例如str

与之对应的是 __setitem__() 方法,把对象视作list或dict来对集合赋值

还有一个 __delitem__() 方法,用于删除某个元素

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
        
        # __getattr__默认返回就是None
        # 要让class只响应特定的几个属性,我们就要按照约定,抛出AttributeError的错误
        raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)

call —— 调用实例本身

对实例进行直接调用就好比对一个函数进行调用一样,所以你完全可以把对象看成函数,把函数看成对象,因为这两者之间本来就没啥根本的区别。

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

    # __call__()还可以定义参数
    def __call__(self):
        print('My name is %s.' % self.name)

s = Student('Michael')
s() ==> My name is Michael.

判断一个对象是否能被调用,能被调用的对象就是一个Callable对象,比如函数和我们上面定义的带有call()的类实例

callable(Student()) ==> True
callable(max) ==> True
callable([1, 2, 3]) ==> False
callable(None) ==> False
callable('str') ==> False

其他特殊的方法名见:special-method-names

枚举类

from enum import Enum

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

这样我们就获得了Month类型的枚举类,可以直接使用Month.Jan来引用一个常量,或者枚举它的所有成员

for name, member in Month.__members__.items():
    # value属性则是自动赋给成员的int常量,默认从1开始计数
    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

访问这些枚举类型的方法:

print(Weekday.Tue)

day1 = Weekday.Tue
print(day1)

print(Weekday['Tue'])

print(Weekday(2))

print(Weekday.Tue.value) ==> 2

使用元类

type() —— 动态创建类

假设有一 hello.py 模块

class Hello(object):
    def hello(self, name='world'):
        print('Hello, %s.' % name)
from hello import Hello

h = Hello()
h.hello() ==> Hello, world.

# Hello是一个class,它的类型就是type
print(type(Hello)) ==> <class 'type'>
# h是一个实例,它的类型就是class Hello
print(type(h)) ==> <class 'hello.Hello'>

type() 函数既可以返回一个对象的类型,又可以创建出新的类型

比如,我们可以通过type()函数创建出Hello类,而无需通过class Hello(object)...的定义:

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


# 参数:
# 1. class的名称
# 2. 继承的父类集合,注意Python支持多重继承,如果只有一个父类,别忘了tuple的单元素写法
# 3. class的方法名称与函数绑定,这里我们把函数fn绑定到方法名hello上
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'>

type() 函数也允许我们动态创建出类来,也就是说,动态语言本身支持运行期动态创建类

metaclass —— 控制类的创建行为(缺)

先定义metaclass,就可以创建类,最后创建实例

所以,metaclass允许你创建类或者修改类。换句话说,你可以把类看成是metaclass创建出来的“实例”

一个简单的例子:

# 这个metaclass可以给我们自定义的MyList增加一个add方法
# metaclass是类的模板,所以必须从`type`类型派生:
class ListMetaclass(type):
    # __new__()方法参数
    # 1. 当前准备创建的类的对象
    # 2. 类的名字
    # 3. 类继承的父类集合
    # 4. 类的方法集合
    def __new__(cls, name, bases, attrs):
        attrs['add'] = lambda self, value: self.append(value)
        return type.__new__(cls, name, bases, attrs)
# 指示Python解释器在创建MyList时,要通过ListMetaclass.__new__()来创建
class MyList(list, metaclass=ListMetaclass):
    pass

动态修改的意义在于:总会遇到需要通过metaclass修改类定义的

展开阅读全文

没有更多推荐了,返回首页