पायथन में मुझे मॉनिटर रिज़ॉल्यूशन कैसे मिलता है?


126

मॉनिटर रिज़ॉल्यूशन प्राप्त करने का सबसे सरल तरीका क्या है (अधिमानतः टुपल में)?


क्या आप किसी विशेष UI टूलकिट का उपयोग कर रहे हैं? (। जैसे जीटीके, wxPython, Tkinter, आदि)
detly

11
Tkinterमॉड्यूल के साथ , आप इसे इस तरह से कर सकते हैं । यह मानक पायथन लाइब्रेरी का हिस्सा है और अधिकांश यूनिक्स और विंडोज प्लेटफार्मों पर काम करता है।
मार्टीन्यू

1
आम यूआई के लिए विभिन्न तकनीकों पर एक अच्छा अवलोकन इस लिंक
ImportanceOfBeingErnest

जवाबों:


75

विंडोज पर:

from win32api import GetSystemMetrics

print("Width =", GetSystemMetrics(0))
print("Height =", GetSystemMetrics(1))

यदि आप उच्च रिज़ॉल्यूशन स्क्रीन के साथ काम कर रहे हैं, तो सुनिश्चित करें कि आपका अजगर इंटरप्रेटर हाईडोपियावेयर है।

इस पोस्ट के आधार पर


9
मल्टीप्लास्टिक पूर्ण समाधान के लिए, इस उत्तर
ध्रुव रेशमवाला

1
कई मॉनिटर का उपयोग करते समय, यह केवल प्राथमिक डिस्प्ले का आकार लौटाएगा।
स्टेवोइसाक

1
आप अजगर दुभाषिया कैसे सेट करते हैं highdpiaware? यह उत्तर में शामिल करने के लिए उपयोगी होगा।
एरिक

121

विंडोज में, आप ctypes का भी उपयोग कर सकते हैं GetSystemMetrics():

import ctypes
user32 = ctypes.windll.user32
screensize = user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)

ताकि आपको pywin32 पैकेज स्थापित करने की आवश्यकता न हो; इसे ऐसी किसी भी चीज़ की ज़रूरत नहीं है जो पायथन के साथ ही नहीं आती है।

मल्टी-मॉनिटर सेटअप के लिए, आप वर्चुअल मॉनिटर की संयुक्त चौड़ाई और ऊंचाई को पुनः प्राप्त कर सकते हैं:

import ctypes
user32 = ctypes.windll.user32
screensize = user32.GetSystemMetrics(78), user32.GetSystemMetrics(79)

11
महत्वपूर्ण नोट: यदि DPI स्केलिंग का उपयोग किया जाता है, तो लौटाए गए मान गलत हो सकते हैं (जैसे: अक्सर 4k डिस्प्ले पर मामला), आपको GUI घटकों को प्रारंभ करने से पहले SetProcessDPIAware को कॉल करना होगा (और गेटस्मार्टमेट फ़ंक्शन को कॉल करने से पहले नहीं)। यह win32 प्लेटफ़ॉर्म पर यहां (GTK, आदि) के अधिकांश उत्तरों के लिए सही है।
4

1
कई मॉनिटर के लिए, आप GetSystemMetrics (78) और GetSystemMetrics (79)
डेरेक

@ डेरेक क्या करता है GetSystemMetrics(78)और क्या GetSystemMetrics(79)लौटाता है?
Stevoisiak

@StevenVascellaro पिक्सल में वर्चुअल स्क्रीन की चौड़ाई / ऊंचाई। msdn.microsoft.com/en-us/library/windows/desktop/…
डेरेक

94

मैंने इस कारण से एक PyPI मॉड्यूल बनाया :

pip install screeninfo

कोड:

from screeninfo import get_monitors
for m in get_monitors():
    print(str(m))

परिणाम:

monitor(1920x1080+1920+0)
monitor(1920x1080+0+0)

यह मल्टी मॉनिटर वातावरण का समर्थन करता है । इसका लक्ष्य क्रॉस प्लेटफॉर्म होना है; अभी के लिए यह Cygwin और X11 को सपोर्ट करता है लेकिन पुल अनुरोध पूरी तरह से स्वागत योग्य है।


2
विंडोज पर बहुत अच्छा काम करता है, लेकिन मैक मुझे निम्न त्रुटि मिलती है: ImportError: X11 लोड नहीं कर सका
क्रिस ल्यूसियन

