web-dev-qa-db-fra.com

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

J'ai besoin d'un moyen de savoir dans quel mode se trouve Shell à partir de Shell.

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

pythonmacos
368
jkp

MISE À JOUR: Une solution consiste à consulter sys.maxsize comme 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.maxsize a été introduit dans Python 2.6. Si vous avez besoin d'un test pour les systèmes plus anciens, ce test légèrement plus compliqué devrait fonctionner avec 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 des binaires universels 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
368
Ned Deily

Lorsque vous démarrez l’interprète Python dans le terminal/la ligne de commande, vous pouvez également voir une ligne du type:

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.

230
Dustin

En gros, une variante de la réponse de Matthew Marshall (avec struct de std.library):

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

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.

71
Matthew Marshall

Ouvrez la console python: 

import platform
platform.architecture()[0]

il devrait afficher "64 bits" ou "32 bits" en fonction de votre plate-forme.

Alternativement ( dans le cas de fichiers binaires OS X ):

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

Sur mon système Centos Linux, j'ai procédé comme suit:

1) Démarrage de l'interpréteur Python (j'utilise la version 2.6.6)
2) A couru le code suivant:

import platform
print(platform.architecture())

et ça m'a donné

(64bit, 'ELF')
17
rekabbnad

Pour une solution non programmatique, consultez le moniteur d'activité. Il répertorie l'architecture des processus 64 bits en tant qu '"Intel (64 bits)".

15
Peter Hosey

Tout regrouper ...

Étant donné que:

  • La question est posée pour OSX (j'ai un ancien (et craqué) VM avec un ancien version Python
  • Mon env principal est Win
  • J'ai seulement la version 32bit installée sur Win (et j'ai construit une version "estropiée" sur Lnx )

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

  1. Vérifier [Python 3.Docs]: sys. taille maximale valeur - comparez-la à 0x100000000 (2 ** 32): plus grand pour 64 bits , plus petit 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)
    • Ubtu 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)
    • Win 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)


  1. 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
>>> 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
    • Win 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


  1. Use [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*)). En remarque, ctypes utilise # 2. (pas nécessairement pour cette tâche) via "$ {PYTHON_SRC_DIR}/Lib/ctypes/__ init __. py" (autour de ) # 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
    • Win 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


  1. [Python 3.Docs]: plate-forme. architecture ( exécutable = sys.executable, bits = '' , linkage = '' ) !!! NON fiable sur OSX !!! en raison d'un exécutable multi-arch (ou . Dylib ) format (utilise dans certains cas # 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')
    • Win 10 x64 :
      • Python 3.5.4 x64 : 
        >>> import platform
>>> platform.architecture()
('64bit', 'WindowsPE')
      • Python 3.6.2 x86 : 
        >>> import platform
>>> platform.architecture()
('32bit', 'WindowsPE')


  1. Lame solution de contournement ( gainarie ) - invoquer une commande externe ( [man7]: FILE (1) ) via [Python 3.Docs] : os. système ( commande ) . Les limitations de # 4. s’appliquent (il se peut même que cela ne fonctionne pas):
    • 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
    • Ubtu 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
    • Win 10 x64 :
      • utilitaire de fichier non présent, il en existe 3 autresrd Des outils de fête qui peuvent être utilisés, mais je ne vais pas insister dessus


Win spécifique:

  1. Vérifiez env vars (par exemple % PROCESSOR_ARCHITECTURE% (ou autres)) via [Python 3.Docs]: os. environ :
    • Win 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'


  1. [Python 3.Docs]: sys. version (aussi affiché dans le 1st ligne au démarrage de l’interprète)
    • Vérifier # 1.
9
CristiFati

platform.architecture() notes disent:

Remarque: sur 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 le "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
9
Shannon Mann

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

Ainsi, les éléments suivants renverraient _32_ si vous exécutez python 32 _ et _64_ si vous exécutez un python 64 bits:

Python 2

_import struct;print struct.calcsize("P") * 8
_

Python

_import struct;print(struct.calcsize("P") * 8)
_
7
kimbaudi
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 dans cmd

3
Nikhil
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)]

3
betontalpfa

L'architecture de plate-forme n'est pas le moyen fiable. Au lieu de 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)
1
Prakhar Agarwal