How to identify which OS Python is running on
Question:
What do I need to look at to see whether I’m on Windows or Unix, etc.?
Answers:
>>> import os
>>> 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
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'
For the record, here are the results on Mac:
>>> import os
>>> os.name
'posix'
>>> import platform
>>> platform.system()
'Darwin'
>>> platform.release()
'8.11.1'
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'
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()
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")
#!/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)
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
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: ('', ('', '', ''), '')
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.
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)
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
Try this:
import os
os.uname()
And you can make it:
info = os.uname()
info[0]
info[1]
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
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]
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.
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.
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.
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()
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.
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())
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'
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
.
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
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'
There are a lot of ways to find this. The easiest way is to use the os package:
import os
print(os.name)
What do I need to look at to see whether I’m on Windows or Unix, etc.?
>>> import os
>>> 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
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'
For the record, here are the results on Mac:
>>> import os
>>> os.name
'posix'
>>> import platform
>>> platform.system()
'Darwin'
>>> platform.release()
'8.11.1'
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'
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()
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")
#!/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)
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
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: ('', ('', '', ''), '')
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.
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)
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
Try this:
import os
os.uname()
And you can make it:
info = os.uname()
info[0]
info[1]
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
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]
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.
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.
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.
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()
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.
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())
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'
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
ornt
, then useos.name
. - If you want to get the raw OS name as supplied by the OS itself, then use
sys.platform
.
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
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'
There are a lot of ways to find this. The easiest way is to use the os package:
import os
print(os.name)