Como determino se meu shell python está sendo executado no modo 32 bits ou 64 bits no OS X?

Eu preciso de uma maneira de dizer em que modo o shell está dentro do shell.

Eu tentei olhar para o módulo da plataforma , mas parece apenas falar sobre "sobre a arquitetura de bits e o formato de ligação usado para o executável": o binário é compilado como 64 bits (estou executando o OS X 10.6), portanto parece sempre relatar 64 bits, embora eu esteja usando os métodos descritos aqui para forçar o modo de 32 bits).

Uma maneira é olhar sys.maxsizecomo documentado aqui :

$ 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.maxsizefoi introduzido no Python 2.6. Se você precisar de um teste para sistemas mais antigos, esse teste um pouco mais complicado deverá funcionar em todas as versões do 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

BTW, você pode ser tentado a usar platform.architecture()para isso. Infelizmente, os resultados nem sempre são confiáveis, particularmente no caso de binários universais 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

Ao iniciar o interpretador Python no terminal / linha de comando, você também pode ver uma linha como:

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

Onde [MSC v.1500 64 bit (AMD64)]significa Python de 64 bits. Funciona para minha configuração específica.

Basicamente, uma variante da resposta de Matthew Marshall (com struct da biblioteca std.library):

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

Tente usar ctypes para obter o tamanho de um ponteiro nulo:

import ctypes
print ctypes.sizeof(ctypes.c_voidp)

Serão 4 para 32 bits ou 8 para 64 bits.

Console python aberto:

import platform
platform.architecture()[0]

deve exibir '64 bits' ou '32 bits' de acordo com a sua plataforma.

Como alternativa ( no caso de binários do OS X ):

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

Para uma solução não programática, procure no Monitor de Atividade. Ele lista a arquitetura dos processos de 64 bits como "Intel (64 bits)".

No meu sistema Centos Linux, fiz o seguinte:

1) Iniciei o interpretador Python (estou usando o 2.6.6)
2) Execute o seguinte código:

import platform
print(platform.architecture())

e isso me deu

(64bit, 'ELF')

platform.architecture() as notas dizem:

Nota: No Mac OS X (e talvez em outras plataformas), os arquivos executáveis ​​podem ser arquivos universais que contêm várias arquiteturas.

Para obter o "64-bitness" do intérprete atual, é mais confiável consultar o atributo sys.maxsize:

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

Agrupando tudo ...

Considerando que:

• A pergunta é feita para o OSX (eu tenho uma VM antiga (e quebrada) com uma versão antiga do Python )
• Meu principal env é Win
• Eu só tenho a versão de 32 bits instalada no Win (e criei uma versão "aleijada" no Lnx )

Vou exemplificar nas três plataformas, usando Python 3 e Python 2 .

1. Marque [Python 3.Docs]: sys. valor maxsize - compare com 0x100000000( 2 ** 32): maior 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)

   • Ganhe 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. Use [Python 3.Docs]: struct. calcsize ( formato ) para determinar o tamanho do objeto produzido pelo formato (ponteiro). Em outras palavras, determina o tamanho do ponteiro ( 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

   • Ganhe 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. Use [Python 3.Docs]: ctypes - Uma biblioteca de funções estrangeira para Python . Também se resume a determinar o tamanho de um ponteiro ( sizeof(void*)). Como uma observação, ctypes usa # 2. (não necessariamente para esta tarefa) via "$ {PYTHON_SRC_DIR} / Lib / ctypes / __ init__.py" (na linha 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

   • Ganhe 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. arquitetura ( executável = sys.executable, bits = '', ligação = '' ) !!! NÃO é confiável no OSX !!! devido ao formato executável em arco múltiplo (ou .dylib ) (em alguns casos, usa # 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')

   • Ganhe 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. Solução alternativa aleijada ( ganho ) - invoque um comando externo ( [man7]: FILE (1) ) via [Python 3.Docs]: os. sistema ( comando ) . As limitações do # 4.aplicar (às vezes pode até não funcionar):
   • 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

   • Ganhe 10 x64 :
     • utilitário de arquivo não está presente, existem outras ferramentas de ^terceiros que podem ser usadas, mas não vou insistir nelas

Vitória específica:

6. Verifique os envios (por exemplo, % PROCESSOR_ARCHITECTURE% (ou outros)) via [Python 3.Docs]: os. meio ambiente :
   • Ganhe 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. versão (também apresentada na 1 ^r linha quando se inicia o intérprete)
   • Marque # 1.

struct.calcsize("P")retorna o tamanho dos bytes necessários para armazenar um único ponteiro. Em um sistema de 32 bits, ele retornaria 4 bytes. Em um sistema de 64 bits, ele retornaria 8 bytes.

Portanto, o seguinte retornaria 32se você estiver executando o python de 32 bits e 64se estiver executando o python de 64 bits:

Python 2

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

Python 3

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

Faça um python -VVna linha de comando. Deve retornar a versão.

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

depois de bater python no cmd

import sys
print(sys.version)

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

Com base na resposta de abe32,

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

Os n_bits terão 32 ou 64 bits.

Para 32 bits retornará 32 e para 64 bits retornará 64

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

Arquitetura de plataforma não é a maneira confiável. Em vez disso nós:

$ 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() é problemático (e caro).

Teste convenientemente sys.maxsize > 2**32desde o Py2.6.

Este é um teste fiável para o (padrão) tamanho real ponteiro e compatível, pelo menos, uma vez que Py2.3: struct.calcsize('P') == 8. Também: ctypes.sizeof(ctypes.c_void_p) == 8.

Notas: Pode haver compilações com a opção gcc -mx32ou mais, que são aplicativos de arquitetura de 64 bits, mas usam ponteiros de 32 bits como padrão (economizando memória e velocidade). 'sys.maxsize = ssize_t' pode não representar estritamente o tamanho do ponteiro C (geralmente é 2**31 - 1assim mesmo). E havia / existem sistemas que têm tamanhos de ponteiro diferentes para código e dados e precisa ser esclarecido qual é exatamente o objetivo de discernir o "modo 32 bits ou 64 bits"?