📦 Virtual Environments and Package Management - pip, venv

Master Python's virtual environment and package management tools. Learn to create isolated environments, manage dependencies with pip, work with requirements.txt files, and follow best practices for Python project setup. Essential for professional Python development and project management.

🎯 Key Takeaways

Understanding why virtual environments are critical for Python development
Creating and managing virtual environments with venv
Installing and managing packages with pip
Working with requirements.txt for reproducible builds
Best practices for project structure and dependency management
Understanding package versioning and compatibility
Troubleshooting common virtual environment issues

📚 Detailed Introduction to Virtual Environments and Package Management

What Are Virtual Environments?

Virtual environments are isolated Python environments that allow you to maintain separate sets of packages and dependencies for different projects. Think of them as containers that hold a specific version of Python along with its own set of installed packages, completely independent from your system's global Python installation. This isolation is fundamental to modern Python development and is considered an essential practice for any serious Python project.

When you create a virtual environment, you're essentially creating a self-contained directory that contains a Python installation and a space for installing packages. This environment includes its own Python binary (or a symlink to it), its own pip installation, and its own site-packages directory where installed packages live. The beauty of this approach is that you can have multiple projects on the same machine, each with completely different—and even conflicting—package requirements, without any interference between them.

Why Virtual Environments Are Critical

The importance of virtual environments cannot be overstated in professional Python development. Imagine working on two different projects: one is a legacy application that requires Django 2.2, while another is a modern web application built with Django 4.2. Without virtual environments, you'd face an impossible situation—you can only have one version of Django installed globally. This scenario extends to countless packages across the Python ecosystem, where different projects may require different versions of the same library.

Beyond version conflicts, virtual environments provide several critical benefits. They keep your global Python installation clean and uncluttered, which is particularly important on Unix-based systems where system tools may depend on the system Python. They make your projects reproducible—a colleague can recreate your exact development environment by simply creating a virtual environment and installing from your requirements file. They also make deployment safer and more predictable, as you can test with the exact same package versions that will run in production.

Understanding pip: Python's Package Installer

pip (Pip Installs Packages) is Python's official package installer and the primary tool for installing packages from the Python Package Index (PyPI), which hosts hundreds of thousands of open-source Python packages. pip handles not just the installation of packages, but also manages their dependencies, versions, and updates. When you install a package with pip, it automatically resolves and installs all the dependencies that package needs, creating a complete, working installation.

Understanding how pip works is crucial for effective Python development. pip reads package metadata, resolves dependency trees, downloads packages from PyPI or other sources, and installs them into your Python environment's site-packages directory. It maintains a database of installed packages, allowing you to query what's installed, check for updates, and manage your project's dependencies. Modern pip versions also include powerful dependency resolution algorithms that can handle complex package relationships and version constraints, though this can sometimes lead to conflicts that require manual intervention.

Real-World Applications and Scenarios

In professional software development, virtual environments and proper package management are used in virtually every Python project. Web developers use them to manage Flask or Django applications with their specific dependencies. Data scientists create environments for different machine learning projects, each with specific versions of NumPy, Pandas, TensorFlow, or PyTorch. DevOps engineers use them to ensure consistent deployment environments across development, staging, and production servers. Even in education, virtual environments help students learn without polluting their system Python or running into mysterious conflicts.

🔍 Core Concepts and Terminology

Essential Terms You Need to Know

Virtual Environment (venv): An isolated Python environment with its own Python binary and package installation directory
pip: Python's package installer, used to install packages from PyPI or other sources
site-packages: The directory where pip installs packages within a Python environment
requirements.txt: A text file listing all packages and their versions needed for a project
PyPI (Python Package Index): The official repository of Python packages, accessible at pypi.org
Dependency: A package that another package needs to function properly
Activation: The process of switching your shell to use a specific virtual environment
Freeze: Creating a snapshot of all installed packages and their exact versions
Semantic Versioning: The version numbering scheme (MAJOR.MINOR.PATCH) used by most Python packages

Understanding Package Version Specifications

When specifying package versions in requirements files or pip commands, you can use various operators to control which versions are acceptable:

== - Exact version (e.g., requests==2.28.0)
>= - Minimum version (e.g., flask>=2.0.0)
<= - Maximum version (e.g., django<=4.0.0)
~= - Compatible version (e.g., numpy~=1.21.0 allows 1.21.x but not 1.22.0)
!= - Exclude specific version (e.g., requests!=2.27.0)

