七夕节写那些结伴而行的特殊方法

__getattr__和__setattr__

这两个特别简单，__getattr__是通过属性操作符.或者反射getattr(),hasattr()无法获取到指定属性(对象,类,父类)的时候,该方法被调用

__setattr__则是设置属性的时候被调用

class A:
    def __getattr__(self, item):

        print('%s找不到这个属性'%item)

    def __setattr__(self, instance, value):
        print('设置了%s == %s'%(instance,value))

a = A()
a.aa # aa找不到这个属性
hasattr(a,'bb') # bb找不到这个属性

a.aa = 'a' # 设置了aa == a
setattr(a,'bb','bb') # 设置了bb == bb

与他相关的一个方法__getattribute__,尝试获取属性时总会调用这个方法(特殊属性或特殊方法除外),当该方法抛出AttributeError时才会调用__getattr__方法.

class A:
    def __getattr__(self, item):

        print('%s找不到这个属性'%item)

    def __setattr__(self, instance, value):
        print('设置了%s == %s'%(instance,value))
    def __getattribute__(self, item):
        return 1
a = A()
print(a.aa) # 1
print(hasattr(a,'bb')) #True

a.aa = 'a' # 设置了aa == a
setattr(a,'bb','bb') # 设置了bb == bb

 __getitem__和__setitem__

对象使用[]时调用的方法, 这里主要说一下切片的原理. 

关键字存在一个slice(), 其实这是一个类

print(slice) # <class 'slice'>

print(dir(slice))
# ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', 
# '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', 
# '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', 
# '__str__', '__subclasshook__', 'indices', 'start', 'step', 'stop']

　　其中indices方法可以根据序列长度修改切片信息,返回一个由起始位置,结束位置,步幅组成的元组.

print(slice(0,10,2).indices(6)) # (0, 6, 2)
print(slice(-3).indices(6)) # (0, 3, 1)

　来看一下我们切片时的操作吧

class A:
    def __getitem__(self, item):
        print(item)

a = A()
a[1:2] # slice(1, 2, None)

　　当使用切片时item就是slice对象

我们这样就可以定义自己的序列类型的切片操作了

class Start:
    def __init__(self,lis=None):
        if lis:
            if isinstance(lis,list):
                self.lis = lis

            else:
                raise TypeError('类型错误')
        else:
            self.lis = []

    def push(self,item):
        self.lis.append(item)

    def pull(self):
        return self.lis.pop()

    def __str__(self):
        return "%s(%s)"%(self.__class__.__name__,self.lis)

    def __getitem__(self, item):
        if isinstance(item,slice):
            return Start(self.lis[item])
        elif isinstance(item,int):
            return self.lis[item]
        else:
            raise TypeError("类型错误")

a = Start([1,2,3,4,5])
print(a[2]) # 3
print(a[2:10]) # Start([3, 4, 5])

 __get__和__set__

之前搜特殊方法的时候看到这两个是操作描述符时调用的方法,而描述符是什么呢? 实现了__get__, __set__或__delete__方法的类就是一个描述符

描述符的用法是创建一个实例,作为另一个类的类属性.

记得property()吧,特性其实也是描述符. 有一些受保护的属性,他的值需要做一些判断, 这时候我们用了property

class Person:
    _age = None
    @property
    def age(self):
        return self._age

    @age.setter
    def age(self,age):
        if age>0 and age<100:
            self._age = age



a = Person()
a.age=10
print(a.age)

我们通过__get__和__set__也能够做到

class Age:
    def __init__(self,age=None):
        self._age = age

    def __get__(self, instance, owner):
        print(instance,owner) # <__main__.Person object at 0x0000024396465470> <class '__main__.Person'>
        return self._age

    def __set__(self, instance, value):
        print(instance, value) # <__main__.Person object at 0x000002B109AB2160> 10
        if value>0 and value<100:
            self._age = value

        else :
            raise TypeError()


class Person:
    age = Age()

a = Person()
print(a.age)
a.age = 10
b = Person()
print(b.age) # 10

干的漂亮b的age也变成了10,为什么? 这就是覆盖型描述符和非覆盖描述符

实现__set__方法的描述符称为覆盖描述符,实现此方法会覆盖对实例属性的赋值操作. 之前我们给实例属性赋值时是在实例的名称空间内

class Person:
    age = None

a = Person()
a.age = 10
print(a.age) # 10 
print(Person.age) # None

再看一下上个例子

class Age:
     ...
    def __str__(self):
        return self._age
print(Person.age) # None <class '__main__.Person'> 10

所以在描述符的例子中我们操作的是描述符实例,也就是类属性的值, 在描述符中是可以操作托管类实例的instance参数就是托管类实例. 通过instance和__dict__我们就可以将值存储在托管类实例的内存空间内了

