Em qual SO estou executando?

Respostas:

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

Louis Brandy
fonte
26
Por que eu deveria preferir platformmais sys.platform?
Matth
40
@matth Saída ligeiramente mais consistente. ou seja, platform.system()retorna em "Windows"vez de "win32". sys.platformtambém contém "linux2"versões antigas do Python, enquanto contém apenas as "linux"mais recentes. platform.system()sempre retornou apenas "Linux".
erb
4
No mac os X, platform.system () sempre retorna "Darwin"? ou existe outro caso possível?
baptiste chéné 12/0118
4
@ baptistechéné, eu sei que isso já faz mais de um ano desde que você perguntou, mas como um comentário não vai doer, eu vou postar assim mesmo :) Então, a razão por trás disso é porque mostra o nome do kernel. Da mesma forma que as distribuições do Linux (o kernel) têm muitos nomes (Ubuntu, Arch, Fedora entre outros), mas ele se apresentará como o nome do kernel, Linux. Darwin (um kernel baseado em BSD), tem seu sistema circundante, o macOS. Tenho certeza de que a Apple lançou Darwin como um código-fonte aberto, mas não há outra distro que atropele Darwin que eu conheça.
João Paulo Rabelo
1
O @TooroSan os.uname()existe apenas para sistemas Unix. Os documentos do Python 3: docs.python.org/3/library/os.html Availability: recent flavors of Unix.
Irving Moy
175

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'
Joey deVilla
fonte
6
Windows 7:platform.release() '7'
Hugo
3
Então, sim, eu apenas corri platform.release()no meu Windows 10 , e isso definitivamente me deu '8'. Talvez eu instalei o python antes de atualizar, mas realmente?
precisa saber é o seguinte
2
Eu pensaria que é mais provável que você tenha atualizado do Windows 8 (em comparação com uma instalação limpa) e o que o Python procurar no registro ou o que foi deixado para trás?
OJFord 30/01
2
A pesquisa de lançamento do python no Windows parece usar a função API Win32 GetVersionEx em seu núcleo. As notas no topo deste artigo Microsoft sobre essa função poderia ser relevante: msdn.microsoft.com/en-us/library/windows/desktop/...
theferrit32
126

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'
Mark Harrison
fonte
1
No macOS Catalina 10.15.2, platform.release()retorna'19.2.0'
Boris
95

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
user3928804
fonte
1
Esse código de exemplo é de qualquer módulo python? Esta é a única resposta que de fato responde à pergunta.
precisa saber é
8
Para resultados mais confusos, `` _platform.startswith ('linux')
Klaatu von Schlacker
42

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

>>> import sys
>>> sys.platform
'linux2'
Moe
fonte
Uma das abordagens tem vantagens, além de precisar ou não importar outro módulo?
Matth
O escopo é a principal vantagem. Você deseja o menor número possível de nomes de variáveis ​​globais. Quando você já tem "sys" como um nome global, não deve adicionar outro. Mas se você ainda não usar "sys", usar "_platform" pode ser mais descritivo e menos provável de colidir com outro significado.
precisa saber é o seguinte
33

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: ('', ('', '', ''), '')
Jens Timmerman
fonte
DeprecationWarning: dist() and linux_distribution() functions are deprecated in Python 3.5
Boris
19

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.
Shital Shah
fonte
Tanta coisa para "Deve haver uma (e de preferência apenas uma) maneira de fazer as coisas". No entanto, acredito que esta é a resposta certa. Você precisaria comparar com os nomes de SO com título, mas esse não é um problema e será mais portátil.
vincent-lg
16

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

whackamadoodle3000
fonte
7
psutil não faz parte da lib padrão
Corey Goldberg
14

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())
coldfix
fonte
11

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()
Alftheo
fonte
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)
vida urantial
fonte
3
Bem-vindo ao SO, aqui, é uma boa prática explicar por que usar sua solução e não apenas como. Isso tornará sua resposta mais valiosa e ajudará outros leitores a entender melhor como você faz isso. Sugiro também que você dê uma olhada em nossas Perguntas frequentes: stackoverflow.com/faq .
ForceMagic
Boa resposta, talvez até igual à resposta original. Mas você poderia explicar o porquê.
vgoff
9

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
Michał Niklas
fonte
Você também pode chamar "platform.java_ver ()" para extrair informações do SO no Jython.
DocOc
8

Resultados interessantes no windows 8:

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

Edit: Isso é um bug

Eric
fonte
7

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
kqw
fonte
6

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")
Elden
fonte
9
Isso é problemático se você estiver em um Mac desde platform.system () retorna "Darwin" em um Mac e .lower () "Darwin" encontrar ( "vitória") = 3..
mishaF
is_windows = platform.system (). lower (). beginwith ("win") ou False
Corey Goldberg
6

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.

tomar sol
fonte
4

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
Stefan Gruenwald
fonte
4

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]
GM
fonte
4

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
robmsmt
fonte
2

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.

Alexander Calvert
fonte
2

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()
hoijui
fonte
1

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

Memin
fonte
1

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.

insira a descrição da imagem aqui

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

not2qubit
fonte
1

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'
tudor
fonte