How do I check which version of Python is running my script?


How do I check which version of the Python interpreter is running my script?

Asked By: carrier



This information is available in the sys.version string in the sys module:

>>> import sys

Human readable:

>>> print(sys.version)  # parentheses necessary in python 3.       
2.5.2 (r252:60911, Jul 31 2008, 17:28:52) 
[GCC 4.2.3 (Ubuntu 4.2.3-2ubuntu7)]

For further processing, use sys.version_info or sys.hexversion:

>>> sys.version_info
(2, 5, 2, 'final', 0)
# or
>>> sys.hexversion

To ensure a script runs with a minimal version requirement of the Python interpreter add this to your code:

assert sys.version_info >= (2, 5)

This compares major and minor version information. Add micro (=0, 1, etc) and even releaselevel (='alpha','final', etc) to the tuple as you like. Note however, that it is almost always better to "duck" check if a certain feature is there, and if not, workaround (or bail out). Sometimes features go away in newer releases, being replaced by others.

Answered By: krawyoti
import sys
sys.version.split(' ')[0]

sys.version gives you what you want, just pick the first number πŸ™‚

Answered By: fengshaun

Your best bet is probably something like so:

>>> import sys
>>> sys.version_info
(2, 6, 4, 'final', 0)
>>> if not sys.version_info[:2] == (2, 6):
...    print "Error, I need python 2.6"
... else:
...    from my_module import twoPointSixCode

Additionally, you can always wrap your imports in a simple try, which should catch syntax errors. And, to @Heikki’s point, this code will be compatible with much older versions of python:

>>> try:
...     from my_module import twoPointSixCode
... except Exception: 
...     print "can't import, probably because your python is too old!"
Answered By: Seth

Put something like:

import sys
if sys.version_info<(2,6,0):
  sys.stderr.write("You need python 2.6 or later to run this scriptn")

at the top of your script.

Note that depending on what else is in your script, older versions of python than the target may not be able to even load the script, so won’t get far enough to report this error. As a workaround, you can run the above in a script that imports the script with the more modern code.

Answered By: rjmunro

Like Seth said, the main script could check sys.version_info (but note that that didn’t appear until 2.0, so if you want to support older versions you would need to check another version property of the sys module).

But you still need to take care of not using any Python language features in the file that are not available in older Python versions. For example, this is allowed in Python 2.5 and later:


but won’t work in older Python versions, because you could only have except OR finally match the try. So for compatibility with older Python versions you need to write:

Answered By: Heikki Toivonen

I like sys.hexversion for stuff like this.

>>> import sys
>>> sys.hexversion
>>> '%x' % sys.hexversion
>>> sys.hexversion < 0x02060000
Answered By: brianz

If you are working on linux just give command python output will be like this

