What Is pip? Python's Package Manager Explained

Why AI Coders Need This

AI generates Python code with imports constantly. Whether you are using Claude, ChatGPT, Cursor, or Windsurf — the moment you ask for anything beyond basic math or string manipulation, the AI is going to write code that depends on packages someone else built. A web scraper needs requests and beautifulsoup4. A Flask API needs flask. A data analysis script needs pandas and matplotlib. An AI chatbot needs openai.

Python ships with a solid standard library — things like json, os, datetime, and math are built in. But the moment your AI reaches for anything beyond those built-in modules, pip enters the picture. Without pip, there is no bridge between "AI wrote the code" and "the code actually runs."

Here is the pattern you will see over and over:

1. You ask your AI to build something in Python
2. The AI writes a script that starts with several import statements
3. You run the script
4. Python throws ModuleNotFoundError: No module named 'some_package'
5. You run pip install some_package
6. You run the script again — it works

That cycle will happen hundreds of times in your journey. pip is the step between "AI wrote it" and "it works on your machine." Understanding it means you stop panicking at ModuleNotFoundError and start fixing it in five seconds.

Real Scenario

You ask Claude to build a Python script that checks the weather and sends you an email summary. Claude writes this:

Write a Python script that fetches the current weather for 
Coeur d'Alene, Idaho using the OpenWeatherMap API, formats 
it nicely, and sends me an email with the summary using SMTP.

Claude generates a clean script. The first few lines look like this:

import requests
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from dotenv import load_dotenv
import os
import schedule
import time

You save it as weather.py, open your terminal, and run python weather.py. Immediately:

Traceback (most recent call last):
  File "weather.py", line 1, in <module>
    import requests
ModuleNotFoundError: No module named 'requests'

The script has seven imports. Some of them — smtplib, os, time, and the email modules — are part of Python's standard library. They come free with Python. But three of them — requests, python-dotenv (which provides dotenv), and schedule — are third-party packages. They need to be installed via pip.

The fix:

pip install requests python-dotenv schedule

Now run python weather.py again. It works. That is pip doing its job — downloading code from the internet and putting it where Python can find it.

Essential pip Commands

You do not need to memorize dozens of commands. These six cover 95% of what you will ever do with pip.

pip install — the command you will use most

Install a single package:

pip install requests

Install multiple packages at once:

pip install requests flask pandas

Install a specific version (useful when AI-generated code depends on a particular version):

pip install requests==2.31.0

pip downloads the package from the Python Package Index (PyPI) — a public registry hosting over 500,000 Python packages as of 2026. Think of PyPI as Python's version of the npm registry.

pip install -r requirements.txt — install everything at once

If a project includes a requirements.txt file (most do, or should), this command installs every package listed in it:

pip install -r requirements.txt

This is the Python equivalent of npm install in a JavaScript project. One command, all dependencies handled.

pip freeze — snapshot your installed packages

pip freeze

This prints every installed package and its exact version number. The output looks like:

certifi==2024.2.2
charset-normalizer==3.3.2
flask==3.0.2
idna==3.6
requests==2.31.0
schedule==1.2.1
urllib3==2.2.1

You will almost always redirect this into a file:

pip freeze > requirements.txt

That creates your requirements.txt. More on this in the next section.

pip list — see what is installed

pip list

Similar to pip freeze, but formatted as a table and includes packages that freeze might skip (like pip itself). Use this when you want a quick look at what is installed.

pip uninstall — remove a package

pip uninstall requests

pip will ask for confirmation before removing it. Add -y to skip the prompt:

pip uninstall -y requests

pip show — get info about a package

pip show flask

This tells you the version, where it is installed, what it depends on, and what depends on it. Useful for debugging dependency chains when something breaks.

requirements.txt — Your Project's Shopping List

requirements.txt is a plain text file that lists every package your project needs. It is Python's version of JavaScript's package.json — but much simpler. No nested objects, no scripts section, no devDependencies distinction. Just a flat list of packages and versions.

A typical requirements.txt looks like this:

requests==2.31.0
flask==3.0.2
python-dotenv==1.0.1
schedule==1.2.1
gunicorn==21.2.0

Why it matters:

• Reproducibility. Without requirements.txt, anyone who clones your project has to guess which packages to install. With it, they run one command and everything works.
• Deployment. Platforms like Railway, Render, Heroku, and AWS all look for requirements.txt to know what to install. No file, no deployment.
• Collaboration. If you share your project on GitHub, requirements.txt tells other people exactly what your code depends on.

How to create one:

# Option 1: Capture everything currently installed
pip freeze > requirements.txt

# Option 2: Write it manually (just the packages you actually use)
# Create a file called requirements.txt and add:
requests==2.31.0
flask==3.0.2
python-dotenv==1.0.1

Option 1 is fast but includes everything — even sub-dependencies you did not install directly. Option 2 is cleaner but requires you to know which packages your code actually imports. For most vibe coders, Option 1 is the right starting point. You can always trim it later.

Virtual Environments — Why You Need Them

