反射，装饰器，类当中的方法，property---day24

1.反射

# ### 反射(针对于类对象 模块)
'''概念：通过字符串去操作类对象或者模块当中的成员(属性方法)'''

class Man():
    pass

class Woman():
    pass

class Children(Man,Woman):
    '''
    成员属性：eye
    成员方法：skylight moonread __makebaby
    完成的功能：描述小孩天生神力
    '''
    eye = "血轮眼"

    def skylight(self):
        print("一下生,直接使用天照,让世界变得混乱")

    def moonread(self,func):
        print("一下生,使出了武功绝学,月度,世界都黑暗了")
        print(func.__name__,type(func.__name__))

    def __makebaby(self):
        print("这一手招数,只能我自己用")
obj = Children()

#(1) 反射类对象中的成员
# hasattr() 检测对象/类是否有指定的成员
#对象
res = hasattr(obj,"eye")
print(res) #True

#类
res = hasattr(Children,"skylight") #True
res = hasattr(Children,"__makebaby") #False
print(res)

# getattr() 获取对象/类成员的值
#对象
func = getattr(obj,"skylight")
func = getattr(obj,"__makebaby") #报错
func() # =>skylight() 通过对象反射出来的方法是绑定方法

#类
func = getattr(Children,"skylight")
func(1) #通过类反射出来的是一个普通方法

#当类对象中的成员不存在时,可以设置默认值(第三个参数是默认参数)
func = getattr(obj,"moonread123","对不起,该成员不存在")
print(func)

#综合案例
'''
strvar = input("请输入你要调用的方法")
if hasattr(obj,strvar): #判断obj对象是否有这个属性
    func = getattr(obj,strvar) #获取对象的这个属性
    func()
'''

#setattr() 设置对象/类成员的值
#对象
setattr(obj,"eye","白眼")
print(obj.eye)
#类
setattr(Children,"tcut",lambda : print("小孩一下生就能使用雷切"))
Children.tcut()
#obj.tcut() #tcut是一个无参普通方法,只能类调用

#delattr() 删除对象/类成员的值

#对象
delattr(obj,"eye")
print(obj.eye)

#类
delattr(Children,'eye')
print(Children.eye)

#(2)反射模块中的成员
'''sys.modules返回一个系统的字典,加载系统模块展现出来'''
import sys
print(sys.modules)

#获取本模块的对象
print(sys.modules["__main__"])
selfmodule = sys.modules["__main__"]

def func1():
    print("我是func1方法")

def func2():
    print("我是func2方法")

def func3():
    print("我是func3方法")

#综合案例
while True:
    strvar = input("请输入你要反射的方法")
    if hasattr(selfmodule,strvar)
        func = getattr(selfmodule,strvar)
        func()
    elif strvar.upper() == "Q":
        break
    else:
        print("没有这个方法")

2.装饰器

# ### 装饰器
'''
装饰器：为原函数扩展新功能，用新功能去替代旧功能
作用：在不改变原有代码的基础上，实现功能上的扩展
符号：@(语法糖)
'''

# 1.装饰器的基本使用
def outer(f):# f = func
    def inner():
        print("测试前")
        f()
        print("测试后")
    return inner
def func():
    print("我叫高富帅")

func = outer(func)
func() #func() = inner()

#2. @符号的使用
'''
@符号使用：
    (1)可以自动把@符号下面的函数当成参数传递给装饰器
    (2)把新函数进行返回，让新函数去替换旧函数，以实现功能的扩展
    # func = inner <==> func() = inner()
'''
def outer(f): #f = func
    def inner():
        print("测试前")
        f() #真正执行函数的调用  =func
        print("测试后")
    return inner
@outer  #先调用outer，并把下面函数名传给参数f，即func = outer(func)
def func(): #被调用的真正函数
    print("我叫高富帅")

func() #func() = inner()

#3.装饰器的嵌套
def outer1(f):
    def inner():
        print("测试前1")
        f()
        print("测试后2")
    return inner

def outer2(f):
    def inner():
        print("测试前3")
        f()
        print("测试后4")
    return inner
@outer2   #3 1 5 2 4
@outer1 #调用outer1并把func传给f  1 5 2
def func():
    print("我是白富美5")
