Which command to use for checking whether python is 64bit or 32bit

First, open cmd and type in

$ python

Then, type in the following two lines

>>> import platform

>>> platform.architecture()

Type in Linux console:

1. In case when you want check whether an application has 64 bit or 32 bit architecture by using its command for run:

type -p <command_to_run_application> | xargs readlink -f | xargs file -b | sed 's/, /\n/g' | sed -n 2p

2. In case when you want check whether an application has 64 bit or 32 bit architecture by using full path to the application:

file -b <full_path_to_an_application> | sed 's/, /\n/g' | sed -n 2p

For example, for Python 3 corresponding commands can be:

type -p python3 | xargs readlink -f | xargs file -b | sed 's/, /\n/g' | sed -n 2p
file -b /usr/bin/python3.5 | sed 's/, /\n/g' | sed -n 2p

Possible output:

x86-64

or

Intel 80386

or

ARM

or other.

If output is "Intel 80386" than the application has 32 bit architecture.

If output is "x86-64" than the application has 64 bit architecture.

import platform
platform.architecture()[0]
#'32bit'

For Python 2.6 and above, you can use sys.maxsize as documented here:

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

UPDATE: I notice that I didn't really answer the question posed. While the above test does accurately tell you whether the interpreter is running in a 32-bit or a 64-bit architecture, it doesn't and can't answer the question of what is the complete set of architectures that this interpreter was built for and could run in. As was noted in the question, this is important for example with Mac OS X universal executables where one executable file may contain code for multiple architectures. One way to answer that question is to use the operating system file command. On most systems it will report the supported architectures of an executable file. Here's how to do it in one line from a shell command line on most systems:

file -L $(python -c 'import sys; print(sys.executable)')

Using the default system Python on OS X 10.6, the output is:

/usr/bin/python: Mach-O universal binary with 3 architectures
/usr/bin/python (for architecture x86_64):  Mach-O 64-bit executable x86_64
/usr/bin/python (for architecture i386):    Mach-O executable i386
/usr/bin/python (for architecture ppc7400): Mach-O executable ppc

On one Linux system:

/usr/bin/python: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.26, stripped

BTW, here's an example of why platform is not reliable for this purpose. Again using the system Python on OS X 10.6:

$ 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