反射简介

反射就是通过字符串的形式去对象（模块）中操作（查找/获取/删除/添加）成员，一种基于字符串的事件驱动。简单说，在Python中，能够通过一个对象，找出其type、class、attribute或method的能力，称为反射或自省。

具有反射能力的函数有type(),isinstance()，getattr()等。

可使用反射的地方：

  • 反射类中的变量：静态属性,类方法，静态方法；
  • 反射对象中的变量、对象属性、普通方法；
  • 反射模块中的变量；
  • 反射本文件中的变量。

为了方便阐述反射的用法，先定义一个类：

  1. class Point:
  2.     def __init__(self, x, y):
  3.         self.x = x
  4.         self.y = y
  6.     def __str__(self):
  7.         return "{} and {}".format(self.x, self.y)
  9.     def show(self):
  10.         print(self.x, self.y)

先对类实例化，然后看一下__dict__方法。

  1. >>> p = Point(4, 5)
  2. >>> print(p)
  3. 4 and 5
  4. >>> print(p.__dict__)
  5. {'x': 4, 'y': 5}
  7. >>> p.__dict__['y'] = 16
  8. >>> print(p.__dict__)
  9. {'x': 4, 'y': 16}

上例通过属性字典__dict__来访问对象的属性，本质上就是利用反射的能力，但是上面的例子中，访问的方式不优雅，Python提供了内置的函数。

反射用法

getattr

判断类、对象或者模块中是否有相应的属性或方法。
用法：

  1. getattr(obj, str, default=None)

判断obj中是否有str属性，有就返回，没有时如果有传入第三参数就返回第三参数，没有就报错。

例子1：下面两个函数等价。

  1. >>> print(p.__dict__)
  2. {'x': 4, 'y': 16}
  3. >>> print(getattr(p, '__dict__'))
  4. {'x': 4, 'y': 16}

这验证了上面说的__dict__本质上就是利用反射的能力。

例子2：getattr()使用方法

  1. >>> p = Point(4, 5)
  2. >>> getattr(p, "x")
  3. 4
  4. >>> getattr(p, "y")
  5. 16
  6. >>> print(getattr(p, '__dict__'))
  7. {'x': 4, 'y': 5}
  9. >>> getattr(p, "z", "NotFound")
  10. 'NotFound'
  11. >>> getattr(p, "z")
  12. Traceback (most recent call last):
  13.   File "D:\Anaconda3\lib\site-packages\IPython\core\interactiveshell.py", line 3331, in run_code
  14.     exec(code_obj, self.user_global_ns, self.user_ns)
  15.   File "<ipython-input-15-83b506d04926>", line 1, in <module>
  16.     getattr(p, "z")
  17. AttributeError: 'Point' object has no attribute 'z'

settattr

设置属性object的属性，存在则覆盖，不存在则新增。第三参数为新的属性值。

  1. setattr(object, name, value)

例子：settattr()使用方法

  1. >>> p1 = Point(4, 5)
  2. >>> p2 = Point(10, 10)
  4. >>> print(p1.__dict__)
  5. {'x': 4, 'y': 5}
  6. >>> print(p2.__dict__)
  7. {'x': 10, 'y': 10}
  9. >>> setattr(p1, 'y', 16)
  10. >>> setattr(p1, 'z', 10)
  11. >>> print(p1.__dict__)
  12. {'x': 4, 'y': 16, 'z': 10}

hasattr

判断对象是否有这个名字的属性，有就返回True，没有就返回False。name必须为字符串

  1. hasaattr(object,name)

例子：动态调用方法

  1. >>> if hasattr(p1, 'show'):
  2. >>>     print(getattr(p1, 'show'))
  4. <bound method Point.show of <__main__.Point object at 0x0000014572376488>>

动态增加方法

  1. >>> if not hasattr(Point, 'add'):
  2. >>>     setattr(Point, 'add', lambda self, other: Point(self.x + other.x, self.y + other.y))
  4. >>> print(Point.add)
  5. <function <lambda> at 0x0000014572371558>
  6. >>> print(p1.add)
  7. <bound method <lambda> of <__main__.Point object at 0x0000014572376488>>
  8. >>> print(p1.add(p2))
  9. 14 and 26
  1. >>> if not hasattr(p1, 'sub'):
  2. >>>     setattr(p1, 'sub', lambda self, other: Point(self.x - other.x, self.y - other.y))
  4. >>> print(p1.sub(p1, p2))
  5. -6 and 6
  7. >>> print(p1.__dict__)
  8. {'x': 4, 'y': 16, 'z': 10, 'sub': <function <lambda> at 0x0000014572381DC8>}
  10. >>> print(Point.__dict__)
  11. {'__module__': '__main__', '__init__': <function Point.__init__ at 0x00000145722E04C8>, '__str__': <function Point.__str__ at 0x00000145722E0318>, 'show': <function Point.show at 0x00000145722E0288>, '__dict__': <attribute '__dict__' of 'Point' objects>, '__weakref__': <attribute '__weakref__' of 'Point' objects>, '__doc__': None, 'add': <function <lambda> at 0x0000014572371558>}

反射相关的魔术方法

getattr()

  1. class Base:
  2.     n = 0
  4. class Point(Base):
  5.     z = 6
  7.     def __init__(self, x, y):
  8.         self.x = x
  9.         self.y = y
  11.     def show(self):
  12.         print(self.x, self.y)
  14.     def __getattr__(self, item):
  15.         return item
  17. >>> p1.x
  18. 4
  19. >>> p1.z
  20. 6
  21. >>> p1.n
  22. 0
  23. >>> p1.t
  24. 't'

