Intereting Posts

¿Cómo analizar eficientemente archivos de ancho fijo? Python tiene problemas para acceder al micrófono USB con Gstreamer para realizar el reconocimiento de voz con Pocketsphinx en una Raspberry Pi En TensorFlow, ¿cuál es la diferencia entre Session.run () y Tensor.eval ()? Python convierte la lista de puntos fijos decimales en radianes Agrupar por múltiples valores, y graficar resultados. ¿Cómo hacer valores en lista de diccionario único? Detectar si el texto es inglés o no (a granel) Diagtwig de histogtwig de la lista de mechones matplotlib ¿Por qué los mensajes de multidifusión están en el mismo puerto pero de diferentes grupos combinados? Cómo generar una lista de flotadores a un archivo binario en Python Filtrar las coordenadas en un rango dado Python / Almohada: Cómo escalar una imagen Idioma de concatenación de cuerdas de Python. Necesita aclaración. Conectando al servidor Sql con Python 3 en Windows ¿Cómo modificar dinámicamente el espacio de nombres local de una función?

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

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

He intentado buscar en el módulo de la plataforma , pero parece que solo te dice sobre “la architecture de bits y el formato de enlace utilizado para el ejecutable”: el binario se comstack como 64 bits (estoy ejecutando en OS X 10.6), por lo que parece que siempre informa de 64 bits, aunque estoy usando los métodos descritos aquí para forzar el modo de 32 bits).

ACTUALIZADO: Una forma es mirar sys.maxsize como 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.maxsize se introdujo 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, podrías estar tentado a usar platform.architecture() para esto. Desafortunadamente, sus resultados no siempre son confiables, particularmente en el caso de los binarios universales de 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 comandos / terminal, 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 struct from the std.library):

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

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

 import ctypes print ctypes.sizeof(ctypes.c_voidp)

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

Abra la consola de python:

 import platform platform.architecture()[0]

debe mostrar los ’64 bits’ o ’32 bits’ 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 architecture de los procesos de 64 bits como “Intel (64 bits)”.

En mi sistema Centos Linux hice lo siguiente:

1) Comenzó 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')

Notas de platform.architecture() dicen:

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

Para obtener el “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 VM antigua (y crackeada) con una versión antigua de Python )
Mi env principal es Win
Solo tengo la versión de 32 bits instalada en Win (y construí una “lisiada” en Lnx )

Voy a ejemplificar en las 3 plataformas, usando Python3 y Python2 .

Compruebe [Python 3]: sys. Valor de tamaño máximo: compárelo con 0x100000000 ( 2 ** 32 ): mayor para 64 bits , más pequeño para 32 bits :

OSX 9 x64 :

Python 2.7.10 x64 :

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

Ubtu 16 x64 :

Python 3.5.2 x64 :

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

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

Gana 10 x64 :

Python 3.5.4 x64 :

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

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

Utilice [Python 3]: struct. calcsize ( fmt ) 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 >>> truct.calcsize("P") * 8 64 
```
- Ubtu 16 x64 :
  - Python 3.5.2 x64 :
```
 >>> import struct >>> truct.calcsize("P") * 8 64 
```
  - Python 3.6.4 x86 :
```
 >>> import struct >>> truct.calcsize("P") * 8 32 
```
- Gana 10 x64 :
  - Python 3.5.4 x64 :
```
 >>> import struct >>> truct.calcsize("P") * 8 64 
```
  - Python 3.6.2 x86 :
```
 >>> import struct >>> truct.calcsize("P") * 8 32 
```

Use [Python 3.5]: ctypes – Una biblioteca de funciones foránea para Python . También se reduce a determinar el tamaño de un puntero ( sizeof(void*) ). Como nota, ctypes utiliza # 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 
```
- Ubtu 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 
```

[Python 3]: plataforma. architecture ( ejecutable = sys.executable, bits = ”, enlace = ” ) !!! NO es confiable en OSX !!! debido al formato de archivos múltiples ejecutables (o .dylib ) (en algunos casos, utiliza # 2. ):

OSX 9 x64 :

Python 2.7.10 x64 :

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

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

Lame workaround ( gainarie ): invoca un comando externo ( [man7]: FILE (1) ) a través de [Python 3]: os. sistema ( comando ) . Las limitaciones del # 4. aplicar (a veces incluso podría no funcionar):

OSX 9 x64 :

Python 2.7.10 x64 :

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

Ubtu 16 x64 :

Python 3.5.2 x64 :

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

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

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

Ganar específico:

Verifique las env vars (por ejemplo, % PROCESSOR_ARCHITECTURE% (u otros)) a través de [Python 3]: os. 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' 
```

[Python 3]: sys. versión (también se muestra en la ^1ª línea al iniciar el intérprete)
- Compruebe # 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.

Por lo tanto, lo siguiente devolvería 32 si está ejecutando python de 32 bits y 64 si está ejecutando python de 64 bits:

Python 2

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

Python 3

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

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

despues de golpear 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) ]

Plataforma de architecture no es la forma confiable. En lugar de 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)