मॉनिटर रिज़ॉल्यूशन प्राप्त करने का सबसे सरल तरीका क्या है (अधिमानतः टुपल में)?
Tkinter
मॉड्यूल के साथ , आप इसे इस तरह से कर सकते हैं । यह मानक पायथन लाइब्रेरी का हिस्सा है और अधिकांश यूनिक्स और विंडोज प्लेटफार्मों पर काम करता है।
मॉनिटर रिज़ॉल्यूशन प्राप्त करने का सबसे सरल तरीका क्या है (अधिमानतः टुपल में)?
Tkinter
मॉड्यूल के साथ , आप इसे इस तरह से कर सकते हैं । यह मानक पायथन लाइब्रेरी का हिस्सा है और अधिकांश यूनिक्स और विंडोज प्लेटफार्मों पर काम करता है।
जवाबों:
विंडोज पर:
from win32api import GetSystemMetrics
print("Width =", GetSystemMetrics(0))
print("Height =", GetSystemMetrics(1))
यदि आप उच्च रिज़ॉल्यूशन स्क्रीन के साथ काम कर रहे हैं, तो सुनिश्चित करें कि आपका अजगर इंटरप्रेटर हाईडोपियावेयर है।
इस पोस्ट के आधार पर
highdpiaware
? यह उत्तर में शामिल करने के लिए उपयोगी होगा।
विंडोज में, आप 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)
GetSystemMetrics(78)
और क्या GetSystemMetrics(79)
लौटाता है?
मैंने इस कारण से एक 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 को सपोर्ट करता है लेकिन पुल अनुरोध पूरी तरह से स्वागत योग्य है।
pip install cython pyobjus
हालांकि मुझे OSX पर इसका इस्तेमाल करने से पहले कुछ आवश्यकताओं को स्थापित करना पड़ा (जैसे )
यदि आप wxWindows का उपयोग कर रहे हैं, तो आप बस कर सकते हैं:
import wx
app = wx.App(False) # the wx.App object must be created first.
print(wx.GetDisplaySize()) # returns a tuple
app = wx.App(False)
अन्यथा आपको होना चाहिए "wx.App ऑब्जेक्ट पहले बनाया जाना चाहिए।" त्रुटि। 26 वोट और किसी ने नहीं किया चेक? क्या वैरिएबल में wx इंस्टेंस के बिना विंडोज में काम किया जाता है?
इस पोस्ट के उत्तर से सीधे लिया गया: Tkinter में स्क्रीन का आकार कैसे प्राप्त करें?
import tkinter as tk
root = tk.Tk()
screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()
विंडोज 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 से
Tkinter
कि यह सही पिक्सल का उपयोग कर रहा है, लेकिन डीपीआई स्केलिंग के बारे में पता नहीं है, इस प्रकार गलत मिमी आकार की रिपोर्ट कर रहा है।
ctypes.windll.shcore.SetProcessDpiAwareness(2)
त्रुटि लौटाता है OSError: [WinError 126] The specified module could not be found
।
लिनक्स का उपयोग करना, सबसे आसान तरीका है बैश कमांड को निष्पादित करना
xrandr | grep '*'
और regexp का उपयोग करके अपने आउटपुट को पार्स करें।
इसके अलावा आप इसे PyGame: http://www.daniweb.com/forums/thread54881.html के माध्यम से कर सकते हैं
यहां एक त्वरित छोटा अजगर कार्यक्रम है जो आपके मल्टी-मॉनिटर सेटअप के बारे में जानकारी प्रदर्शित करेगा:
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
हैं सभी मॉनिटर शामिल हैं ?
gtk.Window()
एक नई विंडो ( यहाँ देखें ) क्या है। get_screen
मॉनिटर की जानकारी प्राप्त करने के लिए विंडो का उपयोग करने का एक तरीका है । यह स्क्रीन को वापस करता है कि खिड़की चालू है (या होगा, अगर यह कभी प्रदर्शित किया गया था)। मुझे लगता है कि यह एक्स कॉन्फ़िगरेशन पर निर्भर करता है कि क्या "स्क्रीन" में सभी "मॉनिटर" शामिल हैं। यह ट्विनव्यू के साथ मेरे सिस्टम पर करता है।
मैं अपने एक प्रोजेक्ट में नीचे की तरह 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)
पुराना सवाल है लेकिन यह गायब है। मैं अजगर के लिए नया हूं इसलिए कृपया मुझे बताएं कि क्या यह "बुरा" समाधान है। यह समाधान केवल विंडोज और मैकओएस के लिए समर्थित है और यह सिर्फ मुख्य स्क्रीन के लिए काम करता है - लेकिन प्रश्न में ओएस का उल्लेख नहीं किया गया है।
स्क्रीनशॉट लेकर साइज नापें। जैसा कि स्क्रीनसेज़ को नहीं बदलना चाहिए, इसे केवल एक बार किया जाना चाहिए। यदि आपके पास GTK, wx, ... जैसे कोई टूलकिट है, तो अधिक सुरुचिपूर्ण समाधान हैं।
तकिया देखें
pip install Pillow
from PIL import ImageGrab
img = ImageGrab.grab()
print (img.size)
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
(केवल लिनक्स पर परीक्षण किया गया क्रॉस-प्लेटफॉर्म काम करना चाहिए)
निम्नलिखित कोड आज़माएं:
import subprocess
resuls = subprocess.Popen(['xrandr'],stdout=subprocess.PIPE).communicate()[0].split("current")[1].split(",")[0]
width = resuls.split("x")[0].strip()
heigth = resuls.split("x")[1].strip()
print width + "x" + heigth
यदि आपके पास 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))
लिनक्स का उपयोग करके रेगेक्सपी के बजाय पहली पंक्ति लें और वर्तमान रिज़ॉल्यूशन मानों को बाहर निकालें।
प्रदर्शन का वर्तमान रिज़ॉल्यूशन: 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 पर किया गया था, मुझे नहीं पता कि आउटपुट अन्य संस्करणों पर अलग है या नहीं, लेकिन इससे यह पता लगाना आसान हो जाता है।
प्रति पिक्सेल बिट्स प्राप्त करने के लिए:
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,
पयुतोगुई आज़माएँ:
import pyautogui
resolution = pyautogui.size()
print(resolution)
Pygame का उपयोग करना :
import pygame
pygame.init()
infos = pygame.display.Info()
screen_size = (infos.current_w, infos.current_h)
हालाँकि, यदि आप अपनी विंडो को स्क्रीन के आकार में सेट करने का प्रयास कर रहे हैं, तो आप बस करना चाहते हैं:
pygame.display.set_mode((0,0),pygame.FULLSCREEN)
अपने प्रदर्शन को फुलस्क्रीन मोड पर सेट करने के लिए। [2]
आप PyMouse का उपयोग कर सकते हैं । स्क्रीन आकार प्राप्त करने के लिए बस screen_size()
विशेषता का उपयोग करें :
from pymouse import PyMouse
m = PyMouse()
a = m.screen_size()
a
एक टपल लौटाएगा (X, Y)
, जहां X
क्षैतिज स्थिति है औरY
ऊर्ध्वाधर स्थिति है।
यदि आप 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 पर काम करता है
लिनक्स पर हम सबप्रोसेस मॉड्यूल का उपयोग कर सकते हैं
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())
यह रेटिना स्क्रीन के लिए थोड़ा परेशान करने वाला है, मैं नकली साइज पाने के लिए टिक्चर का इस्तेमाल करता हूं, असली साइज पाने के लिए पिल्लो ग्रैब का इस्तेमाल करता हूं:
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
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))
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)