මගේ පිටපත අර්ථ නිරූපණය කරන්නේ පයිතන් පරිවර්ථකයාගේ කුමන අනුවාදයදැයි පරීක්ෂා කරන්නේ කෙසේද?

මෙම තොරතුරු sys මොඩියුලයේ sys.version string හි ඇත :

>>> import sys

කියවිය හැකි මානව:

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

වැඩිදුර සැකසීම සඳහා:

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

පයිතන් පරිවර්තකයේ අවම අනුවාද අවශ්‍යතාවයකින් ස්ක්‍රිප්ට් එකක් ක්‍රියාත්මක වන බව සහතික කිරීම සඳහා මෙය ඔබේ කේතයට එක් කරන්න:

assert sys.version_info >= (2, 5)

මෙය ප්‍රධාන හා සුළු අනුවාද තොරතුරු සංසන්දනය කරයි. ක්ෂුද්ර (= එක් කරන්න 0, 1(=, ආදිය) සහ පවා releaselevel 'alpha', 'final'ඔබ කැමති ලෙස tuple කිරීමට, ආදිය). කෙසේ වෙතත්, කිසියම් අංගයක් තිබේදැයි පරීක්ෂා කිරීම "තාරාවා" කිරීම වඩා හොඳ බව සලකන්න, එසේ නොවුවහොත්, වැඩ කිරීම (හෝ ඇප ලබා දීම). සමහර විට විශේෂාංග නව නිකුතුවලදී වෙනත් ඒවා මගින් ප්‍රතිස්ථාපනය වේ.

විධාන රේඛාවෙන් ('V' ප්‍රාග්ධනය සටහන් කරන්න):

python -V

මෙය 'man python' හි ලේඛනගත කර ඇත.

මම මේ වගේ sys.hexversionදේවල් වලට කැමතියි.

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

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

භාවිතය platformගේpython_version මෙම stdlib සිට:

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

ඔබගේ හොඳම ඔට්ටුව බොහෝ විට එවැනි දෙයක් විය හැකිය:

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

මීට අමතරව, ඔබට සෑම විටම ඔබේ ආනයන සරල උත්සාහයකින් ඔතා ගත හැකිය, එමඟින් සින්ටැක්ස් දෝෂ හඳුනාගත හැකිය. @ හීකිගේ කාරණයට අනුව, මෙම කේතය පයිතන්ගේ පැරණි අනුවාද සමඟ අනුකූල වේ:

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

වැනි දෙයක් දමන්න:

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

ඔබගේ ස්ක්‍රිප්ටයේ ඉහළින්ම.

ඔබගේ ස්ක්‍රිප්ටයේ ඇති වෙනත් දේ මත පදනම්ව, ඉලක්කයට වඩා පැරණි පයිතන් අනුවාදයන්ට ස්ක්‍රිප්ට් පූරණය කිරීමට පවා නොහැකි විය හැකි බැවින් මෙම දෝෂය වාර්තා කිරීමට ප්‍රමාණවත් නොවනු ඇත. වැඩ කිරීමේ විසඳුමක් ලෙස, ඔබට වඩාත් නවීන කේත සමඟ ස්ක්‍රිප්ට් ආනයනය කරන ස්ක්‍රිප්ට් එකකින් ඉහත සඳහන් කළ හැකිය.

මෙන්න කෙලින්ම පිටවන කෙටි විධාන රේඛා අනුවාදයකි (ස්ක්‍රිප්ට් සහ ස්වයංක්‍රීයව ක්‍රියාත්මක කිරීම සඳහා පහසුය):

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

හෝ ප්‍රධාන, සුළු හා ක්ෂුද්‍ර:

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)

sixමොඩියුලය සමඟ , ඔබට මෙය කළ හැක්කේ:

import six

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

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

sys.version ඔබට අවශ්‍ය දේ ලබා දෙයි, පළමු අංකය තෝරන්න :)

