python之面向对象反射和双下方法

面向对象之反射，双下方法

1. 反射

   定义：主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）

   python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中一切皆对象（都可以使用反射）

   • 对对象的反射

     class A:
         static_field = '静态属性'
         def __init__(self,name,age):
             self.name = name
             self.age = age
         def func(self):
             print('in A func')
     obj = A('MC骚Q', 18)
     # 判断obj对象中是否含有某种属性
     print(hasattr(obj,'name'))	# True
     print(hasattr(obj,'func'))	# True
     # 获取某种属性，若存在返回属性值，若不存在，返回返回值
     print(getattr(obj,'name'))	# MC骚Q
     print(getattr(obj,'name1',None))	# None
     getattr(obj,'func')(obj)	# in A func
     # 设置属性
     setattr(obj,'hobby','玩')
     print(getattr(obj,'hobby'))	# 玩
     # 删除属性
     delattr(obj,'name')
     print(hasattr(obj,'name'))	# False
     

   • 对类的反射

     class A(object):
         static_filed = 'LOL'
         def __init__(self):
             self.name = '草丛伦'
         def func(self):
             return 'in func'
         @staticmethod
         def func1():
             return 'in func1'
     print(getattr(A,'static_filed'))	# LOL
     print(getattr(A,'func'))	# <function A.func at 0x0000027BB6CC32F0>
     print(getattr(A,'func')(1))	# in func
     print(getattr(A,'func1')())	# in func1
     

   • 对当前模块的反射

     import sys
     def func1():
         print('in func1')
     def func2():
         print('in func2')
     def func3():
         print('in func3')
     class B:
         static = 'B类'
     li = [f'fun{i}' for i in range(1,4)]
     # 获取当前模块所有变量与值的对应关系
     this_modules = sys.modules[__name__]
     print(getattr(this_modules,'func1'))	# <function func1 at 0x000001EE69146048>
     getattr(this_modules,'func1')()	# in func1
     cls = getattr(this_modules,'B')
     obj = cls()
     print(cls.static)	# B类
     for i in li:
         getattr(this_modules,i)()	# in func1	in func2	in func3
     

     sys.modules是一个全局字典，该字典是python启动后就加载在内存中。每当程序员导入新的模块，sys.modules都将记录这些模块。字典sys.modules对于加载模块起到了缓冲的作用。当某个模块第一次导入，字典sys.modules将自动记录该模块。当第二次再导入该模块时，python会直接到字典中查找，从而加快了程序运行的速度。

   • 其他模块的反射

     # 一个模块中的代码
     def test():
         print('from the test')
     '''
     程序目录：
     module_test.py
     index.py
     当前文件：
     index.py
     '''
     # 另一个模块中的代码
     import module_test as obj
     print(hasattr(obj,'test'))	# True
     getattr(obj,'test')()	# from the test
     

   • 反射的应用

     class Auth:
         li = [('login','登陆'),('register','注册'),('exit','退出')]
         def login(self):
             print('登陆')
         def register(self):
             print('注册')
         def exit(self):
             print('退出')
     while 1:
     	obj = Auth()
         for m,n in enumerate(obj.li,1):
             print(m,n[1])
         user_choice = input('请输入选择').strip()
         if hasattr(obj,obj.li[int(user_choice)-1][0]):
             getattr(obj,obj.li[int(user_choice)-1][0])()
         else:
             print('输入错误')
     # 省去对多种情况的判断
     

2. 函数和方法的区别

   • 如何区分

     • 打印函数（方法）名

       def func():
           pass
       class A:
           def func(self):
               pass
       obj = A()
       print(func)	# <function func at 0x0000025FC2E73378> 函数
       print(A.func)	# <function A.func at 0x0000025FC2E73488> 函数
       print(obj.func)	# <bound method A.func of <__main__.A object at 0x0000025FB3F2FDD8>> 方法
       

     • 通过type模块验证

       from types import FuntionType
       from types import MethodType
       def func():
           pass
       class A:
           def func(self):
               pass
       obj = A()
       print(isinstance(func,FuntionType))	# True
       print(isinstance(A.func,FuntionType))	# True
       print(isinstance(obj.func,FuntionType))	# False
       print(isinstance(obj.func,MethodType))	# True
       

   • 静态方法是函数

     from types import FunctionType
     from types import MethodType
     class A:
         @staticmethod
         def func():
             pass
     obj = A()
     print(isinstance(A.func,FunctionType))	# True
     

   • 函数与方法的区别

     • 函数是显性传递参数的；而方法存在隐性传参
     • 方法可以操作类内部的数据
     • 函数跟对象无关；方法跟对象是关联的。例如，strip()方法，必须通过字符串调用