func() #31524
'''
解析
1.调用outer1并把func传给f，返回inner，执行func()想当于执行inner()
outer1的打印顺序为 1 5 2
2.然后再调用outer2把func传给f，返回inner，执行func()想当于执行inner()
outer2的打印顺序为3 1 5 2 4
'''

#4.用装饰器修饰带有参数的函数
'''拓展的新功能和原函数的功能，在参数和返回值上，要保持一致性'''
def outer(f):
    def inner(who,where):
        print("测试前")
        f(who,where)
        print("测试后")
    return inner
@outer  # func = outer(func)
def func(who,where):
    print("{who}在{where}吃饭".format(who=who,where=where))

func("小白","餐厅")

#5.用装饰器修饰带有参数返回值的函数
def outer(f):
    def inner(*args,**kwargs):  # 函数的定义处, *号的打包操作
        print("测试前")
        res = f(*args,**kwargs) # 函数的调用处,*号解包操作
        print("测试后")
        return res
    return inner

@outer  #func = outer(func)
def func(*args,**kwargs):
    dic = {"wz":"王振","xb":"小白","ww":"伟伟"}
    lst = []
    strvar = ""

    #遍历玩耍的地点
    for i in args:
        print("玩耍的地点",i)
    #print(args)
    #print(kwargs)
    '''
    正常写法
    for k,v in kwargs.items():
        if k in dic:
            strvar = dic[k] + "留下" + v + "黄金"
            lst.append(strvar)
    return lst
    '''
    #推导式
    return [dic[k] + "留下" + v + "黄金" for k,v in kwargs.items() if k in dic]
    #谁留下多少黄金
res = func("电影院",'水里',wz="18斤",xb="18吨",ww="18克",zzz = "19k")
print(res)

#6. 用装饰器来拓展原函数
class outer():
    def __call__(self,func):  #第二步  #触发call方法，把func传给func
        return self.outer1(func) #第三步  #调用outer1并把func传给func

    def outer1(self,func):   #第四步
        def inner():  #第七步  #执行第六步相当于执行这一步func()=inner()
            print("测试前1") #第八步 打印
            func()  #第九步 #真正函数调用打印测试进行时
            print("测试后2") #第十二步
        return inner  #第五步 #func = inner  

    def outer2(func):
        def inner():
            print("测试前3")
            func() #真正函数调用打印测试进行时
            print("测试后4")
        return inner
#方法一
'''
@outer.outer2   outer(func).outer2
def func():
    print("测试进行时...")
func()
'''

#方法二
'''
@outer() => @obj<=>对象 => obj(func) <=>把对象当成函数进行使用了,自动触发__call__魔术方法
把新函数inner返回了 => @发动第二个既能，将新函数去替换旧函数，func = inner
func() = inner()

def func():
    print("测试进行时...")
func()
'''
@outer() #第一步 #outer() = > obj对象，然后@obj => func = obj(func),把obj对象当做函数调用会自动触发call方法
def func():  #第十步  执行第九步 就相当于执行真正的函数调用
    print("测试进行时") #第十一步
func()  #第六步 func() = inner()

#7. 带有参数的函数装饰器
def outer(num):
    def kuozhan(func): #第二步 #func = func1
        def inner1(self): #第五步 调用func1相当于调inner1
            print("测试前1")#第六步
            res = func(self)  #第七步
            print("测试后2") #第十步
            return res

        def inner2(self):
            print("测试前3")
            res = func(self)
            print("测试后4")
            return res

        if num == 1:
            return inner1  #第三步  #func1 = inner1
        elif num == 2:
            return inner2
        elif num == 3:
            #把方法变成属性
            return "我是男性"
    return kuozhan

class MyClass():
    @outer(1)#第一步 outer(1)=>返回kuozhan，@kuozhan=> func1=kuozhan(func1)[@符号第一次发动技能] <=> func2 = newfunc2 [@符号第二次发动技能]
    def func1(self): #第八步，第七步执行的真正函数是这个
        print("试一试") #第九步

    @outer(2)#outer(2)=>返回kuozhan ,@kuozhan <==> func2=kuozhan(func2) [@符号第一次发动技能] <=> func2 = newfunc2 [@符号第二次发动技能]
    def func2(self):
        print("拼一拼")

    @outer(3)
    def func3():# outer(3)=>kuozhan , @kuozhan <=> func3=kuozhan(func3) [@符号第一次发动技能] <=> func3 = "我是男性"
        print("搏一搏")