සෙත් කීවාක් මෙන්, ප්‍රධාන පිටපත පරීක්ෂා කළ හැකිය sys.version_info (නමුත් එය 2.0 වන තෙක් නොපෙන්වූ බව සලකන්න, එබැවින් ඔබට පැරණි අනුවාදයන්ට සහය දැක්වීමට අවශ්‍ය නම් sys මොඩියුලයේ වෙනත් අනුවාද දේපල පරීක්ෂා කිරීමට අවශ්‍ය වේ).

නමුත් පැරණි පයිතන් අනුවාදවල නොමැති ගොනුවේ කිසිදු පයිතන් භාෂා අංගයක් භාවිතා නොකිරීමට ඔබ තවමත් සැලකිලිමත් විය යුතුය. උදාහරණයක් ලෙස, පයිතන් 2.5 සහ ඊට පසුව මෙය අවසර දෙනු ලැබේ:

try:
    pass
except:
    pass
finally:
    pass

නමුත් පැරණි පයිතන් අනුවාද වල ක්‍රියා නොකරනු ඇත, මන්ද ඔබට තිබිය හැක්කේ හෝ අවසානයේ උත්සාහයට ගැලපීම පමණි. එබැවින් පැරණි පයිතන් අනුවාද සමඟ අනුකූල වීම සඳහා ඔබ ලිවිය යුතුය:

try:
    try:
        pass
    except:
        pass
finally:
    pass

සරලම ක්‍රමය

ඔබේ පර්යන්තයේ පයිතන් ටයිප් කරන්න, එවිට ඔබට පහත පරිදි අනුවාදය දැකිය හැකිය

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

පිළිතුරු කිහිපයක් දැනටමත් ආකාරය යෝජනා විමසීමට වත්මන් පිඹුරා අනුවාදය. කිරීමට පරීක්ෂා programmatically අනුවාදය අවශ්යතා, මම පහත සඳහන් ක්රම දෙකක් එක් කිරීමට භාවිත කළ කැමතියි:

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

විනෝදය සඳහා, පහත දැක්වෙන්නේ CPython 1.0-3.7b2, Pypy, Jython සහ Micropython මත එය සිදු කිරීමේ ක්‍රමයකි. මෙය නූතන කේතයෙන් එය කරන ක්‍රමයකට වඩා කුතුහලය දනවන කරුණකි. මම එය ලිව්වේ http://stromberg.dnsalias.org/~strombrg/pythons/ , එය පයිතන්හි බොහෝ සංස්කරණවල කේත ස්නිපටයක් එකවර පරීක්ෂා කිරීම සඳහා වන පිටපතකි, එවිට ඔබට පහසුවෙන් කුමන පයිතන් පිළිබඳ හැඟීමක් ලබා ගත හැකිද? විශේෂාංග පයිතන්හි කුමන අනුවාද සමඟ අනුකූල වේ:

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

ඔබට පෙර පයිතන් 3 හඳුනා ගැනීමට අවශ්‍ය නම් සහ කිසිවක් ආනයනය කිරීමට අවශ්‍ය නැතිනම් ...

... ඔබට (ab) ලැයිස්තු අවබෝධය විෂය පථයේ වෙනස්කම් භාවිතා කර තනි ප්‍රකාශනයකින් කළ හැකිය :

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

වින්ඩෝස් හි විධාන සඳහා පයිතන් අනුවාදය සත්‍යාපනය කිරීම සඳහා, විධාන විමසුමක් තුළ පහත දැක්වෙන විධානයන් ක්‍රියාත්මක කර ප්‍රතිදානය සත්‍යාපනය කරන්න

c:\>python -V
Python 2.7.16

c:\>py -2 -V
Python 2.7.16

c:\>py -3 -V
Python 3.7.3

තවද, එක් එක් පයිතන් අනුවාදය සඳහා ෆෝල්ඩර වින්‍යාසය බැලීමට, පහත දැක්වෙන විධානයන් ක්‍රියාත්මක කරන්න:

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

