Modules and Packages

Introduction

In this lab, we will explore how to use Python modules and packages to organize and reuse code. We will start with simple examples and gradually build up to more complex ones. By the end of this lab, you will have a solid understanding of how to use modules and packages in your own projects.

Achievements

• Python Modules
• Python Packages
• PyPI

Skills Graph

What Are Python Modules and Packages?

A module in Python is a file that contains definitions of functions, classes, and variables. We can use modules to break up large programs into smaller, more manageable pieces. Modules also make it easy to reuse code across multiple projects.

A package is a collection of modules. Packages allow us to group related modules together and access them using a simple dot notation.

There are several categories of Python modules and packages:

1. Built-in modules: These are modules that are included with the Python interpreter and are available to all Python programs. Examples of built-in modules include math, os, sys, and random.
2. Standard library modules: These are modules that are part of the Python standard library, but are not built into the interpreter. They can be imported and used in the same way as built-in modules. Examples of standard library modules include json, urllib, re, and csv.
3. Third-party modules: These are modules that are developed and maintained by individuals or organizations outside of the Python core development team. They can be imported and used in the same way as built-in and standard library modules, but they need to be installed separately. There are many third-party modules available, covering a wide range of topics and purposes. Some examples include numpy, pandas, requests, and beautifulsoup4.
4. Local modules: These are modules that are located in the same directory as the Python program that is using them. We can import local modules using the import statement and the module name, without specifying the full path.
5. Relative imports: These are imports that are relative to the current package or module. They allow us to import modules and packages that are located in a different directory than the current one. We can use relative imports to import modules and packages that are part of the same project, but are organized in a different directory structure.

In summary, Python modules and packages can be classified based on where they come from and how they are accessed. Built-in and standard library modules are included with the Python interpreter and are available to all Python programs, while third-party modules need to be installed separately. Local modules and relative imports allow us to import modules and packages that are located in the same project, but in a different directory structure.

Here is an example of how to use one of the built-in Python modules, the math module.

Open up a new Python interpreter session and type the following code:

python3

import math

## Calculate the square root of 16
x = math.sqrt(16)
print(x)  ## Output: 4.0

## Calculate the sine of pi
y = math.sin(math.pi)
print(y)  ## Output: 1.2246467991473532e-16

## Calculate the factorial of 5
z = math.factorial(5)
print(z)  ## Output: 120

The math module is a built-in Python module that provides mathematical functions and constants. Some of the functions available in the math module include sqrt(), sin(), cos(), tan(), log(), exp(), and factorial(). The math module also provides constants such as pi and e.

We can use the import statement to import the math module and then call its functions and access its constants in our code.

In the example above, we use the sqrt() function to calculate the square root of 16, the sin() function to calculate the sine of pi, and the factorial() function to calculate the factorial of 5. We also use the pi constant to represent the value of pi in the call to the sin() function.

There are many other built-in Python modules that provide useful functions and constants. Some examples include the os module for interacting with the operating system, the datetime module for working with dates and times, and the random module for generating random numbers. You can find a complete list of the built-in Python modules in the documentation.

Create a Python Module

In this step, we will create a Python module. A module is a file that contains Python code.

Here is a simple example of how to create and use a Python module:

First, create a new file called my_module.py in the path /home/labex/project/. This will be our module file.

In the my_module.py file, define a function called say_hello() that prints a greeting to the console:

def say_hello():
    print("Hello from my_module!")

Save the file.

Now, open a new Python file (or enter the Python interpreter) and import the my_module module using the import statement:

import my_module

To use the say_hello() function from the my_module module, we can call it like this:

my_module.say_hello()  ## Output: "Hello from my_module!"

That's it! We've successfully created and used a Python module.

ImportError Exception

Note that when we import a module, Python looks for the module file in the current directory, as well as in any directories listed in the PYTHONPATH environment variable. If the module file is not found, we'll get an ImportError exception.

Let's try to import a module that doesn't exist.

