How to list all installed packages and their versions in Python

Navigating the intricate world of Python development often involves managing a multitude of libraries and frameworks. Whether you’re debugging a compatibility issue, ensuring a reproducible environment for your team, or simply trying to understand what’s installed on your system, knowing how to list all installed packages and their versions in Python is an essential skill. Python’s rich ecosystem, powered by the Python Package Index (PyPI), provides developers with thousands of ready-to-use packages, but this abundance also necessitates robust tools for oversight. This guide will walk you through the most effective methods to inspect your Python environment, ensuring you have complete visibility over your project’s dependencies. Understanding your installed packages is a cornerstone of effective Python dependency management, crucial for smooth development workflows and deployment.

Understanding Your Python Environment with pip list

The primary tool for managing Python packages is pip, and one of its most fundamental commands is pip list. This command offers a quick and easy way to view all packages installed in your current Python environment. When executed, it provides a comprehensive table showing the package name and its corresponding version number, making it invaluable for a quick overview.

The output of pip list is designed for human readability, presenting a clear, tabular format that’s easy to scan. It’s particularly useful when you need to confirm if a specific package is installed or to check its version at a glance. For instance, if you’re troubleshooting a script that requires a particular library, this command can immediately tell you whether it’s present and what version is being used, which can often pinpoint compatibility issues. According to the official pip documentation, pip list is the recommended command for displaying installed packages.

Beyond the basic listing, pip list also supports various options to refine its output. You can use pip list --outdated to see which of your installed packages have newer versions available on PyPI, a critical feature for keeping your dependencies up-to-date and secure. Conversely, pip list --uptodate shows packages that are already at their latest version. These options empower developers to maintain healthy, current Python environments, proactively addressing potential vulnerabilities or benefiting from new features and bug fixes. Regularly checking for outdated packages is a best practice in modern software development.

Precision with pip freeze for Reproducible Environments

While pip list provides a general overview, pip freeze is the command of choice when you need an exact, machine-readable list of your installed packages and their versions. This command outputs a list of packages in a format that can be directly used by pip install -r requirements.txt, making it indispensable for creating reproducible Python environments. It lists each package along with its precise version, typically in the format package==version.

To quickly list all installed packages and their exact versions in Python, the most common and effective method is to use your package manager, pip. Simply open your terminal or command prompt, activate your virtual environment if you’re using one, and execute the command pip freeze. This command outputs a precise list of all installed packages and their versions in a format suitable for a requirements.txt file, ensuring reproducibility of your project’s dependencies.

The primary use case for pip freeze is to generate a requirements.txt file. This file acts as a manifest of all your project’s dependencies, ensuring that anyone working on the project, or the deployment environment, can install the exact same versions of libraries. This prevents “it works on my machine” scenarios, which are a common headache in software development. For example, after developing a project, you would run pip freeze > requirements.txt to capture all your current dependencies. Then, another developer or a CI/CD pipeline could run pip install -r requirements.txt to replicate your setup exactly. This practice is fundamental to robust Python dependency management.

It’s important to note that pip freeze is typically used within a virtual environment. If run outside a virtual environment, it will list all packages installed globally, which might be a very long list and include packages unrelated to your specific project. This is why understanding and utilizing Python virtual environments is crucial for effective dependency isolation and management, ensuring that pip freeze only captures relevant project dependencies.

The Critical Role of Virtual Environments

When you ask “how to list all installed packages and their versions in Python?”, the answer largely depends on whether you’re operating within a virtual environment. Virtual environments are isolated Python installations, each with its own set of packages. This isolation prevents conflicts between different projects that might require different versions of the same library. For instance, Project A might need Django 2.0, while Project B requires Django 3.0. Without virtual environments, installing both would lead to version conflicts and potential breakage.

Using virtual environments ensures that pip list and pip freeze only display packages relevant to your current project. This significantly cleans up the output and makes dependency management far more manageable. When you activate a virtual environment, your shell’s PATH variable is temporarily modified to point to that environment’s Python and pip executables. This means any pip commands you run, including pip list and pip freeze, will operate exclusively within that isolated environment, providing a true snapshot of your project’s dependencies.

Here’s a typical workflow for using virtual environments and listing packages:

1. Create a virtual environment: Navigate to your project directory and run python3 -m venv venv (or python -m venv venv on Windows). This creates a folder named ‘venv’ containing the isolated environment.

2. Activate the virtual environment:

   • On macOS/Linux: source venv/bin/activate
   • On Windows (PowerShell): .\venv\Scripts\Activate.ps1
   • On Windows (CMD): .\venv\Scripts\activate.bat

   You’ll typically see the environment’s name (e.g., (venv)) prefixed to your terminal prompt, indicating it’s active.

3. Install project dependencies: Use pip install package_name for each library your project needs.

4. List installed packages: Run pip list for a general overview or pip freeze to generate a requirements.txt file.

5. Deactivate the environment: When you’re done, simply Question & Answer :
   Is there a way in Python to list all installed packages and their versions?

   I know I can go inside python/Lib/site-packages and see what files and directories exist, but I find this very awkward. What I’m looking for something that is similar to npm list i.e. npm-ls.

   If you have pip install and you want to see what packages have been installed with your installer tools you can simply call this:

   pip freeze 
   

   It will also include version numbers for the installed packages.

   Update

   pip has been updated to also produce the same output as pip freeze by calling:

   pip list 
   

   Note

   The output from pip list is formatted differently, so if you have some shell script that parses the output (maybe to grab the version number) of freeze and want to change your script to call list, you’ll need to change your parsing code.