it-swarm.com.de

Erkennen von 64-Bit-Betriebssystemen (Windows) in Python

Weiß jemand, wie ich gehen würde, um herauszufinden, welche Bitversion Windows unter Python ist. Ich muss das wissen, um den richtigen Ordner für Programmdateien zu verwenden.

Danke vielmals

35
williamtroup

platform module - Zugriff auf die Identifizierungsdaten der zugrunde liegenden Plattform

>>> import platform
>>> platform.architecture()
('32bit', 'WindowsPE')

Unter 64-Bit-Windows gibt 32-Bit-Python Folgendes zurück:

('32bit', 'WindowsPE')

Und das bedeutet, dass obwohl diese Antwort akzeptiert wurde, falsch ist. Bitte sehen Sie sich einige der folgenden Antworten an, um Optionen zu erhalten, die für verschiedene Situationen geeignet sind.

20
Joe Koberg

Ich denke, die beste Lösung für dieses Problem wurde von Mark Ribau veröffentlicht.

Die beste Antwort auf die Frage für Python 2.7 und neuer lautet:

def is_os_64bit():
    return platform.machine().endswith('64')

Unter Windows verwendet die plattformübergreifende Funktion platform.machine() intern die in Matthew Scoutens Antwort verwendeten Umgebungsvariablen.

Ich habe folgende Werte gefunden:

  • WinXP-32: x86
  • Vista-32: x86
  • Win7-64: AMD64
  • Debian-32: i686
  • Debian-64: x86_64

Für Python 2.6 und älter:

def is_windows_64bit():
    if 'PROCESSOR_ARCHITEW6432' in os.environ:
        return True
    return os.environ['PROCESSOR_ARCHITECTURE'].endswith('64')

Um die Version des Python-Interpreter-Bits zu finden, verwende ich:

def is_python_64bit():
    return (struct.calcsize("P") == 8)
42
phobie

Ich denke, Sie sollten in os.environ['PROGRAMFILES'] nach dem Ordner der Programmdateien suchen.

39
Jochen Ritzel

Kam hier auf der Suche nach dem richtigen Erkennen, ob auf 64-Bit-Fenstern ausgeführt wird, und kompiliert alles oben genannte in etwas prägnanteres. 

Nachfolgend finden Sie eine Funktion zum Testen, ob unter 64-Bit-Fenstern ausgeführt wird, eine Funktion zum Abrufen des 32-Bit-Programmordners und eine Funktion zum Abrufen des 64-Bit-Programmdateiordners. unabhängig davon, ob 32-Bit- oder 64-Bit-Python ausgeführt wird. Wenn 32-Bit-Python ausgeführt wird, werden die meisten Dinge als 32-Bit angezeigt, wenn sie auf 64-Bit ausgeführt werden, sogar auf os.environ['PROGRAMFILES']

import os

def Is64Windows():
    return 'PROGRAMFILES(X86)' in os.environ

def GetProgramFiles32():
    if Is64Windows():
        return os.environ['PROGRAMFILES(X86)']
    else:
        return os.environ['PROGRAMFILES']

def GetProgramFiles64():
    if Is64Windows():
        return os.environ['PROGRAMW6432']
    else:
        return None

Hinweis : Ja, das ist ein bisschen hackish. Alle anderen Methoden, die "funktionieren sollten", funktionieren nicht, wenn 32-Bit-Python unter 64-Bit-Windows ausgeführt wird (zumindest für die verschiedenen 2.x- und 3.x-Versionen, die ich ausprobiert habe).

Bearbeitungen:
2011-09-07 - Es wurde ein Hinweis hinzugefügt, warum nur diese Hackish-Methode ordnungsgemäß funktioniert.

29
Mark Ribau
def os_platform():
    true_platform = os.environ['PROCESSOR_ARCHITECTURE']
    try:
            true_platform = os.environ["PROCESSOR_ARCHITEW6432"]
    except KeyError:
            pass
            #true_platform not assigned to if this does not exist
    return true_platform

http://blogs.msdn.com/b/david.wang/archive/2006/03/26/howto-detect-prozess-bitness.aspx

8
Matthew Scouten

Viele dieser vorgeschlagenen Lösungen, wie etwa platform.architecture (), schlagen fehl, da ihre Ergebnisse davon abhängen, ob Sie Python mit 32 Bit oder 64 Bit verwenden.

Die einzige zuverlässige Methode, die ich gefunden habe, ist die Überprüfung auf die Existenz von os.environ ['PROGRAMFILES (X86)'].

6
gauss256

Sie sollten Umgebungsvariablen verwenden, um darauf zuzugreifen. Das Verzeichnis der Programmdateien wird unter x86 Windows in der Umgebungsvariablen PROGRAMFILES gespeichert. Das Verzeichnis der 32-Bit-Programmdateien ist in der Umgebungsvariablen PROGRAMFILES(X86) gespeichert. Auf diese Verzeichnisse kann mit os.environ('PROGRAMFILES') zugegriffen werden.

Verwenden Sie sys.getwindowsversion() oder die Existenz von PROGRAMFILES(X86) (if 'PROGRAMFILES(X86)' in os.environ), um festzustellen, welche Windows-Version Sie verwenden.

3
Mike Graham

Nach dieser Dokumentation versuchen Sie diesen Code:

is_64bits = sys.maxsize > 2**32
2
Waynn Lue

Ich habe gerade einen anderen Weg gefunden, dies zu tun, was in manchen Situationen nützlich sein kann.

import subprocess
import os

