Skip to content

Easily Reloading Python Modules: A Step-by-Step Guide


Python Reload Module

In Python programming, modules play a crucial role in organizing code and promoting reusability. Once a module is imported, it is only loaded once per interpreter session, which can be efficient for function and class definitions. However, if a module also contains executable statements for initialization, these statements will only be executed the first time the module is imported.

But what if you make changes to a module and need to reload it without restarting the interpreter? In such cases, the reload() function from the importlib module can be used.

Here is a step-by-step guide on how to reload a module in Python:

Step 1: Understanding the Need for Reloading a Module

Before diving into the reloading process, let’s first understand when and why reloading a module might be necessary.

  • When you make changes to a module’s code and want the changes to take effect without restarting the interpreter.
  • In interactive environments like Jupyter notebooks, where restarting the session might not be convenient.
  • When the current state of the module is not clear, and you want to ensure that the latest changes are reflected.

Step 2: Examining the Initial Module

To illustrate the reloading process, let’s consider a module named Here’s the initial content of the module:

s = "Computers are useless. They can only give you answers."
a = [100, 200, 300]
def printy(arg):
print(f'arg = {arg}')
class Classy:
print(f'a = {a}')

Step 3: Importing and Checking the Initial Module

Now, let’s import the mod module and see its behavior.

import mod
a = [100, 200, 300]
import mod

The output would be:

[100, 200, 300]
"Computers are useless. They can only give you answers."

As you can observe, the print statement inside is executed only once, even when the module is imported multiple times. This behavior is due to the module being loaded only once per interpreter session.

Step 4: Making Changes to the Module

Now, let’s make some changes to the module. Modify the print() statement to include the string “is equal” before the value of a.

s = "Computers are useless. They can only give you answers."
a = [100, 200, 300]
def printy(arg):
print(f'arg = {arg}')
class Classy:
print(f'a is equal {a}')

Step 5: Importing the Module and Verifying Changes

If you try importing the module again without restarting the interpreter, you won’t see any changes. The modified print statement will not be executed.

To overcome this, you can either restart the interpreter or use the reload() function from the importlib module.

Step 6: Reloading the Module using importlib.reload()

To reload the module without restarting the interpreter, follow these steps:

  1. Import the importlib module: import importlib
  2. Call the reload() function, passing the module you want to reload as an argument. In this case, the module’s name is mod.
import importlib

After reloading the module, the modified print statement will now execute, reflecting the changes made to the module.

Step 7: Consequences of Reloading Modules with Dependencies

When you reload a module, it only reloads that specific module. If the module has dependencies on other modules, they won’t be automatically reloaded.

If you have modules with dependencies and need to reload all of them, you will have to reload them individually or write a script to handle the reloading process for you.


Reloading a module in Python can be useful when you need to make changes to the module’s code without restarting the interpreter. By using the reload() function from the importlib module, you can update the module and see the changes take effect immediately.

Remember that reloading a module is not the default behavior in Python, as modules are usually loaded only once per interpreter session. However, understanding the reloading process can be beneficial for developers working with complex codebases and interactive environments.

Explore the importlib module’s documentation for more details on reloading modules and managing dependencies. Keep in mind that reloading modules should be used judiciously, as it can introduce complexities and potential issues if not handled carefully.

Note: The sample code provided in this article assumes you have the required module files and proper Python environment setup.