Python 装饰器和抽象类

#装饰器:对类或者函数进行功能的扩展
'''
#第一步:基本函数
def la():
    print('脚踏黄河两岸,手拿机密文件,前面机枪扫射,后面炮火连天')
 
#调用函数
la()
la()
 
#第二步:扩展函数功能(不能修改原函数)
#用于扩展基本函数的函数
def kuozhan(func):
    #扩展功能1
    print('la前参拜祈求')
    #调用基本函数
    func()
    #扩展功能2
    print('la后还愿感谢')
 
#基本函数
def la():
    print('脚踏黄河两岸,手拿机密文件,前面机枪扫射,后面炮火连天')
 
#扩展之后的函数要重新赋值给基本函数!(但是此步骤还实现不了)
la = kuozhan(la)
print(la)
 
#调用函数
#la()
#la()
 
#第三步:使用语法糖(就是语法)  @语法
 
#用于扩展基本函数的函数
def kuozhan(func):
    #扩展功能1
    print('la前参拜祈求')
    #调用基本函数
    func()
    #扩展功能2
    print('la后还愿感谢')
 
#基本函数
@kuozhan  #la = kuozhan(la)#扩展之后的函数要重新赋值给基本函数!(但是此步骤还实现不了)
def la():
    print('脚踏黄河两岸,手拿机密文件,前面机枪扫射,后面炮火连天')
 
print(la)
 
#调用函数
#la()
#la()
 
#第四步:基本装饰器的实现
 
#用于扩展基本函数的函数
def kuozhan(func):
    #内部函数(扩展之后的la函数)
    def newla():
        #扩展功能1
        print('la前参拜祈求')
        #调用基本函数
        func()
        #扩展功能2
        print('la后还愿感谢')
 
    #添加返回值
    return newla
 
#基本函数
@kuozhan  #la = kuozhan(la)#扩展之后的函数要重新赋值给基本函数!(但是此步骤还实现不了)
def la():
    print('脚踏黄河两岸,手拿机密文件,前面机枪扫射,后面炮火连天')
 
#print(la)
 
#调用函数
la()
la()
 
#第五步:带有参数的装饰器和带有返回值的装饰器
 
#用于扩展基本函数的函数
def kuozhan(func):
    #内部函数(扩展之后的la函数)
    def newla(shui,na):
        #扩展功能1
        print('la前参拜祈求')
        #调用基本函数
        func(shui,na)
        #扩展功能2
        print('la后还愿感谢')
 
    #添加返回值
    return newla
 
#基本函数
@kuozhan  #la = kuozhan(la)#扩展之后的函数要重新赋值给基本函数!(但是此步骤还实现不了)
 
def la(who,where):
    print(who,'在',where,'tuokuzi')
    print('脚踏黄河两岸,手拿机密文件,前面机枪扫射,后面炮火连天')
 
#print(la)
#调用函数
la('yangjun','羊圈')
la('yanfei','鸟巢')
 
#带有返回值的函数
#用于扩展基本函数的函数
def kuozhan(func):
    #内部函数(扩展之后的la函数)
    def newla():
        #扩展功能1
        print('la前参拜祈求')
        #调用基本函数
        result = func()
        #扩展功能2
        print('la后还愿感谢')
 
        #为newla添加返回值
        return result
 
    #添加返回值(装饰器用于返回未来的la函数的return)
    return newla
 
#基本函数
@kuozhan  #la = kuozhan(la)#扩展之后的函数要重新赋值给基本函数!(但是此步骤还实现不了)
def la():
    print('脚踏黄河两岸,手拿机密文件,前面机枪扫射,后面炮火连天')
    return '热翔'
 
#print(la)
 
#调用函数
result = la()
print('函数的返回值为:',result)
 
#第六步:带有收集参数的函数的装饰器
 
def kuozhan(func):
    #定义内部函数
    def newla(*w,**n):
        #扩展功能1
        print('la前参拜祈求')
        #调用基本函数
        func(*w,**n)
        #扩展功能2
        print('la后还愿感谢')
    #返回未来的la函数
    return newla
 
#基本函数
@kuozhan
def la(*who,**nums):
    print('参与la的人有',who)
    print('la了多少',nums)
    print('脚踏黄河两岸,手拿机密文件,前面机枪扫射,后面炮火连天')
 
#调用函数
la('xuyu','wangcheng','xiufeng','zhangbo',xy = '15斤',wc = '15吨',xf = '15克',zb = '15ml')
 
#第七步:带有参数的装饰器
 
#装饰器
def outer(arg):
    #这是装饰器代码
    def kuozhan(func):
        #print(func)
        #未来的la函数
        def newla():
            # 扩展功能1
            print('la前参拜祈求')
            # 调用基本函数
            func()
            # 扩展功能2
            print('la后还愿感谢')
 
        #未来的chifan函数
        def newchifan():
            #扩展功能1
            print('饭前洗洗手')
            #调用基本函数
            func()
            #扩展功能2:
            print('饭后抖一抖')
 
        #根据装饰的函数不同 返回不同的结果
        if arg == 'la':
            #返回的未来的la函数
            return newla
        elif arg == 'chi':
            return newchifan
 
    #返回装饰器
    return kuozhan
 
#基本函数1
@outer('la')#@装饰器函数
def la():
    print('脚踏黄河两岸,手拿机密文件,前面机枪扫射,后面炮火连天')
 
#基本函数2
@outer('chi')
def chifan():
    print('eat meat')
 
#调用基本函数
la()
chifan()
 
#第八步:使用类作为装饰器参数
#装饰器使用的操作类
class Wish:
    #祈求方法
    def before():
        print('la前参拜祈求')
 
    #还愿方法
    def after():
        print('la后还愿感谢')
 
def outer(cls):
    #装饰器函数
    def kuozhan(func):
        def newla():
            #扩展1(类中存在扩展内容)
            cls.before()
            #调用基本函数
            func()
            #扩展2(类中存在扩展内容)
            cls.after()
 
        return newla
    return kuozhan
 
#基本参数
@outer(Wish)#装饰器
def la():
    print('脚踏黄河两岸,手拿机密文件,前面机枪扫射,后面炮火连天')
#调用函数
la()
 
#第九步:使用类作为装饰器
class Kuozhan:
 
    #接受装饰器函数(函数outer)
    def __init__(self,arg):
        #此处可以将参数存入对象
        self.arg = arg
 
    #制作一个内部函数(真正的装饰器  函数kuozhan)
    def __call__(self,func):
        #print(func)
        #将func函数存入对象
        self.func = func
        #返回内部函数
        return self.newla
 
        #定义内部函数
    def newla(self):
        #扩展功能1
        print('la前参拜')
        #调用基本函数
        self.func()
        #扩展功能2
        print('la后还愿')
 
#基本函数
@Kuozhan('la') #la = 对象(la)
def la():
    print('脚踏黄河两岸,手拿机密文件,前面机枪扫射,后面炮火连天')
 
#调用函数
la()
 
#第十步:装饰器来装饰一个类
 
#装饰器函数
def kuozhan(cls):
    print(cls)
 
    #声明一个类(函数)
    def newHuman():
        #扩展类的功能1
        cls.cloth = '衣服'
        #扩展功能2
        cls.hat = '帽子'
        #调用类(实例化对象)
        obj = cls()
        #返回实例化的对象
        return obj
 
    return newHuman
 
#类 (被装饰的类)
@kuozhan #Human = kuozhan(Human)
class Human:#当作一个函数处理  Human()的返回值不是对象
    #属性
    sex = 'man'
    age = 18
 
    #方法
    def liaomei(self):
        print('妹子,这块砖头是你掉的吗')
 
    def tian(self):
        print('kubi')
 
#实例化对象
result = Human()
print(result)
print(result.cloth)
print(result.hat)
'''
 
