Sur quel système d'exploitation est-ce que je fonctionne?


Réponses:


827
>>> 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


26
Pourquoi devrais - je préfère platformplus sys.platform?
2016

40
@matth Sortie légèrement plus cohérente. c'est à dire platform.system()retourne "Windows"au lieu de "win32". sys.platformcontient é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".
erb

4
Sur mac os X, platform.system () renvoie toujours "Darwin"? ou existe-t-il un autre cas possible?
baptiste chéné

4
@ baptistechéné, je sais que cela fait plus d'un an que vous l'avez demandé, mais comme un commentaire ne fera pas de mal, je le posterai quand même :) Donc, la raison derrière c'est parce qu'il montre le nom du noyau. De la même manière que les distributions Linux (le noyau) ont de nombreux noms (Ubuntu, Arch, Fedora entre autres), mais elles se présenteront comme le nom du noyau, Linux. Darwin (un noyau basé sur BSD), a son système environnant, le macOS. Je suis presque sûr qu'Apple a publié Darwin en tant que code open source, mais il n'y a aucune autre distribution fonctionnant sur Darwin à ma connaissance.
Joao Paulo Rabelo

1
@TooroSan 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.
Irving Moy

175

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'

6
Windows 7:platform.release() '7'
Hugo

3
Donc, oui, je viens de courir 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 ??
Codesmith

2
J'aurais pensé qu'il est plus probable que vous ayez effectué une mise à niveau à partir de Windows 8 (par rapport à une installation propre) et quel que soit Python recherché dans le registre ou ce qui a été laissé?
OJFord

2
La recherche de version pour python sous Windows semble utiliser la fonction api Win32 GetVersionEx à sa base. Les notes en haut de cet article Microsoft sur cette fonction peuvent être pertinentes: msdn.microsoft.com/en-us/library/windows/desktop/…
theferrit32

126

Pour mémoire, voici les résultats sur Mac:

>>> import os
>>> os.name
'posix'
>>> import platform
>>> platform.system()
'Darwin'
>>> platform.release()
'8.11.1'

1
Sur macOS Catalina 10.15.2, platform.release()retourne'19.2.0'
Boris

95

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

1
Cet exemple de code provient-il d'un module python? C'est la seule réponse qui répond en fait à la question.
kon psych

8
Pour des résultats plus flous, `` _platform.startswith ('linux')
Klaatu von Schlacker

42

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'

L'une des approches présente-t-elle des avantages, en plus d'avoir à importer ou non un autre module?
Matth

La portée est le principal avantage. Vous voulez aussi peu de noms de variables globales que possible. Lorsque vous avez déjà "sys" comme nom global, vous ne devez pas en ajouter un autre. Mais si vous n'utilisez pas encore "sys", l'utilisation de "_platform" pourrait être plus descriptive et moins susceptible d'entrer en collision avec une autre signification.
sanderd17

33

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
Boris

19

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.

Voilà pour "Il devrait y avoir une (et de préférence une seule) façon de faire les choses". Cependant, je pense que c'est la bonne réponse. Vous auriez besoin de comparer avec les noms de système d'exploitation intitulés, mais ce n'est pas un tel problème et sera plus portable.
vincent-lg

16

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


7
psutil ne fait pas partie de la bibliothèque standard
Corey Goldberg

14

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

11

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

9

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

3
Bienvenue sur SO, ici, c'est une bonne pratique pour expliquer pourquoi utiliser votre solution et pas seulement comment. Cela rendra votre réponse plus précieuse et aidera le lecteur à mieux comprendre comment vous le faites. Je vous suggère également de consulter notre FAQ: stackoverflow.com/faq .
ForceMagic

Bonne réponse, peut-être même à égalité avec la réponse originale. Mais vous pourriez expliquer pourquoi.
vgoff

9

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

Vous pouvez également appeler "platform.java_ver ()" pour extraire les informations du système d'exploitation dans Jython.
DocOc

8

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


7

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

6

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

9
Ceci est problématique si vous êtes sur un Mac car platform.system () renvoie "Darwin" sur un Mac et "Darwin" .lower (). Find ("win") = 3.
mishaF

is_windows = platform.system (). lower (). startswith ("win") ou False
Corey Goldberg

6

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.



4

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

4

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]

4

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

2

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.


2

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

1

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


1

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.

entrez la description de l'image ici

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


1

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'
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.