反射

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

四个可以实现自省的函数：hasattr 、 getattr 、 setattr 、delattr

对对象的反射

  1. class Person:
  2.     s = "静态变量"
  4.     def __init__(self, name, age):
  5.         self.name = name
  6.         self.age = age
  8.     def say_hi(self):
  9.         print("hi,%s" % self.name)
  12. obj = Person("小明", 18)
  13. ================================================
  14. # 检测是否含有某种属性
  15. print(hasattr(obj, 'name'))
  16. print(hasattr(obj, 'say_hi'))
  18. # 运行结果
  19. True
  20. True
  21. ================================================
  22. # 获取属性
  23. n = getattr(obj, 'name')
  24. print(n)
  25. func = getattr(obj, 'say_hi')
  26. func()
  28. print(getattr(obj,'aaaaaaaa','不存在啊')) # 报错
  30. # 运行结果
  31. 小明
  32. hi,小明
  33. ================================================
  34. # 设置属性
  35. setattr(obj, 'smart', True)
  36. setattr(obj, 'show_name', lambda self: self.name + 'smart')
  37. print(obj.__dict__)
  38. print(obj.show_name(obj))
  40. # 运行结果
  41. {'name': '小明', 'age': 18, 'smart': True, 'show_name': <function <lambda> at 0x000001A703627168>}
  42. 小明smart
  43. ================================================
  44. # 删除属性
  45. delattr(obj, 'age')
  46. delattr(obj, 'show_name')
  47. # delattr(obj,'show_name111') # 不存在,则报错
  48. print(obj.__dict__)
  50. # 运行结果
  51. {'name': '小明', 'smart': True}

对类的反射

  1. class Person:
  2.     s = "静态变量"
  4.     def __init__(self, name, age):
  5.         self.name = name
  6.         self.age = age
  8.     def say_hi(self):
  9.         print("hi,%s" % self.name)
  11.     def func(self):
  12.         return 'func'
  14.     @staticmethod
  15.     def learn():
  16.         return 'go to learn'
  18. print(getattr(Person, 's'))
  19. print(getattr(Person, 'func'))
  20. print(getattr(Person, 'learn'))
  22. # 运行结果
  23. 静态变量
  24. <function Person.func at 0x0000014D85D2D558>
  25. <function Person.learn at 0x0000014D85D2D5E8>

当前模块的反射

  1. import sys
  4. def s1():
  5.     print('s1')
  8. def s2():
  9.     print('s2')
  12. this_module = sys.modules[__name__]
  13. print(hasattr(this_module, 's1'))
  14. print(getattr(this_module, 's2'))
  16. # 运行结果
  17. True
  18. <function s2 at 0x000001C1E08E70D8>

其他模块的反射

  • 程序目录：
    • module_test.py
    • test.py
  • 当前文件：
    • test.py
  1. import module_test as obj
  3. obj.test()
  4. print(hasattr(obj,'test'))
  5. getattr(obj,'test')()

举例

使用反射前

  1. class User:
  3.     def login(self):
  4.         print('欢迎来到登录页面')
  6.     def register(self):
  7.         print('欢迎来到注册页面')
  9.     def save(self):
  10.         print('欢迎来到存储页面')
  12. while 1:
  13.     choose = input('>>>').strip()
  14.     if choose == 'login':
  15.         obj = User()
  16.         obj.login()
  17.     elif choose == 'register':
  18.         obj = User()
  19.         obj.register()
  20.     elif choose == 'save':
  21.         obj = User()
  22.         obj.save()

使用反射后

  1. class User:
  3.     def login(self):
  4.         print('欢迎来到登录页面')
  6.     def register(self):
  7.         print('欢迎来到注册页面')
  9.     def save(self):
  10.         print('欢迎来到存储页面')
  12. user = User()
  13. while 1:
  14.     choose = input('>>>').strip()
  15.     if hasattr(user, choose):
  16.         func = getattr(user, choose)
  17.         func()
  18.     else:
  19.         print('输入错误。。。。')

函数 vs 方法

通过打印函数（方法）名确定

  1. def func():
  2.     pass
  5. print(func)
  8. class A:
  9.     def func(self):
  10.         pass
  13. print(A.func)
  14. obj = A()
  15. print(obj.func)
  17. # 运行结果
  18. <function func at 0x0000029C8F2270D8>
  19. <function A.func at 0x0000029C8F2F80D8>
  20. <bound method A.func of <__main__.A object at 0x0000029C8ED9E988>>

由此可见，类实例化为对象后里面是方法，直接定义或在类内定义的是函数。

通过types模块确定

  1. from types import FunctionType
  2. from types import MethodType
  5. def func():
  6.     pass
  9. class A:
  10.     def func(self):
  11.         pass
  14. obj = A()
  15. print(isinstance(func, FunctionType))
  16. print(isinstance(A.func, FunctionType))
  17. print(isinstance(obj.func, FunctionType))
  18. print(isinstance(obj.func, MethodType))
  20. #运行结果
  21. True
  22. True
  23. False
  24. True

静态方法是函数

