Comprehensive Guide to Listing Locally Installed Python Modules

Introduction

In Python development, obtaining a list of locally installed modules is a common requirement. Whether for environment configuration checks, dependency management, or debugging purposes, mastering effective methods for retrieving module lists is crucial. This article systematically introduces multiple approaches for acquiring locally installed Python modules and provides detailed analysis of their advantages, disadvantages, and applicable scenarios.

Core Method: Using pip.get_installed_distributions()

Prior to pip version 10.0, the pip.get_installed_distributions() function was the recommended approach for obtaining installed package lists. This method returns information about all packages installed via setuptools, pip, or easy_install, including package names and version numbers.

Basic Implementation

The following code demonstrates the fundamental implementation using this function:

import pip
installed_packages = pip.get_installed_distributions()
installed_packages_list = sorted(["%s==%s" % (i.key, i.version) for i in installed_packages])
print(installed_packages_list)

This code first imports the pip module, then calls the get_installed_distributions() method to retrieve all installed packages. Using list comprehension, it formats each package's name and version as a string, sorts them alphabetically, and outputs the result.

Simplified Version

For scenarios requiring concise code, the process can be condensed into a single line:

sorted(["%s==%s" % (i.key, i.version) for i in pip.get_installed_distributions()])

This compact version provides identical functionality to the detailed implementation and is particularly suitable for interactive environments.

Application Scope and Advantages

The primary advantage of this method lies in its broad applicability. It can identify not only packages installed via pip but also those installed through setuptools and easy_install. This comprehensive coverage makes the method especially suitable for scenarios requiring complete environment auditing.

In practical applications, this method can be integrated into web services to return package lists of current environments via API endpoints. For example, adding a route endpoint in Flask applications that returns server environment package information when users access specific URLs proves highly useful for debugging and monitoring purposes.

Considerations and Limitations

Version Compatibility

It's crucial to note that the pip.get_installed_distributions() function has been removed in pip version 10.0 and later. If using newer pip versions, this method will not function properly. For modern pip versions, pkg_resources.working_set is recommended as an alternative approach.

Directory Dependency Issue

This method exhibits an important behavioral characteristic: when the Python interpreter runs in the same directory as a setup.py file, it may fail to correctly list packages installed via that setup.py.

To verify this issue, follow these testing steps:

$ cd /tmp
$ virtualenv test_env
$ source test_env/bin/activate
(test_env) $ git clone https://github.com/behave/behave.git
(test_env) $ cd /tmp/behave && pip install .

When running code from the /tmp directory, the behave package appears normally in the list. However, when running from the /tmp/behave directory, the behave package will not appear in the list. This directory-dependent behavior requires special attention during development.

Alternative Method Comparisons

help('modules') Method

Python's built-in help('modules') command can list all available modules, including standard library and third-party modules. However, this approach has several limitations:

help('modules')

When numerous packages are installed in the environment, this method may require significant time to import each module and search its path. Additionally, certain modules may contain code that executes upon import, potentially causing infinite loops or program hangs.

pip freeze Command

pip freeze is another commonly used method for obtaining package lists:

pip freeze

This command outputs all pip-installed packages in the current environment along with their version information, formatted appropriately for requirements file generation. However, it only lists packages installed via pip and cannot detect packages installed through other methods.

pkg_resources Method

For newer Python environments, pkg_resources.working_set is recommended:

import pkg_resources
installed_packages = pkg_resources.working_set
installed_packages_list = sorted(["%s==%s" % (i.key, i.version) for i in installed_packages])
for package in installed_packages_list:
    print(package)

This approach provides functionality similar to pip.get_installed_distributions() but offers better compatibility in modern Python environments.

Environment-Specific Considerations

Virtual Environments

In virtual environments, all aforementioned methods automatically restrict their scope to the currently activated virtual environment. This ensures that returned package lists only contain packages installed within that specific environment, excluding system-wide installed packages.

Package Manager Differences

Different package management tools provide their own package listing methods:

• Pipenv: Use pipenv lock -r command
• Conda: Use conda list command
• Anaconda Navigator: View installed packages through graphical interface

Selecting the appropriate method requires consideration of specific development environments and toolchains.

Best Practice Recommendations

Based on analysis of various methods and practical testing, recommendations for method selection according to specific needs include:

1. For environments requiring compatibility with older pip versions, use pip.get_installed_distributions()
2. For modern environments, prioritize pkg_resources.working_set
3. In command-line environments, use pip freeze for requirements-formatted output
4. In debugging and interactive environments, use help('modules') for quick module overview

Additionally, attention should be paid to limitations and special behaviors of various methods, particularly in scenarios involving local package development and directory dependencies.

Conclusion

Obtaining lists of locally installed Python modules represents a fundamental yet important task in development processes. By understanding the principles, applicable scopes, and limitations of various methods, developers can select the most suitable solutions based on specific requirements. While pip.get_installed_distributions() performs excellently in older versions, modern alternatives are recommended for newer environments. Regardless of the chosen method, understanding behavioral characteristics and potential issues remains key to accurately acquiring environment information.