💻 Practical Examples with Detailed Code

Example 1: Setting Up Your First Virtual Environment

This comprehensive example walks through creating, activating, and using a virtual environment for a new project.

# Step 1: Create a new project directory
# This keeps your projects organized
mkdir my_data_project
cd my_data_project

# Step 2: Create a virtual environment named 'venv'
# The -m flag tells Python to run the venv module
# 'venv' is the name of the directory that will contain the environment
python -m venv venv

# Alternative: Specify a Python version if you have multiple installed
# python3.9 -m venv venv

# Step 3: Verify the virtual environment was created
# You should see a 'venv' directory with the following structure:
ls venv/
# Output shows:
# - bin/ (or Scripts/ on Windows) - contains activation scripts and Python binary
# - include/ - contains C headers for compiling Python packages
# - lib/ - contains the Python standard library and installed packages
# - pyvenv.cfg - configuration file with Python version and settings

# Step 4: Activate the virtual environment
# On Mac/Linux:
source venv/bin/activate

# On Windows Command Prompt:
# venv\Scripts\activate.bat

# On Windows PowerShell:
# venv\Scripts\Activate.ps1

# After activation, your prompt changes to show (venv):
# (venv) user@computer:~/my_data_project$

# Step 5: Verify you're using the virtual environment's Python
which python  # On Mac/Linux
# Output: /path/to/my_data_project/venv/bin/python

# where python  # On Windows
# Output: C:\path\to\my_data_project\venv\Scripts\python.exe

# Step 6: Check the Python version
python --version
# Output: Python 3.10.0 (or whatever version you used to create the venv)

# Step 7: Verify pip is using the virtual environment
which pip  # On Mac/Linux
# Output: /path/to/my_data_project/venv/bin/pip

# Step 8: Check what packages are installed (initially just pip and setuptools)
pip list
# Output:
# Package    Version
# ---------- -------
# pip        22.3.1
# setuptools 65.5.0

# Step 9: Upgrade pip to the latest version (recommended)
pip install --upgrade pip
# Output: Successfully installed pip-23.0.1

# Step 10: When you're done working, deactivate the environment
deactivate
# Your prompt returns to normal: user@computer:~/my_data_project$

# Step 11: Reactivate later when you return to work on the project
source venv/bin/activate  # Mac/Linux
# venv\Scripts\activate  # Windows

💡 Pro Tip: Always create your virtual environment before installing any packages. This ensures complete isolation from the start. Name your environment 'venv' or '.venv' as these are commonly recognized names that most tools and .gitignore templates will handle appropriately.

Example 2: Installing and Managing Packages with pip

This example demonstrates various pip commands for package management, from basic installation to advanced dependency handling.

# Ensure your virtual environment is activated first
source venv/bin/activate  # Mac/Linux
# venv\Scripts\activate  # Windows

# Example 1: Install a single package (latest version)
pip install requests
# Output:
# Collecting requests
# Downloading requests-2.28.2-py3-none-any.whl (62 kB)
# Collecting charset-normalizer<4,>=2
# Collecting idna<4,>=2.5
# Collecting urllib3<1.27,>=1.21.1
# Collecting certifi>=2017.4.17
# Installing collected packages: urllib3, idna, charset-normalizer, certifi, requests
# Successfully installed certifi-2022.12.7 charset-normalizer-3.0.1 idna-3.4 requests-2.28.2 urllib3-1.26.14

# Example 2: Install a specific version
pip install flask==2.2.2
# This ensures you get exactly version 2.2.2, useful for reproducibility

# Example 3: Install with version constraints
pip install "django>=4.0,<5.0"
# This installs the latest Django 4.x version but won't install 5.0

# Example 4: Install multiple packages at once
pip install numpy pandas matplotlib
# This installs all three packages and their dependencies

# Example 5: Install a package with extras (optional dependencies)
pip install "fastapi[all]"
# The [all] extra installs additional optional dependencies for FastAPI

# Example 6: Install from a Git repository
pip install git+https://github.com/psf/requests.git@main
# Installs the latest version from the main branch

# Example 7: Install in editable mode (for development)
# First, let's say you have a local package in ./mypackage
pip install -e ./mypackage
# The -e flag creates a link instead of copying files, so changes are immediately reflected

