Dependency management is one of the essential skills for any Python developer. PIP (Package Installer for Python) is the standard tool that allows you to install, update, and remove packages efficiently. In this complete guide, you'll learn from basic concepts to advanced techniques for keeping your projects organized and reproducible.

📦 What is PIP?

PIP is Python's official package manager. It allows you to install external libraries and frameworks that are not part of the standard library. With PIP, you can access thousands of packages available on the Python Package Index (PyPI), the official Python package repository.

According to the official PIP documentation, the tool was introduced in 2008 and has since become an essential part of the Python ecosystem. PyPI currently hosts over 400,000 packages, covering practically any development need.

Checking if PIP is installed

Most modern Python installations already come with PIP integrated. To check if you have PIP installed, run the following command in your terminal:

pip --version
# or
pip3 --version

If PIP is installed, you'll see something like pip 24.0 from /usr/lib/python3/dist-packages (python 3.12). Otherwise, you'll need to install it separately.

⬇️ Installing Packages with PIP

Installing packages is the most basic PIP operation. You can install packages in various ways, depending on your needs.

Basic installation

To install a package, just use the pip install command followed by the package name:

pip install requests

This downloads and installs the latest version of the package available on PyPI. You can also specify a specific version:

pip install requests==2.31.0

Installing multiple packages

You can install several packages at once:

pip install requests numpy pandas flask

Installing from specific sources

PIP allows you to install packages from various sources:

# From a Git repository
pip install git+https://github.com/user/project.git

# From a local file
pip install ./my-package

# From a local wheel file
pip install ./package.whl

Real Python provides a detailed guide on the different installation methods available in PIP.

📋 Managing requirements.txt

The requirements.txt file is the industry standard for documenting Python project dependencies. It allows other developers to install exactly the same package versions you're using.

Creating requirements.txt

To generate a requirements.txt file with all dependencies from your current environment:

pip freeze > requirements.txt

The generated file will look something like this:

requests==2.31.0
numpy==1.26.0
pandas==2.1.0
flask==3.0.0

Installing from requirements.txt

To install all dependencies from a requirements.txt file:

pip install -r requirements.txt

Best practices with requirements.txt

For professional projects, consider creating multiple requirements files:

requirements.txt          # Main dependencies
requirements-dev.txt     # Development dependencies
requirements-test.txt    # Test dependencies
requirements-prod.txt    # Production dependencies

You can install specific dependencies:

pip install -r requirements-dev.txt

🔄 Updating and Removing Packages

Updating packages

To check if updates are available:

pip list --outdated

To update a specific package:

pip install --upgrade requests

To automatically update pip:

pip install --upgrade pip

Removing packages

To uninstall a package:

pip uninstall requests

To uninstall multiple packages:

pip uninstall requests numpy pandas

To automatically confirm uninstallation:

pip uninstall -y requests

🏠 Virtual Environments

One of the most important practices in Python dependency management is using virtual environments. They allow you to create isolated environments for each project, avoiding conflicts between different package versions.

Why use virtual environments?

  • Isolate dependencies across different projects
  • Avoid version conflicts between packages
  • Allow different Python versions per project
  • Facilitate reproduction of development environment
  • Improve system security

Creating a virtual environment

You can create a virtual environment using the venv module, which comes with Python:

# On Linux/macOS
python3 -m venv my_environment

# On Windows
python -m venv my_environment

Activating the virtual environment

After creating the environment, you need to activate it:

# On Linux/macOS
source my_environment/bin/activate

On Windows (PowerShell)


my_environment\Scripts\Activate


On Windows (CMD)


my_environment\Scripts\activate.bat

When activated, you'll see the environment name in the terminal prompt, like (my_environment) $.

Installing packages in the virtual environment

With the environment activated, all PIP installations will be specific to that environment:

pip install flask requests numpy

The installed packages are only in that virtual environment and don't affect the system-wide installation.

Deactivating the environment

To exit the virtual environment:

deactivate

The official Python documentation provides detailed information on how to work with virtual environments.

🔧 Pipfile and Poetry

In addition to requirements.txt, there are other tools for managing dependencies that offer more advanced features.

What is Pipfile?

Pipfile is the format used by Pipenv, a tool that combines pip and virtualenv in a single tool. It offers features like:

  • Automatic virtual environment management
  • Dependency locking with security hashes
  • Distinction between production and development dependencies
  • Automatic resolution of version conflicts

Using Pipenv

To start using Pipenv in a project:

# Start a new project with Pipenv
pipenv install requests

# Or specify the Python environment
pipenv --python 3.11

# Activate the environment shell
pipenv shell

