How to Install and Manage Python Packages with Pipenv – A Beginner’s Guide

Managing Python dependencies can feel like juggling flaming swords—especially if you’re just starting out. Traditional tools like pip and virtualenv work, but they often leave you scratching your head over version conflicts and reproducible environments. Enter Pipenv, the all‑in‑one solution that combines package installation, virtual environment creation, and lock‑file generation into a single, user‑friendly command line interface. In this guide we’ll walk you through everything you need to know to get Pipenv up and running, install packages safely, and keep your projects tidy. By the end, you’ll have a solid workflow you can rely on for every Python project you start.

What You’ll Need

• Python 3.7+ installed on your machine (check with python --version)
• Administrative or sudo rights to install Pipenv globally (or use a user‑level install)
• A terminal or command prompt you’re comfortable with
• Basic familiarity with the command line
• An internet connection to download packages

Step 1: Install Pipenv

The first thing you need is the Pipenv executable itself. The easiest way is via pip—the package manager that comes with Python. Open your terminal and run:

pip install --user pipenv

The --user flag installs Pipenv to your user’s site‑packages directory, avoiding the need for sudo on Unix‑like systems. After installation, make sure the user‑level binary directory is on your PATH. On most systems it’s ~/.local/bin (Linux/macOS) or %APPDATA%PythonScripts (Windows). Verify the install with:

pipenv --version

You should see something like pipenv, version 2023.12.0. If you get a “command not found” error, add the binary directory to your PATH and retry.

Step 2: Create a New Project Directory

Organising your code in its own folder is a best practice. Navigate to where you keep your projects and create a new directory:

mkdir my_first_pipenv_project
cd my_first_pipenv_project

At this point you have an empty folder ready for Pipenv to initialise a virtual environment and a Pipfile (the modern replacement for requirements.txt).

Step 3: Initialise Pipenv and the Virtual Environment

Run Pipenv without any arguments and it will automatically create a virtual environment using the default Python interpreter:

pipenv install

This command does two things:

• Generates a Pipfile that tracks your project’s dependencies.
• Creates a Pipfile.lock that pins exact versions, ensuring reproducibility.

If you prefer a specific Python version, add the --python flag, for example:

pipenv --python 3.11 install

Pipenv will download the requested interpreter (if available) and set up the environment accordingly.

Step 4: Install a Package

Now that the environment exists, you can start adding packages. Suppose you want to install requests, a popular HTTP library:

pipenv install requests

Pipenv does three things behind the scenes:

1. Installs requests into the virtual environment.
2. Updates the Pipfile with a requests = "*" entry.
3. Refreshes the Pipfile.lock with the exact version it installed.

You can verify the installation by spawning a shell inside the environment:

pipenv shell
python -c "import requests, sys; print('Requests version:', requests.__version__)"

When you’re done, exit the shell with exit or Ctrl‑D.

Step 5: Add Development‑Only Packages

Some tools, like testing frameworks or linters, are only needed during development. Pipenv lets you flag these as “dev” dependencies so they won’t be installed on production servers. For example, to add pytest as a dev package:

pipenv install --dev pytest

The Pipfile will now contain a [dev-packages] section. When you later run pipenv install --ignore-pipfile on a production machine, only the regular dependencies are installed, keeping the environment lean.

Step 6: Share Your Environment

One of Pipenv’s biggest strengths is the lock file. When you push your project to a repository (GitHub, GitLab, etc.), include both Pipfile and Pipfile.lock. Anyone cloning the repo can recreate the exact same environment with a single command:

pipenv sync

The sync command reads the lock file and installs the pinned versions, guaranteeing that “it works on my machine” truly means it works everywhere. If a collaborator prefers to install the latest compatible versions instead of the exact pins, they can run pipenv install which respects the version specifiers in Pipfile but may fetch newer releases.

Common Mistakes to Avoid

Even beginners can stumble over a few recurring pitfalls:

• Forgetting to add --user (or sudo) when installing Pipenv. This leads to permission errors. Use --user for a safe, per‑user install.
• Mixing pip and Pipenv commands. Installing packages with plain pip bypasses the Pipfile and can cause the lock file to become out of sync. Stick to pipenv install (or pipenv uninstall).
• Running pipenv install inside an already‑active virtual environment. Pipenv will try to create a nested env, which can confuse path resolution. Use pipenv shell to enter the env, then run commands without the extra pipenv prefix.
• Neglecting the Pipfile.lock in version control. Without it, collaborators may get different dependency versions, leading to hard‑to‑track bugs.
• Assuming pipenv install --dev will install dev packages on production. Remember to run pipenv install --ignore-pipfile or pipenv sync on production to exclude dev dependencies.

Tips and Tricks

Here are a few shortcuts that make Pipenv even more pleasant:

• Quickly check which Python version your env uses: pipenv --py prints the path to the interpreter.
• Run a one‑off command without entering a shell: pipenv run python script.py executes script.py inside the virtual env.
• Upgrade a single package: pipenv update requests fetches the newest compatible version and rewrites the lock file.
• Clean up unused virtual environments: pipenv --rm removes the environment for the current project.
• Generate a requirements.txt for legacy tools: pipenv lock -r > requirements.txt creates a traditional requirements file from the lock file.

Frequently Asked Questions

Is Pipenv a replacement for virtualenv?

Yes and no. Pipenv builds on virtualenv (or venv on Python 3) to create isolated environments, but it adds dependency resolution and lock‑file management. If you only need a simple env without package pinning, venv may be sufficient.

Can I use Pipenv with Python 2?

No. Pipenv officially supports Python 3.7 and newer. For legacy Python 2 projects, stick with virtualenv and pip or consider migrating to Python 3.

What if I need a package that isn’t on PyPI?

Pipenv can install from Git, local paths, or other indexes. Example:

pipenv install -e git+https://github.com/psf/requests.git#egg=requests

The -e flag marks it as an editable install, useful for development on forked repos.

Conclusion

Pipenv streamlines the often‑confusing world of Python dependency management by giving you a single tool that creates virtual environments, tracks packages, and locks versions for reproducibility. By following the six steps above—installing Pipenv, initialising a project, adding regular and dev dependencies, and sharing the lock file—you’ll avoid many common headaches that plague beginners. Remember to keep your Pipfile and Pipfile.lock in sync, avoid mixing raw pip commands, and use the handy shortcuts we covered. With this foundation, you’re ready to build robust Python applications that run the same way on every machine. Happy coding!

Photo by Hitesh Choudhary on Unsplash