Python: Qual OS estou rodando em?

votos
410

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

Publicado 05/08/2008 em 02:23
fonte usuário
Em outras línguas...                            


30 respostas

votos
513

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

A saída platform.system()é como se segue:

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

Veja: plataforma - Acesso a dados de identificação da plataforma subjacente

Respondeu 05/08/2008 em 02:27
fonte usuário

votos
146

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

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

... e eu não posso acreditar que uma postada de ninguém para Windows 10 ainda:

>>> import os
>>> os.name
'nt'
>>> import platform
>>> platform.system()
'Windows'
>>> platform.release()
'10'
Respondeu 05/08/2008 em 02:57
fonte usuário

votos
108

Para o registro é aqui os resultados no Mac:

>>> import os
>>> os.name
'posix'
>>> import platform
>>> platform.system()
'Darwin'
>>> platform.release()
'8.11.1'
Respondeu 05/08/2008 em 03:13
fonte usuário

votos
35

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

>>> import sys
>>> sys.platform
'linux2'
Respondeu 26/08/2008 em 14:41
fonte usuário

votos
17

Eu faço isso

import sys
print sys.platform

Docs aqui: sys.platform .

Tudo que você precisa é provavelmente no módulo sys.

Respondeu 16/02/2009 em 13:43
fonte usuário

votos
10

Eu estou usando a ferramenta WLST que vem com WebLogic, e não implementar o pacote 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'

Além de corrigir o sistema javaos.py ( problema com os.system () no Windows 2003 com jdk1.5 ) (que eu não posso fazer, eu tenho que usar o WebLogic fora da caixa), este é o que eu uso:

def iswindows():
  os = java.lang.System.getProperty( "os.name" )
  return "win" in os.lower()
Respondeu 11/06/2010 em 06:37
fonte usuário

votos
9
>>> import platform
>>> platform.system()
Respondeu 25/06/2011 em 10:10
fonte usuário

votos
5

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")
Respondeu 28/09/2011 em 16:54
fonte usuário

votos
7

/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)
Respondeu 09/10/2011 em 23:11
fonte usuário

votos
8

