How to Install Python on Windows, macOS, and Linux

Installing Python means adding the Python interpreter and its supporting tools to your computer so you can run Python code locally. Depending on your operating system, learning how to install Python involves different workflows:

Windows users typically rely on the official installer, macOS users can choose between the python.org package or Homebrew, and Linux users generally install through their distribution’s native package manager.

As a core technology across software engineering, data science, and artificial intelligence, mastering how to install Python correctly is the critical first step before building local projects or following structured programming curricula. Without a proper setup, configuring dependencies and running scripts becomes an immediate bottleneck.

Whether you are a beginner setting up your first development environment or an experienced engineer configuring a new machine, this comprehensive guide demonstrates how to install Python on Windows, macOS, and Linux. You will learn step-by-step setup methods, version verification, virtual environment management, and how to resolve common path configuration errors.

What You Need Before Installing Python

Before learning how to install Python on your machine, ensure your system meets these basic prerequisites:

• Supported Operating System: A functional, updated installation of Windows, macOS, or a Linux distribution.
• System Administrator Rights: Administrative privileges or sudo access to install system software and manage environment variables.
• Active Internet Connection: Required to download installers or fetch packages via package managers.
• Terminal or Command-Line Access:
  • Windows: Windows Terminal, PowerShell, or Command Prompt (cmd).
  • macOS: Terminal (Applications > Utilities > Terminal).
  • Linux: Your distribution’s default terminal application (e.g., GNOME Terminal, Konsole).

Step 1: Check for Existing Python Installations

Many operating systems come with Python pre-installed. Before walking through how to install Python, check if a compatible version already exists on your system.

Run the following commands in your system terminal (do not enter these inside Python’s >>> interactive interpreter):

Windows:

Bash

python --version
py --version

macOS or Linux:

Bash

python3 --version

If your terminal outputs a version number formatted as Python 3.x.x, Python 3 is already active. You can proceed with that version or continue below to update to the latest release.

Security Note: Trusted Download Sources

To keep your development environment secure, always obtain installation packages from verified official sources:

• Official Website: Direct downloads from python.org.
• App Stores: Official Microsoft Store listings linked directly from python.org.
• Official Package Repositories: Native system package managers (e.g., brew on macOS, apt or dnf on Linux).

Security Warning: Avoid downloading Python binaries from third-party sites or unverified software repositories.

Which Python Version Should You Install?

Most beginners learning how to install Python should choose the latest stable Python 3 release supported by their operating system and development tools.

The latest stable feature series is Python 3.14 (with Python 3.14.6 as the current maintenance release). Because release cycles update regularly, always check the official python.org downloads page to verify the most up-to-date stable release.

Key Rules for Choosing a Version

• Default Choice: Install the latest stable 3.x release for general learning, script automation, and new projects.
• Targeted Requirements: Choose a specific older release only if mandated by a course, employer, legacy codebase, or deployment target (e.g., AWS Lambda, Heroku).
• Avoid Pre-Releases: Do not use Alpha, Beta, or Release Candidate (RC) builds for daily development or production environments. These builds exist strictly for testing upcoming core engine changes.

The Newest Release Trade-Off

Before finalizing how to install Python on your primary machine, consider the trade-offs of using the newest release versus a mature release:

Best Practice: If joining an existing team or codebase, always mirror the exact Python version documented in the project’s README.md or environment specification file (runtime.txt, .python-version) rather than upgrading independently.

Which Installation Method Should You Choose?

When deciding how to install Python, select the official installation method that aligns with your operating system and preferred updating strategy.

Because Python is completely free and open source, there are no licensing decisions or subscription tiers. Your main decision is determining who or what will manage updates and system paths over time: the Python installer, system package managers, or dedicated version management tools.

Python Installation Methods Compared

Practical Recommendations

• Windows: Use the Python Install Manager. It simplifies multi-version handling and PATH configuration.
• macOS: Use the official python.org .pkg installer if you are new to terminal environments. Use Homebrew if you already manage your dev stack via CLI.
• Linux: Use your distribution’s native package manager (sudo apt install python3 on Ubuntu/Debian, sudo dnf install python3 on Fedora).
• Avoid Source Builds: Do not attempt to compile Python from source code for your first setup unless you have strict custom build requirements.

