Python Modules & Packages

Introduction

When writing Python programs, you might find yourself needing to use the same functions or classes across multiple scripts. Instead of rewriting the same code multiple times, you can organize your code into modules and packages. This makes your code more reusable and easier to maintain.

What is a Module?

A module is simply a file containing Python code. This code can define functions, classes, and variables that you can use in other Python files. Modules help you to organize your code logically.

Creating a Module

Let’s create a simple module. Suppose we want a module that contains functions for basic math operations. We can create a file called mymath.py:

# mymath.py

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

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

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

def divide(a, b):
    if b != 0:
        return a / b
    else:
        return "Division by zero error"

Using a Module

To use the functions in our mymath module, we need to import it into another Python file. Let’s create a new file called main.py:

# main.py

import mymath

print(mymath.add(10, 5))          # Output: 15
print(mymath.subtract(10, 5))     # Output: 5
print(mymath.multiply(10, 5))     # Output: 50
print(mymath.divide(10, 5))       # Output: 2.0

Directories vs Packages and Structure of Packages

What is a Package?

A package is a way of organizing related modules into a directory hierarchy. A package is simply a directory that contains a special __init__.py file, which can be empty. This __init__.py file tells Python that this directory should be treated as a package.

Creating a Package

Let’s create a package called mypackage with two modules: mymath and mystring. The structure of our package will look like this:

mypackage/
    __init__.py
    mymath.py
    mystring.py

Here is the code for mymath.py inside the mypackage:

# mypackage/mymath.py

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

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

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

def divide(a, b):
    if b != 0:
        return a / b
    else:
        return "Division by zero error"

And here is the code for mystring.py inside the mypackage:

# mypackage/mystring.py

def to_uppercase(s):
    return s.upper()

def to_lowercase(s):
    return s.lower()

def capitalize(s):
    return s.capitalize()

Using a Package

To use the functions from the modules in our package, we can import them like this in a new file called main.py:

# main.py

from mypackage import mymath, mystring

# Using functions from mymath module
result_add = mymath.add(5, 3)
result_subtract = mymath.subtract(5, 3)
result_multiply = mymath.multiply(5, 3)
result_divide = mymath.divide(10, 2)

print("Results from mymath module:")
print("Addition:", result_add)
print("Subtraction:", result_subtract)
print("Multiplication:", result_multiply)
print("Division:", result_divide)

# Using functions from mystring module
string = "hello world"
result_upper = mystring.to_uppercase(string)
result_lower = mystring.to_lowercase(string)
result_capitalize = mystring.capitalize(string)

print("\nResults from mystring module:")
print("Uppercase:", result_upper)
print("Lowercase:", result_lower)
print("Capitalized:", result_capitalize)

In this main.py script:

• We import mymath and mystring from the mypackage.
• We then use functions add, subtract, multiply, and divide from mymath, demonstrating basic arithmetic operations.
• Next, we utilize to_uppercase, to_lowercase, and capitalize functions from mystring, showcasing string manipulation.

Make sure your directory structure looks like this:

mypackage/
    __init__.py
    mymath.py
    mystring.py
main.py

When you run main.py, it will output the results of mathematical operations and string manipulations performed using functions imported from the mypackage modules. This demonstrates how to effectively use modules within a package in Python.

Summary

• Modules are Python files containing definitions and statements.
• Packages are directories of Python modules.
• Importing allows you to use functions and variables from modules and packages.

Modules and packages help keep your code organized and encourage code reuse, making Python a powerful and flexible programming language.

This should give you a good starting point to understand modules and packages in Python. Happy coding!