python魔法方法-属性访问控制

属性访问控制

  所谓的属性访问控制就是控制点号访问属性的行为,而且不仅是类的外部,连类的内部也受控制,代码见真章,边看代码边解释:

  • __getattr__(self, item)

  定义当访问不存在的属性时的行为,注意是不存在的属性。

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‘)   # 创建一个实例

测试:

print a.value
print type(a.value)

其行为和没定义前正常,下面看看访问一个不存在的属性时会发生什么:

print a.abc

  按照平常的情况,访问不存在的属性时肯定会抛出异常,但是这里输出了三行,前两个是方法输出的,最后一行是外部的print语句输出的,输出的是方法的return值。方法得到的是我们访问的属性名,而且是以字符串的形式。

  知道了以上信息后,我们就可以定制更多:

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)    # 访问其他不存在的属性时,触发异常。

测试:

a = Foo(123)
print a.value  # 访问存在的属性

  结果正常

print a.scolia  # 访问不存在的属性,但我们做了特殊处理的

  没有触发异常,和我们设想的一样。

print a.good  # 访问不存在的属性,但应该触发异常的

  触发了我们想要的异常。

  这里要再强调一遍,必须是访问不存在的属性时,才会调用这个方法,例如:

a.scolia = 321
print a.scolia

  因为这个属性已经存在了(我们手动添加了),所以访问它的时候并没有调用这个方法,而在方法里所做的任何处理,也不会有效。

更高级的技巧:

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__ 初始化函数中的设置行为:

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 得到的是属性值,属性值根据输入的不同而不同。

  在这里,我们仅仅只是打印了几句话,而没有进行属性的添加,所以当我们试图访问相应的属性时,会发现根本就没有:

print a.value

  触发了异常,表示没有相应的属性。

  知道了这些之后我们可以做很多事情,例如将所有的属性名变成小写或大写,控制某些属性名不能添加之类的,就不再举例。不过,这里你总不可能用 self.key = value 来添加属性吧,因为 key 始终是一个字符串。这个时候就要使用 __dict__ 属性了,向这个字典中添加相应的键值对就可以了,具体就不再演示了。


  • __delattr__(self, item)

  定义了删除一个属性时的行为,item 得到的也是一个字符串形式的属性名,具体细节也无序多说,只要 del 掉 __dict__ 字典中对应是键和值就行了。另外,删除不存在的属性时调用的也是这个方法。


  • __getattribute__(self, name)

  这个方法定义了所有属性访问的行为,注意是所有,而不是 __getattr__ 中的不存在。当实现了这个方法之后,将会覆盖 __getattr__ 方法,毕竟所有涵盖了不存在。

  但是,你也可以显式的调用 __getattr__,例如 a.__getattr__ 来使用这个被掩盖的方法,或者是触发 AttributeError 异常时也会自动调用它。

  然而,非常不建议使用这个方法,因为可能会很多不可预知的异常情况,最常见的就是无尽的递归调用,例如:

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__ 的控制,调用它们就相当于没有终点的自调用(有终点的自调用有时能提升效率),那么这个方法到底要怎么用呢?

  技巧就是调用父类的这个方法:

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的这个方法,如果是涉及到继承的话:

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 所写的,只要会用就可以,虽然这个方法用的也不多。

最后附上一个完整的例子:

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  # 所以访问失败了

结果:



  欢迎大家交流。

时间: 2024-11-05 17:29:50

python魔法方法-属性访问控制的相关文章

python 魔法方法,属性,迭代

9.2 构造方法 python 中也属于自己的构造函数和析构函数, class fibs: def __init__(self): self.a = 0 self.b = 1 def next(self): self.a,self.b = self.b,self.a+self.b return self.a def __iter__(self): return self fib = fibs() for i in fib: if i>1000: print i break 其中的__init__

Python 魔法方法~~

网友写的python魔法方法详情 :详情 魔法方法 含义   基本的魔法方法 __new__(cls[, ...]) 1. __new__ 是在一个对象实例化的时候所调用的第一个方法2. 它的第一个参数是这个类,其他的参数是用来直接传递给 __init__ 方法3. __new__ 决定是否要使用该 __init__ 方法,因为 __new__ 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例,如果 __new__ 没有返回实例对象,则 __init__ 不会被调用4. __ne

