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

Producția de platformă.sistemul()` este după cum urmează:

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

A se vedea: platforma de Acces a platformei de bază datelor de identificare

Dang -- lbrandy mă bate la pumn, dar asta nu't înseamnă că pot't oferi cu sistem de rezultate pentru Vista!

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

...și nu pot să cred că nimeni nu a postat nimeni pentru Windows 10 încă:

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

Pentru a înregistra aici's rezultatele pe Mac:

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

Mostre de cod pentru a diferenția OS's utilizarea 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

Puteți folosi, de asemenea, sys.platforma dacă aveți deja importate sys și nu't doriți să importați un alt modul

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

Dacă doriți utilizator date pot fi citite, dar mai detaliate, puteți utiliza platforma.platforma()

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

Aici's câteva posibile diferite apeluri puteți face pentru a identifica în cazul în care sunt

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

Ieșirile de acest script a fugit pe câteva sisteme diferite (Linux, Windows, Solaris, MacOS) și arhitecturi (x86, x64, Itanium, power pc, sparc) este disponibil aici: https://github.com/hpcugent/easybuild/wiki/OS_flavor_name_version

Ubuntu 12.04 server, de exemplu, vă oferă:

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

Cât despre un nou răspuns:

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

Aceasta ar fi cea de ieșire dacă am fost folosind MACOS

Eu sunt, folosind WLST instrument care vine cu weblogic, și nu't implementa platforma pachet.

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

În afară de patch-uri de sistem javaos.py (problema cu sistemul de operare.sistemul() pe windows 2003 cu jdk1.5) (care nu pot't face, trebuie să utilizați weblogic afară de la cutie), acest lucru este ceea ce am folosi:

def iswindows():
  os = java.lang.System.getProperty( "os.name" )
  return "win" in os.lower()

Pentru Jython singura modalitate de a obține nume de sistem de operare am găsit este de a verifica os.numele Java proprietate (incercat cu sys, `os " și " platforma de module pentru Jython 2.5.3 pe 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

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

Am început un pic mai sistematică listă de ce valori vă puteți aștepta folosind diverse module (simțiți-vă liber pentru a edita și adăuga sistemul dvs.):

Linux (64bit) + WSL

sistem de operare.numele posix sys.platforma linux platforma.sistemul() Linux sysconfig.get_platform() linux-x86_64 platforma.machine() x86_64 platforma.arhitectura() ('64bit', '')

• a încercat cu archlinux si menta, are aceleași rezultate
• pe python2 sys.platforma este terminația de versiunea de kernel, de exemplu, linux2, totul rămâne identic
• aceeași ieșire de pe Windows Subsistem pentru Linux (incercat cu ubuntu 18.04 LTS), cu excepția platformei.arhitectura() = ('64bit', 'ELF')`

WINDOWS (pe 64 de biți)

(cu 32 de biți coloana de funcționare în 32 de biți subsistem)

`` oficial python instalare pe 64 de biți pe 32 de biți

sistem de operare.numele nt nt sys.platforma win32 win32 platforma.sistemul() Windows Windows sysconfig.get_platform() win-amd64 win32 platforma.machine() AMD64 AMD64 platforma.arhitectura() ('64bit', 'WindowsPE') ('64bit', 'WindowsPE')

msys2 64 de biți pe 32 de biți

sistem de operare.numele posix posix sys.platforma msys msys platforma.sistemul() MSYS_NT-10.0 MSYS_NT-10.0-WOW sysconfig.get_platform() msys-2.11.2-x86_64 msys-2.11.2-i686 platforma.machine() x86_64 i686 platforma.arhitectura() ('64bit', 'WindowsPE') ('32bit', 'WindowsPE')

msys2 mingw-w64-x86_64-python3 mingw-w64-i686-python3

sistem de operare.numele nt nt sys.platforma win32 win32 platforma.sistemul() Windows Windows sysconfig.get_platform() mingw mingw platforma.machine() AMD64 AMD64 platforma.arhitectura() ('64bit', 'WindowsPE') ('32bit', 'WindowsPE')

cygwin pe 64 de biți pe 32 de biți

sistem de operare.numele posix posix sys.platforma cygwin cygwin platforma.sistemul() CYGWIN_NT-10.0 CYGWIN_NT-10.0-WOW sysconfig.get_platform() cygwin-3.0.1-x86_64 cygwin-3.0.1-i686 platforma.machine() x86_64 i686 platforma.arhitectura() ('64bit', 'WindowsPE') ('32bit', 'WindowsPE')

``

Câteva observații:

• există, de asemenea, distutils.util.get_platform() care este identică cu `sysconfig.get_platform
• anaconda pe windows este același ca oficial python windows installer
• Eu nu't au un Mac și nici o adevărată 32 de biți sistem și nu a fost motivat pentru a face on-line