Python 2.4.3 (#1, Jun 11 2009, 14:09:37)

[GCC 4.1.2 20080704 (Red Hat 4.1.2-44)] on linux2

Type “help”, “copyright”, “credits” or “license” for more

Answered By: pkm

From the command line (note the capital ‘V’):

python -V

This is documented in ‘man python’.

From IPython console

!python -V
Answered By: jcolino

Use platform‘s python_version from the stdlib:

from platform import python_version

# 3.9.2
Answered By: Bill

Here’s a short commandline version which exits straight away (handy for scripts and automated execution):

python -c "print(__import__('sys').version)"

Or just the major, minor and micro:

python -c "print(__import__('sys').version_info[:1])" # (2,)
python -c "print(__import__('sys').version_info[:2])" # (2, 7)
python -c "print(__import__('sys').version_info[:3])" # (2, 7, 6)
Answered By: Wolph

The simplest way

Just type python in your terminal and you can see the version
as like following

desktop:~$ python
Python 2.7.6 (default, Jun 22 2015, 18:00:18) 
[GCC 4.8.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
Answered By: cjahangir

With six module, you can do it by:

import six

if six.PY2:
  # this is python2.x
  # six.PY3
  # this is python3.x
Answered By: Dzhuang

Several answers already suggest how to query the current python version. To check programmatically the version requirements, I’d make use of one of the following two methods:

# Method 1: (see krawyoti's answer)
import sys
assert(sys.version_info >= (2,6))

# Method 2: 
import platform
from distutils.version import StrictVersion 
assert(StrictVersion(platform.python_version()) >= "2.6")
Answered By: normanius

Just for fun, the following is a way of doing it on CPython 1.0-3.7b2, Pypy, Jython and Micropython. This is more of a curiosity than a way of doing it in modern code. I wrote it as part of , which is a script for testing a snippet of code on many versions of python at once, so you can easily get a feel for what python features are compatible with what versions of python:

via_platform = 0
check_sys = 0
via_sys_version_info = 0
via_sys_version = 0
test_sys = 0
    import platform
except (ImportError, NameError):
    # We have no platform module - try to get the info via the sys module
    check_sys = 1

if not check_sys:
    if hasattr(platform, "python_version"):
        via_platform = 1
        check_sys = 1

if check_sys:
        import sys
        test_sys = 1
    except (ImportError, NameError):
        # just let via_sys_version_info and via_sys_version remain False - we have no sys module

if test_sys:
    if hasattr(sys, "version_info"):
        via_sys_version_info = 1
    elif hasattr(sys, "version"):
        via_sys_version = 1
        # just let via_sys remain False

if via_platform:
    # This gives pretty good info, but is not available in older interpreters.  Also, micropython has a
    # platform module that does not really contain anything.
elif via_sys_version_info:
    # This is compatible with some older interpreters, but does not give quite as much info.
    print("%s.%s.%s" % sys.version_info[:3])
elif via_sys_version:
    import string
    # This is compatible with some older interpreters, but does not give quite as much info.
    verbose_version = sys.version
    version_list = string.split(verbose_version)
Answered By: dstromberg

Check Python version: python -V or python --version or apt-cache policy python

you can also run whereis python to see how many versions are installed.

Answered By: Shusen Yi

sys.version_info doesn’t seem to return a tuple as of 3.7. Rather, it returns a special class, so all of the examples using tuples don’t work, for me at least. Here’s the output from a python console:

>>> import sys
>>> type(sys.version_info)
<class 'sys.version_info'>

I’ve found that using a combination of sys.version_info.major and sys.version_info.minor seems to suffice. For example,…

import sys
if sys.version_info.major > 3:
    print('Upgrade to Python 3')

checks if you’re running Python 3. You can even check for more specific versions with…

import sys
ver = sys.version_info
if ver.major > 2:
    if ver.major == 3 and ver.minor <= 4:
        print('Upgrade to Python 3.5')

can check to see if you’re running at least Python 3.5.

Answered By: Parker E.

If you want to detect pre-Python 3 and don’t want to import anything…

…you can (ab)use list comprehension scoping changes and do it in a single expression:

is_python_3_or_above = (lambda x: [x for x in [False]] and None or x)(True)
Answered By: user541686

To verify the Python version for commands on Windows, run the following commands in a command prompt and verify the output

c:>python -V
Python 2.7.16

c:>py -2 -V
Python 2.7.16

c:>py -3 -V
Python 3.7.3

Also, To see the folder configuration for each Python version, run the following commands:

For Python 2,'py -2 -m site'
For Python 3,'py -3 -m site'
Answered By: Aamir M Meman
from sys import version_info, api_version, version, hexversion

print(f"sys.version: {version}")
print(f"sys.api_version: {api_version}")
print(f"sys.version_info: {version_info}")
print(f"sys.hexversion: {hexversion}")


sys.version: 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) [MSC v.1900 64 bit (AMD64)]
sys.api_version: 1013
sys.version_info: sys.version_info(major=3, minor=6, micro=5, releaselevel='final', serial=0)
sys.hexversion: 50726384
Answered By: oetzi

The even simpler simplest way:

In Spyder, start a new “IPython Console”, then run any of your existing scripts.

Now the version can be seen in the first output printed in the console window:

“Python 3.7.3 (default, Apr 24 2019, 15:29:51)…”

enter image description here

Answered By: S. Jessen

To check from the command-line, in one single command, but include major, minor, micro version, releaselevel and serial, then invoke the same Python interpreter (i.e. same path) as you’re using for your script:

> path/to/your/python -c "import sys; print('{}.{}.{}-{}-{}'.format(*sys.version_info))"


Note: .format() instead of f-strings or '.'.join() allows you to use arbitrary formatting and separator chars, e.g. to make this a greppable one-word string. I put this inside a bash utility script that reports all important versions: python, numpy, pandas, sklearn, MacOS, xcode, clang, brew, conda, anaconda, gcc/g++ etc. Useful for logging, replicability, troubleshootingm bug-reporting etc.

Answered By: smci

A attempt using os.popen to read it in a variable:

import os
ver = os.popen('python -V').read().strip()
Answered By: Wasif

For windows, Go to command prompt and type this command to get the python version:

python --version


python -V
Answered By: shaila

This just returns 2.7, 3.6 or 3.9

import sys
current_version = ".".join(map(str, sys.version_info[0:2]))

which is what you usually you need…

Answered By: freedev

all answers has great insights

another way is platform.python_version_tuple()

python3 -c β€œimport platform; print(platform.python_version_tuple())”

(β€˜3’, β€˜6’, β€˜8’)
Answered By: Ram Ghadiyaram

if you want to check the python version for at least condition (e.g., python 3.9.0):

import platform
python_version_tuple = list(map(int, platform.python_version_tuple()))

if python_version_tuple >= [3, 9, 0]:
    # Running at least Python 3.9.0
    # Running Python below 3.9.0
Answered By: Madiyar

From within python3:

from sys import version_info 
python_version = f"{version_info.major}.{version_info.minor}"

Should return (or similar):


Answered By: Olaf
Categories: questions Tags: ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.