How do I determine if my python shell is executing in 32bit or 64bit?

user_912 0
Viewed 481207

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

While I'm primarily an OS X user, I'd be interested in knowing about other platforms as well.

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

macos python
19 Answers

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, using Python 3 and Python 2.

  1. Check [Python 3.Docs]: 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 {0:s} on {1: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)
    • Ubuntu 16 x64:
      • Python 3.5.2 x64: 
        >>> import sys
>>> "Python {0:s} on {1: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 {0:s} on {1: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 {0:s} on {1: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 {0:s} on {1: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.Docs]: struct.calcsize(format) 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
>>> struct.calcsize("P") * 8
64
    • Ubuntu 16 x64:
      • Python 3.5.2 x64: 
        >>> import struct
>>> struct.calcsize("P") * 8
64
      • Python 3.6.4 x86: 
        >>> import struct
>>> struct.calcsize("P") * 8
32
    • Win 10 x64:
      • Python 3.5.4 x64: 
        >>> import struct
>>> struct.calcsize("P") * 8
64
      • Python 3.6.2 x86: 
        >>> import struct
>>> struct.calcsize("P") * 8
32


  1. Use [Python 3.Docs]: 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
    • Ubuntu 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.Docs]: 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', '')
    • Ubuntu 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.Docs]: 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 {0:s}".format(os.path.realpath(sys.executable)))
/opt/OPSWbuildtools/2.0.6/bin/python2.7.global: Mach-O 64-bit executable x86_64
    • Ubuntu 16 x64:
      • Python 3.5.2 x64: 
        >>> import os
>>> os.system("file {0: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 {0: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 3rd 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.Docs]: 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.Docs]: sys.version (also displayed in the 1st line when starting the interpreter)
    • Check #1.
user_47885460

For 32 bit it will return 32 and for 64 bit it will return 64

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

On Windows 10

Open the cmd termial and start python interpreter by typing >python as shown in the below image

Img

If the interpreter info at start contains AMD64, it's 64-bit, otherwise, 32-bit bit.

user_73441640

Do a python -VV in the command line. It should return the version.

user_125498150

Try this:

import platform
platform.architecture()
user_144627640

Based On abe32's answer,

import sys
n_bits = 32 << bool(sys.maxsize >> 32)

n_bits will have 32 or 64 bits.

user_79020520

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

platform.architecture() is problematic (and expensive).

Conveniently test for sys.maxsize > 2**32 since Py2.6 .

This is a reliable test for the actual (default) pointer size and compatible at least since Py2.3: struct.calcsize('P') == 8. Also: ctypes.sizeof(ctypes.c_void_p) == 8.

Notes: There can be builds with gcc option -mx32 or so, which are 64bit architecture applications, but use 32bit pointers as default (saving memory and speed). 'sys.maxsize = ssize_t' may not strictly represent the C pointer size (its usually 2**31 - 1 anyway). And there were/are systems which have different pointer sizes for code and data and it needs to be clarified what exactly is the purpose of discerning "32bit or 64bit mode?"

user_11849330
Related