Який найпростіший спосіб отримати дозвіл монітора (бажано в кортежі)?
Який найпростіший спосіб отримати дозвіл монітора (бажано в кортежі)?
Відповіді:
У Windows:
from win32api import GetSystemMetrics
print("Width =", GetSystemMetrics(0))
print("Height =", GetSystemMetrics(1))
Якщо ви працюєте з екраном високої роздільної здатності, переконайтесь, що ваш інтерпретатор пітону HIGHDPIAWARE.
На основі цієї публікації.
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)
GetSystemMetrics(78)
і 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, але запити на виклик вітаються.
pip install cython pyobjus
), перш ніж я міг використовувати його на OSX, хоча
Якщо ви використовуєте wxWindows, ви можете просто зробити:
import wx
app = wx.App(False) # the wx.App object must be created first.
print(wx.GetDisplaySize()) # returns a tuple
app = wx.App(False)
інакше, ви отримуєте "об'єкт wx.App потрібно створити спочатку." помилка. 26 голосів, і ніхто не перевірив? Чи працює в Windows, не присвоюючи екземпляр wx змінній?
Взяте безпосередньо з відповіді на цей пост: Як отримати розмір екрана в Tkinter?
import tkinter as tk
root = tk.Tk()
screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()
У 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
Tkinter
, використовують правильні пікселі, але не знають масштабування dpi, таким чином повідомляють про неправильні розміри мм.
ctypes.windll.shcore.SetProcessDpiAwareness(2)
повертає помилку OSError: [WinError 126] The specified module could not be found
.
Використовуючи 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)
gtk.Window()
отримує gdk_default_root_window
? Це, наскільки ви впевнені, .get_screen
містить усі монітори?
gtk.Window()
це означає створити нове вікно (див. Тут ). Вікно - це лише спосіб використання get_screen
інформації про монітор. Він повертає екран, на якому вікно увімкнено (або було б, якби воно коли-небудь відображалося). Я думаю, це залежить від конфігурації X, чи містить цей "екран" усі "монітори". Це відбувається в моїй системі з Twinview.
Я використовую метод 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)
Старе питання, але цього немає. Я новачок у python, тому скажіть, будь ласка, чи це "погане" рішення. Це рішення підтримується лише для Windows та MacOS, і воно працює лише для головного екрану, але ОС не згадується в питанні.
Виміряйте розмір, зробивши знімок екрана. Оскільки розмір екрана не повинен змінюватися, це потрібно зробити лише один раз. Є більш елегантні рішення, якщо у вас встановлений інструментарій gui на зразок GTK, wx, ....
див. Подушка
pip install Pillow
from PIL import ImageGrab
img = ImageGrab.grab()
print (img.size)
Розширення на відповідь @ 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))
Використання 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, я не знаю, чи відрізняється вихід в інших версіях, але це повинно полегшити з'ясування.
Щоб отримати біти на піксель:
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)
Використання пігами :
import pygame
pygame.init()
infos = pygame.display.Info()
screen_size = (infos.current_w, infos.current_h)
Однак якщо ви намагаєтесь встановити вікно під розмір екрану, можливо, вам просто захочеться зробити це:
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, ви можете використовувати модуль ОС, щоб отримати його:
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))
Сценарій утиліти за допомогою 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)