cross platform - Python: Auf welchem Betriebssystem laufe ich?

Translate

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

This question and all comments follow the "Attribution Required."

Alle Antworten

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

Die Ausgabe vonplatform.system()ist wie folgt:

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

Sehen:Plattform - Zugriff auf die Identifizierungsdaten der zugrunde liegenden Plattform

Quelle
Translate

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'
Quelle
Translate

Für die Aufzeichnung hier die Ergebnisse auf Mac:

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

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
Quelle
Moe
Translate

Sie können sys.platform auch verwenden, wenn Sie sys bereits importiert haben und kein anderes Modul importieren möchten

>>> import sys
>>> sys.platform
'linux2'
Quelle
Translate

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

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

Ich mache das

import sys
print sys.platform

Docs hier:sys.platform.

Alles, was Sie brauchen, befindet sich wahrscheinlich im sys-Modul.

Quelle
Translate

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

Quelle
Translate

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 Systemsjavaos.py (Problem mit os.system () unter Windows 2003 mit jdk1.5) (was ich nicht kann, ich muss sofort Weblogic verwenden), das ist was ich benutze:

def iswindows():
  os = java.lang.System.getProperty( "os.name" )
  return "win" in os.lower()
Quelle
Translate
>>> import platform
>>> platform.system()
Quelle
Translate

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

Für Jython ist die einzige Möglichkeit, den von mir gefundenen OS-Namen zu erhalten, die Überprüfungos.nameJava-Eigenschaft (versucht mitsys, osundplatformModule für Jython 2.5.3 unter 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
Quelle
Translate

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 python2sys.platformwird durch die Kernel-Version angehängt, zlinux2alles andere bleibt identisch
  • gleiche Ausgabe unter Windows Subsystem für Linux (versucht mit Ubuntu 18.04 LTS), außerplatform.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 auchdistutils.util.get_platform()Das ist identisch mit `sysconfig.get_platform
  • 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, falls 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())
Quelle
kqw
Translate

Interessante Ergebnisse unter Windows 8:

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

Bearbeiten:Das ist einFehler

Quelle
Translate

Achten Sie darauf, ob Sie mit Cygwin unter Windows arbeitenos.nameistposix.

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

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")
Quelle
Wilbur Lee
Translate

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.

Quelle
Translate

Versuche dies:

import os

os.uname()

und du kannst es schaffen:

info=os.uname()
info[0]
info[1]
Quelle
G M
Translate

Ü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
Quelle
Translate

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]
Quelle
Translate

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

Quelle
Translate

Diese Lösung funktioniert für beidepythonundjython.

Modulos_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()
Quelle
Translate
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())
Quelle
Translate

Verwenden Sie dieimport osundos.nameSchlüsselwörter.

Quelle
Translate

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

Quelle
Translate

Sie können sich den Code in ansehenpyOSinfoDas ist ein Teil derPip-DatePaket, 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 etwas von Ihrer Python-Installation und Ihrem Betriebssystem ab. Zum Beispiel,unameist in 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 wurdenos, sys, platform, site.

enter image description here

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

Quelle
Translate

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