
- Python Basic Tutorial
- Python - Home
- Python - Overview
- Python - Environment Setup
- Python - Basic Syntax
- Python - Comments
- Python - Variables
- Python - Data Types
- Python - Operators
- Python - Decision Making
- Python - Loops
- Python - Numbers
- Python - Strings
- Python - Lists
- Python - Tuples
- Python - Dictionary
- Python - Date & Time
- Python - Functions
- Python - Modules
- Python - Files I/O
- Python - Exceptions
How to retrieve source code from Python objects?
Using the inspect module, you can retrieve the source code of a Python function, method, class, or module. The following example demonstrates how to retrieve a function's source code −
Example
import inspect def my_function(x, y): return x + y source_code = inspect.getsource(my_function) print(source_code)
Output
def my_function(x, y): return x + y
This code defines a simple function my function that accepts two arguments and returns the sum of those arguments. We then retrieve the source code of the my function function using the inspect.getsource function and store it in the source code variable. Finally, the source code is output to the console.
The inspect.getsource function operates by reading the function's source code from the file in which it is defined. It returns the function's entire source code as a string, including any comments or blank lines present in the source code.
The inspect.getsourcefile function can also be used to retrieve the filename containing the source code of a function or module. This is helpful if you need to locate the file containing a specific function or module.
The following example demonstrates how to retrieve the file name containing a function's source code −
Example
import inspect def my_function(x, y): return x + y source_file = inspect.getsourcefile(my_function) print(source_file)
Output
/home/cg/root/79120/main.py
This code defines the same my function function as before and retrieves the file name containing the function's source code using the inspect.getsourcefile function. This function returns the file name as a string, and not the actual source code.
The inspect module offers several functions for retrieving information about Python objects, including their source code. Here are some additional examples −
To retrieve the source code of a class method, call inspect.getsource on the method itself −
Example
import inspect class MyClass: def my_method(self, x, y): return x + y source_code = inspect.getsource(MyClass.my_method) print(source_code)
Output
def my_method(self, x, y): return x + y
In this example, the class MyClass has a single method called my method that accepts two arguments and returns their sum. The source code for the MyClass.my method method is then retrieved using inspect.getsource.
To retrieve the source code of a module in its entirety, use the inspect.getsource function on the module itself −
Example
import inspect import my_module source_code = inspect.getsource(my_module) print(source_code)
In this example, we import the my module module and retrieve its source code using inspect.getsource.
You can also use the inspect.getfile function to get the name of the file that holds the source code for a module, class, or function. Similar to inspect.getsourcefile, this function returns the filename as a string. This example demonstrates how to retrieve the filename of a module using inspect.getfile −
Example
import inspect import my_module source_file = inspect.getfile(my_module) print(source_file)
This code imports the my module module and uses inspect.getfile to retrieve the source code file's name. Note that this function returns the file's absolute path.
The dis module is another way to retrieve the source code of a Python function. The dis module gives you a disassembler for Python bytecode, which you can use to look at the bytecode instructions for a function. By decompiling the bytecode, it is possible to gain a more comprehensive understanding of how the function operates, including the exact order of operations.
Here is an example of how to retrieve the bytecode instructions of a function using the dis module −
Example
import dis def my_function(x, y): return x + y bytecode = dis.Bytecode(my_function) for instruction in bytecode: print(instruction)
Output
Instruction(opname='LOAD_FAST', opcode=124, arg=0, argval='x', argrepr='x', offset=0, starts_line=3, is_jump_target=False) Instruction(opname='LOAD_FAST', opcode=124, arg=1, argval='y', argrepr='y', offset=2, starts_line=None, is_jump_target=False) Instruction(opname='BINARY_ADD', opcode=23, arg=None, argval=None, argrepr='', offset=4, starts_line=None, is_jump_target=False) Instruction(opname='RETURN_VALUE', opcode=83, arg=None, argval=None, argrepr='', offset=6, starts_line=None, is_jump_target=False)
In this example, a simple function called my_function is defined that accepts two arguments and returns their sum. A dis.Bytecode object is then created by passing the my_function function to the dis.Bytecode function Object() { [native code] } . This gives us a view of the function's bytecode instructions after they have been taken apart. We can then use a for loop to go through these instructions and print them to the console.
This code will return a series of dis.Instruction objects, which represent the function's bytecode instructions. Each dis.Instruction object includes attributes such as opname (the name of the bytecode instruction), argval (the instruction's argument), and offset (the byte offset of the instruction in the function's bytecode). By looking at these attributes, you can learn everything you need to know about how the function works.
Please be aware that the dis module can be quite low-level and may not be appropriate for all use cases. However, if you need a thorough understanding of how a function operates, it can be a useful tool to have. We use the getsource() method of the inspect module to get the source code of the function.
Example
inspect.getsource(object)
This returns the text of the object's source code. It is possible for the argument to be a module, class, method, function, traceback, frame, or code object. Returns the source code as a single string. If it is not possible to retrieve the source code, an IOError is generated.
If the function is compiled from a string, stream, or imported from a previously compiled file, then its source code cannot be retrieved.
Following is how we import the inspect module and retrieve the source code for a given script
Example
#baz.py import inspect class foo: def bar(): print ('Hello') print(inspect.getsource(foo))
Output
class foo: def bar(): print ('Hello')
- Related Articles
- How to retrieve source code from Python objects?
- Python Code Objects
- Accessing HTML source code using Python Selenium.
- How to retrieve the MSI package product code using PowerShell?
- Retrieve property value selectively from array of objects in JavaScript
- How to retrieve Python module path?
- How can I source a Python file from another Python file?
- Decrypting source message from a code based on some algorithm in JavaScript
- How to Find out the source code of a transaction in SAP?
- How to represent the source code of an object with JavaScript Arrays?
- How to access Python objects within objects in Python?
- How to retrieve multiple elements from a series when the index is customized Python?
- How to retrieve cookies in Python CGI Programming?
- How to Fetch source code of the transaction note in SAP R/3?
- How to decompile Android DEX (VM bytecode) files into corresponding Java source code?
- Source code of ABAP reports without restriction
