Day20:Decorator and Metaclass

1:enter and exit:

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

    def __enter__(self):
        print('execute enter')
        return self    #self to f below

    def __exit__(self, exc_type, exc_val, exc_tb):   #the exit sentance over means the whole with sentence over!
        print('execute exit')
        print(exc_type)
        print(exc_val)
        print(exc_tb)
        return True    #swallow the wrong reports

with Foo('a.txt') as f:      #f = obj.__enter()__
    print(f)             ##<__main__.Foo object at 0x0000000001DC7A60>
    print(sfsddsgfdgfdgdsfgsdf)
    print(f.name)        #a.txt
    # print('========>')
    # print('========>')
    # print('========>')
    # print('========>')
    # print('========>')

print('000000000000000000000000')

# the result:
# execute enter
# ========>
# ========>
# ========>
# ========>
# ========>
# execute exit
# 000000000000000000000000

2:The use of decorator:

#==============>>>>>>>>>data descriptor:
class Typed:
    def __init__(self,key,expected_type):
        self.key = key
        self.expected_type = expected_type

    def __get__(self, instance, owner):
        # print('get function')
        # print('instance parameter[%s]' %instance)
        # print('owner parameter [%s]' %owner)
        return instance.__dict__[self.key]

    def __set__(self, instance, value):
        # print('set function')
        # print('instance parameter[%s]' %instance)
        # print('owner parameter [%s]' %value)
        # print('=====>>',self)    =====>> <__main__.Typed object at 0x0000000002447A60>
        if not isinstance(value,self.expected_type):
            # print('please insert a string type')
            raise TypeError('%s is not the Type %s' %(self.key,self.expected_type))
        instance.__dict__[self.key] = value

    def __delete__(self, instance):
        return instance.__dict__.pop(self.key)

class People:
    name = Typed('name',str)  #trigure __set__()
    age = Typed('age',int)
    salary = Typed('salary',float)
    gender = Typed('gender',str)
    def __init__(self,name,age,salary,gender):
        self.name = name
        self.age = age
        self.salary = salary
        self.gender = gender


# p1 = People('zxver',18,33.3)
# print(p1.__dict__)
p1 = People('zxver',453,234)
# print(p1.__dict__)
# p1.name
# print(p1.name)
# p1.name = 'egon'
# print(p1.__dict__)
# del p1.name
# print(p1.__dict__)
#{'age': 18, 'salary': 33.3}
#because the age is agented by the data descriptor which is higher level than object


#the refined one:
class Typed:
    def __init__(self,key,expected_type):
        self.key = key
        self.expected_type = expected_type

    def __get__(self, instance, owner):
        # print('get function')
        # print('instance parameter[%s]' %instance)   #p1
        # print('owner parameter [%s]' %owner)        #People
        return instance.__dict__[self.key]

    def __set__(self, instance, value):
        # print('set function')
        # print('instance parameter[%s]' %instance)
        # print('owner parameter [%s]' %value)
        # print('=====>>',self)    =====>> <__main__.Typed object at 0x0000000002447A60>
        if not isinstance(value,self.expected_type):
            # print('please insert a string type')
            raise TypeError('%s is not the Type %s' %(self.key,self.expected_type))
        instance.__dict__[self.key] = value

    def __delete__(self, instance):
        return instance.__dict__.pop(self.key)

def deco(**kwargs):
    def wrapper(obj):
        for key,val in kwargs.items():
            # obj.__dict__[key]=val
             setattr(obj,key,Typed(key,val))
        return obj
    return wrapper

# @deco(name=Typed('name',str),age = Typed('age',int),salary = Typed('salary',float),gender = Typed('gender',str))
@deco(name=str,age=int,salary=float,gender=str)#can add the content which you need
class People:
    # name = Typed('name',str)  #trigure __set__()
    # age = Typed('age',int)
    # salary = Typed('salary',float)
    # gender = Typed('gender',str)
    def __init__(self,name,age,salary,gender):
        self.name = name
        self.age = age
        self.salary = salary
        self.gender = gender


# p1 = People('zxver',18,33.3)
# print(p1.__dict__)
p1 = People('zxver',18,13.7,'male')
print(p1.__dict__)
print(People.__dict__)

3:Class_decorator:

# def deco(func):
#     print('=======')
#     return func
#
# # @deco        #test = deco(test)
# # def test():
# #     print('test is executing')
#
# # test()
#
# @deco     #Foo = deco(Foo)
# class Foo:
#     pass
#
# f1 = Foo()
# print(f1)

def deco(obj):
    print('=======',obj)
    obj.x = 1
    obj.y = 2
    obj.z = 3
    return obj

@deco     #Foo = deco(Foo)
class Foo:
    pass

