web-dev-qa-db-fra.com

Détecter le système d'exploitation 64 bits (Windows) en Python

Est-ce que quelqu'un sait comment j'irais détecter quelle version de bit Windows est sous Python. J'ai besoin de savoir cela pour utiliser le bon dossier pour Program Files.

Merci beaucoup

pythonwindows64bit
35
williamtroup

platform module - Accès aux données d'identification de la plateforme sous-jacente

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

Sous Windows 64 bits, Python 32 bits renvoie:

('32bit', 'WindowsPE')

Et cela signifie que cette réponse, même si elle a été acceptée, est incorrecte. Veuillez consulter certaines des réponses ci-dessous pour connaître les options qui peuvent fonctionner dans différentes situations.

20
Joe Koberg

Je pense que la meilleure solution au problème a été publiée par Mark Ribau.

La meilleure réponse à la question pour Python 2.7 et plus récent est:

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

Sur Windows, la fonction multi-plateforme platform.machine() utilise en interne les variables d'environnement utilisées dans la réponse Matthew Scoutens.

J'ai trouvé les valeurs suivantes:

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

Pour Python 2.6 et les versions antérieures:

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

Pour trouver la version de bit d'interprétation Python que j'utilise:

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

Je suppose que vous devriez regarder dans os.environ['PROGRAMFILES'] pour le dossier des fichiers du programme.

39
Jochen Ritzel

Nous sommes venus ici pour détecter correctement si nous travaillons sur des fenêtres 64 bits, en compilant tout ce qui précède en quelque chose de plus concis. 

Vous trouverez ci-dessous une fonction permettant de tester si vous utilisez Windows 64 bits, une fonction permettant d’obtenir le dossier 32 bits Program Files et une fonction permettant d’obtenir le dossier 64 bits Program Files; tous indépendamment de l'exécution de python 32 bits ou 64 bits. Lors de l'exécution de python 32 bits, la plupart des choses rapportent comme si 32 bits lors de l'exécution sur 64 bits, même 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

Note : Oui, c'est un peu hackish. Toutes les autres méthodes qui "devraient fonctionner" ne fonctionnent pas lors de l'exécution de Python 32 bits sous Windows 64 bits (au moins pour les différentes versions 2.x et 3.x que j'ai essayées).

Modifications:
2011-09-07 - Ajout d'une note expliquant pourquoi seule cette méthode piratée fonctionne correctement.

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-process-bitness.aspx

8
Matthew Scouten

Un grand nombre des solutions proposées, telles que platform.architecture (), échouent car leurs résultats dépendent du fait que vous utilisiez Python 32 bits ou 64 bits.

La seule méthode fiable que j'ai trouvée consiste à vérifier l'existence de os.environ ['PROGRAMFILES (X86)'], qui est malheureusement bidon.

6
gauss256

Vous devriez utiliser des variables d'environnement pour y accéder. Le répertoire des fichiers de programme est stocké dans la variable d'environnement PROGRAMFILES sous x86 Windows, le répertoire des fichiers de programme 32 bits est stocké dans la variable d'environnement PROGRAMFILES(X86). Vous pouvez y accéder à l'aide de os.environ('PROGRAMFILES').

Utilisez sys.getwindowsversion() ou l'existence de PROGRAMFILES(X86) (if 'PROGRAMFILES(X86)' in os.environ) pour déterminer la version de Windows que vous utilisez.

3
Mike Graham

Après cette documentation , essayez ce code:

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

Je viens de trouver une autre façon de faire, ce qui peut être utile dans certaines situations.

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()

J'ai testé ce code dans les environnements suivants:

  • Ubuntu 16.04 + Python 2.7.12
  • Mac OS Sierra + Python 2.7.11
  • Windows 7 Pro 32 bits + Python 2.7.5 (32 bits)
  • Windows 10 Édition Familiale 64 bits + Python 2.7.13 (32 bits)
2
Jake W
import platform

platform.architecture()[0]

Il renverra «32 bits» ou «64 bits» selon l'architecture du système. 

2
shahidullah

Juste pour mettre à jour cet ancien thread - il semble que le module de la plate-forme indique maintenant l'architecture correcte (au moins, dans 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

(désolé je n'ai pas le représentant pour commenter la première réponse qui prétend toujours être fausse :)

1
Hagrid67

Je suis conscient que, dans les commentaires de la question, cette méthode a déjà été utilisée ... C'est la méthode utilisée par .net Framework :

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
Alexander Brüsch

Les lignes d'objet demandent comment détecter les systèmes d'exploitation 64 ou 32 bits, tandis que le corps parle de déterminer l'emplacement de ProgramFiles. Ce dernier a quelques réponses réalisables ici. Je voudrais ajouter une autre solution généralisée pour gérer StartMenu, Desktop, etc. ainsi que ProgramFiles: Comment obtenir le chemin du répertoire Programmes du menu Démarrer?

1
matt wilkie

Lorsque vous avez besoin de connaître le système Windows, il est généralement situé quelque part dans le registre. Selon la documentation de MS, vous devriez consulter ( http://support.Microsoft.com/kb/556009 ) cette valeur de clé :

HKLM\HARDWARE\DESCRIPTION\System\CentralProcessor\0

et si c'est:

0x00000020 (32 en décimal)

C'est une machine 32 bits.

1
World Python Developer
import struct

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

Cela fonctionne pour moi dans les versions Python que j'utilise: 2.7 et 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

il suffit de lancer ce code 

si vous travaillez sur une machine Windows 64 bits, cela imprimera AMD64 

ou si vous travaillez sur 32 bits, il imprimera AMD32

j'espère que ce code peut aider à résoudre complètement ce problème 

0
rishabhr0y

Les versions 64 bits de Windows utilisent quelque chose appelé redirection de registre et clés de réflexion. Il existe une couche de compatibilité appelée WoW64 qui permet la compatibilité des applications 32 bits. À partir de Windows 7 et Windows Server 2008 R2, les clés de registre WoW64 ne sont plus reflétées mais partagées. Vous pouvez lire à ce sujet ici:

registry-reflection: msdn.Microsoft.com/en-us/library/aa384235(v=vs.85).aspx

affectés-clés: msdn.Microsoft.com/en-us/library/aa384253(v=vs.85).aspx

wikipedia: en.wikipedia.org/wiki/WoW64

Tout ce que vous avez à faire est de détecter l’existence de ces clés. Vous pouvez utiliser _winreg pour cela. Utilisez try: et essayez d’ouvrir la clé, exemple:

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