# 1.装饰器的基本用法
'''装饰器是基于闭包函数来实现的'''
def kuozhan(func):
     newfunc():
        print("厕所前,蓬头垢面")
        func()
        厕所后,精神抖擞)
    return newfunc


 func():
    我是宋云杰)

kuozhan()的返回值是newfunc,newfunc替换了func'''
func = kuozhan(func)  func = newfunc 
所以调用func就是相当于在调用newfunc
func()  newfunc() 

 2.@符号的使用
"""
@符号作用:
    (1) 可以自动把@符号下面的函数当成参数传递给装饰器
    (2) 把新函数返回,让新函数去替换旧函数,以实现功能上的扩展(基于原函数)
"""

 newfunc

1.把func当做参数传递给装饰器kuozhan'''
2.将新函数newfunc返回替换旧函数func,进而实现功能的扩展
@kuozhan
我是高雪峰)
func()

 3.装饰器的嵌套
 kuozhan1(func):
     newfunc():    
         newfunc
    
 kuozhan2(func):
     newfunc
    
@kuozhan2
@kuozhan1
我是葛龙0)

func()

 4.用装饰器扩展带有参数的原函数
 newfunc(who,where):
        )
        func(who,where)
        )
        
     newfunc

@kuozhan
 func(who,where):
    {}在{}解手.format(who,where))

func(孙致和",鸟窝")  func = newfunc => func("孙致和","鸟窝") <=> newfunc("孙致和","鸟窝")

 5.用装饰器扩展带有参数和返回值的原函数
def newfunc(*args,**kwargs):
        )
        res = func(*args,1)">kwargs)
        )
         res
     newfunc
        
@kuozhan
def func(*args,1)">kwargs):
    lst = []
    dic = {gaoxuefeng":高雪峰sunzhihegelong戈隆}
    
     解手的地点遍历出来
    for i in args:
        拉屎的地点:,i)
    for k,v  kwargs.items():
        if k  dic:
            strvar = dic[k] + 留下了" + v + 黄金
            lst.append(strvar)
     lst

lst = func(电影院水下15g15顿15斤)
print(lst)

 6.用类装饰器来拓展原函数
class Kuozhan():
    def __call__(self,func):        
         self.kuozhan2(func)
    
     kuozhan1(func):
         newfunc():
            )
            func()
             newfunc

     kuozhan2(self,func):
         newfunc

 方法一
""""""
@Kuozhan.kuozhan1
厕所进行中....)

func()

 方法二

@Kuozhan()   @obj => obj(func)
)

func()

 7.带有参数的函数装饰器
 outer(num):
     kuozhan(func):    
         newfunc1(self):
            )
            func(self)
            )
        
         newfunc2(self):
            )
            
        if num == 1:
             newfunc1
        elif num == 2 newfunc2
        elif num == 3 把func3方法变成属性
            return 我是女性"

     kuozhan

 MyClass():
    
    @outer(1)  => (1) kuozhan(func1) => newfunc1   (2) 发动技能做替换  func1 = newfunc1 
     func1(self):
        向前一小步,文明一大步)
    
    @outer(2)  => (2) kuozhan(func2) => newfunc2   (2) 发动技能做替换  func2 = newfunc2 
     func2(self):
        来也冲冲,去也冲冲)
    
    @outer(3)  => (3) kuozhan(func3) => "我是女性" (2) 发动技能做替换  func3 = "我是女性" 
     func3(self):
        hahaha,lalala)

obj = MyClass()

obj.func1()  <=> newfunc1
obj.func2()
 obj.func3() error
print(obj.func3)
print(MyClass.func3)

 8.带有参数的类装饰器

如果参数是1,就为当前类添加成员属性和方法
如果参数是2,就把原方法run变成属性
"""
 Kuozhan():
    money = 贵族厕所,每小时1000元,贵族厕所欢迎您来,欢迎您再来"
    
    __init__ num
    
    if self.num == 1 self.newfunc1(cls)
            
        elif self.num == 2 self.newfunc2(cls)
    
     ad(self):
        贵族茅厕,茅厕中的百岁山)
    
     newfunc1(self,1)"> 为当前cls这个类,添加属性
            cls.money = Kuozhan.money
            添加方法
            cls.ad = Kuozhan.ad
             cls()
         newfunc
    
     newfunc2(self,1)">if run" in cls.__dict__:
                 调用类中的方法,得到对应的返回值
                res = cls.run()
                 把返回值重新赋值到run属性上
                cls.run = res cls.run = "亢龙有悔"
                
                return newfunc

 参数1
@Kuozhan(1) 
 MyClass():
     run():
        亢龙有悔
obj = MyClass()
(obj.money)
obj.ad()

 参数2
@Kuozhan(2

obj =print(obj.run)

 Ceshi():
    ad = 10 Ceshi()
print(obj.ad)  10

 func(cls):
    cls.money = 100
     cls()
    
 把类当成参数传递到函数当中,在局部空间中,形成独立的副本
obj = func(Ceshi)
 把类变量Ceshi 变成字符串
Ceshi = abcde"
 发现局部空间中类对象中的成员,并没有受到影响
print(obj.money)  100

 Cat():
    name = tom 普通方法
     mai_meng():
        小猫会卖萌 绑定方法(对象)
     attack(self):
        小猫会卅(sua)人 绑定方法(类)
    @classmethod
     youmi(cls):
        (cls)
        可以放大招,伤害最高 静态方法
    @staticmethod
     jump(a,b,c,d,e):
        小猫会上树,抓老鼠)


obj = Cat()
 普通方法 (无参方法只能类调用)
Cat.mai_meng()
 obj.mai_meng() error

 绑定方法(对象)
obj.attack()
Cat.attack(obj)

 绑定方法(类)
对象和类都可以调用绑定到类的方法 推荐使用类来调用"""
Cat.youmi()
obj.youmi()
 print(obj.__class__)

obj.jump()
Cat.jump()

 写法一
 MyClass():

     name    
    
    @property
     username(self):
         self.name
         pass # 不获取
        
    @username.setter
     username(self,val):
         在触发时:val =  朴飘乐  self就是本对象
        self.name = val
         pass # 不设置
        
    @username.deleter
     print("删除方法被触发...")
        del pass # 不删
        

obj = MyClass(朴一生 获取属性
(obj.username)
 设置属性
obj.username = 朴飘乐 删除属性
del obj.username

 写法二
 name    

     获取方法
     get_username(self):
         pass # 不获取

     设置方法
     set_username(self,val):
        self.name = pass # 不获取
        
     删除方法
     del_username(self):
         del self.name
        pass

     property(获取方法,设置方法,删除方法)
    username = property(get_username,set_username,del_username)  这三个顺序不可以调换

obj = MyClass(朴仁猛 获取操作
print(obj.username)   自动触发get_username方法
# 设置操作
obj.username = pdd 自动触发set_username方法 删除操作 
del obj.username      自动触发del_username方法