What Are Packages in Python? Absolute Beginners Tutorial

Python packages are collections of reusable code that other developers have written and made available for you to use in your own programs. Learning how packages work — and how to find, install, and import them — is one of the most practical skills you can pick up as a beginner.

When you first start writing Python, you write everything yourself in a single file. That works fine for small scripts, but programs quickly grow to the point where keeping all your code in one place becomes difficult to manage. Python's solution to this is the module and package system — a way to split code across files and directories, and to pull in code written by others without rewriting it from scratch.

What Is a Module?

Before understanding packages, you need a clear picture of what a module is. A module is simply a Python file — any file that ends in .py. If you create a file called greetings.py and write a function inside it, that file is a module. Another Python file can then load and use that function by importing it.

# greetings.py  — this file is a module

def say_hello(name):
    return f"Hello, {name}!"

def say_goodbye(name):
    return f"Goodbye, {name}!"

Another file in the same folder can import that module and call its functions:

# main.py

import greetings

print(greetings.say_hello("Maya"))   # Hello, Maya!
print(greetings.say_goodbye("Maya")) # Goodbye, Maya!

You can also import only the specific function you need using the from keyword:

from greetings import say_hello

print(say_hello("Carlos"))  # Hello, Carlos!

What Is a Package?

A package is a directory — a folder — that contains one or more module files. What makes a directory a Python package rather than just a folder is the presence of a file called __init__.py inside it. That file can be completely empty; its presence alone signals to Python that this directory should be treated as a package.

Here is what a simple package structure looks like on disk:

my_project/
├── main.py
└── utils/
    ├── __init__.py
    ├── math_helpers.py
    └── text_helpers.py

In this layout, utils is a package. It contains two modules: math_helpers and text_helpers. You import from that package like this:

# From main.py, import a function from the utils package
from utils.math_helpers import round_to_two

result = round_to_two(3.14159)
print(result)  # 3.14

Packages can also be nested. A package can contain sub-packages, which themselves contain modules. This is how large libraries like email and xml in Python's standard library are organized — many layers of packages and sub-packages, each with a focused purpose.

The Python Standard Library

Python ships with a large collection of modules and packages built right in. This collection is called the standard library. You do not need to install anything to use it — if you have Python, you have the standard library. You simply import what you need.

Here are a few of the standard library modules beginners use most often:

# math — mathematical functions
import math
print(math.sqrt(25))      # 5.0
print(math.pi)            # 3.141592653589793

# random — random number generation
import random
print(random.randint(1, 10))  # a random integer between 1 and 10

# datetime — working with dates and times
import datetime
today = datetime.date.today()
print(today)              # e.g. 2025-04-03

# os — interacting with the operating system
import os
print(os.getcwd())        # prints the current working directory

# json — reading and writing JSON data
import json
data = {"name": "Alex", "age": 30}
print(json.dumps(data))   # '{"name": "Alex", "age": 30}'

"The standard library contains built-in modules written in C that provide access to system functionality." — Python Documentation

The standard library is extensive — it covers file I/O, networking, compression, regular expressions, email, cryptography, and much more. Before reaching for a third-party package, it is worth checking whether the standard library already has what you need.

Third-Party Packages and PyPI

The standard library is powerful, but it does not cover everything. The wider Python community has published hundreds of thousands of open-source packages for tasks the standard library does not address — web scraping, machine learning, HTTP requests, image processing, data analysis, and far more.

These packages live in a public repository called the Python Package Index, commonly referred to as PyPI (pronounced "pie-pee-eye"). PyPI is hosted at pypi.org. When someone publishes a Python package, they upload it to PyPI so others can find and install it.

Some of the third-party packages that beginners encounter most often include:

Installing Packages with pip

pip is the tool Python uses to install packages from PyPI. It has been included automatically with Python since version 3.4, so in nearly all cases you already have it. You run pip commands in your terminal (also called the command prompt or shell) — not inside a Python script.

Here are the pip commands you will use most often as a beginner:

# Install a package
pip install requests

# Install a specific version
pip install requests==2.31.0

# Upgrade an existing package to the latest version
pip install --upgrade requests

# Uninstall a package
pip uninstall requests

# List all installed packages
pip list

# Show details about a specific installed package
pip show requests

Once pip installs a package, you import it in your Python file exactly the same way you import a standard library module — with the import statement. The package does not need any special setup beyond the installation step.

# After running: pip install requests

import requests

response = requests.get("https://api.github.com")
print(response.status_code)  # 200 means success

"pip is the package installer for Python. You can use pip to install packages from the Python Package Index." — pip documentation

Python Learning Summary Points

1. A module is a single .py file. A package is a directory of modules that includes an __init__.py file. The word "library" is informal and usually refers to a collection of packages distributed together.
2. The Python standard library ships with every Python installation. You import its modules directly without any additional installation step.
3. Third-party packages live on PyPI and are installed using pip install package-name in your terminal. After installation, you import them the same way you import standard library modules.
4. The import statement has two main forms: import module loads the whole module, while from module import name loads only the specific function or class you need.
5. When Python raises a ModuleNotFoundError, the module is either not installed (install it with pip) or has a typo in the import statement.

Packages are the reason Python's ecosystem is so productive. Rather than writing everything from scratch, you stand on the work of thousands of other developers. Learning how to find, evaluate, and use packages well — starting with the standard library and expanding from there — dramatically expands what you can build.