Pentru a compara cu sistemul dvs., pur și simplu rulați acest script (și vă rog să adăugați rezultatele aici dacă lipsesc :)

`` din viitoarele import print_function import os import sys import platforma import sysconfig

de imprimare("sistem de operare.numele ", os.numele) de imprimare("sys.platforma ", sys.platforma) de imprimare("platforma.sistemul() ", platforma.sistemul()) de imprimare("sysconfig.get_platform() ", sysconfig.get_platform()) de imprimare("platforma.machine() ", platforma.machine()) de imprimare("platforma.arhitectura() ", platforma.arhitectura()) ``

Ai grija daca're pe Windows cu Cygwin unde os.numele "este" posix.

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

Rezultate interesante pe windows 8:

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

Edit: Care's o bug

în aceeași ordine de idei....

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

Dacă nu sunteți în căutarea pentru versiunea de kernel, etc, dar în căutarea pentru distributie de linux, poate doriți să utilizați următoarele

în 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

în python2.4

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

Evident, acest lucru va funcționa numai dacă se execută pe linux. Dacă doriți să aveți mai generic script pe platforme, puteți amesteca cu mostre de cod dat alte răspunsuri.

încercați acest lucru:

import os

os.uname()

și tu poți face asta :

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

Există 3 moduri de a obține OPERARE în Python, fiecare cu propriile sale pro și contra:

Metoda 1

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

Cum funcționează (sursa): pe plan Intern se numește sistem de OPERARE Api-uri pentru a obține numele de OPERARE, astfel cum sunt definite de sistemul de OPERARE. Acest lucru se poate schimba în mod evident de la o versiune la alta, așa că mai bine să nu utilizeze în mod direct. A se vedea aici pentru diferite OS-valori specifice.

Metoda 2

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

Cum funcționează (sursa): pe plan Intern se verifică dacă python are OS-module specifice numite posix sau nt. Dacă doriți să importați aceste module și metodele de apel pe ea, acest lucru funcționează foarte bine. Rețineți că nu există nici o diferențiere între Linux sau OSX.

Metoda 3

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

Cum funcționează (sursa): pe plan Intern, se va apela în cele din urmă interne de OPERARE Api-uri, pentru a primi versiunea sistemului de OPERARE-nume specific ca 'win32' sau 'win16' sau 'linux1' si apoi normalizarea la mai multe nume generice ca 'Windows' sau 'Linux' sau 'Darwin' prin aplicarea de mai multe euristici. Acesta este cel mai bun mod portabil pentru a obține normalizat nume de sistem de OPERARE.

Sumar

• Dacă doriți să verificați dacă sistemul de OPERARE este Windows sau Linux sau OSX atunci cel mai sigur mod este de platformă.sistemul()`.
• Dacă doriți pentru a face sistemul de OPERARE specifice apeluri, dar prin intermediul built-in module Python posix sau nt apoi utilizați os.numele.
• Dacă doriți să obțineți prime nume de sistem de OPERARE cum este furnizat de către sistemul de OPERARE în sine, atunci folosesc sys.platforma`.

Verifica testele disponibile cu modul de platformă și de imprimare răspunsul pentru sistemul dvs.:

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

De asemenea, puteți utiliza numai platform module fără importul de operare, modul de a obține toate informațiile.

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

Un frumos și îngrijit aspect de raportare scop poate fi realizat folosind această linie:

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

Care vă oferă această ieșire:

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

Ceea ce lipsește de obicei este versiunea sistemului de operare, dar ar trebui să știi dacă executați windows, linux sau mac o platformă independentă mod este de a utiliza acest test:

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

Această soluție funcționează atât pentru python " și " jython.

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

Folosi astfel:

import os_identify

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