Python - Packages: Your Gateway to Code Reusability and Organization

Hello, aspiring Python programmers! Today, we're going to embark on an exciting journey into the world of Python packages. As your friendly neighborhood computer science teacher, I'm thrilled to guide you through this essential concept that will take your coding skills to the next level. So, grab your virtual backpacks, and let's dive in!

What Are Python Packages?

Before we start creating our own packages, let's understand what they are and why they're so important.

Imagine you're building a massive LEGO structure. Instead of scattered LEGO pieces everywhere, wouldn't it be nice to have them organized in separate boxes based on their purpose? That's exactly what Python packages do for your code!

A Python package is a way to organize related modules into a directory hierarchy. It allows you to group related functionality together, making your code more organized, reusable, and easier to maintain.

Create a Python Package

Now, let's roll up our sleeves and create our very own Python package. We'll start with a simple example to get our feet wet.

Step 1: Create the Package Directory

First, we need to create a directory for our package. Let's call it my_math_package.

my_math_package/

Step 2: Add an init.py File

Inside the my_math_package directory, create an empty file called __init__.py. This file tells Python that the directory should be treated as a package.

my_math_package/
    __init__.py

Step 3: Create Module Files

Now, let's add some modules to our package. We'll create two simple modules: basic_operations.py and advanced_operations.py.

my_math_package/
    __init__.py
    basic_operations.py
    advanced_operations.py

Step 4: Add Code to the Modules

Let's add some simple functions to our modules.

In basic_operations.py:

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

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

In advanced_operations.py:

def power(base, exponent):
    return base ** exponent

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n-1)

Step 5: Using the Package

Now that we've created our package, let's see how we can use it in our Python code.

# Importing specific functions
from my_math_package.basic_operations import add, subtract
from my_math_package.advanced_operations import power, factorial

# Using the imported functions
print(add(5, 3))  # Output: 8
print(subtract(10, 4))  # Output: 6
print(power(2, 3))  # Output: 8
print(factorial(5))  # Output: 120

Isn't that neat? We've just created and used our very own Python package!

Define Package List

When working on larger projects, you might need to use multiple packages. It's a good practice to keep track of all the packages your project depends on. This is where a package list comes in handy.

A package list is typically stored in a file called requirements.txt. This file lists all the packages and their versions that your project needs to run correctly.

Here's an example of what a requirements.txt file might look like:

numpy==1.21.0
pandas==1.3.0
matplotlib==3.4.2

Each line specifies a package name and its version. The double equals sign (==) indicates that we want exactly that version.

Package Installation

Now that we know how to list our required packages, let's learn how to install them. Python provides a powerful tool called pip for package installation.

Installing a Single Package

To install a single package, you can use the following command in your terminal or command prompt:

pip install package_name

For example, to install NumPy:

pip install numpy

Installing from requirements.txt

To install all packages listed in your requirements.txt file, use:

pip install -r requirements.txt

This command tells pip to read the requirements.txt file and install all the packages listed there.

Virtual Environments

Here's a pro tip: when working on different projects, it's a good idea to use virtual environments. A virtual environment is like a separate playground for each of your projects, keeping their dependencies isolated from each other.

To create a virtual environment:

python -m venv myenv

To activate it:

• On Windows: myenv\Scripts\activate
• On macOS and Linux: source myenv/bin/activate

Once activated, any packages you install will be specific to this environment, keeping your projects nice and tidy!

Conclusion

Congratulations! You've just taken a big step in your Python journey by learning about packages. From creating your own packages to installing and managing them, you now have the tools to organize your code like a pro.

Remember, packages are like the shelves in your code library. They help you keep everything organized, making it easier to find what you need and share your code with others. As you continue your Python adventure, you'll discover many more exciting packages that can add powerful functionality to your projects.

Keep practicing, stay curious, and happy coding!

Method	Description
pip install package_name	Installs a single package
pip install -r requirements.txt	Installs packages listed in requirements.txt
python -m venv myenv	Creates a virtual environment
myenv\Scripts\activate (Windows)	Activates virtual environment on Windows
source myenv/bin/activate (macOS/Linux)	Activates virtual environment on macOS/Linux

Credits: Image by storyset