Python: Wat OS vlucht ik aan de hand?

stemmen
410

Wat heb ik nodig om naar te kijken om te zien of ik op Windows, Unix, etc?

De vraag is gesteld op 05/08/2008 om 04:23
bron van user
In andere talen...                            


29 antwoorden

stemmen
513

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

Het uitgangssignaal van platform.system()is als volgt:

  • Linux: Linux
  • Mac: Darwin
  • Ramen: Windows

Zie ook: platform - Toegang tot identificerende gegevens onderliggende platform

antwoordde op 05/08/2008 om 04:27
bron van user

stemmen
146

Dang - lbrandy sloeg me om de punch, maar dat betekent niet dat ik kan u niet voorzien van het systeem resultaten voor Vista!

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

... en ik kan niet geloven dat niemand Geplaatst een voor Windows 10 nog:

>>> import os
>>> os.name
'nt'
>>> import platform
>>> platform.system()
'Windows'
>>> platform.release()
'10'
antwoordde op 05/08/2008 om 04:57
bron van user

stemmen
108

Voor de goede orde is hier de resultaten op de Mac:

>>> import os
>>> os.name
'posix'
>>> import platform
>>> platform.system()
'Darwin'
>>> platform.release()
'8.11.1'
antwoordde op 05/08/2008 om 05:13
bron van user

stemmen
73

Sample code om OS met behulp van python te onderscheiden:

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
antwoordde op 16/09/2014 om 08:42
bron van user

stemmen
35

U kunt ook sys.platform gebruiken als u al sys hebt geïmporteerd en u niet wilt naar een andere module te importeren

>>> import sys
>>> sys.platform
'linux2'
antwoordde op 26/08/2008 om 16:41
bron van user

stemmen
24

Als u gebruiker leesbare gegevens, maar toch gedetailleerde wilt, kunt u gebruik maken van platform.platform ()

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

Hier zijn een paar verschillende mogelijke gesprekken die u kunt maken om te bepalen waar je bent

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

De uitgangen van dit script liep op een aantal verschillende systemen is hier beschikbaar: https://github.com/hpcugent/easybuild/wiki/OS_flavor_name_version

antwoordde op 23/01/2013 om 11:55
bron van user

stemmen
17

ik doe dit

import sys
print sys.platform

Docs hier: sys.platform .

Alles wat je nodig hebt is waarschijnlijk in de module sys.

antwoordde op 16/02/2009 om 15:43
bron van user

stemmen
10

Ik gebruik de WLST tool die wordt geleverd met weblogic, en het niet uitvoeren van de platform-pakket.

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

Afgezien van het patchen van het systeem javaos.py ( kwestie met os.system () op Windows 2003 met jdk1.5 ) (wat ik niet kan doen, moet ik weblogic gebruiken uit de doos), dit is wat ik gebruik:

def iswindows():
  os = java.lang.System.getProperty( "os.name" )
  return "win" in os.lower()
antwoordde op 11/06/2010 om 08:37
bron van user

stemmen
9
>>> import platform
>>> platform.system()
antwoordde op 25/06/2011 om 12:10
bron van user

stemmen
8

Voor Jython de enige manier om os naam krijg ik vond is om te controleren os.nameJava eigendom (beproefd sys, osen platformmodules voor Jython 2.5.3 op 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
antwoordde op 09/01/2013 om 09:47
bron van user

stemmen
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)
antwoordde op 10/10/2011 om 01:11
bron van user

stemmen
6

Kijk uit als je op Windows met Cygwin, waar os.nameis posix.

>>> import os, platform
>>> print os.name
posix
>>> print platform.system()
CYGWIN_NT-6.3-WOW
antwoordde op 08/07/2015 om 14:46
bron van user

stemmen
6

Interessante resultaten op Windows 8:

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

Edit: Dat is een bug

antwoordde op 14/02/2013 om 23:44
bron van user

stemmen
5

probeer dit:

import os

os.uname()

en je kunt maken:

info=os.uname()
info[0]
info[1]
antwoordde op 16/01/2015 om 18:13
bron van user

stemmen
5

Als u niet op zoek naar de kernel versie etc, maar op zoek naar de Linux distributie kunt u het volgende gebruiken

in 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

in python2.4

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

Uiteraard zal dit alleen werken als u dit draait op Linux. Wilt u meer generieke script op verschillende platforms, kunt u deze mengen met codevoorbeelden gegeven in andere antwoorden.

antwoordde op 28/03/2013 om 06:19
bron van user

stemmen
5

in dezelfde ader....

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")
antwoordde op 28/09/2011 om 18:54
bron van user

stemmen
4

Wat dacht je van een nieuw antwoord:

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

Dit zou de output zijn als ik was met behulp van OSX

antwoordde op 14/08/2017 om 17:00
bron van user

stemmen
3

Ik begon een beetje meer systematische opsomming van welke waarden u kunt verwachten met behulp van de verschillende modules (voel je vrij om te bewerken en voeg uw systeem):

Linux (64bit) + WSL

os.name                     posix
sys.platform                linux
platform.system()           Linux
sysconfig.get_platform()    linux-x86_64
platform.machine()          x86_64
platform.architecture()     ('64bit', '')
  • probeerde met archlinux en munt, kreeg dezelfde resultaten
  • op python2 sys.platformwordt aangegeven met kernel versie, bijvoorbeeld linux2, al het andere blijft gelijk
  • dezelfde output op Windows Subsystem for Linux (geprobeerd met Ubuntu 18.04 LTS), met uitzondering van platform.architecture() = ('64bit', 'ELF')

WINDOWS (64bit)

(Met 32bit kolom die in het subsysteem 32bit)

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

