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

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.

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

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

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

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.

C:Usersxyz>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

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

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

To paraphrase the answer at https://stackoverflow.com/a/1405971 —

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

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)

import sys
print(sys.version)

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

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)

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 032bit (Python) version installed on Win (and I built a "crippled" one on Linux (Ubuntu))

I’m going to exemplify on all 3 platforms, using Python 3 and Python 2.

1. Check [Python.Docs]: sys.maxsize

Compare value to 0x100000000 (4294967296 or 2 ** 32):

• Greater for 064bit (pc064)

• Smaller for 032bit (pc032)

Example:

• OSX 9 pc064:

  • Python 2.7.10 pc064:

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

• Ubuntu 16 pc064:

  • Python 3.5.2 pc064:

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

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

  • Python 3.5.4 pc064:

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

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

2. Use [Python.Docs]: struct.calcsize(format)

Determine the object size produced by the (pointer) format. In other words, determines the pointer size (sizeof(void*)).

Example:

• OSX 9 pc064:

  • Python 2.7.10 pc064:

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

• Ubuntu 16 pc064:

  • Python 3.5.2 pc064:

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

  • Python 3.6.4 pc032:

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

• Win 10 pc064:

  • Python 3.5.4 pc064:

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

  • Python 3.6.2 pc032:

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

3. Use [Python.Docs]: ctypes – A foreign function library for Python

It also boils down to determining the size of a pointer (sizeof(void*)).

CTypes side notes:

• Might use #2. in certain situations (via [GitHub]: python/cpython – (main) cpython/Lib/ctypes/__init__.py)

• Check [SO]: C function called from Python via ctypes returns incorrect value (@CristiFati’s answer) for common mistakes when using it (in more complex scenarios (e.g. calling functions))

• [SO]: Maximum and minimum value of C types integers from Python (@CristiFati’s answer) might also be interesting

Example:

• OSX 9 pc064:

  • Python 2.7.10 pc064:

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

• Ubuntu 16 pc064:

  • Python 3.5.2 pc064:

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

  • Python 3.6.4 pc032:

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

• Win 10 pc064:

  • Python 3.5.4 pc064:

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

  • Python 3.6.2 pc032:

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

4. Check [Python.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.).

Example:

• OSX 9 pc064:

  • Python 2.7.10 pc064:

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

• Ubuntu 16 pc064:

  • Python 3.5.2 pc064:

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

  • Python 3.6.4 pc032:

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

• Win 10 pc064:

  • Python 3.5.4 pc064:

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

  • Python 3.6.2 pc032:

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

5. Invoke an external command

• [Man7]: FILE(1) via [Python.Docs]: os.system(command)

• Lame workaround (gainarie)

• Limitations of #4. apply (sometimes it might not even work):

Example:

• OSX 9 pc064:

  • Python 2.7.10 pc064:

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

• Ubuntu 16 pc064:

  • Python 3.5.2 pc064:

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

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

  • file utility is not present, there are other 3^rd-party tools (Nix emulators: MSYS2, Cygwin, …) that can be used, but I’m not going to insist on them

6. Check env vars

• Via [Python.Docs]: os.environ:

• Win specific:

  • %PROCESSOR_ARCHITECTURE% (or others)

Example:

• Win 10 pc064:

  • Python 3.5.4 pc064:

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

  • Python 3.6.2 pc032:

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

7. Check [Python.Docs]: sys.version

• Also displayed in the 1^st line when starting the interpreter

  • On some platforms, it might contain (textual) architecture information:

    

• Check #1.

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

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

Based on the top answer,

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

n_bits will have 32 or 64 bits.

On Windows 10

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

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