如何在 Python 中获取显示器分辨率？

问题描述：

获取显示器分辨率的最简单方法是什么（最好以元组形式）？

解决方案 1：

为此，我创建了一个PyPI 模块：

pip install screeninfo

代码：

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

结果：

Monitor(x=3840, y=0, width=3840, height=2160, width_mm=1420, height_mm=800, name='HDMI-0', is_primary=False)
Monitor(x=0, y=0, width=3840, height=2160, width_mm=708, height_mm=399, name='DP-0', is_primary=True)

它支持多显示器环境。其目标是跨平台；目前它支持 Cygwin 和 X11，但也非常欢迎拉取请求。

解决方案 2：

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

解决方案 3：

在 Windows 上：

from win32api import GetSystemMetrics

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

如果您使用高分辨率屏幕，请确保您的 Python 解释器是 HIGHDPIAWARE。

根据这篇文章。

解决方案 4：

直接取自对帖子如何在 Tkinter 中获取屏幕尺寸？的回答，

import tkinter as tk

root = tk.Tk()

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

解决方案 5：

如果您正在使用 wxWindows (已经安装了 wxPython)，您可以简单地执行以下操作：

import wx

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

解决方案 6：

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

详细信息如下：

我发现这是因为 Windows 报告的是缩放分辨率。看来 Python 默认是一个“系统 DPI 感知”应用程序。DPI 感知应用程序的类型列在此处：
Windows 上的高 DPI 桌面应用程序开发

基本上，它不会以全显示器分辨率显示内容（这会使字体变得很小），而是将内容放大，直到字体足够大。

在我的显示器上我得到：

物理分辨率：2560 x 1440（220 DPI）

报告的python分辨率：1555 x 875（158 DPI）

根据此 Windows 站点：调整比例以适应更高的 DPI 屏幕。报告的系统有效分辨率的公式为：

（报告像素*当前 dpi）/（96 dpi）= 物理像素

我能够使用以下代码获取正确的全屏分辨率和当前 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

我运行的是 Windows 8.1，配有 220 DPI 显示器。我的显示缩放将当前 DPI 设置为 158。

我将使用 158 来确保我的 Matplotlib 图具有正确的大小：

from pylab import rcParams
rcParams['figure.dpi'] = curr_dpi

解决方案 7：

为了完整性，Mac OS X

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

将为您提供包含所有屏幕尺寸的元组列表（如果有多个显示器）

解决方案 8：

老问题，但缺少这个。我是 Python 新手，请告诉我这是否是一个“糟糕”的解决方案。此解决方案仅支持 Windows 和 MacOS，并且仅适用于主屏幕 - 但问题中未提及操作系统。

通过截屏来测量尺寸。由于屏幕尺寸不会改变，因此只需执行一次。如果您安装了 GTK、wx 等 GUI 工具包，则有更优雅的解决方案。

参见枕头

pip install Pillow

from PIL import ImageGrab

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

解决方案 9：

一种跨平台且简单的方法是使用几乎所有 Python 版本都附带的Tkinter，因此您无需安装任何东西：

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

解决方案 10：

扩展@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 上测试）

解决方案 11：

如果您正在使用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()

解决方案 12：

使用Linux，最简单的方法是执行Bash命令

xrandr | grep '*'

并使用正则表达式解析其输出。

您也可以通过Pygame来完成：Pygame - 获取屏幕尺寸

解决方案 13：

我在我的一个项目中使用了 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)

解决方案 14：

这是一个简单的小型 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)

解决方案 15：

X Window版本：

#!/usr/bin/python

import Xlib
import Xlib.display

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

解决方案 16：

尝试 pyautogui：

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

解决方案 17：

如果您安装了 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))

解决方案 18：

在 Linux 上：

import subprocess
import re

def getScreenDimensions():
    xrandrOutput = str(subprocess.Popen(['xrandr'], stdout=subprocess.PIPE).communicate()[0])
    matchObj = re.findall(r'currents(d+) x (d+)', xrandrOutput)
    if matchObj:
        return (int(matchObj[0][0]), int(matchObj[0][1]))

screenWidth, screenHeight = getScreenDimensions()
print(f'{screenWidth} x {screenHeight}')

解决方案 19：

很多答案都使用 tkinter 来查找屏幕高度/宽度（分辨率），但有时需要知道屏幕的跨平台兼容dpi 。这个答案来自此链接，并作为另一篇文章的评论留下，但我花了几个小时才找到。我还没有遇到任何问题，但如果它在您的系统上不起作用，请告诉我！

import tkinter
root = tkinter.Tk()
dpi = root.winfo_fpixels('1i')

对此的文档说明：

winfo_fpixels(number)
# Return the number of pixels for the given distance NUMBER (e.g. "3c") as float

距离数字是数字后跟单位，因此 3c 表示 3 厘米，该函数给出屏幕上 3 厘米处的像素数（如此处所示）。因此，要获取 dpi，我们要求该函数提供 1 英寸屏幕上的像素数（“1i”）。

解决方案 20：

如果你使用的是 Windows 操作系统，则可以使用 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

更新

对于 Windows 8/8.1/10，上述答案不起作用，请改用下一个：

import os
cmd = "wmic path Win32_VideoController get CurrentVerticalResolution,CurrentHorizontalResolution"
size_tuple = tuple(map(int,os.popen(cmd).read().split()[-2::]))

解决方案 21：

迟到了。我想我找到了支持多台显示器的跨平台无依赖库mss（https://pypi.org/project/mss/）：

import mss
sct=mss.mss()
sct.monitors

然后你会得到类似这样的结果：

[{'left': -1440, 'top': 0, 'width': 4000, 'height': 1080},
 {'left': 0, 'top': 0, 'width': 2560, 'height': 1080},
 {'left': -1440, 'top': 180, 'width': 1440, 'height': 900}]

元素 0 是所有显示器组合而成的虚拟屏幕。元素 1 是主显示器，元素 2 是次要显示器。

解决方案 22：

使用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]

解决方案 23：

使用 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 上完成的，我不知道其他版本的输出是否不同，但这应该可以很容易地弄清楚。

解决方案 24：

要获取每像素的位数：

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,

解决方案 25：

另一个版本使用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)

解决方案 26：

您可以使用PyMouse。要获取屏幕尺寸，只需使用以下screen_size()属性：

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

a将返回一个元组，，(X, Y)其中X是水平位置，Y是垂直位置。

链接到文档中的功能。

解决方案 27：

对于视网膜屏幕来说有点麻烦，我使用 tkinter 来获取虚假尺寸，使用 pilllow grab 来获取真实尺寸：

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

解决方案 28：

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

解决方案 29：

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

解决方案 30：

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