10.描述器和装饰器

1.__new__方法

1、__new__方法是在类创建实例的时候
自动调用的
2、实例是通过类里面的__new__方法是在
类 创建出来的
3、先调用__new__方法创建实例，再调用
__init__方法初始化实例
4、__new__方法，后面括号里的cls代表
的是类本身

class AA:
    def __init__(self):
        print('我是__init__')
    def __new__(cls):
        print('我是__new__')
        return object.__new__(cls)#会优先执行__new__这个方法，再去初始化__init__这个方法

a = AA()
结果：
我是__new__
我是__init__

2.定制属性访问

2.1.hasattr、getattr、__getattribute__查

class AA:
    name = '小红'
    age = 18
    sex = '女'

a = AA()
print(hasattr(a,'name'))#查询AA这个类里面是否有name这个属性，如果有就T，否则就F
print(getattr(a,'age'))#查询AA这个类里面是否有age这个属性，如果有就返回值age里面所赋的值18,否则报错（这个是封装的方法）
print(a.__getattribute__('sex'))#查询AA这个类里面是否有sex这个属性,如果有就返回值，否则报错（这个是魔法方法）
结果：
True
18
女

class AA:
    name = '小红'
    age = 18
    sex = '女'
    def __getattr__(self, item):
     	return '没有这个属性'

a = AA()
print(hasattr(a,'name'))#查询AA这个类里面是否有name这个属性，如果有就T，否则就F
print(getattr(a,'age'))#查询AA这个类里面是否有age这个属性，如果有就返回值age里面所赋的值18,否则报错（这个是封装的方法）
print(getattr(a,'a'))#添加了__getattr__这个魔法方法，查询AA这个类里面是否有a这个属性，如果有就返回值age里面所赋的值18,否则返回'没有这个属性'
print(a.__getattribute__('sex'))#查询AA这个类里面是否有sex这个属性,如果有就返回值，否则报错（这个是魔法方法）
print(a.__getattr__('s'))#查询AA这个类里面是否有s这个属性,如果有就返回值，否则返回'没有这个属性'
结果：
True
18
没有这个属性
女
没有这个属性

2.2.增

class AA:
    name = '小明'

a = AA()
a.age = 18#通过实例直接增属性以及值
setattr(a,'sex','男')#有则增，无则改
a.__setattr__('编号','1')#有则增，无则改
print(hasattr(a,'age'))#查询a这个实例里面是否有age这个属性,有就返回T，没有就F
print(getattr(a,'age'))#查询a这个实例里面是否有age这个属性，有就返回age的值
print(getattr(a,'sex'))
print(getattr(a,'编号'))
setattr(a,'name','小红')
a.__setattr__('sex','女')
print(getattr(a,'name'))
print(getattr(a,'sex'))
结果：
True
18
男
1
小红
女

2.3.删

class AA:
    name = '小明'
    age = 18
    sex = '男'
    def __getattr__(self,item):
        return '没有这个属性'
a = AA()
print(getattr(a,'name'))
delattr(AA,'name')#删除AA类里面的name属性
print(getattr(a,'name'))
结果：
小明
没有这个属性

3.描述符

class A:
    def __get__(self, instance, owner):#获取
        print('我是__get__获取魔法方法')
    def __set__(self, instance, value):#修改
        print('我是__set__修改魔法方法')
    def __delete__(self, instance):#删除
        print('我是__delete__删除魔法方法')
class B:
    a = A()
    def __del__(self):#析构方法
        print('最后执行B类里面的析构方法')
b = B()
b.a#属性的访问/获取,调用的是get
b.a = 'name'#属性的修改，调用的是set
del b.a#属性的删除，调用的是del
结果：
我是__get__获取魔法方法
我是__set__修改魔法方法
我是__delete__删除魔法方法
最后执行B类里面的析构方法

4.装饰器

装饰器本质上就是函数，不修改函数的基础上增加功能
在闭包的基础下
在嵌套函数的基础上才叫闭包

def f1(func):#定义一个函数f1，把下面定义的函数func传进f1这个函数里面去,相当于回调
    def f2():
        print('验证1-------')
        print('验证2-------')
        func()#调用本身的功能
    return f2#外层的函数返回内层的函数体
@f1#证明加有装饰器的证明  #@f相当于把f1()一个整体函数传给f()
def func():#定义函数，如果说不用装饰器上面的@f的话， f1()只会打印我是基础代码，装饰器先写函数，再写前面的闭包
    print('我是基础功能代码')
func()
结果：
验证1-------
验证2-------
我是基础功能代码

python内置装饰器
@property
@staticmethod
@classmethod

class A:
    age = 18
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex
    def a(self):#方法
        print('方法1')
    @property #就和访问属性一样
    def b(self):#方法
        return print('我叫%s,性别%s'%(self.name,self.sex))
    @staticmethod #定义一个静态的方法,与class类断开
    def c():#使用@staticmethod静态的装饰器的话，这个就变成了函数
        print('方法3')
    @classmethod #这个是类方法，cls代表类的本身
    def d(cls):#可以直接调用父类属性
        print(cls.age)
aa = A('小红','女')
aa.a()
aa.b
aa.c()
aa.d()
结果：
方法1
我叫小红,性别女
方法3
18