Wie stelle ich fest, ob meine Python-Shell unter OS X im 32-Bit- oder 64-Bit-Modus ausgeführt wird?

Ich brauche eine Möglichkeit, um zu erkennen, in welchem ​​Modus sich die Shell innerhalb der Shell befindet.

Ich habe versucht, mir das Plattformmodul anzusehen, aber es scheint Ihnen nur "über die Bitarchitektur und das für die ausführbare Datei verwendete Verknüpfungsformat" zu erzählen: Die Binärdatei ist jedoch als 64-Bit kompiliert (ich verwende OS X 10.6) Es scheint immer 64-Bit zu melden, obwohl ich die hier beschriebenen Methoden verwende , um den 32-Bit-Modus zu erzwingen.

Eine Möglichkeit besteht darin, sys.maxsizewie hier dokumentiert zu betrachten :

$ 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.maxsizewurde in Python 2.6 eingeführt. Wenn Sie einen Test für ältere Systeme benötigen, sollte dieser etwas kompliziertere Test auf allen Python 2- und 3-Versionen funktionieren:

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

Übrigens könnten Sie versucht sein, platform.architecture()dies zu verwenden. Leider sind die Ergebnisse nicht immer zuverlässig, insbesondere bei universellen OS X-Binärdateien .

$ 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

Wenn Sie den Python-Interpreter in der Terminal- / Befehlszeile starten, sehen Sie möglicherweise auch eine Zeile wie:

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

Wo [MSC v.1500 64 bit (AMD64)]bedeutet 64-Bit-Python. Funktioniert für mein spezielles Setup.

Grundsätzlich eine Variante von Matthew Marshalls Antwort (mit Struktur aus der std.library):

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

Versuchen Sie, mit ctypes die Größe eines leeren Zeigers zu ermitteln:

import ctypes
print ctypes.sizeof(ctypes.c_voidp)

Es wird 4 für 32 Bit oder 8 für 64 Bit sein.

Öffnen Sie die Python-Konsole:

import platform
platform.architecture()[0]

Je nach Plattform sollte "64bit" oder "32bit" angezeigt werden.

Alternativ ( bei OS X-Binärdateien ):

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

Eine nicht programmatische Lösung finden Sie im Aktivitätsmonitor. Die Architektur von 64-Bit-Prozessen wird als "Intel (64-Bit)" aufgeführt.

Auf meinem Centos Linux-System habe ich Folgendes getan:

1) Den Python-Interpreter gestartet (ich verwende 2.6.6)
2) Den folgenden Code ausgeführt:

import platform
print(platform.architecture())

und es gab mir

(64bit, 'ELF')

platform.architecture() Notizen sagen:

Hinweis: Unter Mac OS X (und möglicherweise auf anderen Plattformen) können ausführbare Dateien universelle Dateien sein, die mehrere Architekturen enthalten.

Um die 64-Bit-Qualität des aktuellen Interpreters zu ermitteln, ist es zuverlässiger, das Attribut sys.maxsize abzufragen:

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

Alles gruppieren ...

Bedenkt, dass:

• Die Frage wird für OSX gestellt (ich habe eine alte (und geknackte) VM mit einer alten Python- Version)
• Meine Hauptumgebung ist Win
• Ich habe nur die 32-Bit- Version auf Win installiert (und ich habe eine "verkrüppelte" Version auf Lnx erstellt )

Ich werde auf allen 3 Plattformen mit Python 3 und Python 2 veranschaulichen .

1. Überprüfen Sie [Python 3.Docs]: sys. maxsize value - vergleiche es mit 0x100000000( 2 ** 32): größer für 64bit , kleiner für 32bit :
   • 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)

   • Gewinnen Sie 10 x 64 :
     • 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. Verwenden Sie [Python 3.Docs]: struct. Kalkulation ( Format ) , um die vom (Zeiger-) Format erzeugte Objektgröße zu bestimmen. Mit anderen Worten, bestimmt die Zeigergröße ( 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

   • Gewinnen Sie 10 x 64 :
     • 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. Verwenden Sie [Python 3.Docs]: ctypes - Eine Fremdfunktionsbibliothek für Python . Es läuft auch darauf hinaus, die Größe eines Zeigers ( sizeof(void*)) zu bestimmen . Als Hinweis verwendet ctypes # 2. (nicht unbedingt für diese Aufgabe) über "$ {PYTHON_SRC_DIR} / Lib / ctypes / __ init__.py" (um Zeile 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

   • Gewinnen Sie 10 x 64 :
     • 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]: Plattform. Architektur ( ausführbar = sys.executable, bits = '', linkage = '' ) !!! NICHT zuverlässig unter OSX !!! aufgrund des ausführbaren Multi-Arch- Formats (oder .dylib- Formats) (verwendet in einigen Fällen # 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')

   • Gewinnen Sie 10 x 64 :
     • 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 ) - Rufen Sie einen externen Befehl ( [man7]: FILE (1) ) über [Python 3.Docs]: os auf. System ( Befehl ) . Die Einschränkungen von # 4.anwenden (manchmal funktioniert es vielleicht gar nicht):
   • 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

   • Gewinnen Sie 10 x 64 :
     • Datei - Dienstprogramm nicht vorhanden ist , gibt es andere 3 ^rd Party - Tools , die verwendet werden können, aber ich werde nicht auf sie darauf bestehen ,

Gewinnen Sie spezifisch:

6. Überprüfen Sie env vars (z. B. % PROCESSOR_ARCHITECTURE% (oder andere)) über [Python 3.Docs]: os. Umwelt :
   • Gewinnen Sie 10 x 64 :
     • 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 (auch angezeigt in der 1 ^st Linie , wenn die Interpreter ausgang)
   • Überprüfen Sie # 1.

struct.calcsize("P")Gibt die Größe der Bytes zurück, die zum Speichern eines einzelnen Zeigers erforderlich sind. Auf einem 32-Bit-System würde es 4 Bytes zurückgeben. Auf einem 64-Bit-System würde es 8 Bytes zurückgeben.

Das Folgende würde also zurückkehren, 32wenn Sie 32-Bit-Python ausführen und 64wenn Sie 64-Bit-Python ausführen:

Python 2

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

Python 3

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

Machen Sie eine python -VVin der Kommandozeile. Es sollte die Version zurückgeben.

import sys
print(sys.version)

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

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

nach dem schlagen von python in cmd

Basierend auf der Antwort von abe32,

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

n_bits haben 32 oder 64 Bit.

Für 32 Bit wird 32 und für 64 Bit 64 zurückgegeben

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

Plattformarchitektur ist nicht der zuverlässige Weg. Stattdessen wir:

$ 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() ist problematisch (und teuer).

Bequem testen für sys.maxsize > 2**32seit Py2.6.

Dies ist ein zuverlässiger Test für die tatsächliche (Standard-) Zeigergröße und mindestens seit Py2.3 kompatibel : struct.calcsize('P') == 8. Auch : ctypes.sizeof(ctypes.c_void_p) == 8.

Hinweise: Es kann Builds mit der Option gcc -mx32oder so geben, bei denen es sich um 64-Bit-Architekturanwendungen handelt, die jedoch standardmäßig 32-Bit-Zeiger verwenden (Speicher und Geschwindigkeit sparen). 'sys.maxsize = ssize_t' repräsentiert möglicherweise nicht genau die C-Zeigergröße (normalerweise 2**31 - 1sowieso). Und es gab / gibt Systeme mit unterschiedlichen Zeigergrößen für Code und Daten, und es muss geklärt werden, was genau der Zweck ist, den "32-Bit- oder 64-Bit-Modus" zu erkennen.