Come posso determinare se la mia shell python viene eseguita in modalità 32 bit o 64 bit su OS X?

Ho bisogno di un modo per dire in quale modalità si trova la shell all'interno della shell.

Ho provato a guardare il modulo della piattaforma ma sembra parlarti solo di "dell'architettura bit e del formato di collegamento utilizzato per l'eseguibile": il binario è compilato come 64 bit (sto eseguendo su OS X 10.6) quindi sembra riportare sempre 64 bit anche se sto usando i metodi descritti qui per forzare la modalità 32 bit).

Un modo è quello di guardare sys.maxsizecome documentato qui :

$ 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è stato introdotto in Python 2.6. Se hai bisogno di un test per sistemi più vecchi, questo test leggermente più complicato dovrebbe funzionare su tutte le versioni di Python 2 e 3:

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

A proposito, potresti essere tentato di usarlo platform.architecture()per questo. Purtroppo, i suoi risultati non sono sempre affidabili, in particolare nel caso di file binari universali 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

Quando avvii l'interprete Python nella riga di comando / terminale potresti anche vedere una riga come:

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

Dove [MSC v.1500 64 bit (AMD64)]significa Python a 64 bit. Funziona per la mia configurazione particolare.

Fondamentalmente una variante della risposta di Matthew Marshall (con struct dalla std.library):

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

Prova a usare ctypes per ottenere la dimensione di un puntatore vuoto:

import ctypes
print ctypes.sizeof(ctypes.c_voidp)

Sarà 4 per 32 bit o 8 per 64 bit.

Apri la console di Python:

import platform
platform.architecture()[0]

dovrebbe visualizzare "64 bit" o "32 bit" in base alla propria piattaforma.

In alternativa ( nel caso di binari OS X ):

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

Per una soluzione non programmatica, cerca nel Monitor attività. Elenca l'architettura dei processi a 64 bit come "Intel (64 bit)".

Sul mio sistema Centos Linux ho fatto quanto segue:

1) Ho avviato l'interprete Python (sto usando 2.6.6)
2) Ho eseguito il seguente codice:

import platform
print(platform.architecture())

e mi ha dato

(64bit, 'ELF')

platform.architecture() le note dicono:

Nota: su Mac OS X (e forse su altre piattaforme), i file eseguibili possono essere file universali contenenti più architetture.

Per ottenere il "64-bitness" dell'interprete corrente, è più affidabile interrogare l'attributo sys.maxsize:

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

Raggruppare tutto ...

Considerando che:

• La domanda è per OSX (ho una vecchia (e crackata) VM con un antico Python versione di )
• Il mio env principale è Win
• Ho solo la versione a 32 bit installata su Win (e ne ho costruita una "paralizzata" su Lnx )

Ho intenzione di esemplificare su tutte e 3 le piattaforme, usando Python 3 e Python 2 .

1. Controlla [Python 3.Docs]: sys. valore massimo : confrontalo con 0x100000000( 2 ** 32): maggiore per 64 bit , più piccolo per 32 bit :
   • 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)

   • Vinci 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. Usa [Python 3.Docs]: struct. calcsize ( formato ) per determinare la dimensione dell'oggetto prodotta dal formato (puntatore). In altre parole, determina la dimensione del puntatore ( 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

   • Vinci 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. Usa [Python 3.Docs]: ctypes - Una libreria di funzioni esterne per Python . Si riduce anche a determinare la dimensione di un puntatore ( sizeof(void*)). Come nota, ctypes usa # 2. (non necessariamente per questa attività) tramite "$ {PYTHON_SRC_DIR} / Lib / ctypes / __ init__.py" (intorno alla riga 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

   • Vinci 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]: piattaforma. architecture ( eseguibile = sys.executable, bits = '', linkage = '' ) !!! NON affidabile su OSX !!! a causa del formato eseguibile multi arch (o .dylib ) (in alcuni casi, utilizza # 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')

   • Vinci 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. Soluzione alternativa ( gainarie ) - richiama un comando esterno ( [man7]: FILE (1) ) tramite [Python 3.Docs]: os. sistema ( comando ) . I limiti di # 4. applicare (a volte potrebbe anche non funzionare):
   • 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

   • Vinci 10 x64 :
     • l' utilità file non è presente, ci sono altri strumenti di ^terze parti che possono essere utilizzati, ma non ho intenzione di insistere su di essi

Win specifico:

6. Controlla i vari parametri (es. % PROCESSOR_ARCHITECTURE% (o altri)) tramite [Python 3.Docs]: os. ambi :
   • Vinci 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. versione (anche visualizzato nella 1 ^° linea quando si avvia l'interprete)
   • Controlla # 1.

struct.calcsize("P")restituisce la dimensione dei byte necessari per memorizzare un singolo puntatore. Su un sistema a 32 bit, restituirebbe 4 byte. Su un sistema a 64 bit, restituirebbe 8 byte.

Quindi quanto segue ritornerebbe 32se si esegue Python a 32 bit e 64se si esegue Python a 64 bit:

Python 2

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

Python 3

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

Esegui un python -VVcomando nella riga di comando. Dovrebbe restituire la versione.

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

dopo aver colpito Python in cmd

import sys
print(sys.version)

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

Basato sulla risposta di abe32,

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

n_bits avrà 32 o 64 bit.

Per 32 bit restituirà 32 e per 64 bit restituirà 64

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

L'architettura della piattaforma non è affidabile. Invece noi:

$ 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() è problematico (e costoso).

Comodamente verificare sys.maxsize > 2**32dal Py2.6.

Questo è un test affidabile per l'attuale (default) dimensione del puntatore e compatibile almeno dal Py2.3: struct.calcsize('P') == 8. Inoltre: ctypes.sizeof(ctypes.c_void_p) == 8.

Note: Possono esserci build con l'opzione gcc -mx32o giù di lì, che sono applicazioni di architettura a 64 bit, ma usano i puntatori a 32 bit come impostazione predefinita (risparmio di memoria e velocità). 'sys.maxsize = ssize_t' potrebbe non rappresentare rigorosamente la dimensione del puntatore C (di solito è 2**31 - 1comunque). E c'erano / ci sono sistemi che hanno dimensioni di puntatore diverse per codice e dati e deve essere chiarito qual è esattamente lo scopo di discernere "modalità a 32 bit o 64 bit?"