二十四、反射，元类和__call__方法,__new__方法，单例模式

一、isinstance和issubclass

isinstance(obj,cls)检查是否obj是否是类 cls 的对象

class Foo(object):
     pass
  
obj = Foo()
  
isinstance(obj, Foo)

issubclass(sub, super)检查sub类是否是 super 类的派生类 

class Foo(object):
    pass
 
class Bar(Foo):
    pass
 
issubclass(Bar, Foo)

二、反射

反射：是用字符串类型的名字，去操作变量
反射指的是一个对象应该具备,可以检测,修改,增加自身属性的能力 

"""反射：是用字符串类型的名字，去操作变量"""


# name = 1
# eval("print(name)")  # 1 容易出现安全隐患


# 反射  就没有安全问题


# 反射对象的属性和方法  hasattr getattr setattr delattr
class A:
    price = 200

    def func(self):
        print("in func")


a = A()
a.name = "alex"
a.age = 18
# 反射对象的属性
# ret = getattr(a, "name")  # alex 通过变量名的字符串形式取到的值
# print(ret)  # alex
# # 反射对象的方法
# """里面是字符串，变成函数和对象的内存地址，加个（）就可以调用方法"""
# ret = getattr(a, "func")
# print(ret)  # <bound method A.func of <__main__.A object at 0x00000299778143C8>>
# ret()  # in func

#
# class A:
#     price = 200
#
#     @classmethod
#     def func(cls):
#         print("in func")
#
#
# # 反射类的属性
# # A.price
# ret = getattr(A, "price")
# print(ret)  # 200
# # 反射类的方法 classmethod 和staticmethod
# # A.func()
# if hasattr(A,"func"):  # 如果成立我就执行，不会报错
#     ret = getattr(A, "func")()
# ret() # in func

# 反射模块的属性
# print(res)
# import my
# #
# # print(my.girl)
# ret = getattr(my, "girl")
# print(ret)
#
# # 反射模块的方法
# my.eva()
# if hasattr(my, "eva"):
#     ret = getattr(my, "eva")()
# print(ret)

# 内置模块也能用
import time

# time.sleep()
ret = getattr(time, "sleep")
ret(2)

import sys

year = 2019
print(sys.modules)  # '__main__': <module '__main__'
print(sys.modules["__main__"].year)


def eva():
    print("eva我喜欢听你讲课")


# 反射自己模块中的变量
getattr(sys.modules["__main__"], "year")

# 反射自己模块中的方法
if hasattr(sys.modules["__main__"], "eva"):
    getattr(sys.modules["__main__"], "eva")()

name = input(">>>>>>>>>>:")
print(getattr(sys.modules[__name__], "name"))


# setattr 设置修改变量，没有就添加
class A:
    pass


a = A()
setattr(a, "name", "nezha")
setattr(A, "name", "eva")
print(a.name)
print(A.name)

# delattr  删除
delattr(a, "name")
delattr(A, "name")
# print(a.name)

二、元类

元类：创建类的类

对象是通过类实例化产生的,如果类也是对象的话,必然类对象也是有另一个类实例化产生的(类就是元类的对象)

定义类的规则都是从元类那来的

默认情况下所有类的元类都是type，但是type是继承object

创建类的三个要素；

class Person(object):
    name =123
    pass

#1.类名 （字符类型）2.类的父类或基类（元组或列表）3.类的名称空间（字典类型）

1.type是继承object

class Person:
    pass


p = Person()
print(type(p))  # <class '__main__.Person'>
print(p.__class__)  # <class '__main__.Person'>
print(type(Person))  # <class 'type'>  元类

type()  #<class 'type'>

2.只要继承了type 那么这个类就变成了一个元类

""" 学习元类的目的：高度自定义一个类
    只要继承type，这个类就变成了元类
需求：控制类的名字必须以“驼峰式”的方式来书写，否则报错"""


