Python: Qu'est-ce que je OS fonctionne sur?

voix
410

Que dois-je besoin de regarder pour voir si je suis sous Windows, Unix, etc?

Créé 05/08/2008 à 04:23
source utilisateur
Dans d'autres langues...                            


29 réponses

voix
513

>>> import os
>>> print os.name
posix
>>> import platform
>>> platform.system()
'Linux'
>>> platform.release()
'2.6.22-15-generic'

La sortie platform.system()est la suivante:

  • Linux: Linux
  • Mac: Darwin
  • Les fenêtres: Windows

Voir: plate - forme - Accès au données d' identification de la plate - forme sous - jacente

Créé 05/08/2008 à 04:27
source utilisateur

voix
146

Dang - lbrandy m'a battu à coup de poing, 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 ne peux pas croire que personne pour celui affiché de 10 encore de Windows:

>>> import os
>>> os.name
'nt'
>>> import platform
>>> platform.system()
'Windows'
>>> platform.release()
'10'
Créé 05/08/2008 à 04:57
source utilisateur

voix
108

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

>>> import os
>>> os.name
'posix'
>>> import platform
>>> platform.system()
'Darwin'
>>> platform.release()
'8.11.1'
Créé 05/08/2008 à 05:13
source utilisateur

voix
73

Exemple de code pour différencier en utilisant le python OS:

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
Créé 16/09/2014 à 08:42
source utilisateur

voix
35

Vous pouvez également utiliser sys.platform si vous avez déjà importé sys et vous ne voulez pas importer un autre module

>>> import sys
>>> sys.platform
'linux2'
Créé 26/08/2008 à 16:41
source utilisateur

voix
24

Si vous voulez des données utilisateur lisibles 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 différents 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 a couru sur quelques systèmes différents sont disponibles ici: https://github.com/hpcugent/easybuild/wiki/OS_flavor_name_version

Créé 23/01/2013 à 11:55
source utilisateur

voix
17

je fais ça

import sys
print sys.platform

Docs ici: sys.platform .

Tout ce dont vous avez besoin est probablement dans le module sys.

Créé 16/02/2009 à 15:43
source utilisateur

voix
10

J'utilise l'outil WLST qui vient avec weblogic, et il ne met pas en œuvre le paquet 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 dehors de patcher le système javaos.py ( problème avec os.system () sur Windows 2003 avec jdk1.5 ) (que je ne peux pas faire, je dois utiliser weblogic hors de la boîte), ce que j'utilise:

def iswindows():
  os = java.lang.System.getProperty( "os.name" )
  return "win" in os.lower()
Créé 11/06/2010 à 08:37
source utilisateur

voix
9
>>> import platform
>>> platform.system()
Créé 25/06/2011 à 12:10
source utilisateur

voix
8

Pour Jython la seule façon d'obtenir le nom d'os , j'ai trouvé est de vérifier la os.namepropriété Java (essayé avec sys, oset platformmodules pour Jython 2.5.3 sur Windows XP):

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
Créé 09/01/2013 à 09:47
source utilisateur

voix
7

/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)
Créé 10/10/2011 à 01:11
source utilisateur

voix
6

Méfiez - vous si vous êtes sur Windows avec Cygwin où os.nameest posix.

>>> import os, platform
>>> print os.name
posix
>>> print platform.system()
CYGWIN_NT-6.3-WOW
Créé 08/07/2015 à 14:46
source utilisateur

voix
6

Des 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

Créé 14/02/2013 à 23:44
source utilisateur

voix
5

essaye ça:

import os

os.uname()

et vous pouvez le faire:

info=os.uname()
info[0]
info[1]
Créé 16/01/2015 à 18:13
source utilisateur

voix
5

Si vous ne cherchez pas la version du noyau etc, mais la recherche de la distribution de 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

De toute évidence, cela ne fonctionnera que si vous utilisez ce sous linux. Si vous voulez avoir plus de script générique sur toutes les plateformes, vous pouvez mélanger cela avec des exemples de code donnés dans d'autres réponses.

Créé 28/03/2013 à 06:19
source utilisateur

voix
5

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")
Créé 28/09/2011 à 18:54
source utilisateur

voix
4

Que diriez-vous d'une nouvelle réponse:

import psutil
psutil.OSX     #True
psutil.WINDOWS #False
psutil.LINUX   #False 

Ce serait la sortie si j'utilisais OSX

Créé 14/08/2017 à 17:00
source utilisateur

voix
3

J'ai commencé un peu plus de liste systématique les valeurs que vous pouvez vous attendre en utilisant les différents modules (ne 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 de menthe, a obtenu des résultats mêmes
  • sur python2 sys.platformest suffixé par la version du noyau, par exemple linux2, tout le reste demeure identique
  • même sortie sur sous-système Windows pour Linux (essayé avec ubuntu 18.04 LTS), à l'exception platform.architecture() = ('64bit', 'ELF')

WINDOWS (64 bits)