5
उबंटू में बढ़िया काम करता है। उबंटू 16.04 पर परीक्षण किया गया।
ध्रुव रेशमवाला

3
FYI करें, Windows DPI स्केलिंग अभी भी लागू होता है। यह पंक्ति विंडोज को बताएगी कि आप क्या चाहते हैं कच्चा, कच्चा संकल्प: "आयात ctypes; user32 = ctypes.windll.user32; user32.SetProcessDPIAware ()"। 1) आपका उत्तर शीर्ष होना चाहिए; बहुत बढ़िया। 2) मेरी टिप्पणी विंडोज-विशिष्ट है, न कि लाइब्रेरी स्पेसिफिक (यानी स्क्रीनइनफो) 3) कोड को कोबजहोन की टिप्पणी से यहाँ रिप्ड और टेस्ट किया गया है: stackoverflow.com/a/32541666/2616321
जेसन 2616321

6
आसान मॉड्यूल (+1)। pip install cython pyobjusहालांकि मुझे OSX पर इसका इस्तेमाल करने से पहले कुछ आवश्यकताओं को स्थापित करना पड़ा (जैसे )
जॉर्ज प्रोफेंज़ा

45

यदि आप wxWindows का उपयोग कर रहे हैं, तो आप बस कर सकते हैं:

import wx

app = wx.App(False) # the wx.App object must be created first.    
print(wx.GetDisplaySize())  # returns a tuple

यह सबसे अच्छा है ... जो wx नहीं है? :) और आपकी आंखों पर कोड का एक गुच्छा के अलावा कुछ पंक्तियाँ। यह अब मेरी डिफ़ॉल्ट विधि है, धन्यवाद।
m3nda 11

1
यह app = wx.App(False)अन्यथा आपको होना चाहिए "wx.App ऑब्जेक्ट पहले बनाया जाना चाहिए।" त्रुटि। 26 वोट और किसी ने नहीं किया चेक? क्या वैरिएबल में wx इंस्टेंस के बिना विंडोज में काम किया जाता है?
m3nda

2
कौन नहीं है wx? बुहत सारे लोग?
आदर्श

43

इस पोस्ट के उत्तर से सीधे लिया गया: Tkinter में स्क्रीन का आकार कैसे प्राप्त करें?

import tkinter as tk

root = tk.Tk()

screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()

8
यदि आपके पास प्राथमिक डिस्प्ले के बगल में बाहरी डिस्प्ले हैं, तो यह पद्धति सभी डिस्प्ले रिज़ॉल्यूशन का योग देगी, न कि वर्तमान डिस्प्ले रिज़ॉल्यूशन।
जूलॉर्ड

एक मल्टीपल स्क्रीन स्टेप के लिए मेरा उत्तर देखें ।
नोरोक 2

29

विंडोज 8.1 पर मुझे ctypes या tk में से सही रिज़ॉल्यूशन नहीं मिल रहा है। अन्य लोगों को ctypes के लिए यही समस्या हो रही है: getystemmetrics गलत स्क्रीन साइज देता है। विंडोज़ 8.1 पर एक उच्च DPI मॉनिटर का सही पूर्ण रिज़ॉल्यूशन प्राप्त करने के लिए, किसी को SetProcessDPIAware को कॉल करना होगा और निम्नलिखित कोड का उपयोग करना होगा:

import ctypes
user32 = ctypes.windll.user32
user32.SetProcessDPIAware()
[w, h] = [user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)]

नीचे पूर्ण विवरण:

मुझे पता चला कि यह इसलिए है क्योंकि खिड़कियां एक बड़े पैमाने पर रिज़ॉल्यूशन की रिपोर्ट कर रही हैं। ऐसा प्रतीत होता है कि अजगर डिफ़ॉल्ट रूप से एक 'सिस्टम डीपीआई जागरूक' एप्लिकेशन है। DPI के प्रकारों के बारे में जानकारी यहाँ सूचीबद्ध है: http://msdn.microsoft.com/en-us/library/windows/desktop/dn469266%28v=vs.85%29.aspx#dpi_and__desktop_scaling_factor

मूल रूप से, सामग्री को पूर्ण मॉनिटर रिज़ॉल्यूशन प्रदर्शित करने के बजाय, जो फोंट को छोटा बना देगा, तब तक सामग्री को छोटा किया जाता है जब तक कि फोंट काफी बड़ा न हो जाए।

