Offensive Security Researcher & Quantum Cryptography Analyst

Installing External Modules Using Pip in Python: Complete Package Management and Dependency Installation Guide

Abdul Wahab Junaid
Installing external modules using pip in python

Installing external modules using pip in python

I remember the exact moment pip clicked for me. I was trying to send an HTTP request in Python using nothing but the standard library, wrestling with urllib, when a more experienced developer told me to “just pip install requests.” One command later, I had a library that made the entire task trivial. From that point on, I understood pip wasn’t just a convenience — it’s the backbone of the entire Python ecosystem.

What Is Pip?

Pip stands for “Pip Installs Packages” (a recursive acronym), and it’s the standard package manager for Python. It downloads packages from the Python Package Index (PyPI), Python’s central repository of open-source libraries, and installs them into your environment so you can import them in your own code.

pip --version

Output (version numbers will vary):

pip 24.0 from /usr/lib/python3/dist-packages/pip (python 3.12)

Since Python 3.4, pip ships bundled with the standard CPython installer by default, so on most modern systems you don’t need to install pip separately — it’s already there alongside python itself.

Installing a Package

The core command is straightforward:

pip install requests

Output (abbreviated):

Collecting requests
  Downloading requests-2.32.3-py3-none-any.whl (64 kB)
Collecting charset-normalizer
  Downloading charset_normalizer-3.3.2-py3-none-any.whl
Collecting idna
Collecting urllib3
Collecting certifi
Installing collected packages: certifi, urllib3, idna, charset-normalizer, requests
Successfully installed certifi-2024.7.4 charset-normalizer-3.3.2 idna-3.7 requests-2.32.3 urllib3-2.2.2

Notice pip didn’t just install requests — it also installed charset-normalizer, idna, urllib3, and certifi automatically. These are requests‘s own dependencies, listed in its package metadata, and pip resolves and installs the entire dependency tree for you without any manual work.

Once installed, you can import and use it immediately:

import requests

response = requests.get("https://api.github.com")
print(response.status_code)

Output:

200

Installing a Specific Version

Sometimes you need an exact version, either for compatibility or to match a production environment.

pip install requests==2.28.0
pip install "requests>=2.25.0,<2.30.0"
pip install requests --upgrade

The first command installs an exact version. The second uses version specifiers to constrain an acceptable range. The third upgrades an already-installed package to the latest available release on PyPI.

Uninstalling and Listing Packages

pip uninstall requests
pip list
pip show requests

pip list prints every package currently installed in your environment, while pip show requests gives detailed metadata about a specific package — its version, dependencies, install location, and homepage.

Output of pip show requests (abbreviated):

Name: requests
Version: 2.32.3
Summary: Python HTTP for Humans.
Home-page: https://requests.readthedocs.io
Requires: charset-normalizer, idna, urllib3, certifi
Required-by:

How Pip Actually Works Internally

Understanding what happens when you run pip install <package> demystified a lot of confusing errors for me. Here’s the actual sequence:

  1. Resolution: Pip contacts PyPI’s API and looks up metadata for the requested package, including its available versions and declared dependencies.
  2. Dependency resolution: Since pip 20.3, it uses a proper backtracking resolver that finds a consistent set of versions for the package and every transitive dependency, avoiding version conflicts wherever mathematically possible.
  3. Download: Pip downloads the appropriate distribution file, preferring a pre-built wheel (.whl) matching your operating system, Python version, and CPU architecture, if one is available. If no compatible wheel exists, it falls back to a source distribution (.tar.gz), which may need to be compiled locally, sometimes requiring a C compiler for packages with native extensions.
  4. Installation: Pip extracts and copies the package’s files into your environment’s site-packages directory, and registers the package’s metadata so future commands like pip show or pip uninstall know it’s there.
python -m site

This command reveals exactly where site-packages lives on your system, which is the actual physical location Python’s import statement searches through when you write import requests.

Virtual Environments: Why They’re Essential

This was the single most important pip-adjacent lesson I learned the hard way. Installing packages globally, system-wide, works fine until you have two different projects that need two different, incompatible versions of the same library. Virtual environments solve this by creating an isolated, self-contained Python installation and site-packages directory for each project.

python -m venv myproject-env

# On Linux/macOS
source myproject-env/bin/activate

# On Windows
myproject-env\Scripts\activate

