Was muss ich mir ansehen, um zu sehen, ob ich unter Windows oder Unix usw. bin?

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

Die Ausgabe von platform.system()ist wie folgt:

• Linux: Linux
• Mac: Darwin
• Windows: Windows

Siehe: platform- Zugriff auf die Identifizierungsdaten der zugrunde liegenden Plattform

Dang - lbrandy hat mich hart getroffen, aber das heißt nicht, dass ich Ihnen nicht die Systemergebnisse für Vista liefern kann!

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

... und ich kann nicht glauben, dass noch niemand einen für Windows 10 gepostet hat:

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

Für die Aufzeichnung hier die Ergebnisse auf Mac:

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

Beispielcode zur Unterscheidung von Betriebssystemen mithilfe von 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

Sie können auch verwenden, sys.platformwenn Sie bereits importiert haben sysund kein anderes Modul importieren möchten

>>> import sys
>>> sys.platform
'linux2'

Wenn Sie vom Benutzer lesbare, aber dennoch detaillierte Daten wünschen, können Sie platform.platform () verwenden.

>>> import platform
>>> platform.platform()
'Linux-3.3.0-8.fc16.x86_64-x86_64-with-fedora-16-Verne'

Hier sind einige verschiedene mögliche Anrufe, die Sie tätigen können, um festzustellen, wo Sie sich befinden

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

Die Ausgaben dieses Skripts liefen auf einigen verschiedenen Systemen (Linux, Windows, Solaris, MacOS) und Architekturen (x86, x64, Itanium, Power PC, Sparc) sind hier verfügbar: https://github.com/hpcugent/easybuild/ wiki / OS_flavor_name_version

Der Ubuntu 12.04 Server bietet zum Beispiel:

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: ('', ('', '', ''), '')

Kurzgeschichte

Verwenden Sie platform.system(). Es kehrt zurück Windows, LinuxoderDarwin (für OSX).

Lange Geschichte

Es gibt drei Möglichkeiten, um das Betriebssystem in Python zu erhalten, jede mit ihren eigenen Vor- und Nachteilen:

Methode 1

>>> import sys
>>> sys.platform
'win32'  # could be 'linux', 'linux2, 'darwin', 'freebsd8' etc

So funktioniert das ( Quelle ): Intern werden Betriebssystem-APIs aufgerufen, um den vom Betriebssystem definierten Namen des Betriebssystems abzurufen. Siehe hier für verschiedene OS-spezifische Werte.

Pro: Keine Magie, niedriges Level.

Con: OS-Version abhängig, daher am besten nicht direkt verwenden.

Methode 2

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

Wie das funktioniert ( Quelle ): Intern wird geprüft, ob Python über betriebssystemspezifische Module namens posix oder nt verfügt.

Pro: Einfach zu überprüfen, ob posix OS

Con: keine Unterscheidung zwischen Linux oder OSX.

Methode 3

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

So funktioniert das ( Quelle ): Intern werden eventuell interne Betriebssystem-APIs aufgerufen, betriebssystemversionsspezifische Namen wie 'win32' oder 'win16' oder 'linux1' abgerufen und dann auf allgemeinere Namen wie 'Windows' oder 'Linux' oder normalisiert 'Darwin' durch Anwendung mehrerer Heuristiken.

Pro: Beste tragbare Methode für Windows, OSX und Linux.

Con: Python-Leute müssen die Normalisierungsheuristik auf dem neuesten Stand halten.

Zusammenfassung

• Wenn Sie überprüfen möchten, ob das Betriebssystem Windows, Linux oder OSX ist, ist dies der zuverlässigste Weg platform.system().
• Wenn Sie betriebssystemspezifische Aufrufe tätigen möchten, aber über integrierte Python-Module posixoder ntdann verwenden möchtenos.name .
• Wenn Sie den vom Betriebssystem selbst bereitgestellten Namen des unformatierten Betriebssystems erhalten möchten, verwenden Sie sys.platform.

Wie wäre es mit einer neuen Antwort:

import psutil
psutil.MACOS   #True (OSX is deprecated)
psutil.WINDOWS #False
psutil.LINUX   #False 

Dies wäre die Ausgabe, wenn ich MACOS verwenden würde

Ich habe eine etwas systematischere Auflistung der Werte begonnen, die Sie mit den verschiedenen Modulen erwarten können (Sie können Ihr System jederzeit bearbeiten und hinzufügen):

Linux (64 Bit) + WSL

os.name                     posix
sys.platform                linux
platform.system()           Linux
sysconfig.get_platform()    linux-x86_64
platform.machine()          x86_64
platform.architecture()     ('64bit', '')

• versucht mit Archlinux und Minze, bekam die gleichen Ergebnisse
• auf python2 sys.platformwird die Kernel-Version angehängt, z. B. linux2bleibt alles andere identisch
• gleiche Ausgabe unter Windows Subsystem für Linux (versucht mit Ubuntu 18.04 LTS), außer platform.architecture() = ('64bit', 'ELF')

FENSTER (64bit)

(mit 32-Bit-Spalte im 32-Bit-Subsystem)

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

Einige Anmerkungen:

• Es gibt auch eine, distutils.util.get_platform()die mit `sysconfig.get_platform identisch ist
• Anaconda unter Windows ist dasselbe wie das offizielle Python Windows-Installationsprogramm
• Ich habe weder einen Mac noch ein echtes 32-Bit-System und war nicht motiviert, dies online zu tun

Um mit Ihrem System zu vergleichen, führen Sie einfach dieses Skript aus (und fügen Sie die Ergebnisse hier an, wenn sie fehlen :)

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

Ich verwende das mit Weblogic gelieferte WLST-Tool und es implementiert das Plattformpaket nicht.

wls:/offline> import os
wls:/offline> print os.name
java 
wls:/offline> import sys
wls:/offline> print sys.platform
'java1.5.0_11'

Abgesehen vom Patchen des Systems javaos.py ( Problem mit os.system () unter Windows 2003 mit jdk1.5 ) (was ich nicht tun kann, muss ich sofort Weblogic verwenden ), verwende ich Folgendes:

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)

Für Jython der einzige Weg os Name , den ich gefunden zu bekommen , ist zu prüfen , os.nameJava - Eigenschaft (versuchte sys, osund platformModule für Jython 2.5.3 auf 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

Interessante Ergebnisse unter Windows 8:

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

Edit: Das ist ein Fehler

Achten Sie , wenn Sie unter Windows mit Cygwin sind , wo os.nameist posix.

>>> import os, platform
>>> print os.name
posix
>>> print platform.system()
CYGWIN_NT-6.3-WOW

in der gleichen Richtung ....

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

Wenn Sie nicht nach der Kernel-Version usw. suchen, sondern nach der Linux-Distribution, möchten Sie möglicherweise Folgendes verwenden

in 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

in python2.4

>>> import platform
>>> print platform.dist()
('centos', '6.0', 'Final')
>>> print platform.dist()[0]
centos
>>> print platform.dist()[1]
6.0

Dies funktioniert natürlich nur, wenn Sie dies unter Linux ausführen. Wenn Sie ein allgemeineres Skript plattformübergreifend haben möchten, können Sie dies mit Codebeispielen mischen, die in anderen Antworten angegeben sind.

Versuche dies:

import os

os.uname()

und du kannst es schaffen:

info=os.uname()
info[0]
info[1]

Überprüfen Sie die verfügbaren Tests mit der Modulplattform und drucken Sie die Antwort für Ihr System aus:

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

Sie können auch nur das Plattformmodul verwenden, ohne das Betriebssystemmodul zu importieren, um alle Informationen abzurufen.

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

Ein schönes und ordentliches Layout für Berichtszwecke kann mit dieser Zeile erreicht werden:

for i in zip(['system','node','release','version','machine','processor'],platform.uname()):print i[0],':',i[1]

Das gibt diese Ausgabe:

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

Was normalerweise fehlt, ist die Betriebssystemversion, aber Sie sollten wissen, ob Sie Windows, Linux oder Mac ausführen. Eine plattformunabhängige Methode ist die Verwendung dieses Tests:

In []: for i in [platform.linux_distribution(),platform.mac_ver(),platform.win32_ver()]:
   ....:     if i[0]:
   ....:         print 'Version: ',i[0]

Ich weiß, dass dies eine alte Frage ist, aber ich glaube, dass meine Antwort für einige Leute hilfreich sein könnte, die nach einer einfachen, leicht verständlichen pythonischen Methode suchen, um das Betriebssystem in ihrem Code zu erkennen. Getestet auf 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

Wenn Sie macOS X ausführen und ausführen, erhalten platform.system()Sie darwin, da macOS X auf dem Darwin-Betriebssystem von Apple basiert. Darwin ist der Kernel von macOS X und im Wesentlichen macOS X ohne die GUI.

Diese Lösung funktioniert sowohl für pythonals auch jython.

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

Verwenden Sie wie folgt:

import os_identify

print "My OS: " + os_identify.name()

Wie wäre es mit einer einfachen Enum-Implementierung wie der folgenden? Keine Notwendigkeit für externe Bibliotheken!

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

Sie können einfach mit Enum-Wert zugreifen

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

PS Es ist Python3

Sie können sich den Code ansehen, der pyOSinfoTeil des Pip-Date- Pakets ist, um die relevantesten Betriebssysteminformationen aus Ihrer Python-Distribution zu erhalten.

Einer der häufigsten Gründe, warum Benutzer ihr Betriebssystem überprüfen möchten, ist die Terminalkompatibilität und die Verfügbarkeit bestimmter Systembefehle. Leider hängt der Erfolg dieser Überprüfung in gewissem Maße von Ihrer Python-Installation und Ihrem Betriebssystem ab. Ist beispielsweise unamebei den meisten Windows-Python-Paketen nicht verfügbar. Das obige Python-Programm zeigt Ihnen die Ausgabe der am häufigsten verwendeten integrierten Funktionen, die bereits von bereitgestellt wurden os, sys, platform, site.

Der beste Weg, um nur den wesentlichen Code zu erhalten, besteht darin , dies als Beispiel zu betrachten. (Ich denke, ich hätte es einfach hier einfügen können, aber das wäre politisch nicht korrekt gewesen.)

Ich komme zu spät zum Spiel, aber für den Fall, dass jemand es braucht, ist dies eine Funktion, mit der ich meinen Code so anpasse, dass er unter Windows, Linux und MacOs läuft:

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'