Come posso verificare quale versione dell'interprete Python sta interpretando il mio script?

Questa informazione è disponibile nella stringa sys.version nel modulo sys :

>>> import sys

Leggibile dagli umani:

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

Per ulteriori elaborazioni:

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

Per assicurarti che uno script venga eseguito con una versione minima richiesta dell'interprete Python aggiungi questo al tuo codice:

assert sys.version_info >= (2, 5)

Questo confronta le informazioni sulla versione principale e secondaria. Aggiungere micro (= 0, 1, ecc) e anche releaselevel (= 'alpha', 'final', ecc) per la tupla come ti piace. Si noti, tuttavia, che è quasi sempre meglio "anatra" verificare se esiste una determinata funzionalità e, in caso contrario, soluzione (o salvataggio). A volte le funzionalità scompaiono nelle versioni più recenti, sostituite da altre.

Dalla riga di comando (notare la 'V' maiuscola):

python -V

Questo è documentato in 'man python'.

Mi piace sys.hexversionper cose come questa.

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

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

La tua scommessa migliore è probabilmente qualcosa del genere:

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

Inoltre, puoi sempre avvolgere le tue importazioni in un semplice tentativo, che dovrebbe rilevare errori di sintassi. E, al punto di @ Heikki, questo codice sarà compatibile con versioni molto più vecchie di python:

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

Utilizzare platform'ilpython_version dal stdlib:

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

Metti qualcosa come:

#!/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)

nella parte superiore della tua sceneggiatura.

Nota che, a seconda di cos'altro c'è nello script, le versioni precedenti di Python rispetto alla destinazione potrebbero non essere in grado di caricare lo script, quindi non andranno abbastanza lontano per segnalare questo errore. Come soluzione alternativa, è possibile eseguire quanto sopra in uno script che importa lo script con il codice più moderno.

Ecco una breve versione della riga di comando che esce immediatamente (utile per gli script e l'esecuzione automatizzata):

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

O solo il maggiore, il minore e il 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 il sixmodulo, puoi farlo tramite:

import six

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

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

sys.version ti dà quello che vuoi, basta scegliere il primo numero :)

Il modo più semplice

Digita python nel tuo terminale e puoi vedere la versione come 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.
>>> 

Come ha detto Seth, lo script principale potrebbe verificare sys.version_info(ma si noti che non è apparso fino alla 2.0, quindi se si desidera supportare versioni precedenti è necessario controllare un'altra proprietà della versione del modulo sys).

Ma devi comunque fare attenzione a non utilizzare nel file alcuna funzionalità del linguaggio Python che non sia disponibile nelle versioni precedenti di Python. Ad esempio, questo è consentito in Python 2.5 e versioni successive:

try:
    pass
except:
    pass
finally:
    pass

ma non funzionerà nelle versioni precedenti di Python, perché potresti avere solo tranne OR finalmente abbinare il tentativo. Quindi per compatibilità con le versioni precedenti di Python devi scrivere:

try:
    try:
        pass
    except:
        pass
finally:
    pass

Diverse risposte suggeriscono già come interrogare l'attuale versione di Python. Per verificare a livello di programmazione i requisiti della versione, farei uso di uno dei due metodi seguenti:

# 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 per divertimento, il seguente è un modo di farlo su CPython 1.0-3.7b2, Pypy, Jython e Micropython. Questa è più una curiosità che un modo di farlo nel codice moderno. L'ho scritto come parte di http://stromberg.dnsalias.org/~strombrg/pythons/ , che è uno script per testare uno snippet di codice su molte versioni di Python contemporaneamente, così puoi facilmente avere un'idea di quale Python le funzionalità sono compatibili con quali versioni di 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")

Controlla la versione di Python: python -Voppure python --versionoppureapt-cache policy python

puoi anche eseguire whereis pythonper vedere quante versioni sono installate.

Se vuoi rilevare pre-Python 3 e non vuoi importare nulla ...

... puoi (ab) usare le modifiche all'ambito della comprensione dell'elenco e farlo in una singola espressione :

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

Per verificare la versione di Python per i comandi su Windows, eseguire i seguenti comandi in un prompt dei comandi e verificare l'output

c:\>python -V
Python 2.7.16

c:\>py -2 -V
Python 2.7.16

c:\>py -3 -V
Python 3.7.3

Inoltre, per visualizzare la configurazione della cartella per ciascuna versione di Python, eseguire i comandi seguenti:

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

produzione

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_infonon sembra restituire un tupleal 3.7. Piuttosto, restituisce una classe speciale, quindi tutti gli esempi che usano le tuple non funzionano, almeno per me. Ecco l'output da una console Python:

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

Ho scoperto che usare una combinazione di sys.version_info.majore sys.version_info.minorsembra essere sufficiente. Per esempio,...

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

controlla se stai eseguendo Python 3. Puoi anche verificare versioni più specifiche 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)

può verificare se stai eseguendo almeno Python 3.5.

Il modo ancora più semplice:

In Spyder, avvia una nuova "Console IPython", quindi esegui uno qualsiasi degli script esistenti.

Ora la versione è visibile nel primo output stampato nella finestra della console:

"Python 3.7.3 (impostazione predefinita, 24 aprile 2019, 15:29:51) ..."

Per controllare dalla riga di comando, in un unico comando, ma includere major, minor, micro version, releaselevel e serial :

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

3.7.6-final-0

Nota: .format()invece di f-string o '.'.join()consente di utilizzare la formattazione arbitraria e i caratteri di separazione, ad esempio per rendere questa stringa stringibile di una sola parola. Lo inserisco in uno script di utilità bash che riporta tutte le versioni importanti: python, numpy, panda, sklearn, MacOS, xcode, clang, brew, conda, anaconda, gcc / g ++ ecc. Utile per la registrazione, la replicabilità, la risoluzione dei problemi, la segnalazione di bug ecc. .

Se stai lavorando su Linux, basta dare l' python output del comando sarà così

Python 2.4.3 (n. 1, 11 giugno 2009, 14:09:37)

[GCC 4.1.2 20080704 (Red Hat 4.1.2-44)] su Linux2

Digita "aiuto", "copyright", "crediti" o "licenza" per ulteriori informazioni.