实例属性会按照继承关系寻找，如果找不到，就会执行__getattr__()方法，如果没有这个方法，就会抛出AttributeError异常标识找不到属性。

setattr()

  1. class Base:
  2.     n = 0
  4. class Point(Base):
  5.     z = 6
  7.     def __init__(self, x, y):
  8.         self.x = x
  9.         self.y = y
  11.     def show(self):
  12.         print(self.x, self.y)
  14.     def __getattr__(self, item):
  15.         return item
  17.     def __setattr__(self, key, value):
  18.         print(key, value)
  20. # --------------------------------------------------
  21. >>> p1 = Point(4, 5)
  22. x 4
  23. y 5
  24. >>> print(p1.x)
  25. x
  26. >>> print(p1.z)
  27. 6
  28. >>> print(p1.n)
  29. 0
  30. >>> print(p1.t)
  31. t
  32. # --------------------------------------------------
  33. >>> p1.x = 50
  34. >>> print(p1.x)
  35. x
  36. >>> print(p1.__dict__)
  37. {}
  38. >>> p1.__dict__['x'] = 60
  39. >>> print(p1.__dict__)
  40. {'x': 60}
  41. >>> p1.x
  42. 60

实例通过.点号设置属性，例如self.x=x，就会调用__setattr__()，属性要加到实例的__dict__中，就需要自己完成。

setattr()方法，可以拦截堆实例属性的增加，修改操作，如果要设置生效，需要自己操作实例的__dict__。

  1. class Base:
  2.     n = 200
  4. class A(Base):
  5.     z = 100
  6.     d = {}
  8.     def __init__(self, x, y):
  9.         self.x = x
  10.         setattr(self, 'y', y)
  11.         self.__dict__['a'] = 5
  13.     def __getattr__(self, item):
  14.         print(item)
  15.         return self.d[item]
  17.     def __setattr__(self, key, value):
  18.         print(key, value)
  19.         self.d[key] = value
  21. >>> a = A(4, 5)
  22. x 4
  23. y 5
  24. >>> print(a.__dict__)
  25. {'a': 5}
  26. >>> print(A.__dict__)
  27. A.__dict__
  28. mappingproxy({'__module__': '__main__',
  29.               'z': 100,
  30.               'd': {'x': 4, 'y': 5},
  31.               '__init__': <function __main__.A.__init__(self, x, y)>,
  32.               '__getattr__': <function __main__.A.__getattr__(self, item)>,
  33.               '__setattr__': <function __main__.A.__setattr__(self, key, value)>,
  34.               '__doc__': None})
  35. >>> print(a.x, a.y)
  36. x
  37. y
  38. 4 5
  39. >>> print(a.a)
  40. 5

delattr()

  1. class Point:
  2.     z = 5
  4.     def __init__(self, x, y):
  5.         self.x = x
  6.         self.y = y
  8.     def __delattr__(self, item):
  9.         print(item)
  10.         p = Point(14, 5)
  13. >>> p = Point(3, 4)
  14. >>> del p.x
  15. x
  16. >>> p.z=15
  17. >>> del p.z
  18. z
  19. >>> del p.Z        
  20. Z
  21. >>> print(Point.__dict__)
  22. {'__module__': '__main__', 'z': 5, '__init__': <function Point.__init__ at 0x0000019E93B01318>, '__delattr__': <function Point.__delattr__ at 0x0000019E93B013A8>, '__dict__': <attribute '__dict__' of 'Point' objects>, '__weakref__': <attribute '__weakref__' of 'Point' objects>, '__doc__': None}

getattribute

  1. class Base:
  2.     n = 0
  4. class Point(Base):
  5.     z = 6
  7.     def __init__(self, x, y):
  8.         self.x = x
  9.         self.y = y
  11.     def __getattr__(self, item):
  12.         return item
  14.     def __getattribute__(self, item):
  15.         return item
  17. >>> p1 = Point(4, 5)
  18. >>> print(p1.__dict__)
  19. __dict__
  20. >>> print(p1.x)
  21. x
  22. >>> print(p1.z)
  23. z
  24. >>> print(p1.n)
  25. n
  26. >>> print(p1.t)
  27. t
  28. >>> print(Point.__dict__)
  29. {'__module__': '__main__', 'z': 6, '__init__': <function Point.__init__ at 0x000001F5EB7063A8>, '__getattr__': <function Point.__getattr__ at 0x000001F5EB706558>, '__getattribute__': <function Point.__getattribute__ at 0x000001F5EB706168>, '__doc__': None}
  30. >>> print(Point.z)
  31. 6

实例的所有的属性访问，第一个都会调用__getattribute__方法，它阻止了属性的查找，该方法应该返回值或者抛出一个AttributeError异常。

  • 该方法的返回值将作为属性查找的结果。
  • 如果抛出AttributeError异常，则会直接调用__getattr__方法，因为属性没有找到，__getattribute__方法中为了避免在该方法中无限递归，它的实现应该永远调用基类的同名方法以访问需要的任何属性。

需要注意的是，除非明确知道**__getattrtbute__**方法用来做什么，否则不要使用。

使用场景

  • input
    用户输入的如果是a，那么就打印1，如果输入的是b就打印2
  • 文件
    从文件中读出的字符串，想转换成变量的名字
  • 网络
    将网络传输的字符串转换成变量的名字

参考