Jak mogę sprawdzić wersję Pythona w programie, który korzysta z nowych funkcji językowych?

Jeśli mam skrypt w języku Python, który wymaga co najmniej konkretnej wersji języka Python, jaki jest prawidłowy sposób, by upaść z wdziękiem, gdy do uruchomienia skryptu używana jest wcześniejsza wersja języka Python?

Jak uzyskać kontrolę wystarczająco wcześnie, aby wysłać komunikat o błędzie i wyjść?

Na przykład mam program, który używa operatora ternery (nowy w wersji 2.5) i „z” blokami (nowy w wersji 2.6). Napisałem prostą, małą procedurę sprawdzania wersji interpretera, która jest pierwszą rzeczą, którą skrypt mógłby wywołać ... tyle że nie zaszła tak daleko. Zamiast tego skrypt nie działa podczas kompilacji Pythona, zanim moje procedury zostaną nawet wywołane. W związku z tym użytkownik skryptu widzi pewne bardzo niejasne mechanizmy śledzenia błędów syx - które w zasadzie wymagają od eksperta wywnioskowania, że ​​po prostu chodzi o uruchomienie niewłaściwej wersji Pythona.

Wiem, jak sprawdzić wersję Pythona. Problem polega na tym, że niektóre składnie są nielegalne w starszych wersjach Pythona. Rozważ ten program:

import sys
if sys.version_info < (2, 4):
    raise "must use python 2.5 or greater"
else:
    # syntax error in 2.4, ok in 2.5
    x = 1 if True else 2
    print x

Gdy działa poniżej 2.4, chcę ten wynik

$ ~/bin/python2.4 tern.py 
must use python 2.5 or greater

a nie ten wynik:

$ ~/bin/python2.4 tern.py 
  File "tern.py", line 5
    x = 1 if True else 2
           ^
SyntaxError: invalid syntax

(Kanalizacja dla współpracownika.)

Możesz przetestować za pomocą eval:

try:
  eval("1 if True else 2")
except SyntaxError:
  # doesn't have ternary

Ponadto, with jest dostępny w Pythonie 2.5, wystarczy dodać from __future__ import with_statement.

EDYCJA: aby uzyskać kontrolę wystarczająco wcześnie, możesz podzielić ją na różne .pypliki i sprawdzić zgodność w głównym pliku przed importem (np. W __init__.pypakiecie):

# __init__.py

# Check compatibility
try:
  eval("1 if True else 2")
except SyntaxError:
  raise ImportError("requires ternary support")

# import from another module
from impl import *

Mają opakowanie wokół programu, który wykonuje następujące czynności.

import sys

req_version = (2,5)
cur_version = sys.version_info

if cur_version >= req_version:
   import myApp
   myApp.run()
else:
   print "Your Python interpreter is too old. Please consider upgrading."

Możesz również rozważyć użycie sys.version(), jeśli planujesz spotkać ludzi, którzy używają interpreterów języka Python w wersjach wcześniejszych niż 2.0, ale wtedy musisz zrobić kilka wyrażeń regularnych.

I mogą być bardziej eleganckie sposoby na zrobienie tego.

Próbować

platforma importowa
platform.python_version ()

Powinien dać ci ciąg taki jak „2.3.1”. Jeśli nie jest to dokładnie takie, jak chcesz, istnieje bogaty zestaw danych dostępnych za pośrednictwem wbudowanej „platformy”. To, czego chcesz, powinno gdzieś tam być.

Prawdopodobnie najlepszym sposobem na porównanie tej wersji jest użycie sys.hexversion. Jest to ważne, ponieważ porównanie krotek wersji nie da pożądanego wyniku we wszystkich wersjach Pythona.

import sys
if sys.hexversion < 0x02060000:
    print "yep!"
else:
    print "oops!"

import sys    
# prints whether python is version 3 or not
python_version = sys.version_info.major
if python_version == 3:
    print("is python 3")
else:
    print("not python 3")

Odpowiedź od Nykakina z AskUbuntu :

