Python教程075 自省(introspection)1

https://www.cnblogs.com/huxi/archive/2011/01/02/1924317.html

自省(introspection)

是指在运行时来判断一个对象的类型的能力。简单的说，就是用python的代码自己告诉这个对象是什么，有什么，以及祖宗是什么，子孙是什么….(反射是java的说法，python叫自省)

Python内置的自省函数

help([object])
如果说能够通过一个函数就能够学会Python，那这个函数一定就是help()。help函数的作用就是查看对象的帮组文档。如果你需要得到关于类似return操作符的帮助，需要在内部加上引号，help(‘return’)

callable(object)
检查对象object是否可调用。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。对于函数, lambda匿名函数, 类, 以及实现了call方法的类实例, 它都返回True。

delattr(object, name)
删除对象的属性。delattr(x, ‘foobar’) 相当于del x.foobar

isinstance(object, classinfo)
来判断一个对象是否是一个已知的类型，类似type()。isinstance()会认为子类是一种父类类型，考虑继承关系。classinfo参数可以是一个Tuple，元素可以是重复的。

issubclass(class, classinfo)
用于判断参数class是否是类型参数classinfo的子类。类本身也会返回True。

dir([obj])
调用这个方法将返回包含obj大多数属性名的列表（会有一些特殊的属性不包含在内）。obj的默认值是当前的模块对象。

hasattr(obj, attr)
这个方法用于检查obj是否有一个名为attr的值的属性，返回一个布尔值。

getattr(obj, attr)
调用这个方法将返回obj中名为attr值的属性的值，例如如果attr为’bar’，则返回obj.bar。

setattr(obj, attr, val)
调用这个方法将给obj的名为attr的值的属性赋值为val。例如如果attr为’bar’，则相当于obj.bar = val。

例如，访问对象的属性

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


#coding: UTF-8
#  导入sys和inspect模块
import sys
import inspect
def foo(): pass # 函数，foo指向这个函数对象

class Cat: # 类，Cat指向这个类对象
    def __init__(self, name='kitty'):
        self.name = name
    def sayHi(self): #  实例方法，sayHi指向这个方法对象，使用  类或实例.sayHi访问
        print(self.name, 'says Hi!') # 访问名为name的字段，使用  实例.name访问

cat = Cat('kitty')  # cat是Cat类的实例对象

print(cat.name) # 访问实例属性
cat.sayHi() # 调用实例方法

print(dir(cat))                   # 获取实例的属性名，以列表形式返回
if hasattr(cat, 'name'):          # 检查实例是否有这个属性
    setattr(cat, 'name', 'tiger') # 等同于: a.name = 'tiger'
print(getattr(cat, 'name'))       # 等同于: print(a.name)

getattr(cat, 'sayHi')()           # 等同于: cat.sayHi()

访问对象的元数据
当你对一个你构造的对象使用dir()时，可能会发现列表中的很多属性并不是你定义的。这些属性一般保存了对象的元数据，比如类的name属性保存了类名。大部分这些属性都可以修改，不过改动它们意义并不是很大；修改其中某些属性如function.func_code还可能导致很难发现的问题，所以改改name什么的就好了，其他的属性不要在不了解后果的情况下修改。

接下来列出特定对象的一些特殊属性。另外，Python的文档中有提到部分属性不一定会一直提供，下文中将以红色的星号*标记，使用前你可以先打开解释器确认一下。

模块(module)

__doc__: 文档字符串。如果模块没有文档，这个值是None。
__name__: 始终是定义时的模块名；即使你使用import .. as 为它取了别名，或是赋值给了另一个变量名。
__dict__: 包含了模块里可用的属性名-属性的字典；也就是可以使用模块名.属性名访问的对象。
__file__: 包含了该模块的文件路径。需要注意的是内建的模块没有这个属性，访问它会抛出异常！

例如：

1
2
3
4
5


import fnmatch as m
print m.__doc__.splitlines()[0] # Filename matching with shell patterns.
print m.__name__                # fnmatch
print m.__file__                # /usr/lib/python2.6/fnmatch.pyc
print m.__dict__.items()[0]     # ('fnmatchcase', <function>)</function>

类(class)

