Packages

A package is a way of organizing related modules into a single directory hierarchy. Packages help you organize large codebases and create reusable libraries.

What is a Package?

A package is a directory containing:

Python modules (.py files)
An __init__.py file (makes the directory a package)
Optionally, subpackages (nested directories with their own __init__.py)

Package Structure

Here’s a typical package structure:

1
my_package/
2
    __init__.py
3
    module1.py
4
    module2.py
5
    subpackage/
6
        __init__.py
7
        module3.py
8
        module4.py

The `init.py` File

The __init__.py file makes a directory a Python package. It can be:

Empty (just marks the directory as a package)
Contains initialization code
Controls what gets imported with from package import *

Empty `init.py`

1
# __init__.py
2
# Empty file - just marks directory as package

`init.py` with Initialization

1
# __init__.py
2
"""My Package - A collection of useful utilities."""
3

4
# Import commonly used items
5
from .module1 import function1, function2
6
from .module2 import Class1
7

8
# Package-level variables
9
__version__ = "1.0.0"
10
__author__ = "Your Name"
11

12
# Define what gets imported with *
13
__all__ = ['function1', 'function2', 'Class1']

Creating a Simple Package

Let’s create a simple package step by step:

Step 1: Create Directory Structure

1
calculator/
2
    __init__.py
3
    basic.py
4
    advanced.py

Step 2: Create Modules

1
# calculator/basic.py
2
def add(a, b):
3
    return a + b
4

5
def subtract(a, b):
6
    return a - b
7

8
def multiply(a, b):
9
    return a * b
10

11
def divide(a, b):
12
    if b == 0:
13
        raise ValueError("Cannot divide by zero")
14
    return a / b

1
# calculator/advanced.py
2
import math
3

4
def power(a, b):
5
    return a ** b
6

7
def sqrt(a):
8
    return math.sqrt(a)
9

10
def factorial(n):
11
    return math.factorial(n)

Step 3: Create `init.py`

1
# calculator/__init__.py
2
"""Calculator package for basic and advanced operations."""
3

4
from .basic import add, subtract, multiply, divide
5
from .advanced import power, sqrt, factorial
6

7
__all__ = ['add', 'subtract', 'multiply', 'divide', 'power', 'sqrt', 'factorial']

Step 4: Use the Package

1
# Import from package
2
from calculator import add, multiply, power
3

4
result1 = add(5, 3)
5
result2 = multiply(4, 7)
6
result3 = power(2, 8)
7

8
print(result1)  # 8
9
print(result2)  # 28
10
print(result3)  # 256

Package Import Methods

Method 1: Import Package

1
import calculator
2

3
# Access through package name
4
result = calculator.basic.add(5, 3)

Method 2: Import Module from Package

1
from calculator import basic
2

3
result = basic.add(5, 3)

Method 3: Import Function from Package

1
from calculator import add
2

3
result = add(5, 3)

Method 4: Import from Subpackage

1
from calculator.advanced import power
2

3
result = power(2, 8)

Nested Packages (Subpackages)

You can create packages within packages:

1
my_package/
2
    __init__.py
3
    utils/
4
        __init__.py
5
        string_utils.py
6
        math_utils.py
7
    data/
8
        __init__.py
9
        processors.py
10
        validators.py

Importing from Subpackages

1
from my_package.utils import string_utils
2
from my_package.data import processors
3

4
# Or
5
from my_package.utils.string_utils import function_name

Package Initialization

The __init__.py file runs when the package is first imported:

1
# my_package/__init__.py
2
print("Package is being imported!")
3

4
def initialize():
5
    print("Package initialized")
6

7
# This runs on import
8
initialize()

Package-Level Variables

You can define package-level variables in __init__.py:

1
# my_package/__init__.py
2
__version__ = "1.0.0"
3
__author__ = "Your Name"
4
__license__ = "MIT"
5

6
# Access from outside
7
# import my_package
8
# print(my_package.__version__)

Controlling Package Exports

Use __all__ to control what gets imported with from package import *:

