मैं किस OS पर चल रहा हूँ?

Question

मुझे यह देखने के लिए क्या देखने की आवश्यकता है कि मैं विंडोज पर हूं या यूनिक्स, आदि?

Comments

विवरण के लिए देखें ( bugs.python.org/issue12326 )!

— अरनकोर

यहाँ एक संबंधित प्रश्न है: linux distro नाम की जाँच करें ।

— ९

Answer 1

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

इस platform.system()प्रकार इसका उत्पादन निम्नानुसार है:

• लिनक्स: Linux
• मैक: Darwin
• खिड़कियाँ: Windows

देखें: platform- अंतर्निहित प्लेटफ़ॉर्म की पहचान डेटा तक पहुंच

Comments

मैं क्यों पसंद किए जाने वाले platformसे अधिक sys.platform?

— मैट

@ ममथ थोड़ा अधिक सुसंगत आउटपुट। के बजाय platform.system()रिटर्न । पाइथन के पुराने संस्करणों में भी शामिल है, जबकि इसमें सिर्फ नए हैं। हमेशा ही वापस लौटा है । "Windows""win32"sys.platform"linux2""linux"platform.system()"Linux"

— एर

मैक ओएस एक्स पर, platform.system () हमेशा "डार्विन" लौटाता है? या क्या कोई अन्य मामला संभव है?

— बपतिस्मा देने वाला

@ baptistechéné, मुझे पता है कि यह पूछे जाने के बाद से एक वर्ष से अधिक है, लेकिन एक टिप्पणी के रूप में चोट नहीं पहुंचेगी, मैं इसे वैसे भी पोस्ट करूंगा :) इसलिए, इसके पीछे का कारण है क्योंकि यह कर्नेल नाम दिखाता है। उसी तरह लिनक्स (कर्नेल) डिस्ट्रोस के कई नाम हैं (उबंटू, आर्क, फेडोरा और अन्य), लेकिन यह खुद को कर्नेल नाम, लिनक्स के रूप में प्रस्तुत करेगा। डार्विन (बीएसडी-आधारित कर्नेल), इसके आस-पास की प्रणाली, macOS है। मुझे पूरा यकीन है कि Apple ने डार्विन को एक ओपन सोर्स कोड के रूप में रिलीज़ किया था, लेकिन डार्विन के ऊपर कोई और डिस्ट्रो नहीं चल रहा है जिसका मुझे पता है।

— जोआओ पाउलो रैलो

@TooroSan os.uname()केवल यूनिक्स सिस्टम के लिए मौजूद है। पायथन 3 डॉक्स: docs.python.org/3/library/os.html Availability: recent flavors of Unix.

— इरविंग

Answer 2

डांग - लब्रैंडी ने मुझे पंच मारा, लेकिन इसका मतलब यह नहीं है कि मैं आपको विस्टा के लिए सिस्टम परिणाम प्रदान नहीं कर सकता!

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

... और मुझे विश्वास नहीं हो रहा है कि किसी ने भी विंडोज 10 के लिए कोई पोस्ट नहीं किया है:

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

Comments

विंडोज 7:platform.release() '7'

— ह्यूगो

तो, हाँ, मैं सिर्फ platform.release()अपने विंडोज 10 पर भाग गया , और यह निश्चित रूप से बस मुझे दिया '8'। शायद मैं उन्नयन से पहले अजगर स्थापित किया, लेकिन वास्तव में ??

— कोडस्मिथ

मैंने सोचा होगा कि यह विंडोज 8 से उन्नत होने की संभावना है (बनाम यह एक साफ इंस्टॉल है) और जो भी पायथन रजिस्ट्री में दिखता है या जो कुछ भी पीछे रह गया था?

— 20

विंडोज पर अजगर के लिए रिलीज़ लुकअप अपने मूल में Win32 एपीआई फ़ंक्शन GetVersionEx का उपयोग करता है। उस फ़ंक्शन के बारे में Microsoft के इस लेख के शीर्ष नोट प्रासंगिक हो सकते हैं: msdn.microsoft.com/en-us/library/windows/desktop/…

— theferrit32

Answer 3

मैक पर परिणाम के रिकॉर्ड के लिए:

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

Comments

MacOS कैटालिना 10.15.2 पर, platform.release()रिटर्न'19.2.0'

— बोरिस

Answer 4

अजगर के उपयोग से ओएस को अलग करने के लिए नमूना कोड:

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

Comments

क्या यह नमूना कोड किसी भी अजगर मॉड्यूल से है? यह एकमात्र उत्तर है जो वास्तव में प्रश्न का उत्तर देता है।

— कोन मन

फजीयर परिणामों के लिए, `` _platform.startswith ('linux')