(Avec colonne de 32 bits en cours d'exécution dans le sous-système de 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 ce distutils.util.get_platform()qui est identique à `sysconfig.get_platform
  • anaconda fenêtres est la même que les fenêtres de python officiel d'installation
  • Je n'ai pas de Mac, ni un véritable système 32bit et n'a pas été motivé à le faire en ligne

Pour comparer avec votre système, il suffit de lancer ce script (et s'il vous plaît append résultats ici si 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())
Créé 23/02/2019 à 02:39
source utilisateur

voix
3

Vous pouvez également utiliser le module uniquement de plate-forme 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 belle mise en page et bien rangé à des fins de rapports peut être réalisé 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 est généralement la version du système d'exploitation, mais vous devez savoir si vous utilisez Windows, Linux ou Mac une plate-forme façon indépendente est d'utiliser ce test:

In []: for i in [platform.linux_distribution(),platform.mac_ver(),platform.win32_ver()]:
   ....:     if i[0]:
   ....:         print 'Version: ',i[0]
Créé 20/08/2016 à 08:03
source utilisateur

voix
3

Vérifiez les tests disponibles avec la plate-forme de module et imprimer 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
Créé 30/10/2014 à 00:43
source utilisateur

voix
2
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())
Créé 03/02/2019 à 22:43
source utilisateur

voix
1

Vous pouvez consulter le code pyOSinfoqui fait partie du pip jour package, pour obtenir les informations les plus pertinentes du système d'exploitation, comme on le voit de votre distribution Python.

L' une des raisons les plus communes que les gens veulent vérifier leur système d' exploitation est la compatibilité du terminal et si certaines commandes du système sont disponibles. Malheureusement, le succès de cette vérification dépend quelque peu de votre installation de python et OS. Par exemple, unamene sont pas disponibles sur la plupart des paquets de python Windows. Le programme python ci - dessus vous montre la sortie des fonctions intégrées les plus couramment utilisés, déjà fournies par os, sys, platform, site.

entrez la description d'image ici

Donc , la meilleure façon d'obtenir que le code essentiel est à la recherche à ce titre d'exemple. (Je suppose que je aurais pu collé ici, mais qui ne serait pas politiquement correct.)

Créé 07/02/2019 à 21:10
source utilisateur

voix
1

Cette solution fonctionne à la fois 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()
Créé 29/01/2019 à 13:06
source utilisateur

voix
1

Si vous utilisez X et exécutez macOS platform.system()vous obtenez darwin parce que X est construit macOS sur Apple Darwin OS. Darwin est le noyau de MacOS X et est essentiellement X sans l'macOS GUI.

Créé 13/01/2018 à 21:29
source utilisateur

voix
1

Utilisez les import oset os.namemots - clés.

Créé 07/05/2017 à 03:07
source utilisateur

voix
0

Il y a 3 façons d'obtenir OS en Python, chacun 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 ( la source ): En interne , il appelle OS API pour obtenir le nom du système d' exploitation tel que défini par OS. Cela peut évidemment changer de version en version, donc préférable de ne pas utiliser directement. Voir ici pour différentes valeurs spécifiques à l' OS.

méthode 2

>>> import os
>>> os.name
'nt'  # for Linux and Mac it prints 'posix'

Comment cela fonctionne ( la source ): En interne , il vérifie si python a des modules spécifiques à l' OS appelé posix ou nt. Si vous souhaitez importer ces modules et méthodes d'appel à ce sujet , cela fonctionne très bien. Notez qu'il n'y a pas de différence entre Linux ou OSX.

méthode 3

>>> import platform
>>> platform.system()
'Windows' # for Linux it prints 'Linux', Mac it prints `'Darwin'

Comment cela fonctionne ( la source ): En interne , il finira par appeler les API OS internes, obtenir le nom du système d'exploitation spécifique à la version comme « win32 » ou « win16 » ou « linux1 », puis normaliser à des noms plus génériques comme « Windows » ou « Linux » ou « Darwin » en appliquant plusieurs heuristiques. Ceci est la meilleure façon portable pour obtenir le nom du système d'exploitation normalisé.

Sommaire

  • Si vous voulez vérifier si OS est Windows ou Linux ou Mac OS X , puis la façon la plus fiable est platform.system().
  • Si vous voulez faire des appels spécifiques à l' OS , mais par l' intermédiaire des modules Python intégrés posixou ntalors utiliser os.name.
  • Si vous souhaitez obtenir le nom du système d'exploitation brut fourni par OS lui - même utiliser ensuite sys.platform.
Créé 24/09/2019 à 02:28
source utilisateur

voix
0

Je suis en retard pour le jeu, mais, juste au cas où tout le monde a besoin, cette fonction que j'utilise pour faire des ajustements sur mon code pour qu'il fonctionne sous Windows, Linux et Mac OS:

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'
Créé 22/05/2019 à 16:32
source utilisateur

voix
0

Que diriez-vous d'une simple mise en œuvre Enum comme ce qui suit? Pas besoin de libs externe!

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

Tout simplement, vous pouvez accéder à la valeur Enum

if OS.LINUX.value:
    print("Cool it is Linux")

PS Il est python3

Créé 27/09/2018 à 17:39
source utilisateur

voix
-4

Juste pour être complet, « OS » variable d'environnement semble être défini partout. Sous Windows XP / 7/8/10, il est réglé sur "Windows_NT". Sous Linux SuSE SP2, il est réglé sur "SLES11 linux x86-64 [2]". Je n'ai pas accès aux machines OS X ou BSD, serait intéressant de vérifier là aussi.

import os

os_name = os.getenv("OS")
if os_name == "Windows_NT":
    # Windows
elif "linux" in os_name:
    # Linux
elif ...
Créé 01/12/2015 à 07:28
source utilisateur

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more