obj = MyClass()
obj.func1() #第四步
obj.func2() #func2() <==> newfunc2()
#把方法变成属性
print(obj.func3) #func3=kuozhan(func3) => func3 = "我是男性"

#8.带有参数的类装饰器
'''
如果参数是1，就为当前类添加成员属性和方法
如果参数是2，就把原方法run变成属性
'''
class outer():
    ad = "贵族茅房,每小时100元,贵族茅房,欢迎您来,欢迎您再来"
    def __init__(self,num):
        self.num = num

    def __call__(self,cls): #第二步  把MyClass传入 cls接收
        if self.num == 1:
            return self.inner1(cls)  #第三步 执行inner1函数
        elif self.num == 2:
            return self.inner2(cls)

    def money(self):
        print("茅中贵族,百岁山")

    #参数为1的情况
    def inner1(self,cls):  #第四步 cls接收MyClass
        def inner():  #第七步
            #为当前cls这个类,添加属性(为MyClass)
            cls.ad = outer.ad  #第八步
            #为当前cls这个类，添加方法(为MyClass)
            cls.money = outer.money  #第九步
            return cls() #第十步 #对象obj = cls()
        return inner  # 第五步 返回 MyClass = inner

    #参数为2的情况
    def inner2(self,cls):
        def inner():
            if "run" in cls.__dict__:
                #调用类中的方法,拿到返回值
                res = cls.run()
                #把返回值重新赋值给run属性，后者覆盖了前者,方法变成了属性
                cls.run = res #再把值赋值给MyClass的run属性
                return cls()  #返回对象

        return inner
#obj = outer(1)
'''
@obj [@符号第一次发动技能] <==>obj(MyClass) 把对象当成函数使用了，触发__call__魔术方法
self.inner1(cls) <==> return inner
<==>  [@符号第二次发动技能]  将新函数替换旧函数 MyClass = inner
obj = MyClass() <==> inner()  => cls() => obj对象

情况一
@outer(1) #第一步 @obj => MyClass = obj(MyClass) 对象obj当成函数调用触发call方法
class MyClass():
    def run():
        return "亢龙有悔"
obj = MyClass() #第六步 MyClass() = inner() = cls()
print(obj.ad) #第十一步
obj.money()
'''

'''
@obj [@符号第一次发动技能] <==> obj(MyClass) 把对象当成函数使用了，触发__call__魔术方法
self.inner2(cls) <==> return inner
<==>  [@符号第二次发动技能] 将新函数替换旧函数 MyClass = inner
obj = MyClass()  <==> inner() => cls() => obj对象
'''
#情况二
@outer(2) # outer(2) => obj对象，@obj => MyClass = obj(MyClass),obj(MyClass) 把对象当成函数使用了，触发__call__魔术方法
class MyClass():
    def run():
        return "亢龙有悔"
obj = MyClass() # MyClass() => inner()返回cls() => obj
print(obj.run) #亢龙有悔

'''
obj = MyClass()的解释
#第一部分 定义一个类
class Ceshi():
    c = 100
obj =  Ceshi()
print(obj.c)

#第二部分，定义两个函数
def func22():
    print(111)

def func(cls):
    cls.aabbcc = 200
    obj = cls()
    return obj

#第三部分，把类当成参数传递给func，类在func函数中形成了一个独立的副本
obj= func(Ceshi)

#第四部分，把这个类做替换，变成函数，那么现在在全局空间的Ceshi已经变成了函数，不再是类
Ceshi = func22

#第五部分，调用局部空间obj，还是可以得到原来类中的成员属性和方法
print(obj.c)
print(obj.aabbcc)
'''

3.类当中的方法

# ### 面向对象中的方法
'''
普通方法：可以有参数,或者无参数,当成正常的函数调用
绑定方法:(1)绑定到对象(自动传递参数为对象)(2)绑定到类(自动传递参数为类)
静态方法:无论是对象还是类,都可以调用,默认不用传递任何参数
'''

