装饰器和抽象类
装饰器就是对函数或者方法或者类进行修饰
'''
#第一步：创建一个普通函数
def laxi():
print('噗哧噗哧噗哧噗哧～～～')
#调用函数
laxi()
laxi()
'''
'''
#第二步：扩展函数的功能(不是装饰器)
#声明一个扩展函数
def decor(func):
print('求神拜佛，祝愿一切顺利')
func()#相当于调用laxi()
print('拉稀成功，烧香还愿')
def laxi():
print('噗哧噗哧噗哧噗哧～～～')
#将laxi函数传入decor函数中
laxi = decor(laxi)
#调用函数
laxi()
laxi()
'''
'''
#第三步：扩展函数的功能(不是装饰器)，使用语法糖
#声明一个扩展函数
def decor(func):
print('求神拜佛，祝愿一切顺利')
func()#相当于调用laxi()
print('拉稀成功，烧香还愿')
@decor #将laxi函数传入decor函数中#laxi = decor(laxi)
def laxi():
print('噗哧噗哧噗哧噗哧～～～')
#调用函数
laxi()
laxi()
'''
'''
#第四步：实现基本的装饰器
def decor(func):#函数名随便写
#声明内部函数来制作完整的装饰函数
def _decor():#函数名随便写
print('求神拜佛，祝愿一切顺利')
func()#相当于调用laxi()
print('拉稀成功，烧香还愿')
return _decor
@decor#laxi = decor(laxi)
def laxi():
print('噗哧噗哧噗哧噗哧～～～')
#调用函数
laxi()
laxi()
laxi()
laxi()
'''
'''
#第五步：实现带有参数和返回值的哦装饰器
#装饰器
def decor(func):
#这就是未来的拉稀函数
def _decor():
print('求神拜佛，祝愿一切顺利')
#调用拉稀函数时接收拉稀函数本身的返回值
result = func()#相当于调用laxi()
print('拉稀成功，烧香还愿')
#为装饰之后的函数返回一个值
return result
#返回内部函数作为未来的laxi函数
return _decor
@decor
#拉稀函数
def laxi():
print('噗哧噗哧噗哧噗哧～～～')
return '热翔一碗'
#调用拉稀函数
jg = laxi()
print(jg)
'''
'''
#装饰器
def decor(func):
#这就是未来的拉稀函数（原函数有什么形参，这里就要有什么形参）
def _decor(who,weight):
print('求神拜佛，祝愿一切顺利')
#调用拉稀函数时接收拉稀函数本身的返回值
result = func(who,weight)#相当于调用laxi()
print('拉稀成功，烧香还愿')
#为装饰之后的函数返回一个值
return result
#返回内部函数作为未来的laxi函数
return _decor
@decor
#拉稀函数
def laxi(who,weight):
print('噗哧噗哧噗哧噗哧～～～:'+who+'拉了'+weight+'斤便便')
return '热翔一碗'
jg = laxi('马俊龙','10')
print(jg)
'''
'''
#第六步：收集参数装饰器（给装饰器内部的函数加参数）
def decor(func):
#返回未来的拉稀函数
def _decor(*who,*weight):
print('求神拜佛，祝愿一切顺利')
result = func(*who,**weight)
print('拉稀成功，烧香还愿')
return result
#返回装饰之后的函数
return _decor
@decor
def laxi(*who,**weight):
print('噗哧噗哧噗哧噗哧～～～')
print('参与拉屎的人有:',who)
print('分别拉了多少:',weight)
return '热翔一大锅！'
#调用函数
jg = laxi('马俊龙','阎瑞龙','霍云瑞','曹睿','宋笑寒',mjl = '5斤',yrl = '2斤',hyr= '1吨',cr = '10克',sxh = '便秘')
print(jg)
'''
'''
#第七步：带有参数的装饰器（给装饰器加参数）
#定义装饰器（接收装饰器参数）
def decor(arg):
#接收函数的参数
def _decor(func):
#未来的拉稀和吃饭函数的装饰
def __decorla():#未来的拉稀函数
print('求神拜佛，祝愿一切顺利')
result = func()
print('拉稀成功，烧香还愿')
return result
def __decorchi():#未来的吃饭函数
print('我要开动了～')
result = func()
print('我吃完了～')
return result
#根据装饰器的参数返回不同的装饰结果
if arg == 'la':
return __decorla
elif arg == 'chi':
return __decorchi
#返回装饰器的第一层
return _decor
@decor('la')
def laxi():
print('噗哧噗哧噗哧噗哧～～～')
return '热翔一碗'
@decor('chi')
def chifan():
print('吧唧吧唧吧唧吧唧！～～～')
return '空碗一个'
#调用laxi
jg = laxi()
print(jg)
#调用chifan
jg = chifan()
print(jg)
'''
'''
#第八步：将类作为装饰器参数传入进来
#祝愿祈福类
class Wish:
#绑定类的方法
def before():
print('烧香拜服，祝愿一切顺利！')
#绑定类的方法
def after():
print('拉稀成功，烧香还愿～')
#装饰器
def decor(cls):
def _decor(func):
#这是未来的拉稀函数
def __decor():
cls.before()
result = func()
cls.after()
return result
#返回装饰之后的函数
return __decor
return _decor
@decor(Wish)
def laxi():
print('噗哧噗哧噗哧噗哧～～～')
return '热翔一手'
#调用函数
jg = laxi()
print(jg)
'''
'''
#第九步：将类作为装饰器使用
class Decor:
def __init__(self,arg):
#存入对象
self.arg = arg
#此魔术方法用于接收原函数
def __call__(self,func):
#将原方法存到对象当中
self.func = func
#返回装饰之后的函数
return self.mylaxi
#装饰函数
def mylaxi(self):
print('烧香拜服，祝愿一切顺利！')
#调用原函数
result = self.func()
print('拉稀成功，烧香还愿～')
return result
@Decor(5)
def laxi():
print('噗哧噗哧噗哧噗哧～～～')
return '热翔一手'
jg = laxi()
print(jg)
'''
'''
#第十步：为类添加装饰器（单例模式）
#声明一个容器用于存放对象
obj = {}#假设存入的对象键名only 值为对象本身 {'only':对象}
def decor(cls):
#装饰器的操作
def _decor():
if 'only' in obj:
#对象已经创建
return obj['only']
else:
#对象没有创建，创建对象并返回
obj['only'] = cls()
return obj['only']
#返回装饰的操作
return _decor
#当前类只能实例化一个对象
@decor
class LiXue:
name = '小雪'
sex = '女'
age = '21岁'
def stuPy():
print('好好学习天天向上！')
#实例化第一个对象
one = LiXue()
print(one)
two = LiXue()
print(two)
three = LiXue()
print(three)
'''
#第十一步：多个装饰器嵌套
#装饰器1
def decor1(func):
def _decor1():
print('脱裤子，准备放炮')
result = func()
print('拉屎完毕，提裤子走人～')
return result
return _decor1
#装饰器2
def decor2(func):
def _decor2():
print('烧香拜佛，祝愿一切顺利！')
result = func()
print('操作成功，烧香还愿')
return result
return _decor2
@decor2
@decor1
def laxi():
print('扑哧扑哧扑哧扑哧扑哧～～')
return '热翔一大杯'
jg = laxi()
print(jg)
类和对象的方法一共分为三种：
实例方法/对象方法
只有实例化对象之后才可以使用的方法，该方法的第一个形参接收的一定是对象本身！
绑定类的方法/静态方法
无需实例化，可以通过类直接调用的方法，方法中的参数既不接收对象名也不接受类。 一般方法可以独立调用，跟类中其他成员关联不大
类方法
无需实例化，可以通过类直接调用的方法
但是方法的第一个参数接收的一定是类本身，这种方法一般情况下需要借助类中其他成员操作
#包含各种方法的类
class Person:
#绑定类的方法，静态方法
@staticmethod #可以省略不写
def walk():
print('走路方法，绑定类的方法')
#非绑定类的方法 对象方法
def say(self):
print(self)
print('说话功能，非绑定类方法')
#类方法
@classmethod #必须写
def drink(cls):
print(cls)
print('喝水方法，类方法')
#调用非绑定类的方法(对象/实例方法)
tw = Person()
tw.say()
#绑定类的方法，静态方法
Person.walk()
#调用类方法
Person.drink()
具有抽象方法的类就是抽象类。
抽象方法就是没有完成的方法。只有方法名称和参数，没有方法内容的方法。
作用：适合于领导指定开发规范及多人协作完成类。
abc abstract class 抽象类的缩写
抽象类的语法
#使用抽象类必须使用abc模块
import abc
#书写抽象类必须指定抽象类的元类 固定格式
class Human(metaclass = abc.ABCMeta):
<span >#定义一个抽象的实例方法/非绑定类的方法</span>
@abc.abstractmethod
def smoking(self):
pass
<span >#定义一个抽象的类方法</span>
@abc.abstractclassmethod
def say(cls):
pass
<span >#定义一个抽象的静态方法/绑定类的方法</span>
@abc.abstractstaticmethod
def cry():
pass
抽象类的特征：
1.抽象类中可以包含具体的方法也可以包含抽象方法
2.抽象类中可以包含成员属性,而且属性没有抽象不抽象之分
3.抽象类无法实例化使用.
4.抽象类只能被其他类继承使用，（唯一的用法）
5.只有子类实现了抽象类的所有抽象方法之后，该子类才可以正常实例化使用。有一个抽象方法没有实现都不可以实例化
6.抽象类的作用是指定程序开发的标准（方法名，参数等）
多态，多种状态！就是一个类，根据不同的情况，相同的方法产生不同的结果。
