O que eu preciso olhar para ver se estou no Windows ou Unix, etc?

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

A saída de platform.system()é a seguinte:

• Linux: Linux
• Mac: Darwin
• Janelas: Windows

Consulte: platform- Acesso aos dados de identificação da plataforma subjacente

Dang - lbrandy me venceu, mas isso não significa que não posso fornecer os resultados do sistema para o Vista!

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

... e não acredito que ninguém postou um para o Windows 10 ainda:

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

Para o registro, aqui estão os resultados no Mac:

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

Exemplo de código para diferenciar sistemas operacionais usando 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

Você também pode usar sys.platformse você já importou syse não deseja importar outro módulo

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

Se você quiser dados legíveis pelo usuário, mas ainda detalhados, use platform.platform ()

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

Aqui estão algumas chamadas possíveis diferentes que você pode fazer para identificar onde está

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

As saídas desse script foram executadas em alguns sistemas diferentes (Linux, Windows, Solaris, MacOS) e arquiteturas (x86, x64, Itanium, power pc, sparc) estão disponíveis aqui: https://github.com/hpcugent/easybuild/ wiki / OS_flavor_name_version

O servidor Ubuntu 12.04, por exemplo, fornece:

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

História curta

Use platform.system(). Retorna Windows, Linuxou Darwin(para OSX).

Longa história

Existem três maneiras de obter o SO no Python, cada uma com seus próprios prós e contras:

Método 1

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

Como isso funciona ( origem ): Internamente, ele chama APIs do SO para obter o nome do SO, conforme definido pelo SO. Veja aqui para vários valores específicos do SO.

Pro: Sem mágica, nível baixo.

Con: Depende da versão do SO, por isso é melhor não usar diretamente.

Método 2

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

Como isso funciona ( fonte ): Internamente, verifica se o python possui módulos específicos do sistema operacional chamados posix ou nt.

Pro: simples para verificar se o sistema operacional posix

Con: sem diferenciação entre Linux ou OSX.

Método 3

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

Como isso funciona ( fonte ): Internamente, eventualmente chamará APIs de SO internas, obterá o nome específico da versão do SO, como 'win32' ou 'win16' ou 'linux1' e, em seguida, normalizará para nomes mais genéricos como 'Windows' ou 'Linux' ou 'Darwin', aplicando várias heurísticas.

Pro: a melhor maneira portátil para Windows, OSX e Linux.

Contras: O pessoal do Python deve manter a heurística da normalização atualizada.

Sumário

• Se você deseja verificar se o sistema operacional é Windows ou Linux ou OSX, a maneira mais confiável é platform.system().
• Se você deseja fazer chamadas específicas do sistema operacional, mas via módulos Python internos, posixou ntentão use os.name.
• Se você deseja obter o nome bruto do sistema operacional, conforme fornecido pelo próprio sistema operacional, use sys.platform.

Que tal uma nova resposta:

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

Essa seria a saída se eu estivesse usando o MACOS

Comecei uma lista um pouco mais sistemática de quais valores você pode esperar usando os vários módulos (fique à vontade para editar e adicionar seu 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', '')

• experimentado com archlinux e mint, obteve os mesmos resultados
• no python2 sys.platformé sufixado pela versão do kernel, por exemplo linux2, todo o resto permanece idêntico
• mesma saída no Windows Subsystem para Linux (experimentada com o ubuntu 18.04 LTS), exceto platform.architecture() = ('64bit', 'ELF')

WINDOWS (64 bits)

(com a coluna de 32 bits em execução no 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')

Algumas observações:

• existe também o distutils.util.get_platform()que é idêntico ao `sysconfig.get_platform
• anaconda no windows é o mesmo que o instalador oficial do windows python
• Não tenho um Mac nem um verdadeiro sistema de 32 bits e não estava motivado para fazê-lo online

Para comparar com o seu sistema, basta executar este script (e, por favor, acrescente os resultados aqui, se estiver faltando :)

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

Estou usando a ferramenta WLST que acompanha o weblogic e ela não implementa o pacote da plataforma.

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

Além de corrigir o sistema javaos.py ( problema com os.system () no Windows 2003 com jdk1.5 ) (o que não posso fazer, preciso usar o weblogic pronto), é isso que eu 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 o Jython, a única maneira de obter o nome do sistema operacional que encontrei é verificar a os.namepropriedade Java (experimentada com sys, ose platformmódulos para o Jython 2.5.3 no 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 interessantes no windows 8:

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

Edit: Isso é um bug

Cuidado se você estiver no Windows com Cygwin, onde os.nameestá posix.

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

Na mesma veia....

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 você não procura a versão do kernel, etc, mas procura a distribuição linux, pode usar o seguinte

em 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

em python2.4

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

Obviamente, isso funcionará apenas se você estiver executando isso no linux. Se você deseja ter um script mais genérico entre plataformas, pode misturar isso com exemplos de código fornecidos em outras respostas.

tente isto:

import os

os.uname()

e você pode fazer isso:

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

Verifique os testes disponíveis com a plataforma do módulo e imprima a resposta para o seu 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

Você também pode usar apenas o módulo da plataforma sem importar o módulo os para obter todas as informações.

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

Um layout agradável e arrumado para fins de geração de relatórios pode ser alcançado usando esta linha:

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

Isso fornece esta saída:

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

O que está faltando geralmente é a versão do sistema operacional, mas você deve saber se está executando o windows, linux ou mac de uma maneira independente da plataforma é usar este teste:

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

Sei que essa é uma pergunta antiga, mas acredito que minha resposta seja útil para algumas pessoas que procuram uma maneira python simples e fácil de entender para detectar o SO no código. Testado em 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 você estiver executando o macOS X e for executado, platform.system()obterá o darwin porque o macOS X foi desenvolvido no Darwin OS da Apple. Darwin é o núcleo do macOS X e é essencialmente o macOS X sem a GUI.

Esta solução funciona para ambos pythone 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>" 

Use assim:

import os_identify

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

Que tal uma implementação simples do Enum como a seguir? Não há necessidade de bibliotecas 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

Simplesmente você pode acessar com o valor Enum

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

PS É python3

Você pode olhar o código no pyOSinfoqual faz parte do pacote pip-date , para obter as informações mais relevantes do sistema operacional, como visto na sua distribuição Python.

Uma das razões mais comuns pelas quais as pessoas desejam verificar seu sistema operacional é a compatibilidade do terminal e se determinados comandos do sistema estão disponíveis. Infelizmente, o sucesso dessa verificação depende um pouco da instalação e do sistema operacional python. Por exemplo, unamenão está disponível na maioria dos pacotes python do Windows. O programa python acima mostrará a saída das funções internas mais usadas, já fornecidas por os, sys, platform, site.

Portanto, a melhor maneira de obter apenas o código essencial é considerá- lo um exemplo. (Acho que poderia ter colado aqui, mas isso não teria sido politicamente correto.)

Estou atrasado para o jogo, mas, caso alguém precise, essa é uma função que eu uso para fazer ajustes no meu código para que ele seja executado no 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'