# Example 8: View detailed information about a package
pip show requests
# Output:
# Name: requests
# Version: 2.28.2
# Summary: Python HTTP for Humans.
# Home-page: https://requests.readthedocs.io
# Author: Kenneth Reitz
# License: Apache 2.0
# Location: /path/to/venv/lib/python3.10/site-packages
# Requires: certifi, charset-normalizer, idna, urllib3
# Required-by: 

# Example 9: List all installed packages
pip list
# Output shows a table of all packages with versions

# Example 10: List outdated packages
pip list --outdated
# Shows packages that have newer versions available

# Example 11: Upgrade a package to the latest version
pip install --upgrade requests
# Updates requests to the newest available version

# Example 12: Uninstall a package
pip uninstall flask
# Prompts for confirmation, then removes the package

# Example 13: Uninstall without confirmation (useful in scripts)
pip uninstall -y pandas
# The -y flag automatically confirms the uninstall

# Example 14: Search for packages (deprecated in newer pip versions)
# pip search machine-learning
# Note: This feature was disabled due to PyPI infrastructure issues
# Use https://pypi.org/ to search instead

# Example 15: Check for dependency conflicts
pip check
# Output: No broken requirements found.
# Or lists any conflicting dependencies

# Example 16: Download packages without installing
pip download requests -d ./packages/
# Downloads requests and its dependencies to the ./packages/ directory

# Example 17: Install from a local wheel file
pip install ./packages/requests-2.28.2-py3-none-any.whl
# Useful for offline installations or custom builds

# Example 18: View pip configuration
pip config list
# Shows current pip configuration settings

# Example 19: Set pip to use a different index
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
# Useful in regions where the default PyPI is slow

# Example 20: Cache management
pip cache info
# Shows information about pip's cache

pip cache purge
# Clears pip's cache to free up disk space

⚠️ Common Mistake: Installing packages globally instead of in a virtual environment. Always activate your virtual environment before running pip install. You can verify you're in a virtual environment by checking if your prompt shows the environment name in parentheses.

Example 3: Creating and Using requirements.txt Files

The requirements.txt file is the standard way to specify project dependencies in Python. This example shows various techniques for creating and managing requirements files.

# scenario_requirements.py
"""
Demonstration of requirements.txt workflows in a real project.
This script simulates setting up a data science project with proper dependency management.
"""

import subprocess
import sys
from pathlib import Path

