inspect是专门用来收集python对象的信息的，可以获取参数信息，原码，解析堆栈，判断对象类型等等。下面看看一些主要用法

import inspect
# 1.判断是不是一个模块
import tornado
print(inspect.ismodule(tornado)) # True
# 2.判断是不是一个类
Foo = type("Foo", (object, ), {})
print(inspect.isclass(Foo)) # True
# 3.判断是不是一个方法。说白了就是判断是不是类里面定义的一个函数，
class A:
def m(self):
...
print(inspect.ismethod(A().m), type(A().m)) # True 
# 4.判断是不是一个方法描述符。说白了就是首先得是一个类的实例对象，并且这个类里面定义了__get__方法，且没有定义__set__方法
class A:
def __get__(self, instance, owner):
...
print(inspect.ismethoddescriptor(A()))
# 5.判断是不是一个数据描述符。说白了就是首先得是一个类的实例对象，并且这个类里面定义了__get__方法和__set__方法
class A:
def __get__(self, instance, owner):...
def __set__(self, instance, value):...
print(inspect.isdatadescriptor(A())) # True
# 6.判断是不是一个函数
print(inspect.isfunction(lambda: ...)) # True
# 7.判断是不是一个生成器函数
def foo(): yield 1
print(inspect.isgeneratorfunction(foo)) # True
# 同时生成器函数也是一个函数
print(inspect.isfunction(foo)) # True
# 8.判断是不是一个协程函数,协程函数必须是由async def语法定义的函数，使用types.coroutine或者asyncio.coroutine装饰的函数都不是
async def foo():
...
print(inspect.iscoroutinefunction(foo)) # True
# 9.判断是不是一个异步生成器函数，异步生成器函数是由async def语法定义，并且函数体内部要包含yield的函数
async def foo():
yield 1
print(inspect.isasyncgenfunction(foo)) # True
# 10.判断是不是一个异步生成器，就是异步生成器函数加上小括号
print(inspect.isasyncgen(foo())) # True
# 11.判断是不是一个生成器, 就是生成器函数加上小括号
def gen(): yield 1
print(inspect.isgenerator(gen())) # True
# 12.判断是不是一个协程,就是协程函数加上小括号
async def foo(): ...
print(inspect.iscoroutine(foo())) # True
# 13.判断是不是一个可以awaitable，说白了就是await一个迭代器对象
async def foo():
await [1, 2, 3].__iter__()
print(inspect.isawaitable(foo())) # True
# 14.判断是不是一个栈帧
def foo():
# 该函数可以获取栈帧
frame = inspect.currentframe()
return frame
print(inspect.isframe(foo())) # True
# 15.判断是是不是code
def foo(): ...
print(inspect.iscode(foo.__code__)) # True
# 16.获取成员
class A:
def __init__(self):...
def parse(self): ...
import pprint
pprint.pprint(inspect.getmembers(A))
‘‘‘
[(‘__class__‘, ),
(‘__delattr__‘, ),
(‘__dict__‘,
mappingproxy({‘__dict__‘: ,
‘__doc__‘: None,
‘__init__‘: ,
‘__module__‘: ‘__main__‘,
‘__weakref__‘: ,
‘parse‘: })),
(‘__dir__‘, ),
(‘__doc__‘, None),
(‘__eq__‘, ),
(‘__format__‘, ),
(‘__ge__‘, ),
(‘__getattribute__‘, ),
(‘__gt__‘, ),
(‘__hash__‘, ),
(‘__init__‘, ),
(‘__init_subclass__‘,
),
(‘__le__‘, ),
(‘__lt__‘, ),
(‘__module__‘, ‘__main__‘),
(‘__ne__‘, ),
(‘__new__‘, ),
(‘__reduce__‘, ),
(‘__reduce_ex__‘, ),
(‘__repr__‘, ),
(‘__setattr__‘, ),
(‘__sizeof__‘, ),
(‘__str__‘, ),
(‘__subclasshook__‘,
),
(‘__weakref__‘, ),
(‘parse‘, )]
‘‘‘
# 17.获取mro,包括自己
class A(object): ...
print(inspect.getmro(A)) # (, )
# 18.获取doc
print(inspect.getdoc(int))
‘‘‘
int([x]) -> integer
int(x, base=10) -> integer
Convert a number or string to an integer, or return 0 if no arguments
are given. If x is a number, return x.__int__(). For floating point
numbers, this truncates towards zero.
If x is not a number or if base is given, then x must be a string,
bytes, or bytearray instance representing an integer literal in the
given base. The literal can be preceded by ‘+‘ or ‘-‘ and be surrounded
by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.
Base 0 means to interpret the base from the string as an integer literal.
>>> int(‘0b100‘, base=0)
4
‘‘‘
# 19.查看对象被定义在哪一个文件里面
from pandas import DataFrame
print(inspect.getfile(DataFrame)) # C:\python37\lib\site-packages\pandas\core\frame.py
# 当然也可以是一个模块
import requests
print(inspect.getfile(requests)) # C:\python37\lib\site-packages\requests\__init__.py
# 20.返回一个给定对象的模块名,不过存在不存在,感觉没卵用
print(inspect.getmodulename(r"C:\python37\lib\site-packages\peeaaawee.py")) # peeaaawee
# 21.和getfile类似
print(inspect.getabsfile(DataFrame)) # c:\python37\lib\site-packages\pandas\core\frame.py
# 22.获取参数信息，但需要传入字节码
def foo(a, b=1): ...
print(inspect.getargs(foo.__code__)) # Arguments(args=[‘a‘, ‘b‘], varargs=None, varkw=None)
print(inspect.getargs(foo.__code__).args) # [‘a‘, ‘b‘]
# 23.获取参数信息吗， 传入函数即可
def foo(a, b=1): ...
print(inspect.getfullargspec(foo)) # FullArgSpec(args=[‘a‘, ‘b‘], varargs=None, varkw=None, defaults=(1,), kwonlyargs=[], kwonlydefaults=None, annotations={})
print(foo.__defaults__) # (1,)
import inspect
def bar():
name = "Mashiro"
age = 16
return foo()
def foo():
name = "Satori"
age = 18
return inspect.currentframe()
# frame叫做栈帧，表示当前函数调用栈的某一帧，是一个上下文。正所谓在python中一切皆对象，这个栈帧也是一个对象。
# 函数执行要在相应的栈帧中执行
# 栈帧有一下几大特性，
# f_back：调用者的上一级栈帧
# f_code：字节码
# f_lineno：栈帧所在的哪一行
# frame是定义在foo函数里面，所以currentframe拿到的是foo的栈帧
# 但是又是通过bar来调用的，所以foo的上一级栈帧就是bar的栈帧
f = bar()
print(f.f_back) # 
print(f.f_code) # 
print(f.f_lineno) # 13
# 这个f_code里面也有很多的属性
# co_name：获取栈帧所对应的函数名
print(f.f_code.co_name) # foo
# co_filename：获取相应的文件名
print(f.f_code.co_filename) # D:/乱七八糟的/龙卷风/3.py
print(f.f_back.f_code.co_name) # bar
print(f.f_back.f_code.co_filename) # D:/乱七八糟的/龙卷风/3.py
# 查看当前的局部变量，可以看到由于栈帧还在，所以局部变量依旧存储在堆上
print(f.f_locals) # {‘name‘: ‘Satori‘, ‘age‘: 18}
# 同理它的上一级栈帧也是
print(f.f_back.f_locals) # {‘name‘: ‘Mashiro‘, ‘age‘: 16}
# 如果是生成器的话，就不需要了
def gen():
yield 1
name = ("xxx", )
yield 2
age = 16
yield 3
gender = "f"
yield 4
return
g = gen()
# 生成器有一个gi_frame属性，可以直接获取
print(g.gi_frame.f_locals) # {}
print(next(g)) # 1
print(g.gi_frame.f_locals) # {}
print(next(g)) # 2
print(g.gi_frame.f_locals) # {‘name‘: ‘xxx‘}
print(next(g)) # 3
print(g.gi_frame.f_locals) # {‘name‘: ‘xxx‘, ‘age‘: 16}
print(next(g)) # 4
print(g.gi_frame.f_locals) # {‘name‘: ‘xxx‘, ‘age‘: 16, ‘gender‘: ‘f‘}
try:
next(g)
except StopIteration as e:
print(e.value) # result