cross platform - Python: What OS am I running on?


Translate

What do I need to look at to see whether I'm on Windows or Unix, etc?


所有的回答
  • Translate
    >>> import os
    >>> print os.name
    posix
    >>> import platform
    >>> platform.system()
    'Linux'
    >>> platform.release()
    '2.6.22-15-generic'
    

    The output of platform.system() is as follows:

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

    See: platform — Access to underlying platform’s identifying data


  • Translate

    Dang -- lbrandy beat me to the punch, but that doesn't mean I can't provide you with the system results for Vista!

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

    ...and I can’t believe no one’s posted one for Windows 10 yet:

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

  • Translate

    For the record here's the results on Mac:

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

  • Translate

    Sample code to differentiate OS's using 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
    

  • Translate

    You can also use sys.platform if you already have imported sys and you don't want to import another module

    >>> import sys
    >>> sys.platform
    'linux2'
    

  • Translate

    If you want user readable data but still detailed, you can use platform.platform()

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

    Here's a few different possible calls you can make to identify where you are

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

    The outputs of this script ran on a few different systems (Linux, Windows, Solaris, MacOS) and architectures (x86, x64, Itanium, power pc, sparc) is available here: https://github.com/hpcugent/easybuild/wiki/OS_flavor_name_version

    Ubuntu 12.04 server for example gives:

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

  • Translate

    I do this

    import sys
    print sys.platform
    

    Docs here : sys.platform.

    Everything you need is probably in the sys module.


  • Translate

    How about a new answer:

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

    This would be the output if I was using MACOS


  • Translate

    I am using the WLST tool that comes with weblogic, and it doesn't implement the platform package.

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

    Apart from patching the system javaos.py (issue with os.system() on windows 2003 with jdk1.5) (which I can't do, I have to use weblogic out of the box), this is what I use:

    def iswindows():
      os = java.lang.System.getProperty( "os.name" )
      return "win" in os.lower()
    

  • Translate
    >>> import platform
    >>> platform.system()
    

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

  • Translate

    For Jython the only way to get os name I found is to check os.name Java property (tried with sys, os and platform modules for Jython 2.5.3 on 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
    

  • Translate

    I started a bit more systematic listing of what values you can expect using the various modules (feel free to edit and add your system):

    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', '')
    
    • tried with archlinux and mint, got same results
    • on python2 sys.platform is suffixed by kernel version, e.g. linux2, everything else stays identical
    • same output on Windows Subsystem for Linux (tried with ubuntu 18.04 LTS), except platform.architecture() = ('64bit', 'ELF')

    WINDOWS (64bit)

    (with 32bit column running in the 32bit subsystem)

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

    Some remarks:

    • there is also distutils.util.get_platform() which is identical to `sysconfig.get_platform
    • anaconda on windows is same as official python windows installer
    • I don't have a Mac nor a true 32bit system and was not motivated to do it online

    To compare with your system, simply run this script (and please append results here if missing :)

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

  • Translate

    Interesting results on windows 8:

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

    Edit: That's a bug


  • Translate

    Watch out if you're on Windows with Cygwin where os.name is posix.

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

  • Translate

    in the same vein....

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

  • Wilbur Lee
    Translate

    If you not looking for the kernel version etc, but looking for the linux distribution you may want to use the following

    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
    

    Obviously, this will work only if you are running this on linux. If you want to have more generic script across platforms, you can mix this with code samples given in other answers.


  • Translate

    try this:

    import os
    
    os.uname()
    

    and you can make it :

    info=os.uname()
    info[0]
    info[1]
    

  • Translate

    Check the available tests with module platform and print the answer out for your system:

    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
    

  • Translate

    You can also use only platform module without importing os module to get all the information.

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

    A nice and tidy layout for reporting purpose can be achieved using this line:

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

    That gives this 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
    

    What is missing usually is the operating system version but you should know if you are running windows, linux or mac a platform indipendent way is to use this test:

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

  • Translate

    If you are running macOS X and run platform.system() you get darwin because macOS X is built on Apple's Darwin OS. Darwin is the kernel of macOS X and is essentially macOS X without the GUI.


  • Translate

    This solution works for both python and 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>" 
    

    Use like this:

    import os_identify
    
    print "My OS: " + os_identify.name()
    

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

  • Translate

    Use the import os and os.name keywords.


  • Translate

    How about a simple Enum implementation like the following? No need for external 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
    

    Simply you can access with Enum value

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

    P.S It is python3


  • Translate

    You can look at the code in pyOSinfo which is part of the pip-date package, to get the most relevant OS information, as seen from your Python distribution.

    One of the most common reasons people want to check their OS is for terminal compatibility and if certain system commands are available. Unfortunately, the success of this checking is somewhat dependent on your python installation and OS. For example, uname is not available on most Windows python packages. The above python program will show you the output of the most commonly used built-in functions, already provided by os, sys, platform, site.

    enter image description here

    So the best way to get only the essential code is looking at that as an example. (I guess I could have just pasted it here, but that would not have been politically correct.)


  • Translate

    I am late to the game but, just in case anybody needs it, this a function I use to make adjustments on my code so it runs on Windows, Linux and 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'