class Age:

    def __get__(self, instance, owner):
        print(instance,owner) # <__main__.Person object at 0x0000024396465470> <class '__main__.Person'>
        return instance.__dict__.get('age')

    def __set__(self, instance, value):
        print(instance, value) # <__main__.Person object at 0x000002B109AB2160> 10
        if value>0 and value<100:
            instance.__dict__['age'] = value

        else :
            raise TypeError()


class Person:
    age = Age()



a = Person()
print(a.age)
a.age = 10
b = Person()
print(b.age) # 10

自己实现一个property

class Property:

    def setattr(self, func):
        self.set = func

    @staticmethod
    def _set(*args):
        raise AttributeError("can't set attribute")

    def __init__(self,get,set=None,delter=None):

        self.get = get
        if set:
            self.set = set
        else:
            self.set = Property._set
        self.delter = delter

    def __get__(self, instance, owner):
        return self.get(instance)

    def __set__(self, instance, value):
        self.set(instance,value)



class Person:
    _age = 0
    @Property
    def age(self):
        return self._age
    @age.setattr
    def getage(self,age):
        if age > 0 and age < 100:
            self._age = age

    # def getage(self):
    #         print('获取值')
    #         return self._age
    # age = Property(getage)
a = Person()
print(a.age)
a.age = 10
print(a.age)

b = Person()
print(b.age)

描述符的分类:

• 覆盖性描述符实现了__set__方法的描述符. 该方法会覆盖对实例属性的赋值操作, 用法建议例如只读属性可以在__set__中抛出异常
• 没有实现__get__方法的描述符, 获取实例属性时会得到描述符实例, 用于验证可以只使用__set__方法
• 没有实现__set__方法的描述符是非覆盖性描述符. 设置同名的实例属性描述符会被遮盖.

值的注意的是,无论是不是覆盖性描述符,为类属性赋值都能覆盖描述符.

事实上方法就是描述符,我们可以查看函数的方法

class bb:
    def aa(self):
        pass
# function

b  = bb()
print(b.aa) # <bound method bb.aa of <__main__.bb object at 0x000001EBE99853C8>>
print(bb.aa) # <function bb.aa at 0x000001EBF89C8B70>
print(dir(bb.aa))
# ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', 
# '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', 
# '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', 
# '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', 
# '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', 
# '__str__', '__subclasshook__']

　　我们可以看到函数实现了__get__方法, 通过instance来判断是否是由对象来调用的, 通过托管类访问时返回的是自身. 通过托管实例访问时会将instance绑定给函数的第一个参数, 类似partial

from functools import partial
class Func:
    def __get__(self, instance, owner):
        if not instance:
            return self
        else:
            return partial(self, instance)

    def __call__(self, *args, **kwargs):
        print(11111)

class A:
    func = Func()

print(A.func)
a = A()
print(a.func)

 __enter__ 和 __exit__

上下文协议的两个方法, with后面的语句被求值后，返回对象的 __enter__() 方法被调用，这个方法的返回值将被赋值给as后面的变量。

也就是说with语句后表达式的结果必须是实现了上下文协议的类的对象. 并且__enter__方法的返回值会被赋给as后的变量

class A:
    def __enter__(self):
        print('进来了')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('出去了')

    def b(self):
        print('执行了')

with A() as a:
    a.b()

　　在Flask中的AppContext类中可以看到类似的用法

__exit__方法中有三个参数, 当一切正常时, 这三个参数都是None, 有异常抛出时三个参数分别是异常类, 异常实例, 以及traceback对象.

class A:
    def __enter__(self):
        print('进来了')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(1,exc_type)
        print(2,exc_val)
        print(3,exc_tb)
        print('出去了')

    def b(self):
        print('执行了')

with A() as a:
    a.b()
    raise TypeError('我错啦')

# 执行如下
进来了
Traceback (most recent call last):
执行了
  File "D:/python练习/yian2/shihui/tests.py", line 181, in <module>
1 <class 'TypeError'>
    raise TypeError('我错啦')
2 我错啦
TypeError: 我错啦
3 <traceback object at 0x0000022B387DFCC8>
出去了

　　这里也可以控制跳过某一个异常,只需要__exit__方法返回True即可, 修改__exit__方法如下

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(1,exc_type)
        print(2,exc_val)
        print(3,exc_tb)
        print('出去了')
        if isinstance(exc_val,TypeError):
            return True

# 
进来了
执行了
1 <class 'TypeError'>
2 我错啦
3 <traceback object at 0x000001A0A715FCC8>
出去了

　　如果with语句块中跑出了多个异常??修改with语句如下

with A() as a:
    a.b()
    raise TypeError('我错啦')
    print('我错没错')
    raise TypeError('我没有错')

# 
进来了
执行了
1 <class 'TypeError'>
2 我错啦
3 <traceback object at 0x000002A215D7FCC8>
出去了

　　可见with语句遇到一个没有被捕获的异常时便会退出