¿Cómo puedo verificar qué versión de Python Interpreter está interpretando mi script?

Esta información está disponible en la cadena sys.version en el módulo sys :

>>> import sys

Legible por humanos:

>>> 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)]

Para su posterior procesamiento:

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

Para garantizar que se ejecute un script con un requisito de versión mínima del intérprete de Python, agregue esto a su código:

assert sys.version_info >= (2, 5)

Esto compara la información de la versión mayor y menor. Añadir micro (= 0, 1releaselevel, etc) e incluso (= 'alpha', 'final', etc) a la tupla como te gusta. Sin embargo, tenga en cuenta que casi siempre es mejor "agacharse" para verificar si existe cierta característica y, de lo contrario, solucionar el problema (o rescatarlo). A veces, las funciones desaparecen en versiones más recientes y son reemplazadas por otras.

Desde la línea de comando (observe la 'V' mayúscula):

python -V

Esto está documentado en 'man python'.

Me gusta sys.hexversionpara cosas como esta.

http://docs.python.org/library/sys.html#sys.hexversion

>>> import sys
>>> sys.hexversion
33883376
>>> '%x' % sys.hexversion
'20504f0'
>>> sys.hexversion < 0x02060000
True

Su mejor apuesta es probablemente algo así:

>>> 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
>>> 

Además, siempre puede ajustar sus importaciones en un simple intento, que debería detectar errores de sintaxis. Y, para el punto de @ Heikki, este código será compatible con versiones mucho más antiguas de python:

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

Use platform'spython_version del stdlib:

>>> from platform import python_version
>>> print(python_version())
2.7.8

Pon algo como:

#!/usr/bin/env/python
import sys
if sys.version_info<(2,6,0):
  sys.stderr.write("You need python 2.6 or later to run this script\n")
  exit(1)

en la parte superior de tu guión.

Tenga en cuenta que, dependiendo de qué más haya en su secuencia de comandos, es posible que las versiones anteriores de python que el objetivo ni siquiera puedan cargar la secuencia de comandos, por lo que no llegarán lo suficientemente lejos como para informar este error. Como solución alternativa, puede ejecutar lo anterior en un script que importe el script con el código más moderno.

Aquí hay una versión corta de la línea de comandos que sale de inmediato (útil para scripts y ejecución automatizada):

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

O simplemente el mayor, menor y 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)

Con el sixmódulo, puedes hacerlo de la siguiente manera:

import six

if six.PY2:
  # this is python2.x
else:
  # six.PY3
  # this is python3.x

import sys
sys.version.split(' ')[0]

sys.version te da lo que quieres, solo elige el primer número :)

La forma mas simple

Simplemente escriba python en su terminal y puede ver la versión de la siguiente manera

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.
>>> 

Como dijo Seth, el script principal podría verificar sys.version_info(pero tenga en cuenta que eso no apareció hasta 2.0, por lo que si desea admitir versiones anteriores, deberá verificar otra propiedad de versión del módulo sys).

Pero aún debe tener cuidado de no utilizar ninguna función del lenguaje Python en el archivo que no esté disponible en versiones anteriores de Python. Por ejemplo, esto está permitido en Python 2.5 y versiones posteriores:

try:
    pass
except:
    pass
finally:
    pass

pero no funcionará en versiones anteriores de Python, porque solo podría tener excepto O finalmente coincidir con el intento. Entonces, para la compatibilidad con versiones anteriores de Python, debe escribir:

try:
    try:
        pass
    except:
        pass
finally:
    pass

Varias respuestas ya sugieren cómo consultar la versión actual de Python. Para verificar mediante programación los requisitos de la versión, utilizaría uno de los dos métodos siguientes:

# 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")

Solo por diversión, la siguiente es una forma de hacerlo en CPython 1.0-3.7b2, Pypy, Jython y Micropython. Esto es más una curiosidad que una forma de hacerlo en código moderno. Lo escribí como parte de http://stromberg.dnsalias.org/~strombrg/pythons/ , que es un script para probar un fragmento de código en muchas versiones de Python a la vez, para que pueda tener una idea de qué Python Las características son compatibles con las versiones de Python:

via_platform = 0
check_sys = 0
via_sys_version_info = 0
via_sys_version = 0
test_sys = 0
try:
    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
    else:
        check_sys = 1

if check_sys:
    try:
        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
        pass

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

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.
    print(platform.python_version())
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)
    print(version_list[0])
else:
    print("unknown")

Verifique la versión de Python: python -Vo python --versionoapt-cache policy python

También puede ejecutar whereis pythonpara ver cuántas versiones están instaladas.

Si desea detectar pre-Python 3 y no quiere importar nada ...

... puede (ab) usar cambios de alcance de comprensión de listas y hacerlo en una sola expresión :

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

Para verificar la versión de Python para comandos en Windows, ejecute los siguientes comandos en un símbolo del sistema y verifique la salida

c:\>python -V
Python 2.7.16

c:\>py -2 -V
Python 2.7.16

c:\>py -3 -V
Python 3.7.3

Además, para ver la configuración de la carpeta para cada versión de Python, ejecute los siguientes comandos:

For Python 2,'py -2 -m site'
For Python 3,'py -3 -m site'

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}")

salida

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

sys.version_infono parece devolver un a tuplepartir de 3.7. Más bien, devuelve una clase especial, por lo que todos los ejemplos que usan tuplas no funcionan, al menos para mí. Aquí está el resultado de una consola python:

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

He descubierto que usar una combinación de sys.version_info.majory sys.version_info.minorparece ser suficiente. Por ejemplo,...

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

comprueba si estás ejecutando Python 3. Incluso puedes buscar versiones más específicas con ...

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

puede verificar si está ejecutando al menos Python 3.5.

La forma aún más simple:

En Spyder, inicie una nueva "Consola IPython", luego ejecute cualquiera de sus scripts existentes.

Ahora la versión se puede ver en la primera salida impresa en la ventana de la consola:

"Python 3.7.3 (predeterminado, 24 de abril de 2019, 15:29:51) ..."

Para verificar desde la línea de comandos, en un solo comando, pero incluye mayor, menor, micro versión, releaselevel y serial :

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

3.7.6-final-0

Nota: en .format()lugar de f-strings o le '.'.join()permite utilizar el formato arbitrario y los caracteres de separación, por ejemplo, para hacer de esta una cadena de una sola palabra greppable. Puse esto dentro de un script de utilidad bash que informa todas las versiones importantes: python, numpy, pandas, sklearn, MacOS, xcode, clang, brew, conda, anaconda, gcc / g ++ etc. Útil para el registro, la replicabilidad, la resolución de problemas, informes de errores, etc. .

Si está trabajando en Linux, simplemente dé la python salida del comando será así

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

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

Escriba "ayuda", "derechos de autor", "créditos" o "licencia" para obtener más información.