Here is a problem that bites every Python developer eventually: you have two projects. Project A needs flask==2.3.0. Project B needs flask==3.0.2. If pip installs packages globally (which it does by default), you can only have one version of Flask on your machine at a time. Installing Flask 3 for Project B breaks Project A.

Virtual environments solve this. A virtual environment is an isolated Python installation — a self-contained folder with its own copy of Python and its own set of installed packages. Each project gets its own environment. No conflicts.

Creating a virtual environment

# Navigate to your project folder
cd my-project

# Create a virtual environment called "venv"
python -m venv venv

This creates a folder called venv inside your project directory. It contains a copy of Python and an empty set of packages.

Activating the virtual environment

# On macOS / Linux:
source venv/bin/activate

# On Windows:
venv\Scripts\activate

Once activated, your terminal prompt changes — usually showing (venv) at the beginning. This tells you that any pip install commands will install packages into this environment only, not globally.

Deactivating

deactivate

That exits the virtual environment and returns you to the global Python installation.

The complete workflow

# 1. Create your project folder
mkdir my-ai-project && cd my-ai-project

# 2. Create a virtual environment
python -m venv venv

# 3. Activate it
source venv/bin/activate    # macOS/Linux
# venv\Scripts\activate     # Windows

# 4. Install packages (they go into the venv, not globally)
pip install requests flask python-dotenv

# 5. Save your dependencies
pip freeze > requirements.txt

# 6. Write and run your code
python app.py

# 7. When done, deactivate
deactivate

When someone else clones your project, they create their own virtual environment and install from your requirements.txt:

python -m venv venv
source venv/bin/activate
pip install -r requirements.txt

pip vs npm — A Comparison

If you have already read our npm guide or you are coming from a JavaScript background, this comparison table will help map concepts between the two ecosystems.

The biggest difference for vibe coders: npm isolates packages per-project automatically (they go into node_modules inside your project folder). pip installs globally by default — which is why virtual environments exist. If you are used to npm, think of python -m venv venv && source venv/bin/activate as the extra step Python requires to get npm-like isolation.

What AI Gets Wrong About pip

AI assistants are generally good at writing Python import statements. They are less good at making sure you can actually install and run the code. Here are the recurring mistakes.

Forgetting requirements.txt entirely

This is the number one AI blind spot with Python projects. The AI generates a script with import requests, import flask, import pandas — and never mentions that you need to install any of them. It just assumes they are there. Always check: does the AI's output include a requirements.txt or a list of pip install commands? If not, ask for one.

Using the wrong Python version

Many machines have both Python 2 and Python 3 installed. On macOS, python might point to Python 2 (which is ancient and deprecated), while python3 points to Python 3. The same applies to pip vs pip3. AI often writes pip install when you might need pip3 install. If pip install gives you errors or installs packages into the wrong Python version, try:

python3 -m pip install requests

Using python3 -m pip explicitly ties pip to the Python 3 installation — no ambiguity.

Installing globally when you should use a virtual environment

AI almost never tells you to create a virtual environment first. It jumps straight to pip install flask. For a quick one-off script, that is fine. For any real project — especially one you will deploy or share — install into a virtual environment. Global installs eventually create version conflicts that are painful to debug.

Package name does not match import name

This one is genuinely confusing. Some Python packages have a different install name than import name. For example:

• You import cv2 — but you pip install opencv-python
• You import PIL — but you pip install Pillow
• You import dotenv — but you pip install python-dotenv
• You import yaml — but you pip install PyYAML
• You import bs4 — but you pip install beautifulsoup4

AI usually gets these right in the code, but when listing install commands, it sometimes uses the import name instead of the package name. If pip install something says "no matching distribution found," the package might just have a different name on PyPI.

Not pinning versions

AI writes pip install flask, which installs the latest version. But if you are following a tutorial from six months ago or the AI's training data references an older API, you might need a specific version. A requirements.txt with pinned versions (like flask==3.0.2) prevents the "it worked yesterday, it is broken today" problem.

How to Debug pip Problems With AI

When pip errors happen, they can look intimidating — walls of red text, tracebacks, and cryptic error codes. Here is how to handle the most common ones.

The best debugging strategy: copy the entire error message and paste it into your AI assistant. Say: "I ran pip install flask and got this error. What is wrong and how do I fix it?" The exact error text is what your AI needs — do not paraphrase or summarize it.

What to Learn Next

Now that you understand pip, several related concepts become much clearer:

• What Is npm? — If you work with both Python and JavaScript (and most AI-assisted developers do), npm is pip's counterpart for the JavaScript ecosystem. Understanding both means you can handle dependencies regardless of language.
• What Is a Package Manager? — The big picture of why pip, npm, and similar tools exist. Understanding the concept helps you pick up any new package manager instantly.
• What Is Python? — If you jumped straight to using AI-generated Python code without understanding the language itself, this guide fills in the foundations.
• What Is Git? — You commit requirements.txt to Git and add venv/ to .gitignore. Git and pip work hand-in-hand for any shareable Python project.
• What Is an Environment Variable? — After pip installs your packages, the next thing AI wants you to set up is environment variables for API keys and secrets. The python-dotenv package you installed with pip is how Python reads .env files.

FAQ