¿Cómo obtengo la resolución del monitor en Python?

126

¿Cuál es la forma más sencilla de obtener la resolución del monitor (preferiblemente en una tupla)?

rectángulo
fuente
¿Está utilizando un conjunto de herramientas de interfaz de usuario en particular? (p. ej., GTK, wxPython, Tkinter, etc.)
precisa,
11
Con el Tkintermódulo, puede hacerlo de esta manera . Es parte de la biblioteca estándar de Python y funciona en la mayoría de las plataformas Unix y Windows.
martineau
1
En este enlace
ImportanceOfBeingErnest

Respuestas:

75

En Windows:

from win32api import GetSystemMetrics

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

Si está trabajando con una pantalla de alta resolución, asegúrese de que su intérprete de Python sea HIGHDPIAWARE.

Basado en esta publicación.

Robus
fuente
9
Para una solución completa multiplataforma, consulte esta respuesta
Dhruv Reshamwala
1
Cuando utilice varios monitores, esto solo devolverá el tamaño de la pantalla principal.
Stevoisiak
1
¿Cómo se configura el intérprete de Python highdpiaware? Sería útil incluir esto en la respuesta.
Eric
121

En Windows, también puede usar ctypes con GetSystemMetrics():

import ctypes
user32 = ctypes.windll.user32
screensize = user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)

para que no necesite instalar el paquete pywin32; no necesita nada que no venga con Python.

Para configuraciones de varios monitores, puede recuperar el ancho y alto combinados del monitor virtual:

import ctypes
user32 = ctypes.windll.user32
screensize = user32.GetSystemMetrics(78), user32.GetSystemMetrics(79)
jcao219
fuente
11
Nota importante: los valores devueltos pueden ser incorrectos si se usa la escala DPI (es decir, a menudo es el caso en pantallas 4k), debe llamar a SetProcessDPIAware antes de inicializar los componentes de la GUI (y no antes de llamar a la función GetSystemMetrics). Esto es cierto para la mayoría de las respuestas aquí (GTK, etc.) en la plataforma win32.
totaam
1
Para varios monitores, puede usar GetSystemMetrics (78) y GetSystemMetrics (79)
Derek
@Derek ¿Qué hace GetSystemMetrics(78)y GetSystemMetrics(79)vuelve?
Stevoisiak
@StevenVascellaro El ancho / alto de la pantalla virtual, en píxeles. msdn.microsoft.com/en-us/library/windows/desktop/…
Derek
94

Creé un módulo PyPI por este motivo:

pip install screeninfo

El código:

from screeninfo import get_monitors
for m in get_monitors():
    print(str(m))

Resultado:

monitor(1920x1080+1920+0)
monitor(1920x1080+0+0)

Es compatible con entornos de varios monitores . Su objetivo es ser multiplataforma; por ahora es compatible con Cygwin y X11, pero las solicitudes de extracción son totalmente bienvenidas.

rr-
fuente
2
Funciona muy bien en Windows, pero Mac obtengo el siguiente error: ImportError: no se pudo cargar X11
Chris Lucian
5
Funciona muy bien en Ubuntu. Probado en Ubuntu 16.04.
Dhruv Reshamwala
3
Para su información, la escala de DPI de Windows todavía se aplica. Esta línea le dirá a Windows que desea la resolución sin formato, sin escalar: "import ctypes; user32 = ctypes.windll.user32; user32.SetProcessDPIAware ()". 1) Su respuesta debe ser superior; buen trabajo. 2) Mi comentario es específico de Windows, no específico de la biblioteca (es decir, screeninfo) 3) código extraído y probado del comentario de KobeJohn aquí: stackoverflow.com/a/32541666/2616321
Jason2616321
6
Módulo práctico (+1). Sin pip install cython pyobjusembargo
George Profenza
45

Si está utilizando wxWindows, simplemente puede hacer:

import wx

app = wx.App(False) # the wx.App object must be created first.    
print(wx.GetDisplaySize())  # returns a tuple
Ned Batchelder
fuente
Este es el mejor ... ¿quién no tiene wx? :) más unas pocas líneas en lugar de un montón de código en tus ojos. Este es ahora mi método predeterminado, gracias.
m3nda
1
Esto debería ser de lo app = wx.App(False)contrario, obtendrá el "primero se debe crear el objeto wx.App". error. 26 votos y nadie lo comprobó? ¿Funciona en Windows sin asignar una instancia de wx a una variable?
m3nda
2
¿Quién no tiene wx? ¿Muchas personas?
pantano
43

Tomado directamente de una respuesta a esta publicación: ¿Cómo obtener el tamaño de la pantalla en Tkinter?

import tkinter as tk

root = tk.Tk()

screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()
user2366975
fuente
8
Si tiene pantallas externas extendidas al lado de la pantalla principal, este método daría la suma de todas las resoluciones de pantalla, no la resolución de pantalla actual.
jadelord
Para un paso de pantalla múltiple, vea mi respuesta .
norok2
29

En Windows 8.1 no obtengo la resolución correcta de ctypes o tk. Otras personas están teniendo el mismo problema con los tipos de ctypes: getsystemmetrics devuelve un tamaño de pantalla incorrecto Para obtener la resolución completa correcta de un monitor de alto DPI en Windows 8.1, se debe llamar a SetProcessDPIAware y usar el siguiente código:

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

Detalles completos a continuación:

Descubrí que esto se debe a que Windows informa una resolución escalada. Parece que Python es, de forma predeterminada, una aplicación "consciente de dpi del sistema". Los tipos de aplicaciones compatibles con DPI se enumeran aquí: http://msdn.microsoft.com/en-us/library/windows/desktop/dn469266%28v=vs.85%29.aspx#dpi_and_the_desktop_scaling_factor

Básicamente, en lugar de mostrar el contenido con la resolución completa del monitor, lo que haría que las fuentes fueran pequeñas, el contenido se escala hasta que las fuentes sean lo suficientemente grandes.

En mi monitor obtengo:
Resolución física: 2560 x 1440 (220 DPI)
Resolución de Python reportada: 1555 x 875 (158 DPI)

Según este sitio de Windows: http://msdn.microsoft.com/en-us/library/aa770067%28v=vs.85%29.aspx La fórmula para la resolución efectiva del sistema informado es: (report_px * current_dpi) / (96 dpi ) = físico_px

Puedo obtener la resolución de pantalla completa correcta y el DPI actual con el siguiente código. Tenga en cuenta que llamo a SetProcessDPIAware () para permitir que el programa vea la resolución real.

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

Que regresó:

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

Estoy ejecutando Windows 8.1 con un monitor con capacidad de 220 DPI. La escala de mi pantalla establece mi DPI actual en 158.

Usaré el 158 para asegurarme de que mis parcelas de matplotlib tengan el tamaño correcto con: from pylab import rcParams rcParams ['figure.dpi'] = curr_dpi

otro espacio
fuente
Tiene mucha información buena aquí, pero la respuesta en sí está enterrada en el medio. Para que sea un poco más fácil de leer, ¿puede aclarar exactamente cuál es la respuesta y luego proporcionar la información de fondo?
skrrgwasme
Edité mi publicación para mostrar la respuesta al principio y luego entrar en detalles. Gracias por la respuesta.
spacether
1
Parece que hay una falla en los cálculos aquí, que es fácil de detectar si calcula un tamaño diagonal a partir del ancho y alto reportados (en pulgadas). Mi pantalla con 13,3 pulgadas de diagonal se informó como 15 pulgadas. Parece que Tkinterestá usando píxeles correctos, pero no es consciente de la escala de ppp, por lo que informa tamaños de mm incorrectos.
Primer
Esto no funciona en Windows 10, allí el SetSystemDPIAware () no parece marcar la diferencia. Sin embargo, llamar a ctypes.windll.shcore.SetProcessDpiAwareness (2) parece ser el truco.
Klamer Schutte
@KlamerSchutte: ctypes.windll.shcore.SetProcessDpiAwareness(2)devuelve error OSError: [WinError 126] The specified module could not be found.
Adrian Keister
21

Y para completar, Mac OS X

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

le dará una lista de tuplas que contienen todos los tamaños de pantalla (si hay varios monitores presentes)

cobbal
fuente
15

Si está utilizando Qtespecíficamente el kit de herramientas PySide, puede hacer lo siguiente:

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
fuente
13

Usando Linux, la forma más sencilla es ejecutar el comando bash

xrandr | grep '*'

y analizar su salida usando regexp.

También puedes hacerlo a través de PyGame: http://www.daniweb.com/forums/thread54881.html

Pavel Strakhov
fuente
¿Cómo usas pygame para obtener la resolución de pantalla?
Jamie Twells
11

Aquí hay un pequeño programa rápido de Python que mostrará la información sobre su configuración de múltiples monitores:

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)  

Aquí hay un ejemplo de su salida:

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
fuente
¿ gtk.Window()Obtiene el gdk_default_root_window? ¿Es así como está seguro de que .get_screencontiene todos los monitores?
yatg
Lo pregunto porque en mi código estoy tratando de replicar su código, lo estoy haciendo en jsctypes, y me sigue diciendo 0 monitores: gist.github.com/yajd/55441c9c3d0711ee4a38#file-gistfile1-txt-L3
yatg
2
Ha pasado un tiempo desde que escribí ese código pero, si mal no recuerdo, lo que gtk.Window()hace es crear una nueva ventana (ver aquí ). La ventana es solo una forma get_screende obtener la información del monitor. Devuelve la pantalla en la que está la ventana (o lo estaría, si alguna vez se mostrara). Supongo que depende de la configuración X si esa "pantalla" contiene todos los "monitores". Lo hace en mi sistema con Twinview.
starfry
¡Gracias @starfry! Necesitaba encontrar una solución cruzada que obtuviera todos los monitores y sus dimensiones independientemente de las pantallas. ¿Has tenido alguna oportunidad para desarrollar algo así? :)
yatg
Alternativa para versiones posteriores del kit de herramientas: `` python
satyagraha
9