How to Install Python on Windows

To set up Python on Windows, install the official Python Install Manager, use it to install the current stable Python runtime, and verify the executable paths from your command line.

Python’s official Windows documentation recommends using the Python Install Manager. It is available via direct download from python.org or through the Microsoft Store (both packages are functionally identical).

Download the Python Install Manager: Official installer options.

• Go to the official python.org downloads page.
• Select the download for the Python Install Manager, or navigate to the official Microsoft Store listing.
• If you downloaded the executable file, double-click it and select Install.

Note: Standard per-user installations generally do not require system administrator privileges. However, enterprise or educational network policies may restrict store apps or MSIX installers.

Install the Default Python Runtime: Executing installation via CLI.

Open a fresh PowerShell or Command Prompt window and run:

Bash

py install default
Code language: JavaScript (javascript)

The default argument instructs the manager to pull and configure the latest stable Python runtime.

If your project specifically requires a particular release version, you can specify it directly:

Bash

py install 3.14
Code language: CSS (css)

(Running the bare python command on a fresh Windows system without a runtime configured can also prompt automatic installation of the latest stable build, but running py install explicitly ensures control over the runtime environment.)

Verify the Windows Installation: Checking Python and Pip pathing.

In your terminal, execute the following commands to verify that the launcher, interpreter, and package manager are mapped correctly:

Bash

python --version
py list
py -m pip --version
Code language: PHP (php)

• python --version: Confirms that the main Python executable is active and displays the active version.
• py list: Displays all Python runtimes currently indexed by the Python Install Manager.
• py -m pip --version: Ensures the pip package manager is attached directly to the active py runtime environment.

Do You Need to Add Python to PATH on Windows?

When learning how to install Python on Windows using the modern Python Install Manager, you usually do not need to edit system PATH environment variables manually.

The Install Manager automatically registers python, py, and pymanager using Windows App Execution Aliases. For most beginners and general workflows, manual PATH configuration is unnecessary and can cause conflicting version paths if configured incorrectly.

Understanding Extra PATH Configurations

While the core launcher works out of the box, specific development scenarios interact with PATH differently:

• User Binaries (%LocalAppData%\Python\bin): The installer may offer to add this directory to PATH for optional versioned aliases. If you execute scripts using python, py, or py -m pip, this step remains optional.
• Global Package Scripts (Scripts/ folder): When you install third-party command-line tools using pip install <package> globally, their binaries are placed inside a specific runtime’s Scripts directory. To run these tools directly by name, that directory must be in your PATH—or you should run them inside an activated virtual environment (the recommended best practice).

Troubleshooting Windows App Execution Aliases

If typing python in Command Prompt or PowerShell opens the Microsoft Store or returns 'python' is not recognized as an internal or external command, follow these diagnostic steps:

• Enable App Execution Aliases:
  • Open the Start Menu and search for Manage app execution aliases.
  • Locate App Installer – python.exe and App Installer – python3.exe.
  • Toggle both settings to On.
• Verify User Profile PATH Variable:
  • Open System Properties (sysdm.cpl) > Advanced > Environment Variables.
  • Under User variables, check that %UserProfile%\AppData\Local\Microsoft\WindowsApps exists in the PATH list. This directory allows Windows to route the python alias directly to the Python Install Manager.

What About the Older Windows .exe Installer?

Older Python releases (Python 3.12 and earlier) and certain enterprise environments frequently use standalone executable installers (python-3.x.x-amd64.exe).

If your workflow requires using a legacy .exe executable rather than the modern Install Manager, keep these key factors in mind when learning how to install Python:

• Check the PATH Checkbox: During setup, you must manually check the box that says “Add python.exe to PATH” on the first wizard screen. Omitting this causes 'python' is not recognized terminal errors.
• Avoid Mixing Installers: Do not run both the old .exe installer and the new Python Install Manager simultaneously on the same system without isolation. Mixing them can create conflicting execution aliases and path precedence issues.
• Follow Release-Specific Docs: Always refer to the exact documentation for that specific Python release series.

