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

  • Estás usando una interfaz de usuario kit de herramientas? (por ejemplo. GTK, wxPython, Tkinter, etc)
  • Con el Tkinter módulo, usted puede hacerlo así. Es parte del estándar de la biblioteca de Python y funciona en la mayoría de las plataformas Unix y Windows.
  • Una buena visión general sobre las diferentes técnicas para el común de la UIs se da en este enlace

27 Comentarios

  1. 56

    En Windows:

    from win32api import GetSystemMetrics
    
    print("Width =", GetSystemMetrics(0))
    print("Height =", GetSystemMetrics(1))

    Si usted está trabajando con pantalla de alta resolución, asegúrese de que el intérprete de python es HIGHDPIAWARE.

    Basado en este post.

    • Para multiplataforma solución completa, se refieren a este respuesta
    • Cuando el uso de varios monitores, esto sólo va a devolver el tamaño de la pantalla principal.
    • ¿Cómo se establece el intérprete de python para ser highdpiaware? Esto sería útil incluir en la respuesta.
  2. 101

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

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

    de modo que usted no necesita instalar el pywin32 paquete;
    no necesito nada que no viene con el propio Python.

    Para configuraciones de múltiples pantallas, puede recuperar el combinado de la anchura y la altura del monitor virtual:

    import ctypes
    user32 = ctypes.windll.user32
    screensize = user32.GetSystemMetrics(78), user32.GetSystemMetrics(79)
    • Funciona incluso en el Vino.
    • Nota importante: los valores devueltos pueden ser incorrecta si el ajuste de escala de PPP se utiliza (es decir: a menudo el caso en 4k muestra), usted tiene que llamar a SetProcessDPIAware antes de la inicialización de 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.
    • Para varios monitores, puede utilizar GetSystemMetrics(78) y GetSystemMetrics(79)
    • ¿Qué GetSystemMetrics(78) y GetSystemMetrics(79) retorno?
    • La anchura/altura de la pantalla virtual, en píxeles. msdn.microsoft.com/en-us/library/windows/desktop/…
  3. 68

    He creado un PyPI módulo por esta razón:

    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 múltiples monitores entornos. Su objetivo es ser la plataforma de la cruz; por ahora es compatible con Cygwin y X11 pero pull requests son totalmente bienvenidos.

    • Funciona muy bien en Windows, pero en Mac me sale el siguiente Error: ImportError: no se Pudo cargar X11
    • Funciona muy bien en Ubuntu. Probado en Ubuntu 16.04.
    • FYI, Windows DPI escala todavía se aplica. Esta línea va a decir a Windows que desea la materia prima, sin escala de resolución: «la importación ctypes; user32 = ctypes.windll.user32; user32.SetProcessDPIAware()». 1) la respuesta debe ser superior; buen trabajo. 2) Mi comentario es específico de Windows, no de una biblioteca específica (es decir, screeninfo) 3) código de la extracción y de la prueba de KobeJohn a comentar aquí: stackoverflow.com/a/32541666/2616321
    • Práctico del módulo (+1). He tenido que instalar un par de requisitos (por ejemplo,pip install cython pyobjus) antes de que se podía utilizar en OSX, aunque
  4. 43

    Si usted está usando wxWindows, usted puede simplemente hacer:

    import wx
    
    app = wx.App(False) # the wx.App object must be created first.    
    print(wx.GetDisplaySize())  # returns a tuple
    • +1 por una cruz-plataforma de respuesta.
    • Este es el mejor… que no tienen wx? 🙂 además de un par de líneas en lugar de un montón de código en sus ojos. Este es ahora mi método predeterminado, gracias.
    • Este debe ser app = wx.App(False) de otro modo se obtiene el «wx.Objeto de aplicación deberá crear en primer lugar.» error. 26 votos y nadie hizo cheque? Funciona en Windows, sin necesidad de realización de wx instancia a una variable?
    • Que no tienen wx? Muchas personas?
  5. 38

    Tomado directamente de una respuesta a este post: 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()
    • Si usted tiene pantallas externas extendido a lado de la pantalla principal, este método daría la suma de todas las pantallas de resoluciones, no la resolución de pantalla actual.
    • Para una pantalla múltiple paso, consulte mi respuesta.
  6. 23

    En Windows 8.1 no estoy recibiendo la resolución correcta de cualquiera de ctypes o de los conocimientos tradicionales.
    Otras personas están teniendo este mismo problema para ctypes: getsystemmetrics incorrecto devuelve el tamaño de la pantalla
    Para conseguir la correcta resolución completa de un monitor de alta resolución de PPP en windows 8.1, uno debe llamar SetProcessDPIAware y utilizar el siguiente código:

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

    Todos Los Detalles A Continuación:

    Me enteré de que esto es porque windows es la presentación de informes a la escala de resolución. Parece que python es por defecto un sistema de dpi conscientes » de la aplicación. Tipos de DPI de las aplicaciones compatibles 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 completo de la resolución del monitor, lo cual haría de fuentes pequeñas, el contenido se escala hasta las fuentes son lo suficientemente grandes.

    En mi monitor de recibir:

    Física de resolución: 2560 x 1440 (220 PPP)

    Informó python resolución: 1555 x 875 (158 DPI)

    Por este sitio de windows: http://msdn.microsoft.com/en-us/library/aa770067%28v=vs.85%29.aspx
    La fórmula para el sistema de resolución efectiva es:
    (reported_px*current_dpi)/(96 ppp) = physical_px

    Soy capaz de conseguir la correcta resolución de pantalla completa y actual de los DPI con el siguiente código.
    Tenga en cuenta que yo llamo SetProcessDPIAware() para permitir que el programa para ver 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 devuelve:

    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 220 DPI capaz monitor.
    Mi pantalla de escala de los conjuntos de mi actual DPI a 158.

    Voy a utilizar el 158 para asegurarse de que mi matplotlib parcelas son del tamaño correcto con:
    from pylab import rcParams
    rcParams[‘figura.dpi’] = curr_dpi

    • Usted tiene un montón de buena información aquí, pero la respuesta sí es enterrado en el medio. Para hacer un poco más fácil de leer, ¿puede aclarar exactamente cuál es la respuesta y luego proporcionar la información de fondo?
    • He editado mi post para mostrar la respuesta en el principio, luego de entrar en detalles. Gracias por los comentarios.
    • Parece que hay un error en los cálculos aquí, que es fácil de detectar es calcular un tamaño diagonal de la informó de la anchura y la altura (en pulgadas). Mi pantalla de 13,3 pulgadas de diagonal fue reportado como de 15 pulgadas. Parece Tkinter es el uso correcto de los píxeles, pero no es consciente de que el ajuste de escala de ppp por lo tanto los informes equivocado mm tamaños.
    • Esto no funciona en Windows 10, no se la SetSystemDPIAware() no parece hacer una diferencia. Sin embargo, llamar ctypes.windll.shcore.SetProcessDpiAwareness(2) en lugar parece hacer el truco.
    • Gracias esto funciona perfecto en 4K pantalla win10
    • devuelve el error OSError: [WinError 126] The specified module could not be found.
    • Estoy en Win 7, aunque.
    • Este código no funciona en Windows 7 de 64 bits. Me estoy poniendo de una ventana de ancho y altura de la ventana que se fuera. El winfo_screenmmwidth() función de los rendimientos de los resultados incorrectos. Alguna idea?
    • si yo fuera usted, me gustaría probar el otro input_value a: user32.GetSystemMetrics(input_value) Los valores posibles se enumeran a continuación: docs.microsoft.com/en-us/windows/desktop/api/winuser/… y concéntrese en lo que su actual resultados reportados son de wx, lo son de user32, cuál es la diferencia, y si la diferencia es de un DPI problema.
    • Gracias! Voy a intentar eso y volver a usted.
    • Miré a través de la MS de la documentación a la que se enlaza. Lamentablemente, no hay métodos para encontrar dpi o cualquier tipo de conversión. Todo está en píxeles. De acuerdo a las especificaciones en mi monitor, parece que devolver el número de píxeles. Pero la densidad es definitivamente superior a 96 dpi, ya que no tengo una de 20″ de ancho monitor. user32 está volviendo números muy cerca de lo que tkinter es.
    • en los docs se indica la forma en que esos métodos no son dpi consciente. Una búsqueda de DPI en los docs muestra que usted debe buscar en docs.microsoft.com/en-us/windows/desktop/api/winuser/… y docs.microsoft.com/en-us/windows/desktop/hidpi/…
    • Genial, gracias! Voy a comprobar que una vez estoy de vuelta con mi máquina Windows. Ahora mismo, tengo un trabajo experimental-alrededor de donde yo medición física de mi monitor y me empírica de los dpi. Funciona bastante bien, pero obviamente, esto sería más elegante si yo pudiera llegar a trabajar.

  7. 16

    Y para la integridad, 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 contiene todos los tamaños de pantalla (si hay varios monitores presente)

  8. 14

    Si usted está utilizando el Qt kit de herramientas específicamente 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()
  9. 12

    Este es un pequeño programa en Python que se mostrará la información acerca de su configuración de varios 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)  

    He aquí 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)
    • ¿gtk.Window() Obtener la gdk_default_root_window? Es que la forma en que son ciertas .get_screen contiene todos los monitores?
    • Lo pregunto porque en mi código Im tratando de replicar el código, lo que estoy haciendo en jsctypes, y que me dice 0 monitores: gist.github.com/yajd/55441c9c3d0711ee4a38#file-gistfile1-txt-L3
    • Es un tiempo desde que escribí ese código pero, si recuerdo correctamente, lo que gtk.Window() hace es crear una nueva ventana (ver aquí). La ventana sólo una manera de utilizar get_screen para obtener la información del monitor. Devuelve la pantalla de que la ventana es (o lo sería, si alguna vez se muestran). Supongo que depende de la configuración de X si esa «pantalla» contiene todos los «monitores». Que hace en mi sistema con Twinview.
    • Gracias @starfry! Necesitaba encontrar una cruz solución que se obtiene de todos los monitores y sus dimensiones, independientemente de las pantallas. Ha tenido usted alguna chacne para desarrollar algo como eso? 🙂
    • Alternativa para su posterior kit de herramientas de versiones: «python
  10. 9

    Estoy usando un get_screen_resolution método en uno de mis proyectos como el de abajo, que es básicamente una importación de la cadena. Usted puede modificar este acuerdo a Sus necesidades, eliminando aquellas partes que no son necesarios y se mueven más probable es que los puertos 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)
    • Gracias por compartir esto, pero podría haber sido acortado mucho mediante el uso de una función para gestionar el if-else casos
  11. 7

    Vieja pregunta, pero esta es la que falta.
    Soy nuevo en python, así que por favor dime si esto es una «mala solución».
    Esta solución es compatible con Windows y MacOS y sólo funciona sólo para la pantalla principal – pero el sistema operativo no es mencionado en la pregunta.

    Medir el tamaño de tomar una captura de pantalla. Como el screensize no debe cambiar esto tiene que ser hecho sólo una vez.
    Hay más soluciones elegantes si usted tiene un conjunto de herramientas gui como GTK, wx, … instalado.

    ver Almohada

    pip install Pillow

    from PIL import ImageGrab
    img = ImageGrab.grab()
    print (img.size)
  12. 6

    XWindows versión:

    #!/usr/bin/python
    import Xlib
    import Xlib.display
    resolution = Xlib.display.Display().screen().root.get_geometry()
    print str(resolution.width) + "x" + str(resolution.height)
  13. 5

    En caso de tener PyQt4 instalado, intente 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, los siguientes:

    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))
  14. 3

    El Uso De Linux
    En lugar de regexp tomar la primera línea y llevar a cabo la resolución actual de los valores.

    Actual de la resolución 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 fue hecho en el xrandr 1.3.5, no sé si el resultado es diferente en otras versiones, pero esto debería hacer que sea fácil de averiguar.

    • lamentablemente no es muy bueno con las configuraciones de múltiples monitores. no python culpa, pero el uso de este puede tener resultados inesperados…
  15. 3

    Expansión en @user2366975‘s respuesta, para obtener el tamaño de pantalla actual en un multi-pantalla de configuración mediante el uso de 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 de la cruz-plataforma, probado en Linux)

  16. 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,
  17. 2

    Otra versión, con 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)
  18. 2

    Utilizando pygame:

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

    [1]

    Sin embargo, si usted está tratando de crear su ventana al tamaño de la pantalla, es posible que sólo quieren hacer:

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

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

    • Confirmado que funciona en Windows 🙂 Qué bonito no es de Windows método específico!
  19. 1

    Intentar pyautogui:

    import pyautogui
    resolution = pyautogui.size()
    print(resolution) 
    • Usted realmente debe añadir alguna explicación de por qué este código debería funcionar – también se pueden añadir comentarios en el código en sí mismo – en su forma actual, no proporciona ningún tipo de explicación que puede ayudar al resto de la comunidad a entender lo que usted hizo para resolver/responder a la pregunta. Pero esta también es una pregunta vieja – con se aceptan como respuesta…
    • Genial, funciona en Windows 🙂
  20. 1

    Una plataforma de la cruz y la manera fácil de hacer esto es mediante el uso de TKinter que viene con casi todas las versiones de python así que usted no tiene que instalar nada:

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

    Si usted está trabajando en el sistema operativo Windows, puede utilizar OS módulo de conseguirlo:

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

    Devuelve 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

  22. 0

    En Linux podemos usar el módulo subprocess

    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())
  23. 0

    Es un poco molesto para la pantalla retina, yo uso tkinter para obtener el falso tamaño, uso pilllow agarrar conseguir el verdadero tamaño :

    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
  24. 0

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

Dejar respuesta

Please enter your comment!
Please enter your name here