#装饰器:对类或者函数进行功能的扩展
'''
#第一步:基本函数
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()
