import inspect
class A:
print(inspect.isclass(A))
Example 2: In this example, we are checking whether a given object is a module or not. We import the numpy module and then pass it to inspect.ismodule(). If the object passed is a module, the method returns True.
Python
import inspect
import numpy
print(inspect.ismodule(numpy))
Example 3: In this example, we check if an object is a user-defined function. The function fun returns double the input. Passing it to isfunction() returns True since it's a valid function.
Python
import inspect
def fun(a):
return 2 * a
print(inspect.isfunction(fun))
Example 4: In this example, we use inspect.ismethod() to check if collections.Counter is a method. Since Counter is a class and not a method, ismethod() returns False.
Python
import inspect
import collections
print(inspect.ismethod(collections.Counter))
Methods to Retrieve the Source of Token
Inspect module also provides methods to retrieve the source of an object, such as inspecting class hierarchies, member functions, or function signatures. These tools help you understand the structure and source details of objects in your code.
Method | Description |
|---|
getclasstree(classes) | Returns a nested list of tuples showing the class hierarchy |
|---|
getmembers(obj) | Returns all the members of an object as (name, value) pairs |
|---|
signature(callable) | Returns the call signature of a function/method |
|---|
stack() | Returns the call stack at the point where it's called |
|---|
getmodule(obj) | Returns the module in which an object was defined |
|---|
getdoc(obj) | Returns the docstring of the object |
|---|
Example 1: In this example, we inspect the class hierarchy of C, which inherits from B and B inherits from A. We use inspect.getmro(C) to get the method resolution order and pass it to inspect.getclasstree() to get a structured inheritance tree.
Python
import inspect
class A: pass
class B(A): pass
class C(B): pass
t = inspect.getclasstree(inspect.getmro(C))
for i in t:
print(i)
Output(<class 'object'>, ())
[(<class '__main__.A'>, (<class 'object'>,)), [(<class '__main__.B'>, (<class '__main__.A'>,)), [(<class '__main__.C'>, (<class '__main__.B'>,))]]]
Example 2: In this example, we use inspect.getmembers() to fetch members of the math module and print the names and types of the first five.
Python
import inspect
import math
for n, m in inspect.getmembers(math)[:5]:
print(n, type(m))
Output__doc__ <class 'str'>
__file__ <class 'str'>
__loader__ <class '_frozen_importlib_external.ExtensionFileLoader'>
__name__ <class 'str'>
__package__ <class 'str'>
Example 3: In this example, we use inspect.signature() to get the signature of the greet function, showing its parameters and default values.
Python
import inspect
def greet(name, age=18):
return f"Hello {name}, age {age}"
s = inspect.signature(greet)
print(s)
Example 4: In this example, we use inspect.stack() to retrieve the current call stack. We then print the function names and line numbers of the top two stack frames.
Python
import inspect
def test():
stk = inspect.stack()
for f in stk[:2]: # Showing top 2 stack frames
print(f"Function: {f.function}, Line No: {f.lineno}")
test()
OutputFunction: test, Line No: 4
Function: <module>, Line No: 8
Example 5: In this example, we use inspect.getmodule() to retrieve the module that the math.sin function belongs to. We then print the name of the module using m.__name__.
Python
import inspect
import math
m = inspect.getmodule(math.sin)
print(m.__name__)
Example 6: In this example, we use inspect.getdoc() to fetch the docstring of the fun function, which describes its purpose returning the product of x and y.
Python
import inspect
def fun(x, y):
"""Returns the product of x and y."""
return x * y
print(inspect.getdoc(fun))
OutputReturns the product of x and y.
We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
Privacy Policy
Got It !