मेरे मॉनिटर पर मुझे मिलता है:
शारीरिक संकल्प: 2560 x 1440 (220 DPI)
रिपोर्टेड पायथन रिज़ॉल्यूशन: 1555 x 875 (158 DPI)

इस विंडो साइट के अनुसार: http://msdn.microsoft.com/en-us/library/aa770067%28v=vs.85%29.aspx रिपोर्ट सिस्टम प्रभावी रिज़ॉल्यूशन के लिए सूत्र है: (report_px * current_dpi) / (96 डीपीआई) ) = physical_px

मैं नीचे दिए गए कोड के साथ सही पूर्ण स्क्रीन रिज़ॉल्यूशन, और वर्तमान डीपीआई प्राप्त करने में सक्षम हूं। ध्यान दें कि मैं SetProcessDPIAware () को प्रोग्राम को वास्तविक रिज़ॉल्यूशन देखने की अनुमति देने के लिए कहता हूं।

import tkinter as tk
root = tk.Tk()

width_px = root.winfo_screenwidth()
height_px = root.winfo_screenheight() 
width_mm = root.winfo_screenmmwidth()
height_mm = root.winfo_screenmmheight() 
# 2.54 cm = in
width_in = width_mm / 25.4
height_in = height_mm / 25.4
width_dpi = width_px/width_in
height_dpi = height_px/height_in 

print('Width: %i px, Height: %i px' % (width_px, height_px))
print('Width: %i mm, Height: %i mm' % (width_mm, height_mm))
print('Width: %f in, Height: %f in' % (width_in, height_in))
print('Width: %f dpi, Height: %f dpi' % (width_dpi, height_dpi))

import ctypes
user32 = ctypes.windll.user32
user32.SetProcessDPIAware()
[w, h] = [user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)]
print('Size is %f %f' % (w, h))

curr_dpi = w*96/width_px
print('Current DPI is %f' % (curr_dpi))    

जो लौटा:

Width: 1555 px, Height: 875 px
Width: 411 mm, Height: 232 mm
Width: 16.181102 in, Height: 9.133858 in
Width: 96.099757 dpi, Height: 95.797414 dpi
Size is 2560.000000 1440.000000
Current DPI is 158.045016

मैं एक 220 डीपीआई सक्षम मॉनिटर के साथ विंडोज 8.1 चला रहा हूं। मेरा प्रदर्शन स्केलिंग मेरे वर्तमान DPI को 158 पर सेट करता है।

मैं यह सुनिश्चित करने के लिए 158 का उपयोग करूंगा कि मेरे मैटलपोटलिब प्लॉट सही आकार के हैं: पाइलैब आयात rcParams rcParams ['Fig.dpi'] = curr_dpi से


आपके पास यहां बहुत सारी अच्छी जानकारी है, लेकिन जवाब खुद ही बीच में दफन हो जाता है। इसे पढ़ना थोड़ा आसान बनाने के लिए, क्या आप स्पष्ट रूप से बता सकते हैं कि उत्तर क्या है और फिर पृष्ठभूमि की जानकारी प्रदान करें?
skrrgwasme

मैंने शुरुआत में जवाब दिखाने के लिए अपनी पोस्ट को संपादित किया, फिर विवरण में मिला। प्रतिक्रिया के लिए धन्यवाद।
स्पेसर

1
ऐसा लगता है कि यहां गणनाओं में एक दोष है, जो कि यह रिपोर्ट करना आसान है कि आप रिपोर्ट की गई चौड़ाई और ऊंचाई (इंच में) से एक विकर्ण आकार की गणना करते हैं। 13.3 इंच विकर्ण वाली मेरी स्क्रीन 15 इंच बताई गई। ऐसा लगता है Tkinterकि यह सही पिक्सल का उपयोग कर रहा है, लेकिन डीपीआई स्केलिंग के बारे में पता नहीं है, इस प्रकार गलत मिमी आकार की रिपोर्ट कर रहा है।
प्राइमर

यह विंडोज 10 पर काम नहीं करता है, वहां सेटसिस्टमडीपीआईएवेयर () अंतर नहीं लगता है। हालाँकि, इसके बजाय ctypes.windll.shcore.SetProcessDpiA जागरूकता (2) को कॉल करना चाल को लगता है।
क्लेमर स्कुटे

