Linux Python Package Installing

Introduction

Python packages extend the functionality of Python by providing specialized tools and libraries for various tasks. Installing and managing these packages efficiently is an essential skill for Python developers.

In this lab, you will learn how to use pip, the standard Python package installer, on a Linux system. You will set up your environment, install packages, manage dependencies, and explore different installation options. These skills are fundamental for any Python developer working in Linux environments.

Setting up Your Python Environment

In this step, you'll prepare a clean Python environment for package management. You'll learn to use virtual environments, which are essential for managing project dependencies without conflicts.

Verifying Python and pip

First, let's verify that Python and pip are available:

python3 --version
pip3 --version

You should see Python 3.10.x and pip version information. If pip is not installed, install it:

sudo apt update
sudo apt install python3.10-venv -y
sudo apt upgrade python3-pip -y

Creating a Virtual Environment

Virtual environments create isolated Python spaces for each project. This prevents package conflicts between different projects:

cd ~/project
python3 -m venv myproject_env
source myproject_env/bin/activate

Your prompt should now show (myproject_env) indicating you're in the virtual environment. Inside a virtual environment, you can use pip instead of pip3.

Creating a Requirements File

Create a requirements.txt file to track your project's dependencies:

touch requirements.txt

This file will help you recreate the same environment on different systems.

Installing Python Packages

In this step, you'll learn to install Python packages both individually and using a requirements file. Ensure you're in your virtual environment (you should see (myproject_env) in your prompt).

Installing Your First Package

Let's install the requests package, which is commonly used for making HTTP requests:

pip install requests

You'll see the download and installation progress. Verify the installation:

pip list

You should see requests in the list of installed packages.

Using a Requirements File

Now let's specify multiple packages with exact versions in your requirements file. Open it:

nano requirements.txt

Add the following content:

requests==2.31.0
numpy==1.24.3
pandas==2.0.3

Save with Ctrl+O, Enter, then exit with Ctrl+X.

This approach ensures consistent environments across different systems by specifying exact package versions.

Installing from Requirements File

Install all packages from your requirements file:

pip install -r requirements.txt

Since requests is already installed, pip will either keep it or update it to match the specified version. The new packages (numpy and pandas) will be installed fresh.

Verify all packages are installed:

pip list | grep -E "(requests|numpy|pandas)"

You should see all three packages with their specified versions.

Managing Package Versions

In this step, you'll learn essential package management operations: checking package information, updating packages, and installing specific versions.

Viewing Package Information

Check detailed information about an installed package:

pip show requests

This displays version, dependencies, license, and installation location information.

Installing Specific Versions

Sometimes you need a different version for compatibility. Install a specific version of numpy:

pip install numpy==1.23.5

Verify the version change:

pip show numpy | grep Version

You should see version 1.23.5 instead of 1.24.3.

Updating Packages

Update a package to its latest version:

pip install --upgrade pandas

This updates pandas to the newest available version.

Freezing Your Environment

Generate a complete list of your current packages and versions:

pip freeze > current_env.txt

View the generated file:

cat current_env.txt

This file can be used to recreate the exact same environment elsewhere using pip install -r current_env.txt.

Working with Virtual Environments and Dependencies

In this final step, you'll learn virtual environment best practices and how to manage project dependencies effectively.

Deactivating and Reactivating

Practice deactivating your virtual environment:

deactivate

Your prompt should return to normal (no (myproject_env)). Try to run pip list:

pip list

You'll see only system-installed packages. Now reactivate your environment:

source ~/project/myproject_env/bin/activate

Notice how your project packages return when you reactivate.

Understanding Dependencies

Check which packages depend on others:

pip show pandas

Look at the "Requires" line to see pandas' dependencies. This is why managing environments is crucial - installing one package often installs many others.

Cleaning Up and Best Practices

Create a clean requirements file with only your direct dependencies:

nano ~/project/requirements.txt

Replace the content with just the packages you explicitly need (not their dependencies):

requests==2.31.0
numpy==1.23.5
pandas==2.0.3

Save and exit. When someone else installs from this file, pip will automatically handle the dependencies.

Sharing Your Environment

Your environment is now ready to be shared. Anyone can recreate it using:

pip install -r requirements.txt

This is the foundation of reproducible Python development.

Summary

In this lab, you've mastered the fundamentals of Python package management on Linux:

• Environment Setup: Created and managed Python virtual environments for project isolation
• Package Installation: Installed packages individually and using requirements files with specific versions
• Version Management: Updated packages, installed specific versions, and generated environment snapshots
• Best Practices: Learned to maintain clean dependency lists and share reproducible environments

These skills are essential for any Python developer. Virtual environments prevent conflicts between projects, while proper dependency management ensures your code works consistently across different systems.

You're now ready to manage Python packages confidently in any Linux development environment!