Install Python on Ubuntu

By Khimananda Oli | Last reviewed: August 2026

You need to install Python on Ubuntu for application development, data engineering, or automation scripting, but blindly upgrading the system interpreter can break critical OS utilities like apt and cloud-init. The correct approach depends entirely on whether you are setting up a local development environment or provisioning a production server. This guide walks through safe installation methods that keep your base system stable while giving you access to modern Python runtimes.

How do you safely install Python on Ubuntu without breaking system tools?

The single most important rule when you install Python on Ubuntu is to never replace, symlink over, or uninstall the default python3 binary shipped with your release. Ubuntu 24.04 LTS (Noble Numbat) ships Python 3.12 as a core system dependency. Tools like apt, unattended-upgrades, cloud-init, and netplan rely on this specific interpreter and its associated standard library paths. Removing it will render your package manager inoperable and may prevent the system from booting correctly after a restart.

Instead, treat the system Python as an immutable OS component. When you need a different version for application development, install it alongside the system interpreter using one of three safe methods: the deadsnakes PPA for pre-built binaries, compiling from source for maximum control, or using containerized runtimes. Each method installs to separate prefixes or uses namespace isolation, ensuring zero conflict with Ubuntu's internal tooling. For teams managing infrastructure at scale, I recommend reading about automating server setup with Ansible playbooks to enforce these safety patterns consistently across fleets.

Verify your current system Python before proceeding

Before adding any new repositories or compiling code, confirm what Ubuntu currently provides. This baseline helps you troubleshoot later and ensures you don't accidentally mask the system binary.

# Check the default system Python version
/usr/bin/python3 --version

# Verify which package owns the binary
dpkg -S /usr/bin/python3

# List all installed Python interpreters
ls -la /usr/bin/python*

On a fresh Ubuntu 24.04 installation, you should see Python 3.12.x. On Ubuntu 22.04 LTS, expect Python 3.10.x. Document this version; if future commands change this output, stop immediately and investigate.

How do you use the deadsnakes PPA to install specific Python versions?

The deadsnakes PPA is the de facto standard for installing newer (or older) CPython versions on Ubuntu without touching system packages. Maintained by Felix Krull since 2015, it provides properly packaged .deb files that install to /usr/bin/python3.X without creating conflicting python3 symlinks. This is the recommended method for most developers who need to install Python on Ubuntu for web frameworks, data science, or AI workloads.

Step-by-step PPA installation

1. Add the PPA repository: The software-properties-common package provides the add-apt-repository command. Install it first if missing.
2. Update package indexes: Always refresh metadata after adding a new source.
3. Install the target version plus venv and dev headers: The base package alone is insufficient; you need -venv for virtual environments and -dev for compiling C extensions.
4. Verify the installation: Confirm the new binary exists and runs independently.

# Step 1: Install prerequisites and add deadsnakes PPA
sudo apt update
sudo apt install -y software-properties-common
sudo add-apt-repository ppa:deadsnakes/ppa -y

# Step 2: Refresh package lists
sudo apt update

# Step 3: Install Python 3.13 with venv and dev libraries
sudo apt install -y python3.13 python3.13-venv python3.13-dev

# Step 4: Verify installation
python3.13 --version
# Expected output: Python 3.13.x

# Confirm system Python is unchanged
python3 --version
# Should still show the original Ubuntu version

A common mistake is skipping the python3.13-venv package. Without it, running python3.13 -m venv myenv fails with "ensurepip is not available." The -dev package is equally critical if your project uses libraries like numpy, pandas, or cryptography that compile C extensions during pip install.

Managing multiple PPA-installed versions

You can install several Python versions simultaneously. Use update-alternatives only for convenience aliases, never to override /usr/bin/python3:

# Register alternatives for convenient switching (optional)
sudo update-alternatives --install /usr/local/bin/python python /usr/bin/python3.12 1
sudo update-alternatives --install /usr/local/bin/python python /usr/bin/python3.13 2

# Switch between registered versions interactively
sudo update-alternatives --config python

# Note: This creates /usr/local/bin/python, NOT /usr/bin/python3
# System tools continue using /usr/bin/python3 unaffected

When should you compile Python from source on Ubuntu?

Compiling from source is necessary when you require custom build flags (e.g., enabling --enable-optimizations for PGO, linking against a specific OpenSSL version, or disabling unused modules). It's also the only option for bleeding-edge releases not yet available in deadsnakes, or for air-gapped environments where PPA access is restricted. The trade-off is maintenance burden: you own security patching, dependency management, and rebuild cycles.

Install build dependencies

CPython requires several C libraries to compile core modules. Missing dependencies result in silent module failures (e.g., no SSL support, no sqlite3).

# Install all required build dependencies for CPython
sudo apt install -y build-essential zlib1g-dev libncurses5-dev \
    libgdbm-dev libnss3-dev libssl-dev libreadline-dev libffi-dev \
    libsqlite3-dev wget libbz2-dev liblzma-dev tk-dev uuid-dev

Download, configure, and compile

Always use make altinstall instead of make install. The latter overwrites /usr/local/bin/python3, which can still interfere with locally installed tools. altinstall installs only the versioned binary (e.g., python3.13).