@KlamerSchutte: ctypes.windll.shcore.SetProcessDpiAwareness(2)त्रुटि लौटाता है OSError: [WinError 126] The specified module could not be found
एड्रियन कीस्टर

21

और पूर्णता के लिए, मैक ओएस एक्स

import AppKit
[(screen.frame().size.width, screen.frame().size.height)
    for screen in AppKit.NSScreen.screens()]

आप सभी स्क्रीन आकार (यदि कई मॉनिटर मौजूद है) युक्त tuples की एक सूची देगा


15

यदि आप Qtटूलकिट का विशेष रूप से उपयोग कर रहे हैं PySide, तो आप निम्न कार्य कर सकते हैं:

from PySide import QtGui
import sys

app = QtGui.QApplication(sys.argv)
screen_rect = app.desktop().screenGeometry()
width, height = screen_rect.width(), screen_rect.height()

13

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

xrandr | grep '*'

और regexp का उपयोग करके अपने आउटपुट को पार्स करें।

इसके अलावा आप इसे PyGame: http://www.daniweb.com/forums/thread54881.html के माध्यम से कर सकते हैं


स्क्रीन रिज़ॉल्यूशन पाने के लिए आप pygame का उपयोग कैसे करते हैं?
जेमी ट्वेल्स

11

यहां एक त्वरित छोटा अजगर कार्यक्रम है जो आपके मल्टी-मॉनिटर सेटअप के बारे में जानकारी प्रदर्शित करेगा:

import gtk

window = gtk.Window()

# the screen contains all monitors
screen = window.get_screen()
print "screen size: %d x %d" % (gtk.gdk.screen_width(),gtk.gdk.screen_height())

# collect data about each monitor
monitors = []
nmons = screen.get_n_monitors()
print "there are %d monitors" % nmons
for m in range(nmons):
  mg = screen.get_monitor_geometry(m)
  print "monitor %d: %d x %d" % (m,mg.width,mg.height)
  monitors.append(mg)

# current monitor
curmon = screen.get_monitor_at_window(screen.get_active_window())
x, y, width, height = monitors[curmon]
print "monitor %d: %d x %d (current)" % (curmon,width,height)  

यहाँ इसके उत्पादन का एक उदाहरण है:

screen size: 5120 x 1200
there are 3 monitors
monitor 0: 1600 x 1200
monitor 1: 1920 x 1200
monitor 2: 1600 x 1200
monitor 1: 1920 x 1200 (current)

करता gtk.Window()मिलता है gdk_default_root_window? क्या यह है कि आप कैसे निश्चित .get_screenहैं सभी मॉनिटर शामिल हैं ?
यग १g

मैं पूछता हूं क्योंकि मेरे कोड में Im आपके कोड को दोहराने की कोशिश कर रहा है, मैं इसे jsctypes में कर रहा हूं, और यह मुझे 0 मॉनिटर बताता रहता है: gist.github.com/yajd/55441c9c3d07115aa38#file-gistfile1-txt-L3
yatg

2
जब से मैंने उस कोड को लिखा है तब से थोड़ी देर है, लेकिन अगर मुझे सही से याद है, तो gtk.Window()एक नई विंडो ( यहाँ देखें ) क्या है। get_screenमॉनिटर की जानकारी प्राप्त करने के लिए विंडो का उपयोग करने का एक तरीका है । यह स्क्रीन को वापस करता है कि खिड़की चालू है (या होगा, अगर यह कभी प्रदर्शित किया गया था)। मुझे लगता है कि यह एक्स कॉन्फ़िगरेशन पर निर्भर करता है कि क्या "स्क्रीन" में सभी "मॉनिटर" शामिल हैं। यह ट्विनव्यू के साथ मेरे सिस्टम पर करता है।
स्टारफ्री

धन्यवाद @ स्टारफ्री! मुझे एक क्रॉस समाधान खोजने की आवश्यकता थी जो सभी मॉनिटर और उनके आयामों को स्क्रीन की परवाह किए बिना प्राप्त करता है। क्या आपके पास ऐसा कुछ विकसित करने का कोई चांस है? :)
यटग