Once activated, your shell prompt typically changes to show the environment name, and any pip install command from that point only affects this isolated environment, not your system-wide Python installation.

(myproject-env) $ pip install requests
(myproject-env) $ pip list

To leave the virtual environment:

deactivate

I now create a fresh virtual environment for essentially every project I start, without exception. It’s saved me from countless “it works on my machine but not yours” situations, and it keeps my system Python installation clean.

Requirements Files: Reproducible Environments

For any real project, especially one shared with others or deployed to a server, I maintain a requirements.txt file listing exact dependencies.

pip freeze > requirements.txt

This generates a file listing every installed package and its exact version:

certifi==2024.7.4
charset-normalizer==3.3.2
idna==3.7
requests==2.32.3
urllib3==2.2.2

Anyone else — or any deployment pipeline — can then recreate the exact same environment with a single command:

pip install -r requirements.txt

This is genuinely one of the most important habits for professional Python workflows. Without a requirements file, “works on my machine” becomes a recurring nightmare across a team or across environments like local development, staging, and production.

Installing from Other Sources

Pip isn’t limited to PyPI. I’ve used it to install directly from GitHub repositories, local directories, and even local wheel files.

# Install directly from a GitHub repository
pip install git+https://github.com/psf/requests.git

# Install a local project in "editable" mode, useful during development
pip install -e .

# Install from a local wheel file
pip install ./mypackage-1.0.0-py3-none-any.whl

Editable installs (-e .) are especially useful when actively developing your own package — changes to your source code take effect immediately without needing to reinstall.

Common Errors and How to Resolve Them

Permission denied errors happen when trying to install into a system-protected location without sufficient privileges:

ERROR: Could not install packages due to an OSError: [Errno 13] Permission denied

The fix is almost always to use a virtual environment instead of trying to force installation with elevated privileges like sudo pip install, which can actually corrupt your system’s Python installation over time.

Dependency conflicts happen when two packages require incompatible versions of the same dependency:

ERROR: Cannot install package-a and package-b because these package versions have conflicting dependencies.

Pip’s resolver will usually explain exactly which packages are conflicting and why. The fix typically involves relaxing a version constraint, upgrading one of the conflicting packages, or, in more complex cases, using separate virtual environments for tools that fundamentally can’t coexist.

Missing build tools for packages with native extensions:

error: Microsoft Visual C++ 14.0 or greater is required

Some packages, especially scientific computing libraries, include C extensions that need to be compiled if no pre-built wheel matches your platform. Installing a pre-built wheel (when the maintainers publish one) avoids this entirely, which is why I always check PyPI first to see if my exact Python version and OS combination has a wheel available.

Real-World and Professional Workflow Use Cases

pip list --outdated
pip install --upgrade package_name

Best Practices

Common Mistakes

A mistake I made early on was installing everything globally without virtual environments, which eventually led to version conflicts between two unrelated projects that both depended on different versions of the same library. Another common mistake is forgetting to update requirements.txt after installing a new package mid-project, which leaves collaborators with an incomplete environment when they try to reproduce it.

# After installing something new mid-project, always regenerate the file
pip install pandas
pip freeze > requirements.txt

FAQs

Do I need to install pip separately? Usually not. Pip ships bundled with Python installers since Python 3.4, so it’s typically already available alongside python and python3.

What’s the difference between pip install package and pip install -e .? The first installs a fixed copy of a package into site-packages. The second installs your own local project in “editable” mode, so code changes take effect immediately without reinstalling.

Why do I need virtual environments if pip already works globally? To isolate dependencies per project, avoiding version conflicts between projects that need different versions of the same package, and to keep your system Python installation clean.

What is a wheel file? A .whl file is a pre-built, ready-to-install package distribution format. Pip prefers wheels over source distributions because they install faster and don’t require local compilation.

How do I recreate someone else’s exact environment? Ask for their requirements.txt (generated via pip freeze), then run pip install -r requirements.txt inside your own virtual environment.

Summary

Pip is the backbone of Python’s entire package ecosystem, handling dependency resolution, downloading, and installation from PyPI and other sources with a single command. Understanding what actually happens during pip install — resolution, wheel preference, and installation into site-packages — combined with disciplined use of virtual environments and requirements.txt, is what separates a fragile, conflict-prone Python setup from a clean, reproducible, professional one. It’s a small set of habits, but they’ve saved me from more environment headaches than almost any other Python workflow practice.

References

Exit mobile version