Python:Sur quel système d'exploitation suis-je exécuté ?
https://stackoverflow.com/questions/1854
-
08-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Que dois-je vérifier pour savoir si je suis sous Windows ou Unix, etc. ?
La solution
>>> import os
>>> print os.name
posix
>>> import platform
>>> platform.system()
'Linux'
>>> platform.release()
'2.6.22-15-generic'
La sortie de platform.system() est comme suit:
- Linux :
Linux - Mac:
Darwin - Les fenêtres:
Windows
Voir: plateforme — Accès aux données d'identification de la plateforme sous-jacente
Autres conseils
Dang -- lbrandy m'a devancé, mais cela ne veut pas dire que je ne peux pas vous fournir les résultats du système pour Vista !
>>> import os
>>> os.name
'nt'
>>> import platform
>>> platform.system()
'Windows'
>>> platform.release()
'Vista'
... et je n'arrive pas à croire que personne n'en ait encore publié pour Windows 10 :
>>> import os
>>> os.name
'nt'
>>> import platform
>>> platform.system()
'Windows'
>>> platform.release()
'10'
Pour mémoire, voici les résultats sur Mac :
>>> import os
>>> os.name
'posix'
>>> import platform
>>> platform.system()
'Darwin'
>>> platform.release()
'8.11.1'
Exemple de code pour différencier les systèmes d'exploitation à l'aide de Python :
from sys import platform as _platform
if _platform == "linux" or _platform == "linux2":
# linux
elif _platform == "darwin":
# MAC OS X
elif _platform == "win32":
# Windows
elif _platform == "win64":
# Windows 64-bit
Vous pouvez également utiliser sys.platform si vous avez déjà importé un système et que vous ne souhaitez pas importer un autre module
>>> import sys
>>> sys.platform
'linux2'
Si vous souhaitez des données lisibles par l'utilisateur mais toujours détaillées, vous pouvez utiliser plateforme.plateforme()
>>> import platform
>>> platform.platform()
'Linux-3.3.0-8.fc16.x86_64-x86_64-with-fedora-16-Verne'
Voici quelques appels possibles que vous pouvez passer pour identifier où vous vous trouvez
import platform
import sys
def linux_distribution():
try:
return platform.linux_distribution()
except:
return "N/A"
print("""Python version: %s
dist: %s
linux_distribution: %s
system: %s
machine: %s
platform: %s
uname: %s
version: %s
mac_ver: %s
""" % (
sys.version.split('\n'),
str(platform.dist()),
linux_distribution(),
platform.system(),
platform.machine(),
platform.platform(),
platform.uname(),
platform.version(),
platform.mac_ver(),
))
Les sorties de ce script exécutées sur différents systèmes (Linux, Windows, Solaris, MacOS) et architectures (x86, x64, Itanium, power pc, sparc) sont disponibles ici : https://github.com/hpcugent/easybuild/wiki/OS_flavor_name_version
Le serveur Ubuntu 12.04 donne par exemple :
Python version: ['2.6.5 (r265:79063, Oct 1 2012, 22:04:36) ', '[GCC 4.4.3]']
dist: ('Ubuntu', '10.04', 'lucid')
linux_distribution: ('Ubuntu', '10.04', 'lucid')
system: Linux
machine: x86_64
platform: Linux-2.6.32-32-server-x86_64-with-Ubuntu-10.04-lucid
uname: ('Linux', 'xxx', '2.6.32-32-server', '#62-Ubuntu SMP Wed Apr 20 22:07:43 UTC 2011', 'x86_64', '')
version: #62-Ubuntu SMP Wed Apr 20 22:07:43 UTC 2011
mac_ver: ('', ('', '', ''), '')
je fais ça
import sys
print sys.platform
Documents ici : sys.plateforme.
Tout ce dont vous avez besoin se trouve probablement dans le module sys.
J'utilise l'outil WLST fourni avec weblogic et il n'implémente pas le package de plateforme.
wls:/offline> import os
wls:/offline> print os.name
java
wls:/offline> import sys
wls:/offline> print sys.platform
'java1.5.0_11'
En plus de patcher le système javaos.py (problème avec os.system() sur Windows 2003 avec jdk1.5) (ce que je ne peux pas faire, je dois utiliser weblogic prêt à l'emploi), voici ce que j'utilise :
def iswindows():
os = java.lang.System.getProperty( "os.name" )
return "win" in os.lower()
Que diriez-vous d'une nouvelle réponse :
import psutil
psutil.MACOS #True (OSX is deprecated)
psutil.WINDOWS #False
psutil.LINUX #False
Ce serait le résultat si j'utilisais MACOS
>>> import platform
>>> platform.system()
/usr/bin/python3.2
def cls():
from subprocess import call
from platform import system
os = system()
if os == 'Linux':
call('clear', shell = True)
elif os == 'Windows':
call('cls', shell = True)
Pour Jython, la seule façon d'obtenir le nom du système d'exploitation que j'ai trouvé est de vérifier os.name Propriété Java (essayée avec sys, os et platform modules pour Jython 2.5.3 sur WinXP) :
def get_os_platform():
"""return platform name, but for Jython it uses os.name Java property"""
ver = sys.platform.lower()
if ver.startswith('java'):
import java.lang
ver = java.lang.System.getProperty("os.name").lower()
print('platform: %s' % (ver))
return ver
J'ai commencé une liste un peu plus systématique des valeurs auxquelles vous pouvez vous attendre en utilisant les différents modules (n'hésitez pas à modifier et ajouter votre système) :
Linux (64 bits) + WSL
os.name posix
sys.platform linux
platform.system() Linux
sysconfig.get_platform() linux-x86_64
platform.machine() x86_64
platform.architecture() ('64bit', '')
- essayé avec archlinux et mint, j'ai obtenu les mêmes résultats
- sur python2
sys.platformest suffixé par la version du noyau, par ex.linux2, tout le reste reste identique - même résultat sur le sous-système Windows pour Linux (essayé avec Ubuntu 18.04 LTS), sauf
platform.architecture() = ('64bit', 'ELF')
WINDOWS (64 bits)
(avec une colonne 32 bits exécutée dans le sous-système 32 bits)
official python installer 64bit 32bit
------------------------- ----- -----
os.name nt nt
sys.platform win32 win32
platform.system() Windows Windows
sysconfig.get_platform() win-amd64 win32
platform.machine() AMD64 AMD64
platform.architecture() ('64bit', 'WindowsPE') ('64bit', 'WindowsPE')
msys2 64bit 32bit
----- ----- -----
os.name posix posix
sys.platform msys msys
platform.system() MSYS_NT-10.0 MSYS_NT-10.0-WOW
sysconfig.get_platform() msys-2.11.2-x86_64 msys-2.11.2-i686
platform.machine() x86_64 i686
platform.architecture() ('64bit', 'WindowsPE') ('32bit', 'WindowsPE')
msys2 mingw-w64-x86_64-python3 mingw-w64-i686-python3
----- ------------------------ ----------------------
os.name nt nt
sys.platform win32 win32
platform.system() Windows Windows
sysconfig.get_platform() mingw mingw
platform.machine() AMD64 AMD64
platform.architecture() ('64bit', 'WindowsPE') ('32bit', 'WindowsPE')
cygwin 64bit 32bit
------ ----- -----
os.name posix posix
sys.platform cygwin cygwin
platform.system() CYGWIN_NT-10.0 CYGWIN_NT-10.0-WOW
sysconfig.get_platform() cygwin-3.0.1-x86_64 cygwin-3.0.1-i686
platform.machine() x86_64 i686
platform.architecture() ('64bit', 'WindowsPE') ('32bit', 'WindowsPE')
Quelques remarques :
- il y a aussi
distutils.util.get_platform()qui est identique à `sysconfig.get_platform - anaconda sur Windows est identique au programme d'installation officiel de Python Windows
- Je n'ai pas de Mac ni de vrai système 32 bits et je n'étais pas motivé pour le faire en ligne
Pour comparer avec votre système, exécutez simplement ce script (et veuillez ajouter les résultats ici s'ils sont manquants :)
from __future__ import print_function
import os
import sys
import platform
import sysconfig
print("os.name ", os.name)
print("sys.platform ", sys.platform)
print("platform.system() ", platform.system())
print("sysconfig.get_platform() ", sysconfig.get_platform())
print("platform.machine() ", platform.machine())
print("platform.architecture() ", platform.architecture())
Résultats intéressants sur Windows 8 :
>>> import os
>>> os.name
'nt'
>>> import platform
>>> platform.system()
'Windows'
>>> platform.release()
'post2008Server'
Modifier: C'est un bogue
Attention si vous êtes sous Windows avec Cygwin où os.name est posix.
>>> import os, platform
>>> print os.name
posix
>>> print platform.system()
CYGWIN_NT-6.3-WOW
dans la même veine....
import platform
is_windows=(platform.system().lower().find("win") > -1)
if(is_windows): lv_dll=LV_dll("my_so_dll.dll")
else: lv_dll=LV_dll("./my_so_dll.so")
Si vous ne recherchez pas la version du noyau, etc., mais la distribution Linux, vous souhaiterez peut-être utiliser ce qui suit
en python2.6+
>>> import platform
>>> print platform.linux_distribution()
('CentOS Linux', '6.0', 'Final')
>>> print platform.linux_distribution()[0]
CentOS Linux
>>> print platform.linux_distribution()[1]
6.0
en python2.4
>>> import platform
>>> print platform.dist()
('centos', '6.0', 'Final')
>>> print platform.dist()[0]
centos
>>> print platform.dist()[1]
6.0
Évidemment, cela ne fonctionnera que si vous l’exécutez sous Linux.Si vous souhaitez disposer d'un script plus générique sur toutes les plates-formes, vous pouvez le mélanger avec des exemples de code donnés dans d'autres réponses.
essaye ça:
import os
os.uname()
et tu peux le faire :
info=os.uname()
info[0]
info[1]
Vérifiez les tests disponibles avec la plateforme de modules et imprimez la réponse pour votre système :
import platform
print dir(platform)
for x in dir(platform):
if x[0].isalnum():
try:
result = getattr(platform, x)()
print "platform."+x+": "+result
except TypeError:
continue
Vous pouvez également utiliser uniquement le module de plateforme sans importer le module OS pour obtenir toutes les informations.
>>> import platform
>>> platform.os.name
'posix'
>>> platform.uname()
('Darwin', 'mainframe.local', '15.3.0', 'Darwin Kernel Version 15.3.0: Thu Dec 10 18:40:58 PST 2015; root:xnu-3248.30.4~1/RELEASE_X86_64', 'x86_64', 'i386')
Une mise en page agréable et ordonnée à des fins de reporting peut être obtenue en utilisant cette ligne :
for i in zip(['system','node','release','version','machine','processor'],platform.uname()):print i[0],':',i[1]
Cela donne ce résultat :
system : Darwin
node : mainframe.local
release : 15.3.0
version : Darwin Kernel Version 15.3.0: Thu Dec 10 18:40:58 PST 2015; root:xnu-3248.30.4~1/RELEASE_X86_64
machine : x86_64
processor : i386
Ce qui manque généralement, c'est la version du système d'exploitation, mais vous devez savoir si vous utilisez Windows, Linux ou Mac, une manière indépendante de la plate-forme consiste à utiliser ce test :
In []: for i in [platform.linux_distribution(),platform.mac_ver(),platform.win32_ver()]:
....: if i[0]:
....: print 'Version: ',i[0]
Si vous utilisez macOS X et exécutez platform.system() Vous obtenez Darwin car MacOS X est construit sur Darwin OS d'Apple.Darwin est le noyau de macOS X et est essentiellement macOS X sans l'interface graphique.
Cette solution fonctionne pour les deux python et jython.
module os_identify.py:
import platform
import os
# This module contains functions to determine the basic type of
# OS we are running on.
# Contrary to the functions in the `os` and `platform` modules,
# these allow to identify the actual basic OS,
# no matter whether running on the `python` or `jython` interpreter.
def is_linux():
try:
platform.linux_distribution()
return True
except:
return False
def is_windows():
try:
platform.win32_ver()
return True
except:
return False
def is_mac():
try:
platform.mac_ver()
return True
except:
return False
def name():
if is_linux():
return "Linux"
elif is_windows():
return "Windows"
elif is_mac():
return "Mac"
else:
return "<unknown>"
Utilisez comme ceci :
import os_identify
print "My OS: " + os_identify.name()
import sys
import platform
# return a platform identifier
print(sys.platform)
# return system/os name
print(platform.system())
# print system info
# similar to 'uname' command in unix
print(platform.uname())
Utilisez le import os et os.name mots clés.
Que diriez-vous d’une simple implémentation Enum comme celle-ci ?Pas besoin de bibliothèques externes !
import platform
from enum import Enum
class OS(Enum):
def checkPlatform(osName):
return osName.lower()== platform.system().lower()
MAC = checkPlatform("darwin")
LINUX = checkPlatform("linux")
WINDOWS = checkPlatform("windows") #I haven't test this one
Vous pouvez simplement accéder avec la valeur Enum
if OS.LINUX.value:
print("Cool it is Linux")
PS : c'est python3
Vous pouvez regarder le code dans pyOSinfo qui fait partie du date pip package, pour obtenir les informations les plus pertinentes sur le système d’exploitation, telles que vues dans votre distribution Python.
L'une des raisons les plus courantes pour lesquelles les gens souhaitent vérifier leur système d'exploitation est la compatibilité des terminaux et la disponibilité de certaines commandes système.Malheureusement, le succès de cette vérification dépend quelque peu de votre installation Python et de votre système d'exploitation.Par exemple, uname n'est pas disponible sur la plupart des packages Windows Python.Le programme python ci-dessus vous montrera le résultat des fonctions intégrées les plus couramment utilisées, déjà fournies par os, sys, platform, site.
La meilleure façon d'obtenir uniquement le code essentiel est donc de consulter que par exemple.(Je suppose que j'aurais pu le coller ici, mais cela n'aurait pas été politiquement correct.)
Je suis en retard dans le jeu mais, juste au cas où quelqu'un en aurait besoin, c'est une fonction que j'utilise pour apporter des ajustements à mon code afin qu'il fonctionne sous Windows, Linux et MacO :
import sys
def get_os(osoptions={'linux':'linux','Windows':'win','macos':'darwin'}):
'''
get OS to allow code specifics
'''
opsys = [k for k in osoptions.keys() if sys.platform.lower().find(osoptions[k].lower()) != -1]
try:
return opsys[0]
except:
return 'unknown_OS'
