在Python中,面向对象有很多高级特性,允许我们写出非常强大的功能。包括多重继承、定制类、元类等概念。
__slots__属性使用正常情况下,当定义了一个class并创建了一个class的实例后,可以给该实例绑定任何属性和方法,这就是动态语言的灵活性。动态绑定允许在程序运行的过程中动态给实例或class加上功能
Python允许在定义class的时候,定义一个特殊的__slots__变量,来限制该class实例能添加的属性
class Student(object): # 用tuple定义允许绑定的属性名称 __slots__ = ('name', 'age')
使用__slots__要注意,slots__定义的属性仅对当前类实例起作用,对继承的子类是不起作用的
除非在子类中也定义__slots,这样,子类实例允许定义的属性就是自身的__slots__加上父类的__slots__
为了封装属性并引入参数有效性检查,推荐在class内进行getter和setter的设置,但调用方法略显复杂,没有直接用属性来得直接简单。
Python内置的@property装饰器负责把一个方法变成属性调用
把一个getter方法变成属性,只需要加上@property就可以了
@property本身可创建了另一个装饰器@score.setter,负责把一个setter方法变成属性赋值
应用@property后,属性的调用和设置就可以直接进行,但底层又是getter和setter的逻辑,实现了简单调用且不失封装性的效果
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): # birth是可读写属性,age是只读属性 @property def birth(self): return self._birth @birth.setter def birth(self, value): self._birth = value @property def age(self): return 2015 - self._birth
要特别注意:属性的方法名不要和实例变量重名,否则会造成无限递归,最终导致栈溢出报错RecursionError。
@property广泛应用在类的定义中,可以让调用者写出简短的代码,同时保证对参数进行必要的检查,程序运行时减少了出错的可能性。
请利用@property给一个Screen对象加上width和height属性,以及一个只读属性resolution
# -*- coding: utf-8 -*- class Screen(object): @property def width(self): return self._width @width.setter def width(self, value): self._width = value @property def height(self): return self._height @height.setter def height(self, value): self._height = value @property def resolution(self): return self._width * self._height多重继承
Python允许使用多重继承,因此,MixIn就是一种常见的设计
class Dog(Mammal, Runnable): pass
MixIn的目的就是给一个类增加多个功能,这样,在设计类的时候,我们优先考虑通过多重继承来组合多个MixIn的功能,而不是设计多层次的复杂的继承关系。
利用特殊函数定制类Python的class允许定义许多定制方法,可以让我们非常方便地生成特定的类。
__str__方法定义好__str__()方法可以规定返回类对象实例的信息,打印出来的实例,不但好看,而且容易看出实例内部重要的数据
直接显示变量调用的不是__str__(),而是__repr__(),两者的区别是__str__()返回用户看到的字符串,而__repr__()返回程序开发者看到的字符串,也就是说__repr__()是为调试服务的
可以人为地将__str__()和__repr__()调成一致
>>> class Student(object): ... def __init__(self, name): ... self.name = name ... def __str__(self): ... return 'Student object (name: %s)' % self.name ... # 可以使得直接显示变量也输出要求的字符串 ... __repr__ = __str__ ... >>> print(Student('Michael')) Student object (name: Michael) >>> s = Student('Michael') >>> s Student object (name: Michael)__iter__方法
如果一个类想被用于for … in循环,类似list或tuple那样,就必须实现一个__iter__()方法,该方法返回一个迭代对象,然后,Python的for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值,直到遇到StopIteration错误时退出循环。
以斐波那契数列为例,写一个Fib类,可以用于for循环
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 # 返回下一个值__getitem__方法
要表现得像list那样按照下标取出元素,需要实现__getitem__()方法
以斐波那契数列为例,写一个Fib类,可以同时用索引和切片形式获取值
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
但是与list相比,Fib切片没有对step参数做处理,也没有考虑负数,所以要正确实现一个__getitem__()还是有很多工作要做的。此外,如果把对象看成dict,那么__getitem__()的参数也可能是一个可以作key的object,例如str。
与__getitem__()对应的是__setitem__()方法,把对象视作list或dict来对集合赋值。最后,还有一个__delitem__()方法,用于删除某个元素。
通过上述方法,自定义的类可以表现得和Python自带的list、tuple、dict没什么区别,这完全归功于动态语言的“鸭子类型”,不需要强制继承某个接口。
写一个__getattr__()方法,动态返回一个属性
当调用不存在的属性时,Python解释器会试图调用__getattr__(self, ‘score’)来尝试获得属性
只有在没有找到属性的情况下,才调用__getattr__,已有的属性,比如name,不会在__getattr__中查找
__getattr__默认返回是None。要让class只响应特定的几个属性,我们就要按照约定,抛出AttributeError的错误
实际上可以把一个类的所有属性和方法调用全部动态化处理。这种完全动态调用的特性作用就是可以针对完全动态的情况作调用。例如:实现一个动态生成地址的类
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__ >>> Chain().status.user.timeline.list '/status/user/timeline/list'__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() My name is Michael.
此外__call__()还可以定义参数。对实例进行直接调用与对一个函数进行调用一样,完全可以把对象看成函数,把函数看成对象,因为这两者之间本来就没啥根本的区别,即python的万物皆对象理念。
如果把对象看成函数,那么函数本身其实也可以在运行期动态创建出来,因为类的实例都是运行期创建出来的。
如何判断一个变量是对象还是函数呢?更多的时候,需要判断一个对象是否能被调用,能被调用的对象就是一个Callable对象,通过callable()函数可以判断一个对象是否是“可调用”对象
当需要定义常量时,可以为这样的枚举类型定义一个class类型,然后,每个常量都是class的一个唯一实例。Python提供了Enum类来实现这个功能
Enum可以把一组相关常量定义在一个class中,且class不可变,而且成员可以直接比较
from enum import Enum Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')) # 直接使用Month.Jan来引用一个常量 # value属性是自动赋给成员的int常量,默认从1开始计数 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派生出自定义类:
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 # 访问:既可以用成员名称引用枚举常量 # 又可以直接根据value的值获得枚举常量 Weekday.Mon Weekday(1) # 也是Weekday.Mon Weekday.Tue Weekday['Tue'] # 也是Weekday.Tue练习
把Student的gender属性改造为枚举类型,可以避免使用字符串:
# -*- coding: utf-8 -*- from enum import Enum, unique class Gender(Enum): Male = 0 Female = 1 class Student(object): def __init__(self, name, gender): self.name = name if (gender in (Gender.Male, Gender.Female)): self.gender = gender else: self.gender = None元类 使用type()动态创建类
type()函数可以查看一个类型或变量的类型,一个class的类型就是“type”,一个实例的类型是“class 类名”。
class的定义是运行时动态创建的,创建class的方法就是使用type()函数
type()函数既可以返回一个对象的类型,又可以创建出新的类型
要创建一个class对象,type()函数依次传入3个参数:
- class的名称;
- 继承的父类集合,注意Python支持多重继承,如果只有一个父类,需传入tuple的单元素写法;
- class的方法名称与函数绑定,这里我们把函数fn绑定到方法名hello上
通过type()函数创建的类和直接写class完全一样,因为Python解释器遇到class定义时,仅仅是扫描一下class定义的语法,然后调用type()函数创建出class。
正常情况下,都用class Xxx…来定义类,但是,type()函数也允许动态创建出类,也就是说,动态语言本身支持运行期动态创建类
控制类的创建行为还可以使用metaclass,直译为元类
metaclass允许创建类或者修改类。可以把类看成是metaclass创建出来的“实例”。
metaclass是Python中非常具有魔术性的对象,它可以改变类创建时的行为。一般不会涉及到使用metaclass
欢迎分享,转载请注明来源:内存溢出
评论列表(0条)