अजगर: मैं पर क्या OS चला रहा हूँ?

वोट
410

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

05/08/2008 को 04:23
का स्रोत उपयोगकर्ता
अन्य भाषाओं में...                            


29 जवाब

वोट
513

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

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

  • लिनक्स: Linux
  • मैक: Darwin
  • विंडोज: Windows

देखें: मंच - अंतर्निहित मंच के पहचान वाले डेटा तक पहुंच

05/08/2008 को 04:27
का स्रोत उपयोगकर्ता

वोट
146

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

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

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

>>> import os
>>> os.name
'nt'
>>> import platform
>>> platform.system()
'Windows'
>>> platform.release()
'10'
05/08/2008 को 04:57
का स्रोत उपयोगकर्ता

वोट
108

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

>>> import os
>>> os.name
'posix'
>>> import platform
>>> platform.system()
'Darwin'
>>> platform.release()
'8.11.1'
05/08/2008 को 05:13
का स्रोत उपयोगकर्ता

वोट
73

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

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
16/09/2014 को 08:42
का स्रोत उपयोगकर्ता

वोट
35

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

>>> import sys
>>> sys.platform
'linux2'
26/08/2008 को 16:41
का स्रोत उपयोगकर्ता

वोट
24

आप उपयोगकर्ता पठनीय डेटा, लेकिन अभी भी विस्तृत चाहते हैं, आप उपयोग कर सकते हैं 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(),
))

इस स्क्रिप्ट के आउटपुट में कुछ अलग सिस्टम पर चलता था यहाँ उपलब्ध है: https://github.com/hpcugent/easybuild/wiki/OS_flavor_name_version

23/01/2013 को 11:55
का स्रोत उपयोगकर्ता

वोट
17

मैं यह करता हूँ

import sys
print sys.platform

यहाँ डॉक्स: sys.platform

सब कुछ आप की जरूरत शायद sys मॉड्यूल में है।

16/02/2009 को 15:43
का स्रोत उपयोगकर्ता

वोट
10

मैं WLST उपकरण है जो weblogic के साथ आता है का उपयोग कर रहा है, और यह मंच पैकेज को लागू नहीं करता है।

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 ( Windows 2003 jdk1.5 साथ पर os.system () के साथ इस मुद्दे ), यह मैं क्या उपयोग है (जो मैं नहीं कर सकता, मैं बॉक्स से बाहर weblogic उपयोग करने के लिए):

def iswindows():
  os = java.lang.System.getProperty( "os.name" )
  return "win" in os.lower()
11/06/2010 को 08:37
का स्रोत उपयोगकर्ता

वोट
9
>>> import platform
>>> platform.system()
25/06/2011 को 12:10
का स्रोत उपयोगकर्ता

वोट
8

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
09/01/2013 को 09:47
का स्रोत उपयोगकर्ता

वोट
7

/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)
10/10/2011 को 01:11
का स्रोत उपयोगकर्ता

वोट
6

से सावधान रहें यदि आप Cygwin के साथ विंडोज पर हैं जहां os.nameहै posix

>>> import os, platform
>>> print os.name
posix
>>> print platform.system()
CYGWIN_NT-6.3-WOW
08/07/2015 को 14:46
का स्रोत उपयोगकर्ता

वोट
6

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

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

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

14/02/2013 को 23:44
का स्रोत उपयोगकर्ता

वोट
5

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

import os

os.uname()

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

info=os.uname()
info[0]
info[1]
16/01/2015 को 18:13
का स्रोत उपयोगकर्ता

वोट
5

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

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

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

28/03/2013 को 06:19
का स्रोत उपयोगकर्ता

वोट
5

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

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")
28/09/2011 को 18:54
का स्रोत उपयोगकर्ता

वोट
4

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

import psutil
psutil.OSX     #True
psutil.WINDOWS #False
psutil.LINUX   #False 

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

14/08/2017 को 17:00
का स्रोत उपयोगकर्ता

वोट
3

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

लिनक्स (64 बिट) + WSL

os.name                     posix
sys.platform                linux
platform.system()           Linux
sysconfig.get_platform()    linux-x86_64
platform.machine()          x86_64
platform.architecture()     ('64bit', '')
  • archlinux और पुदीना के साथ की कोशिश की, एक ही परिणाम मिला
  • पर को Python2 sys.platformकर्नेल संस्करण द्वारा प्रत्यय है, उदाहरण के लिए linux2, सब कुछ और कुछ समान रहता है
  • लिनक्स के लिए Windows सबसिस्टम पर एक ही निर्गम (ubuntu 18.04 LTS साथ की कोशिश की), को छोड़कर platform.architecture() = ('64bit', 'ELF')

WINDOWS (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 के समान है
  • खिड़कियों पर एनाकोंडा आधिकारिक अजगर Windows इंस्टालर रूप में ही है
  • मैं एक मैक है और न ही एक सच्चे 32bit प्रणाली की जरूरत नहीं है और इसे ऑनलाइन करने के लिए प्रेरित नहीं किया गया था

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

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())
23/02/2019 को 02:39
का स्रोत उपयोगकर्ता