print(Foo.__dict__)

#>>>>>>>>>>>>>>.all is object:
@deco
def test():
    print('test function')
print(test.__dict__)


################

def Typed(**kwargs):
    def deco(obj):
        print('=====>',kwargs)
        print('=====>',obj)
        for key,val in kwargs.items():
            # obj.__dict__[key]=val
             setattr(obj,key,val)
        # obj.x = 1
        # obj.y = 1
        # obj.z = 1
        return obj
    print('===>',kwargs)
    return deco

@Typed(x=1,y=2,z=3)   #it will execute with ()  1.Typed(x=1,y=2,z=3) --->deco 2.@deco --->Foo=deco(Foo)
class Foo:
    pass
print(Foo.__dict__)

@Typed(name='zxver')    #Bar = deco(Bar)
class Bar:
    pass
print(Bar.__dict__)
print(Bar.name)

4:Property:

class Lazyproperty:
    def __init__(self,func):
        print('=======>>')
        self.func = func

    def __get__(self, instance, owner):
        if instance is None:
            return self
        res = self.func(instance)
        setattr(instance,self.func.__name__,res)
        return res

    # def __set__(self, instance, value):
    #     pass
    
##*****************:important:if add __set__attribute ,the set priviledge will be higher ,then when you call tha r1.area,
##it can't ectract the content from r1.

class Room:
    def __init__(self,name,width,length):
        self.name = name
        self.width = width
        self.length = length

    # @property  #area = property(area)
    @Lazyproperty    #area = Lazyproperty(area)    #execute Lazyproperty's _init__function
    def area(self):
        return self.width * self.length

    @property
    def area1(self):
        return self.width * self.length
    @property
    def test(self):
        # print('------')
        return '11111111111111'

r1 = Room('restroom',1,1)
########instance call:
# print(r1.area1)    #execute __get__()
# print(r1.area1)    #execute __get__()
# print(r1.area1)    #execute __get__()

print(r1.area)        #execute __get__()
print(r1.__dict__)    ##extract from the r1
print(r1.area)        ##extract from the r1

########class call:
# print(Room.area)   #add a condition to judge the instance is None,return self,or it will report wrong.
#result:<__main__.Lazyproperty object at 0x0000000001DD7A60>

# r1 = Room('restroom',1,1)
# print(r1.area.func(r1))
# print(Room.__dict__)
# print(r1.test)
# print(Room.test)
#redult:<property object at 0x0000000001E2A0E0>

5:Metaclass:

# class Foo:
#     pass
#
# f1 = Foo()
#
# print(type(f1))
# print(type(Foo))
#the result:
# <class '__main__.Foo'>
# <class 'type'>

#the two method to make class:
###########1:
# class Foo:
#     pass
# print(Foo)

##########2:
def __init__(self,name,age):
    self.name = name
    self.age = age

def test(self):
    print('=====>')

FFo = type('FFo',(object,),{'x':1,'__init__':__init__,'test':test})   #type(name,father level,attribute)
print(FFo)
print(FFo.__dict__)
f1 = FFo('alex',19)
print(f1.x)
print(f1.test)
f1.test()

#####make own metaclass:

class MyType(type):
    def __init__(self,a,b,c):
        # print(a)
        # print(b)
        # print(c)

#:Foo
# ()
# {'__module__': '__main__', '__qualname__': 'Foo', '__init__': <function Foo.__init__ at 0x0000000001E0D0D0>}
        print('made metaclass')

    def __call__(self, *args, **kwargs):
        print('=======>')
        print(self)
        print(args,kwargs)
        obj = object.__new__(self)   #create a new object;object.__new__(Foo) >>f1
#the result:
# <class '__main__.Foo'>
# ('zxver',) {}
        self.__init__(obj,*args, **kwargs)   #Foo.__init__(f1,*args, **kwargs)
        return obj


class Foo(metaclass=MyType): #Mytype(self,'Foo',(object,),{}),four attributes
    def __init__(self,name):
        self.name = name  #obj,f1.name = name

# print(Foo)
f1 = Foo('zxver')
# print(f1.__dict__)
print(f1)
print(f1.__dict__)

6:Make classmethod:

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

    def __get__(self, instance, owner): #类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身,
        def feedback(*args,**kwargs):
            print('在这里可以加功能啊...')
            return self.func(owner,*args,**kwargs)
        return feedback

class People:
    name='linhaifeng'
    @ClassMethod # say_hi=ClassMethod(say_hi)
    def say_hi(cls,msg):
        print('你好啊,帅哥 %s %s' %(cls.name,msg))

People.say_hi('你是那偷心的贼')

p1=People()
p1.say_hi('你是那偷心的贼')