def os_Arch():
    os_Arch = '32-bit'
    if os.name == 'nt':
        output = subprocess.check_output(['wmic', 'os', 'get', 'OSArchitecture'])
        os_Arch = output.split()[1]
    else:
        output = subprocess.check_output(['uname', '-m'])
        if 'x86_64' in output:
            os_Arch = '64-bit'
        else:
            os_Arch = '32-bit'
    return os_Arch

print 'os_Arch=%s' % os_Arch()

Ich habe diesen Code in den folgenden Umgebungen getestet:

  • Ubuntu 16.04 + Python 2.7.12
  • Mac OS Sierra + Python 2.7.11
  • Windows 7 Pro 32-Bit + Python 2.7.5 (32-Bit)
  • Windows 10 Home 64-Bit + Python 2.7.13 (32-Bit)
2
Jake W
import platform

platform.architecture()[0]

Je nach Systemarchitektur wird '32bit' oder '64bit' zurückgegeben. 

2
shahidullah

Nur um diesen alten Thread zu aktualisieren - es sieht so aus, als würde das Plattformmodul jetzt die korrekte Architektur melden (zumindest in Python 2.7.8):

c:\python27\python.exe -c "import platform; print platform.architecture(), platform.python_version()"
('32bit', 'WindowsPE') 2.7.6

c:\home\python278-x64\python.exe -c "import platform; print platform.architecture(), platform.python_version()"
('64bit', 'WindowsPE') 2.7.8

(Entschuldigung, ich habe nicht die Sprecherin, um die erste Antwort zu kommentieren, die immer noch behauptet, falsch zu sein :)

1
Hagrid67

Ich bin mir bewusst, dass diese Methode in den Kommentaren der Frage bereits verwendet wurde .. Dies ist die Methode, die das Framework .net verwendet :

import ctypes

def is64_bit_os():
    """ Returns wethever system is a 64bit operating system"""
    is64bit = ctypes.c_bool()
    handle = ctypes.windll.kernel32.GetCurrentProcess() # should be -1, because the current process is currently defined as (HANDLE) -1
    success = ctypes.windll.kernel32.IsWow64Process(handle, ctypes.byref(is64bit)) #should return 1
    return (success and is64bit).value
print(is64_bit_os())
1

Die Betreffzeilen fragen nach dem Erkennen von 64- oder 32-Bit-Betriebssystemen, während der Körper über die Ermittlung des Speicherorts von ProgramFiles spricht. Letzteres hat hier ein paar brauchbare Antworten. Ich möchte eine andere Lösung hinzufügen, die allgemein für StartMenu, Desktop usw. sowie ProgramFiles geeignet ist: Wie bekomme ich den Pfad zum Programmverzeichnis des Startmenüs?

1
matt wilkie

Wenn Sie etwas über das Windows-System herausfinden möchten, befindet sich dieses normalerweise in der Registrierung. Laut MS-Dokumentation sollten Sie ( http://support.Microsoft.com/kb/556009 ) diesen Schlüsselwert anzeigen :

HKLM\HARDWARE\DESCRIPTION\System\CentralProcessor\0

und wenn es ist:

0x00000020 (32 dezimal)

Es ist eine 32-Bit-Maschine.

import struct

def is64Windows():
    return struct.calcsize('P') * 8 == 64
0
Vlad Bezden

Dies funktioniert für mich in den von mir verwendeten Python-Versionen: 2.7 und 2.5.4

    import win32com.client
    import _winreg

    Shell = win32com.client.Dispatch('WScript.Shell')
    proc_Arch = Shell.ExpandEnvironmentStrings(r'%PROCESSOR_ARCHITECTURE%').lower()

    if proc_Arch == 'x86':
        print "32 bit"
    Elif proc_Arch == 'AMD64':
        print "64 bit"
    else:
        raise Exception("Unhandled Arch: %s" % proc_Arch)
0
BooneStars
 import _winreg
 def get_registry_value(key, subkey, value):
   key = getattr(_winreg, key)
   handle = _winreg.OpenKey(key, subkey )
   (value, type) = _winreg.QueryValueEx(handle, value)
   return value

 windowsbit=cputype = get_registry_value(
        "HKEY_LOCAL_MACHINE",
        "SYSTEM\\CurrentControlSet\Control\\Session Manager\\Environment",
        "PROCESSOR_ARCHITECTURE")
 print windowsbit

führen Sie einfach diesen Code aus 

wenn Sie an einer 64-Bit-Windows-Maschine arbeiten, wird AMD64 gedruckt 

wenn Sie mit 32 Bit arbeiten, wird AMD32 gedruckt

ich hoffe, dieser Code kann dazu beitragen, dieses Problem vollständig zu lösen 

0
rishabhr0y

64-Bit-Versionen von Windows verwenden so genannte Registrierungsumleitungs- und -reflexionsschlüssel. Es gibt eine Kompatibilitätsschicht namens WoW64, die die Kompatibilität von 32-Bit-Anwendungen ermöglicht. Ab Windows 7 und Windows Server 2008 R2 werden WoW64-Registrierungsschlüssel nicht mehr angezeigt, sondern freigegeben. Sie können hier lesen:

registry-Reflection: msdn.Microsoft.com/de-de/library/aa384235(v=vs.85).aspx

betroffene Schlüssel: msdn.Microsoft.com/de-de/library/aa384253(v=vs.85).aspx

wikipedia: de.wikipedia.org/wiki/WoW64

Sie müssen nur das Vorhandensein dieser Schlüssel erkennen. Sie können _winreg dafür verwenden. Verwenden Sie try: und versuchen Sie den Schlüssel zu öffnen. Beispiel:

try:
aReg = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,"SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Run")
0
idenoq