¿Cómo determino si mi shell de Python se está ejecutando en modo de 32 bits o 64 bits en OS X?

Necesito una manera de saber en qué modo está el shell desde dentro del shell.

Intenté mirar el módulo de la plataforma , pero parece solo decirle "sobre la arquitectura de bits y el formato de enlace utilizado para el ejecutable": el binario se compila como 64 bits (estoy ejecutando en OS X 10.6) así que parece que siempre informa 64 bits, aunque estoy usando los métodos descritos aquí para forzar el modo 32 bits).

Una forma es mirar sys.maxsizecomo se documenta aquí :

$ 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.maxsizefue introducido en Python 2.6. Si necesita una prueba para sistemas más antiguos, esta prueba un poco más complicada debería funcionar en todas las versiones de Python 2 y 3:

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

Por cierto, puede ser tentado a usar platform.architecture()para esto. Por desgracia, sus resultados no siempre son fiables, sobre todo en el caso de los binarios universales OS X .

$ 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

Al iniciar el intérprete de Python en la línea de terminal / comando, también puede ver una línea como:

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

Donde [MSC v.1500 64 bit (AMD64)]significa Python de 64 bits. Funciona para mi configuración particular.

Básicamente, una variante de la respuesta de Matthew Marshall (con una estructura de la biblioteca estándar):

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

Intente usar ctypes para obtener el tamaño de un puntero vacío:

import ctypes
print ctypes.sizeof(ctypes.c_voidp)

Será 4 para 32 bits u 8 para 64 bits.

Consola Python abierta:

import platform
platform.architecture()[0]

debería mostrar el '64bit' o '32bit' de acuerdo con su plataforma.

Alternativamente ( en el caso de los binarios de OS X ):

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

Para una solución no programática, busque en el Monitor de actividad. Enumera la arquitectura de los procesos de 64 bits como "Intel (64 bits)".

En mi sistema Centos Linux hice lo siguiente:

1) Comencé el intérprete de Python (estoy usando 2.6.6)
2) Ejecuté el siguiente código:

import platform
print(platform.architecture())

y me dio

(64bit, 'ELF')

platform.architecture() las notas dicen:

Nota: en Mac OS X (y quizás en otras plataformas), los archivos ejecutables pueden ser archivos universales que contienen múltiples arquitecturas.

Para llegar a la "64 bits" del intérprete actual, es más confiable consultar el atributo sys.maxsize:

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

Agrupando todo ...

Teniendo en cuenta que:

• La pregunta se hace para OSX (tengo una máquina virtual antigua (y agrietada) con una versión antigua de Python )
• Mi principal env es Win
• Solo tengo la versión de 32 bits instalada en Win (y construí una versión "paralizada" en Lnx )

Voy a ejemplificar en las 3 plataformas, usando Python 3 y Python 2 .

1. Marque [Python 3.Docs]: sys. valor de tamaño máximo: compárelo con 0x100000000( 2 ** 32): mayor para 64 bits , menor para 32 bits :
   • 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)

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

2. Utilice [Python 3.Docs]: struct. calcsize ( formato ) para determinar el tamaño del objeto producido por el formato (puntero). En otras palabras, determina el tamaño del puntero (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

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

3. Utilice [Python 3.Docs]: ctypes: una biblioteca de funciones foráneas para Python . También se reduce a determinar el tamaño de un puntero ( sizeof(void*)). Como nota, ctypes usa # 2. (no necesariamente para esta tarea) a través de "$ {PYTHON_SRC_DIR} / Lib / ctypes / __ init__.py" (alrededor de la línea # 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

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

4. [Python 3.Docs]: plataforma. arquitectura ( ejecutable = sys.executable, bits = '', enlace = '' ) !!! ¡NO es confiable en OSX ! debido al formato ejecutable de múltiples arcos (o .dylib ) (en algunos casos, usa el # 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')

   • Gana 10 x64 :
     • Python 3.5.4 x64 :

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

     • Python 3.6.2 x86 :

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

5. Solución poco convincente ( gainarie ): invoque un comando externo ( [man7]: FILE (1) ) a través de [Python 3.Docs]: os. sistema ( comando ) . Las limitaciones del # 4. aplicar (a veces puede que incluso no funcione):
   • 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

   • Gana 10 x64 :
     • la utilidad de archivo no está presente, hay otras herramientas de ^terceros que se pueden usar, pero no voy a insistir en ellas

Ganancia específica:

6. Verifique los valores del entorno (por ejemplo, % PROCESSOR_ARCHITECTURE% (u otros)) a través de [Python 3.Docs]: os. medio ambiente :
   • Gana 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'

7. [Python 3.Docs]: sys. versión (también se muestra en la ^primera línea al iniciar el intérprete)
   • Verifique # 1.

struct.calcsize("P")devuelve el tamaño de los bytes necesarios para almacenar un solo puntero. En un sistema de 32 bits, devolvería 4 bytes. En un sistema de 64 bits, devolvería 8 bytes.

Entonces, lo siguiente volvería 32si está ejecutando python de 32 bits y 64si está ejecutando python de 64 bits:

Python 2

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

Python 3

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

Haz un python -VVen la línea de comando. Debería devolver la versión.

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

después de tocar python en cmd

import sys
print(sys.version)

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

Según la respuesta de abe32,

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

n_bits tendrá 32 o 64 bits.

Para 32 bits devolverá 32 y para 64 bits devolverá 64

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

La arquitectura de plataforma no es la forma confiable. En cambio nosotros:

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

platform.architecture() Es problemático (y costoso).

Prueba convenientemente sys.maxsize > 2**32desde Py2.6.

Esta es una prueba fiable para la (predeterminado) Tamaño de puntero actual y compatible al menos desde Py2.3: struct.calcsize('P') == 8. También: ctypes.sizeof(ctypes.c_void_p) == 8.

Notas: Puede haber compilaciones con la opción gcc más -mx32o menos, que son aplicaciones de arquitectura de 64 bits, pero usan punteros de 32 bits de forma predeterminada (ahorro de memoria y velocidad). 'sys.maxsize = ssize_t' puede no representar estrictamente el tamaño del puntero C (generalmente de 2**31 - 1todos modos). Y hubo / hay sistemas que tienen diferentes tamaños de puntero para código y datos y es necesario aclarar cuál es exactamente el propósito de discernir el "modo de 32 bits o 64 bits".