兄弟连学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()