Python魔法方法总结及注意事项

1.何为魔法方法: Python中,一定要区分开函数和方法的含义: 1.函数:类外部定义的,跟类没有直接关系的:形式: def func(*argv): 2.方法:class内部定义的函数(对象的方法也可以认为是属性):分为两种: ① python自动产生的(魔法方法):一般形式为 __func__(),python会在对应的时机自动调用该函数: ② 人为自定义的方法:一般和普通函数没有区别,只是定义在了class中而已 3.方法与函数的区别: 方法可认为是函数的特殊情况: ① 方法定义在cla

python 魔法方法(学习过程的笔记)

有小伙伴会问,什么是python的魔法方法,python的魔法方法有什么用呢, 它们在面向对象的Python的处处皆是.它们是一些可以让你对类添加"魔法"的特殊方法. 它们经常是两个下划线包围来命名的. 我感觉魔法方法很牛逼的, 目前我们常见的魔法方法大致可分为以下几类: 构造与初始化 类的表示 访问控制 比较操作 容器类操作 可调用对象 Pickling序列化 在我们写python中最常见的就是__init__,这是python的构造方法,这是初始化对象,定义一个对象的初始化的值,_

python魔法方法

Python 魔术方法指南 入门 构造和初始化 构造定制类 用于比较的魔术方法 用于数值处理的魔术方法 表现你的类 控制属性访问 创建定制序列 反射 可以调用的对象 会话管理器 创建描述器对象 持久化对象 总结 附录 介绍 此教程为我的数篇文章中的一个重点.主题是魔术方法. 什么是魔术方法?他们是面向对象的Python的一切.他们是可以给你的类增加”magic”的特殊方法.他们总是被双下划线所包围(e.g. __init__ 或者 __lt__).然而他们的文档却远没有提供应该有的内容.Pyth

python魔法方法详解

文章来源:http://blog.csdn.net/koko66/article/details/42709279 据说,Python 的对象天生拥有一些神奇的方法,它们总被双下划线所包围,他们是面向对象的 Python 的一切. 他们是可以给你的类增加魔力的特殊方法,如果你的对象实现(重载)了这些方法中的某一个,那么这个方法就会在特殊的情况下被 Python 所调用,你可以定义自己想要的行为,而这一切都是自动发生的. Python 的魔术方法非常强大,然而随之而来的则是责任.了解正确的方法去使

python魔法方法-反射运算和增量运算

反射运算 什么是反射运算符,其实就是反转了两个对象,下面先看一个普通运行符的实现: class Foo(object): def __init__(self, x): self.x = x def __add__(self, other): return 'Foo:%s + %s' % (self.x, other.x) class Boo(object): def __init__(self, x): self.x = x def __add__(self, other): return 'B

知识点:Python 魔法方法详解

据说,Python 的对象天生拥有一些神奇的方法,它们总被双下划线所包围,他们是面向对象的 Python 的一切. 他们是可以给你的类增加魔力的特殊方法,如果你的对象实现(重载)了这些方法中的某一个,那么这个方法就会在特殊的情况下被 Python 所调用,你可以定义自己想要的行为,而这一切都是自动发生的. Python 的魔术方法非常强大,然而随之而来的则是责任.了解正确的方法去使用非常重要! 魔法方法 含义 基本的魔法方法 __new__(cls[, ...]) 1. __new__ 是在一个

python魔法方法-属性转换和类的表示

类型转换魔法 类型转换魔法其实就是实现了str.int等工厂函数的结果,通常这些函数还有类型转换的功能,下面是一些相关的魔法方法: __int__(self) 转换成整型,对应int函数. __long__(self) 转换成长整型,对应long函数. __float__(self) 转换成浮点型,对应float函数. __complex__(self) 转换成 复数型,对应complex函数. __oct__(self) 转换成八进制,对应oct函数. __hex__(self) 转换成十六进