ප්‍රතිදානය

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

පයිතන් අනුවාදය පරීක්ෂා කරන්න: python -Vහෝpython --version හෝapt-cache policy python

whereis pythonඅනුවාද කීයක් ස්ථාපනය කර ඇත්දැයි බැලීමට ඔබට ධාවනය කළ හැකිය.

sys.version_infotuple3.7 වන විට ආපසු ලබා දෙන බවක් නොපෙනේ . ඒ වෙනුවට, එය විශේෂ පංතියක් ලබා දෙයි, එබැවින් ටුපල් භාවිතා කරන සියලුම උදාහරණ ක්‍රියා නොකරයි, මට අවම වශයෙන්. පයිතන් කොන්සෝලයක ප්‍රතිදානය මෙන්න:

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

සංකලනයක් භාවිතා නොවන බව ද මට තියෙනවා sys.version_info.majorසහ sys.version_info.minorකියවීම ප්රමාණවත්ය පෙනේ. උදාහරණයක් වශයෙන්,...

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

ඔබ පයිතන් 3 ධාවනය කරන්නේ දැයි පරීක්ෂා කරයි. ඔබට වඩාත් නිශ්චිත අනුවාදයන් සමඟ පරීක්ෂා කළ හැකිය ...

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)

ඔබ අවම වශයෙන් පයිතන් 3.5 ක් ධාවනය කරන්නේ දැයි පරීක්ෂා කළ හැකිය.

ඊටත් වඩා සරලම ක්‍රමය:

ස්පයිඩර් හි, නව "අයිපයිතන් කොන්සෝලය" ආරම්භ කරන්න, ඉන්පසු ඔබගේ පවතින ඕනෑම ස්ක්‍රිප්ට් එකක් ධාවනය කරන්න.

දැන් අනුවාදය කොන්සෝල කවුළුවේ මුද්‍රණය කරන ලද පළමු ප්‍රතිදානයේ දැකිය හැකිය:

"පයිතන් 3.7.3 (පෙරනිමිය, අප්‍රේල් 24 2019, 15:29:51) ..."

විධාන රේඛාවෙන් පරීක්ෂා කිරීම සඳහා, එක් විධානයකින්, නමුත් ප්‍රධාන, සුළු, මයික්‍රෝ අනුවාදය, මුදාහැරීම් සහ අනුක්‍රමික ඇතුළත් කරන්න , ඉන්පසු ඔබ ඔබේ පිටපත සඳහා භාවිතා කරන ආකාරයටම එකම පයිතන් පරිවර්තකය (එනම් එකම මාවත) භාවිතා කරන්න:

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

3.7.6-final-0

සටහන: .format()f-string වෙනුවට හෝ '.'.join()අත්තනෝමතික හැඩතල ගැන්වීම් සහ බෙදුම් අක්ෂර භාවිතා කිරීමට ඔබට ඉඩ සලසයි, උදා. පයිතන්, අංකී, පැන්ඩා, ස්කලර්න්, මැකෝස්, එක්ස්කෝඩ්, ක්ලැන්ග්, බීර, කොන්ඩා, ඇනකොන්ඩා, ජීසීසී / ජී ++ යනාදී සියලුම වැදගත් අනුවාදයන් වාර්තා කරන බාෂ් උපයෝගිතා ස්ක්‍රිප්ටයක් තුළ මම මෙය තැබුවෙමි. .

ඔබ ලිනක්ස් හි වැඩ කරන්නේ නම් විධාන python ප්‍රතිදානය ලබා දෙන්න

පයිතන් 2.4.3 (# 1, ජුනි 11, 2009, 14:09:37)

[GCC 4.1.2 20080704 (Red Hat 4.1.2-44)] ලිනක්ස් 2 මත

වැඩි විස්තර සඳහා "උදව්", "ප්‍රකාශන හිමිකම", "බැර" හෝ "බලපත්‍රය" ටයිප් කරන්න.