बाद के टूलकिट संस्करणों के लिए वैकल्पिक: `` `अजगर
सत्याग्रह

9

मैं अपने एक प्रोजेक्ट में नीचे की तरह get_screen_resolution विधि का उपयोग कर रहा हूं, जो मूल रूप से एक आयात श्रृंखला है। आप अपनी आवश्यकताओं के अनुसार उन भागों को हटाकर संशोधित कर सकते हैं जिनकी आवश्यकता नहीं है और श्रृंखला में अधिक संभावित बंदरगाहों को ऊपर की ओर ले जाते हैं।

PYTHON_V3 = sys.version_info >= (3,0,0) and sys.version_info < (4,0,0):
#[...]
    def get_screen_resolution(self, measurement="px"):
        """
        Tries to detect the screen resolution from the system.
        @param measurement: The measurement to describe the screen resolution in. Can be either 'px', 'inch' or 'mm'. 
        @return: (screen_width,screen_height) where screen_width and screen_height are int types according to measurement.
        """
        mm_per_inch = 25.4
        px_per_inch =  72.0 #most common
        try: # Platforms supported by GTK3, Fx Linux/BSD
            from gi.repository import Gdk 
            screen = Gdk.Screen.get_default()
            if measurement=="px":
                width = screen.get_width()
                height = screen.get_height()
            elif measurement=="inch":
                width = screen.get_width_mm()/mm_per_inch
                height = screen.get_height_mm()/mm_per_inch
            elif measurement=="mm":
                width = screen.get_width_mm()
                height = screen.get_height_mm()
            else:
                raise NotImplementedError("Handling %s is not implemented." % measurement)
            return (width,height)
        except:
            try: #Probably the most OS independent way
                if PYTHON_V3: 
                    import tkinter 
                else:
                    import Tkinter as tkinter
                root = tkinter.Tk()
                if measurement=="px":
                    width = root.winfo_screenwidth()
                    height = root.winfo_screenheight()
                elif measurement=="inch":
                    width = root.winfo_screenmmwidth()/mm_per_inch
                    height = root.winfo_screenmmheight()/mm_per_inch
                elif measurement=="mm":
                    width = root.winfo_screenmmwidth()
                    height = root.winfo_screenmmheight()
                else:
                    raise NotImplementedError("Handling %s is not implemented." % measurement)
                return (width,height)
            except:
                try: #Windows only
                    from win32api import GetSystemMetrics 
                    width_px = GetSystemMetrics (0)
                    height_px = GetSystemMetrics (1)
                    if measurement=="px":
                        return (width_px,height_px)
                    elif measurement=="inch":
                        return (width_px/px_per_inch,height_px/px_per_inch)
                    elif measurement=="mm":
                        return (width_px/mm_per_inch,height_px/mm_per_inch)
                    else:
                        raise NotImplementedError("Handling %s is not implemented." % measurement)
                except:
                    try: # Windows only
                        import ctypes
                        user32 = ctypes.windll.user32
                        width_px = user32.GetSystemMetrics(0)
                        height_px = user32.GetSystemMetrics(1)
                        if measurement=="px":
                            return (width_px,height_px)
                        elif measurement=="inch":
                            return (width_px/px_per_inch,height_px/px_per_inch)
                        elif measurement=="mm":
                            return (width_px/mm_per_inch,height_px/mm_per_inch)
                        else:
                            raise NotImplementedError("Handling %s is not implemented." % measurement)
                    except:
                        try: # Mac OS X only
                            import AppKit 
                            for screen in AppKit.NSScreen.screens():
                                width_px = screen.frame().size.width
                                height_px = screen.frame().size.height
                                if measurement=="px":
                                    return (width_px,height_px)
                                elif measurement=="inch":
                                    return (width_px/px_per_inch,height_px/px_per_inch)
                                elif measurement=="mm":
                                    return (width_px/mm_per_inch,height_px/mm_per_inch)
                                else:
                                    raise NotImplementedError("Handling %s is not implemented." % measurement)
                        except: 
                            try: # Linux/Unix
                                import Xlib.display
                                resolution = Xlib.display.Display().screen().root.get_geometry()
                                width_px = resolution.width
                                height_px = resolution.height
                                if measurement=="px":
                                    return (width_px,height_px)
                                elif measurement=="inch":
                                    return (width_px/px_per_inch,height_px/px_per_inch)
                                elif measurement=="mm":
                                    return (width_px/mm_per_inch,height_px/mm_per_inch)
                                else:
                                    raise NotImplementedError("Handling %s is not implemented." % measurement)
                            except:
                                try: # Linux/Unix
                                    if not self.is_in_path("xrandr"):
                                        raise ImportError("Cannot read the output of xrandr, if any.")
                                    else:
                                        args = ["xrandr", "-q", "-d", ":0"]
                                        proc = subprocess.Popen(args,stdout=subprocess.PIPE)
                                        for line in iter(proc.stdout.readline,''):
                                            if isinstance(line, bytes):
                                                line = line.decode("utf-8")
                                            if "Screen" in line:
                                                width_px = int(line.split()[7])
                                                height_px = int(line.split()[9][:-1])
                                                if measurement=="px":
                                                    return (width_px,height_px)
                                                elif measurement=="inch":
                                                    return (width_px/px_per_inch,height_px/px_per_inch)
                                                elif measurement=="mm":
                                                    return (width_px/mm_per_inch,height_px/mm_per_inch)
                                                else:
                                                    raise NotImplementedError("Handling %s is not implemented." % measurement)
                                except:
                                    # Failover
                                    screensize = 1366, 768
                                    sys.stderr.write("WARNING: Failed to detect screen size. Falling back to %sx%s" % screensize)
                                    if measurement=="px":
                                        return screensize
                                    elif measurement=="inch":
                                        return (screensize[0]/px_per_inch,screensize[1]/px_per_inch)
                                    elif measurement=="mm":
                                        return (screensize[0]/mm_per_inch,screensize[1]/mm_per_inch)
                                    else:
                                        raise NotImplementedError("Handling %s is not implemented." % measurement)

1
इसे साझा करने के लिए धन्यवाद, लेकिन अगर-और मामलों को संभालने के लिए एक फ़ंक्शन का उपयोग करके इसे बहुत छोटा किया जा सकता है
उदयराज देशमुख

8

पुराना सवाल है लेकिन यह गायब है। मैं अजगर के लिए नया हूं इसलिए कृपया मुझे बताएं कि क्या यह "बुरा" समाधान है। यह समाधान केवल विंडोज और मैकओएस के लिए समर्थित है और यह सिर्फ मुख्य स्क्रीन के लिए काम करता है - लेकिन प्रश्न में ओएस का उल्लेख नहीं किया गया है।

स्क्रीनशॉट लेकर साइज नापें। जैसा कि स्क्रीनसेज़ को नहीं बदलना चाहिए, इसे केवल एक बार किया जाना चाहिए। यदि आपके पास GTK, wx, ... जैसे कोई टूलकिट है, तो अधिक सुरुचिपूर्ण समाधान हैं।

तकिया देखें

pip install Pillow

from PIL import ImageGrab

img = ImageGrab.grab()
print (img.size)

6

XWindows संस्करण:

#!/usr/bin/python

import Xlib
import Xlib.display

resolution = Xlib.display.Display().screen().root.get_geometry()
print str(resolution.width) + "x" + str(resolution.height)

6

Tkinter (Python 2/3 में कोड) का उपयोग करके मल्टी-स्क्रीन सेटअप में वर्तमान स्क्रीन आकार प्राप्त करने के लिए @ user2366975 के उत्तर पर विस्तार करना :

try:
    # for Python 3
    import tkinter as tk
except ImportError:
    # for Python 2
    import Tkinter as tk


def get_curr_screen_geometry():
    """
    Workaround to get the size of the current screen in a multi-screen setup.

    Returns:
        geometry (str): The standard Tk geometry string.
            [width]x[height]+[left]+[top]
    """
    root = tk.Tk()
    root.update_idletasks()
    root.attributes('-fullscreen', True)
    root.state('iconic')
    geometry = root.winfo_geometry()
    root.destroy()
    return geometry

(केवल लिनक्स पर परीक्षण किया गया क्रॉस-प्लेटफॉर्म काम करना चाहिए)



5

यदि आपके पास PyQt4 स्थापित है, तो निम्न कोड आज़माएं:

from PyQt4 import QtGui
import sys

MyApp = QtGui.QApplication(sys.argv)
V = MyApp.desktop().screenGeometry()
h = V.height()
w = V.width()
print("The screen resolution (width X height) is the following:")
print(str(w) + "X" + str(h))

PyQt5 के लिए, निम्नलिखित काम करेगा:

from PyQt5 import QtWidgets
import sys

MyApp = QtWidgets.QApplication(sys.argv)
V = MyApp.desktop().screenGeometry()
h = V.height()
w = V.width()
print("The screen resolution (width X height) is the following:")
print(str(w) + "X" + str(h))

5

एक क्रॉस प्लेटफ़ॉर्म और ऐसा करने का आसान तरीका TKinter का उपयोग करके है जो लगभग सभी अजगर संस्करणों के साथ आता है ताकि आपको इसे स्थापित न करना पड़े:

import tkinter
root = tkinter.Tk()
root.withdraw()
WIDTH, HEIGHT = root.winfo_screenwidth(), root.winfo_screenheight()

3

लिनक्स का उपयोग करके रेगेक्सपी के बजाय पहली पंक्ति लें और वर्तमान रिज़ॉल्यूशन मानों को बाहर निकालें।

प्रदर्शन का वर्तमान रिज़ॉल्यूशन: 0

>>> screen = os.popen("xrandr -q -d :0").readlines()[0]
>>> print screen
Screen 0: minimum 320 x 200, current 1920 x 1080, maximum 1920 x 1920
>>> width = screen.split()[7]
>>> print width
1920
>>> height = screen.split()[9][:-1]
>>> print height
1080
>>> print "Current resolution is %s x %s" % (width,height)
Current resolution is 1920 x 1080

यह xrandr 1.3.5 पर किया गया था, मुझे नहीं पता कि आउटपुट अन्य संस्करणों पर अलग है या नहीं, लेकिन इससे यह पता लगाना आसान हो जाता है।


दुख की बात है मल्टीमिंटन सेटअप के साथ बहुत अच्छा नहीं है। अजगर की गलती नहीं, लेकिन इसके इस्तेमाल से अप्रत्याशित परिणाम हो सकते हैं ...
black_puppydog

2

प्रति पिक्सेल बिट्स प्राप्त करने के लिए:

import ctypes
user32 = ctypes.windll.user32
gdi32 = ctypes.windll.gdi32

screensize = (user32.GetSystemMetrics(0), user32.GetSystemMetrics(1))
print "screensize =%s"%(str(screensize))
dc = user32.GetDC(None);

screensize = (gdi32.GetDeviceCaps(dc,8), gdi32.GetDeviceCaps(dc,10), gdi32.GetDeviceCaps(dc,12))
print "screensize =%s"%(str(screensize))
screensize = (gdi32.GetDeviceCaps(dc,118), gdi32.GetDeviceCaps(dc,117), gdi32.GetDeviceCaps(dc,12))
print "screensize =%s"%(str(screensize))

g3232 में पैरामीटर:

#/// Vertical height of entire desktop in pixels
#DESKTOPVERTRES = 117,
#/// Horizontal width of entire desktop in pixels
#DESKTOPHORZRES = 118,
#/// Horizontal width in pixels
#HORZRES = 8,
#/// Vertical height in pixels
#VERTRES = 10,
#/// Number of bits per pixel
#BITSPIXEL = 12,

2

पयुतोगुई आज़माएँ:

import pyautogui
resolution = pyautogui.size()
print(resolution) 

आपको वास्तव में कुछ स्पष्टीकरण जोड़ना चाहिए कि यह कोड क्यों काम करना चाहिए - आप स्वयं कोड में टिप्पणी भी जोड़ सकते हैं - अपने वर्तमान रूप में, यह कोई स्पष्टीकरण नहीं देता है जो समुदाय के बाकी लोगों को समझने में मदद कर सकता है कि आपने क्या हल किया था /प्रश्न का उत्तर दो। लेकिन यह भी एक बहुत पुराना सवाल है - एक स्वीकृत जवाब के साथ ...
ishmelMakitla

2

एक और संस्करण का उपयोग कर xrandr:

import re
from subprocess import run, PIPE

output = run(['xrandr'], stdout=PIPE).stdout.decode()
result = re.search(r'current (\d+) x (\d+)', output)
width, height = map(int, result.groups()) if result else (800, 600)

2

Pygame का उपयोग करना :

import pygame
pygame.init()
infos = pygame.display.Info()
screen_size = (infos.current_w, infos.current_h)

[1]

हालाँकि, यदि आप अपनी विंडो को स्क्रीन के आकार में सेट करने का प्रयास कर रहे हैं, तो आप बस करना चाहते हैं:

pygame.display.set_mode((0,0),pygame.FULLSCREEN)

अपने प्रदर्शन को फुलस्क्रीन मोड पर सेट करने के लिए। [2]


यह पुष्टि करता है कि यह विंडोज पर काम करता है :) क्या एक अच्छा गैर-विंडोज विशिष्ट तरीका है!
लुकाज़ सेज़रविंस्की

1

आप PyMouse का उपयोग कर सकते हैं । स्क्रीन आकार प्राप्त करने के लिए बस screen_size()विशेषता का उपयोग करें :

from pymouse import PyMouse
m = PyMouse()
a = m.screen_size()

aएक टपल लौटाएगा (X, Y), जहां Xक्षैतिज स्थिति है औरY ऊर्ध्वाधर स्थिति है।

प्रलेखन में कार्य करने के लिए लिंक।


1

यदि आप Windows OS पर काम कर रहे हैं, तो आप इसे प्राप्त करने के लिए OS मॉड्यूल का उपयोग कर सकते हैं:

import os
cmd = 'wmic desktopmonitor get screenheight, screenwidth'
size_tuple = tuple(map(int,os.popen(cmd).read().split()[-2::]))

यह एक tuple (Y, X) लौटाएगा जहां Y ऊर्ध्वाधर आकार है और X क्षैतिज आकार है। यह कोड पायथन 2 और पायथन 3 पर काम करता है


0

लिनक्स पर हम सबप्रोसेस मॉड्यूल का उपयोग कर सकते हैं

import subprocess
cmd = ['xrandr']
cmd2 = ['grep', '*']
p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
p2 = subprocess.Popen(cmd2, stdin=p.stdout, stdout=subprocess.PIPE)
p.stdout.close()

resolution_string, junk = p2.communicate()
resolution = resolution_string.split()[0]
resolution = resolution.decode("utf-8") 
width = int(resolution.split("x")[0].strip())
heigth = int(resolution.split("x")[1].strip())

0

यह रेटिना स्क्रीन के लिए थोड़ा परेशान करने वाला है, मैं नकली साइज पाने के लिए टिक्चर का इस्तेमाल करता हूं, असली साइज पाने के लिए पिल्लो ग्रैब का इस्तेमाल करता हूं:

import tkinter
root = tkinter.Tk()
resolution_width = root.winfo_screenwidth()
resolution_height = root.winfo_screenheight()
image = ImageGrab.grab()
real_width, real_height = image.width, image.height
ratio_width = real_width / resolution_width
ratio_height = real_height/ resolution_height

0

PyGtk के बाद के संस्करणों के लिए:

import gi
gi.require_version("Gdk", "3.0")
from gi.repository import Gdk

display = Gdk.Display.get_default()
n_monitors = display.get_n_monitors()
print("there are %d monitors" % n_monitors)
for m in range(n_monitors):
  monitor = display.get_monitor(m)
  geometry = monitor.get_geometry()
  print("monitor %d: %d x %d" % (m, geometry.width, geometry.height))

0

लिनक्स के लिए, आप इसका उपयोग कर सकते हैं:

import gi
gi.require_version("Gdk", "3.0")
from gi.repository import Gdk

s = Gdk.Screen.get_default()
screen_width = s.get_width()
screen_height = s.get_height()
print(screen_width)
print(screen_height)

0

pynputपुस्तकालय का उपयोग उपयोगिता स्क्रिप्ट । रेफरी के लिए यहां पोस्टिंग:

 
from pynput.mouse import Controller as MouseController

def get_screen_size():
    """Utility function to get screen resolution"""

    mouse = MouseController()

    width = height = 0

    def _reset_mouse_position():
        # Move the mouse to the top left of 
        # the screen
        mouse.position = (0, 0)

    # Reset mouse position
    _reset_mouse_position()

    count = 0
    while 1:
        count += 1
        mouse.move(count, 0)
        
        # Get the current position of the mouse
        left = mouse.position[0]

        # If the left doesn't change anymore, then
        # that's the screen resolution's width
        if width == left:
            # Add the last pixel
            width += 1

            # Reset count for use for height
            count = 0
            break

        # On each iteration, assign the left to 
        # the width
        width = left
    
    # Reset mouse position
    _reset_mouse_position()

    while 1:
        count += 1
        mouse.move(0, count)

        # Get the current position of the mouse
        right = mouse.position[1]

        # If the right doesn't change anymore, then
        # that's the screen resolution's height
        if height == right:
            # Add the last pixel
            height += 1
            break

        # On each iteration, assign the right to 
        # the height
        height = right

    return width, height

>>> get_screen_size()
(1920, 1080)
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.