问题:如何检查正在运行脚本的Python版本?

如何检查正在解释脚本的版本的Python Interpreter?

How can I check what version of the Python Interpreter is interpreting my script?


回答 0

sys模块的sys.version字符串中提供了此信息:

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

为确保脚本以Python解释器的最低版本要求运行,请将其添加到您的代码中:

assert sys.version_info >= (2, 5)

这将比较主要版本和次要版本信息。微(=添加01等等),甚至releaselevel(= 'alpha''final'等)的元组只要你喜欢。但是请注意,最好总是“躲开”检查是否存在某个功能,如果不存在,则要变通(或纾困)。有时,某些功能在较新的版本中会消失,而被其他功能取代。

This information is available in the sys.version string in the sys module:

>>> import sys

Human readable:

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

For further processing:

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

To ensure a script runs with a minimal version requirement of the Python interpreter add this to your code:

assert sys.version_info >= (2, 5)

This compares major and minor version information. Add micro (=0, 1, etc) and even releaselevel (='alpha','final', etc) to the tuple as you like. Note however, that it is almost always better to “duck” check if a certain feature is there, and if not, workaround (or bail out). Sometimes features go away in newer releases, being replaced by others.


回答 1

在命令行中(注意大写的“ V”):

python -V

在’man python’中有记录。

From the command line (note the capital ‘V’):

python -V

This is documented in ‘man python’.


回答 2

我喜欢这样sys.hexversion的东西。

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

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

I like sys.hexversion for stuff like this.

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

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

回答 3

您最好的选择可能是这样的:

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

此外,您始终可以通过简单的尝试将导入文件包装起来,这样可以捕获语法错误。而且,就@Heikki而言,此代码将与许多旧版本的python兼容:

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

Your best bet is probably something like so:

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

Additionally, you can always wrap your imports in a simple try, which should catch syntax errors. And, to @Heikki’s point, this code will be compatible with much older versions of python:

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

回答 4

使用platformpython_version从STDLIB:

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

Use platform‘s python_version from the stdlib:

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

回答 5

放入类似:

#!/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甚至可能无法加载脚本,因此无法报告该错误。解决方法是,您可以在脚本中运行以上命令,该脚本将使用更现代的代码导入该脚本。

Put something like:

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

at the top of your script.

Note that depending on what else is in your script, older versions of python than the target may not be able to even load the script, so won’t get far enough to report this error. As a workaround, you can run the above in a script that imports the script with the more modern code.


回答 6

这是一个简短的命令行版本,可以立即退出(对于脚本和自动执行非常方便):

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)

Here’s a short commandline version which exits straight away (handy for scripts and automated execution):

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

Or just the major, minor and 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)

回答 7

使用six模块,您可以通过以下方法实现:

import six

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

With six module, you can do it by:

import six

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

回答 8

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

sys.version提供您想要的,只需选择第一个数字即可:)

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

sys.version gives you what you want, just pick the first number :)


回答 9

最简单的方法

只需在终端中键入python,您就可以看到如下所示的版本

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

The simplest way

Just type python in your terminal and you can see the version as like following

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

回答 10

就像Seth所说的那样,主脚本可以检查sys.version_info(但是请注意,直到2.0才出现),因此,如果要支持旧版本,则需要检查sys模块的另一个版本属性。

但是,您仍然需要注意不要使用该文件中的任何Python语言功能,这些功能在较早的Python版本中不可用。例如,在Python 2.5和更高版本中允许这样做:

try:
    pass
except:
    pass
finally:
    pass

但在较旧的Python版本中将无法使用,因为您只能使用OR或最终与try匹配。因此,为了与旧版本的Python兼容,您需要编写:

try:
    try:
        pass
    except:
        pass
finally:
    pass

Like Seth said, the main script could check sys.version_info (but note that that didn’t appear until 2.0, so if you want to support older versions you would need to check another version property of the sys module).

But you still need to take care of not using any Python language features in the file that are not available in older Python versions. For example, this is allowed in Python 2.5 and later:

try:
    pass
except:
    pass
finally:
    pass

but won’t work in older Python versions, because you could only have except OR finally match the try. So for compatibility with older Python versions you need to write:

try:
    try:
        pass
    except:
        pass
finally:
    pass

回答 11

一些答案已经建议如何查询当前的python版本。为了以编程方式检查版本要求,我将使用以下两种方法之一:

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

Several answers already suggest how to query the current python version. To check programmatically the version requirements, I’d make use of one of the following two methods:

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

回答 12