即使在实例化对象里，静态方法也是函数。

  1. from types import FunctionType
  2. from types import MethodType
  4. class A:
  5.     def func(self):
  6.         pass
  8.     @classmethod
  9.     def func1(self):
  10.         pass
  12.     @staticmethod
  13.     def func2(self):
  14.         pass
  16. obj = A()
  17. # 静态方法其实是函数
  18. print(isinstance(A.func2,FunctionType))
  19. print(isinstance(obj.func2,FunctionType))
  21. # 运行结果
  22. True
  23. True

函数与方法的区别

  1. 函数是显式传递数据的，例如我们要为 len() 函数传递需要处理的数据。
  2. 函数与对象无关
  3. 方法是隐式传递数据的，方法可操作类内部的数据。
  4. 方法与对象相关联。如在使用 strip() 方法时要通过str对象调用。

    双下方法

    len

    ```python class B: def len(self):
    1.  return 666

b = B() print(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(a.dict) print(len(a))

运行结果

666 {‘a’: 1, ‘b’: 2} 2

  1. <a name="kOEOo"></a>
  2. ## __hash__
  3. ```python
  4. class A:
  5.     def __init__(self):
  6.         self.a = 1
  7.         self.b = 2
  9.     def __hash__(self):
  10.         print(str(self.a)+str(self.b))
  11.         return hash(str(self.a)+str(self.b))
  13. a = A()
  14. print(hash(a))
  16. # 运行结果
  17. 12
  18. -1326642716895049178

str

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

  1. class A:
  2.     def __init__(self):
  3.         pass
  4.     def __str__(self):
  5.         return 'jack'
  6. a = A()
  7. print(a)
  8. print('%s' % a)
  10. # 运行结果
  11. jack
  12. jack

repr

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

  1. class A:
  2.     def __init__(self):
  3.         pass
  4.     def __repr__(self):
  5.         return 'jack'
  6. a = A()
  7. print(repr(a))
  8. print('%r'%a)
  10. #运行结果
  11. jack
  12. jack

call

对象后加括号，触发执行。

注意：new方法的执行是由创建对象触发的，即：对象 = 类名() ；而call方法是 对象() 或 类()() 触发调用的。

  1. class Foo:
  3.     def __init__(self):
  4.         print('__init__')
  6.     def __call__(self, *args, **kwargs):
  7.         print('__call__')
  9. obj = Foo()  # 执行 __init__
  10. obj()  # 执行 __call__
  12. # 运行结果
  13. __init__
  14. __call__

eq

判断两个对象是否相等时调用

  1. class A:
  3.     def __init__(self):
  4.         self.a = 1
  5.         self.b = 2
  7.     def __eq__(self,obj):
  8.         if  self.a == obj.a and self.b == obj.b:
  9.             return True
  11. a = A()
  12. b = A()
  13. print(a == b)
  15. # 运行结果
  16. True

del

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

注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，
因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触
发执行的。

new

  • new() 方法是在类准备将自身实例化时调用。
  • new() 方法始终都是类的静态方法，即使没有被加上静态方法装饰器。

  • 通常来说，新式类开始实例化时， new() 方法会返回cls（cls指代当前类）的实例，然后该类的 init() 方法作为构造方法会接收这个实例（即self）作为自己的第一个参数，然后依次传入 new() 方法中接收的位置参数和命名参数。 ```python class A:

    def init(self):

    1.   self.x = 1
    2.   print('in init function')

    def new(cls, args, *kwargs):

    1.   print('in new function')
    2.   return object.__new__(A, *args, **kwargs)

a = A() print(a.x)

运行结果

in new function in init function 1

  1. <a name="zUTDC"></a>
  2. ## __item__系列
  3. ```python
  4. class Foo:
  5.     def __init__(self, name):
  6.         self.name = name
  8.     def __getitem__(self, item):
  9.         print(self.__dict__[item])
  11.     def __setitem__(self, key, value):
  12.         self.__dict__[key] = value
  13.         print('赋值成功')
  15.     def __delitem__(self, key):
  16.         print('del obj[key]时,我执行')
  17.         self.__dict__.pop(key)
  19.     def __delattr__(self, item):
  20.         print('del obj.key时,我执行')
  21.         self.__dict__.pop(item)
  24. f1 = Foo('sb')
  25. f1['age'] = 18
  26. f1['age1'] = 19
  27. print(f1.__dict__)
  28. del f1.age1
  29. del f1['age']
  30. f1['name'] = 'mingzi'
  31. print(f1.__dict__)
  33. # 运行结果
  34. 赋值成功
  35. 赋值成功
  36. {'name': 'sb', 'age': 18, 'age1': 19}
  37. del obj.key时,我执行
  38. del obj[key]时,我执行
  39. 赋值成功
  40. {'name': 'mingzi'}

上下文管理器相关

enter和exit

  1. class A:
  2.     def __init__(self, text):
  3.         self.text = text
  5.     def __enter__(self):  # 开启上下文管理器对象时触发此方法
  6.         self.text = self.text + '您来啦'
  7.         return self  # 将实例化的对象返回f1
  9.     def __exit__(self, exc_type, exc_val, exc_tb):  # 执行完上下文管理器对象f1时触发此方法
  10.         self.text = self.text + '这就走啦'
  12. with A('大爷') as f1:
  13.     print(f1.text)
  14. print(f1.text)
  16. # 运行结果
  17. 大爷您来啦
  18. 大爷您来啦这就走啦