Python에서 모니터 해상도를 얻으려면 어떻게해야합니까?

모니터 해상도를 얻는 가장 간단한 방법은 무엇입니까 (가급적 튜플에서)?

Windows의 경우 :

from win32api import GetSystemMetrics

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

고해상도 화면으로 작업하는 경우 Python 인터프리터가 HIGHDPIAWARE인지 확인하십시오.

이 게시물을 기반으로 합니다 .

Windows에서는 다음과 함께 ctypes를 사용할 수도 있습니다 GetSystemMetrics().

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

따라서 pywin32 패키지를 설치할 필요가 없습니다. Python 자체와 함께 제공되지 않는 것은 필요하지 않습니다.

다중 모니터 설정의 경우 가상 모니터의 결합 된 너비와 높이를 검색 할 수 있습니다.

import ctypes
user32 = ctypes.windll.user32
screensize = user32.GetSystemMetrics(78), user32.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을 지원하지만 풀 요청은 전적으로 환영합니다.

wxWindows를 사용하는 경우 다음을 수행 할 수 있습니다.

import wx

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

이 게시물에 대한 답변에서 직접 발췌 : Tkinter에서 화면 크기를 얻는 방법?

import tkinter as tk

root = tk.Tk()

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

Windows 8.1에서 ctypes 또는 tk에서 올바른 해상도를 얻지 못합니다. 다른 사람들이 ctypes에 대해 동일한 문제를 겪고 있습니다 . getsystemmetrics가 잘못된 화면 크기 를 반환합니다 . Windows 8.1에서 높은 DPI 모니터의 올바른 전체 해상도를 얻으려면 SetProcessDPIAware를 호출하고 다음 코드를 사용해야합니다.

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

아래 전체 세부 정보 :

윈도우가 스케일 된 해상도를보고하기 때문이라는 것을 알았습니다. 파이썬은 기본적으로 '시스템 dpi 인식'응용 프로그램 인 것으로 보입니다. DPI 인식 응용 프로그램의 유형은 다음과 같습니다. http://msdn.microsoft.com/en-us/library/windows/desktop/dn469266%28v=vs.85%29.aspx#dpi_and_the_desktop_scaling_factor

기본적으로 콘텐츠를 전체 모니터 해상도로 표시하여 글꼴을 작게 만드는 대신 글꼴이 충분히 커질 때까지 콘텐츠가 확대됩니다.

내 모니터에서 다음을 얻습니다.
물리적 해상도 : 2560 x 1440 (220 DPI)
보고 된 파이썬 해상도 : 1555 x 875 (158 DPI)

이 Windows 사이트별로 : http://msdn.microsoft.com/en-us/library/aa770067%28v=vs.85%29.aspx 보고 된 시스템 유효 해상도의 공식은 다음과 같습니다. (reported_px * current_dpi) / (96 dpi ) = physical_px

아래 코드를 사용하여 올바른 전체 화면 해상도와 현재 DPI를 얻을 수 있습니다. 프로그램이 실제 해상도를 볼 수 있도록 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 DPI 지원 모니터로 Windows 8.1을 실행하고 있습니다. 내 디스플레이 배율은 현재 DPI를 158로 설정합니다.

158을 사용하여 matplotlib 플롯이 올바른 크기인지 확인합니다. from pylab import rcParams rcParams [ 'figure.dpi'] = curr_dpi

완전성을 위해 Mac OS X

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

모든 화면 크기를 포함하는 튜플 목록을 제공합니다 (여러 모니터가있는 경우).

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

Linux를 사용하는 가장 간단한 방법은 bash 명령을 실행하는 것입니다.

xrandr | grep '*'

regexp를 사용하여 출력을 구문 분석합니다.

또한 PyGame을 통해 할 수 있습니다 : http://www.daniweb.com/forums/thread54881.html

다음은 다중 모니터 설정에 대한 정보를 표시하는 간단한 Python 프로그램입니다.

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)

아래 프로젝트 중 하나에서 기본적으로 가져 오기 체인 인 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)

오래된 질문이지만 이것은 누락되었습니다. 저는 파이썬을 처음 접했기 때문에 이것이 "나쁜"해결책인지 알려주세요. 이 솔루션은 Windows 및 MacOS에서만 지원되며 기본 화면에서만 작동하지만 OS는 질문에 언급되어 있지 않습니다.

스크린 샷을 찍어 크기를 측정합니다. 화면 크기가 변경되지 않아야하므로 한 번만 수행하면됩니다. GTK, wx, ...와 같은 GUI 툴킷이 설치되어 있다면 더 우아한 솔루션이 있습니다.

베개 참조

pip install Pillow

from PIL import ImageGrab

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

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)

@ user2366975 의 답변을 확장 하여 Tkinter (Python 2/3 코드)를 사용하여 다중 화면 설정에서 현재 화면 크기를 가져옵니다.

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

(크로스 플랫폼에서 작동해야하며 Linux에서만 테스트)

다음 코드를 시도하십시오.

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

크로스 플랫폼과이를위한 쉬운 방법은 거의 모든 파이썬 버전과 함께 제공되는 TKinter를 사용하는 것이므로 아무것도 설치할 필요가 없습니다.

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

정규식 대신 Linux 사용 첫 번째 줄을 사용하고 현재 해상도 값을 가져옵니다.

디스플레이의 현재 해상도 : 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))

gdi32의 매개 변수 :

#/// 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,

pyautogui 시도 :

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

다음을 사용하는 다른 버전 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)

파이 게임 사용 :

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]

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::]))

또한 튜플 반환 (Y, X) Y는 세로 크기이고, X는 수평 크기이다. 이 코드는 Python 2 및 Python 3에서 작동합니다.

Linux에서는 하위 프로세스 모듈을 사용할 수 있습니다.

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

망막 화면에는 약간 귀찮습니다. tkinter를 사용하여 가짜 크기를 얻고 필로우 그랩을 사용하여 실제 크기를 얻습니다.

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

Linux의 경우 다음을 사용할 수 있습니다.

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)

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)