Recommendation: For any new personal setup, project, or development machine, stick with the Python Install Manager. It handles multi-version management cleaner and requires less manual environment maintenance over time.

How to Install Python on macOS

For a straightforward graphical setup on macOS, download and run the official Universal2 package from python.org, then complete its root certificate configuration.

The official macOS package (.pkg) is built as a Universal2 binary, meaning it runs natively on both Apple Silicon (M1/M2/M3/M4 chips) and Intel-based Macs.

Check Existing System Python Command: Identify pre-existing Apple CLI tools.

Open Terminal (Command + Space > type Terminal) and check for an existing Python executable:

Bash

python3 --version

Note: macOS often ships with a system-managed python3 stub linked to Xcode Command Line Tools. Do not modify or delete Apple’s system Python files. The official python.org framework will co-exist safely alongside Apple’s built-in toolchain.

Download and Run the Package Installer: Download and execute the GUI installer.

• Visit the official python.org downloads page.
• Download the latest macOS 64-bit Universal2 installer (.pkg).
• Double-click the downloaded .pkg file to open the installation wizard.
• Follow the prompts through the license agreement and click Install.

Because the python.org installer installs the Python framework system-wide for all users, macOS will prompt you to enter your administrator password.

Install the Included SSL Certificates: Required for SSL/TLS network requests.

Once the main installer wizard completes, open Finder and navigate to Applications > Python 3.x.

• Double-click the file named Install Certificates.command.
• A Terminal window will launch and download the required certifi SSL root certificates.
• Wait until the terminal output prints [Command completed] before closing the window.

Crucial Note: If you skip this step, Python scripts attempting to make secure HTTPS web requests or fetch packages via pip will fail with SSL certificate verification errors.

Verify the Installation in Terminal: Confirm binary paths and pip linking.

Open a new Terminal window (to reload environment paths) and run:

Bash

python3 --version
python3 -m pip --version
python3 -c "import sys; print(sys.executable)"
Code language: JavaScript (javascript)

• python3 --version: Verifies the active Python 3 release.
• python3 -m pip --version: Confirms that pip is properly attached to the newly installed interpreter.
• sys.executable script: Prints the exact file system path of the running Python binary (typically /Library/Frameworks/Python.framework/Versions/3.x/bin/python3), helping you confirm you aren’t accidentally invoking Apple’s system binary.

Can You Install Python with Homebrew Instead?

Yes. If you already use Homebrew to manage software on macOS, installing Python via the terminal is a fast and efficient alternative to the graphical .pkg installer.

Homebrew compiles or fetches pre-built binaries (bottles) directly to its own system prefix, automatically handling path aliases and terminal dependencies.

Step-by-Step Homebrew Setup

Install Python via Homebrew

Open your terminal and run the installation command for the target release:

Bash

brew install python@3.14
Code language: CSS (css)

(If you run brew install python without specifying a version tag, Homebrew defaults to its current core Python formula.)

Verify Executable Precedence

Because macOS can host multiple Python installations (Apple’s Xcode Command Line Tools, python.org framework packages, and Homebrew), verify which executable your shell active path selects:

Bash

which -a python3
python3 -c "import sys; print(sys.executable)"
Code language: JavaScript (javascript)

• which -a python3: Displays all python3 binary paths available in your system PATH, ordered by priority.
• sys.executable script: Prints the exact location of the active interpreter. For Homebrew on Apple Silicon Macs, this typically points to /opt/homebrew/bin/python3 (or /usr/local/bin/python3 on Intel Macs).

Management Warning: Choose either Homebrew or the python.org installer as your primary Python setup. Mixing both management tools without regularly tracking active interpreter paths can lead to broken pip packages and virtual environment conflicts.

How to Install Python on Linux

To set up Python on Linux, use your distribution’s native package manager to install the core interpreter, pip, and virtual environment tooling.

Because many core Linux system utilities depend on Python, a version of Python 3 is often pre-installed. Before running installation scripts, verify whether it is already present:

Bash

python3 --version

If the command returns a version number but lacks pip or virtual environment capability, use the corresponding commands below to complete your setup.

Installation Commands by Distribution

Distribution Notes & Best Practices