class ProjectSetup:
    """Handles virtual environment and dependency management for a Python project."""
    
    def __init__(self, project_name):
        self.project_name = project_name
        self.project_path = Path(project_name)
        self.venv_path = self.project_path / "venv"
        self.requirements_path = self.project_path / "requirements.txt"
        self.dev_requirements_path = self.project_path / "requirements-dev.txt"
        
    def create_project_structure(self):
        """Create the basic project directory structure."""
        print(f"Creating project structure for {self.project_name}...")
        self.project_path.mkdir(exist_ok=True)
        (self.project_path / "src").mkdir(exist_ok=True)
        (self.project_path / "tests").mkdir(exist_ok=True)
        (self.project_path / "data").mkdir(exist_ok=True)
        print("✓ Project structure created")
        
    def create_virtual_environment(self):
        """Create a virtual environment for the project."""
        print("\nCreating virtual environment...")
        subprocess.run([sys.executable, "-m", "venv", str(self.venv_path)])
        print("✓ Virtual environment created at", self.venv_path)
        
    def create_requirements_file(self):
        """Create a requirements.txt file with production dependencies."""
        print("\nCreating requirements.txt...")
        
        # Production dependencies for a data science project
        requirements = """# Core data science libraries
numpy==1.24.2
pandas==1.5.3
matplotlib==3.7.0
seaborn==0.12.2

# Machine learning
scikit-learn==1.2.1
scipy==1.10.0

# Web framework for serving models
flask==2.2.2
flask-cors==3.0.10

# API and HTTP
requests==2.28.2

# Database
sqlalchemy==2.0.4
psycopg2-binary==2.9.5

# Configuration and environment
python-dotenv==1.0.0

# Logging and monitoring
loguru==0.6.0
"""
        
        self.requirements_path.write_text(requirements)
        print("✓ requirements.txt created with production dependencies")
        
    def create_dev_requirements_file(self):
        """Create a requirements-dev.txt file with development dependencies."""
        print("\nCreating requirements-dev.txt...")
        
        # Development dependencies
        dev_requirements = """# Include production requirements
-r requirements.txt

# Testing
pytest==7.2.1
pytest-cov==4.0.0
pytest-mock==3.10.0

# Code quality
black==23.1.0
flake8==6.0.0
pylint==2.16.2
mypy==1.0.0

# Documentation
sphinx==6.1.3
sphinx-rtd-theme==1.2.0

# Development tools
ipython==8.10.0
jupyter==1.0.0
notebook==6.5.2

# Debugging
ipdb==0.13.11
"""
        
        self.dev_requirements_path.write_text(dev_requirements)
        print("✓ requirements-dev.txt created with development dependencies")
        
    def demonstrate_requirements_usage(self):
        """Show how to use requirements files."""
        print("\n" + "="*60)
        print("HOW TO USE THESE REQUIREMENTS FILES")
        print("="*60)
        
        print("\n1. Activate your virtual environment:")
        print("   Mac/Linux: source venv/bin/activate")
        print("   Windows:   venv\\Scripts\\activate")
        
        print("\n2. Install production dependencies:")
        print(f"   pip install -r {self.requirements_path}")
        
        print("\n3. For development, install dev dependencies:")
        print(f"   pip install -r {self.dev_requirements_path}")
        print("   (This includes production dependencies via -r requirements.txt)")
        
        print("\n4. After installing packages, freeze your environment:")
        print("   pip freeze > requirements.txt")
        print("   (This captures exact versions of all installed packages)")
        
        print("\n5. Update dependencies:")
        print("   pip install --upgrade -r requirements.txt")
        
        print("\n6. Check for security vulnerabilities:")
        print("   pip install safety")
        print("   safety check")
        
    def create_gitignore(self):
        """Create a .gitignore file to exclude virtual environment and other files."""
        print("\nCreating .gitignore...")
        
        gitignore_content = """# Virtual environment
venv/
env/
ENV/
.venv/

# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg

# IDE
.vscode/
.idea/
*.swp
*.swo
*~

# Testing
.coverage
htmlcov/
.pytest_cache/

# Data
data/raw/
data/processed/
*.csv
*.db
*.sqlite

# Environment variables
.env
.env.local

# OS
.DS_Store
Thumbs.db
"""
        
        gitignore_path = self.project_path / ".gitignore"
        gitignore_path.write_text(gitignore_content)
        print("✓ .gitignore created")
        
    def create_readme(self):
        """Create a README with setup instructions."""
        print("\nCreating README.md...")
        
        readme_content = f"""# {self.project_name}

## Setup Instructions

### Prerequisites
- Python 3.8 or higher
- pip

### Installation

1. Clone this repository:
   ```bash
   git clone 
   cd {self.project_name}
   ```

2. Create and activate a virtual environment:
   ```bash
   # Mac/Linux
   python -m venv venv
   source venv/bin/activate
   
   # Windows
   python -m venv venv
   venv\\Scripts\\activate
   ```

3. Install dependencies:
   ```bash
   # For production
   pip install -r requirements.txt
   
   # For development (includes production dependencies)
   pip install -r requirements-dev.txt
   ```

4. Set up environment variables:
   ```bash
   cp .env.example .env
   # Edit .env with your configuration
   ```

### Development

Run tests:
```bash
pytest
```

Format code:
```bash
black src/
```

Lint code:
```bash
flake8 src/
pylint src/
```

### Updating Dependencies

To update all packages to their latest versions:
```bash
pip install --upgrade -r requirements.txt
pip freeze > requirements.txt
```

To check for security vulnerabilities:
```bash
pip install safety
safety check
```

### Project Structure

```
{self.project_name}/
├── venv/                  # Virtual environment (not in git)
├── src/                   # Source code
├── tests/                 # Test files
├── data/                  # Data files (not in git)
├── requirements.txt       # Production dependencies
├── requirements-dev.txt   # Development dependencies
├── .gitignore            # Git ignore rules
└── README.md             # This file
```
"""
        
        readme_path = self.project_path / "README.md"
        readme_path.write_text(readme_content)
        print("✓ README.md created")

