Na jakim systemie operacyjnym korzystam?

Odpowiedzi:

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

Louis Brandy
źródło
26
Dlaczego warto Wolę platformponad sys.platform?
matth
40
@matth Nieco bardziej spójne wyjście. tzn. platform.system()zwraca "Windows"zamiast "win32". sys.platformzawiera również "linux2"na starszych wersjach Pythona, podczas gdy zawiera tylko "linux"na nowsze. platform.system()zawsze wrócił właśnie "Linux".
erb
4
W systemie Mac OS X platforma.system () zawsze zwraca „Darwin”? czy jest możliwy inny przypadek?
baptiste chéné
4
@ baptistechéné, wiem, że ma to ponad rok, odkąd poprosiłeś, ale jako komentarz nie zaszkodzi, i tak opublikuję :) Więc powodem jest to, że pokazuje nazwę jądra. W ten sam sposób dystrybucje Linuksa (jądra) mają wiele nazw (między innymi Ubuntu, Arch, Fedora), ale będą się prezentować jako nazwa jądra, Linux. Darwin (jądro oparte na BSD) ma swój system otaczający, macOS. Jestem prawie pewien, że Apple wypuściło Darwina jako kod open source, ale nie ma innej dystrybucji działającej nad Darwinem, o której wiem.
Joao Paulo Rabelo
1
@TooroSan os.uname()istnieje tylko dla systemów uniksowych. Dokumenty Python 3: docs.python.org/3/library/os.html Availability: recent flavors of Unix.
Irving Moy
175

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'
Joey deVilla
źródło
6
Windows 7:platform.release() '7'
Hugo,
3
Tak, tak, ja po prostu zabrakło platform.release()na moim systemie Windows 10 , a na pewno po prostu dał mi '8'. Być może zainstalowałem Pythona przed aktualizacją, ale naprawdę?
Codesmith,
2
Myślałem, że bardziej prawdopodobne jest uaktualnienie systemu Windows 8 (w porównaniu z czystą instalacją) i cokolwiek Python wyszukuje w rejestrze lub cokolwiek pozostało?
OJFord
2
Wygląda na to, że w wersji dla Pythona w systemie Windows używana jest funkcja API apI Win32 GetVersionEx. Uwagi na górze tego artykułu Microsoft na temat tej funkcji mogą być istotne: msdn.microsoft.com/en-us/library/windows/desktop/…
theferrit32
126

Dla przypomnienia oto wyniki na Macu:

>>> import os
>>> os.name
'posix'
>>> import platform
>>> platform.system()
'Darwin'
>>> platform.release()
'8.11.1'
Mark Harrison
źródło
1
Na MacOS Catalina 10.15.2 platform.release()powraca'19.2.0'
Boris
95

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
użytkownik3928804
źródło
1
Czy ten przykładowy kod z dowolnego modułu python? To jedyna odpowiedź, która w rzeczywistości odpowiada na pytanie.
kon psych
8
Aby uzyskać bardziej skomplikowane wyniki, `` _platform.startswith ('linux')
Klaatu von Schlacker
42

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

>>> import sys
>>> sys.platform
'linux2'
Moe
źródło
Czy jedno z podejść ma jakieś zalety oprócz konieczności importowania innego modułu?
matth
Główną zaletą jest zakres. Chcesz mieć jak najmniej globalnych nazw zmiennych, jak to możliwe. Kiedy już masz „sys” jako globalną nazwę, nie powinieneś dodawać kolejnej. Ale jeśli nie używasz jeszcze „sys”, użycie „_platform” może być bardziej opisowe i mniej prawdopodobne, że zderzy się z innym znaczeniem.
sanderd17,
33

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: ('', ('', '', ''), '')
Jens Timmerman
źródło
DeprecationWarning: dist() and linux_distribution() functions are deprecated in Python 3.5
Boris
19

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.
Shital Shah
źródło
Tyle o „Powinien istnieć jeden (a najlepiej tylko jeden) sposób robienia rzeczy”. Uważam jednak, że to właściwa odpowiedź. Trzeba by porównać z nazwanymi nazwami systemów operacyjnych, ale to nie jest taki problem i będzie bardziej przenośny.
vincent-lg
16

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

whackamadoodle3000
źródło
7
psutil nie jest częścią standardowej biblioteki
Corey Goldberg
14

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())
coldfix
źródło
11

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()
Alftheo
źródło
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)
urantialife
źródło
3
Witamy w SO, tutaj dobrą praktyką jest wyjaśnienie, dlaczego warto korzystać z rozwiązania, a nie tylko jak. To sprawi, że twoja odpowiedź będzie bardziej wartościowa i pomoże czytelnikowi lepiej zrozumieć, w jaki sposób to robisz. Sugeruję również zajrzenie do naszego FAQ: stackoverflow.com/faq .
ForceMagic,
Dobra odpowiedź, może nawet na równi z oryginalną odpowiedzią. Ale możesz wyjaśnić dlaczego.
vgoff,
9

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
Michał Niklas
źródło
Możesz także wywołać „platform.java_ver ()”, aby wyodrębnić informacje o systemie operacyjnym w Jython.
DocOc,
8

Ciekawe wyniki w systemie Windows 8:

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

Edycja: To błąd

Eric
źródło
7

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
kqw
źródło
6

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")
Elden
źródło
9
Jest to problematyczne, jeśli korzystasz z komputera Mac, ponieważ platforma.system () zwraca „Darwin” na komputerze Mac, a „Darwin” .lower (). Find („win”) = 3.
mishaF 19.04.13
is_windows = platform.system (). lower (). zaczyna się od („win”) lub False
Corey Goldberg
6

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.

sunil
źródło
4

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
Stefan Gruenwald
źródło
4

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]
GM
źródło
4

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
robmsmt
źródło
2

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.

Alexander Calvert
źródło
2

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()
hoijui
źródło
1

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

Memin
źródło
1

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.

wprowadź opis zdjęcia tutaj

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

not2qubit
źródło
1

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'
Tudor
źródło