Here are the system results for Windows Vista!

>>> import os

>>> os.name
'nt'

>>> import platform

>>> platform.system()
'Windows'

>>> platform.release()
'Vista'

And for Windows 10:

>>> import os

>>> os.name
'nt'

>>> import platform

>>> platform.system()
'Windows'

>>> platform.release()
'10'

Short Story

Use platform.system(). It returns Windows, Linux or Darwin (for OS X).

Long Story

There are three ways to get the OS in Python, each with its own pro and cons:

Method 1

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

How this works (source): Internally it calls OS APIs to get the name of the OS as defined by the OS. See here for various OS-specific values.

Pro: No magic, low level.

Con: OS version dependent, so best not to use directly.

Method 2

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

How this works (source): Internally it checks if Python has OS-specific modules called posix or nt.

Pro: Simple to check if it is a POSIX OS

Con: no differentiation between Linux or OS X.

Method 3

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

How this works (source): Internally it will eventually call internal OS APIs, get the OS version-specific name, like 'win32' or 'win16' or 'linux1' and then normalize to more generic names like 'Windows' or 'Linux' or 'Darwin' by applying several heuristics.

Pro: The best portable way for Windows, OS X, and Linux.

Con: Python folks must keep normalization heuristic up to date.

Summary

• If you want to check if OS is Windows or Linux, or OS X, then the most reliable way is platform.system().
• If you want to make OS-specific calls, but via built-in Python modules posix or nt, then use os.name.
• If you want to get the raw OS name as supplied by the OS itself, then use sys.platform.

For the record, here are the results on Mac:

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

Sample code to differentiate operating systems using Python:

import sys

if sys.platform.startswith("linux"):  # could be "linux", "linux2", "linux3", ...
    # linux
elif sys.platform == "darwin":
    # MAC OS X
elif os.name == "nt":
    # Windows, Cygwin, etc. (either 32-bit or 64-bit)

I started a bit more systematic listing of what values you can expect using the various modules:

Linux (64 bit) + WSL

                            x86_64            aarch64
                            ------            -------
os.name                     posix             posix
sys.platform                linux             linux
platform.system()           Linux             Linux
sysconfig.get_platform()    linux-x86_64      linux-aarch64
platform.machine()          x86_64            aarch64
platform.architecture()     ('64bit', '')     ('64bit', 'ELF')

• I tried with Arch Linux and Linux Mint, but I got the same results
• on Python 2, sys.platform is suffixed by the kernel version, e.g., linux2, and everything else stays identical
• the same output on Windows Subsystem for Linux (I tried with Ubuntu 18.04 (Bionic Beaver) LTS), except platform.architecture() = ('64bit', 'ELF')

Windows (64 bit)

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

Official Python installer   64 bit                    32 bit
-------------------------   -----                     -----
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                       64 bit                     32 bit
-----                       -----                     -----
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                      64 bit                    32 bit
------                      -----                     -----
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 the same as the official Python Windows installer
• I don't have a Mac nor a true 32-bit system and was not motivated to do it online

To compare with your system, simply run this script:

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

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'

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 are a few different possible calls you can make to identify where you are. linux_distribution and dist are removed in recent Python versions.

import platform
import sys

def linux_distribution():
  try:
    return platform.linux_distribution()
  except:
    return "N/A"

def dist():
  try:
    return platform.dist()
  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(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, and macOS) and architectures (x86, x64, Itanium, PowerPC, and SPARC) is available at OS_flavor_name_version.

Ubuntu 12.04 server (Precise Pangolin), 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: ('', ('', '', ''), '')

Use:

import psutil

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

This would be the output if I was using macOS.

Use platform.system()

Returns the system/OS name, such as 'Linux', 'Darwin', 'Java', 'Windows'. An empty string is returned if the value cannot be determined.

import platform
system = platform.system().lower()

is_windows = system == 'windows'
is_linux = system == 'linux'
is_mac = system == 'darwin'

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 Server 2003 with JDK 1.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()

For Jython the only way to get the OS name I found is to check the os.name Java property (I tried with sys, os and platform modules for Jython 2.5.3 on Windows XP):

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

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

#!/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)

Interesting results on Windows 8:

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

That's a bug.

Here is an easy and simple-to-understand Pythonic way to detect the OS in code. It was tested on Python 3.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

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

In Python 2.6 and later:

>>> 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 Python 2.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 a more generic script across platforms, you can mix this with code samples given in other answers.

Try this:

import os

os.uname()

And you can make it:

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

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

You can also use only the platform module without importing the 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

Usually the operating system version is missing, but you should know if you are running Windows, Linux or Mac, a platform-independent 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]

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

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

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

If you want to use OS related operations. You can use this code:

import sys


def getOS() -> str:
    os = sys.platform
    if os == "linux":
        return "linux"
    elif os == "darwin":
        return "mac"
    elif os == "win32":
        return "windows"
    else:
        raise Exception("OS not supported")

See this reference for more detail: https://docs.python.org/3/library/sys.html#sys.platform

Use a simple Enum implementation like the following. There isn't any need for external libraries!

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 tested this one

Simply you can access them with the Enum value:

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

PS: It is Python 3.

There are a lot of ways to find this. The easiest way is to use the os package:

import os

print(os.name)

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'

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.

So the best way to get only the essential code is looking at that as an example.