def main():
    """Main function to demonstrate project setup."""
    project = ProjectSetup("data_science_project")
    
    print("PYTHON PROJECT SETUP WITH REQUIREMENTS MANAGEMENT")
    print("=" * 60)
    
    # Create project structure
    project.create_project_structure()
    
    # Create virtual environment
    project.create_virtual_environment()
    
    # Create requirements files
    project.create_requirements_file()
    project.create_dev_requirements_file()
    
    # Create supporting files
    project.create_gitignore()
    project.create_readme()
    
    # Show usage instructions
    project.demonstrate_requirements_usage()
    
    print("\n" + "=" * 60)
    print("✓ Project setup complete!")
    print(f"✓ Navigate to '{project.project_name}' to start working")
    print("=" * 60)

if __name__ == "__main__":
    main()

Expected Output:

PYTHON PROJECT SETUP WITH REQUIREMENTS MANAGEMENT
============================================================
Creating project structure for data_science_project...
✓ Project structure created

Creating virtual environment...
✓ Virtual environment created at data_science_project/venv

Creating requirements.txt...
✓ requirements.txt created with production dependencies

Creating requirements-dev.txt...
✓ requirements-dev.txt created with development dependencies

Creating .gitignore...
✓ .gitignore created

Creating README.md...
✓ README.md created

============================================================
HOW TO USE THESE REQUIREMENTS FILES
============================================================

1. Activate your virtual environment:
   Mac/Linux: source venv/bin/activate
   Windows:   venv\Scripts\activate

2. Install production dependencies:
   pip install -r data_science_project/requirements.txt

3. For development, install dev dependencies:
   pip install -r data_science_project/requirements-dev.txt
   (This includes production dependencies via -r requirements.txt)

4. After installing packages, freeze your environment:
   pip freeze > requirements.txt
   (This captures exact versions of all installed packages)

5. Update dependencies:
   pip install --upgrade -r requirements.txt

6. Check for security vulnerabilities:
   pip install safety
   safety check

============================================================
✓ Project setup complete!
✓ Navigate to 'data_science_project' to start working
============================================================

💡 Best Practice: Separate production and development dependencies using two requirements files. The requirements-dev.txt file should include requirements.txt using the -r requirements.txt directive. This keeps your production deployments lean while providing all necessary tools for development.

Example 4: Advanced Package Management Scenarios

This example covers advanced scenarios like handling dependency conflicts, working with private packages, and managing multiple environments.

# advanced_package_management.py
"""
Advanced package management techniques including conflict resolution,
version pinning strategies, and environment management.
"""

import subprocess
import json
from pathlib import Path
from typing import List, Dict, Tuple

