Na co muszę patrzeć, czy korzystam z systemu Windows, Unix itp.?

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

Dane wyjściowe platform.system()są następujące:

• Linux: Linux
• Prochowiec: Darwin
• Windows: Windows

Zobacz: platform- Dostęp do danych identyfikujących platformę bazową

Dang - lbrandy pobił mnie na dobre, ale to nie znaczy, że nie mogę dostarczyć ci wyników systemowych dla Visty!

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

... i nie mogę uwierzyć, że nikt jeszcze nie opublikował takiego dla systemu Windows 10:

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

Dla przypomnienia oto wyniki na Macu:

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

Przykładowy kod do rozróżnienia systemów operacyjnych za pomocą 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

Możesz również użyć, sys.platformjeśli już zaimportowałeś sysi nie chcesz importować innego modułu

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

Jeśli chcesz dane czytelne dla użytkownika, ale wciąż szczegółowe, możesz użyć platform.platform ()

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

Oto kilka różnych możliwych połączeń, które możesz wykonać, aby określić, gdzie jesteś

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

Dane wyjściowe tego skryptu działały na kilku różnych systemach (Linux, Windows, Solaris, MacOS), a architektury (x86, x64, Itanium, power pc, sparc) są dostępne tutaj: https://github.com/hpcugent/easybuild/ wiki / nazwa_smaku_wersji_ OS

Na przykład serwer Ubuntu 12.04 zapewnia:

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

Krótka historia

Zastosowanie platform.system(). Zwraca Windows, Linuxlub Darwin(dla OSX).

Długa historia

Istnieją 3 sposoby uzyskania systemu operacyjnego w Pythonie, każdy z własnymi zaletami i wadami:

Metoda 1

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

Jak to działa ( źródło ): Wewnętrznie wywołuje interfejsy API systemu operacyjnego, aby uzyskać nazwę systemu operacyjnego zdefiniowaną przez system operacyjny. Zobacz tutaj różne wartości specyficzne dla systemu operacyjnego.

Pro: Bez magii, niski poziom.

Con: Zależnie od wersji systemu operacyjnego, więc najlepiej nie używać bezpośrednio.

Metoda 2

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

Jak to działa (źródło ): Wewnętrznie sprawdza, czy python ma moduły specyficzne dla systemu operacyjnego o nazwie posix lub nt.

Pro: Łatwo sprawdzić, czy system operacyjny POSIX

Przeciw: brak rozróżnienia między Linuksem a OSX.

Metoda 3

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

Jak to działa ( źródło ): Wewnętrznie w końcu wywoła wewnętrzne interfejsy API systemu operacyjnego, uzyska nazwę specyficzną dla wersji systemu operacyjnego, taką jak „win32” lub „win16” lub „linux1”, a następnie znormalizuje się do bardziej ogólnych nazw, takich jak „Windows” lub „Linux” lub „Darwin” poprzez zastosowanie kilku heurystyk.

Pro: najlepszy przenośny sposób dla systemów Windows, OSX i Linux.

Przeciw: Ludzie Pythona muszą aktualizować heurystycznie normalizację.

Podsumowanie

• Jeśli chcesz sprawdzić, czy system operacyjny to Windows, Linux lub OSX, najbardziej niezawodnym sposobem jest platform.system() .
• Jeśli chcesz wykonywać połączenia specyficzne dla systemu operacyjnego, ale za pośrednictwem wbudowanych modułów Python, posixa ntnastępnie użyjos.name .
• Jeśli chcesz uzyskać surową nazwę systemu operacyjnego dostarczoną przez sam system operacyjny, użyj sys.platform.

Co powiesz na nową odpowiedź:

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

To byłby wynik, gdybym używał MACOS

Zacząłem nieco bardziej systematyczną listę wartości, których możesz oczekiwać przy użyciu różnych modułów (możesz edytować i dodawać swój system):

Linux (64-bitowy) + WSL

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

• próbowałem z archlinux i miętą, uzyskałem te same wyniki
• na python2 sys.platformjest sufiks wersji jądra, np. linux2wszystko inne pozostaje identyczne
• takie same dane wyjściowe w podsystemie Windows dla systemu Linux (wypróbowano w systemie Ubuntu 18.04 LTS), z wyjątkiem platform.architecture() = ('64bit', 'ELF')

WINDOWS (64-bitowy)

(z kolumną 32-bitową działającą w podsystemie 32-bitowym)

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

Kilka uwag:

• istnieje również distutils.util.get_platform()identyczny z `sysconfig.get_platform
• anakonda w systemie Windows jest taka sama jak oficjalny instalator systemu Windows w Pythonie
• Nie mam komputera Mac ani prawdziwego systemu 32-bitowego i nie miałem motywacji, aby zrobić to online

Aby porównać ze swoim systemem, po prostu uruchom ten skrypt (i dołącz wyniki tutaj, jeśli brakuje :)

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

Korzystam z narzędzia WLST, które jest dostarczane z weblogic i nie implementuje pakietu platformy.

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

Oprócz łatania systemu javaos.py ( problem z os.system () w systemie Windows 2003 za pomocą jdk1.5 ) (czego nie mogę zrobić, muszę używać weblogic od razu po wyjęciu z pudełka), to jest to, czego używam:

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)

Dla Jython jedynym sposobem, aby uzyskać nazwę os znalazłem jest sprawdzenie os.namewłaściwości Java (wypróbowane sys, osa platformmoduły dla Jython 2.5.3 na 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

Ciekawe wyniki w systemie Windows 8:

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

Edycja: To błąd

Uważaj, jeśli korzystasz z systemu Windows z Cygwin, gdzie os.namejest posix.

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

W tej samej żyle....

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

Jeśli nie szukasz wersji jądra itp., Ale szukasz dystrybucji linuksa, możesz skorzystać z poniższych

w 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

w python2.4

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

Oczywiście będzie to działać tylko wtedy, gdy używasz tego na Linuksie. Jeśli chcesz mieć bardziej ogólny skrypt na różnych platformach, możesz połączyć to z przykładowymi kodami podanymi w innych odpowiedziach.

Spróbuj tego:

import os

os.uname()

i możesz to zrobić:

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

Sprawdź dostępne testy z platformą modułów i wydrukuj odpowiedź dla swojego systemu:

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

Możesz również użyć tylko modułu platformy bez importowania modułu systemu operacyjnego, aby uzyskać wszystkie informacje.

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

Przy użyciu tego wiersza można uzyskać ładny i uporządkowany układ do celów sprawozdawczych:

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

To daje ten wynik:

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

Zwykle brakuje wersji systemu operacyjnego, ale powinieneś wiedzieć, jeśli korzystasz z systemu Windows, Linux lub Mac, niezależnym sposobem na skorzystanie z tego testu jest:

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

Wiem, że to stare pytanie, ale wierzę, że moja odpowiedź może być pomocna dla niektórych osób, które szukają łatwego, łatwego do zrozumienia pytonicznego sposobu wykrywania systemu operacyjnego w kodzie. Testowane na 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

Jeśli używasz MacOS X i platform.system()działasz, dostajesz darwin, ponieważ macOS X jest zbudowany na systemie operacyjnym Apple Darwin. Darwin jest jądrem systemu macOS X i zasadniczo jest systemem macOS X bez graficznego interfejsu użytkownika.

To rozwiązanie działa zarówno w przypadku, jak pythoni jython.

moduł 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>" 

Użyj w ten sposób:

import os_identify

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

Co powiesz na prostą implementację Enum, taką jak poniżej? Nie potrzebujesz zewnętrznych bibliotek!

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

Po prostu możesz uzyskać dostęp z wartością Enum

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

PS To jest python3

Możesz spojrzeć na kod, pyOSinfoktóry jest częścią pakietu pip-date , aby uzyskać najbardziej odpowiednie informacje o systemie operacyjnym, jak widać z twojej dystrybucji Pythona.

Jednym z najczęstszych powodów, dla których ludzie chcą sprawdzić swój system operacyjny, jest zgodność terminala i dostępność niektórych poleceń systemowych. Niestety powodzenie tego sprawdzania zależy w pewnym stopniu od instalacji Pythona i systemu operacyjnego. Na przykład unamenie jest dostępny w większości pakietów Windows python. Powyższy program python wyświetli dane wyjściowe najczęściej używanych funkcji wbudowanych, już dostarczonych przez os, sys, platform, site.

Zatem najlepszym sposobem na uzyskanie tylko niezbędnego kodu jest spojrzenie na to jako przykład. (Chyba mógłbym go tutaj wkleić, ale nie byłoby to politycznie poprawne).

Spóźniłem się z grą, ale na wypadek, gdyby ktokolwiek jej potrzebował, jest to funkcja, której używam do wprowadzania poprawek w moim kodzie, aby działał w systemach Windows, Linux i MacO:

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'