Як отримати дозвіл монітора в Python?


126

Який найпростіший спосіб отримати дозвіл монітора (бажано в кортежі)?


Ви використовуєте певний інструментарій інтерфейсу? (наприклад, GTK, wxPython, Tkinter тощо)
детліп

11
З Tkinterмодулем ви можете це зробити так . Це частина стандартної бібліотеки Python і працює на більшості платформ Unix та Windows.
martineau

1
Хороший огляд різних методів для загальних інтерфейсів представлений за цим посиланням
ImportanceOfBeingErnest

Відповіді:


75

У Windows:

from win32api import GetSystemMetrics

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

Якщо ви працюєте з екраном високої роздільної здатності, переконайтесь, що ваш інтерпретатор пітону HIGHDPIAWARE.

На основі цієї публікації.


9
Щоб отримати повний розв'язок з мультиплатформою, зверніться до цієї відповіді
Dhruv Reshamwala

1
При використанні декількох моніторів це поверне лише розмір основного дисплея.
Stevoisiak

1
Як встановити інтерпретатора пітона highdpiaware? Це було б корисно включити у відповідь.
eric

121

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

11
Важлива примітка: повернені значення можуть бути неправильними, якщо використовується масштабування DPI (тобто часто це відбувається на дисплеях 4k), вам потрібно викликати SetProcessDPIAware перед ініціалізацією компонентів GUI (а не перед викликом функції GetSystemMetrics). Це стосується більшості відповідей тут (GTK тощо) на платформі win32.
вчора

1
Для декількох моніторів ви можете використовувати GetSystemMetrics (78) та GetSystemMetrics (79)
Дерек

@Derek Що робить GetSystemMetrics(78)і GetSystemMetrics(79)повертається?
Stevoisiak

@StevenVascellaro Ширина / висота віртуального екрана, у пікселях. msdn.microsoft.com/en-us/library/windows/desktop/…
Дерек

94

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


2
Відмінно працює у Windows, але на Mac я отримую таку помилку: ImportError: Не вдалося завантажити X11
Chris Lucian

5
Відмінно працює на Ubuntu. Тестовано на Ubuntu 16.04.
Dhruv Reshamwala

3
FYI, масштабування DPI Windows все ще застосовується. Цей рядок повідомляє Windows про те, що ви хочете отримати необроблену нерозмірну роздільну здатність: "import ctypes; user32 = ctypes.windll.user32; user32.SetProcessDPIAware ()". 1) Ваша відповідь повинна бути вгорі; хороша робота. 2) Мій коментар для Windows-конкретні, а НЕ бібліотека конкретних (тобто screeninfo) 3) код рельєфним і протестований від коментарів KobeJohn тут: stackoverflow.com/a/32541666/2616321
Jason2616321

6
Зручний модуль (+1). Мені довелося встановити пару вимог (наприклад pip install cython pyobjus), перш ніж я міг використовувати його на OSX, хоча
Джордж Профенза

45

Якщо ви використовуєте wxWindows, ви можете просто зробити:

import wx

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

Це найкращий ... у кого немає wx? :) плюс кілька рядків замість купки коду на ваших очах. Це тепер мій метод за замовчуванням, дякую.
м3нда

1
Це має бути app = wx.App(False)інакше, ви отримуєте "об'єкт wx.App потрібно створити спочатку." помилка. 26 голосів, і ніхто не перевірив? Чи працює в Windows, не присвоюючи екземпляр wx змінній?
м3нда

2
У кого немає wx? Багато людей?
болото

43

Взяте безпосередньо з відповіді на цей пост: Як отримати розмір екрана в Tkinter?

import tkinter as tk

root = tk.Tk()

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

8
Якщо у вас зовнішні дисплеї розширені поруч із основним дисплеєм, цей метод дасть суму всіх роздільних можливостей дисплеїв, а не поточну роздільну здатність дисплея.
нефритовий

Крок із декількома екранами дивіться мою відповідь .
norok2

29

У Windows 8.1 я не отримую правильної роздільної здатності ні від ctypes, ні від tk. Інші люди мають таку ж проблему щодо ctypes: getystemmetrics повертає неправильний розмір екрана Щоб отримати правильну повну роздільну здатність високого монітора DPI у Windows 8.1, потрібно зателефонувати на SetProcessDPIAware та використати наступний код:

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

Повна інформація нижче:

