Understand Python Packages in Details

Last Updated on October 16, 2023 by Ankit Kochar

Python, known for its simplicity and versatility, has grown into one of the world’s most popular programming languages. One of its key strengths is its modular and organized structure, made possible by the use of packages. Python packages are a fundamental component of the language, allowing developers to organize their code into reusable modules, making code management and distribution more efficient.

In this comprehensive guide, we will delve into the world of Python packages, exploring what they are, how they work, and why they are crucial for software development. Whether you’re a beginner looking to understand the basics or an experienced Pythonista seeking to master package management, this article will provide you with the knowledge and insights you need to harness the full potential of Python packages.

What are Packages in Python?

A Python package is a module-level organization of code that allows for code reuse, modularity, and abstraction. It is a directory structure that contains Python modules, sub-packages, and other resources like data files, etc.

Example of Python Packages

An example of a Python package is the NumPy package, which stands for Numerical Python. It provides support for arrays and matrices and includes functions for numerical operations, linear algebra, and random number generation. It is commonly used for scientific and engineering applications.

To install the NumPy package in your device enter the below command in the terminal or command line.

pip install numpy

After completion of the installation, use the below statement in your code to use the numpy module.

import numpy as np

Let’s see how we can use the above python package in a python code.

import numpy as np

matrix = np.zeros([3, 3])
print("\nMatrix : \n", matrix)

Output:

Matrix : 
 [[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

Lets see how to create a python package.

How to Create a Python Package?

Following the below simple steps you can create your own python packages.

• Choose a name for your package and create a directory with that name.
• Create an init.py file in the package directory. This file can be empty, but it signals to Python that this directory should be considered a package.
• Create one or more Python modules (i.e., .py files) in the package directory, containing the functions and classes you want to include in your package.
• Define the package’s API in the init.py file. This can include importing modules and sub-packages and defining variables and functions that should be exposed to users of the package.
• Write documentation for your package, describing what it does and how to use it.

Now, let’s see how we can create a python package using the above steps.

We will create a calculator package with modules addition, subtraction, multiplication, and division.

Now, let’s create all these modules.

addition.py

def add(a,b):
    return a+b

subtraction.py

def sub(a,b):
    return a-b

multiplication.py

def mul(a,b):
    return a*b

division.py

def div(a,b):
    return a/b

Below is the folder structure of the python package.

calculator

     |
     |
     |------ __init__.py
     |
     |
     |------ addition.py
     |      |
     |      |---------- add()
     |
     |
     |------ subtraction.py
     |      |
     |      |---------- sub()
     |
     |
     |------ multiplication.py
     |      |
     |      |---------- mul()
     |
     |
     |------ division.py
        |
        |---------- div()

Why to use init.py?

init.py file is used to define the package’s API and can be empty or can contain code that initializes the package. We can also mention specific functions from the module to use in this file. Let’s see how the init.py file look.

init.py

from .addition import add
from .subtraction import sub
from .multiplication import mul
from .division import div

Lets see how to import modules from packages in Python.

How to Import Modules from the Python Packages.

We can import modules from the python packages using import and from keyword and using . operator. The syntax to import the module from the python packages is given below.

Syntax:

Import package_name.mudule_name

Example: Program to import modules from the package
In this example, we will import the module from the package, and then we will use the functions of that python package.

Code:

from calculator import addition
from calculator import subtraction
from calculator import multiplication
from calculator import division

print("Addition of 8 and 4 is:", addition.add(8, 4))
print("Subtraction of 7 and 2 is:", subtraction.sub(7, 2))
print("Multiplication of 3 and 4 is:", multiplication.mul(3, 4))
print("Division of 12 and 3 is:", division.div(12, 3))

Output:

Addition of 8 and 4 is: 12
Subtraction of 7 and 2 is: 5
Multiplication of 3 and 4 is: 12
Division of 12 and 3 is: 4.0

Example: Program to import specific function from the module
In this example, we will directly import the specific function from the module of the python package.

Code:

from calculator.addition import add
from calculator.subtraction import sub
from calculator.multiplication import mul
from calculator.division import div

print("Addition of 5 and 4 is:", add(5, 4))
print("Subtraction of 10 and 2 is:", sub(10, 2))
print("Multiplication of 3 and 4 is:", mul(3, 4))
print("Division of 12 and 3 is:", div(12, 3))

Output:

Addition of 5 and 4 is: 9
Subtraction of 10 and 2 is: 8
Multiplication of 3 and 4 is: 12
Division of 12 and 3 is: 4.0

Conclusion
Python packages are the backbone of modular and organized Python programming. They enable developers to create reusable code, enhance code organization, and simplify code distribution. Throughout this guide, we’ve explored the ins and outs of Python packages, from their structure and creation to their use in practical applications.

As you continue your Python journey, remember that packages are not just a technical aspect of the language; they are a powerful tool that can significantly improve your code’s maintainability, scalability, and reusability. Whether you’re building small scripts or large-scale applications, mastering Python packages is a skill that will serve you well.

FAQs Related to Python Packages

Here are some FAQs related to Packages in Python.

1. What is the difference between a python module and a python package?
A module is a single file that contains Python code and can be imported into other Python files. A package is a collection of modules organized into a directory structure. Packages provide a way to distribute and reuse code and organize modules into a logical structure.

2. How do I create my own Python package?
To create a Python package, you need to organize your modules into directories and include an init.py file in each directory. This file can be empty or contain package-level initialization code.

3. What is the purpose of the init.py file in a Python package?
The init.py file serves as an indicator to Python that a directory should be treated as a package. It can also contain package-level initialization code that runs when the package is imported.

4. How can I install and use third-party packages from PyPI (Python Package Index)?
You can use the pip command to install packages from PyPI. For example, to install the requests package, you can run pip install requests. Once installed, you can import and use the package in your Python code.

5. What are virtual environments, and why are they important when working with Python packages?
Virtual environments are isolated environments that allow you to manage dependencies and package versions for different projects. They prevent conflicts between packages used in different projects and ensure project-specific package installations.

6. Can I share my Python packages with others?
Yes, you can share your Python packages with others by publishing them on PyPI or by distributing them as source code or binary distributions. The setuptools library is commonly used to package and distribute Python projects.