Comment déterminer si mon shell python s'exécute en mode 32 bits ou 64 bits sur OS X?

J'ai besoin d'un moyen de dire dans quel mode se trouve le shell depuis l'intérieur du shell.

J'ai essayé de regarder le module de plate - forme, mais il ne semble que vous parler "de l'architecture de bits et du format de liaison utilisé pour l'exécutable": le binaire est cependant compilé en 64 bits (je fonctionne sur OS X 10.6) donc il semble toujours signaler 64 bits même si j'utilise les méthodes décrites ici pour forcer le mode 32 bits).

Une façon consiste à regarder sys.maxsizecomme documenté ici :

$ 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.maxsizea été introduit dans Python 2.6. Si vous avez besoin d'un test pour des systèmes plus anciens, ce test légèrement plus compliqué devrait fonctionner sur toutes les versions de Python 2 et 3:

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

BTW, vous pourriez être tenté d'utiliser platform.architecture()pour cela. Malheureusement, ses résultats ne sont pas toujours fiables, en particulier dans le cas d'OS X binaires universels .

$ 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

Lorsque vous démarrez l'interpréteur Python dans le terminal / la ligne de commande, vous pouvez également voir une ligne comme:

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

Où [MSC v.1500 64 bit (AMD64)]signifie Python 64 bits. Fonctionne pour ma configuration particulière.

Fondamentalement, une variante de la réponse de Matthew Marshall (avec struct à partir de la bibliothèque std):

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

Essayez d'utiliser des ctypes pour obtenir la taille d'un pointeur vide:

import ctypes
print ctypes.sizeof(ctypes.c_voidp)

Ce sera 4 pour 32 bits ou 8 pour 64 bits.

Ouvrez la console python:

import platform
platform.architecture()[0]

il devrait afficher le «64 bits» ou le «32 bits» en fonction de votre plate-forme.

Alternativement ( en cas de binaires OS X ):

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

Pour une solution non programmatique, recherchez dans le moniteur d'activité. Il répertorie l'architecture des processus 64 bits comme «Intel (64 bits)».

Sur mon système Centos Linux, j'ai fait ce qui suit:

1) Lancement de l'interpréteur Python (j'utilise 2.6.6)
2) Exécution du code suivant:

import platform
print(platform.architecture())

et ça m'a donné

(64bit, 'ELF')

platform.architecture() les notes disent:

Remarque: Sous Mac OS X (et peut-être sur d'autres plates-formes), les fichiers exécutables peuvent être des fichiers universels contenant plusieurs architectures.

Pour obtenir les «64 bits» de l'interpréteur actuel, il est plus fiable d'interroger l'attribut sys.maxsize:

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

Tout regrouper ...

Étant donné que:

• La question est posée pour OSX (j'ai une ancienne machine virtuelle (et fissurée) avec une ancienne version Python )
• Mon principal env est Win
• Je n'ai que la version 32 bits installée sur Win (et j'en ai construit une "paralysée" sur Lnx )

Je vais illustrer sur les 3 plates-formes, en utilisant Python 3 et Python 2 .

1. Vérifiez [Python 3.Docs]: sys. valeur maxsize - comparez-la à 0x100000000( 2 ** 32): plus grande pour 64 bits , plus petite pour 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)

   • Gagnez 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. Utilisez [Python 3.Docs]: struct. calcsize ( format ) pour déterminer la taille de l'objet produite par le format (pointeur). En d'autres termes, détermine la taille du pointeur ( 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

   • Gagnez 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. Utilisez [Python 3.Docs]: ctypes - Une bibliothèque de fonctions étrangères pour Python . Cela revient également à déterminer la taille d'un pointeur ( sizeof(void*)). Remarque: ctypes utilise # 2. (pas nécessairement pour cette tâche) via "$ {PYTHON_SRC_DIR} / Lib / ctypes / __ init__.py" (autour de la ligne # 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

   • Gagnez 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]: plateforme. architecture ( exécutable = sys.executable, bits = '', linkage = '' ) !!! PAS fiable sur OSX !!! en raison du format exécutable multi-arch (ou .dylib ) (dans certains cas, utilise # 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')

   • Gagnez 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. Lame workaround ( gainarie ) - invoquez une commande externe ( [man7]: FILE (1) ) via [Python 3.Docs]: os. système ( commande ) . Les limites de # 4. appliquer (parfois cela peut même ne pas fonctionner):
   • 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

   • Gagnez 10 x64 :
     • l' utilitaire de fichier n'est pas présent, il existe d'autres outils de ^tierce partie qui peuvent être utilisés, mais je ne vais pas insister sur eux

Gagnez spécifique:

6. Vérifiez les vars env (par exemple % PROCESSOR_ARCHITECTURE% (ou autres)) via [Python 3.Docs]: os. environ :
   • Gagnez 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. version (également affichée sur la ^1ère ligne lors du démarrage de l'interpréteur)
   • Vérifiez # 1.

struct.calcsize("P")renvoie la taille des octets nécessaires pour stocker un seul pointeur. Sur un système 32 bits, il retournerait 4 octets. Sur un système 64 bits, il retournerait 8 octets.

Donc, ce qui suit retournerait 32si vous exécutez du python 32 bits et 64si vous exécutez du python 64 bits:

Python 2

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

Python 3

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

Faites un python -VVdans la ligne de commande. Il devrait renvoyer la version.

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

après avoir frappé python en cmd

import sys
print(sys.version)

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

Basé sur la réponse d'abe32,

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

n_bits aura 32 ou 64 bits.

Pour 32 bits, il renverra 32 et pour 64 bits, il renverra 64

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

L'architecture de plate-forme n'est pas le moyen fiable. Au lieu de cela nous:

$ 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() est problématique (et cher).

Idéalement pour tester sys.maxsize > 2**32depuis Py2.6.

Ceci est un test fiable pour la taille du pointeur réelle (par défaut) et compatible au moins depuis Py2.3: struct.calcsize('P') == 8. En outre: ctypes.sizeof(ctypes.c_void_p) == 8.

Notes: Il peut y avoir des builds avec l'option gcc -mx32, qui sont des applications d'architecture 64 bits, mais utilisent des pointeurs 32 bits par défaut (économie de mémoire et de vitesse). 'sys.maxsize = ssize_t' peut ne pas représenter strictement la taille du pointeur C (c'est généralement de 2**31 - 1toute façon). Et il y avait / existe des systèmes qui ont des tailles de pointeur différentes pour le code et les données et il faut clarifier quel est exactement le but de discerner le "mode 32 bits ou 64 bits?"