内置函数补充，__str__方法、__del__方法 和 __call__方法和元祖

一 、内置函数补充

        1.isinstance函数：
            isinstance(obj,cls)检查obj是否是类 cls 的对象
            使用该函数来判断一个函数的类型

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

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

二、反射
            通过字符串来操作类与对象的属性，这种操作称为反射
            class People:
                country="China"
                def __init__(self,name):
                    self.name=name
                def tell(self):
                    print('%s is aaa' %self.name)

            obj=People('egon')
            1、hasattr  #检测是否含有某属性
            print(hasattr(obj,'name'))
            print(hasattr(obj,'country'))
            print(hasattr(obj,'tell'))

            2、getattr   #获取对应的属性
            f=getattr(obj,'tell',None)   # None为没有对应属性是的默认返回值
            print(f == obj.tell)
            f()
            obj.tell()

            3、setattr   #设置属性等同修改操作
            obj.age=18
            setattr(obj,"age",18)
            print(obj.__dict__)

            4、delattr   #删除属性
            del obj.name
            delattr(obj,"name")
            print(obj.__dict__)

三、__str__方法、__del__方法 和 __call__方法

       1.  __str__是系统默认函数，在打印对象时自动触发函数执行

            class People:
                def __init__(self,name,age,sex):
                    self.name=name
                    self.age=age
                    self.sex=sex

                def __str__(self):
                    # print('========>')
                    return '<名字：%s 年龄：%s 性别：%s>' %(self.name,self.age,self.sex)

            obj=People('egon',18,'male')
            print(obj)
        2. __del__也是系统默认函数在程序结束时，对象被删除的条件下，自动执行。
        注：如果产生的对象仅仅只是python程序级别的（用户级），那么无需定义__del__,如果产生的
        对象的同时还会向操作系统发起系统调用，即一个对象有用户级与内核级两种资源，比如（打开
        一个文件，创建一个数据库链接），则必须在清除对象的同时回收系统资源3，这就用到了__del__。

        实际使用示例：
            class MyOpen:
                def __init__(self,filepath,mode="r",encoding="utf-8"):
                    self.filepath=filepath
                    self.mode=mode
                    self.encoding=encoding
                    self.fobj=open(filepath,mode=mode,encoding=encoding)  #打开文件时会自动调用系统资源

                def __str__(self):
                    msg="""
                    filepath:%s
                    mode:%s
                    encoding:%s
                    """ %(self.filepath,self.mode,self.encoding)
                    return msg

                def __del__(self):
                    self.fobj.close()   #此时在清除对象之前自动执行归还系统资源

            res=f.fobj.read()
            print(res)

        3.__call__ :对象后面加括号，触发执行。
            构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__
            方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
            class Foo:
                def __init__(self):
                    pass
                def __str__(self):
                    return '123123'

                def __del__(self):
                    pass

                # 调用对象，则会自动触发对象下的绑定方法__call__的执行，
                # 然后将对象本身当作第一个参数传给self，将调用对象时括号内的值
                #传给*args与**kwargs
                def __call__(self, *args, **kwargs):
                    print('__call__',args,kwargs)

            obj=Foo()

            obj(1,2,3,a=1,b=2,c=3)

四、元类

        1. 一切皆为对象：
        元类：类的类就是元类，
        我们用class定义的类使用来产生我们自己的对象的
        内置元类type是用来专门产生class定义的类的

        2、用内置的元类type，来实例化得到我们的类
            class_name='Chinese'
            class_bases=(object,)
            class_body="""
            country="China"
            def __init__(self,name,age,sex):
                self.name=name
                self.age=age
                self.sex=sex
            def speak(self):
                print('%s speak Chinese' %self.name)
            """
            class_dic={}
            exec(class_body,{},class_dic)
        # 类的三大要素class_name,class_bases,class_dic

        3 、自定义元类：  自己可以控制类规范
            class Mymeta(type):
                # 来控制类Foo的创建
                def __init__(self,class_name,class_bases,class_dic): #self=Foo
                    if not class_name.istitle():
                        raise TypeError('类名的首字母必须大写傻叉')

                    if not class_dic.get('__doc__'):
                        raise TypeError('类中必须写好文档注释，大傻叉')

                    super(Mymeta,self).__init__(class_name,class_bases,class_dic)

                # 控制类Foo的调用过程，即控制实例化Foo的过程
                def __call__(self, *args, **kwargs):   #self=Foo,args=(1111,) kwargs={}
                    #1 造一个空对象obj
                    obj=object.__new__(self)
                    #2、调用Foo.__init__,将obj连同调用Foo括号内的参数一同传给__init__
                    self.__init__(obj,*args,**kwargs)
                    return obj

            # 下一行等同于传值 Foo=Mymeta('Foo',(object,),class_dic)
            class Foo(object,metaclass=Mymeta):
                """
                文档注释
                """
                x=1
                def __init__(self,y):
                    self.Y=y

                def f1(self):
                    print('from f1')

            obj=Foo(1111) #Foo.__call__()

        5.单例模式：适用于值重复不会改变，可节省一定资源

        方式一、
            import settings

            class MySQL:
                __instance=None
                def __init__(self,ip,port):
                    self.ip=ip
                    self.port=port

                @classmethod
                def singleton(cls):
                    if not cls.__instance:
                        obj=cls(settings.IP, settings.PORT)
                        cls.__instance=obj
                    return cls.__instance

            obj4=MySQL.singleton()
            obj5=MySQL.singleton()
            obj6=MySQL.singleton()

            print(obj4 is obj5 is obj6)