Que dois-je regarder pour voir si je suis sous Windows ou Unix, etc.?
Que dois-je regarder pour voir si je suis sous Windows ou Unix, etc.?
Réponses:
>>> import os
>>> os.name
'posix'
>>> import platform
>>> platform.system()
'Linux'
>>> platform.release()
'2.6.22-15-generic'
La sortie de platform.system()
est la suivante:
Linux
Darwin
Windows
Voir: platform
- Accès aux données d'identification de la plateforme sous-jacente
platform
plus sys.platform
?
platform.system()
retourne "Windows"
au lieu de "win32"
. sys.platform
contient également "linux2"
sur les anciennes versions de Python alors qu'il ne contient que "linux"
sur les plus récentes. platform.system()
est toujours revenu juste "Linux"
.
os.uname()
n'existe que pour les systèmes Unix. Les documents Python 3: docs.python.org/3/library/os.html Availability: recent flavors of Unix.
Dang - lbrandy m'a battu, mais cela ne signifie pas 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é un pour Windows 10:
>>> import os
>>> os.name
'nt'
>>> import platform
>>> platform.system()
'Windows'
>>> platform.release()
'10'
platform.release()
'7'
platform.release()
sur mon Windows 10 , et ça m'a vraiment donné '8'
. Peut-être que j'ai installé python avant la mise à niveau, mais vraiment ??
Pour mémoire, voici les résultats sur Mac:
>>> import os
>>> os.name
'posix'
>>> import platform
>>> platform.system()
'Darwin'
>>> platform.release()
'8.11.1'
platform.release()
retourne'19.2.0'
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é sys
et que vous ne souhaitez pas importer un autre module
>>> import sys
>>> sys.platform
'linux2'
Si vous voulez des données lisibles par l'utilisateur mais toujours détaillées, vous pouvez utiliser platform.platform ()
>>> 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 faire pour identifier où vous êtes
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 ont fonctionné sur quelques systèmes différents (Linux, Windows, Solaris, MacOS) et des 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: ('', ('', '', ''), '')
DeprecationWarning: dist() and linux_distribution() functions are deprecated in Python 3.5
Histoire courte
Utilisez platform.system()
. Il renvoie Windows
, Linux
ou Darwin
(pour OSX).
Longue histoire
Il existe 3 façons d'obtenir un système d'exploitation en Python, chacune avec ses propres avantages et inconvénients:
Méthode 1
>>> import sys
>>> sys.platform
'win32' # could be 'linux', 'linux2, 'darwin', 'freebsd8' etc
Comment cela fonctionne ( source ): en interne, il appelle les API du système d'exploitation pour obtenir le nom du système d'exploitation tel que défini par le système d'exploitation. Voir ici pour différentes valeurs spécifiques au système d'exploitation.
Pro: Pas de magie, bas niveau.
Con: dépend de la version du système d'exploitation, il est donc préférable de ne pas l'utiliser directement.
Méthode 2
>>> import os
>>> os.name
'nt' # for Linux and Mac it prints 'posix'
Comment cela fonctionne ( source ): en interne, il vérifie si python a des modules spécifiques au système d'exploitation appelés posix ou nt.
Pro: simple pour vérifier si le système d'exploitation posix
Inconvénient: pas de différenciation entre Linux ou OSX.
Méthode 3
>>> import platform
>>> platform.system()
'Windows' # for Linux it prints 'Linux', Mac it prints `'Darwin'
Comment cela fonctionne ( source ): en interne, il finira par appeler des API de système d'exploitation internes, obtenir un nom spécifique à la version du système d'exploitation comme 'win32' ou 'win16' ou 'linux1', puis normaliser vers des noms plus génériques comme 'Windows' ou 'Linux' ou «Darwin» en appliquant plusieurs heuristiques.
Pro: Meilleur moyen portable pour Windows, OSX et Linux.
Con: les gens de Python doivent garder l'heuristique de normalisation à jour.
Sommaire
platform.system()
.posix
ou nt
utiliseros.name
.sys.platform
.Que diriez-vous d'une nouvelle réponse:
import psutil
psutil.MACOS #True (OSX is deprecated)
psutil.WINDOWS #False
psutil.LINUX #False
Ce serait la sortie si j'utilisais MACOS
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):
os.name posix
sys.platform linux
platform.system() Linux
sysconfig.get_platform() linux-x86_64
platform.machine() x86_64
platform.architecture() ('64bit', '')
sys.platform
est suffixé par la version du noyau, par exemple linux2
, tout le reste reste identiqueplatform.architecture() = ('64bit', 'ELF')
(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:
distutils.util.get_platform()
qui est identique à `sysconfig.get_platformPour comparer avec votre système, exécutez simplement ce script (et veuillez ajouter les résultats ici s'il manque :)
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())
J'utilise l'outil WLST fourni avec weblogic et il n'implémente pas le package de plate-forme.
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 hors de la boîte), voici ce que j'utilise:
def iswindows():
os = java.lang.System.getProperty( "os.name" )
return "win" in os.lower()
/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, le seul moyen d'obtenir le nom du système d'exploitation que j'ai trouvé est de vérifier os.name
la propriété Java (essayé avec sys
, os
et les 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
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 que vous recherchez la distribution linux, vous pouvez utiliser les éléments suivants
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 sur Linux. Si vous souhaitez avoir un script plus générique sur toutes les plateformes, vous pouvez mélanger cela avec des exemples de code donnés dans d'autres réponses.
essaye ça:
import os
os.uname()
et vous pouvez le faire:
info=os.uname()
info[0]
info[1]
os.uname()
ne sont pas disponibles sur les fenêtres: docs.python.org/2/library/os.html#os.uname Disponibilité: saveurs récentes d'Unix.
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 bien rangée à des fins de rapport 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 cette sortie:
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 exécutez Windows, Linux ou Mac d'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]
Je sais que c'est une vieille question, mais je pense que ma réponse pourrait être utile à certaines personnes qui recherchent un moyen pythonique facile à comprendre pour détecter le système d'exploitation dans leur code. Testé sur python3.7
from sys import platform
class UnsupportedPlatform(Exception):
pass
if "linux" in platform:
print("linux")
elif "darwin" in platform:
print("mac")
elif "win" in platform:
print("windows")
else:
raise UnsupportedPlatform
Si vous exécutez macOS X et exécutez, platform.system()
vous obtenez darwin car macOS X est construit sur le système d'exploitation Darwin d'Apple. Darwin est le noyau de macOS X et est essentiellement macOS X sans l'interface graphique.
Cette solution fonctionne pour 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()
Que diriez-vous d'une implémentation Enum simple 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
Simplement, vous pouvez accéder avec la valeur Enum
if OS.LINUX.value:
print("Cool it is Linux")
PS c'est python3
Vous pouvez consulter le code pyOSinfo
qui fait partie du package pip-date , pour obtenir les informations de système d'exploitation les plus pertinentes, comme le montre votre distribution Python.
L'une des raisons les plus courantes pour lesquelles les utilisateurs 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 la sortie des fonctions intégrées les plus couramment utilisées, déjà fournies par os, sys, platform, site
.
Donc, la meilleure façon d'obtenir uniquement le code essentiel est de considérer cela comme un 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 faire des ajustements sur mon code pour qu'il fonctionne sur Windows, Linux et MacOs:
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'