__doc__: 文档字符串。如果类没有文档，这个值是None。
__name__: 始终是定义时的类名。
__dict__: 包含了类里可用的属性名-属性的字典；也就是可以使用类名.属性名访问的对象。
__module__: 包含该类的定义的模块名；需要注意，是字符串形式的模块名而不是模块对象。
__bases__: 直接父类对象的元组；但不包含继承树更上层的其他类，比如父类的父类。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


class Cat:
    def __init__(self, name='kitty'):
        self.name = name
    def sayHi(self):
        print(self.name, 'says Hi!')

print(Cat.__doc__)           # None
print(Cat.__name__)          # Cat
print(Cat.__module__)        # __main__
print(Cat.__bases__)         # (<class 'object'>,)
print(Cat.__dict__)          # {'__module__': '__main__', ...}</type>

执行以上程序会输出如下结果：

1
2
3
4
5


None
Cat
__main__
(<class 'object'>,)
{'__module__': '__main__', '__init__': <function Cat.__init__ at 0x7fe1b0b1f0d0>, 'sayHi': <function Cat.sayHi at 0x7fe1b0b1f158>, '__dict__': <attribute '__dict__' of 'Cat' objects>, '__weakref__': <attribute '__weakref__' of 'Cat' objects>, '__doc__': None}

实例(instance)

实例是指类实例化以后的对象。

__dict__: 包含了可用的属性名-属性字典。 __class__: 该实例的类对象。对于类Cat，cat.__class__ == Cat 为 True。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class Cat:
    def __init__(self, name='kitty'):
        self.name = name
    def sayHi(self):
        print(self.name, 'says Hi!')

cat = Cat()
print(cat.__dict__)
print(cat.__class__)
print(cat.__class__ == Cat) # True

执行以上程序会输出如下结果：

1
2
3


{'name': 'kitty'}
<class '__main__.Cat'>
True

内建函数和方法(built-in functions and methods)

根据定义，内建的(built-in)模块是指使用C写的模块，可以通过sys模块的builtin_module_names字段查看都有哪些模块是内建的。这些模块中的函数和方法可以使用的属性比较少，不过一般也不需要在代码中查看它们的信息。

__doc__: 函数或方法的文档。
__name__: 函数或方法定义时的名字。
__self__: 仅方法可用，如果是绑定的(bound)，则指向调用该方法的类（如果是类方法）或实例（如果是实例方法），否则为None。
__module__: 函数或方法所在的模块名。

abs是Python内置函数，用来返回数值的绝对值。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


print(abs.__doc__)     #输出 Return the absolute value of the argument.
print(abs.__name__)    #输出 abs
print(abs.__module__)  #输出 builtins
print(abs.__self__)    #输出 <module 'builtins' (built-in)>

def func(a, b):
    """打印参数的值"""
    print(a,b)

print(func.__doc__)     #输出 打印参数的值
print(func.__name__)    #输出 func
print(func.__module__)  #输出 __main__
print(func.__self__)    #没有self属性，报错

执行以上程序会输出如下结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


Return the absolute value of the argument.
abs
builtins
<module 'builtins' (built-in)>
打印参数的值
func
__main__
Traceback (most recent call last):
  File "main.py", line 13, in <module>
    print(func.__self__)
AttributeError: 'function' object has no attribute '__self__'

函数(function)

这里特指非内建的函数。注意，在类中使用def定义的是方法，方法与函数虽然有相似的行为，但它们是不同的概念。

__doc__: 函数的文档。
__name__: 函数定义时的函数名。
__module__: 包含该函数定义的模块名；同样注意，是模块名而不是模块对象。
__dict__: 函数的可用属性。
不要忘了函数也是对象，可以使用函数.属性名访问属性（赋值时如果属性不存在将新增一个），或使用内置函数has/get/setattr()访问。不过，在函数中保存属性的意义并不大。
__defaults__: 这个属性保存了函数的参数默认值元组；因为默认值总是靠后的参数才有，所以不使用字典的形式也是可以与参数对应上的。
__code__: 这个属性指向一个该函数对应的code对象，code对象中定义了其他的一些特殊属性，将在下文中另外介绍。
__globals__: 这个属性指向定义函数时的全局命名空间。
__closure__: 这个属性仅当函数是一个闭包时有效，指向一个保存了所引用到的外部函数的变量cell的元组，如果该函数不是一个内部函数，则始终为None。这个属性也是只读的。

