new方法，定制属性的访问，描述符，装饰器

一、__new__方法
class A(object):
    def __init__(self):
        print("hello")

a = A()
#实例化的时候被调用
# new  方法就是用来创建对象 先创建再初始化

class Person:
    def __init__(self):
        print('yuan')

    def __new__(cls, *args, **kwargs): #cls类本身
        print(cls)
        return object.__new__(cls)

print(Person)    #cls Person 是一个类
a = Person()


class Person:
    pass
a = Person()
b = Person()
print(id(a))
print(id(b))   #id 不同各自独立

#单例模式
class A:
    _instance = None
    def __new__(cls, *args, **kwargs):
        if cls._instance == None:
            cls._instance = object.__new__(cls)
            return cls._instance
        else:
            return cls._instance


a = A()
b = A()
print(id(a))
print(id(b))
# 单例模式效果实在同一id上进行创建
# 单例模式



二、定制属性访问
增：
re .aaa = 1
setattr(re, 'bbb', 2)  # 有bbb属性就改，没有就增
re.__setattr__('ccc', 3) # 同上
删：
delattr(re , 'ccc')
re .__delattr__('bbb')
del re 
改：
setattr(re , 'length', 6)
re .__setattr__('length', 5)
查：
hasattr(re, 'length')	# 返回bool值
getattr(re,  'length')	# 返回属性值
re . __getattribute__('length') # 返回属性值

class Person:
    def __init__(self,name):
        self.name = name

a = Person('qiye')
print(hasattr(a,'name'))  #查 返回bool值
print(getattr(a,'name'))  #c查 返回属性值
print(a.__getattribute__('name'))  #查 返回属性值
setattr(a,'name','b')  #  修改(对象，属性，内容)
print(a,'name')
setattr(a,'age',9)  #有则改 无则增
delattr(a,'name')  #删除
三、描述符
class A:
    def __get__(self, instance, owner): #（实例和类）
        print('get')

    def __set__(self, instance, value):
        print('set')

    def __delete__(self, instance):
        print('deleat')

class B:
    a = A()

b = B()   #实例化
b.a   # 访问属性
b.a = 'laowang'
#描述符协议：python描述符是一个“绑定行为”的对象属性，在描述符协议中，它可以通过方法重写属性的访问。这些方法有 __get__(), __set__(), 和__delete__()。如果这些方法中的任何一个被定义在一个对象中，这个对象就是一个描述符


四、装饰器   #就是闭包  本质是函数，能够实现在不修改原来的函数的基础上添加功能。
def girl():
    return '这是一个女孩'
a = girl()
print(a)

def modify(func):
    result = func()
    return result + ',他叫小芳'
j = modify(girl)
print(j)

def modify(func):    #闭包
    def wrapper():
        result = func()
        return result + ',他叫小芳'
    return wrapper
g = modify(girl)
print(g())

@modify   #语法糖  只会影响一行
def girl():    #会把girl 传到装饰器里面去
    return '这是一个女孩'

e = girl()
print(e)
#自带三个装饰器
@ modify   #语法糖  只会影响一行
def girl():    #会把girl 传到装饰器里面去
    return '这是一个女孩'

e = girl()
print(e)

class Person:
    @ property  #把我们的方法变成像属性一样调用  不用（）项目用的比较多
    def run(self):
        print('人在跑')

a = Person ()
a.run

class Person:
    @ staticmethod  #静态方法  去掉self  变成普通函数
    def run():  #与实例解绑
        print('人在跑')

b = Person()
b.run

class Person:
    @ classmethod
    def world(cls):
        print('hello world')

Person.world()  #类调方法


class Myclss:
    def __init__(self,func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print("__开始验证__")
        return self.func()

@ Myclss  #类当做装饰器
def func():
    print("__正在登陆__")
func()

#类装饰器   类也可以做装饰器，但是需要定义 __call__ 方法
class Test_Class:
    def __init__(self, func):
        self.func = func
    def __call__(self):
        print('类')
        return self.func
@Test_Class
def fun_test():
    print('这是个测试函数')

fun_test()