Làm cách nào để nhận độ phân giải màn hình bằng Python?

Cách đơn giản nhất để có được độ phân giải màn hình (tốt nhất là trong một bộ) là gì?

Trên Windows:

from win32api import GetSystemMetrics

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

Nếu bạn đang làm việc với màn hình có độ phân giải cao, hãy đảm bảo trình thông dịch python của bạn là HIGHDPIAWARE.

Dựa trên bài đăng này .

Trong Windows, bạn cũng có thể sử dụng ctypes với GetSystemMetrics():

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

để bạn không cần cài đặt gói pywin32; nó không cần bất cứ thứ gì không đi kèm với Python.

Đối với thiết lập nhiều màn hình, bạn có thể truy xuất chiều rộng và chiều cao kết hợp của màn hình ảo:

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

Tôi đã tạo một mô-đun PyPI vì lý do này:

pip install screeninfo

Mật mã:

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

Kết quả:

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

Nó hỗ trợ nhiều môi trường màn hình . Mục tiêu của nó là trở thành đa nền tảng; hiện tại nó hỗ trợ Cygwin và X11 nhưng các yêu cầu kéo hoàn toàn được hoan nghênh.

Nếu đang sử dụng wxWindows, bạn chỉ cần thực hiện:

import wx

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

Lấy trực tiếp từ câu trả lời cho bài đăng này: Làm thế nào để lấy kích thước màn hình trong Tkinter?

import tkinter as tk

root = tk.Tk()

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

Trên Windows 8.1, tôi không nhận được độ phân giải chính xác từ ctypes hoặc tk. Những người khác cũng gặp phải vấn đề này đối với ctypes: getystemmetrics trả về kích thước màn hình sai Để có được độ phân giải đầy đủ chính xác của màn hình DPI cao trên windows 8.1, người ta phải gọi SetProcessDPIAware và sử dụng mã sau:

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

Chi tiết đầy đủ bên dưới:

Tôi phát hiện ra rằng điều này là do các cửa sổ đang báo cáo độ phân giải được chia tỷ lệ. Có vẻ như python theo mặc định là ứng dụng 'nhận biết dpi hệ thống'. Các loại ứng dụng nhận biết DPI được liệt kê ở đây: http://msdn.microsoft.com/en-us/library/windows/desktop/dn469266%28v=vs.85%29.aspx#dpi_and_the_desktop_scaling_factor

Về cơ bản, thay vì hiển thị nội dung ở độ phân giải màn hình đầy đủ, điều này sẽ làm cho phông chữ nhỏ, nội dung được tăng tỷ lệ cho đến khi phông chữ đủ lớn.

Trên màn hình của tôi, tôi nhận được:
Độ phân giải vật lý: 2560 x 1440 (220 DPI)
Độ phân giải python được báo cáo: 1555 x 875 (158 DPI)

Theo trang web cửa sổ này: http://msdn.microsoft.com/en-us/library/aa770067%28v=vs.85%29.aspx Công thức cho độ phân giải hiệu quả của hệ thống được báo cáo là: (report_px * current_dpi) / (96 dpi ) = vật lý_px

Tôi có thể nhận được độ phân giải toàn màn hình chính xác và DPI hiện tại bằng mã bên dưới. Lưu ý rằng tôi gọi SetProcessDPIAware () để cho phép chương trình xem độ phân giải thực.

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

Đã trả lại:

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

Tôi đang chạy windows 8.1 với màn hình có khả năng 220 DPI. Tỷ lệ màn hình của tôi đặt DPI hiện tại của tôi thành 158.

Tôi sẽ sử dụng 158 để đảm bảo các ô matplotlib của tôi có kích thước phù hợp với: from pylab import rcParams rcParams ['figure.dpi'] = curr_dpi

Và để hoàn thiện, Mac OS X

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

sẽ cung cấp cho bạn danh sách các bộ chứa tất cả các kích thước màn hình (nếu có nhiều màn hình)

Nếu bạn đang sử dụng Qtbộ công cụ cụ thể PySide, bạn có thể làm như sau:

from PySide import QtGui
import sys

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

Sử dụng Linux, cách đơn giản nhất là thực hiện lệnh bash

xrandr | grep '*'