下面的代码演示了closure：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


#coding: UTF-8
def foo(a, b=100):
    n = a + b
    def bar():
        print(n) # 引用非全局的外部变量n，构造一个闭包
    n = 2
    return bar

print(foo.__doc__)            #输出 None
print(type(foo.__doc__))      #输出 <class 'NoneType'>
print(foo.__name__)           #输出 foo
print(type(foo.__name__))     #输出 <class 'str'>
print(foo.__module__)         #输出 __main__
print(type(foo.__module__))   #输出 <class 'str'>
print(foo.__dict__)           #输出 {}
print(type(foo.__dict__))     #输出 <class 'dict'>
print(foo.__defaults__)       #输出 (100,)
print(type(foo.__defaults__)) #输出 <class 'tuple'>
print(foo.__code__)           #输出 <code object foo at 0x7fae1eb175d0, file "main.py", line 1>
print(type(foo.__code__))     #输出 <class 'code'>
print(foo.__globals__)        #输出 {'__name__': '__main__',...}
print(type(foo.__globals__))  #输出 <class 'dict'>
print(foo.__closure__)        #输出 None
print(type(foo.__closure__))  #输出 <class 'NoneType'>
closure = foo(10)
print(closure.__closure__)    #输出 (<cell at 0x7fae1eb0f948: int object at 0x7fae1fe4a3e0>,)
print(type(closure.__closure__))  #输出 <class 'tuple'>

执行以上程序会输出如下结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


None
<class 'NoneType'>
foo
<class 'str'>
__main__
<class 'str'>
{}
<class 'dict'>
(100,)
<class 'tuple'>
<code object foo at 0x7fc089be45d0, file "main.py", line 1>
<class 'code'>
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7fc089b7f438>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'main.py', '__cached__': None, 'foo': <function foo at 0x7fc089c50e18>}
<class 'dict'>
None
<class 'NoneType'>
(<cell at 0x7fc089bdcac8: int object at 0x7fc08af173e0>,)
<class 'tuple'>

由这个例子可以看到，遇到未知的对象使用dir()是一个很好的主意：）

方法(method)

方法虽然不是函数，但可以理解为在函数外面加了一层外壳；拿到方法里实际的函数以后，就可以使用2.5节的属性了。

__doc__: 与函数相同。
__name__: 与函数相同。
__module__: 与函数相同。
__func__: 使用这个属性可以拿到方法里实际的函数对象的引用。
__self__: 如果是绑定的(bound)，则指向调用该方法的类（如果是类方法）或实例（如果是实例方法），否则为None。 im_class: 实际调用该方法的类，或实际调用该方法的实例的类。注意不是方法的定义所在的类，如果有继承关系的话。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


class Cat:
    def __init__(self, name='kitty'):
        self.name = name
    def sayHi(self):
        print(self.name, 'says Hi!')

cat = Cat()
im = cat.sayHi
print(im.__func__)          #输出 <function Cat.sayHi at 0x7f06100f51e0>
print(type(im.__func__))    #输出 <class 'function'>
print(im.__self__)          #输出 <__main__.Cat object at 0x7f06100ff9b0>
print(type(im.__self__))    #输出 <class '__main__.Cat'>
print(im.__class__)         #输出 <class 'method'>
print(type(im.__class__))   #输出 <class 'type'>

执行以上程序会输出如下结果：

1
2
3
4
5
6


<function Cat.sayHi at 0x7f06100f51e0>
<class 'function'>
<__main__.Cat object at 0x7f06100ff9b0>
<class '__main__.Cat'>
<class 'method'>
<class 'type'>

这里讨论的是一般的实例方法，另外还有两种特殊的方法分别是类方法(classmethod)和静态方法(staticmethod)。类方法还是方法，不过因为需要使用类名调用，所以他始终是绑定的；而静态方法可以看成是在类的命名空间里的函数（需要使用类名调用的函数），它只能使用函数的属性，不能使用方法的属性。

转载请注明本网址。

文章目录

自省(introspection)

Python内置的自省函数

模块(module)

类(class)

实例(instance)

内建函数和方法(built-in functions and methods)

函数(function)

方法(method)