Como posso verificar qual versão do Python Interpreter está interpretando meu script?

Esta informação está disponível na cadeia sys.version no módulo sys :

>>> import sys

Legível 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 processamento adicional:

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

Para garantir que um script seja executado com um requisito de versão mínima do interpretador Python, adicione-o ao seu código:

assert sys.version_info >= (2, 5)

Isso compara as informações das versões principais e secundárias. Adicionar micro (= 0, 1, etc) e até mesmo releaselevel (= 'alpha', 'final', etc) para a tupla como você gosta. Observe, no entanto, que quase sempre é melhor "pular" para verificar se um determinado recurso está presente e, se não estiver, uma solução alternativa (ou resgate). Às vezes, os recursos desaparecem em versões mais recentes, sendo substituídos por outros.

Na linha de comando (observe o capital 'V'):

python -V

Isso está documentado no 'man python'.

Eu gosto sys.hexversionde coisas assim.

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

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

Sua melhor aposta é provavelmente algo assim:

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

Além disso, você sempre pode agrupar suas importações em uma tentativa simples, que deve detectar erros de sintaxe. E, ao ponto de @ Heikki, esse código será compatível com versões muito mais antigas do python:

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

Use platformépython_version do stdlib:

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

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

no topo do seu script.

Observe que, dependendo do que mais há no seu script, as versões mais antigas do python que o destino podem não conseguir carregar o script, portanto, não será suficiente o suficiente para relatar esse erro. Como solução alternativa, você pode executar o procedimento acima em um script que importa o script com o código mais moderno.

Aqui está uma versão curta da linha de comando que sai imediatamente (útil para scripts e execução automatizada):

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

Ou apenas os principais, menores e 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)

Com o sixmódulo, você pode fazer isso:

import six

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

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

sys.version oferece o que você deseja, basta escolher o primeiro número :)

A maneira mais simples

Basta digitar python no seu terminal e você pode ver a versão como se segue

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 Seth disse, o script principal pode verificar sys.version_info(mas observe que isso não apareceu até a versão 2.0, portanto, se você quiser suportar versões mais antigas, precisará verificar outra propriedade de versão do módulo sys).

Mas você ainda precisa cuidar de não usar nenhum recurso da linguagem Python no arquivo que não esteja disponível nas versões mais antigas do Python. Por exemplo, isso é permitido no Python 2.5 e posterior:

try:
    pass
except:
    pass
finally:
    pass

mas não funcionará em versões mais antigas do Python, porque você só pode ter, exceto OU finalmente, a tentativa. Portanto, para compatibilidade com versões mais antigas do Python, você precisa escrever:

try:
    try:
        pass
    except:
        pass
finally:
    pass

Várias respostas já sugerem como consultar a versão atual do python. Para verificar programaticamente os requisitos de versão, eu usaria um dos dois métodos a seguir:

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

Apenas por diversão, a seguir é uma maneira de fazê-lo no CPython 1.0-3.7b2, Pypy, Jython e Micropython. Isso é mais uma curiosidade do que uma maneira de fazê-lo no código moderno. Eu o escrevi como parte de http://stromberg.dnsalias.org/~strombrg/pythons/ , que é um script para testar um trecho de código em várias versões de python de uma só vez, para que você possa entender facilmente o que python recursos são compatíveis com quais versões do 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 a versão do Python: python -Vou python --versionouapt-cache policy python

você também pode executar whereis pythonpara ver quantas versões estão instaladas.

Se você deseja detectar o pré-Python 3 e não deseja importar nada ...

... você pode (ab) usar alterações no escopo da compreensão da lista e fazê-lo em uma única expressão :

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

Para verificar a versão do Python para comandos no Windows, execute os seguintes comandos em um prompt de comando e verifique a saída

c:\>python -V
Python 2.7.16

c:\>py -2 -V
Python 2.7.16

c:\>py -3 -V
Python 3.7.3

Além disso, para ver a configuração da pasta para cada versão do Python, execute os seguintes 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}")

resultado

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_infoparece não retornar um a tuplepartir de 3,7. Em vez disso, ele retorna uma classe especial, para que todos os exemplos usando tuplas não funcionem, pelo menos para mim. Aqui está a saída de um console python:

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

Eu descobri que usar uma combinação de sys.version_info.majore sys.version_info.minorparece suficiente. Por exemplo,...

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

verifica se você está executando o Python 3. Você pode até verificar versões mais específicas com ...

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)

pode verificar se você está executando pelo menos o Python 3.5.

A maneira ainda mais simples e simples:

No Spyder, inicie um novo "IPython Console" e execute qualquer um dos scripts existentes.

Agora a versão pode ser vista na primeira saída impressa na janela do console:

"Python 3.7.3 (padrão, 24 de abril de 2019 às 15:29:51) ..."

Para verificar na linha de comando, em um único comando, mas inclua as versões principal, secundária, micro, nível de liberação e serial :

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

3.7.6-final-0

Nota: em .format()vez de f-strings ou '.'.join()permite que você use caracteres arbitrários de formatação e separador, por exemplo, para tornar uma string de uma palavra aceitável. Coloquei isso dentro de um script do utilitário bash que relata todas as versões importantes: python, numpy, pandas, sklearn, MacOS, xcode, clang, brew, conda, anaconda, gcc / g ++ etc. Útil para registro, replicabilidade, solução de problemas, relatórios de erros etc. .

Se você estiver trabalhando no linux, apenas dê a python saída do comando , será assim

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

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

Digite "ajuda", "direitos autorais", "créditos" ou "licença" para obter mais informações.