How we can bundle multiple python modules?

Working with complex programs that run for thousands of lines produces two fundamental problems arise – managing the code to know which functionality is implemented where and debugging the program in case of an error. Fortunately, both problems can be solved by breaking the code into multiple modules and then creating a single script file from the different modules.

Python provides this exact functionality where different python modules can be bundled into a single executable script. This functionality allows for easy management and debugging of complex programs.

Using zip

One way of bundling multiple modules in python is by creating a zip file from the different modules and then executing the zip file in python terminal. To use this method first step is to define the different modules making sure that one module is named, which allows the compiler to know where the program execution will start.

The modules should then be zipped into a single file which can then be executed to get the output.


Following is the syntax of executing zip file in python −



In this example the first step is to define module which imports fibonacci function from sum_fibonacci module and passes value 10 to the function.

from sum_fibonacci import fibonacci output = fibonacci(10) print(output)

The fibonacci function defined in sum_fibonacci module is used to calculate the sum of first 10 numbers in the fibonacci series and return the value to the main module.

def fibonacci(term): first_val = 0 second_val = 1 sum_fibonacci = 0 for num in range(0, term): sum_fibonacci = sum_fibonacci + first_val next_val = first_val + second_val first_val = second_val second_val = next_val return sum_fibonacci

The main module and sum_fibonacci module are then zipped into, which can then be executed using the code below to get the desired output.



The output gives the sum of first 10 numbers in the Fibonacci series.


Using stickytape

Another way of bundling multiple modules in python is by using stickytape command. To use stickytape, first step is to define the different modules that need to be bundled, in which one module should be named, since execution starts from this module.

Once all the modules are defined, then stickytape can be used on main module in python shell to automatically create a single script file that can be executed to get the output of the code.


Following is the syntax to create single file using stickytape −

stickytape >


The first step is to define module from where the execution of program starts. The main module imports members of the other modules and is used for calling those members.

# Importing the members of the modules from calculate import Calculation from fact_find import factorial # Calling method of Calculation class in calculate module calc = Calculation(value=5) # Calling the factorial function in fact_find module output = factorial(calc.value) print(output)

Calculation class in module is defined next to receive the value from main module and assign it to self.value object.

class Calculation: def __init__(self, value): self.value = value # assigning 5 as value

Factorial function in fact_find module is then defined to recursively calculate the factorial of 5.

factorial(fact): if fact == 1: return fact else: return fact*factorial(fact-1) # recursive function to find factorial

Finally, stickytape is used to bundle all the modules into which can then be run to get the output of the program.

# Creating a single file which bundles all the modules stickytape >


The output is the factorial of 5.