và phân tích cú pháp đầu ra của nó bằng regexp.

Ngoài ra, bạn có thể làm điều đó thông qua PyGame: http://www.daniweb.com/forums/thread54881.html

Đây là một chương trình Python nhỏ nhanh chóng sẽ hiển thị thông tin về thiết lập đa màn hình của bạn:

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)  

Đây là một ví dụ về đầu ra của nó:

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)

Tôi đang sử dụng phương thức get_screen_resolution trong một trong những dự án của mình như dự án bên dưới, về cơ bản là một chuỗi nhập. Bạn có thể sửa đổi điều này theo nhu cầu của mình bằng cách loại bỏ những phần không cần thiết và di chuyển các cổng có khả năng hơn lên trong chuỗi.

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)

Câu hỏi cũ nhưng cái này còn thiếu. Tôi mới sử dụng python, vì vậy xin vui lòng cho tôi biết nếu đây là một giải pháp "xấu". Giải pháp này chỉ được hỗ trợ cho Windows và MacOS và nó chỉ hoạt động cho màn hình chính - nhưng hệ điều hành không được đề cập trong câu hỏi.

Đo kích thước bằng cách chụp ảnh màn hình. Vì kích thước màn hình không nên thay đổi nên chỉ thực hiện một lần. Có nhiều giải pháp thanh lịch hơn nếu bạn đã cài đặt bộ công cụ gui như GTK, wx, ....

xem Gối

pip install Pillow

from PIL import ImageGrab

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

Phiên bản 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)

Mở rộng theo câu trả lời của @ user2366975 , để có kích thước màn hình hiện tại trong thiết lập đa màn hình bằng Tkinter (mã bằng 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

(Nên hoạt động đa nền tảng, chỉ được thử nghiệm trên Linux)

Hãy thử mã sau:

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

Trong trường hợp bạn đã cài đặt PyQt4, hãy thử mã sau:

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

Đối với PyQt5, những điều sau sẽ hoạt động:

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

Một nền tảng chéo và cách dễ dàng để thực hiện điều này là sử dụng TKinter đi kèm với gần như tất cả các phiên bản python, do đó bạn không phải cài đặt bất kỳ thứ gì:

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

Sử dụng Linux Thay vì regexp, hãy lấy dòng đầu tiên và lấy ra các giá trị độ phân giải hiện tại.

Độ phân giải hiện tại của màn hình: 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

Điều này đã được thực hiện trên xrandr 1.3.5, tôi không biết liệu đầu ra có khác trên các phiên bản khác hay không, nhưng điều này sẽ giúp bạn dễ dàng tìm ra.

Để lấy bit trên mỗi pixel:

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

tham số trong 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,

Hãy thử pyautogui:

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

Một phiên bản khác sử dụng 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)

Sử dụng pygame :

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

[1]

Tuy nhiên, nếu bạn đang cố gắng đặt cửa sổ của mình bằng kích thước của màn hình, bạn có thể chỉ muốn thực hiện:

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

để đặt màn hình của bạn ở chế độ toàn màn hình. [2]

Bạn có thể sử dụng PyMouse . Để có kích thước màn hình, chỉ cần sử dụng screen_size()thuộc tính:

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

asẽ trả về một bộ giá trị, (X, Y)ở đó Xlà vị trí ngang và Ylà vị trí dọc.

Liên kết đến chức năng trong tài liệu.

Nếu bạn đang làm việc trên hệ điều hành Windows, bạn có thể sử dụng mô-đun hệ điều hành để có được nó:

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

Nó sẽ trả về một bộ giá trị (Y, X) trong đó Y là kích thước dọc và X là kích thước ngang. Mã này hoạt động trên Python 2 và Python 3

Trên Linux, chúng ta có thể sử dụng mô-đun quy trình con

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

Có một chút rắc rối đối với màn hình retina, tôi sử dụng tkinter để lấy kích thước giả, sử dụng tính năng lấy tabletlow để có kích thước thật:

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

Đối với các phiên bản sau của 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))

Đối với Linux, bạn có thể sử dụng cái này:

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)

Tập lệnh tiện ích sử dụng pynputthư viện. Đăng ở đây cho ref:

 
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)