• Debian & Ubuntu Derivatives: Package managers split Python components into smaller modular packages. Even if python3 is present, running python3 -m venv myenv will fail unless python3-venv is explicitly installed via apt.
• System Environment Protection (PEP 668): Modern Linux distributions enforce rules against running sudo pip install <package> directly into system libraries. Always use virtual environments (python3 -m venv) for personal code and third-party PyPI dependencies to prevent breaking OS-level tools.
• Minimal Installations & Containers: Stripped-down Linux environments (such as Docker images or minimal cloud instances) may omit Python entirely. Search your distribution’s package index if a specific sub-package name differs.

Why You Should Avoid Replacing the Linux System Python

When learning how to install Python on Linux, one critical rule governs system stability: never replace, delete, or overwrite the default system Python interpreter.

Many core Linux operating system tools—including package managers like apt (Debian/Ubuntu) and dnf (Fedora/RHEL), desktop configuration daemons, and system network utilities—are written directly in Python. Overwriting system binaries like /usr/bin/python3 or manually modifying system-level packages can break critical operating system functions.

Key System Management Risks

• Corrupting System Utilities: Removing or overwriting /usr/bin/python3 with a custom-compiled Python version breaks OS tools that rely on specific distribution-patched library structures.
• Global Dependency Conflicts: Running sudo pip install <package> installs third-party code directly into /usr/lib/python3/dist-packages/. Overwriting OS-managed libraries can cause system maintenance scripts to crash during routine Linux updates.

Understanding the PEP 668 Guardrail

Modern Linux distributions enforce PEP 668, which marks system Python installations as “externally managed environments.”

If you attempt to run pip install globally outside of a virtual environment, your terminal will block the execution and return an error:

Plaintext

error: externally-managed-environment

× This environment is externally managed
╰─> To install Python packages system-wide, try apt install... 
    or create a virtual environment using python3 -m venv.
Code language: HTTP (http)

Warning: Never use the --break-system-packages flag as a routine workaround to bypass PEP 668. Doing so overrides safety checks and risks corrupting core operating system tools.

The Correct Approach: Virtual Environments

Instead of altering the global system environment, create isolated project environments using the standard venv module:

Bash

# 1. Create a project directory and virtual environment
mkdir my_project && cd my_project
python3 -m venv .venv

# 2. Activate the isolated environment
source .venv/bin/activate

# 3. Safely install third-party packages
pip install requests
Code language: PHP (php)

Using virtual environments ensures your development packages remain completely isolated from the operating system, allowing you to install any library version without affecting Linux system stability.

What If the Repository’s Python Version Is Older?

When learning how to install Python on Linux, you may notice that your distribution’s default package manager (apt, dnf, zypper) ships a version slightly behind the newest release on python.org.

For most users, using the distribution-supported version is actually the safest choice. Operating system maintainers backport critical security fixes directly to that specific build, guaranteeing maximum stability with system libraries and desktop tools.

However, if your specific project, framework, or employer requires features from a newer release, you can install a newer interpreter safely without disrupting system binaries.

Modern Solutions for Running Newer Python Versions

Why You Should Avoid Compiling from Source

Compiling Python directly from source code (./configure, make, sudo make install) is an advanced option that should generally be avoided by beginners and intermediate developers.

• Missing Dependencies: Compiling requires manually downloading developer C libraries (like libssl-dev, zlib1g-dev, and libffi-dev). If any are missing, features like pip or HTTPS connections will fail post-build.
• Overwriting System Files: Running sudo make install without specifying a separate execution path can overwrite system binaries in /usr/bin/python3, corrupting your operating system tools. (If you must compile, always use sudo make altinstall to preserve default system links).
• Manual Updates: Source builds do not receive automatic security updates via system package managers—requiring you to manually re-compile every minor security release.

Rule of Thumb: Use a version manager like pyenv or containerized dev environments whenever a project demands a newer Python version than your Linux distribution provides natively.

How to Verify Python and Pip

After following the steps for how to install Python, you should always verify that both the interpreter and the pip package manager are correctly installed, wired to the right PATH environment, and executing properly from a fresh terminal window.

Verification Commands Matrix

