Comment obtenir la résolution du moniteur en Python?

Quel est le moyen le plus simple d'obtenir la résolution du 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 ce post.

Sous Windows, vous pouvez également utiliser des 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 package pywin32; il n'a besoin de rien qui ne vient pas avec Python lui-même.

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 prend en charge les environnements multi-moniteurs . Son objectif est d'être multiplateforme; pour l'instant, il prend en charge Cygwin et X11, mais les pull requests 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 à ce post: Comment obtenir la taille de l'écran dans Tkinter?

import tkinter as tk

root = tk.Tk()

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

Sous Windows 8.1, je n'obtiens pas la résolution correcte de ctypes ou de tk. D'autres personnes ont le même problème pour les ctypes: getsystemmetrics renvoie une taille d'écran incorrecte Pour obtenir la résolution complète correcte d'un moniteur à haute résolution sur Windows 8.1, il faut appeler SetProcessDPIAware et utiliser le code suivant:

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

Détails complets ci-dessous:

J'ai découvert que c'est parce que Windows rapporte une résolution mise à l'échelle. Il semble que python soit par défaut une application «compatible avec le dpi système». Les types d'applications prenant en charge DPI sont répertorié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 à la résolution complète du moniteur, ce qui rendrait les polices minuscules, le contenu est mis à l'échelle jusqu'à ce que les polices soient suffisamment grandes.

Sur mon moniteur, j'obtiens:
Résolution physique: 2560 x 1440 (220 DPI)
Résolution python rapportée: 1555 x 875 (158 DPI)

Par ce site Windows: http://msdn.microsoft.com/en-us/library/aa770067%28v=vs.85%29.aspx La formule pour la résolution effective du système rapportée est: (rapporté_px * courant_dpi) / (96 dpi ) = physical_px

Je peux 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 renvoyé:

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 affichage définit mon DPI actuel sur 158.

Je vais utiliser le 158 pour m'assurer que mes tracés matplotlib sont de la bonne taille avec: from 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 Qtspécifiquement la boîte à outils 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()

En utilisant Linux, le moyen le plus simple est d'exécuter la commande bash

xrandr | grep '*'

et analyser sa sortie en utilisant regexp.

Vous pouvez également le faire via PyGame: http://www.daniweb.com/forums/thread54881.html

Voici un petit programme Python rapide qui affichera 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 le modifier en fonction de vos besoins en supprimant les pièces inutiles et en déplaçant les ports les plus probables vers le haut dans 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)

Ancienne question mais cela manque. Je suis nouveau sur python, alors dites-moi s'il s'agit d'une "mauvaise" solution. Cette solution est uniquement prise en charge pour Windows et MacOS et ne fonctionne que pour l'écran principal - mais le système d'exploitation n'est pas mentionné dans la question.

Mesurez 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 seule fois. Il existe des solutions plus élégantes si vous avez une boîte à outils d'interface graphique comme GTK, wx, ... installée.

voir oreiller

pip install Pillow

from PIL import ImageGrab

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

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)

Expansion sur la réponse de @ user2366975 , pour obtenir la taille d'écran actuelle dans une configuration multi-écran en utilisant Tkinter (code en 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 multiplateforme, testé sur Linux uniquement)

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

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

Un moyen multiplateforme et simple de le faire consiste à utiliser TKinter qui est livré avec presque toutes les versions de python afin que vous n'ayez rien à installer:

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

En utilisant Linux au lieu de regexp, prenez la première ligne et supprimez les valeurs de résolution actuelles.

Résolution actuelle de l'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 la sortie est différente sur les autres versions, mais cela devrait le rendre facile à comprendre.

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,

Essayez pyautogui:

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

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)

Utilisation de pygame :

import pygame
pygame.init()
infos = pygame.display.Info()
screen_size = (infos.current_w, infos.current_h)

[1]

Cependant, si vous essayez de définir votre fenêtre à la taille de l'écran, vous voudrez peut-être simplement faire:

pygame.display.set_mode((0,0),pygame.FULLSCREEN)

pour régler votre affichage en mode plein écran. [2]

Vous pouvez utiliser PyMouse . Pour obtenir la taille de l'écran, utilisez simplement l' screen_size()attribut:

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

arenverra un tuple,, (X, Y)où Xest la position horizontale et Yla position verticale.

Lien vers la fonction dans la documentation.

Si vous travaillez sur le système d'exploitation Windows, vous pouvez utiliser le module du 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 renverra 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

Sous Linux, nous pouvons utiliser le 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())

C'est un peu gênant pour l'écran de la rétine, j'utilise tkinter pour obtenir la fausse taille, j'utilise 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

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

Pour Linux, vous pouvez utiliser ceci:

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)

Script utilitaire utilisant la pynputbibliothèque. Publier ici pour réf .:

 
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)