Możesz również sprawdzić wersję Pythona z samego kodu za pomocą platformmodułu ze standardowej biblioteki.

Istnieją dwie funkcje:

• platform.python_version() (zwraca ciąg znaków).
• platform.python_version_tuple() (zwraca krotkę).

Kod Python

Utwórz plik na przykład version.py:)

Łatwa metoda sprawdzenia wersji:

import platform

print(platform.python_version())
print(platform.python_version_tuple())

Możesz także użyć evalmetody:

try:
  eval("1 if True else 2")
except SyntaxError:
  raise ImportError("requires ternary support")

Uruchom plik Python w wierszu polecenia:

$ python version.py 
2.7.11
('2', '7', '11')

Dane wyjściowe Pythona z CGI za pośrednictwem serwera WAMP w systemie Windows 10:

Pomocne zasoby

• /ubuntu/505081/what-version-of-python-do-i-have

Zestawy stały się częścią podstawowego języka Python 2.4, aby zachować kompatybilność wsteczną. Zrobiłem to wtedy, co również zadziała dla ciebie:

if sys.version_info < (2, 4):
    from sets import Set as set

Chociaż pytanie brzmi: jak uzyskać kontrolę wystarczająco wcześnie, aby wysłać komunikat o błędzie i wyjść ?

Pytanie, na które odpowiadam brzmi: Jak uzyskać kontrolę wystarczająco wcześnie, aby wydać komunikat o błędzie przed uruchomieniem aplikacji ?

Mogę odpowiedzieć na to znacznie inaczej niż na inne posty. Wygląda na to, że jak dotąd odpowiedzi próbują rozwiązać twoje pytanie z poziomu Pythona.

Mówię, sprawdź wersję przed uruchomieniem Pythona. Widzę, że twoja ścieżka to Linux lub Unix. Mogę jednak zaoferować tylko skrypt systemu Windows. Wyobrażam sobie, że dostosowanie go do składni skryptów linuksowych nie byłoby zbyt trudne.

Oto skrypt DOS z wersją 2.7:

@ECHO OFF
REM see http://ss64.com/nt/for_f.html
FOR /F "tokens=1,2" %%G IN ('"python.exe -V 2>&1"') DO ECHO %%H | find "2.7" > Nul
IF NOT ErrorLevel 1 GOTO Python27
ECHO must use python2.7 or greater
GOTO EOF
:Python27
python.exe tern.py
GOTO EOF
:EOF

To nie uruchamia żadnej części twojej aplikacji i dlatego nie wywoła wyjątku Python. Nie tworzy żadnych plików tymczasowych ani nie dodaje żadnych zmiennych środowiskowych systemu operacyjnego. I to nie kończy twojej aplikacji na wyjątku z powodu różnych reguł składni wersji. To trzy mniej prawdopodobne punkty bezpieczeństwa dostępu.

The FOR /FLinia jest kluczem.

FOR /F "tokens=1,2" %%G IN ('"python.exe -V 2>&1"') DO ECHO %%H | find "2.7" > Nul

W przypadku wielu wersji Pythona sprawdź adres URL: http://www.fpschultze.de/modules/smartfaq/faq.php?faqid=17

I moja wersja hacka:

[Skrypt MS; Sprawdzanie wersji Python przed uruchomieniem modułu Python] http://pastebin.com/aAuJ91FQ

import sys
sys.version

dostanę taką odpowiedź

„2.7.6 (domyślnie, 26 października 2016 r., 20:30:19) \ n [GCC 4.8.4]”

tutaj 2.7.6 jest wersją

Jak wspomniano powyżej, błędy składniowe występują w czasie kompilacji, a nie w czasie wykonywania. Podczas gdy Python jest „językiem interpretowanym”, kod Pythona nie jest w rzeczywistości bezpośrednio interpretowany; jest kompilowany do kodu bajtowego, który jest następnie interpretowany. Jest krok kompilacji, który ma miejsce, gdy moduł jest importowany (jeśli nie ma już skompilowanej wersji dostępnej w postaci pliku .pyc lub .pyd) i wtedy pojawia się błąd, a nie (całkiem dokładnie) kiedy Twój kod działa.