Enkele opmerkingen:

  • er is ook distutils.util.get_platform()dat identiek is aan `sysconfig.get_platform
  • anaconda op ramen is hetzelfde als officiële python Windows Installer
  • Ik heb geen een Mac of een echte 32-bits systeem en was niet gemotiveerd om het online te doen

Te vergelijken met het systeem, eenvoudig dit script uit te voeren (en hier voegen resultaten als vermist :)

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())
antwoordde op 23/02/2019 om 02:39
bron van user

stemmen
3

U kunt ook enige platform module gebruiken zonder te importeren os module om alle informatie te krijgen.

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

Een mooi en netjes lay-out voor het melden van doel kan worden bereikt met behulp van deze lijn:

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

Dat geeft deze output:

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

Wat ontbreekt meestal is de versie van het besturingssysteem, maar je moet weten als u werkt met Windows, Linux of Mac een platform onafhankelijke manier is om deze test te gebruiken:

In []: for i in [platform.linux_distribution(),platform.mac_ver(),platform.win32_ver()]:
   ....:     if i[0]:
   ....:         print 'Version: ',i[0]
antwoordde op 20/08/2016 om 08:03
bron van user

stemmen
3

Controleer de beschikbare tests met module platform en print het antwoord uit voor uw systeem:

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
antwoordde op 30/10/2014 om 00:43
bron van user

stemmen
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())
antwoordde op 03/02/2019 om 22:43
bron van user

stemmen
1

U kunt kijken naar de code in pyOSinfodie deel uitmaakt van de pip-date pakket, om de meest relevante OS informatie te krijgen, gezien vanaf uw Python distributie.

Een van de meest voorkomende redenen waarom mensen willen hun OS controleren is voor de terminal compatibiliteit en als bepaalde systeem commando's zijn beschikbaar. Helaas is het succes van deze controle is enigszins afhankelijk van uw python installatie en OS. Bijvoorbeeld, unameis niet beschikbaar op de meeste Windows-python pakketten. De bovenstaande python programma zal u de output van de meest gebruikte ingebouwde functies, reeds door os, sys, platform, site.

voer image beschrijving hier

Dus de beste manier om alleen de essentiële code is op zoek naar dat als voorbeeld. (Ik denk dat ik kon net hebben geplakt hier, maar dat zou niet politiek correct zijn geweest.)

antwoordde op 07/02/2019 om 21:10
bron van user

stemmen
1

Deze oplossing werkt zowel voor pythonen jython.

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

Gebruik als volgt uit:

import os_identify

print "My OS: " + os_identify.name()
antwoordde op 29/01/2019 om 13:06
bron van user

stemmen
1

Als u werkt met MacOS X en uit te voeren platform.system()krijg je darwin omdat MacOS X is gebouwd op Apple's Darwin OS. Darwin is de kern van MacOS X en is in wezen MacOS X zonder de GUI.

antwoordde op 13/01/2018 om 21:29
bron van user

stemmen
1

Gebruik de import osen os.namezoekwoorden.

antwoordde op 07/05/2017 om 03:07
bron van user

stemmen
0

Er zijn 3 manieren om OS te krijgen in Python, elk met zijn eigen voor- en nadelen:

methode 1

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

Hoe dit in zijn werk ( bron ): Intern roept OS API's om de naam van het OS te krijgen, zoals gedefinieerd door OS. Dit kan uiteraard verschillen van versie naar versie, dus best niet om direct te gebruiken. Zie hier voor verschillende OS-specifieke waarden.

methode 2

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

Hoe dit in zijn werk ( bron ): Intern kijkt het of python heeft OS-specifieke modules zogenaamde POSIX of NT. Als u wilt deze modules en call methoden te importeren op het, dit werkt geweldig. Merk op dat er geen onderscheid tussen Linux en OSX.

methode 3

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

Hoe dit in zijn werk ( bron ): Intern zal het uiteindelijk noemen interne OS API's, krijgen OS versie-specifieke naam zoals 'win32' of 'Win16' of 'linux1' en vervolgens normaliseren om meer generieke namen als 'Windows' of 'Linux' of 'Darwin' door het toepassen van verschillende heuristiek. Dit is de beste draagbare manier om genormaliseerde OS naam te krijgen.

Samenvatting

  • Als u wilt controleren of besturingssysteem is Windows of Linux of OSX dan is de meest betrouwbare manier is platform.system().
  • Als u wilt OS-specifieke oproepen te maken, maar via de ingebouwde Python modules posixen ntvervolgens gebruiken os.name.
  • Als u wilt rauwe OS naam krijgen zoals geleverd door OS zelf vervolgens gebruiken sys.platform.
antwoordde op 24/09/2019 om 02:28
bron van user

stemmen
0

Ik ben laat om het spel, maar, voor het geval iemand het nodig heeft, is dit een functie die ik gebruik om aanpassingen te maken op mijn code, zodat het draait op Windows, Linux en 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'
antwoordde op 22/05/2019 om 16:32
bron van user

stemmen
0

Wat dacht je van een eenvoudige Enum implementatie als het volgende? Geen behoefte aan externe libs!

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

Gewoon je kunt benaderen met Enum-waarde

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

PS Het is python3

antwoordde op 27/09/2018 om 17:39
bron van user

stemmen
-4

Gewoon voor de volledigheid, "OS" omgeving variabele lijkt overal te worden gedefinieerd. Op Windows XP / 7/8/10 is ingesteld op "Windows_NT". Op Linux SuSE SP2 is ingesteld op "x86-64 linux SLES11 [2]". Ik heb geen toegang tot OS-X of BSD machines, interessant om daar ook te controleren zou zijn.

import os

os_name = os.getenv("OS")
if os_name == "Windows_NT":
    # Windows
elif "linux" in os_name:
    # Linux
elif ...
antwoordde op 01/12/2015 om 07:28
bron van user

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