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
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.
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:
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)
Je suppose que vous devriez regarder dans os.environ['PROGRAMFILES']
pour le dossier des fichiers du programme.
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.
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
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.
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.
Après cette documentation , essayez ce code:
is_64bits = sys.maxsize > 2**32
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:
import platform
platform.architecture()[0]
Il renverra «32 bits» ou «64 bits» selon l'architecture du système.
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 :)
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())
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?
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.
import struct
def is64Windows():
return struct.calcsize('P') * 8 == 64
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)
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
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")