Comment obtenir la résolution du moniteur en Python?

126

Quel est le moyen le plus simple d'obtenir la résolution du moniteur (de préférence dans un tuple)?

rectangle
la source
Utilisez-vous une boîte à outils d'interface utilisateur particulière? (par exemple. GTK, wxPython, Tkinter, etc.)
detly
11
Avec le Tkintermodule, vous pouvez le faire de cette façon . Il fait partie de la bibliothèque Python standard et fonctionne sur la plupart des plates-formes Unix et Windows.
martineau
1
Un bon aperçu des différentes techniques pour les interfaces utilisateur courantes est donné sur ce lien
ImportanceOfBeingErnest

Réponses:

75

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.

Robus
la source
9
Pour une solution complète multiplateforme, reportez-vous à cette réponse
Dhruv Reshamwala
1
Lorsque vous utilisez plusieurs moniteurs, cela ne renverra que la taille de l'écran principal.
Stevoisiak
1
Comment définissez-vous l'interpréteur python highdpiaware? Cela serait utile à inclure dans la réponse.
eric
121

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)
jcao219
la source
11
Remarque importante: les valeurs renvoyées peuvent être incorrectes si la mise à l'échelle DPI est utilisée (c'est-à-dire: souvent le cas sur les écrans 4k), vous devez appeler SetProcessDPIAware avant d'initialiser les composants GUI (et pas avant d'appeler la fonction GetSystemMetrics). Cela est vrai pour la plupart des réponses ici (GTK, etc.) sur la plate-forme win32.
totaam le
1
Pour plusieurs moniteurs, vous pouvez utiliser GetSystemMetrics (78) et GetSystemMetrics (79)
Derek
@Derek Que fait GetSystemMetrics(78)et que GetSystemMetrics(79)revient?
Stevoisiak
@StevenVascellaro La largeur / hauteur de l'écran virtuel, en pixels. msdn.microsoft.com/en-us/library/windows/desktop/…
Derek
94

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.

rr-
la source
2
Fonctionne très bien sur Windows mais Mac J'obtiens l'erreur suivante: ImportError: Impossible de charger X11
Chris Lucian
5
Fonctionne très bien sur Ubuntu. Testé sur Ubuntu 16.04.
Dhruv Reshamwala
3
Pour info, la mise à l'échelle PPP de Windows s'applique toujours. Cette ligne indiquera à Windows que vous voulez la résolution brute et non mise à l'échelle: "import ctypes; user32 = ctypes.windll.user32; user32.SetProcessDPIAware ()". 1) Votre réponse devrait être top; bon travail. 2) Mon commentaire est spécifique à Windows, pas spécifique à la bibliothèque (ie screeninfo) 3) code extrait et testé à partir du commentaire de KobeJohn ici: stackoverflow.com/a/32541666/2616321
Jason2616321
6
Module pratique (+1). J'ai dû installer quelques exigences (par exemple pip install cython pyobjus) avant de pouvoir l'utiliser sur OSX
George Profenza
45

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
Ned Batchelder
la source
C'est le meilleur ... qui n'a pas de wx? :) plus quelques lignes au lieu d'un tas de code sur vos yeux. C'est maintenant ma méthode par défaut, merci.
m3nda
1
Cela devrait être app = wx.App(False)sinon vous obtenez le "l'objet wx.App doit être créé en premier." Erreur. 26 votes et personne n'a vérifié? Fonctionne-t-il sous Windows sans associer une instance wx à une variable?
m3nda
2
Qui n'a pas de wx? Beaucoup de gens?
marsh
43

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()
user2366975
la source
8
Si vous avez des écrans externes étendus à côté de l'affichage principal, cette méthode donnera la somme de toutes les résolutions d'affichage, et non la résolution d'affichage actuelle.
jadelord
Pour une étape à plusieurs écrans, consultez ma réponse .
norok2
29

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