वोट
3

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

>>> 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]
20/08/2016 को 08:03
का स्रोत उपयोगकर्ता

वोट
3

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

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
30/10/2014 को 00:43
का स्रोत उपयोगकर्ता

वोट
2
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())
03/02/2019 को 22:43
का स्रोत उपयोगकर्ता

वोट
1

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

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

यहाँ छवि विवरण दर्ज

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

07/02/2019 को 21:10
का स्रोत उपयोगकर्ता

वोट
1

यह समाधान दोनों के लिए काम करता 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()
29/01/2019 को 13:06
का स्रोत उपयोगकर्ता

वोट
1

आप MacOS एक्स चल रहा है और चलाए जा रहे हैं, तो platform.system()आप डार्विन मिलता है क्योंकि MacOS एक्स एप्पल डार्विन ओएस पर बनाया गया है। डार्विन MacOS एक्स के गिरी है और जीयूआई बिना अनिवार्य रूप से MacOS एक्स है।

13/01/2018 को 21:29
का स्रोत उपयोगकर्ता

वोट
1

का प्रयोग करें import osऔर os.nameकीवर्ड।

07/05/2017 को 03:07
का स्रोत उपयोगकर्ता

वोट
0

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

विधि 1

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

यह कैसे काम करता ( स्रोत ): आंतरिक रूप से यह के रूप में ओएस द्वारा परिभाषित ओएस के नाम पाने के लिए ओएस एपीआई कहता है। यह स्पष्ट रूप से संस्करण के लिए संस्करण से बदल सकते हैं, तो सबसे अच्छा सीधे उपयोग करने के लिए नहीं। देखें यहाँ विभिन्न ओएस-विशिष्ट मानों के लिए।

विधि 2

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

यह कैसे काम करता ( स्रोत ): आंतरिक रूप से यह जाँच करता है, तो अजगर ओएस विशिष्ट मॉड्यूल POSIX या NT कहा जाता है। आप उस पर इन मॉड्यूल और कॉल तरीकों आयात करना चाहते हैं, इस महान काम करता है। नोट लिनक्स या OSX के बीच कोई भेदभाव नहीं है।

विधि 3

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

यह कैसे काम करता ( स्रोत ): आंतरिक रूप से यह अंततः आंतरिक ओएस एपीआई फोन करेगा, 'Win32' या 'Win16' या 'linux1' की तरह ओएस संस्करण-विशिष्ट नाम हो जाते हैं और फिर 'विंडोज' या 'लिनक्स' या करने के लिए अधिक सामान्य नाम को सामान्य कई heuristics लगाने से 'डार्विन'। यह सामान्यीकृत ओएस नाम पाने के लिए सबसे अच्छा पोर्टेबल तरीका है।

सारांश

  • आप जाँच करना चाहते हैं, तो ओएस विंडोज या लिनक्स या OSX है तो सबसे विश्वसनीय तरीका है platform.system()
  • आप ओएस-विशिष्ट कॉल लेकिन बनाने के लिए निर्मित अजगर मॉड्यूल के माध्यम से चाहते हैं posixया ntतो का उपयोग os.name
  • आप के रूप में ओएस खुद के द्वारा आपूर्ति की कच्चे ओएस नाम प्राप्त करना चाहते हैं तो का उपयोग sys.platform
24/09/2019 को 02:28
का स्रोत उपयोगकर्ता

वोट
0

मैं बस में मामला किसी को भी यह की जरूरत है, यह एक समारोह का उपयोग मैं मेरी कोड पर समायोजन करने के लिए तो यह विंडोज, लिनक्स और 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'
22/05/2019 को 16:32
का स्रोत उपयोगकर्ता

वोट
0

कैसे निम्नलिखित की तरह एक साधारण Enum कार्यान्वयन के बारे में? बाहरी 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

सीधे शब्दों में आप Enum मान के साथ उपयोग कर सकते हैं

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

पुनश्च यह python3 है

27/09/2018 को 17:39
का स्रोत उपयोगकर्ता

वोट
-4

बस पूर्णता के लिए, "ओएस" वातावरण चर हर जगह में परिभाषित किया जा रहा है। Windows XP पर / 7/8/10 यह "Windows_NT" पर सेट है। लिनक्स SuSE SP2 पर यह "x86-64 linux sles11 [2]" को तैयार है। मैं ओएस एक्स या बीएसडी मशीनों के लिए पहुँच नहीं है, वहाँ के रूप में अच्छी जाँच करने के लिए दिलचस्प हो जाएगा।

import os

os_name = os.getenv("OS")
if os_name == "Windows_NT":
    # Windows
elif "linux" in os_name:
    # Linux
elif ...
01/12/2015 को 07:28
का स्रोत उपयोगकर्ता

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more