Que dois-je regarder pour voir si je suis sous Windows ou Unix, etc.?

>>> 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: Linux
• Mac: Darwin
• Les fenêtres: Windows

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

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'

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.platformsi vous avez déjà importé syset 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: ('', ('', '', ''), '')

Histoire courte

Utilisez platform.system(). Il renvoie Windows, Linuxou 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

• Si vous voulez vérifier si le système d'exploitation est Windows ou Linux ou OSX, le moyen le plus fiable est platform.system() .
• Si vous souhaitez effectuer des appels spécifiques au système d'exploitation mais via des modules Python intégrés posixou ntutiliseros.name .
• Si vous souhaitez obtenir le nom brut du système d'exploitation tel que fourni par le système d'exploitation lui-même, utilisez 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):

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 menthe, a obtenu les mêmes résultats
• sur python2 sys.platformest suffixé par la version du noyau, par exemple linux2, tout le reste reste identique
• même sortie 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 en a aussi distutils.util.get_platform()qui est identique à `sysconfig.get_platform
• anaconda sur windows est le même que l'installateur officiel de windows python
• Je n'ai pas de Mac ni de véritable 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'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.namela propriété Java (essayé avec sys, oset les platformmodules 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

Résultats intéressants sur Windows 8:

>>> import os
>>> os.name
'nt'
>>> import platform
>>> platform.system()
'Windows'
>>> platform.release()
'post2008Server'

Edit: c'est un bug

Attention si vous êtes sous Windows avec Cygwin où os.nameest 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 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]

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 pythonet 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 pyOSinfoqui 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, unamen'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'