#第十一步
 
#装饰器1
def kuozhan1(func):
    #定义装饰之后的函数
    def newla1():
        #扩展功能1
        print('1-----la前参拜')
        #调用基本函数
        func()
        #扩展功能2
        print('1-----la后还愿')
 
    return newla1
 
#装饰器2
def kuozhan2(func):
 
    #定义装饰之后的函数
    def newla2():
        #扩展功能1
        print('2-----la前tuokuzi')
        #调用基本函数
        func()
        #扩展功能2
        print('2-----la后capigu')
 
    return newla2
 
#基本函数
@kuozhan2
@kuozhan1
def la():
    print('脚踏黄河两岸,手拿机密文件,前面机枪扫射,后面炮火连天')
 
#调用函数
la()
 
#方法的分类
 
class Cat:
    #属性
    color = 'orange'
    age = 2
    sex = '公'
 
    #方法
    #非绑定类的方法/对象方法/实例方法
    def getFish(self):
        print(self)
        print('抓鱼方法')
 
    #绑定类的方法
    def say():
        print('喵喵~~~')
 
    #类方法
    @classmethod
    def run(cls):
        print(cls)
        print('猫跑不跑直线取决于耗子')
 
    #静态方法
    @staticmethod
    def jump():
        print('跳起来四脚朝地')
 