Możesz odłożyć krok kompilacji i sprawić, by stało się to w czasie wykonywania pojedynczego wiersza kodu, jeśli chcesz, używając eval, jak wspomniano powyżej, ale ja osobiście wolę tego unikać, ponieważ powoduje to, że Python może potencjalnie działać niepotrzebna kompilacja w czasie wykonywania, z jednej strony, a z drugiej, tworzy coś, co wydaje mi się bałaganem kodu. (Jeśli chcesz, możesz wygenerować kod, który generuje kod, który generuje kod - i mieć absolutnie fantastyczny czas na modyfikowanie i debugowanie tego za 6 miesięcy od teraz.) Więc zamiast tego poleciłbym coś takiego:

import sys
if sys.hexversion < 0x02060000:
    from my_module_2_5 import thisFunc, thatFunc, theOtherFunc
else:
    from my_module import thisFunc, thatFunc, theOtherFunc

.. co zrobiłbym, nawet gdybym miał tylko jedną funkcję, która używałaby nowszej składni i była ona bardzo krótka. (W rzeczywistości podjąłbym wszelkie rozsądne środki, aby zminimalizować liczbę i rozmiar takich funkcji. Mógłbym nawet napisać funkcję taką jak ifTrueAElseB (cond, a, b) z tą pojedynczą linią składni.)

Kolejną rzeczą, na którą warto zwrócić uwagę (jestem trochę zaskoczony, że nikt jeszcze nie zauważył) jest to, że chociaż wcześniejsze wersje Pythona nie obsługiwały kodu takiego jak

value = 'yes' if MyVarIsTrue else 'no'

.. obsługuje kod jak

value = MyVarIsTrue and 'yes' or 'no'

To był stary sposób pisania wyrażeń potrójnych. Nie mam jeszcze zainstalowanego Pythona 3, ale o ile wiem, ten „stary” sposób nadal działa do dziś, więc możesz sam zdecydować, czy warto warunkowo użyć nowej składni, jeśli potrzebujesz do obsługi korzystania ze starszych wersji Pythona.

Umieść u góry pliku następujące informacje:

import sys

if float(sys.version.split()[0][:3]) < 2.7:
    print "Python 2.7 or higher required to run this code, " + sys.version.split()[0] + " detected, exiting."
    exit(1)

Następnie przejdź do normalnego kodu Python:

import ...
import ...
other code...

Myślę, że najlepszym sposobem jest przetestowanie funkcjonalności, a nie wersji. W niektórych przypadkach jest to banalne, w innych nie.

na przykład:

try :
    # Do stuff
except : # Features weren't found.
    # Do stuff for older versions.

Tak długo, jak jesteś wystarczająco zaawansowany w korzystaniu z bloków try / wyjątkiem, możesz pokryć większość swoich baz.

Właśnie znalazłem to pytanie po szybkim wyszukiwaniu, próbując samodzielnie rozwiązać problem, i opracowałem hybrydę opartą na kilku powyższych sugestiach.

Podoba mi się pomysł DevPlayera na użycie skryptu opakowania, ale wadą jest to, że ostatecznie utrzymujesz wiele opakowań dla różnych systemów operacyjnych, więc postanowiłem napisać opakowanie w pythonie, ale użyj tego samego podstawowego „pobierz wersję, uruchamiając exe” i wymyślił to.

Myślę, że powinno działać od wersji 2.5 i nowszych. Do tej pory przetestowałem go w wersjach 2.66, 2.7.0 i 3.1.2 w systemie Linux i 2.6.1 w systemie OS X.

import sys, subprocess
args = [sys.executable,"--version"]

output, error = subprocess.Popen(args ,stdout = subprocess.PIPE, stderr = subprocess.PIPE).communicate()
print("The version is: '%s'"  %error.decode(sys.stdout.encoding).strip("qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLMNBVCXZ,.+ \n") )