# Download specific version (verify checksum in production!)
cd /tmp
wget https://www.python.org/ftp/python/3.13.0/Python-3.13.0.tgz
tar -xzf Python-3.13.0.tgz
cd Python-3.13.0

# Configure with performance optimizations
# --enable-optimizations runs profile-guided optimization (PGO)
# --with-lto enables link-time optimization
./configure --enable-optimizations --with-lto --prefix=/usr/local

# Compile using all available cores
make -j$(nproc)

# Install WITHOUT overwriting system python3
sudo make altinstall

# Verify
/usr/local/bin/python3.13 --version

The --enable-optimizations flag adds 20-30 minutes to build time but yields 10-15% runtime performance gains. Skip it only for quick testing. For production servers, always enable it.

How do you set up Python virtual environments on Ubuntu correctly?

Virtual environments are non-negotiable. They isolate project dependencies from both the system Python and other projects, preventing version conflicts and ensuring reproducible builds. Whether you installed via PPA or source, the workflow is identical.

Create and activate a virtual environment

# Create venv using your newly installed Python
python3.13 -m venv ~/projects/myapp/.venv

# Activate (bash/zsh)
source ~/projects/myapp/.venv/bin/activate

# Verify isolated Python and pip
which python      # Should show .venv/bin/python
python --version  # Should match 3.13.x
pip list          # Should show minimal packages

# Deactivate when done
deactivate

Never run pip install outside a virtual environment unless you're installing a system-wide CLI tool via pipx. Global pip installs pollute the interpreter's site-packages and create hidden dependencies that break during OS upgrades.

Common venv pitfalls and fixes

• "ensurepip is not available": Install python3.13-venv package (PPA) or ensure ensurepip module wasn't excluded during source compilation.
• SSL/TLS errors in pip: Missing libssl-dev at compile time. Rebuild Python with OpenSSL headers present.
• Permission denied on activation: Never use sudo with venv. If ownership is wrong, fix with chown -R $USER:$USER .venv.
• IDE not detecting venv: Point VS Code/PyCharm to .venv/bin/python explicitly. Don't rely on auto-detection.

What are the differences between apt, PPA, and source installations?

Choosing the right installation method affects security posture, maintenance overhead, and compatibility. Here's a practical comparison based on real-world usage across development and production environments.

For most teams, the deadsnakes PPA offers the best balance of flexibility and maintainability. Reserve source compilation for scenarios requiring specific optimizations or unsupported versions. In containerized deployments, consider using official python:3.13-slim images instead of installing Python on Ubuntu base images — this reduces attack surface and image size significantly. Teams working with AI workloads should also review self-hosting LLM options and GPU requirements, as Python environment setup directly impacts model serving performance.

How do you automate Python installation for production Ubuntu servers?

Manual installation doesn't scale. For production fleets, codify your Python setup using Infrastructure as Code. This ensures consistency, auditability, and rapid recovery. Whether you use Ansible, Terraform with cloud-init, or Dockerfiles, the principles remain the same: pin versions, validate checksums, and enforce virtual environment usage.

Ansible playbook example for fleet deployment

# tasks/python.yml
- name: Add deadsnakes PPA
  ansible.builtin.apt_repository:
    repo: ppa:deadsnakes/ppa
    state: present
    update_cache: true

- name: Install Python 3.13 with venv and dev
  ansible.builtin.apt:
    name:
      - python3.13
      - python3.13-venv
      - python3.13-dev
    state: present

- name: Verify Python installation
  ansible.builtin.command: python3.13 --version
  register: python_version
  changed_when: false

- name: Fail if wrong version installed
  ansible.builtin.fail:
    msg: "Expected Python 3.13, got {{ python_version.stdout }}"
  when: "'3.13' not in python_version.stdout"

This playbook is idempotent and safe to run repeatedly. Integrate it into your initial Ubuntu server setup workflow to ensure every new instance has a consistent Python environment from first boot. For teams adopting AI-assisted operations, exploring AIOps for infrastructure management can help detect configuration drift before it causes incidents.

Docker best practices for Python on Ubuntu

If you're containerizing applications, avoid installing Python on Ubuntu base images unless you have specific OS-level dependencies. Instead:

• Use python:3.13-slim-bookworm as your base — it's smaller, patched faster, and includes only essential runtime libraries.
• Pin exact versions in requirements.txt using pip-compile from pip-tools.
• Use multi-stage builds to exclude build dependencies from final images.
• Run as non-root user and set PYTHONUNBUFFERED=1 for proper log streaming.

Next Steps After You Install Python on Ubuntu

Getting Python installed correctly is just the foundation. Your next priorities should be establishing reproducible dependency management, integrating with your CI/CD pipeline, and implementing security scanning for third-party packages. Start by adopting pip-tools or poetry for deterministic builds, configure pre-commit hooks for linting and type checking, and add safety or pip-audit to your deployment checks. If you're building AI/ML workflows, pair your Python setup with proper MLOps practices for model deployment to bridge the gap between development and production. Need help designing a secure, scalable Python infrastructure for your team? Get in touch to discuss your specific requirements.