Open a new terminal window and change the current directory to /home/labex/:

cd /home/labex/

Now, open a new Python interpreter and try to import the my_module module:

python3

import my_module

You should get an ImportError exception:

ModuleNotFoundError: No module named 'my_module'

You can add a directory to the PYTHONPATH environment variable by adding the following line to your Python file:

import sys
## my_module.py is located in the /home/labex/project/ directory
sys.path.append("/home/labex/project")

import my_module
my_module.say_hello()

Note that the sys.path.append() function must be called before the import statement.

Create a Python Packages

In this step, we will create a Python package. A package is a directory that contains Python modules.

Let's upgrade the example from the previous step.

First, create a new directory called my_package in the path /home/labex/project/. This will be our package directory.

Inside the /home/labex/project/my_package directory, create a new file called __init__.py. This is a special file that tells Python that the my_package directory should be treated as a package.

Inside the my_package directory, create a new file called my_module.py. This will be our module file.

In the my_module.py file, define a function called say_hello() that prints a greeting to the console:

def say_hello():
    print("Hello from my_module!")

Now, open a new Python file (or enter the Python interpreter) and import the my_package package:

import my_package

To use the say_hello() function from the my_module module, we can call it like this:

my_package.my_module.say_hello()  ## Output: "Hello from my_module!"

That's it! We've successfully created and used a Python package with a module.

Here is the directory structure of our project:

my_package/
├── __init__.py
└── my_module.py

This example shows how we can create a package and access its modules using the dot notation. The my_package package contains the my_module module, and we can access the say_hello() function from the my_module module by calling my_package.my_module.say_hello().

In this context, my_package is a Python package and my_module is a Python module. Packages allow us to organize our code in a hierarchical structure, which can be helpful for larger projects with many modules.

In summary, the main difference between a package and a module is that a package is a collection of modules that can be accessed using a dot notation, while a module is a standalone file that contains definitions of functions, classes, and variables.

Third-Party Packages

Python third-party packages are packages that are developed and maintained by individuals or organizations outside of the Python core development team. They can be imported and used in the same way as built-in and standard library modules, but they need to be installed separately.

There are many third-party packages available for Python, covering a wide range of topics and purposes. Some examples include numpy for scientific computing, pandas for data analysis, requests for working with HTTP requests, and beautifulsoup4 for web scraping.

The most important reason Python is so popular is the abundance of Third-Party Packages.

To install a third-party package, we can use the pip package manager, which is included with Python by default. For example, to install the requests package, we can run the following command:

pip install requests

We can also use other package managers such as conda to install third-party packages. See the Anaconda for more information.

Once the package is installed, we can import it and use it in our Python code. For example, here is how we can use the requests package to send an HTTP request and print the response:

python3

import requests

response = requests.get("https://www.example.com")
print(response.text)

This code sends an HTTP GET request to the URL https://www.example.com using the requests package, and then prints the response text to the console.

The requests.get() function sends an HTTP GET request to the specified URL and returns an HTTPResponse object that contains the response data. The response object has various attributes and methods that allow us to access and manipulate the response data.

In this case, the response.text attribute contains the response body as a string. By calling print(response.text), we are printing the response body to the console.

Python third-party packages are an important part of the Python ecosystem, as they provide ready-made solutions for common tasks and extend the functionality of Python. They can save us time and effort by providing pre-built solutions that we can use in our projects, rather than having to build everything from scratch.

In addition to the time and effort saved by using third-party packages, they can also help us write more reliable and maintainable code. By using well-tested, widely-used packages, we can leverage the work of others and focus on solving our specific problem.

Overall, Python third-party packages are an important resource for extending the functionality of Python and for solving common tasks. They can save us time and effort, help us integrate with other tools and libraries, and contribute to the reliability and maintainability of our code.

Summary

In this lab, we learned how to use Python modules and packages to organize and reuse code. We saw how to import and use modules and packages in our programs, and we also learned how to create our own packages. By using modules and packages, we can write cleaner, more maintainable code.