CODEWITHSUNDEEP
python32bit-64bit
jkp
jkp

Reputation: 81290

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

How can I 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 "the bit architecture and the linkage format used for the executable". My binary is compiled as 64bit (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.

Upvotes: 548

Views: 577799

Answers (18)

Lawrence L
Lawrence L

Reputation: 53

With python 3.8 above, you can run pyhton -VV

Upvotes: 1

CristiFati
CristiFati

Reputation: 41147

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:

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

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 3rd-party tools (Nix emulators: MSYS2, Cygwin, ...) that can be used, but I'm not going to insist on them

6. Check env vars

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 1st line when starting the interpreter

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

      Img0

  • Check #1.

Upvotes: 20

anon
anon

Reputation:

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

Upvotes: 93

Rishabh Bhatnagar
Rishabh Bhatnagar

Reputation: 640

Based on the top answer,

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

n_bits will have 32 or 64 bits.

Upvotes: 12

Ned Deily
Ned Deily

Reputation: 85095

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)

On Windows, run the same commands formatted as follows:

python -c "import sys;print(\"%x\" % sys.maxsize, sys.maxsize > 2**32)"

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

Upvotes: 511

DevLoverUmar
DevLoverUmar

Reputation: 14011

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.

Upvotes: 14

user12549815
user12549815

Reputation: 175

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

Upvotes: 11

kxr
kxr

Reputation: 5538

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

Upvotes: 0

Shannon Mann
Shannon Mann

Reputation: 111

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

Upvotes: 11

Prakhar Agarwal
Prakhar Agarwal

Reputation: 2852

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)

Upvotes: 0

rekabbnad
rekabbnad

Reputation: 389

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

Upvotes: 35

betontalpfa
betontalpfa

Reputation: 3752

import sys
print(sys.version)

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

Upvotes: 4

kimbaudi
kimbaudi

Reputation: 15615

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)

Upvotes: 8

Dustin
Dustin

Reputation: 3071

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.

Upvotes: 303

Matthew Marshall
Matthew Marshall

Reputation: 5883

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.

Upvotes: 103

Nikhil
Nikhil

Reputation: 310

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

Upvotes: 4

Peter Hosey
Peter Hosey

Reputation: 96373

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

Upvotes: 17

ChristopheD
ChristopheD

Reputation: 116267

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

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

Upvotes: 234

Related Questions