When installing packages, Pipenv automatically creates Pipfile and Pipfile.lock:

[[source]]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"

[packages]
requests = "*"


[dev-packages]


[requires]
python_version = "3.11"

Installing with Pipenv

# Install all dependencies
pipenv install

# Install only production dependencies
pipenv install --prod

# Install development dependencies (like pytest)
pipenv install --dev pytest

Pipenv is widely recommended by the Python community as a more robust solution for dependency management.

📦 Creating and Publishing Your Own Packages

An advanced skill is creating and publishing your own packages on PyPI, allowing other developers to easily install your code.

Basic package structure

A well-structured Python package usually has the following structure:

my-package/
├── setup.py
├── setup.cfg
├── README.md
├── LICENSE
├── requirements.txt
├── my_package/
│   ├── __init__.py
│   ├── module1.py
│   └── module2.py
└── tests/
    └── test_module1.py

Creating setup.py

The setup.py file defines your package information:

from setuptools import setup, find_packages

setup(
name="my-package",
version="1.0.0",
author="Your Name",
author_email="[email protected]",
description="A brief description of the package",
long_description=open("README.md").read(),
long_description_content_type="text/markdown",
url="https://github.com/your-user/my-package",
packages=find_packages(),
classifiers=[
"Programming Language :: Python :: 3",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
],
python_requires=">=3.8",
install_requires=[
"requests>=2.25.0",
],
)

Publishing to PyPI

To publish your package on PyPI:

# Install build tools
pip install build twine

# Create the package
python -m build

# Upload to PyPI
twine upload dist/*

You'll need to create an account on PyPI and configure your ~/.pypirc file with your credentials.

The official packaging documentation provides a complete tutorial on how to create and distribute Python packages.

🐳 Docker and Dependency Management

In modern projects, especially in production environments, Docker is often used to create reproducible environments.

Dockerfile with PIP

Example of a Dockerfile using PIP:

FROM python:3.11-slim

WORKDIR /app


COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt


COPY . .


CMD ["python", "app.py"]

Using requirements.txt in Docker

The recommended practice is to only copy requirements.txt first and install dependencies before copying the code:

FROM python:3.11-slim

WORKDIR /app


Copy only requirements and install dependencies


COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt


Then copy source code


COPY . .


CMD ["python", "app.py"]

This approach allows Docker to use caching for dependency layers, making the build much faster when only the code changes.

⚠️ Common Problems and Solutions

1. Version conflicts

When different packages need incompatible versions of the same library, you may face conflicts:

ERROR: Exception: requests 2.31.0 has requirement urllib3<2.0,>=1.21.1, but you'll have urllib3 2.0.0 which is incompatible.



Solutions:


    

  • Use Pipenv or Poetry that automatically resolve dependencies
    • 

  • Manually specify compatible versions
    • 

  • Create separate virtual environments for each project
    • 



2. Slow installation


To speed up package installation, you can:


# Use local cache
pip install --cache-dir /tmp/pip-cache requests

Use Brazilian mirror


pip install -i https://mirror.pyBrazil.org/simple/ requests



3. Permission problems


If you encounter permission errors, never use sudo pip install. Instead, use virtual environments:


python3 -m venv my_environment
source my_environment/bin/activate
pip install requests


PEP 668 formalizes this practice, marking systems that don't allow global installations without virtual environment.


🛠️ Useful PIP Commands


Here's a quick reference of the most useful PIP commands:


# List installed packages
pip list

List outdated packages


pip list --outdated


Show package information


pip show requests


Search packages on PyPI


pip search requests  # (deprecated, use pypi.org)


Download package without installing


pip download requests -d ./packages


Check for security requirements


pip audit


Show dependency tree


pip freeze | grep -E "^[^=]+" | cut -d < -f1 | xargs pip show | grep -E "^Name:|^Requires:"



🚀 Best Practices


    

  • Always use virtual environments: Never install packages globally in projects
    • 

  • Document your dependencies: Keep an updated requirements.txt or Pipfile
    • 

  • Specify versions: Use fixed versions in production to avoid surprises
    • 

  • Use Pipenv or Poetry: Modern tools that make management easier
    • 

  • Review your dependencies: Regularly check for updates and security vulnerabilities
    • 

  • Test locally: Always test your project in a clean environment before deployment
    • 

  • Use Docker: For reproducible production environments
    • 



🔗 Next Steps


Now that you master dependency management with PIP, keep exploring other related topics:



Mastering PIP is essential for any professional Python developer. Keep practicing and exploring the available tools to improve your productivity and code quality! 🎯