Tak, wiem, że ostatnia linia dekodowania / stripowania jest okropna, ale chciałem tylko szybko pobrać numer wersji. Udoskonalę to.

Na razie działa mi to wystarczająco dobrze, ale jeśli ktoś może to poprawić (lub powiedzieć mi, dlaczego to okropny pomysł), to też byłoby fajne.

W przypadku samodzielnych skryptów Pythona działa następująca sztuczka docstring modułu w celu wymuszenia wersji Pythona (tutaj v2.7.x) (testowana na * nix).

#!/bin/sh
''''python -V 2>&1 | grep -q 2.7 && exec python -u -- "$0" ${1+"$@"}; echo "python 2.7.x missing"; exit 1 # '''

import sys
[...]

Powinno to również obsługiwać brakujący plik wykonywalny Pythona, ale ma zależność od grep. Zobacz tutaj dla tła.

Możesz to sprawdzić za pomocą sys.hexversionlub sys.version_info.

sys.hexversionnie jest zbyt przyjazny dla człowieka, ponieważ jest liczbą szesnastkową. sys.version_infojest krotką, więc jest bardziej przyjazna dla człowieka.

Sprawdź Python 3.6 lub nowszy za pomocą sys.hexversion:

import sys, time
if sys.hexversion < 0x30600F0:
    print("You need Python 3.6 or greater.")
    for _ in range(1, 5): time.sleep(1)
    exit()

Sprawdź Python 3.6 lub nowszy za pomocą sys.version_info:

import sys, time
if sys.version_info[0] < 3 and sys.version_info[1] < 6:
    print("You need Python 3.6 or greater.")
    for _ in range(1, 5): time.sleep(1)
    exit()

sys.version_infojest bardziej przyjazny dla człowieka, ale wymaga więcej postaci. Polecamsys.hexversion , choć jest mniej przyjazny dla człowieka.

Mam nadzieję, że to ci pomogło!

Rozwijam doskonałą odpowiedź Akhana, która drukuje przydatną wiadomość przed skompilowaniem skryptu Python.

Jeśli chcesz się upewnić, że skrypt jest uruchamiany w Pythonie 3.6 lub nowszym, dodaj te dwa wiersze u góry skryptu Python:

#!/bin/sh
''''python3 -c 'import sys; sys.exit(sys.version_info < (3, 6))' && exec python3 -u -- "$0" ${1+"$@"}; echo 'This script requires Python 3.6 or newer.'; exit 1 # '''

(Uwaga: Drugi wiersz zaczyna się od czterech pojedynczych cudzysłowów, a kończy na trzech pojedynczymi cudzysłowami. Może to wyglądać dziwnie, ale nie jest to literówka.)

Zaletą tego rozwiązania jest to, że kod podobny print(f'Hello, {name}!')nie spowoduje, SyntaxErrorże zostanie użyta wersja Python starsza niż 3.6. Zamiast tego zobaczysz tę pomocną wiadomość:

This script requires Python 3.6 or newer.

Oczywiście to rozwiązanie działa tylko na powłokach uniksopodobnych i tylko wtedy, gdy skrypt jest wywoływany bezpośrednio (na przykład ./script.py:) i przy ustawionych odpowiednich bitach uprawnień eXecute.

Co powiesz na to:

import sys

def testPyVer(reqver):
  if float(sys.version[:3]) >= reqver:
    return 1
  else:
    return 0

#blah blah blah, more code

if testPyVer(3.0) == 1:
  #do stuff
else:
  #print python requirement, exit statement

Problem jest dość prosty. Sprawdziłeś, czy wersja była mniejsza niż 2,4, nie mniejsza niż lub równa . Więc jeśli wersja Pythona to 2.4, to nie mniej niż 2.4. Co powinieneś był mieć:

    if sys.version_info **<=** (2, 4):

, nie

    if sys.version_info < (2, 4):