cross platform - Python: sur quel système d'exploitation est-ce que je fonctionne?

Translate

Que dois-je regarder pour voir si je suis sous Windows ou Unix, etc.?

This question and all comments follow the "Attribution Required."

Toutes les réponses

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

La sortie deplatform.system()est comme suit:

  • Linux:Linux
  • Mac:Darwin
  • Les fenêtres:Windows

Voir:plateforme - Accès aux données d'identification de la plateforme sous-jacente

La source
Translate

Dang - lbrandy m'a battu, mais cela ne veut pas dire que je ne peux pas vous fournir les résultats système pour Vista!

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

... et je ne peux pas croire que personne n'en ait encore publié pour Windows 10:

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

Pour mémoire, voici les résultats sur Mac:

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

Exemple de code pour différencier les systèmes d'exploitation à l'aide de 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
La source
Moe
Translate

Vous pouvez également utiliser sys.platform si vous avez déjà importé sys et que vous ne souhaitez pas importer un autre module

>>> import sys
>>> sys.platform
'linux2'
La source
Translate

Si vous voulez des données lisibles par l'utilisateur mais toujours détaillées, vous pouvez utiliserplatform.platform ()

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

Voici quelques appels possibles que vous pouvez passer pour identifier où vous vous trouvez

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

Les sorties de ce script exécutées sur quelques systèmes (Linux, Windows, Solaris, MacOS) et architectures (x86, x64, Itanium, power pc, sparc) sont disponibles ici:https://github.com/hpcugent/easybuild/wiki/OS_flavor_name_version

Le serveur Ubuntu 12.04 par exemple donne:

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

je fais ça

import sys
print sys.platform

Docs ici:sys.platform.

Tout ce dont vous avez besoin se trouve probablement dans le module sys.

La source
Translate

Que diriez-vous d'une nouvelle réponse:

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

Ce serait la sortie si j'utilisais MACOS

La source
Translate

J'utilise l'outil WLST fourni avec weblogic et il n'implémente pas le package de plate-forme.

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

En plus de patcher le systèmejavaos.py (problème avec os.system () sur Windows 2003 avec jdk1.5) (ce que je ne peux pas faire, je dois utiliser weblogic hors de la boîte), voici ce que j'utilise:

def iswindows():
  os = java.lang.System.getProperty( "os.name" )
  return "win" in os.lower()
La source
Translate
>>> import platform
>>> platform.system()
La source
Translate

/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)
La source
Translate

Pour Jython, le seul moyen d'obtenir le nom du système d'exploitation que j'ai trouvé est de vérifieros.namePropriété Java (essayé avecsys, osetplatformmodules pour Jython 2.5.3 sur 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
La source
Translate

J'ai commencé une liste un peu plus systématique des valeurs auxquelles vous pouvez vous attendre en utilisant les différents modules (n'hésitez pas à modifier et à ajouter votre système):

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', '')
  • essayé avec archlinux et menthe, a obtenu les mêmes résultats
  • sur python2sys.platformest suffixé par la version du noyau, par exemplelinux2, tout le reste reste identique
  • même sortie sur le sous-système Windows pour Linux (essayé avec ubuntu 18.04 LTS), saufplatform.architecture() = ('64bit', 'ELF')

WINDOWS (64 bits)

(avec une colonne 32 bits exécutée dans le sous-système 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')

Quelques remarques:

  • il y a aussidistutils.util.get_platform()qui est identique à `sysconfig.get_platform
  • anaconda sur Windows est identique à l'installateur officiel de Windows python
  • Je n'ai pas de Mac ni de véritable système 32 bits et je n'étais pas motivé pour le faire en ligne

Pour comparer avec votre système, exécutez simplement ce script (et veuillez ajouter les résultats ici s'il manque :)

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())
La source
kqw
Translate

Résultats intéressants sur Windows 8:

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

Éditer:C'est unpunaise

La source
Translate

Attention si vous êtes sous Windows avec Cygwin oùos.nameestposix.

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

dans la même veine....

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")
La source
Wilbur Lee
Translate

Si vous ne recherchez pas la version du noyau, etc., mais que vous recherchez la distribution Linux, vous pouvez utiliser ce qui suit

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

De toute évidence, cela ne fonctionnera que si vous l'exécutez sous Linux. Si vous souhaitez avoir un script plus générique sur toutes les plates-formes, vous pouvez le mélanger avec des exemples de code donnés dans d'autres réponses.

La source
Translate

essaye ça:

import os

os.uname()

et vous pouvez le faire:

info=os.uname()
info[0]
info[1]
La source
G M
Translate

Vérifiez les tests disponibles avec la plate-forme du module et imprimez la réponse pour votre système:

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
La source
Translate

Vous pouvez également utiliser uniquement le module de plate-forme sans importer le module os pour obtenir toutes les informations.

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

Une mise en page agréable et ordonnée à des fins de rapport peut être obtenue en utilisant cette ligne:

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

Cela donne cette sortie:

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

Ce qui manque généralement est la version du système d'exploitation, mais vous devez savoir si vous exécutez Windows, Linux ou Mac d'une manière indépendante de la plate-forme est d'utiliser ce test:

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

Si vous exécutez macOS X et exécutezplatform.system()vous obtenez darwin parce que macOS X est construit sur le système d'exploitation Darwin d'Apple. Darwin est le noyau de macOS X et est essentiellement macOS X sans l'interface graphique.

La source
Translate

Cette solution fonctionne pour les deuxpythonetjython.

moduleos_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>" 

Utilisez comme ceci:

import os_identify

print "My OS: " + os_identify.name()
La source
Translate
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())
La source
Translate

Utilisez leimport osetos.namemots clés.

La source
Translate

Que diriez-vous d'une simple implémentation Enum comme celle-ci? Pas besoin de bibliothèques externes!

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

Vous pouvez simplement accéder avec la valeur Enum

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

PS c'est python3

La source
Translate

Vous pouvez consulter le code danspyOSinfoqui fait partie de lapip-datepackage, pour obtenir les informations les plus pertinentes sur le système d'exploitation, comme le montre votre distribution Python.

L'une des raisons les plus courantes pour lesquelles les gens veulent vérifier leur système d'exploitation est la compatibilité du terminal et la disponibilité de certaines commandes système. Malheureusement, le succès de cette vérification dépend quelque peu de votre installation python et de votre système d'exploitation. Par exemple,unamen'est pas disponible sur la plupart des packages python Windows. Le programme python ci-dessus vous montrera la sortie des fonctions intégrées les plus couramment utilisées, déjà fournies paros, sys, platform, site.

enter image description here

Donc, la meilleure façon d'obtenir uniquement le code essentiel consiste à regardercettepar exemple. (Je suppose que j'aurais pu simplement le coller ici, mais cela n'aurait pas été politiquement correct.)

La source
Translate

Je suis en retard au jeu mais, juste au cas où quelqu'un en aurait besoin, c'est une fonction que j'utilise pour faire des ajustements sur mon code afin qu'il fonctionne sous Windows, Linux et 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'
La source