Dependency Management in Python: Mastering Pip, Virtual Environments, and Poetry

Suptojit Modak

March 18, 2026 March 18, 2026

Welcome to Cyber Supto! I'm Supto.

When building Python projects, you rarely work with only the built-in libraries. Most real-world applications depend on external packages such as web frameworks, data analysis libraries, or automation tools.

Managing these external libraries properly is called dependency management. If dependencies are not handled correctly, projects may break due to version conflicts, missing packages, or environment inconsistencies.

Professional Python developers rely on three essential tools for dependency management:

pip – Python’s default package installer
Virtual Environments – Isolated environments for projects
Poetry – A modern tool for dependency and project management

In this guide, we will explore how these tools work together to create reliable and reproducible Python environments.

What is Dependency Management?

Dependencies are external libraries that a project needs to function properly.

For example, a web application might depend on:

Flask or Django
Requests
SQLAlchemy

Dependency management ensures that:

The correct versions of libraries are installed
Projects remain isolated from each other
Other developers can reproduce the same environment

Problem Without Dependency Management	Example
Version conflicts	Project A needs requests 2.25 but Project B needs 2.31
Broken environments	Installing a new library breaks an existing project
Unreproducible setups	Another developer cannot run the project

Understanding pip

pip is Python’s default package manager used to install external libraries from the Python Package Index (PyPI).

Basic pip commands:

pip install requests

This installs the requests library.

Check installed packages:

pip list

Upgrade a package:

pip install --upgrade requests

Uninstall a package:

pip uninstall requests

Installing Specific Versions

Sometimes your project requires a specific version of a library.

pip install django==4.2

This ensures compatibility with the application.

Using requirements.txt

Professional projects often include a requirements.txt file that lists dependencies.

Example:

flask==3.0.0
requests==2.31.0
pandas==2.1.0

Install all dependencies:

pip install -r requirements.txt

Generate a requirements file:

pip freeze > requirements.txt

Command	Purpose
pip freeze	Lists installed packages
pip install -r	Install packages from file

Why Virtual Environments Are Important

Installing packages globally can cause conflicts between projects.

Virtual environments solve this problem by creating isolated Python environments.

Each project gets its own environment with its own dependencies.

Without Virtual Environment	With Virtual Environment
Global packages conflict	Each project isolated
Hard to maintain	Clean dependency management
Version clashes	Project-specific versions

Creating a Virtual Environment

Python includes a built-in module called venv.

Create an environment:

python -m venv venv

This creates a folder named venv.

Activating the Environment

On Windows:

venv\Scripts\activate

On macOS/Linux:

source venv/bin/activate

After activation, packages installed with pip will only affect this environment.

Deactivating the Environment

deactivate

This returns the terminal to the global Python environment.

Introduction to Poetry

Poetry is a modern Python dependency management and packaging tool.

It simplifies tasks such as:

Dependency management
Virtual environment handling
Package publishing
Project configuration

Unlike pip and requirements.txt, Poetry manages dependencies using a pyproject.toml file.

Installing Poetry

pip install poetry

Verify installation:

poetry --version

Creating a New Poetry Project

poetry new myproject

This generates a structured project layout:

myproject/
├── pyproject.toml
├── README.md
└── myproject

Adding Dependencies with Poetry

poetry add requests

This automatically:

Installs the package
Updates pyproject.toml
Locks the version in poetry.lock

Installing Project Dependencies

poetry install

This installs everything defined in the project configuration.

Poetry vs Pip

Feature	Pip	Poetry
Dependency installation	Yes	Yes
Version locking	Manual	Automatic
Environment management	External tools needed	Built-in
Project management	No	Yes

Best Practices for Dependency Management

Always use virtual environments for projects
Pin dependency versions to avoid conflicts
Commit dependency files to version control
Avoid installing packages globally
Use modern tools like Poetry for larger projects

Real-World Development Workflow

A typical professional workflow looks like this:

Create project folder
Create virtual environment
Install dependencies
Track packages with requirements.txt or pyproject.toml
Share environment configuration with team

Frequently Asked Questions (FAQ)

What is pip used for?

pip installs and manages Python packages from the Python Package Index.

Why are virtual environments necessary?

They isolate dependencies so different projects can use different package versions without conflicts.

What is Poetry in Python?

Poetry is a modern tool that handles dependency management, packaging, and virtual environments in a unified workflow.

Should beginners use Poetry?

Beginners can start with pip and virtual environments, then move to Poetry for larger projects.

Can pip and Poetry be used together?

Yes, but typically projects choose one primary dependency management system.

Conclusion

Dependency management is a critical skill for modern Python developers. Tools like pip, virtual environments, and Poetry allow developers to build reliable, reproducible, and scalable applications.

By mastering these tools, you can avoid version conflicts, maintain clean project environments, and collaborate efficiently with other developers.

Professional Python workflows depend heavily on proper dependency management, making it an essential part of every developer’s toolkit.

Thanks for reading on Cyber Supto! I'm Supto.

Keep learning, keep building, and keep mastering Python development.

Python