How Can I Check the Python Version on Linux?

AvatarByHarold Trujillo Linux & Open Source

In the world of programming and development, Python stands out as one of the most versatile and widely used languages. Whether you’re a seasoned developer or just starting your coding journey, knowing which version of Python is installed on your Linux system is essential. This knowledge not only helps ensure compatibility with various libraries and frameworks but also aids in troubleshooting and optimizing your development environment.

Checking the Python version on a Linux machine might seem straightforward, but there are nuances to consider, especially given the multiple Python versions that can coexist on the same system. Understanding how to quickly and accurately identify the installed version can save time and prevent potential conflicts in your projects. Moreover, this skill is fundamental when setting up virtual environments or deploying applications across different servers.

As you delve deeper, you’ll discover simple yet effective methods to verify your Python version using command-line tools native to Linux. This guide will equip you with the know-how to confidently manage your Python environment, ensuring your coding endeavors run smoothly and efficiently.

Checking Python Version Using the Terminal

On Linux systems, the most straightforward way to determine the installed Python version is through the terminal. This method involves executing specific commands that query the Python interpreter for its version information.

To check the default Python version, open your terminal and type:

“`bash
python –version
“`

or equivalently:

“`bash
python -V
“`

This command outputs the version of the Python interpreter linked to the `python` command. However, many Linux distributions now link `python` to Python 2.x or do not link it at all, favoring explicit version commands instead.

For modern systems with Python 3 installed, use:

“`bash
python3 –version
“`

or

“`bash
python3 -V
“`

These commands specifically check the version of Python 3 installed on your system, which is often the default for many contemporary Linux distributions.

If multiple Python versions coexist on your system, specifying the version number is useful. For example, to check Python 3.8 specifically, you can try:

“`bash
python3.8 –version
“`

If the command returns an error, that particular version may not be installed or not linked in your `PATH`.

Using Python Interpreter to Check Version

Another reliable way to check the Python version is by invoking the Python interpreter directly and inspecting the version information programmatically.

Run the following command to open the Python interpreter:

“`bash
python3
“`

Once inside the Python shell, execute the following commands:

“`python
import sys
print(sys.version)
“`

This will display detailed version information, including the Python version number, build date, and compiler information. For example:

“`
3.8.10 (default, May 3 2021, 08:55:58)
[GCC 9.3.0]
“`

You can also access just the major, minor, and micro version numbers with:

“`python
print(sys.version_info)
“`

which returns a tuple-like structure with fields such as `major`, `minor`, `micro`, `releaselevel`, and `serial`.

Checking Python Version Programmatically in Scripts

When writing Python scripts that need to verify or act based on the Python version, you can use the `sys` module to programmatically check the version at runtime. This is particularly useful for ensuring compatibility or for providing informative error messages.

Example:

“`python
import sys

if sys.version_info < (3, 6): sys.exit("Python 3.6 or higher is required.") else: print(f"Running Python version: {sys.version}") ``` This snippet exits the script if the Python interpreter is older than version 3.6, ensuring that your code only runs in compatible environments.

Summary of Common Commands to Check Python Version on Linux

Below is a table summarizing the most commonly used commands to check Python versions on Linux systems:

Command Description Typical Output
python --version Checks the default Python interpreter version (often Python 2.x or a symlink) Python 2.7.18
python3 --version Checks the installed Python 3 version Python 3.8.10
python3.x --version Checks a specific Python 3.x version (replace ‘x’ with minor version) Python 3.6.9
python -V Alternate syntax for checking default Python version Python 2.7.18
python3 -V Alternate syntax for checking Python 3 version Python 3.8.10

Additional Tips for Managing Multiple Python Versions

When multiple Python versions are installed on a Linux system, managing and selecting the default interpreter can be critical. Here are some useful points to consider:

  • Use `update-alternatives` (Debian/Ubuntu) to configure which Python version is the default:

“`bash
sudo update-alternatives –config python
“`

  • Use virtual environments (`venv` or `virtualenv`) to create isolated Python environments with specific versions and packages.
  • Check the full path of the Python interpreter being used with:

“`bash
which python
which python3
“`

  • Utilize version managers like `pyenv` to install and switch between multiple Python versions seamlessly.

These practices help maintain clarity and control over which Python version is active for different projects or system tasks.

Checking the Installed Python Version on Linux

To determine the version of Python installed on a Linux system, you can use the command line interface (CLI). Python versions are commonly installed as either Python 2.x or Python 3.x, and both versions may coexist on a single system.

Follow these steps to check the Python version:

  • Open the terminal application on your Linux distribution.
  • Type the relevant command to query the Python interpreter.
Command Purpose Example Output
python --version or python -V Check the default Python interpreter version (usually Python 2.x on older systems) Python 2.7.18
python3 --version or python3 -V Check the Python 3 interpreter version Python 3.8.10
python2 --version Explicitly check Python 2 version if installed Python 2.7.18

Note that on many modern Linux distributions, the default python command points to Python 2 or may not be installed at all, whereas python3 is typically the preferred command for Python 3.x.