Para Jython a única maneira de obter o nome OS eu encontrei é verificar os.namepropriedade Java (tentei com sys, ose platformmódulos para 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
Respondeu 09/01/2013 em 06:47
fonte usuário

votos
24

Se você quiser usuário dados legíveis, mas ainda detalhado, você pode usar platform.platform ()

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

Eis algumas chamadas diferentes possíveis que você pode fazer para identificar onde você 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 deste script foi executado em alguns sistemas diferentes estão disponíveis aqui: https://github.com/hpcugent/easybuild/wiki/OS_flavor_name_version

Respondeu 23/01/2013 em 08:55
fonte usuário

votos
6

resultados interessantes no Windows 8:

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

Edit: Isso é um bug

Respondeu 14/02/2013 em 20:44
fonte usuário

votos
5

Se você não está procurando a versão do kernel etc, mas olhando para a distribuição linux você pode querer 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

no python2.4

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

Obviamente, isso só funcionará se você estiver executando isso no linux. Se você quiser ter mais de script genérico em todas as plataformas, você pode misturar isso com exemplos de código dadas em outras respostas.

Respondeu 28/03/2013 em 03:19
fonte usuário

votos
73

código de exemplo para diferenciar usando python do OS:

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
Respondeu 16/09/2014 em 06:42
fonte usuário

votos
3

Verifique os testes disponíveis com plataforma de módulo e imprimir a resposta para fora 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
Respondeu 29/10/2014 em 22:43
fonte usuário

votos
5

tente o seguinte:

import os

os.uname()

e você pode fazê-lo:

info=os.uname()
info[0]
info[1]
Respondeu 16/01/2015 em 16:13
fonte usuário

votos
6

Cuidado se você estiver no Windows com Cygwin onde os.nameé posix.

>>> import os, platform
>>> print os.name
posix
>>> print platform.system()
CYGWIN_NT-6.3-WOW
Respondeu 08/07/2015 em 13:46
fonte usuário

votos
-4

Apenas para completar, variável "OS" ambiente parece ser definido em todos os lugares. No Windows XP / 7/8/10 é definido como "Windows_NT". No Linux SuSE SP2 é definido como "SLES11 linux x86-64 [2]". Eu não tenho acesso a máquinas OS-X ou BSD, seria interessante verificar lá também.

import os

os_name = os.getenv("OS")
if os_name == "Windows_NT":
    # Windows
elif "linux" in os_name:
    # Linux
elif ...
Respondeu 01/12/2015 em 05:28
fonte usuário

votos
3

Você também pode usar somente módulo de plataforma sem importar 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 relatar propósito 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 dá essa 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 você estiver executando Windows, Linux ou Mac uma maneira indipendent plataforma é usar este teste:

In []: for i in [platform.linux_distribution(),platform.mac_ver(),platform.win32_ver()]:
   ....:     if i[0]:
   ....:         print 'Version: ',i[0]
Respondeu 20/08/2016 em 07:03
fonte usuário

votos
1

Use o import ose os.namepalavras-chave.

Respondeu 07/05/2017 em 02:07
fonte usuário

votos
4

Como sobre uma nova resposta:

import psutil
psutil.OSX     #True
psutil.WINDOWS #False
psutil.LINUX   #False 

Esta seria a saída se eu estava usando OSX

Respondeu 14/08/2017 em 16:00
fonte usuário

votos
1

Se você estiver executando o MacOS X e correr platform.system()você começa darwin, porque o MacOS X é construído sobre Darwin OS, da Apple. Darwin é o kernel de MacOS X e é essencialmente MacOS X sem a GUI.

Respondeu 13/01/2018 em 19:29
fonte usuário

votos
0

Como cerca de uma implementação simples Enum como o seguinte? Não há necessidade de libs externa!

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

Respondeu 27/09/2018 em 16:39
fonte usuário

votos
1

Esta solução funciona tanto para 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()
Respondeu 29/01/2019 em 11:06
fonte usuário

votos
2
import sys
import platform

# return a platform identifier
print(sys.platform)

# return system/os name
print(platform.system())

# print system info
# similar to 'uname' command in unix
print(platform.uname())
Respondeu 03/02/2019 em 20:43
fonte usuário

votos
1

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

Uma das razões mais comuns que as pessoas querem verificar o seu sistema operacional é a compatibilidade do terminal e se determinados comandos do sistema estão disponíveis. Infelizmente, o sucesso desta verificação é um pouco dependente da sua instalação python e OS. Por exemplo, unamenão está disponível na maioria dos pacotes python Windows. O programa python acima irá mostrar-lhe a saída das funções internas mais comumente usados, já fornecido pelo os, sys, platform, site.

digite descrição da imagem aqui

Portanto, a melhor maneira de obter apenas o código essencial é olhar para que como um exemplo. (Eu acho que eu poderia ter colado-lo aqui, mas isso não teria sido politicamente correto.)

Respondeu 07/02/2019 em 19:10
fonte usuário

votos
3

Comecei a lista um pouco mais sistemática do que os valores que você pode esperar usando os vários módulos (sinta-se livre 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', '')
  • tentei com archlinux e hortelã, tenho mesmos resultados
  • em python2 sys.platformé sufixo versão do kernel, por exemplo linux2, tudo o resto permanece idêntica
  • mesma saída no Windows Subsistema para Linux (tentei com ubuntu 18.04 LTS), com exceção platform.architecture() = ('64bit', 'ELF')

JANELAS (64 bits)

(Com coluna de 32 bits em execução no subsistema 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:

  • há também distutils.util.get_platform()que é idêntico ao `sysconfig.get_platform
  • anaconda no Windows é o mesmo que o instalador oficial janelas python
  • Eu não tenho um Mac, nem um sistema de 32 bits verdadeiro e não estava motivado para fazê-lo on-line

Para comparar com o seu sistema, basta executar este script (e por favor anexar resultados aqui se ausente :)

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())
Respondeu 23/02/2019 em 00:39
fonte usuário

votos
0

Estou atrasado para o jogo, mas, apenas no caso de alguém precisa dele, esta uma função que eu uso para fazer ajustes no meu código para que ele roda em 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'
Respondeu 22/05/2019 em 15:32
fonte usuário

votos
0

Existem 3 maneiras de obter OS em Python, cada um com a sua própria prós e contras:

Método 1

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

Como isso funciona ( fonte ): Internamente, chama OS APIs para obter o nome do sistema operacional, conforme definido pela OS. Isso pode obviamente mudar de versão para versão, então melhor não usar diretamente. Veja aqui para vários valores específicos do SO.

método 2

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

Como isso funciona ( fonte ): Internamente ele verifica se python tem módulos específicos do SO chamados posix ou nt. Se você deseja importar esses módulos e chamar métodos sobre ele, isso funciona muito bem. Note-se que não há 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 ele acabará por chamar APIs OS internos, obter o nome específico da versão OS como 'win32' ou 'Win16' ou 'linux1' e depois normalizar a nomes mais genéricas como 'Windows' ou 'Linux' ou 'Darwin', aplicando várias heurísticas. Esta é a melhor maneira portátil para obter o nome OS normalizado.

resumo

  • Se você quiser verificar se OS é o Windows ou Linux ou OSX, em seguida, a maneira mais confiável é platform.system().
  • Se você quiser fazer chamadas específicas do sistema operacional, mas através de módulos Python embutidos posixou ntentão usar os.name.
  • Se você quiser obter o nome OS cru conforme fornecido pelo próprio sistema operacional, em seguida, usar sys.platform.
Respondeu 24/09/2019 em 01:28
fonte usuário

votos
0

Eu sei que isto é uma questão antiga, mas acredito que a minha resposta é aquela que pode ser útil para algumas pessoas que estão procurando uma maneira fácil, simples de entender maneira Python para detectar OS em seu 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
Respondeu 22/01/2020 em 16:30
fonte usuário

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more