Cosa devo guardare per vedere se sono su Windows o Unix, ecc.?

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

L'output di platform.system()è il seguente:

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

Vedi: platform- Accesso ai dati identificativi della piattaforma sottostante

Dang - lbrandy mi ha battuto sul pugno, ma ciò non significa che non posso fornirti i risultati di sistema per Vista!

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

... e non posso credere che nessuno ne abbia ancora pubblicato uno per Windows 10:

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

Per la cronaca ecco i risultati su Mac:

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

Codice di esempio per differenziare i SO utilizzando 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

Puoi anche usarlo sys.platformse hai già importato syse non vuoi importare un altro modulo

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

Se desideri dati leggibili dall'utente ma ancora dettagliati, puoi utilizzare platform.platform ()

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

Ecco alcune diverse possibili chiamate che puoi effettuare per identificare dove ti trovi

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

I risultati di questo script sono stati eseguiti su alcuni sistemi diversi (Linux, Windows, Solaris, MacOS) e architetture (x86, x64, Itanium, power pc, sparc) è disponibile qui: https://github.com/hpcugent/easybuild/ wiki / OS_flavor_name_version

Il server Ubuntu 12.04 ad esempio fornisce:

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

Storia breve

Usa platform.system(). Si ritorna Windows, Linuxo Darwin(per OSX).

Lunga storia

Esistono 3 modi per ottenere il sistema operativo in Python, ognuno con i suoi pro e contro:

Metodo 1

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

Come funziona ( fonte ): internamente chiama le API del sistema operativo per ottenere il nome del sistema operativo come definito dal sistema operativo. Vedi qui per vari valori specifici del sistema operativo.

Pro: nessuna magia, basso livello.

Con: versione del sistema operativo dipendente, quindi è meglio non usarlo direttamente.

Metodo 2

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

Come funziona ( fonte ): internamente controlla se python ha moduli specifici del sistema operativo chiamati posix o nt.

Pro: semplice da verificare se sistema operativo posix

Contro: nessuna differenziazione tra Linux o OSX.

Metodo 3

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

Come funziona ( fonte ): internamente alla fine chiamerà API interne del sistema operativo, otterrà il nome specifico della versione del sistema operativo come 'win32' o 'win16' o 'linux1' e quindi si normalizzerà con nomi più generici come 'Windows' o 'Linux' o "Darwin" applicando diverse euristiche.

Pro: il miglior modo portatile per Windows, OSX e Linux.

Contro: le persone di Python devono tenere aggiornata l'euristica della normalizzazione.

Sommario

• Se si desidera verificare se il sistema operativo è Windows o Linux o OSX, il modo più affidabile è platform.system().
• Se si desidera effettuare chiamate specifiche del sistema operativo, ma tramite moduli Python integrati posixo ntquindi utilizzare os.name.
• Se si desidera ottenere il nome del SO grezzo come fornito dal SO stesso, utilizzare sys.platform.

Che ne dici di una nuova risposta:

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

Questo sarebbe l'output se stavo usando MACOS

Ho iniziato un elenco un po 'più sistematico di quali valori puoi aspettarti utilizzando i vari moduli (sentiti libero di modificare e aggiungere il tuo sistema):

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

• provato con Archlinux e Mint, ha ottenuto gli stessi risultati
• su python2 sys.platformè suffisso dalla versione del kernel, ad esempio linux2, tutto il resto rimane identico
• stesso output sul sottosistema Windows per Linux (provato con Ubuntu 18.04 LTS), tranne platform.architecture() = ('64bit', 'ELF')

WINDOWS (64 bit)

(con colonna a 32 bit in esecuzione nel sottosistema a 32 bit)

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

Alcune osservazioni:

• c'è anche distutils.util.get_platform()che è identico a `sysconfig.get_platform
• anaconda su windows è lo stesso dell'installer ufficiale di Windows in Python
• Non ho un Mac né un vero sistema a 32 bit e non ero motivato a farlo online

Per confrontare con il tuo sistema, esegui semplicemente questo script (e aggiungi i risultati qui se manca :)

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

Sto usando lo strumento WLST fornito con weblogic e non implementa il pacchetto della piattaforma.

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

Oltre a correggere il sistema javaos.py ( problema con os.system () su Windows 2003 con jdk1.5 ) (cosa che non posso fare, devo usare weblogic out of the box), questo è quello che uso:

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)

Per Jython l'unico modo per ottenere il nome del sistema operativo che ho trovato è quello di verificare os.nameproprietà Java (provato con sys, ose platformmoduli per Jython 2.5.3 su 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

Risultati interessanti su Windows 8:

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

Modifica: è un bug

Fai attenzione se sei su Windows con Cygwin dove si os.nametrova posix.

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

nella stessa vena....

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

Se non stai cercando la versione del kernel ecc., Ma stai cercando la distribuzione di Linux, potresti voler usare quanto segue

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

Ovviamente, questo funzionerà solo se lo stai eseguendo su Linux. Se vuoi avere uno script più generico su più piattaforme, puoi mescolarlo con esempi di codice forniti in altre risposte.

prova questo:

import os

os.uname()

e puoi farcela:

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

Controlla i test disponibili con la piattaforma dei moduli e stampa la risposta per il tuo sistema:

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

È inoltre possibile utilizzare solo il modulo piattaforma senza importare il modulo os per ottenere tutte le informazioni.

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

Con questa riga è possibile ottenere un layout semplice e ordinato a scopo di reportistica:

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

Questo dà questo risultato:

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

Quello che manca di solito è la versione del sistema operativo, ma dovresti sapere se stai usando Windows, Linux o Mac in modo indipendente dalla piattaforma è usare questo test:

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

So che questa è una vecchia domanda, ma credo che la mia risposta possa essere utile per alcune persone che sono alla ricerca di un modo pitonico facile da capire per rilevare il sistema operativo nel loro codice. Testato su 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

Se stai eseguendo macOS X ed esegui platform.system()ottieni darwin perché macOS X è basato sul sistema operativo Darwin di Apple. Darwin è il kernel di macOS X ed è essenzialmente macOS X senza la GUI.

Questa soluzione funziona per entrambi pythone jython.

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

Usa così:

import os_identify

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

Che ne dici di una semplice implementazione di Enum come la seguente? Non c'è bisogno di librerie esterne!

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

Semplicemente puoi accedere con il valore Enum

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

PS È python3

Puoi guardare il codice in pyOSinfocui fa parte del pacchetto pip-date , per ottenere le informazioni più rilevanti sul sistema operativo, come si vede dalla tua distribuzione Python.

Uno dei motivi più comuni per cui le persone desiderano controllare il proprio sistema operativo è la compatibilità dei terminali e la disponibilità di determinati comandi di sistema. Sfortunatamente, il successo di questo controllo dipende in qualche modo dall'installazione e dal sistema operativo di Python. Ad esempio, unamenon è disponibile sulla maggior parte dei pacchetti python di Windows. Il programma python sopra ti mostrerà l'output delle funzioni integrate più comunemente usate, già fornite da os, sys, platform, site.

Quindi il modo migliore per ottenere solo il codice essenziale sta guardando che come esempio. (Immagino che avrei potuto incollarlo qui, ma non sarebbe stato politicamente corretto.)

Sono in ritardo al gioco ma, nel caso in cui qualcuno ne abbia bisogno, questa è una funzione che utilizzo per apportare modifiche al mio codice in modo che funzioni su Windows, Linux e MacOs:

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'