Is it safe to use sys.platform=='win32' ch

Question

The usual check to differentiate between running Python-application on Windows and on other OSes (Linux typically) is to use conditional:

if sys.platform == 'win32':
    ...

But I wonder is it safe to use today when 64-bit Python is more widely used in last years? Does 32 really means 32-bit, or basically it refers to Win32 API?

If there is possibility to have one day sys.platform as 'win64' maybe such condition would be more universal?

if sys.platform.startswith('win'):
    ...

There is also another way to detect Windows I'm aware of:

if os.name == 'nt':
    ...

But I really never saw in other code the use of the latter.

What is the best way then?

UPD: I'd like to avoid using extra libraries if I can. Requiring installing extra library to check that I'm work not in the Windows may be annoying for Linux users.

Answer 1

Notice that you cannot use either sys.platform or os.name for this on Jython:

$ jython -c "import sys, os; print sys.platform; print os.name"
java1.6.0_20
java

I think there's a plan in Jython project to change os.name to report the underlying OS similarly as CPython, but because people are using os.name == 'java' to check are they on Jython this change cannot be done overnight. There is, however, already os._name on Jython 2.5.x:

$ jython -c "import os; print os._name"
posix

Personally I tend to use os.sep == '/' with code that needs to run both on Jython and CPython, and both on Windows and unixy platforms. It's somewhat ugly but works.

Answer 2

Personally I use platinfo for detecting the underlying platform.

>>> from platinfo import PlatInfo
>>> pi = PlatInfo()
>>> pi.os
'win64'
>>> pi.arch
'x64'
>>> pi.name()
'win64-x64'

For 32-bit, pi.name() returns win32-x86.

Answer 3

sys.platform will be win32 regardless of the bitness of the underlying Windows system, as you can see in PC/pyconfig.h (from the Python 2.6 source distribution):

#if defined(MS_WIN64)
/* maintain "win32" sys.platform for backward compatibility of Python code,
   the Win64 API should be close enough to the Win32 API to make this
   preferable */
#       define PLATFORM "win32"

It's possible to find the original patch that introduced this on the web, which offers a bit more explanation:

The main question is: is Win64 so much more like Win32 than different from it that the common-case general Python programmer should not ever have to make the differentiation in his Python code. Or, at least, enough so that such differentiation by the Python scriptor is rare enough that some other provided mechanism is sufficient (even preferable). Currently the answer is yes. Hopefully MS will not change this answer.

Answer 4

The caveats for Windows/32 and Windows/64 are the same, so they should use the same value. The only difference would be in e.g. sys.maxint and ctypes. If you need to distinguish between 32 and 64 regardless then platform is your best bet.