Как получить разрешение монитора в Python?

какой самый простой способ получить разрешение монитора (желательно в кортеж)?

906   22  

22 ответов:

На Windows:

from win32api import GetSystemMetrics

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

Если вы работаете с экраном высокого разрешения, убедитесь, что ваш интерпретатор python является HIGHDPIAWARE.

на основе этой пост.

42  
2018-07-30 18:20:21

В 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)
84  
2018-07-31 23:06:28

Я создал модуль 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, но запросы pull полностью приветствуются.

46  
2018-07-31 19:48:31

Если вы используете wxWindows, вы можете просто сделать:

import wx

app = wx.App(False) # the wx.App object must be created first.    
print(wx.GetDisplaySize())  # returns a tuple
40  
2017-08-30 17:55:44

взято непосредственно из ответа на этот пост:Как получить размер экрана в Tkinter?

import tkinter as tk

root = tk.Tk()

screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()
26  
2017-05-23 14:33:24

В Windows 8.1 я не получаю правильное разрешение ни от ctypes, ни от tk. Другие люди испытывают ту же проблему для ctypes: getsystemmetrics возвращает неправильный Размер экрана Чтобы получить правильное полное разрешение монитора с высоким разрешением DPI в windows 8.1, необходимо вызвать SetProcessDPIAware и использовать следующий код:

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

Полная Информация Ниже:

я узнал, что это потому, что windows сообщает масштабируемое разрешение. Оказывается, что python по умолчанию является приложением "system dpi aware". Типы приложений с поддержкой 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)
Сообщается разрешение python: 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

я запускаю windows 8.1 с монитором с разрешением 220 точек на дюйм. Мое масштабирование дисплея устанавливает мой текущий DPI на 158.

Я буду использовать 158, чтобы убедиться, что мои графики matplotlib имеют правильный размер с: из pylab импортируют rcParams rcParams ['рисунок.dpi'] = curr_dpi

18  
2017-05-23 15:18:36

и для полноты картины, Mac OS X

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

даст вам список кортежей, содержащих все размеры экрана (если несколько мониторов присутствует)

15  
2010-06-28 04:09:39

Если вы используете 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  
2015-05-18 04:55:44

используя Linux, самый простой способ-выполнить команду bash

xrandr | grep '*'

и проанализировать его вывод с помощью регулярного выражения.

также вы можете сделать это через PyGame:http://www.daniweb.com/forums/thread54881.html

12  
2010-06-28 02:53:58

вот быстрая маленькая программа 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)
12  
2014-05-12 14:39:44

Я использую метод 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)
7  
2014-01-19 06:18:37

версия 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  
2013-04-22 06:24:19

попробуйте следующий код:

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
5  
2015-10-12 21:48:42

старый вопрос, но это отсутствует. Я новичок в Python, поэтому, пожалуйста, скажите мне, если это "плохое" решение. Это решение поддерживается только для windows и mac, и оно работает только для главного экрана - но ОС не упоминается в вопросе.

измерьте размер, сделав снимок экрана. Поскольку screensize не должен меняться, это должно быть сделано только один раз. Есть более элегантные решения, если у вас есть графический инструментарий, такой как gtk, wx,... установленный.

посмотреть подушка

pip install Pillow

from PIL import ImageGrab

img = ImageGrab.grab
print (img.size)
5  
2017-03-21 12:13:37

Если у Вас установлен 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  
2018-02-02 06:18:33

Использование 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, я не знаю, отличается ли выход на других версиях, но это должно сделать его легко понять.

3  
2013-03-28 07:33:55

чтобы получить бит на пиксель:

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,
2  
2014-06-19 18:26:55

другая версия с помощью 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  
2017-08-02 21:03:38

используя , С которым 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]

2  
2017-10-09 21:27:00

попробуйте pyautogui:

import pyautogui
resolution = pyautogui.size()
print(resolution)
1  
2016-08-15 23:38:11

вы могли бы использовать PyMouse. Чтобы получить размер экрана просто используйте :

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

a возвращает кортеж, (X, Y), где X - это горизонтальное положение и Y - вертикальное положение.

ссылка на функцию в документации.

0  
2018-04-15 17:16:07

в 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())
0  
2018-09-28 10:43:11

Comments

    Ничего не найдено.
Click here to cancel reply.