# 定义元类
class MyType(type):
    def __init__(self, clss_name, bases, dict):
        super().__init__(clss_name, bases, dict)  # 类的三要素：类名，基类（父类），类的名称空间
        print(clss_name, bases, dict)
        if not clss_name.istitle():
            raise Exception("名字不会写？类名要大写,sb")


# 指定元类
class Pig(metaclass=MyType):
    pass
# 通过__init__方法控制类名（类的属性）
# MyType("pig", (), {})  初始化方法

三、__call__方法的应用

1.自定义__call__方法

class MyMeta(type):
    def __init__(self, name, bases, dict):
        super().__init__(name, bases, dict)
        print("你个铺盖仔")

    def __call__(self, *args, **kwargs):  # 可变参数爱传不传
        print("元类 call run")
        print(self)  # <class '__main__.Dog'>Dog类
        print(args)  # ()('大帅',)把对象属性传参传进来了
        print(kwargs)  # {}字典，传进来
        return super().__call__(*args, **kwargs)


class Dog(metaclass=MyMeta):  # 会走元类init方法  Dog =MyMeta("Dog",(),{})
    def __init__(self, name):
        self.name = name

    def __call__(self, *args, **kwargs):
        print("call run")


d = Dog("大帅")  # 类是元类的对象
print(d.name)
# 当你把类实例化会自动触发元类call方法，*args是位置传参列表元祖，*kwargs是字典"""

2.需求把对象属性改为大写

# 创建元类
class MyType(type):
    def __call__(self, *args, **kwargs):
        new_args = []
        for i in args:
            new_args.append(i.upper())

        # print(new_args)
        print(kwargs)
        return super().__call__(*new_args, **kwargs)  # 执行或覆盖call方法


class Person(metaclass=MyType):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender


p = Person("wukai", "man")
print(p.name, p.gender)  # WUKAI ,MAN
# 调用自定义元类__call__方法可以修改对象属性
# 注意自定义元类中，重点在于覆盖父类__call__方法，并返回其值

class MyType(type):
    def __call__(self, *args, **kwargs):
       if args:
           raise Exception("顶你的费，不允许，用位置参数传参")

        # print(new_args)
       print(kwargs)
       return super().__call__(*args, **kwargs)  # 执行或覆盖call方法


class Person(metaclass=MyType):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender


p = Person(name="wukai",gender="man")
p = Person("wukai", "man")
print(p.name, p.gender)

四、__new__方法

当你要创建类对象时，会首先执行元类中__new__方法，先新创建“类对象”，然后自动调用__init__方法，对这个类进行初始化
注意：new方法必须有返回值且必须是 对应的对象"

# 自定义元类
class Meta(type):

    def __new__(cls, *args, **kwargs):
        print(cls)  # 元类自己
        print(args)  # 创建类需要的几个参数：类名 基类 名称空间
        print(kwargs)  # 空字典
        print("run new")
        return super().__new__(cls, *args, **kwargs)  # 初始化类对象，必须有返回值且是类对象
        # obj=type.__new__(cls,*args,**kwargs)  # 第二种方法
        # return obj

    def __init__(self, a, b, c):
        super().__init__(a, b, c)
        print("run init")


class A(metaclass=Meta):
    pass


print(A)
# 总结：new方法和init方法都可以实现控制类的创建过程，init更简单些
# a = A()

五、单例模式

设计模式：用于解决某种固定问题的套路
单例：指的是一个类只能产生一个对象
单例目的：单例是为了节省资源，当一个类的所有对象属性全部相同时，则没有必要创建多个对象，浪费资源

 单例元类
class Single(type):
    def __call__(self, *args, **kwargs):
        if hasattr(self, "obj"):
            return getattr(self, "obj")
        obj = super().__call__(*args, **kwargs)   # 初始化call方法
        print("new 了")
        self.obj = obj
        return obj


class Student(metaclass=Single):
    def __init__(self, name, age):
        self.name = name
        self.age = age


stu = Student("jack", 18)
stu = Student("jack", 18)
stu = Student("jack", 18)