— कल्लातु वॉन श्लाकेर

Answer 5

sys.platformयदि आप पहले से ही आयात कर चुके हैं sysऔर आप किसी अन्य मॉड्यूल को आयात नहीं करना चाहते हैं, तो आप इसका उपयोग भी कर सकते हैं

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

Comments

किसी अन्य मॉड्यूल को आयात करने या न करने के अलावा, दृष्टिकोण के किसी भी फायदे हैं?

— मैट

स्कोपिंग मुख्य लाभ है। आप संभव के रूप में कुछ वैश्विक चर नाम चाहते हैं। जब आपके पास पहले से ही "sys" एक वैश्विक नाम के रूप में है, तो आपको एक और नहीं जोड़ना चाहिए। लेकिन अगर आप अभी तक "सीस" का उपयोग नहीं करते हैं, तो "_platform" का उपयोग करना अधिक वर्णनात्मक हो सकता है और किसी अन्य अर्थ से टकराने की संभावना कम हो सकती है।

— सैंडरड 17

Answer 6

यदि आप उपयोगकर्ता पठनीय डेटा चाहते हैं, लेकिन फिर भी विस्तृत है, तो आप platform.platform () का उपयोग कर सकते हैं

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

यहां कुछ अलग संभावित कॉल हैं जिनसे आप पहचान सकते हैं कि आप कहां हैं

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

इस स्क्रिप्ट के आउटपुट कुछ अलग सिस्टम (लिनक्स, विंडोज, सोलारिस, मैकओएस) और आर्किटेक्चर (x86, x64, Itanium, पावर पीसी, स्पार्क) पर चलते हैं: https://github.com/hpcugent_easybuild/ wiki / OS_flavor_name_version

उदाहरण के लिए Ubuntu 12.04 सर्वर देता है:

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

Comments

DeprecationWarning: dist() and linux_distribution() functions are deprecated in Python 3.5

— बोरिस

Answer 7

लघु कथा

का उपयोग करें platform.system()। यह रिटर्न Windows, Linuxया Darwin(OSX के लिए)।

लम्बी कहानी

पायथन में ओएस प्राप्त करने के 3 तरीके हैं, प्रत्येक अपने स्वयं के समर्थक और विपक्ष के साथ:

विधि 1

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

यह कैसे काम करता है ( स्रोत ): आंतरिक रूप से यह ओएस द्वारा परिभाषित ओएस के नाम को प्राप्त करने के लिए ओएस एपीआई कहता है। विभिन्न ओएस-विशिष्ट मूल्यों के लिए यहां देखें ।

प्रो: कोई जादू नहीं, निम्न स्तर।

Con: OS संस्करण निर्भर है, इसलिए सीधे उपयोग करने के लिए सर्वोत्तम नहीं है।

विधि 2

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

यह कैसे काम करता है ( स्रोत ): आंतरिक रूप से यह जांचता है कि अजगर के पास ओएस-विशिष्ट मॉड्यूल हैं जिन्हें पॉज़िक्स या एनटी कहा जाता है।

प्रो: सरल अगर पॉज़िक्स ओएस की जाँच करें

Con: लिनक्स या OSX के बीच कोई अंतर नहीं है।

विधि 3

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

यह कैसे काम करता है ( स्रोत ): आंतरिक रूप से यह अंततः आंतरिक ओएस एपीआई को कॉल करेगा, ओएस संस्करण-विशिष्ट नाम प्राप्त करें जैसे 'win32' या 'win16' या 'linux1' और फिर 'विंडोज' या 'लिनक्स' या 'जैसे' और अधिक सामान्य नामों को सामान्य करें। Ur डार्विन ’ने कई उत्तराधिकारी लागू किए।

प्रो: विंडोज, ओएसएक्स और लिनक्स के लिए सबसे अच्छा पोर्टेबल तरीका।

Con: अजगर लोगों को सामान्य होने की स्थिति को अपडेट रखना चाहिए।

सारांश

• यदि आप जांचना चाहते हैं कि ओएस विंडोज या लिनक्स या ओएसएक्स है तो सबसे विश्वसनीय तरीका है platform.system() ।
• यदि आप ओएस-विशिष्ट कॉल करना चाहते हैं, लेकिन अंतर्निहित पायथन मॉड्यूल के माध्यम से posixया ntफिर उपयोग करते हैंos.name ।
• यदि आप ओएस द्वारा आपूर्ति की गई कच्ची ओएस नाम प्राप्त करना चाहते हैं तो उपयोग करें sys.platform।

Comments