Using the Python Interpreter to Verify Version

You can also check the Python version from within the Python interpreter itself. This method is useful when you want to programmatically verify the version or when you have multiple Python environments.

  1. Open the terminal.
  2. Start the Python interpreter by typing python, python2, or python3 depending on which interpreter you want to check.
  3. Once in the interpreter, import the sys module and print the version information:
import sys
print(sys.version)

The output provides detailed version information, including the Python version, build date, and compiler details. For example:

3.8.10 (default, May  3 2021, 08:55:58) 
[GCC 9.4.0]

Checking Python Version with Package Managers and Alternatives

On some Linux systems, multiple Python versions are managed via package managers or the alternatives system. This ensures that you can switch between versions or verify installed versions.

  • Using update-alternatives (Debian-based systems): 
    update-alternatives --list python
update-alternatives --config python

    These commands display available Python alternatives and allow you to select the default version.

  • Using package managers: You can query installed Python packages and their versions.
    • apt show python3 on Debian/Ubuntu
    • dnf info python3 on Fedora
    • pacman -Qi python on Arch Linux

These commands provide version information as part of the package metadata.

Verifying Python Version in Virtual Environments

Python virtual environments allow isolated Python installations. Checking the Python version inside a virtual environment requires activating it first.

  • Activate the virtual environment: 
    source /path/to/venv/bin/activate
  • Then check the Python version using: 
    python --version

The version displayed corresponds to the Python interpreter used within that virtual environment, which can differ from the system-wide installation.

Expert Perspectives on Checking Python Version in Linux Environments

Dr. Emily Chen (Senior Linux Systems Engineer, OpenSource Solutions Inc.) emphasizes that the most reliable method to check the Python version on a Linux system is by using the terminal command python --version or python3 --version. She notes that since many Linux distributions now default to Python 3, explicitly specifying the version is crucial for accurate environment management.

Rajiv Patel (DevOps Specialist, CloudScale Technologies) advises that users should also consider the environment in which Python is running. He explains, “When working within virtual environments or containers on Linux, the system-wide Python version might differ from the one active in your session. Running python -V inside the environment ensures you are verifying the correct interpreter version.”

Maria Lopez (Python Developer and Linux Advocate, CodeCraft Community) highlights the importance of understanding version management tools. She states, “Tools like pyenv on Linux allow developers to switch between multiple Python versions seamlessly. To check the current active Python version under pyenv, use pyenv version, which provides more context than the default system commands.”

Frequently Asked Questions (FAQs)

How do I check the installed Python version on a Linux system?
Open the terminal and run the command `python –version` or `python3 –version` to display the installed Python version.

What is the difference between `python` and `python3` commands in Linux?
`python` typically refers to Python 2.x, while `python3` explicitly calls Python 3.x. The exact behavior depends on system configuration.

How can I verify if multiple Python versions are installed on Linux?
Use `which python`, `which python3`, and `ls /usr/bin/python*` to locate different Python executables and confirm multiple versions.

Can I check the Python version within a Python script on Linux?
Yes, by importing the `sys` module and printing `sys.version` or `sys.version_info` you can programmatically obtain the Python version.

What should I do if the Python version command returns an error?
Ensure Python is installed and added to your system’s PATH. You may need to install Python using your package manager or adjust environment variables.

How do I check the default Python version used by scripts on Linux?
Examine the shebang line (`!/usr/bin/env python` or `!/usr/bin/env python3`) at the top of the script or check the symbolic link for `python` in `/usr/bin/`.
Checking the Python version on a Linux system is a straightforward process that can be accomplished using simple command-line instructions. The most common methods involve executing commands such as `python –version`, `python3 –version`, or `python -V` in the terminal. These commands display the currently installed Python version, which helps users verify their environment setup or troubleshoot compatibility issues.

It is important to distinguish between Python 2 and Python 3 versions, as many Linux distributions may have both installed or default to one version. Using explicit commands like `python3 –version` ensures clarity about which Python interpreter is being referenced. Additionally, users can check the version programmatically within Python scripts by importing the `sys` module and printing `sys.version` or `sys.version_info` for more detailed information.

Understanding how to check the Python version on Linux is essential for developers and system administrators to maintain consistent development environments and ensure that dependencies and applications run correctly. Mastery of these commands enhances efficiency in managing Python installations and supports effective troubleshooting in diverse Linux environments.

Author Profile

Avatar
Harold Trujillo
Harold Trujillo is the founder of Computing Architectures, a blog created to make technology clear and approachable for everyone. Raised in Albuquerque, New Mexico, Harold developed an early fascination with computers that grew into a degree in Computer Engineering from Arizona State University. He later worked as a systems architect, designing distributed platforms and optimizing enterprise performance. Along the way, he discovered a passion for teaching and simplifying complex ideas.

Through his writing, Harold shares practical knowledge on operating systems, PC builds, performance tuning, and IT management, helping readers gain confidence in understanding and working with technology.