Я дізнався, що це тому, що Windows повідомляє про масштабовану роздільну здатність. Здається, що python за замовчуванням є додатком «система 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 Формула для ефективної роздільної здатності системи повідомляється: (повідомлено_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. Масштабування мого дисплея встановлює поточний показник DPI на 158.

Я буду використовувати 158, щоб переконатися, що мої сюжети matplotlib потрібного розміру: з імпорту pylab rcParams rcParams ['figure.dpi'] = curr_dpi


У вас тут багато хорошої інформації, але сама відповідь похована посередині. Щоб полегшити читання, чи можете ви уточнити, що саме відповідь, а потім надати довідкову інформацію?
skrrgwasme

Я відредагував своє повідомлення, щоб показати відповідь на початку, а потім розібратися в деталях. Дякуємо за відгук.
космічний інший

1
Схоже, тут є недолік у розрахунках, який легко помітити, ви обчислюєте розмір діагоналі від повідомленої ширини та висоти (у дюймах). Мій екран із діагоналлю 13,3 дюйма повідомлявся як 15 дюймів. Здається Tkinter, використовують правильні пікселі, але не знають масштабування dpi, таким чином повідомляють про неправильні розміри мм.
Буквар

Це не працює в Windows 10, тому SetSystemDPIAware (), схоже, не має ніякого значення. Однак виклик ctypes.windll.shcore.SetProcessDpiAwareness (2) замість цього, здається, робить свою справу.
Кламер Шутт

@KlamerSchutte: ctypes.windll.shcore.SetProcessDpiAwareness(2)повертає помилку OSError: [WinError 126] The specified module could not be found.
Адріан Кейстер

21

А для повноти - Mac OS X

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

надасть вам список кортежів, що містять усі розміри екрана (якщо є кілька моніторів)


15

Якщо ви спеціально використовуєте 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

Використовуючи Linux, найпростіший спосіб - це виконувати команду bash

xrandr | grep '*'

і аналізувати його вихід за допомогою regexp.

Також ви можете це зробити через PyGame: http://www.daniweb.com/forums/thread54881.html


Як ви використовуєте пігаму для отримання роздільної здатності екрана?
Джеймі Твіллс

11

Ось коротка маленька програма 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)

Чи gtk.Window()отримує gdk_default_root_window? Це, наскільки ви впевнені, .get_screenмістить усі монітори?
ятг

Я запитую, оскільки в коді я намагаюся копіювати ваш код, я роблю це у jsctypes, і він постійно повідомляє мені 0 моніторів: gist.github.com/yajd/55441c9c3d0711ee4a38#file-gistfile1-txt-L3
yatg

2
Минув час, коли я написав цей код, але, якщо я пам'ятаю правильно, gtk.Window()це означає створити нове вікно (див. Тут ). Вікно - це лише спосіб використання get_screenінформації про монітор. Він повертає екран, на якому вікно увімкнено (або було б, якби воно коли-небудь відображалося). Я думаю, це залежить від конфігурації X, чи містить цей "екран" усі "монітори". Це відбувається в моїй системі з Twinview.
starfry

Дякую @starfry! Мені потрібно було знайти перехресне рішення, яке отримує всі монітори та їх розміри незалежно від екранів. Чи було у вас якесь чанне, щоб розробити щось подібне? :)
ятг

Альтернатива для більш пізніх версій інструментарію: `` `Пітон
сатьяграха

9

Я використовую метод 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)

1
Дякуємо за поділ, але це могло бути скорочено багато з допомогою функції для обробки , якщо-небудь ще випадків
Udayraj Дешмук

8

Старе питання, але цього немає. Я новачок у python, тому скажіть, будь ласка, чи це "погане" рішення. Це рішення підтримується лише для Windows та MacOS, і воно працює лише для головного екрану, але ОС не згадується в питанні.

Виміряйте розмір, зробивши знімок екрана. Оскільки розмір екрана не повинен змінюватися, це потрібно зробити лише один раз. Є більш елегантні рішення, якщо у вас встановлений інструментарій gui на зразок GTK, wx, ....

див. Подушка

pip install Pillow

from PIL import ImageGrab

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

6

Версія 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

Розширення на відповідь @ 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)



5

Якщо у вас встановлений 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

Кросова платформа та простий спосіб зробити це за допомогою TKinter, який постачається майже з усіма версіями python, тому вам нічого не потрібно встановлювати:

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

3

Використання Linux Замість regexp візьміть перший рядок і вийміть поточні значення роздільної здатності.

Поточна роздільна здатність дисплея: 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, я не знаю, чи відрізняється вихід в інших версіях, але це повинно полегшити з'ясування.


на жаль, не дуже добре з налаштуваннями мультимонітора. не вина пітона, але використання цього може мати неочікувані результати ...
black_puppydog

2

Щоб отримати біти на піксель:

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

Спробуйте pyautogui:

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

Справді слід додати пояснення, чому цей код повинен працювати - ви також можете додавати коментарі до самого коду - у його теперішній формі він не дає жодних пояснень, які б допомогли решті спільноти зрозуміти, що ви зробили для вирішення. /відповісти на запитання. Але це теж дуже давнє запитання - з прийнятою відповіддю ...
ishmaelMakitla

2

Інша версія з використанням 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

Використання пігами :

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]


Підтверджено, що він працює в Windows :) Який приємний метод, який не стосується Windows!
Лукаш Червінський


1

Якщо ви працюєте в ОС Windows, ви можете використовувати модуль ОС, щоб отримати його:

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


0

В 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

Для екрана сітківки це трохи клопітно, я використовую 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

0

Для пізніших версій 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))

0

Для 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)

0

Сценарій утиліти за допомогою 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)
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.