spacether
la source
Vous avez beaucoup de bonnes informations ici, mais la réponse elle-même est enterrée au milieu. Pour rendre la lecture un peu plus facile, pouvez-vous clarifier exactement quelle est la réponse et ensuite fournir les informations de base?
skrrgwasme
J'ai édité mon message pour afficher la réponse au début, puis entrer dans les détails. Merci pour les commentaires.
spacether
1
Il semble qu'il y ait un défaut dans les calculs ici, ce qui est facile à repérer, vous calculez une taille diagonale à partir de la largeur et de la hauteur rapportées (en pouces). Mon écran avec une diagonale de 13,3 pouces était de 15 pouces. Il semble qu'il Tkinterutilise des pixels corrects, mais n'est pas conscient de la mise à l'échelle en dpi, signalant ainsi des tailles en mm erronées.
Primer
Cela ne fonctionne pas sous Windows 10, là, SetSystemDPIAware () ne semble pas faire de différence. Cependant, appeler ctypes.windll.shcore.SetProcessDpiAwareness (2) semble à la place faire l'affaire.
Klamer Schutte
@KlamerSchutte: ctypes.windll.shcore.SetProcessDpiAwareness(2)renvoie une erreur OSError: [WinError 126] The specified module could not be found.
Adrian Keister
21

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)

cobbal
la source
15

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()
MadeOfAir
la source
13

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

Pavel Strakhov
la source
Comment utilisez-vous pygame pour obtenir la résolution de l'écran?
Jamie Twells
11

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)
starfry
la source
Obtient- gtk.Window()il le gdk_default_root_window? Est-ce ainsi que vous êtes certain qu'il .get_screencontient tous les moniteurs?
yatg
Je demande parce que dans mon code, j'essaie de répliquer votre code, je le fais dans jsctypes, et il ne cesse de me dire 0 moniteurs: gist.github.com/yajd/55441c9c3d0711ee4a38#file-gistfile1-txt-L3
yatg
2
Cela fait un moment que j'ai écrit ce code mais, si je me souviens bien, ce qui gtk.Window()fait est de créer une nouvelle fenêtre (voir ici ). La fenêtre est juste un moyen d'utiliser get_screenpour obtenir les informations du moniteur. Il renvoie l'écran sur lequel se trouve la fenêtre (ou serait, si elle était jamais affichée). Je suppose que cela dépend de la configuration X si cet "écran" contient tous les "moniteurs". C'est le cas sur mon système avec Twinview.
starfry
Merci @starfry! J'avais besoin de trouver une solution croisée qui obtienne tous les moniteurs et leurs dimensions indépendamment des écrans. Avez-vous eu une chacne pour développer quelque chose comme ça? :)
yatg
Alternative pour les versions ultérieures de la boîte à outils: `` python
satyagraha
9

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)
Martin Hansen
la source
1
Merci de partager cela, mais cela aurait pu être beaucoup raccourci en utilisant une fonction pour gérer les cas if-else
Udayraj Deshmukh
8

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)
lumos0815
la source
6

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)
cpoakes
la source
6

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)

norok2
la source
5

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
Taghouti Tarek
la source
5

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))
Harsh Kumar Narula
la source
5

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()
kitsiosque
la source
3

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.

Alex R
la source
malheureusement pas très bon avec les configurations multi-moniteurs. pas la faute de python, mais son utilisation peut avoir des résultats inattendus ...
black_puppydog
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,
user3757097
la source
2

Essayez pyautogui:

import pyautogui
resolution = pyautogui.size()
print(resolution) 
Tyler
la source
Vous devriez vraiment ajouter une explication sur la raison pour laquelle ce code devrait fonctionner - vous pouvez également ajouter des commentaires dans le code lui-même - dans sa forme actuelle, il ne fournit aucune explication qui puisse aider le reste de la communauté à comprendre ce que vous avez fait pour résoudre /répondre à la question. Mais c'est aussi une question très ancienne - avec une réponse acceptée ...
ishmaelMakitla
2

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)
sirex
la source
2

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]

Tom Burrows
la source
Confirmé que cela fonctionne sous Windows :) Quelle belle méthode non spécifique à Windows!
Lukasz Czerwinski
1

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)Xest la position horizontale et Yla position verticale.

Lien vers la fonction dans la documentation.

Simon
la source
1

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)Y est la taille verticale et X est la taille horizontale. Ce code fonctionne sur Python 2 et Python 3

Diroallu
la source
0

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())
kamran kausar
la source
0

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
NicolasLi
la source
0

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))
satyagraha
la source
0

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)
Jefflgaol
la source
0

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)
olumidésane
la source