¿En qué sistema operativo estoy ejecutando?

Respuestas:

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

Louis Brandy
fuente
26
¿Por qué debería preferir platformmás sys.platform?
Mt
40
@matth Salida ligeramente más consistente. es decir, platform.system()devuelve en "Windows"lugar de "win32". sys.platformtambién contiene "linux2"versiones antiguas de Python, mientras que solo contiene versiones más "linux"recientes. platform.system()siempre ha regresado justo "Linux".
erb
44
En mac os X, ¿platform.system () siempre devuelve "Darwin"? o hay otro caso posible?
Baptiste Chéné
44
@ Baptistechéné, sé que esto ha pasado más de un año desde que lo pediste, pero como un comentario no va a doler, lo publicaré de todos modos :) Entonces, la razón detrás de esto es porque muestra el nombre del núcleo. De la misma manera que las distribuciones de Linux (el núcleo) tienen muchos nombres (Ubuntu, Arch, Fedora entre otros), pero se presentará como el nombre del núcleo, Linux. Darwin (un kernel basado en BSD) tiene su sistema circundante, el macOS. Estoy bastante seguro de que Apple lanzó Darwin como un código fuente abierto, pero no conozco ninguna otra distribución que se ejecute sobre Darwin.
Joao Paulo Rabelo
1
@TooroSan os.uname()solo existe para sistemas Unix. Los documentos de Python 3: docs.python.org/3/library/os.html Availability: recent flavors of Unix.
Irving Moy
175

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'
Joey deVilla
fuente
66
Windows 7:platform.release() '7'
Hugo
3
Entonces, sí, acabo de ejecutar platform.release()mi Windows 10 , y definitivamente me dio '8'. Tal vez instalé Python antes de actualizar, ¿pero realmente?
Codesmith
2
¿Pensé que es más probable que haya actualizado desde Windows 8 (en comparación con una instalación limpia) y lo que Python busque en el registro o lo que quedó?
OJFord
2
La búsqueda de lanzamiento de Python en Windows parece utilizar la función de API Win32 GetVersionEx en su núcleo. Las notas en la parte superior de este artículo de Microsoft sobre esa función podrían ser relevantes: msdn.microsoft.com/en-us/library/windows/desktop/…
theferrit32
126

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

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
usuario3928804
fuente
1
¿Es este código de muestra de algún módulo de Python? Esta es la única respuesta que de hecho responde a la pregunta.
kon psych
8
Para obtener resultados más difusos, `` _platform.startswith ('linux')
Klaatu von Schlacker,
42

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

>>> import sys
>>> sys.platform
'linux2'
Moe
fuente
¿Tiene alguno de los enfoques alguna ventaja, además de tener que importar o no importar otro módulo?
Mt
El alcance es la principal ventaja. Desea la menor cantidad posible de nombres de variables globales. Cuando ya tiene "sys" como nombre global, no debe agregar otro. Pero si aún no usa "sys", usar "_platform" podría ser más descriptivo y menos propenso a chocar con otro significado.
sanderd17
33

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

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.
Shital Shah
fuente
Esto en cuanto a "Debería haber una (y preferiblemente solo una) forma de hacer las cosas". Sin embargo, creo que esta es la respuesta correcta. Debería comparar con los nombres de SO titulados, pero no es un problema y será más portátil.
vincent-lg
16

¿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

whackamadoodle3000
fuente
77
psutil no es parte de la lib estándar
Corey Goldberg
14

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

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()
Alftheo
fuente
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)
urantialife
fuente
3
Bienvenido a SO, aquí, es una buena práctica explicar por qué usar su solución y no solo cómo. Eso hará que su respuesta sea más valiosa y ayudará al lector a comprender mejor cómo lo hace. También sugiero que eche un vistazo a nuestras preguntas frecuentes: stackoverflow.com/faq .
ForceMagic
Buena respuesta, tal vez incluso a la par con la respuesta original. Pero podrías explicar por qué.
vgoff
9

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
Michał Niklas
fuente
También puede llamar a "platform.java_ver ()" para extraer información del sistema operativo en Jython.
DocOc
8

Resultados interesantes en Windows 8:

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

Editar: Eso es un error

Eric
fuente
7

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

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")
Elden
fuente
99
Esto es problemático si está en una Mac ya que platform.system () devuelve "Darwin" en una Mac y "Darwin" .lower (). Find ("win") = 3.
mishaF
is_windows = platform.system (). lower (). comienza con ("win") o False
Corey Goldberg
6

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.

sunil
fuente
4

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

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

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

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.

Alexander Calvert
fuente
2

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

¿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

Memin
fuente
1

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.

ingrese la descripción de la imagen aquí

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

not2qubit
fuente
1

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