¿Qué necesito mirar para ver si estoy en Windows o Unix, etc.?

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

La salida de platform.system()es la siguiente:

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

Ver: platform- Acceso a los datos de identificación de la plataforma subyacente.

Dang - lbrandy me ganó, pero eso no significa que no pueda proporcionarle los resultados del sistema para Vista.

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

... y no puedo creer que nadie haya publicado uno para Windows 10 todavía:

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

Para el registro aquí están los resultados en Mac:

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

Código de muestra para diferenciar los sistemas operativos con 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

También puede usarlo sys.platformsi ya ha importado sysy no desea importar otro módulo

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

Si desea datos legibles por el usuario pero aún detallados, puede usar platform.platform ()

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

Aquí hay algunas posibles llamadas diferentes que puede hacer para identificar dónde se encuentra

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

Los resultados de este script se ejecutaron en algunos sistemas diferentes (Linux, Windows, Solaris, MacOS) y las arquitecturas (x86, x64, Itanium, power pc, sparc) están disponibles aquí: https://github.com/hpcugent/easybuild/ wiki / OS_flavor_name_version

El servidor Ubuntu 12.04 por ejemplo da:

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

Cuento

Uso platform.system(). Regresa Windows, Linuxo Darwin(para OSX).

Larga historia

Hay 3 formas de obtener el sistema operativo en Python, cada una con sus propios pros y contras:

Método 1

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

Cómo funciona esto ( fuente ): internamente llama a las API del sistema operativo para obtener el nombre del sistema operativo tal como lo define el sistema operativo. Consulte aquí los distintos valores específicos del sistema operativo.

Pro: Sin magia, bajo nivel.

Con: la versión del sistema operativo depende, por lo que es mejor no usarla directamente.

Método 2

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

Cómo funciona esto ( fuente ): internamente comprueba si python tiene módulos específicos del sistema operativo llamados posix o nt.

Pro: simple para verificar si el sistema operativo posix

Con: no hay diferenciación entre Linux u OSX.

Método 3

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

Cómo funciona esto ( fuente ): internamente eventualmente llamará API internas del sistema operativo, obtendrá un nombre específico de la versión del sistema operativo como 'win32' o 'win16' o 'linux1' y luego se normalizará a nombres más genéricos como 'Windows' o 'Linux' o 'Darwin' aplicando varias heurísticas.

Pro: la mejor forma portátil para Windows, OSX y Linux.

Con: la gente de Python debe mantener la normalización heurística actualizada.

Resumen

• Si desea verificar si el sistema operativo es Windows o Linux o OSX, entonces la forma más confiable es platform.system().
• Si desea realizar llamadas específicas del sistema operativo pero a través de módulos Python incorporados posixo ntluego usar os.name.
• Si desea obtener el nombre del sistema operativo sin procesar tal como lo proporciona el propio sistema operativo, úselo sys.platform.

¿Qué tal una nueva respuesta:

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

Este sería el resultado si estuviera usando MACOS

Comencé una lista un poco más sistemática de los valores que puede esperar utilizando los diversos módulos (no dude en editar y agregar su sistema):

Linux (64 bits) + WSL

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

• probado con archlinux y mint, obtuve los mismos resultados
• en python2 sys.platformtiene el sufijo de la versión del kernel, por ejemplo linux2, todo lo demás permanece idéntico
• mismo resultado en Windows Subsystem para Linux (probado con ubuntu 18.04 LTS), excepto platform.architecture() = ('64bit', 'ELF')

VENTANAS (64 bits)

(con una columna de 32 bits ejecutándose en el subsistema de 32 bits)

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

Algunas observaciones:

• también hay distutils.util.get_platform()que es idéntico a `sysconfig.get_platform
• anaconda en windows es igual que el instalador oficial de python windows
• No tengo una Mac ni un verdadero sistema de 32 bits y no estaba motivado para hacerlo en línea

Para comparar con su sistema, simplemente ejecute este script (y agregue los resultados aquí si faltan :)

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

Estoy usando la herramienta WLST que viene con weblogic y no implementa el paquete de plataforma.

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

Además de parchear el sistema javaos.py ( problema con os.system () en Windows 2003 con jdk1.5 ) (que no puedo hacer, tengo que usar weblogic de fábrica), esto es lo que 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)

Para Jython, la única forma de obtener el nombre del sistema operativo que encontré es verificar os.namela propiedad de Java (probado con sys, osy los platformmódulos para Jython 2.5.3 en 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

Resultados interesantes en Windows 8:

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

Editar: Eso es un error

Tenga cuidado si está en Windows con Cygwin donde os.nameestá posix.

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

en la misma 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")

Si no está buscando la versión del kernel, etc., pero está buscando la distribución de Linux, puede usar lo siguiente

en 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

en python2.4

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

Obviamente, esto funcionará solo si está ejecutando esto en Linux. Si desea tener un script más genérico en todas las plataformas, puede mezclar esto con ejemplos de código proporcionados en otras respuestas.

prueba esto:

import os

os.uname()

y puedes hacerlo:

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

Verifique las pruebas disponibles con la plataforma del módulo e imprima la respuesta para su 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

También puede usar solo el módulo de plataforma sin importar el módulo os para obtener toda la información.

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

Se puede lograr un diseño agradable y ordenado para fines de informes utilizando esta línea:

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

Eso da esta salida:

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

Lo que falta generalmente es la versión del sistema operativo, pero debe saber si está ejecutando Windows, Linux o Mac, una forma independiente de la plataforma es utilizar esta prueba:

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

Sé que esta es una vieja pregunta, pero creo que mi respuesta podría ser útil para algunas personas que buscan una forma pitónica fácil de entender para detectar el sistema operativo en su código. Probado en 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

Si está ejecutando macOS X y se ejecuta platform.system(), obtendrá darwin porque macOS X se basa en el sistema operativo Darwin de Apple. Darwin es el núcleo de macOS X y es esencialmente macOS X sin la GUI.

Esta solución funciona para ambos pythony jython.

módulo 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>" 

Usar así:

import os_identify

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

¿Qué tal una implementación simple de Enum como la siguiente? ¡No hay necesidad de libs externas!

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

Simplemente puede acceder con el valor Enum

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

PD: es python3

Puede ver el código en el pyOSinfoque forma parte del paquete pip-date , para obtener la información más relevante del sistema operativo, como se ve en su distribución de Python.

Una de las razones más comunes por las que las personas quieren verificar su sistema operativo es la compatibilidad de la terminal y si ciertos comandos del sistema están disponibles. Desafortunadamente, el éxito de esta comprobación depende en cierta medida de su instalación y sistema operativo de Python. Por ejemplo, unameno está disponible en la mayoría de los paquetes de Python de Windows. El programa de Python anterior le mostrará el resultado de las funciones integradas más utilizadas, ya proporcionadas por os, sys, platform, site.

Entonces, la mejor manera de obtener solo el código esencial es mirar eso como un ejemplo. (Supongo que podría haberlo pegado aquí, pero eso no habría sido políticamente correcto).

Llego tarde al juego, pero, en caso de que alguien lo necesite, esta es una función que uso para hacer ajustes en mi código para que se ejecute en Windows, Linux y 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'