只是为了好玩,下面是在CPython 1.0-3.7b2,Pypy,Jython和Micropython上执行此操作的一种方法。这更多是出于好奇,而不是现代代码中的一种实现方式。我将其作为http://stromberg.dnsalias.org/~strombrg/pythons/的一部分编写的,该脚本是用于一次在多个python版本上测试代码段的脚本,因此您可以轻松了解python的种类功能与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")

Just for fun, the following is a way of doing it on CPython 1.0-3.7b2, Pypy, Jython and Micropython. This is more of a curiosity than a way of doing it in modern code. I wrote it as part of http://stromberg.dnsalias.org/~strombrg/pythons/ , which is a script for testing a snippet of code on many versions of python at once, so you can easily get a feel for what python features are compatible with what versions of 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")

回答 13

检查Python版本:python -Vpython --versionapt-cache policy python

您还可以运行whereis python以查看安装了多少个版本。

Check Python version: python -V or python --version or apt-cache policy python

you can also run whereis python to see how many versions are installed.


回答 14

如果您想检测Python 3之前的版本并且不想导入任何东西…

…您可以(ab)使用列表理解范围的更改,并在单个表达式中完成

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

If you want to detect pre-Python 3 and don’t want to import anything…

…you can (ab)use list comprehension scoping changes and do it in a single expression:

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

回答 15

要在Windows上验证Python版本的命令,请在命令提示符下运行以下命令并验证输出

c:\>python -V
Python 2.7.16

c:\>py -2 -V
Python 2.7.16

c:\>py -3 -V
Python 3.7.3

另外,要查看每个Python版本的文件夹配置,请运行以下命令:

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

To verify the Python version for commands on Windows, run the following commands in a command prompt and verify the output

c:\>python -V
Python 2.7.16

c:\>py -2 -V
Python 2.7.16

c:\>py -3 -V
Python 3.7.3

Also, To see the folder configuration for each Python version, run the following commands:

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

回答 16

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

output

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

回答 17

sys.version_infotuple从3.7开始似乎没有返回a 。相反,它返回一个特殊的类,因此至少对于我来说,所有使用元组的示例都不起作用。这是python控制台的输出:

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

我发现结合使用sys.version_info.majorsys.version_info.minor似乎足够了。例如,…

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

检查您是否正在运行Python3。您甚至可以使用…检查更特定的版本。

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)

可以检查您是否至少运行Python 3.5。

sys.version_info doesn’t seem to return a tuple as of 3.7. Rather, it returns a special class, so all of the examples using tuples don’t work, for me at least. Here’s the output from a python console:

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

I’ve found that using a combination of sys.version_info.major and sys.version_info.minor seems to suffice. For example,…

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

checks if you’re running Python 3. You can even check for more specific versions with…

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)

can check to see if you’re running at least Python 3.5.


回答 18

最简单的方法:

在Spyder中,启动新的“ IPython Console”,然后运行任何现有脚本。

现在,可以在控制台窗口中打印的第一个输出中看到版本:

“ Python 3.7.3(默认值,2019年4月24日,15:29:51)…”

在此处输入图片说明

The even simpler simplest way:

In Spyder, start a new “IPython Console”, then run any of your existing scripts.

Now the version can be seen in the first output printed in the console window:

“Python 3.7.3 (default, Apr 24 2019, 15:29:51)…”

enter image description here


回答 19

要从命令行检查,只需一个命令,但要包含主要,次要,微型版本,发行版和序列号

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

3.7.6-final-0

注意:.format()代替f字符串,或者'.'.join()允许您使用任意格式和分隔符char,例如,使其成为可抓握的单字字符串。我将其放在报告所有重要版本的bash实用程序脚本中:python,numpy,pandas,sklearn,MacOS,xcode,clang,brew,conda,anaconda,gcc / g ++等。对于日志记录,可复制性,故障排除报告等很有用。

To check from the command-line, in one single command, but include major, minor, micro version, releaselevel and serial:

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

3.7.6-final-0

Note: .format() instead of f-strings or '.'.join() allows you to use arbitrary formatting and separator chars, e.g. to make this a greppable one-word string. I put this inside a bash utility script that reports all important versions: python, numpy, pandas, sklearn, MacOS, xcode, clang, brew, conda, anaconda, gcc/g++ etc. Useful for logging, replicability, troubleshootingm bug-reporting etc.


回答 20

如果您在linux上工作,请给出命令python 输出将如下所示

Python 2.4.3(#1,2009年6月11日,14:09:37)

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

键入“帮助”,“版权”,“信用”或“许可证”以获取更多信息。

If you are working on linux just give command python output will be like this

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.


声明:本站所有文章,如无特殊说明或标注,均为本站原创发布。任何个人或组织,在未征得本站同意时,禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益,可联系我们进行处理。