How do I determine if my python shell is executing

问题:

I need a way to tell what mode the shell is in from within the shell.

I\'ve tried looking at the platform module but it seems only to tell you about \"about the bit architecture and the linkage format used for the executable\": the binary is compiled as 64bit though (I\'m running on OS X 10.6) so it seems to always report 64bit even though I\'m using the methods described here to force 32bit mode).

回答1:

UPDATED: One way is to look at sys.maxsize as documented here:

$ python-32 -c \'import sys;print(\"%x\" % sys.maxsize, sys.maxsize > 2**32)\'
(\'7fffffff\', False)
$ python-64 -c \'import sys;print(\"%x\" % sys.maxsize, sys.maxsize > 2**32)\'
(\'7fffffffffffffff\', True)

sys.maxsize was introduced in Python 2.6. If you need a test for older systems, this slightly more complicated test should work on all Python 2 and 3 releases:

$ python-32 -c \'import struct;print( 8 * struct.calcsize(\"P\"))\'
32
$ python-64 -c \'import struct;print( 8 * struct.calcsize(\"P\"))\'
64

BTW, you might be tempted to use platform.architecture() for this. Unfortunately, its results are not always reliable, particularly in the case of OS X universal binaries.

$ arch -x86_64 /usr/bin/python2.6 -c \'import sys,platform; print platform.architecture()[0], sys.maxsize > 2**32\'
64bit True
$ arch -i386 /usr/bin/python2.6 -c \'import sys,platform; print platform.architecture()[0], sys.maxsize > 2**32\'
64bit False

回答2:

When starting the Python interpreter in the terminal/command line you may also see a line like:

Python 2.7.2 (default, Jun 12 2011, 14:24:46) [MSC v.1500 64 bit (AMD64)] on win32

Where [MSC v.1500 64 bit (AMD64)] means 64-bit Python. Works for my particular setup.

回答3:

Basically a variant on Matthew Marshall\'s answer (with struct from the std.library):

import struct
print struct.calcsize(\"P\") * 8

回答4:

Try using ctypes to get the size of a void pointer:

import ctypes
print ctypes.sizeof(ctypes.c_voidp)

It\'ll be 4 for 32 bit or 8 for 64 bit.

回答5:

Open python console:

import platform
platform.architecture()[0]

it should display the \'64bit\' or \'32bit\' according to your platform.

Alternatively( in case of OS X binaries ):

import sys
sys.maxsize > 2**32 
# it should display True in case of 64bit and False in case of 32bit

回答6:

For a non-programmatic solution, look in the Activity Monitor. It lists the architecture of 64-bit processes as “Intel (64-bit)”.

回答7:

On my Centos Linux system I did the following:

1) Started the Python interpreter (I\'m using 2.6.6)
2) Ran the following code:

import platform
print(platform.architecture())

and it gave me

(64bit, \'ELF\')

回答8:

platform.architecture() notes say:

Note: On Mac OS X (and perhaps other platforms), executable files may be universal files containing multiple architectures.

To get at the “64-bitness” of the current interpreter, it is more reliable to query the sys.maxsize attribute:

import sys
is_64bits = sys.maxsize > 2**32

回答9:

struct.calcsize(\"P\") returns size of the bytes required to store a single pointer. On a 32-bit system, it would return 4 bytes. On a 64-bit system, it would return 8 bytes.

So the following would return 32 if you\'re running 32-bit python and 64 if you\'re running 64-bit python:

Python 2

import struct;print struct.calcsize(\"P\") * 8

Python 3

import struct;print(struct.calcsize(\"P\") * 8)

回答10:

Grouping everything...

Considering that:

• The question is asked for OSX (I have an old (and cracked) VM with an ancient Python version)
• My main env is Win
• I only have the 32bit version installed on Win (and I built a \"crippled\" one on Lnx)

I\'m going to exemplify on all 3 platforms. I\'ll be using Python3 and Python2. Doc URLs however, will be Python3 specific.

1. Check [Python 3]: sys.maxsize value - compare it to 0x100000000 (2 ** 32): greater for 64bit, smaller for 32bit:
   • OSX 9 x64:
     • Python 2.7.10 x64:

       >>> import sys
       >>> \"Python {:s} on {:s}\".format(sys.version, sys.platform)
       \'Python 2.7.10 (default, Oct 14 2015, 05:51:29) \\n[GCC 4.8.2] on darwin\'
       >>> hex(sys.maxsize), sys.maxsize > 0x100000000
       (\'0x7fffffffffffffff\', True)
       

   • Ubtu 16 x64:
     • Python 3.5.2 x64:

       >>> import sys
       >>> \"Python {:s} on {:s}\".format(sys.version, sys.platform)
       \'Python 3.5.2 (default, Nov 23 2017, 16:37:01) \\n[GCC 5.4.0 20160609] on linux\'
       >>> hex(sys.maxsize), sys.maxsize > 0x100000000
       (\'0x7fffffffffffffff\', True)
       

     • Python 3.6.4 x86:

       >>> import sys
       >>> \"Python {:s} on {:s}\".format(sys.version, sys.platform)
       \'Python 3.6.4 (default, Apr 25 2018, 23:55:56) \\n[GCC 5.4.0 20160609] on linux\'
       >>> hex(sys.maxsize), sys.maxsize > 0x100000000
       (\'0x7fffffff\', False)
       

   • Win 10 x64:
     • Python 3.5.4 x64:

       >>> import sys
       >>> \"Python {:s} on {:s}\".format(sys.version, sys.platform)
       \'Python 3.5.4 (v3.5.4:3f56838, Aug  8 2017, 02:17:05) [MSC v.1900 64 bit (AMD64)] on win32\'
       >>> hex(sys.maxsize), sys.maxsize > 0x100000000
       (\'0x7fffffffffffffff\', True)
       

     • Python 3.6.2 x86:

       >>> import sys
       >>> \"Python {:s} on {:s}\".format(sys.version, sys.platform)
       \'Python 3.6.2 (v3.6.2:5fd33b5, Jul  8 2017, 04:14:34) [MSC v.1900 32 bit (Intel)] on win32\'
       >>> hex(sys.maxsize), sys.maxsize > 0x100000000
       (\'0x7fffffff\', False)
       

1. Use [Python 3]: struct.calcsize(fmt) to determine the object size produced by the (pointer) format. In other words, determines the pointer size (sizeof(void*)):
   • OSX 9 x64:
     • Python 2.7.10 x64:

       >>> import struct
       >>> truct.calcsize(\"P\") * 8
       64
       

   • Ubtu 16 x64:
     • Python 3.5.2 x64:

       >>> import struct
       >>> truct.calcsize(\"P\") * 8
       64
       

     • Python 3.6.4 x86:

       >>> import struct
       >>> truct.calcsize(\"P\") * 8
       32
       

   • Win 10 x64:
     • Python 3.5.4 x64:

       >>> import struct
       >>> truct.calcsize(\"P\") * 8
       64
       

     • Python 3.6.2 x86:

       >>> import struct
       >>> truct.calcsize(\"P\") * 8
       32
       

1. Use [Python 3.5]: ctypes - A foreign function library for Python. It also boils down to determining the size of a pointer (sizeof(void*)). As a note, ctypes uses #2. (not necessarily for this task) via \"${PYTHON_SRC_DIR}/Lib/ctypes/__init__.py\" (around line #15):
   • OSX 9 x64:
     • Python 2.7.10 x64:

       >>> import ctypes
       >>> ctypes.sizeof(ctypes.c_void_p) * 8
       64
       

   • Ubtu 16 x64:
     • Python 3.5.2 x64:

       >>> import ctypes
       >>> ctypes.sizeof(ctypes.c_void_p) * 8
       64
       

     • Python 3.6.4 x86:

       >>> import ctypes
       >>> ctypes.sizeof(ctypes.c_void_p) * 8
       32
       

   • Win 10 x64:
     • Python 3.5.4 x64:

       >>> import ctypes
       >>> ctypes.sizeof(ctypes.c_void_p) * 8
       64
       

     • Python 3.6.2 x86:

       >>> import ctypes
       >>> ctypes.sizeof(ctypes.c_void_p) * 8
       32
       

1. [Python 3]: platform.architecture(executable=sys.executable, bits=\'\', linkage=\'\') !!! NOT reliable on OSX !!! due to multi arch executable (or .dylib) format (in some cases, uses #2.):
   • OSX 9 x64:
     • Python 2.7.10 x64:

       >>> import platform
       >>> platform.architecture()
       (\'64bit\', \'\')
       

   • Ubtu 16 x64:
     • Python 3.5.2 x64:

       >>> import platform
       >>> platform.architecture()
       (\'64bit\', \'ELF\')
       

     • Python 3.6.4 x86:

       >>> import platform
       >>> platform.architecture()
       (\'32bit\', \'ELF\')
       

   • Win 10 x64:
     • Python 3.5.4 x64:

       >>> import platform
       >>> platform.architecture()
       (\'64bit\', \'WindowsPE\')
       

     • Python 3.6.2 x86:

       >>> import platform
       >>> platform.architecture()
       (\'32bit\', \'WindowsPE\')
       

1. Lame workaround (gainarie) - invoke an external command ([man7]: FILE(1)) via [Python 3]: os.system(command). The limitations of #4. apply (sometimes it might not even work):
   • OSX 9 x64:
     • Python 2.7.10 x64:

       >>> import os
       >>> os.system(\"file {:s}\".format(os.path.realpath(sys.executable)))
       /opt/OPSWbuildtools/2.0.6/bin/python2.7.global: Mach-O 64-bit executable x86_64
       

   • Ubtu 16 x64:
     • Python 3.5.2 x64:

       >>> import os
       >>> os.system(\"file {:s}\".format(os.path.realpath(sys.executable)))
       /usr/bin/python3.5: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=59a8ef36ca241df24686952480966d7bc0d7c6ea, stripped
       

     • Python 3.6.4 x86:

       >>> import os
       >>> os.system(\"file {:s}\".format(os.path.realpath(sys.executable)))
       /home/cfati/Work/Dev/Python-3.6.4/python: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=5c3d4eeadbd13cd91445d08f90722767b0747de2, not stripped
       

   • Win 10 x64:
     • file utility is not present, there are other 3^rd Party tools that can be used, but I\'m not going to insist on them

Win specific:

1. Check env vars (e.g. %PROCESSOR_ARCHITECTURE% (or others)) via [Python 3]: os.environ:
   • Win 10 x64:
     • Python 3.5.4 x64:

       >>> import os
       >>> os.environ[\"PROCESSOR_ARCHITECTURE\"]
       \'AMD64\'
       

     • Python 3.6.2 x86:

       >>> import os
       >>> os.environ[\"PROCESSOR_ARCHITECTURE\"]
       \'x86\'
       

1. [Python 3]: sys.version (also displayed in the 1^st line when starting the interpreter)
   • Check #1.

回答11:

C:\\Users\\xyz>python

Python 2.7.6 (default, Nov XY ..., 19:24:24) **[MSC v.1500 64 bit (AMD64)] on win
32**
Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.
>>>

after hitting python in cmd

回答12:

import sys
print(sys.version)

3.5.1 (v3.5.1:37a07cee5969, Dec 6 2015, 01:54:25) [MSC v.1900 64 bit (AMD64)]

回答13:

Platform Architecture is not the reliable way. Instead us:

$ arch -i386 /usr/local/bin/python2.7
Python 2.7.9 (v2.7.9:648dcafa7e5f, Dec 10 2014, 10:10:46)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.
>>> import platform, sys
>>> platform.architecture(), sys.maxsize
((\'64bit\', \'\'), 2147483647)
>>> ^D
$ arch -x86_64 /usr/local/bin/python2.7
Python 2.7.9 (v2.7.9:648dcafa7e5f, Dec 10 2014, 10:10:46)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.
>>> import platform, sys
>>> platform.architecture(), sys.maxsize
((\'64bit\', \'\'), 9223372036854775807)