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

respuesta

Esta información está disponible en la sys.versioncadena en el sysmódulo:

>>> 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, utilice sys.version_infoo sys.hexversion:

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

Para asegurarse de que un script se ejecute 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 principal y secundaria. Agregue micro (= 0, 1, etc) e incluso releaselevel (= 'alpha', 'final', etc) a la tupla como desee. Tenga en cuenta, sin embargo, que casi siempre es mejor "eludir" verificar si una característica determinada está allí y, si no, solucionarlo (o rescatarlo). A veces, las funciones desaparecen en las versiones más recientes y se reemplazan por otras.

Desde la línea de comando (tenga en cuenta la 'V' mayúscula):

python -V

Esto está documentado en 'man python'.

Desde la consola de IPython

!python -V

Me gusta sys.hexversionpara cosas como esta.

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

Use platform'spython_version de stdlib:

from platform import python_version
print(python_version())

# 3.9.2

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 envolver sus importaciones en un simple intento, lo que debería detectar errores de sintaxis. Y, al 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!"
>>>

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 su 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 destino 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 una secuencia de comandos que importa la secuencia de comandos 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 solo 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 sixel módulo, puede 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 :)

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 usar ninguna característica 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 hacer coincidir el intento. Entonces, para 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, haría uso de 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 lo que python las características son compatibles con qué 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")

Si desea detectar versiones anteriores a Python 3 y no desea importar nada...

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

is_python_3_or_above = (lambda x: [x for x in [False]] and None or x)(True)
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}")

producción

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

La forma más sencilla

Simplemente escriba python en su terminal y podrá 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.
>>> 

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

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á la salida de una consola de python:

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

Descubrí 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á ejecutando Python 3. Incluso puede 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.

Para verificar la versión de Python para los 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 carpetas para cada versión de Python, ejecute los siguientes comandos:

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

La forma más simple 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)..."

ingrese la descripción de la imagen aquí

Para verificar desde la línea de comandos, en un solo comando, pero incluya la versión principal, secundaria, micro, el nivel de versión y la serie , luego invoque el mismo intérprete de Python (es decir, la misma ruta) que está usando para su secuencia de comandos:

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

3.7.6-final-0

Nota: .format()en lugar de f-strings o '.'.join()le permite usar formato arbitrario y caracteres separadores, por ejemplo, para hacer de esta una cadena de una sola palabra que se pueda greppar. 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 registro, replicabilidad, resolución de problemas, informes de errores, etc. .

Para Windows, vaya al símbolo del sistema y escriba este comando para obtener la versión de Python:

python --version

O

python -V

Esto simplemente regresa 2.7, 3.6o3.9

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

que es lo que normalmente necesitas...

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

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

Un intento os.popende leerlo en una variable:

import os
ver = os.popen('python -V').read().strip()
print(ver)