兄弟连学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()
时间： 2024-10-07 12:03:30

兄弟连学Python 装饰器和抽象类的相关文章

【转】九步学习python装饰器

本篇日志来自:http://www.cnblogs.com/rhcad/archive/2011/12/21/2295507.html 纯转,只字未改.只是为了学习一下装饰器.其实现在也是没有太看明白,对于装饰器我就是用的时候找例子,能蒙对,但是用过之后一段时间就忘了.还是用的少.有空应该好好看一看的,包括闭包.对于各种现代编程语言来说闭包都是很重要的.在这里先谢过原作者,如有侵权请告知. =-=-=-=-=-=-=-=-=-=-一条不怎么华丽的分隔线-=-=-=-=-=-=-=-=-=-= 这

深入浅出 Python 装饰器：16 步轻松搞定 Python 装饰器

Python的装饰器的英文名叫Decorator,当你看到这个英文名的时候,你可能会把其跟Design Pattern里的Decorator搞混了,其实这是完全不同的两个东西.虽然好像,他们要干的事都很相似--都是想要对一个已有的模块做一些"修饰工作",所谓修饰工作就是想给现有的模块加上一些小装饰(一些小功能,这些小功能可能好多模块都会用到),但又不让这个小装饰(小功能)侵入到原有的模块中的代码里去.但是OO的Decorator简直就是一场恶梦,不信你就去看看wikipedia上的词条

Python装饰器的学习笔记(转载)

Python装饰器的学习笔记 2017-05-18 程序员共读 来自:标点符的<Python装饰器的学习笔记> 链接:http://www.biaodianfu.com/python-decorator.html 原文:http://stackoverflow.com/questions/739654/how-to-make-a-chain-of-function-decorators-in-python#answer-1594484 装饰器(decorator)是一种高级Python语法.可

Python装饰器学习

Python装饰器学习(九步入门) 这是在Python学习小组上介绍的内容,现学现卖.多练习是好的学习方式. 第一步:最简单的函数,准备附加额外功能 ? 1 2 3 4 5 6 7 8 # -*- coding:gbk -*- '''示例1: 最简单的函数,表示调用了两次''' def myfunc():     print("myfunc() called.") myfunc() myfunc() 第二步:使用装饰函数在函数执行前和执行后分别附加额外功能 ? 1 2 3 4 5 6

利用世界杯，读懂 Python 装饰器

Python 装饰器是在面试过程高频被问到的问题,装饰器也是一个非常好用的特性, 熟练掌握装饰器会让你的编程思路更加宽广,程序也更加 pythonic. 今天就结合最近的世界杯带大家理解下装饰器. 德国战车 6 月 17 日德国战墨西哥,小痴虽然是一个伪球迷,但每年的世界杯还是会了解下.而德国是上届的冠军,又是这届夺冠热门.德意志战车在 32 年间小组赛就没有输过!卧槽!虽然小痴很少赌球,但这次德国如此强大,肯定会赢吧.搏一搏单车变摩托!随后小痴买了德国队赢.心里想着这次肯定稳了!赢了会所嫩模!

Python装饰器详解，详细介绍它的应用场景

装饰器的应用场景 附加功能 数据的清理或添加: 函数参数类型验证 @require_ints 类似请求前拦截 数据格式转换 将函数返回字典改为 JSON/YAML 类似响应后篡改 为函数提供额外的数据 mock.patch 函数注册 在任务中心注册一个任务 注册一个带信号处理器的函数 不同应用场景下装饰器实现 函数注册表 简单注册表 funcs = [] def register(func): funcs.append(func) return func @register def a(): r

5.初识python装饰器 高阶函数＋闭包＋函数嵌套＝装饰器

一.什么是装饰器? 实际上装饰器就是个函数,这个函数可以为其他函数提供附加的功能. 装饰器在给其他函数添加功能时,不会修改原函数的源代码,不会修改原函数的调用方式. 高阶函数+函数嵌套+闭包 ＝ 装饰器 1.1什么是高阶函数? 1.1.1函数接收的参数,包涵一个函数名. 1.1.2 函数的返回值是一个函数名. 其实这两个条件都很好满足,下面就是一个高阶函数的例子. def test1(): print "hamasaki ayumi" def test2(func): return t

python装饰器通俗易懂的解释！

python装饰器 刚刚接触python的装饰器,简直懵逼了,直接不懂什么意思啊有木有,自己都忘了走了多少遍Debug,查了多少遍资料,猜有点点开始明白了.总结了一下解释得比较好的,通俗易懂的来说明一下: 小P闲来无事,随便翻看自己以前写的一些函数,忽然对一个最最最基础的函数起了兴趣: 1 def sum1(): 2 sum = 1 + 2 3 print(sum) 4 sum1() 此时小P想看看这个函数执行用了多长时间,所以写了几句代码插进去了: 1 import time 2 3 def

python装饰器1

第八步:让装饰器带 类 参数 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 # -*- coding:gbk -*- '''示例8: 装饰器带类参数''' class locker:     def __init__(self):         print("locker.__init__() should be not called.")