Why Module Invocation (-m pip) Is Best Practice

The official Python Packaging User Guide recommends invoking pip using the -m pip module flag rather than typing a standalone pip or pip3 command.

• Prevents Environment Mismatches: On systems with multiple Python installations, a standalone pip command might install libraries into an old or unwanted Python installation directory.
• Guarantees Alignment: Running py -m pip (Windows) or python3 -m pip (macOS/Linux) guarantees that third-party packages are installed directly into the exact Python environment that the active terminal session is running.

Exiting the Interactive Shell

If you launch the interactive shell (python or python3) to test your setup, you will see the >>> prompt. To exit back to your standard terminal prompt:

• Command: Type exit() and press Enter.
• Keyboard Shortcut (Windows): Press Ctrl + Z, then press Enter.
• Keyboard Shortcut (macOS / Linux): Press Ctrl + D.

How to Run Your First Python Script

Once you have verified how to install Python, the final test of a working installation is creating a script file and running it through the interpreter.

To execute a script, write valid Python code in a plain-text file ending in .py, navigate to its directory in your terminal, and pass the filename to Python.

Create the Test Script File: Plain-text code file.

1. Open a plain-text editor (such as VS Code, Notepad, or TextEdit in plain text mode).
2. Create a new file named hello.py inside a dedicated project folder.
3. Add the following line of code:

Python

print("Python is working!")
Code language: PHP (php)

4. Save the file. Ensure the extension is strictly .py (avoid hidden .txt extensions like hello.py.txt).

Open Your Terminal in the File Location: Navigating directories in Terminal/PowerShell.

Open your command-line application and change your directory (cd) to the folder containing hello.py:

Bash

cd path/to/your/folder

• Windows Verification: Type dir to list files in your active folder.
• macOS / Linux Verification: Type ls to check file names, or pwd to check your full path directory.

Pass the File to the Python Interpreter: Executing the code.

Run the execution command corresponding to your operating system:

Windows:

Bash

python hello.py
Code language: CSS (css)

macOS / Linux:

Bash

python3 hello.py
Code language: CSS (css)

If configured correctly, your terminal will output:

Plaintext

Python is working!

Troubleshooting File Not Found Errors

If your terminal displays python: can't open file 'hello.py': [Errno 2] No such file or directory, your Python installation is working correctly—but the terminal is looking in the wrong folder.

• Confirm Current Folder: Run dir (Windows) or ls (macOS/Linux) to confirm hello.py is inside your active working directory.
• Check File Extensions: Ensure Windows or macOS file settings have not appended an extra extension (e.g., hello.py.txt). Rename the file if necessary.

Why You Should Create a Virtual Environment

When learning how to install Python and build projects, using virtual environments is a critical best practice. A virtual environment creates an isolated folder containing a self-contained Python binary and package directory.

Creating an isolated environment before installing third-party packages (like requests, pandas, or flask) ensures that:

• Dependencies Stay Isolated: Project A can use an older version of a library while Project B uses a newer version on the same computer without version conflicts.
• System Files Stay Protected: Prevents third-party packages from modifying or corrupting system-managed Python files (especially on Linux and macOS).
• Deployments Remain Clean: Allows you to generate accurate dependency files (requirements.txt) that list only the packages your specific project actually uses.

Step-by-Step Setup Guide

Always create and activate a virtual environment inside your project’s main folder before installing libraries with pip.

Windows Setup

PowerShell:

PowerShell

# Create the virtual environment folder named .venv
python -m venv .venv

# Activate the environment
.\.venv\Scripts\Activate.ps1

# Upgrade pip inside the active environment
python -m pip install --upgrade pip
Code language: PHP (php)

Command Prompt (cmd.exe):

DOS

:: Create the virtual environment
python -m venv .venv

:: Activate the environment
.venv\Scripts\activate.bat

:: Upgrade pip
python -m pip install --upgrade pip
Code language: CSS (css)

Note for PowerShell: If you see an error stating that script execution is disabled on your system, run Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser once to allow local script activation.

macOS & Linux Setup

Bash

# Create the virtual environment folder named .venv
python3 -m venv .venv

# Activate the environment
source .venv/bin/activate