तो "चीजों को करने के लिए एक (और अधिमानतः केवल एक) तरीका होना चाहिए"। हालाँकि मेरा मानना ​​है कि यह सही उत्तर है। आपको शीर्षक वाले ओएस नामों के साथ तुलना करने की आवश्यकता होगी लेकिन यह ऐसा कोई मुद्दा नहीं है और अधिक पोर्टेबल होगा।

— विन्सेंट-एलजी

Answer 8

एक नए उत्तर के बारे में कैसे:

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

यह उत्पादन होगा अगर मैं MACOS का उपयोग कर रहा था

Comments

psutil मानक lib का हिस्सा नहीं है

— कोरी गोल्डबर्ग

Answer 9

मैंने कुछ और व्यवस्थित व्यवस्थित करना शुरू कर दिया है कि आप विभिन्न मॉड्यूल का उपयोग करके किन मूल्यों की उम्मीद कर सकते हैं (अपने सिस्टम को संपादित करने और जोड़ने के लिए स्वतंत्र महसूस करें):

लिनक्स (64 बिट) + डब्ल्यूएसएल

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

• आर्कलिनक्स और टकसाल के साथ की कोशिश की, एक ही परिणाम मिला
• python2 पर sys.platformकर्नेल संस्करण द्वारा प्रत्यय दिया गया है, जैसेlinux2 , बाकी सब कुछ समान है
• लिनक्स के लिए विंडोज सबसिस्टम पर समान आउटपुट (को छोड़कर ubuntu 18.04 LTS के साथ), को छोड़कर platform.architecture() = ('64bit', 'ELF')

विन्डोज़ (64 बिट)

(32 बिट सबसिस्टम में 32 बिट कॉलम चल रहा है)

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

कुछ टिप्पणी:

• वहाँ भी distutils.util.get_platform() जो `sysconfig.get_platform के समान है
• खिड़कियों पर एनाकोंडा आधिकारिक अजगर खिड़कियों इंस्टॉलर के रूप में ही है
• मेरे पास एक मैक नहीं है और न ही एक 32 बिट सिस्टम है और इसे ऑनलाइन करने के लिए प्रेरित नहीं किया गया है

अपने सिस्टम के साथ तुलना करने के लिए, बस इस स्क्रिप्ट को चलाएं (और अगर लापता हैं तो कृपया परिणाम यहाँ जोड़ दें)

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

Answer 10

मैं WLST टूल का उपयोग कर रहा हूं जो वेबलॉजिक के साथ आता है, और यह प्लेटफ़ॉर्म पैकेज को लागू नहीं करता है।

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

सिस्टम javaos.py ( OS.system के साथ समस्या) jdk1.5 के साथ विंडोज़ पर पैचिंग के अलावा ) (जो मैं नहीं कर सकता, मुझे बॉक्स से वेबलॉगिक का उपयोग करना होगा), यह वही है जो मैं उपयोग करता हूं:

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

Answer 11

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

Comments

SO पर आपका स्वागत है, यहाँ, यह समझाने के लिए एक अच्छा अभ्यास है कि अपने समाधान का उपयोग क्यों करें और न कि कैसे। यह आपके उत्तर को अधिक मूल्यवान बना देगा और आगे के पाठक को यह समझने में मदद करेगा कि आप इसे कैसे करते हैं। मैं यह भी सुझाव है कि आप हमारे FAQ पर एक नजर है: stackoverflow.com/faq ।

— 22 मई को ForceMagic

अच्छा जवाब, शायद मूल जवाब के बराबर भी। लेकिन आप क्यों समझा सकते हैं।

— vgoff 22

Answer 12

Jython के लिए मैंने पाया ओएस नाम पाने के लिए एक ही रास्ता जाँच करने के लिए है os.nameजावा संपत्ति (के साथ करने की कोशिश की sys, osऔर platformWinXP पर Jython 2.5.3 के लिए मॉड्यूल):

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

Comments

आप Jython में OS की जानकारी निकालने के लिए "platform.java_ver ()" भी कह सकते हैं।

— डॉकऑक

Answer 13

विंडोज 8 पर दिलचस्प परिणाम:

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

संपादित करें: यह एक बग है

Answer 14

अगर आप Cygwin के साथ विंडोज पर हैं, तो देखें कि कहां os.nameहै posix।

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

Answer 15

एक ही शिरे में....

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

Comments

यदि आप एक मैक पर हैं, तो यह समस्याग्रस्त है क्योंकि platform.system () एक मैक पर "डार्विन" और "डार्विन" .lower () लौटाता है। खोजें ("जीत") = 3.

— mishaF

is_windows = platform.system ()। निचला ()। प्रारंभ ("जीत") या गलत

— कोरी गोल्डबर्ग

Answer 16

यदि आप कर्नेल संस्करण आदि की तलाश नहीं कर रहे हैं, लेकिन लिनक्स वितरण की तलाश में आप निम्नलिखित का उपयोग करना चाह सकते हैं

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

python2 में। 4

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

जाहिर है, यह तभी काम करेगा जब आप इसे लिनक्स पर चला रहे हों। यदि आप प्लेटफार्मों में अधिक सामान्य स्क्रिप्ट रखना चाहते हैं, तो आप इसे अन्य उत्तरों में दिए गए कोड नमूनों के साथ मिला सकते हैं।

Answer 17

इसे इस्तेमाल करे:

import os

os.uname()

और आप इसे बना सकते हैं:

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

Comments

os.uname()विंडोज़ पर भी उपलब्ध नहीं है: docs.python.org/2/library/os.html#os.uname उपलब्धता: यूनिक्स के हाल के स्वाद।

— ccpizza

Answer 18

मॉड्यूल प्लेटफ़ॉर्म के साथ उपलब्ध परीक्षणों की जाँच करें और अपने सिस्टम के लिए उत्तर को प्रिंट करें:

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

Answer 19

आप सभी जानकारी प्राप्त करने के लिए ओएस मॉड्यूल आयात किए बिना केवल प्लेटफ़ॉर्म मॉड्यूल का उपयोग कर सकते हैं।

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

रिपोर्टिंग उद्देश्य के लिए एक अच्छा और स्पष्ट लेआउट इस लाइन का उपयोग करके प्राप्त किया जा सकता है:

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

यह उत्पादन देता है:

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

क्या गायब है आमतौर पर ऑपरेटिंग सिस्टम संस्करण है, लेकिन आपको पता होना चाहिए कि क्या आप विंडोज़, लिनक्स या मैक चला रहे हैं, इस परीक्षण का उपयोग करने के लिए एक प्लेटफ़ॉर्म इंडिपेंडेंट तरीका है:

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

Answer 20

मुझे पता है कि यह एक पुराना सवाल है, लेकिन मेरा मानना ​​है कि मेरा उत्तर वह है जो कुछ लोगों के लिए मददगार हो सकता है, जो अपने कोड में ओएस का पता लगाने के लिए एक आसान, सरल और समझदार तरीके की तलाश कर रहे हैं। Python3.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

Answer 21

यदि आप macOS X चला रहे हैं और platform.system()आप को डार्विन मिलता है क्योंकि macOS X को Apple के डार्विन OS पर बनाया गया है। डार्विन macOS X का कर्नेल है और अनिवार्य रूप से GUI के बिना macOS X है।

Answer 22

यह समाधान pythonऔर दोनों के लिए काम करता है jython।

मॉड्यूल 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>" 

इस तरह का उपयोग करें:

import os_identify

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

Answer 23

निम्नलिखित की तरह एक सरल एनम कार्यान्वयन के बारे में कैसे? बाहरी कामों के लिए कोई ज़रूरत नहीं है!

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

बस आप Enum मान के साथ पहुँच सकते हैं

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

PS यह python3 है

Answer 24

आप उस कोड को देख सकते हैं pyOSinfoजिसमें पिप-डेट पैकेज का हिस्सा है , सबसे प्रासंगिक ओएस जानकारी प्राप्त करने के लिए, जैसा कि आपके पायनियर वितरण से देखा गया है।

सबसे सामान्य कारणों में से एक लोग अपने ओएस की जांच करना चाहते हैं जो टर्मिनल संगतता के लिए है और यदि कुछ सिस्टम कमांड उपलब्ध हैं। दुर्भाग्य से, इस जाँच की सफलता आपके अजगर स्थापना और OS पर कुछ हद तक निर्भर है। उदाहरण के लिए, unameअधिकांश विंडोज पायथन पैकेज पर उपलब्ध नहीं है। उपरोक्त अजगर कार्यक्रम आपको पहले से ही प्रदान किए गए सबसे अधिक उपयोग किए जाने वाले कार्यों का आउटपुट दिखाएगा os, sys, platform, site।

तो केवल आवश्यक कोड प्राप्त करने का सबसे अच्छा तरीका एक उदाहरण के रूप में देख रहा है । (मुझे लगता है कि मैं इसे यहाँ पेस्ट कर सकता था, लेकिन यह राजनीतिक रूप से सही नहीं होगा।)

Answer 25

मुझे खेल के लिए देर हो चुकी है, लेकिन अगर किसी को इसकी आवश्यकता है, तो यह एक फ़ंक्शन है जिसका उपयोग मैं अपने कोड पर समायोजन करने के लिए करता हूं, इसलिए यह विंडोज, लिनक्स और मैकओ पर चलता है:

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'