Estoy usando un método get_screen_resolution en uno de mis proyectos como el siguiente, que es básicamente una cadena de importación. Puede modificar esto de acuerdo con sus necesidades eliminando las partes que no son necesarias y moviendo los puertos más probables hacia arriba en la cadena.

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
fuente
1
Gracias por compartir esto, pero podría haberse acortado mucho al usar una función para manejar los casos if-else
Udayraj Deshmukh
8

Pregunta antigua, pero falta esta. Soy nuevo en Python, así que dígame si esta es una solución "mala". Esta solución es compatible solo con Windows y MacOS y funciona solo para la pantalla principal, pero el sistema operativo no se menciona en la pregunta.

Mide el tamaño tomando una captura de pantalla. Como el tamaño de la pantalla no debería cambiar, esto solo debe hacerse una vez. Hay soluciones más elegantes si tiene un kit de herramientas de interfaz gráfica de usuario como GTK, wx, ... instalado.

ver almohada

pip install Pillow

from PIL import ImageGrab

img = ImageGrab.grab()
print (img.size)
lumos0815
fuente
6

Versión de 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
fuente
6

Ampliando la respuesta de @ user2366975 , para obtener el tamaño de pantalla actual en una configuración de múltiples pantallas usando Tkinter (código 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

(Debería funcionar multiplataforma, probado solo en Linux)

norok2
fuente
5

Prueba el siguiente código:

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
fuente
5

En caso de que tenga PyQt4 instalado, pruebe el siguiente código:

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

Para PyQt5, funcionará lo siguiente:

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))
Áspero Kumar Narula
fuente
5

Una forma multiplataforma y fácil de hacer esto es usando TKinter que viene con casi todas las versiones de Python para que no tenga que instalar nada:

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

Usando Linux En lugar de regexp, tome la primera línea y saque los valores de resolución actuales.

Resolución actual de la pantalla: 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

Esto se hizo en xrandr 1.3.5, no sé si el resultado es diferente en otras versiones, pero esto debería facilitar su comprensión.

Alex R
fuente
lamentablemente no es muy bueno con configuraciones multimonitor. no es culpa de Python, pero usar esto puede tener resultados inesperados ...
black_puppydog
2

Para obtener bits por píxel:

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

parámetros en 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,
usuario3757097
fuente
2

Prueba pyautogui:

import pyautogui
resolution = pyautogui.size()
print(resolution) 
Tyler
fuente
Realmente debería agregar alguna explicación de por qué este código debería funcionar; también puede agregar comentarios en el código mismo; en su forma actual, no proporciona ninguna explicación que pueda ayudar al resto de la comunidad a comprender lo que hizo para resolver Respondo la pregunta. Pero esta también es una pregunta muy antigua, con una respuesta aceptada ...
ishmaelMakitla
2

Otra versión usando 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
fuente
2

Usando pygame :

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

[1]

Sin embargo, si está tratando de configurar su ventana al tamaño de la pantalla, es posible que desee hacer lo siguiente:

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

para configurar su pantalla en modo de pantalla completa. [2]

Tom Burrows
fuente
Confirmado que funciona en Windows :) ¡Qué buen método no específico de Windows!
Lukasz Czerwinski
1

Podrías usar PyMouse . Para obtener el tamaño de la pantalla, simplemente use el screen_size()atributo:

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

adevolverá una tupla, (X, Y)donde Xes la posición horizontal yY es la posición vertical.

Enlace a la función en la documentación.

Simón
fuente
1

Si está trabajando en el sistema operativo Windows, puede usar el módulo del sistema operativo para obtenerlo:

import os
cmd = 'wmic desktopmonitor get screenheight, screenwidth'
size_tuple = tuple(map(int,os.popen(cmd).read().split()[-2::]))

Devolverá una tupla (Y, X) donde Y es el tamaño vertical y X es el tamaño horizontal. Este código funciona en Python 2 y Python 3

Diroallu
fuente
0

En Linux podemos usar el módulo de subproceso

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
fuente
0

Es un poco problemático para la pantalla de retina, uso tkinter para obtener el tamaño falso, uso pilllow grab para obtener el tamaño real:

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
fuente
0

Para versiones posteriores 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
fuente
0

Para Linux, puede usar esto:

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
fuente
0

Script de utilidad usando pynputbiblioteca. Publicando aquí para ref .:

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