Comment puis-je obtenir la résolution du moniteur en Python?
Quel est le moyen le plus simple d’obtenir une résolution de moniteur (de préférence dans un tuple)?
Sous Windows:
from win32api import GetSystemMetrics
print("Width =", GetSystemMetrics(0))
print("Height =", GetSystemMetrics(1))
Si vous travaillez avec un écran haute résolution, assurez-vous que votre interpréteur python est HIGHDPIAWARE.
Basé sur this post.
Sous Windows, vous pouvez également utiliser ctypes avec GetSystemMetrics() :
import ctypes
user32 = ctypes.windll.user32
screensize = user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)
afin que vous n'ayez pas besoin d'installer le paquet pywin32; il n'a besoin de rien qui ne vienne pas avec Python.
Pour les configurations multi-moniteurs, vous pouvez récupérer la largeur et la hauteur combinées du moniteur virtuel:
import ctypes
user32 = ctypes.windll.user32
screensize = user32.GetSystemMetrics(78), user32.GetSystemMetrics(79)
J'ai créé un module PyPI pour cette raison:
pip install screeninfo
Le code:
from screeninfo import get_monitors
for m in get_monitors():
print(str(m))
Résultat:
monitor(1920x1080+1920+0)
monitor(1920x1080+0+0)
Il supporte les environnements multi-moniteurs. Son but est d'être multi-plateforme; pour l'instant, il prend en charge Cygwin et X11, mais les demandes d'extraction sont les bienvenues.
Si vous utilisez wxWindows, vous pouvez simplement faire:
import wx
app = wx.App(False) # the wx.App object must be created first.
print(wx.GetDisplaySize()) # returns a Tuple
Tiré directement d'une réponse à cet article: Comment obtenir la taille d'écran dans Tkinter?
import tkinter as tk
root = tk.Tk()
screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()
Sous Windows 8.1, les types de fichiers ctypes et tk ne donnent pas la résolution correcte. D'autres personnes rencontrent le même problème pour les types de fichiers ctypes: getsystemmetrics renvoie une taille d'écran incorrecte Moniteur DPI sur Windows 8.1, vous devez appeler SetProcessDPIAware et utiliser le code suivant:
import ctypes
user32 = ctypes.windll.user32
user32.SetProcessDPIAware()
[w, h] = [user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)]
Tous les détails ci-dessous:
J'ai découvert que c'est parce que Windows signale une résolution réduite. Il semble que python soit par défaut une application «compatible système dpi». Les types d’applications DPI sensibles sont énumérés ici: http://msdn.Microsoft.com/en-us/library/windows/desktop/dn469266%28v=vs.85%29.aspx#dpi_and_the_desktop_scaling_factor
Fondamentalement, plutôt que d’afficher le contenu dans l’ensemble de la résolution du moniteur, ce qui réduirait la taille des polices, le contenu est mis à l’échelle jusqu’à ce que les polices soient suffisamment grandes.
Sur mon moniteur, je reçois:
Résolution physique: 2560 x 1440 (220 DPI)
Résolution rapportée en python: 1555 x 875 (158 DPI)
Selon ce site Windows: http://msdn.Microsoft.com/en-us/library/aa770067%28v=vs.85%29.aspx La formule de résolution effective du système est la suivante: (posted_px * current_dpi)/(96 dpi) = physical_px
Je suis en mesure d’obtenir la bonne résolution plein écran et le DPI actuel avec le code ci-dessous . Notez que j’appelle SetProcessDPIAware () pour permettre au programme de voir la résolution réelle.
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))
Qui a retourné:
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
J'utilise Windows 8.1 avec un moniteur compatible 220 DPI . La mise à l'échelle de mon écran définit le DPI actuel sur 158.
J'utiliserai le 158 pour m'assurer que mes parcelles matplotlib ont la bonne taille avec: De pylab import rcParams RcParams ['figure.dpi'] = curr_dpi
Et pour être complet, Mac OS X
import AppKit
[(screen.frame().size.width, screen.frame().size.height)
for screen in AppKit.NSScreen.screens()]
vous donnera une liste de tuples contenant toutes les tailles d'écran (si plusieurs moniteurs sont présents)
Si vous utilisez la boîte à outils Qt spécifiquement PySide, vous pouvez effectuer les opérations suivantes:
from PySide import QtGui
import sys
app = QtGui.QApplication(sys.argv)
screen_rect = app.desktop().screenGeometry()
width, height = screen_rect.width(), screen_rect.height()
Sous Linux, le moyen le plus simple consiste à exécuter la commande bash
xrandr | grep '*'
et analyser sa sortie en utilisant regexp.
Vous pouvez aussi le faire via PyGame: http://www.daniweb.com/forums/thread54881.html
Voici un petit programme rapide Python qui affiche les informations sur votre configuration multi-moniteurs:
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)
Voici un exemple de sa sortie:
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)
J'utilise une méthode get_screen_resolution dans l'un de mes projets, comme celui ci-dessous, qui est essentiellement une chaîne d'importation. Vous pouvez modifier cela en fonction de vos besoins en supprimant les pièces inutiles et en déplaçant les ports les plus probables vers le haut de la chaîne.
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)
Version 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)
Vieille question mais cela manque. Je suis nouveau sur python alors dites-moi s’il s’agit d’une "mauvaise" solution . Cette solution est prise en charge uniquement par Windows et Mac et ne fonctionne que pour l’écran principal - mais le système d’exploitation n’est pas mentionné dans. la question.
Mesurer la taille en prenant une capture d'écran. Comme la taille de l'écran ne doit pas changer, cela ne doit être fait qu'une fois ... Il existe des solutions plus élégantes si vous avez installé une boîte à outils graphique comme gtk, wx, ....
voir Oreiller
pip install Pillow
from PIL import ImageGrab
img = ImageGrab.grab
print (img.size)
Si PyQt4 est installé, essayez le code suivant:
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))
Pour PyQt5, ce qui suit fonctionnera:
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))
Essayez le code suivant:
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
Sous Linux, au lieu de regexp, prenez la première ligne et extrayez les valeurs de résolution actuelles.
Résolution actuelle d'affichage: 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
Cela a été fait sur xrandr 1.3.5, je ne sais pas si le résultat est différent sur les autres versions, mais cela devrait faciliter la tâche.
Une autre version utilisant 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)
Développer la réponse de @ user2366975 , pour obtenir la taille d'écran actuelle dans une configuration multi-écrans à l'aide de Tkinter (code dans 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
(Devrait fonctionner multi-plateforme, testé sur Linux uniquement)
Utiliser pygame :
import pygame
pygame.init()
infos = pygame.display.Info()
screen_size = (infos.current_w, infos.current_h)
Cependant, si vous essayez de définir la taille de votre fenêtre, vous voudrez peut-être simplement:
pygame.display.set_mode((0,0),pygame.FULLSCREEN)
pour régler votre affichage en mode plein écran. [2]
Pour obtenir des bits par 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))
paramètres dans 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,
Si vous travaillez sous Windows, vous pouvez utiliser le module de système d'exploitation pour l'obtenir:
import os
cmd = 'wmic desktopmonitor get screenheight, screenwidth'
size_Tuple = Tuple(map(int,os.popen(cmd).read().split()[-2::]))
Il retournera un tuple (Y, X) où Y est la taille verticale et X est la taille horizontale. Ce code fonctionne sur Python 2 et Python 3
Essayez pyautogui:
import pyautogui
resolution = pyautogui.size()
print(resolution)
Pour les versions ultérieures de 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))
C'est un peu gênant pour l'écran de la rétine, j'utilise tkinter pour obtenir la taille factice, utilisez pilllow grab pour obtenir la taille réelle:
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
Vous pouvez utiliser PyMouse . Pour obtenir la taille de l'écran, utilisez simplement l'attribut screen_size():
from pymouse import PyMouse
m = PyMouse()
a = m.screen_size()
a renverra un tuple, (X, Y), où X est la position horizontale et Y est la position verticale.
Un moyen simple et multiplate-forme de le faire consiste à utiliser TKinter fourni avec presque toutes les versions de python. Vous n'avez donc rien à installer:
import tkinter
root = tkinter.Tk()
root.withdraw()
WIDTH, HEIGHT = root.winfo_screenwidth(), root.winfo_screenheight()
Sous Linux, nous pouvons utiliser un module de sous-processus
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())