构造和初始化
__init__
我们很熟悉了,它在对象初始化的时候调用,我们一般将它理解为"构造函数".
实际上, 当我们调用x = SomeClass()
的时候调用,__init__
并不是第一个执行的, __new__
才是。所以准确来说,是__new__
和__init__
共同构成了"构造函数".
__new__
是用来创建类并返回这个类的实例, 而__init__
只是将传入的参数来初始化该实例.
__new__
在创建一个实例的过程中必定会被调用,但__init__
就不一定,比如通过pickle.load
的方式反序列化一个实例时就不会调用__init__
。
__new__
方法总是需要返回该类的一个实例,而__init__
不能返回除了None的任何值。比如下面例子:
classFoo(object):
def__init__(self):
print 'foo __init__'
return None # 必须返回None,否则抛TypeError
def__del__(self):
print 'foo __del__'
实际中,你很少会用到__new__
,除非你希望能够控制类的创建。
如果要讲解__new__
,往往需要牵扯到metaclass
(元类)的介绍。
对于__new__
的重载,Python文档中也有了详细的介绍。
在对象的生命周期结束时, __del__
会被调用,可以将__del__
理解为"析构函数".__del__
定义的是当一个对象进行垃圾回收时候的行为。
有一点容易被人误解, 实际上,x.__del__()
并不是对于del x
的实现,但是往往执行del x
时会调用x.__del__()
.
怎么来理解这句话呢? 继续用上面的Foo类的代码为例:
foo = Foo()
foo.__del__()
print foo
del foo
print foo # NameError, foo is not defined
如果调用了foo.__del__()
,对象本身仍然存在. 但是调用了del foo
, 就再也没有foo这个对象了.
请注意,如果解释器退出的时候对象还存在,就不能保证 __del__
被确切的执行了。所以__del__
并不能替代良好的编程习惯。
比如,在处理socket时,及时关闭结束的连接。
属性访问控制
总有人要吐槽Python缺少对于类的封装,比如希望Python能够定义私有属性,然后提供公共可访问的getter和 setter。Python其实可以通过魔术方法来实现封装。
__getattr__(self, name)
该方法定义了你试图访问一个不存在的属性时的行为。因此,重载该方法可以实现捕获错误拼写然后进行重定向, 或者对一些废弃的属性进行警告。
__setattr__(self, name, value)
__setattr__
是实现封装的解决方案,它定义了你对属性进行赋值和修改操作时的行为。
不管对象的某个属性是否存在,它都允许你为该属性进行赋值,因此你可以为属性的值进行自定义操作。有一点需要注意,实现__setattr__
时要避免"无限递归"的错误,下面的代码示例中会提到。
__delattr__(self, name)
__delattr__
与__setattr__
很像,只是它定义的是你删除属性时的行为。实现__delattr__
是同时要避免"无限递归"的错误。
__getattribute__(self, name)
__getattribute__
定义了你的属性被访问时的行为,相比较,__getattr__
只有该属性不存在时才会起作用。
因此,在支持__getattribute__
的Python版本,调用__getattr__
前必定会调用 __getattribute__
。__getattribute__
同样要避免"无限递归"的错误。
需要提醒的是,最好不要尝试去实现__getattribute__
,因为很少见到这种做法,而且很容易出bug。
例子说明__setattr__
的无限递归错误:
def__setattr__(self, name, value):
self.name = value
# 每一次属性赋值时, __setattr__都会被调用,因此不断调用自身导致无限递归了。
因此正确的写法应该是:
def__setattr__(self, name, value):
self.__dict__[name] = value
__delattr__
如果在其实现中出现del self.name
这样的代码也会出现"无限递归"错误,这是一样的原因。
下面的例子很好的说明了上面介绍的4个魔术方法的调用情况:
classAccess(object):
def__getattr__(self, name):
print '__getattr__'
return super(Access, self).__getattr__(name)
def__setattr__(self, name, value):
print '__setattr__'
return super(Access, self).__setattr__(name, value)
def__delattr__(self, name):
print '__delattr__'
return super(Access, self).__delattr__(name)
def__getattribute__(self, name):
print '__getattribute__'
return super(Access, self).__getattribute__(name)
access = Access()
access.attr1 = True # __setattr__调用
access.attr1 # 属性存在,只有__getattribute__调用
try:
access.attr2 # 属性不存在, 先调用__getattribute__, 后调用__getattr__
except AttributeError:
pass
del access.attr1 # __delattr__调用
描述器对象
我们从一个例子来入手,介绍什么是描述符,并介绍__get__
, __set__
, __delete__
的使用。(放在这里介绍是为了跟上一小节介绍的魔术方法作对比)
我们知道,距离既可以用单位"米"表示,也可以用单位"英尺"表示。
现在我们定义一个类来表示距离,它有两个属性: 米和英尺。
classMeter(object):
'''Descriptor for a meter.'''
def__init__(self, value=0.0):
self.value = float(value)
def__get__(self, instance, owner):
return self.value
def__set__(self, instance, value):
self.value = float(value)
classFoot(object):
'''Descriptor for a foot.'''
def__get__(self, instance, owner):
return instance.meter * 3.2808
def__set__(self, instance, value):
instance.meter = float(value) / 3.2808
classDistance(object):
meter = Meter()
foot = Foot()
d = Distance()
print d.meter, d.foot # 0.0, 0.0
d.meter = 1
print d.meter, d.foot # 1.0 3.2808
d.meter = 2
print d.meter, d.foot # 2.0 6.5616
在上面例子中,在还没有对Distance的实例赋值前, 我们认为meter和foot应该是各自类的实例对象, 但是输出却是数值。这是因为__get__
发挥了作用.
我们只是修改了meter,并且将其赋值成为int,但foot也修改了。这是__set__
发挥了作用.
描述器对象(Meter、Foot)不能独立存在, 它需要被另一个所有者类(Distance)所持有。
描述器对象可以访问到其拥有者实例的属性,比如例子中Foot的instance.meter
。
在面向对象编程时,如果一个类的属性有相互依赖的关系时,使用描述器来编写代码可以很巧妙的组织逻辑。
在Django的ORM中, models.Model中的IntegerField等, 就是通过描述器来实现功能的。
一个类要成为描述器,必须实现__get__
, __set__
, __delete__
中的至少一个方法。下面简单介绍下:
__get__(self, instance, owner)
参数instance是拥有者类的实例。参数owner是拥有者类本身。__get__
在其拥有者对其读值的时候调用。
__set__(self, instance, value)
__set__
在其拥有者对其进行修改值的时候调用。
__delete__(self, instance)
__delete__
在其拥有者对其进行删除的时候调用。
构造自定义容器(Container)
在Python中,常见的容器类型有: dict, tuple, list, string。
其中tuple, string是不可变容器,dict, list是可变容器。
可变容器和不可变容器的区别在于,不可变容器一旦赋值后,不可对其中的某个元素进行修改。
比如定义了l = [1, 2, 3]
和t = (1, 2, 3)
后, 执行l[0] = 0
是可以的,但执行t[0] = 0
则会报错。
如果我们要自定义一些数据结构,使之能够跟以上的容器类型表现一样,那就需要去实现某些协议。
这里的协议跟其他语言中所谓的"接口"概念很像,一样的需要你去实现才行,只不过没那么正式而已。
如果要自定义不可变容器类型,只需要定义__len__
和 __getitem__
方法;
如果要自定义可变容器类型,还需要在不可变容器类型的基础上增加定义__setitem__
和 __delitem__
。
如果你希望你的自定义数据结构还支持"可迭代", 那就还需要定义__iter__
。
__len__(self)
需要返回数值类型,以表示容器的长度。该方法在可变容器和不可变容器中必须实现。
__getitem__(self, key)
当你执行self[key]
的时候,调用的就是该方法。该方法在可变容器和不可变容器中也都必须实现。
调用的时候,如果key的类型错误,该方法应该抛出TypeError;
如果没法返回key对应的数值时,该方法应该抛出ValueError。
__setitem__(self, key, value)
当你执行self[key] = value
时,调用的是该方法。
__delitem__(self, key)
当你执行del self[key]
的时候,调用的是该方法。
__iter__(self)
该方法需要返回一个迭代器(iterator)。当你执行for x in container:
或者使用iter(container)
时,该方法被调用。
__reversed__(self)
如果想要该数据结构被內建函数reversed()
支持,就还需要实现该方法。
__contains__(self, item)
如果定义了该方法,那么在执行item in container
或者 item not in container
时该方法就会被调用。
如果没有定义,那么Python会迭代容器中的元素来一个一个比较,从而决定返回True或者False。
__missing__(self, key)
dict
字典类型会有该方法,它定义了key如果在容器中找不到时触发的行为。
比如d = {'a': 1}
, 当你执行d[notexist]
时,d.__missing__('notexist')
就会被调用。
下面举例,使用上面讲的魔术方法来实现Haskell语言中的一个数据结构。
# -*- coding: utf-8 -*-
classFunctionalList:
''' 实现了内置类型list的功能,并丰富了一些其他方法: head, tail, init, last, drop, take'''
def__init__(self, values=None):
if values is None:
self.values = []
else:
self.values = values
def__len__(self):
return len(self.values)
def__getitem__(self, key):
return self.values[key]
def__setitem__(self, key, value):
self.values[key] = value
def__delitem__(self, key):
del self.values[key]
def__iter__(self):
return iter(self.values)
def__reversed__(self):
return FunctionalList(reversed(self.values))
defappend(self, value):
self.values.append(value)
defhead(self):
# 获取第一个元素
return self.values[0]
deftail(self):