# Upgrade pip inside the active environment
python -m pip install --upgrade pip
Code language: PHP (php)

Working Inside an Active Environment

Once activated, your terminal prompt will display (.venv) at the beginning of the line.

While activated:

• Running bare python and python -m pip will automatically route to the environment’s Python interpreter—even on macOS and Linux where python3 is normally required.
• Any library installed via pip install <package> stays locked strictly inside that project’s .venv folder.

To exit the environment when you finish working, simply run:

Bash

deactivate

The Trade-Off

The primary trade-off of virtual environments is adding a minor 10-second setup step whenever you launch a new project. In return, you eliminate broken dependencies, prevent global package clutter, and keep your primary Python installation clean and maintainable.

How Do You Fix Common Python Installation Problems?

Most installation issues stem from environment variable mismatches, multiple co-existing Python installations, or typing system commands directly into the Python interactive shell.

Before trying to fix a setup error, identify which command, executable path, and package manager your session is using.

Troubleshooting Matrix

Safe Cleanup Guidelines

If you encounter duplicate installations or version conflicts, do not attempt to fix the problem by manually deleting Python folders from your file system.

• Audit Active Paths: Run python3 -c "import sys; print(sys.executable)" (or py list on Windows) to map every installed runtime.
• Uninstall via Original Tools: Remove duplicate or unwanted versions using the exact package manager or installer that placed them there (e.g., Windows Settings Add/Remove Programs, brew uninstall, or sudo apt remove).
• Preserve OS Tools: Never delete system-managed Python files located in /usr/bin/python3 on Linux or system frameworks on macOS.

Python Installation Checklist

Use this high-signal checklist to confirm your environment is fully operational before launching new learning modules or software projects:

• [ ] Verified Source: Python 3 was installed directly from an official, trusted source (python.org, official Microsoft Store link, Homebrew, or system package manager).
• [ ] Interpreter Executable: Running python --version, py --version (Windows), or python3 --version (macOS/Linux) in a fresh terminal window outputs your expected version number.
• [ ] Package Manager Alignment: Running py -m pip --version (Windows) or python3 -m pip --version (macOS/Linux) successfully reports the active pip build attached to your interpreter.
• [ ] Path Audit: Executing python -c "import sys; print(sys.executable)" confirms the active binary path matches your intended installation directory.
• [ ] Script Test Failsafe: A basic hello.py test script containing print("Python is working!") executes cleanly without path or syntax errors.
• [ ] Virtual Environment Setup: You can create and activate an isolated project environment (python -m venv .venv or python3 -m venv .venv).
• [ ] Package Isolation: All third-party PyPI dependencies (requests, pandas, pytest) are installed strictly inside an active .venv environment, keeping global system paths clean.
• [ ] System Safety: System-managed Python installations (/usr/bin/python3 on Linux or Xcode command-line utilities on macOS) remain intact and uncorrupted.

In Conclusion

Learning how to install Python effectively requires choosing the right setup path for your primary operating system. Because environment management varies across platforms, matching your installation strategy to your OS guarantees a maintainable, conflict-free setup:

• Windows: Use the official Python Install Manager for the cleanest, most maintainable runtime configuration without manual PATH editing.
• macOS: Install the signed Universal2 package from python.org for a native graphical installation on Intel and Apple Silicon Macs, or leverage Homebrew if you prefer CLI-based environment management.
• Linux: Stick to distribution-managed package managers (apt, dnf, pacman) to preserve system stability, while utilizing virtual environments or version managers when a project requires newer language builds.

Final Implementation Checklist

Regardless of which OS workflow you execute when learning how to install Python, adhere to these universal post-installation steps before starting any programming course or software project:

• Verify Binary Paths: Confirm both python/python3 and pip binaries respond correctly from a fresh terminal window.
• Execute a Test Script: Run a basic .py file to verify interpreter execution end-to-end.
• Isolate Dependencies: Always create and activate a project-level virtual environment (.venv) before using pip to install third-party libraries.

For beginners, stick to the default official method recommended for your platform. For cross-platform developers and engineers, strictly follow each project’s documented Python runtime targets and verify binary path execution on every new machine.