1
# my_package/__init__.py
2
from .module1 import func1, func2
3
from .module2 import Class1
4

5
# Only these will be imported with *
6
__all__ = ['func1', 'func2', 'Class1']

Package Example: Math Utilities

Let’s create a complete example:

Directory Structure

1
math_utils/
2
    __init__.py
3
    basic.py
4
    geometry.py
5
    statistics.py

Module Files

1
# math_utils/basic.py
2
def add(a, b):
3
    return a + b
4

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

1
# math_utils/geometry.py
2
import math
3

4
def circle_area(radius):
5
    return math.pi * radius ** 2
6

7
def rectangle_area(length, width):
8
    return length * width

1
# math_utils/statistics.py
2
def mean(numbers):
3
    return sum(numbers) / len(numbers)
4

5
def median(numbers):
6
    sorted_nums = sorted(numbers)
7
    n = len(sorted_nums)
8
    if n % 2 == 0:
9
        return (sorted_nums[n//2 - 1] + sorted_nums[n//2]) / 2
10
    return sorted_nums[n//2]

Package Init

1
# math_utils/__init__.py
2
"""Math utilities package."""
3

4
from .basic import add, multiply
5
from .geometry import circle_area, rectangle_area
6
from .statistics import mean, median
7

8
__version__ = "1.0.0"
9
__all__ = ['add', 'multiply', 'circle_area', 'rectangle_area', 'mean', 'median']

Using the Package

1
from math_utils import add, circle_area, mean
2

3
# Basic operations
4
result = add(5, 3)
5
print(result)  # 8
6

7
# Geometry
8
area = circle_area(5)
9
print(area)  # 78.53981633974483
10

11
# Statistics
12
avg = mean([1, 2, 3, 4, 5])
13
print(avg)  # 3.0

Package Best Practices

Use __init__.py: Always include it, even if empty
Organize logically: Group related modules together
Document packages: Add docstrings to __init__.py
Use __all__: Control what gets exported
Keep it simple: Don’t create unnecessary nesting
Version your packages: Include version info in __init__.py

Package vs Module

Module: A single .py file
Package: A directory containing multiple modules and an __init__.py file

Create a simple package structure. You have a package called utils with a module string_utils.py containing a function uppercase(text). Write code to import and use this function. Assume the package structure exists.

Answer:

1
# Assuming utils package exists:
2
#     __init__.py
3
#     string_utils.py
4

5
# In string_utils.py:
6
# def uppercase(text):
7
#     return text.upper()
8

9
# Import and use
10
from utils.string_utils import uppercase
11

12
text = input()
13
result = uppercase(text)
14
print(result)

Exercise 2: Package Import Methods

Given a package math_ops with module basic.py containing add(a, b), demonstrate three different ways to import and use this function. Use method 3 (direct function import) and calculate add(10, 20).

Answer:

1
# Method 1: import package
2
# import math_ops
3
# result = math_ops.basic.add(10, 20)
4

5
# Method 2: import module
6
# from math_ops import basic
7
# result = basic.add(10, 20)
8

9
# Method 3: import function (using this)
10
from math_ops.basic import add
11

12
result = add(10, 20)
13
print(result)

Packages

Table of Contents

Table of Contents

Course Progress

Packages

What is a Package?

Package Structure

The `init.py` File

Empty `init.py`

`init.py` with Initialization

Creating a Simple Package

Step 1: Create Directory Structure

Step 2: Create Modules

Step 3: Create `init.py`

Step 4: Use the Package

Package Import Methods

Method 1: Import Package

Method 2: Import Module from Package

Method 3: Import Function from Package

Method 4: Import from Subpackage

Nested Packages (Subpackages)

Importing from Subpackages

Package Initialization

Package-Level Variables

Controlling Package Exports

Package Example: Math Utilities

Directory Structure

Module Files

Package Init

Using the Package

Package Best Practices

Package vs Module

Exercises

Exercise 1: Understanding Package Structure

Understanding Package Structure

Exercise 2: Package Import Methods

Package Import Methods

Course Progress