""" 装饰器: 为原函数去扩展新功能.用新函数去替换旧函数 作用: 在不改变原代码的前提下,实现功能上的扩展 符号: @(语法糖) """
一. 装饰器的基本用法
def kuozhan(func): def newfunc(): print('厕所前.蓬头垢面') func() print('厕所后,精神抖擞') return newfunc def func(): print('我是宋云杰') func = kuozhan(func) func()
二. @符号的使用
""" @符号作用: (1) 可以自动把@符号下面的函数当成参数传递给装饰器 (2) 把新函数返回,让新函数去替换旧函数,已实现功能上的扩展(基于原函数) """
def kuozhan(func): def newfunc(): print("厕所前,牛头马面") func() print("厕所后,黑白无常") return newfunc @kuozhan def func(): print("我是高雪峰") func()
三.装饰器的嵌套
def kuozhan1(func):
def newfunc():
print("厕所前,人模狗样1")
func()
print("厕所后,斯文败类2")
return newfunc
def kuozhan2(func):
def newfunc():
print("厕所前,洗洗手3")
func()
print("厕所后,簌簌口4")
return newfunc
@kuozhan2
@kuozhan1
def func():
print("我是葛龙0")
func()
四.用装饰器扩展带有参数的原函数
def kuozhan(func): def newfunc(who,where): print('厕所前,未弥补站') func(who,where) print('厕所后,兽性大发') return newfunc @kuozhan def func(who,where) print('{}在{}接手'.format(who,where)) func('孙志和','鸟窝')
五.用装饰器扩展带有参数和返回值的原函数
def kuozhan(func): def newfunc(*args,**kwargs): print("厕所前,饥肠辘辘") res = func(*args,**kwargs) print("厕所后,酒足饭饱") return res return newfunc @kuozhan def func(*args,**kwargs): lst = [] dic = {"gaoxuefeng":"高雪峰","sunzhihe":"孙致和","gelong":"戈隆"} # 解手的地点遍历出来 for i in args: print("拉屎的地点:",i) for k,v in kwargs.items(): if k in dic: strvar = dic[k] + "留下了" + v + "黄金" lst.append(strvar) return lst lst = func("电影院","水下",gaoxuefeng = "15g",sunzhihe = "15顿",gelong="15斤") print(lst)
六 用类装饰器来扩展原函数
class Kuozhan(): def __call__(self,func): return self.kuozhan2(func) def kuozhan1(func): def newfunc(): print("厕所前,老实巴交") func() print("厕所后,咋咋乎乎") return newfunc def kuozhan2(self,func): def newfunc(): print("厕所前,唯唯诺诺") func() print("厕所后,重拳出击") return newfunc # 方法一 """""" @Kuozhan.kuozhan1 def func(): print("厕所进行中....") # func() # 方法二 @Kuozhan() # @obj => obj(func) def func(): print("厕所进行中....") func() """ print("<======分割线1=======>") Kuozhan() #=> obj def func(): print("厕所进行中....") @符发动第一次发动技能: func 当成参数传递给obj => obj(func) 这种形式把对象当成函数使用 -> 直接触发__call__魔术方法 调用结束之后. @符发动第二次发动技能: 将返回的新函数 赋值给 旧函数,形成替换的效果 func = newfunc func() <=> newfunc() """ """ print("<======分割线2=======>") <==相当于==> def func(): print("厕所进行中....") obj = Kuozhan() func = obj(func) func() """
七、带有参数的函数装饰器
def outer(num): def kuozhan(func): def newfunc1(self): print("厕所前,干净整齐") func(self) print("厕所后,一片狼藉") def newfunc2(self): print("厕所前,大腹便便") func(self) print("厕所后,满口雌黄") if num == 1: return newfunc1 elif num == 2: return newfunc2 elif num == 3: # 把func3方法变成属性 return "我是女性" return kuozhan class MyClass(): @outer(1) # => (1) kuozhan(func1) => newfunc1 (2) 发动技能做替换 func1 = newfunc1 def func1(self): print("向前一小步,文明一大步") @outer(2) # => (2) kuozhan(func2) => newfunc2 (2) 发动技能做替换 func2 = newfunc2 def func2(self): print("来也冲冲,去也冲冲") @outer(3) # => (3) kuozhan(func3) => "我是女性" (2) 发动技能做替换 func3 = "我是女性" def func3(self): print("尿道外面,说明你短") obj = MyClass() print("<================>") obj.func1() # <=> newfunc1 print("<================>") obj.func2() print("<================>") # obj.func3() error print(obj.func3) print(MyClass.func3)
""" 套上outer这层函数就是为了保留1 2 3 三个参数,可以在闭包函数中使用 调用outer 结束之后,才是返回正常的装饰器kuozhan 此刻,@符第一次发动技能, 把func1当成参数传递给kuozhan , 返回newfunc1 然后,@符第二次发动技能, 将返回的newfunc1替换原来func1 obj.func1() => newfunc1(obj) if num == 1 返回闭包函数newfunc1 if num == 2 返回闭包函数newfunc2 来做替换 obj.func3 在执行时,装饰器已经把func3变成了属性func3 = "我是女性" 所以obj.func3 或者 MyClass.func3 都是"我是女性" 字符串. obj.func3 => return "我是女性" MyClass.func3 => return "我是女性" """
八、带有参数的类装饰器
class Kuozhan(): money = "贵族厕所,每小时1000元,贵族厕所欢迎您来,欢迎您再来" def __init__(self,num): self.num = num def __call__(self,cls): if self.num == 1: return self.newfunc1(cls) elif self.num == 2: return self.newfunc2(cls) def ad(self): print("贵族茅厕,茅厕中的百岁山") def newfunc1(self,cls): def newfunc(): # 为当前cls这个类,添加属性 cls.money = Kuozhan.money # 为当前cls这个类,添加方法 cls.ad = Kuozhan.ad return cls() return newfunc def newfunc2(self,cls): def newfunc(): # 判断run成员是否在类当中 if "run" in cls.__dict__: # 调用类中的方法,得到对应的返回值 res = cls.run() # 把返回值重新赋值到run属性上 cls.run = res# cls.run = "亢龙有悔" return cls() return newfunc
参数:
""" 参数为2,代码解析: @Kuozhan(2) => @obj => @符第一次发动技能: 把MyClass当成参数传递给obj => obj(MyClass) => return self.newfunc2(cls) => return newfunc @obj => @符第二次发动技能: 实现替换效果,将 MyClass = newfunc obj = MyClass() = newfunc() = cls() = 对象 对象.run = "亢龙有悔" """
九、面向对象当中的方法
""" 普通方法: 有参或者无参,如果是无参,只能类来调用 绑定方法: (1) 绑定到对象(自动传递对象参数) (2) 绑定到类(自动传递类参数) 静态方法: 无论是对象还是类,都可以调用此方法.而不会默认传递任何参数 """
class Cat(): name = "tom" # 普通方法 def mai_meng(): print("小猫会卖萌") # 绑定方法(对象) def attack(self): print("小猫会卅(sua)人") # 绑定方法(类) @classmethod def youmi(cls): print(cls) print("可以放大招,伤害最高") # 静态方法 @staticmethod def jump(a,b,c,d,e): print("小猫会上树,抓老鼠") 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()
十、property
""" property 可以把方法变成属性使用 作用: 控制属性的获取,修改,删除等操作 变向的增加成员的安全性,可以通过自定义的逻辑进行控制 自动触发: 要去名字相同.同一个名字 获取@property 设置@属性名.setter 删除@属性名.deleter """
1、写法一
class MyClass(): def __init__(self,name): self.name = name @property def username(self): # return self.name pass # 不获取 @username.setter def username(self,val): # 在触发时:val = 朴飘乐 self就是本对象 # self.name = val pass # 不设置 @username.deleter def username(self): # print("删除方法被触发...") # del self.name pass # 不删 obj = MyClass("朴一生") # 获取属性 print(obj.username) # 设置属性 obj.username = "朴飘乐" # 获取属性 print(obj.username) # 删除属性 del obj.username # 获取属性 print(obj.username)
2、写法二
class MyClass(): def __init__(self,name): self.name = name # 获取方法 def get_username(self): return self.name # pass # 不获取 # 设置方法 def set_username(self,val): self.name = val # pass # 不获取 # 删除方法 def 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方法 # 获取操作 print(obj.username) # 删除操作 del obj.username # 自动触发del_username方法 # 获取操作 print(obj.username)