#实例化对象
mimi = Cat()
 
#对象方法
mimi.getFish()
 
#绑定类的方法
Cat.say()
 
#类方法
Cat.run()
 
#抽象类
#具有抽象方法的类就是抽象类
#抽象方法
#没有方法体的方法就是抽象方法
 
import abc
class Dog(metaclass = abc.ABCMeta):#指定类的元素 -> 制作类的方法
    #属性
    age = 10
    sex = '母'
    color = '黑色'
 
    #方法
    #对象抽象方法
    @abc.abstractmethod
    def swimming(self):
        pass
 
    #静态抽象方法
    @abc.abstractstaticmethod
    def eat():
        pass
 
    #类抽象方法
    @abc.abstractclassmethod
    def drink(cls):
        pass
 
    #绑定类的方法
    @abc.abstractmethod
    def run():
        pass
 
    #具体的有内容的方法
    def say(self):
        print('旺旺')
 
#实例化对象  会报错
#xiaohei = Dog()
 
#抽象类的使用
import abc
#conghao (boss)
class User(metaclass = abc.ABCMeta):
    #属性
    username = ''
    userid = 0
 
    #方法
 
    #添加用户(mengfei)
    @abc.abstractmethod
    def add(self,name,pwd):
        pass
 
    #删除用户(yujiao)
    @abc.abstractclassmethod
    def dele(cls,uid):
        pass
 
    #修改用户(shengyue)
    @abc.abstractstaticmethod
    def mod():
        pass
 
    #查找用户(conghao)
    def find(self):
        print('查找用户操作')
 
#文件2(mengfei)
class MFUser(User):
    #添加用户(mengfei)
    def add(self,name,pwd):
        print('添加用户操作')
 
#文件3(yujiao)
class YJUser(MFUser):
    #删除用户(yujiao)
    @classmethod
    def dele(cls,uid):
        print(uid)
        print('删除用户操作')
 
#文件4(shengyue)
class SYUser(YJUser):
    #修改用户(shengyue)
    @staticmethod
    def mod():
        print('修改用户操作')
 
#SYUser是真实的类不是抽象类
 
user = SYUser()
 
#添加操作
user.add('mengfei','mf')
 
#删除操作
SYUser.dele(250)
 
#修改操作
user.mod()
 
#查找操作
user.find()
 
#多态的实现
 
#1.设计抽象类  定义规则
import abc
 
class Animal(metaclass = abc.ABCMeta):
    #尿
    @abc.abstractmethod
    def niao(self):
        pass
 
    #拉
    @abc.abstractmethod
    def la(self):
        pass
 
    #叫
    @abc.abstractmethod
    def jiao(self):
        pass
 
#定义小狗类
class Dog(Animal):
    #尿
    def niao(self):
        print('抬起后腿尿')
 
    #拉
    def la(self):
        print('蹲着拉')
 
    #叫
    def jiao(self):
        print('汪汪叫')
 
#定义小猫类
class Cat(Animal):
    #尿
    def niao(self):
        print('蹲着尿')
 
    #拉
    def la(self):
        print('蹲着拉')
 
    #叫
    def jiao(self):
        print('喵喵叫')
 
#定义小鸡类
class Chick(Animal):
    #尿
    def niao(self):
        print('站着尿')
 
    #拉
    def la(self):
        print('站着拉')
 
    #叫
    def jiao(self):
        print('嗷嗷叫')
 
#动物行为类
class Action():
 
    #定义初始化方法
    def __init__(self,animal):
        #将动物存入对象成员
        self.animal = animal
 
    #尿
    def niao(self):
        self.animal.niao()
 
    #拉
    def la(self):
        self.animal.la()
 
    #叫
    def jiao(self):
        self.animal.jiao()
 
#实例化小狗
xiaohei = Dog()
 
#实例化小猫
miaomiao = Cat()
 
#实例化小鸡
huahua = Chick()
 
#实例化行为类对象
a = Action(xiaohei)
 
#调用行为对象的方法
a.niao()
a.jiao()
a.la()
 
#改变行为类对象中的动物
a.animal = miaomiao
#调用行为对象的方法
a.niao()
a.jiao()
a.la
 
#改变行为类对象中的动物
a.animal = huahua
#调用行为对象的方法
a.niao()
a.jiao()
a.la()