3. 双下方法

   1. __len__当对对象执行len()方法时，就会自动执行

      class B:
          def __len__(self):
              print(666)
      b = B()
      len(b)	# len 一个对象就会触发__len__方法
      class A:
          def __init__(self):
              self.a = 1
              self.b = 2
          def __len__(self):
              return len(self.__dict__)
      a = A()
      print(len(a))	# 2
      

   2. __hash__当对对象执行hash()方法时，就会自动执行

      class A:
          def __init__(self):
              self.a = 1
              self.b = 2
          def __hash__(self):
              return hash(str(self.a)+str(self.b))
      a = A()
      print(hash(a)) # 打印'12'的hash值,-3594961296004182135
      

   3. __str__当打印对象时，就会自动执行

      如果一个类中定义了__str__方法,那么在打印对象时,默认输出该方法的返回值

      class A:
          def __init__(self):
              pass
          def __str__(self):
              return '铁憨憨'
      a = A()
      print(a)	# 铁憨憨
      

   4. __repr__同__str__

      如果一个类中定义了__repr__方法，那么在repr(对象)时，默认输出该方法的返回值

      class A:
          def __init__(self):
              pass
          def __str__(self):
              return '铁憨憨'
      a = A()
      print(repr(a))	# 铁憨憨
      print('%r'%a)	# 铁憨憨
      

   5. __call__对象后加括号，会触发执行

      class A:
          def __init__(self):
              pass
          def __call__(self,*args,**kwargs):
              print('__call__')
      obj = A()
      obj()	# 执行__call__,打印__call__
      

   6. __eq__当对两个对象比较时执行

      class A:
          def __init__(self):
              self.a = 1
              self.b = 2
          def __eq__(self,obj):
              if self.a == obj.a and self.b == obj.b:
                  return True
      a = A()
      b = A()
      print(a == b)
      

   7. __del__析构方法，当对象在内存中被释放时，自动触发执行

      析构函数的调用是由解释器在进行垃圾回收机制时自动出发执行的

      class A:
          def __del__(self):
              print(111)
      obj = A()
      del obj	# 111
      

   8. __new__构造函数，创建并返回一个新对象

      class A:
          def __init__(self):
              self.x = 1
              print('in init function')
          def __new__(cls,*args,**kwargs):
              print('in new function')
              return object.__new__(cls,*args,**kwargs)
      a = A()
      print(a.x)
      # in new function
      # in init function
      # 1
      

      单例模式：

      class A:
          __instance = None
          def __new__(cls,*args,**kwargs):
              if cls.__instance is None:
                  cls.__instance = object.__new__(cls)
              return cls.__instance
      a = A()
      b = A()
      print(a)	# <__main__.A object at 0x0000015BC7C68E80>
      print(b)	# <__main__.A object at 0x0000015BC7C68E80>
      

      单例模式分析：一个类只能实例化一个对象,无论你实例化多少次,内存中都只有一个对象.

      """
      单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。
      【采用单例模式动机、原因】
      对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID(序号)生成器。如在Windows中就只能打开一个任务管理器。如果不使用机制对窗口对象进行唯一化，将弹出多个窗口，如果这些窗口显示的内容完全一致，则是重复对象，浪费内存资源；如果这些窗口显示的内容不一致，则意味着在某一瞬间系统有多个状态，与实际不符，也会给用户带来误解，不知道哪一个才是真实的状态。因此有时确保系统中某个对象的唯一性即一个类只能有一个实例非常重要。
      如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。一个更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的模式动机。
      【单例模式优缺点】
      【优点】
      一、实例控制
      单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。
      二、灵活性
      因为类控制了实例化过程，所以类可以灵活更改实例化过程。
      【缺点】
      一、开销
      虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。
      二、可能的开发混淆
      使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。
      三、对象生存期
      不能解决删除单个对象的问题。在提供内存管理的语言中（例如基于.NET Framework的语言），只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中（如 C++），其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用
      

   9. __item__系列

      对对象进行类似于字典的操作

      class A:
          def __init__(self,name):
              self.name = name
          def __getitem__(self,item):
              print(item)
              print('get时执行我')
          def __setitem__(self,key,value):
              self.name = value
              print('set时执行')
          def __delitem__(self,key):
              print(f'del obj{[key]}时执行')
      obj = A('皮皮寒')
      obj['name']	# name	get时执行我
      obj['name'] = '铁憨憨'	# set时执行
      print(obj.name)	# 只是触发了__setitem__实际并未更改，因此还是皮皮寒
      del obj['name']	# del obj['name']时执行
      

   10. 上下文管理器相关

       对一个对象类似于进行with语句上下文管理的操作, 必须要在类中定义__enter__ __exit__

       class A:
           def __init__(self,text):
               self.text = text
           def __enter__(self):	# 开启上下文管理器对象时触发此方法
               self.text = self.text + '您来啦'
               return self	# 将实例化的对象返回给f1
           def __exit__(self,exc_type,exc_val,exc_tb):	# 执行完上下文管理器对象f1时触发此方法
               self.text = self.text + '这就走啦'
       with A('大爷') as f1:
           print(f1.text)
       print(f1.text)
       # 大爷您来啦
       # 大爷您来啦这就走啦