class Dog():
    name = "旺财"

    #普通方法
    def jiao():
        print("小狗哇哇哇的叫唤")

    #绑定方法(对象)
    def eat(self):
        print("小狗喜欢吃骨头")

    #绑定方法(类) 类方法
    @classmethod
    def tail(cls):
        print(cls)
        print("小狗看到主人喜欢摇尾巴")

    #静态方法
    @staticmethod
    def jump(num):
        print("小狗喜欢接飞盘")
obj = Dog()
#普通方法(无参方法只能类调用)
#obj.jiao()  error
Dog.jiao()

#绑定self方法(一般用对象调用)
obj.eat() #推荐
Dog.eat(123) #类调用绑定方法 不推荐

#绑定类方法(classmethod类的专属方法推荐用类调用)
'''系统自己把类当成参数进行传递'''
Dog.tail() #类调用方法 推荐
obj.tail()

#静态方法(staticmethod不会默认传递任何参数,如果有参数,当成普通方法调用自己)
obj.jump(1)
Dog.jump(2)

### 在类外,为对象添加成员方法，默认皆是静态方法
obj.func = lambda : print(123)
obj.func()

4.property装饰器

# ### property
'''
property 可以把方法变成属性使用
作用:控制属性的获取 设置  删除操作
变相的增加成员的安全性,可以通过自定义逻辑对成员进行控制

自动触发：要求是同一个名字
    获取 @property
    设置@属性名.setter
    删除@属性名.deleter
'''

#方法一
class MyClass():
    def __init__(self,name):
        self.name = name

    @property
    def username(self):
        return self.name
        #pass

    @username.setter
    def username(self,val):
        print(2131231)
        val = "朴仁猛"
        self.name = val

    @username.deleter
    def username(self):
        #如果发现有删除行为,可以在这个方法中拒绝删除
        #pass
        del self.name
obj = MyClass("小芳")

#获取属性(自动触发获取方法@property)
#print(obj.username())#TypeError: 'str' object is not callable
print(obj.username) #把方法当做属性

#设置属性(自动触发设置方法)val形参自动接收设置的值
obj.username = "朴仁猛"
print(obj.username)

#删除属性
del obj.username
#print(obj.username) error

#方法二
class MyClass():
    def __init__(self,name):
        self.name = name

    #获取
    def get_username(self):
        return self.name

    #设置
    def set_username(self,val):
        # val = "朴仁猛"
        self.name = val

    #删除
    def del_username(self):
        #如果发现有删除行为,可以在这个方法中拒绝删除
        del self.name

    #顺序必须按照 获取 ->设置 ->删除的参数进行传递
    username = property(get_username,set_username,del_username)

obj = MyClass("朴飘乐")
#获取
print(obj.username)
#设置
obj.username = "朴一辈"
print(obj.username)
#删除
del obj.username
print(obj.username)  #error  被删掉了

总结：

今天主要讲了反射 装饰器，类当中的方法普通方法，类方法，静态方法，property装饰
反射就是通过字符串去操作对象或者模块中的成员(属性或者方法)
可以反射类或者对象中的成员
主要有
hasattr 检测类或者对象中是否有该成员 返回True或者False
getattr 获取类或者对象中的成员 存在则获取到，不存在则报错，可以设置第三个参数防止报错
setattr 设置类或者对象成员的值
delattr 删除类或者对象成员

装饰器函数
为原函数拓展新功能，用新功能去替代旧功能
作用：在不改变原有代码的基础上，实现功能上的拓展
符号：@符号
@符号的作用
自动把@符号下面的函数当成参数传递给装饰器
把新函数进行返回，让新函数去替换旧函数，以实现功能的拓展

装饰器的嵌套
用装饰器修饰带有参数的函数
用装饰器修饰带有参数返回值的函数
装饰器拓展原函数
带有参数的函数装饰器
带有参数的类装饰器

面向对象中的方法
普通方法：可以有参数，或者无参数，当成正常的函数调用
绑定方法：绑定到对象(自动传递参数为对象)self方法(2)绑定到类(自动传递参数为类)类方法，需要用@classmethod装饰，参数至少为一个cls
静态方法：@staticmethod 无论对象还是类，都可以调用，默认不用传递任何参数

property装饰器
可以把方法变成属性使用
作用控制属性的获取 设置 删除操作
变相的增加成员的安全性，可以通过自定义逻辑对成员进行控制

自动触发的时候，要求是用一个名字
获取 @property
设置 @属性名.setter
删除 @属性名.deleter