class DependencyManager:
    """Advanced dependency management tools."""
    
    @staticmethod
    def analyze_dependencies(package_name: str) -> Dict:
        """
        Analyze a package's dependency tree.
        
        Args:
            package_name: Name of the package to analyze
            
        Returns:
            Dictionary containing dependency information
        """
        print(f"\nAnalyzing dependencies for {package_name}...")
        
        # Get package information
        result = subprocess.run(
            ["pip", "show", package_name],
            capture_output=True,
            text=True
        )
        
        if result.returncode != 0:
            print(f"Package {package_name} not found")
            return {}
        
        # Parse the output
        info = {}
        for line in result.stdout.split('\n'):
            if ':' in line:
                key, value = line.split(':', 1)
                info[key.strip()] = value.strip()
        
        print(f"Package: {info.get('Name', 'Unknown')}")
        print(f"Version: {info.get('Version', 'Unknown')}")
        print(f"Requires: {info.get('Requires', 'None')}")
        print(f"Required-by: {info.get('Required-by', 'None')}")
        
        return info
    
    @staticmethod
    def check_conflicts() -> List[str]:
        """
        Check for dependency conflicts in the current environment.
        
        Returns:
            List of conflict messages
        """
        print("\nChecking for dependency conflicts...")
        
        result = subprocess.run(
            ["pip", "check"],
            capture_output=True,
            text=True
        )
        
        if result.returncode == 0:
            print("✓ No conflicts found")
            return []
        else:
            conflicts = result.stdout.strip().split('\n')
            print(f"⚠ Found {len(conflicts)} conflicts:")
            for conflict in conflicts:
                print(f"  - {conflict}")
            return conflicts
    
    @staticmethod
    def create_lockfile():
        """
        Create a lock file with exact versions of all dependencies.
        Similar to package-lock.json in Node.js or Gemfile.lock in Ruby.
        """
        print("\nCreating lock file...")
        
        # Get all installed packages with exact versions
        result = subprocess.run(
            ["pip", "freeze"],
            capture_output=True,
            text=True
        )
        
        if result.returncode != 0:
            print("Error creating lock file")
            return
        
        # Write to requirements.lock
        lock_content = result.stdout
        Path("requirements.lock").write_text(lock_content)
        
        print("✓ Lock file created: requirements.lock")
        print("\nLock file contains:")
        print(lock_content[:500] + "..." if len(lock_content) > 500 else lock_content)
        
        return lock_content
    
    @staticmethod
    def pin_transitive_dependencies():
        """
        Create a requirements file that pins all dependencies,
        including transitive ones (dependencies of dependencies).
        """
        print("\nPinning all dependencies (including transitive)...")
        
        # Get current direct dependencies
        if not Path("requirements.txt").exists():
            print("requirements.txt not found")
            return
        
        direct_deps = Path("requirements.txt").read_text().split('\n')
        direct_deps = [d.split('==')[0].split('>=')[0].split('~=')[0].strip() 
                      for d in direct_deps if d and not d.startswith('#')]
        
        # Get all installed packages
        result = subprocess.run(
            ["pip", "freeze"],
            capture_output=True,
            text=True
        )
        
        all_packages = result.stdout
        
        # Create a comprehensive requirements file
        comprehensive_req = f"""# Comprehensive requirements with all dependencies pinned
# Generated automatically - do not edit manually
# Direct dependencies are marked, others are transitive

# Direct dependencies:
"""
        for dep in direct_deps:
            for line in all_packages.split('\n'):
                if line.startswith(dep + '=='):
                    comprehensive_req += line + "\n"
                    break
        
        comprehensive_req += "\n# Transitive dependencies:\n"
        for line in all_packages.split('\n'):
            if line and not any(line.startswith(dep + '==') for dep in direct_deps):
                comprehensive_req += line + "\n"
        
        Path("requirements-pinned.txt").write_text(comprehensive_req)
        print("✓ Created requirements-pinned.txt with all dependencies")
    
    @staticmethod
    def compare_environments(env1_requirements: str, env2_requirements: str):
        """
        Compare two requirements files to see differences.
        
        Args:
            env1_requirements: Path to first requirements file
            env2_requirements: Path to second requirements file
        """
        print(f"\nComparing {env1_requirements} and {env2_requirements}...")
        
        def parse_requirements(filepath: str) -> Dict[str, str]:
            """Parse requirements file into package: version dict."""
            packages = {}
            if Path(filepath).exists():
                for line in Path(filepath).read_text().split('\n'):
                    line = line.strip()
                    if line and not line.startswith('#'):
                        if '==' in line:
                            name, version = line.split('==')
                            packages[name.strip()] = version.strip()
            return packages
        
        env1 = parse_requirements(env1_requirements)
        env2 = parse_requirements(env2_requirements)
        
        # Find differences
        only_in_env1 = set(env1.keys()) - set(env2.keys())
        only_in_env2 = set(env2.keys()) - set(env1.keys())
        common = set(env1.keys()) & set(env2.keys())
        different_versions = {pkg: (env1[pkg], env2[pkg]) 
                            for pkg in common if env1[pkg] != env2[pkg]}
        
        print("\n📊 Comparison Results:")
        print(f"\nPackages only in {env1_requirements}: {len(only_in_env1)}")
        for pkg in sorted(only_in_env1):
            print(f"  - {pkg}=={env1[pkg]}")
        
        print(f"\nPackages only in {env2_requirements}: {len(only_in_env2)}")
        for pkg in sorted(only_in_env2):
            print(f"  + {pkg}=={env2[pkg]}")
        
        print(f"\nPackages with different versions: {len(different_versions)}")
        for pkg, (v1, v2) in sorted(different_versions.items()):
            print(f"  ~ {pkg}: {v1} → {v2}")
        
        print

Complete Python Programming: From Fundamentals to Advanced

Python Fundamentals

Functions and Modules

Data Structures

Object-Oriented Programming

File Handling and Exception Handling

Advanced Python Concepts