8.10_python_lx_day26

一.装饰器

• 装饰器 : 为原函数去扩展新功能,用新函数去替换旧函数
• 作用 : 在不改变原代码的前提下,实现功能上的扩展
• 符号 : @(语法糖)

(1)装饰器的基本语法

def kuozhan(func):
    def newfunc():
        print('01234')
        func()
        print('56789')
    return newfunc
def func():
    print('!@#$%')
func = kuozhan(func) # func = newfunc
func()

(2)@符号的使用

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

def kuozhan(func):
    def newfunc():
        print('01234')
        func()
        print('56789')
    return newfunc

@kuozhan
def func():
    print('!@#$%')
func()

(3)装饰器的嵌套

def kuozhan1(func):
    def newfunc():
        print(1)
        func()
        print(2)
    return newfunc

def kuozhan2(func):
    def newfunc():
        print(3)
        func()
        print(4)
    return newfunc

@kuozhan1
@kuozhan2
def func():
    print(0)
func()

(4)用装饰器扩展带有参数的原函数

def kuozhan(func):
    def newfunc(a,b):
        print('警察来了')
        func(a,b)
        print('带走了{}'.format(a))
    return newfunc

@kuozhan
def func(a,b):
    print('{}打死了了{}'.format(a,b))
func('男一','女一')

(5)用装饰器扩展代用参数和返回值的原函数

def kuozhan(func):
    def newfunc(*args,**kwargs):
        print('01234')
        res = func(*args,**kwargs)
        print('56789')
        return res
    return newfunc

@kuozhan
def func(*args,**kwargs):
    lst = []
    dic = {'a':'A','b':'B','c':'C'}
    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('lzh傻逼','傻逼lzh',a = '11',b='22',c='33')
print(lst)

(6)用类装饰器来拓展原函数

class Kuozhan():
    def __call__(self,func):
        return self.kuozhan2(func)
    
    def kuozhan1(func):
        def newfunc():
            print('01234')
            func()
            print('56789')
        return newfunc
    
    def kuozhan2(self,func):
        def newfunc():
            print('98765')
            func()
            print('43210')
        return newfunc

<1>方法一

@Kuozhan.kuozhan1
def func():
    print('!@$@!')
func()

<2>方法二

@Kuozhan()
def func():
    print('!@$@!')
func()

(7)带有参数的函数装饰器

def outer(num):
    def kuozhan(func):
        def newfunc1(self):
            print("我是newfunc1")
            func(self)
            print("我是newfunc1")
        def newfunc2(self):
            print("我是newfunc2")
            func(self)
            print("我是newfunc2")            
        if num == 1:
            return newfunc1
        elif num ==2:
            return newfunc2
        elif num ==3:
            return '我是一个属性'                    
    return kuozhan    

class MyClass():    
    @outer(1)
    def func1(self):
        print('1111111111')

    @outer(2)
    def func2(self):
        print('2222222222')

    @outer(3)
    def func3(self):
        print('3333333333')

obj = MyClass()
obj.func1()
MyClass.func1(obj)
obj.func2()
MyClass.func2(obj)
print(obj.func3)
print(MyClass.func3)

(8)带有参数的类装饰器

• 如果参数是1,就为当前类添加成员属性和方法
• 如果参数是2,就把原方法run变成属性

class Kuozhan():
    money = '111111'    
    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.money = Kuozhan.money
            cls.ad = Kuozhan.ad
            return cls()
        return newfunc

    def newfunc2(self,cls):
        def newfunc():
            if 'run' in cls.__dict__:
                res = cls.run()
                cls.run = res
                return cls()
        return newfunc

<1>参数1

@Kuozhan(1)
class MyClass():
    def run():
        return '亢龙有悔'
obj = MyClass()
print(obj.money)
obj.ad()

<2>参数2

@Kuozhan(2)
class MyClass():
    def run():
        return "亢龙有悔"

obj = MyClass()
print(obj.run)

二.面向对象中的方法

• 普通方法: 有参或者无参,如果无参,只能类来调用
• 绑定方法: (1)绑定到对象(自动传递对象参数)(2)绑定到类(自动传递类参数)
• 静态方法: 无论是对象还是类,都可以调用此方法,而不会默认传递任何参数;

class Cat():
    name = 'tom'

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

(1)普通方法(无参方法只能类调用)

obj = Cat()
Cat.mai_meng()

(2)绑定方法(对象)

obj = Cat()
obj.attack()
Cat.attack(obj)

(3)绑定方法(类)

• 对象和类都可以调用绑定到类的方法 推荐使用类来调用

obj = Cat()
Cat.youmi()
obj.youmi()

(4)静态方法

obj.jump(1,2,3,4,5)
Cat.jump(1,2,3,4,5)

三.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)