属性访问控制
所谓的属性访问控制就是控制点号访问属性的行为，而且不仅是类的外部，连类的内部也受控制，代码见真章，边看代码边解释：
•__getattr__(self, item)
定义当访问不存在的属性时的行为，注意是不存在的属性。
|
1
2
3
4
5
6
7
8
9
10
|
class Foo(object):
def __init__(self, value):
self.value = value
def __getattr__(self, item):
print item # 查看得到的参数是什么
print type(item) # 参数的类型是什么
return 'attr:%s' % item # 最后返回一个东西看其行为如何
a = Foo('scolia') # 创建一个实例
|
测试：
|
1
2
|
print a.value
print type(a.value)
|
其行为和没定义前正常，下面看看访问一个不存在的属性时会发生什么：
|
1
|
print a.abc
|
按照平常的情况，访问不存在的属性时肯定会抛出异常，但是这里输出了三行，前两个是方法输出的，最后一行是外部的print语句输出的，输出的是方法的return值。方法得到的是我们访问的属性名，而且是以字符串的形式。
知道了以上信息后，我们就可以定制更多：
|
1
2
3
4
5
6
7
8
9
|
class Foo(object):
def __init__(self, value):
self.value = value
def __getattr__(self, item):
if item == 'scolia':
return 'can not set attr: %s' % item # 访问不存在的scolia属性时，打印一句话而不报错
else:
raise AttributeError('not attr name: %s' % item) # 访问其他不存在的属性时，触发异常。
|
测试：
|
1
2
|
a = Foo(123)
print a.value # 访问存在的属性
|
|
1
|
print a.scolia # 访问不存在的属性，但我们做了特殊处理的
|
没有触发异常，和我们设想的一样。
|
1
|
print a.good # 访问不存在的属性，但应该触发异常的
|
触发了我们想要的异常。
这里要再强调一遍，必须是访问不存在的属性时，才会调用这个方法，例如：
|
1
2
|
a.scolia = 321
print a.scolia
|
因为这个属性已经存在了（我们手动添加了），所以访问它的时候并没有调用这个方法，而在方法里所做的任何处理，也不会有效。
更高级的技巧：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class Foo(object):
def __init__(self, value, defulat=None):
self.value = value
self.__defulat = defulat
def __getattr__(self, item):
item = item.lower() # 用字符串的方法对其进行小写
if item in self.__dict__:
return self.__dict__[item] # 返回相应的属性
else:
self.__dict__[item] = self.__defulat # 若属性不存在则添加这个属性并使用默认值
return self.__dict__[item]
a = Foo(123)
a.scolia = 321
print a.SCOlia
print a.good
|
我们实现了属性的不区分大小写访问和自动添加不存在的属性。
这里的秘诀在于活用 __dict__ 这个属性，我在类的属性中已经讨论过这个属性。这个属性由python自动创建，是一个字典，包含对象的所有属性，字典里的键就是属性名，对应的值就是属性值。所以这里在这个字典中添加了键和值，就相当于为对象添加了属性和属性值。
•__setattr__(self, key, value)
定义了设置属性时的行为，包括在 __init__ 初始化函数中的设置行为：
|
1
2
3
4
5
6
7
8
9
10
|
class Foo(object):
def __init__(self, value, defulat=None):
self.value = value
def __setattr__(self, key, value):
print key, type(key)
print value, type(value)
a = Foo('scolia')
b = Foo(123)
|
这里可以看到初始化函数中的属性添加的行为也受到了控制，其中 key 得到的是属性名，以字符串的形式；而 value 得到的是属性值，属性值根据输入的不同而不同。
在这里，我们仅仅只是打印了几句话，而没有进行属性的添加，所以当我们试图访问相应的属性时，会发现根本就没有：
|
1
|
print a.value
|
触发了异常，表示没有相应的属性。
知道了这些之后我们可以做很多事情，例如将所有的属性名变成小写或大写，控制某些属性名不能添加之类的，就不再举例。不过，这里你总不可能用 self.key = value 来添加属性吧，因为 key 始终是一个字符串。这个时候就要使用 __dict__ 属性了，向这个字典中添加相应的键值对就可以了，具体就不再演示了。
•__delattr__(self, item)
定义了删除一个属性时的行为，item 得到的也是一个字符串形式的属性名，具体细节也无序多说，只要 del 掉 __dict__ 字典中对应是键和值就行了。另外，删除不存在的属性时调用的也是这个方法。
•__getattribute__(self, name)
这个方法定义了所有属性访问的行为，注意是所有，而不是 __getattr__ 中的不存在。当实现了这个方法之后，将会覆盖 __getattr__ 方法，毕竟所有涵盖了不存在。
这个方法只在新式类中有效。
但是，你也可以显式的调用 __getattr__，例如 a.__getattr__ 来使用这个被掩盖的方法，或者是触发 AttributeError 异常时也会自动调用它。
然而，非常不建议使用这个方法，因为可能会很多不可预知的异常情况，最常见的就是无尽的递归调用，例如：
|
1
2
3
4
5
6
7
8
9
|
class Foo(object):
def __init__(self, value):
self.value = value
def __getattribute__(self, item):
return self.__dict__[item]
a = Foo('scolia')
print a.value
|
这段代码看起来很正常，但是这里有一个陷阱，因为类中的所有的属性访问都是受这几个魔法方法控制的，包括上面介绍的几个魔法方法。它们似乎比普通的魔法方法拥有更高的权限一般。
但这就导致了一个问题，例如这里的 self.__dict__[item] ，这句话也受属性访问的控制，尽管这个属性是 python 为我们创建的。
也就是说获取 self.__dict__ 时，会再次调用 __getattribute__ 方法，然后方法内又调用了 self.__dict__ 。这样无限循环下去，最终会抛出一个异常。
异常信息非常长，这里我是拉到最后才截的图。
其实不仅这个魔法方法会导致这样异常，上面讨论的几种魔法方法可能都会出现这个问题，只不过这个魔法方法的权限更大，所以异常出现的可能性更高一些。
这也就是不推荐这个魔法方法的原因，而使用其他的属性控制方法的时候也要小心。
而到目前为止，我们所学到的属性访问的方法只有两种，一是直接用点号访问，还有就是先通过点号访问__dict__ 属性，然后在这个字典中获取相应的键值对。而这两种方法都受到了 __getattribute__ 的控制，调用它们就相当于没有终点的自调用（有终点的自调用有时能提升效率），那么这个方法到底要怎么用呢？
技巧就是调用父类的这个方法：
|
1
2
3
4
5
6
7
8
9
|
class Foo(object):
def __init__(self, value):
self.value = value
def __getattribute__(self, item):
return object.__getattribute__(self, item) # 非绑定方法要显式传递self
a = Foo('scolia')
print a.value
|
这里调用的是object的这个方法，如果是涉及到继承的话：
|
1
2
3
4
5
6
7
8
9
10
11
|
class Boo(Foo):
def __init__(self, value):
self.value = value
def __getattribute__(self, item):
return Foo.__getattribute__(self, item)
# return super(Boo, self).__getattribute__(item) 也可以使用super函数让python自动在其父类们寻找这个方法。
a = Foo('scolia')
print a.value
b = Boo(123)
print b.value
|
访问正常。
其实最后调用了还是 object 或其他内置类型的方法。
而我们姑且不起探究object到底是怎么实现的，因为这可能是用 C 所写的，只要会用就可以，虽然这个方法用的也不多。
最后附上一个完整的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
class Foo(object):
def __init__(self, value):
self.value = value
def __getattr__(self, item):
if item == 'scolia':
return 'no attr:%s' % item
elif item in self.__dict__:
return self.__dict__[item]
else:
raise AttributeError('no attr:%s' % item)
def __setattr__(self, key, value):
if key == 'good':
print 'can not set the attr: good'
else:
self.__dict__[key] = value
def __delattr__(self, item):
if item == 'a':
print 'no attr: good'
else:
del self.__dict__[item]
def __getattribute__(self, item):
if item == 'a':
raise AttributeError('not a')
return object.__getattribute__(self, item)
a = Foo('scolia')
print a.value # 正常访问
a.a = 123 # __getattribute__会触发AttributeError异常，此时调用__getattr__
# 而__getattr__添加了这个属性，所以最后异常没有触发，属性也添加了
print a.a # 结果能够访问
del a.a # 试图删除这个属性
print a.a # 删除行为被阻止了，所以该属性还在
a.good = 'good' # 因为添加被阻止了
print a.good # 所以访问失败了
|
结果：
以上这篇python魔法方法-属性访问控制详解就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持服务器之家。