Come faccio a ottenere la risoluzione del monitor in Python?

Qual è il modo più semplice per ottenere la risoluzione del monitor (preferibilmente in una tupla)?

  • Stai usando un particolare UI toolkit? (es. GTK, wxPython, Tkinter, ecc)
  • Con il Tkinter modulo, si può fare in questo modo. Fa parte della libreria standard di Python e funziona sulla maggior parte delle piattaforme Unix e Windows.
  • Una buona panoramica sulle diverse tecniche per comune UIs è dato a questo link

 

26 Replies
  1. 53

    Su Windows:

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

    Se si lavora con schermo ad alta risoluzione, assicuratevi che il vostro interprete python è HIGHDPIAWARE.

    Base questo post.

    • Per multipiattaforma soluzione completa, fare riferimento a risposta
    • Quando si utilizzano più monitor, questo sarà solo restituire la dimensione del display primario.
    • Come si fa a impostare l’interprete python per essere highdpiaware? Questo sarebbe utile includere nella risposta.
  2. 97

    In Windows, è possibile utilizzare anche ctypes con GetSystemMetrics():

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

    in modo che non hai bisogno di installare il pywin32 pacchetto;
    non ha bisogno di nulla che non arrivano con Python stesso.

    Per le configurazioni multi-monitor, è possibile recuperare il combinato larghezza e l’altezza del monitor virtuale:

    import ctypes
    user32 = ctypes.windll.user32
    screensize = user32.GetSystemMetrics(78), user32.GetSystemMetrics(79)
    • Funziona anche sul Vino.
    • Nota importante: i valori restituiti può essere corretto se il ridimensionamento DPI utilizzato (ie: spesso il caso in 4k display), e devo dire che SetProcessDPIAware prima di inizializzare i componenti dell’interfaccia grafica (e non prima di chiamare la funzione GetSystemMetrics). Questo è vero per la maggior parte delle risposte qui (GTK, ecc) su piattaforma win32.
    • Per più monitor, è possibile utilizzare GetSystemMetrics(78) e GetSystemMetrics(79)
    • Cosa GetSystemMetrics(78) e GetSystemMetrics(79) ritorno?
    • La larghezza/altezza dello schermo virtuale, in pixel. msdn.microsoft.com/en-us/library/windows/desktop/…
  3. 65

    Ho creato un PyPI modulo per questo motivo:

    pip install screeninfo

    Codice:

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

    Risultato:

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

    Supporta il multi monitor ambienti. Il suo obiettivo è quello di essere cross-platform; per ora supporta Cygwin e X11, ma tirare le richieste sono assolutamente i benvenuti.

    • Funziona alla grande su Windows ma Mac ottengo il seguente Errore: ImportError: impossibile caricare X11
    • Funziona alla grande su Ubuntu. Testato su Ubuntu 16.04.
    • Cordiali saluti, Windows ridimensionamento DPI si applica ancora. Questa linea dire di Windows che si desidera che il raw, non in scala di risoluzione: “importa ctypes; user32 = ctypes.windll.user32; user32.SetProcessDPIAware()”. 1) la risposta dovrebbe essere superiore; buon lavoro. 2) il Mio commento è specifico per Windows, non specifico di libreria (cioè screeninfo) 3) codice strappato e testato da KobeJohn commento qui: stackoverflow.com/a/32541666/2616321
    • Pratico modulo (+1). Ho dovuto installare un paio di requisiti (ad esempio,pip install cython pyobjus) prima di poter utilizzare su OSX se
  4. 42

    Se si utilizza wxWindows, si può semplicemente fare:

    import wx
    
    app = wx.App(False) # the wx.App object must be created first.    
    print(wx.GetDisplaySize())  # returns a tuple
    • +1 per un cross-piattaforma di risposta.
    • Questo è il migliore… che non hanno wx? 🙂 più un paio di righe invece che un mucchio di codice sui vostri occhi. Questo è ora il mio metodo di default, grazie.
    • Questo dovrebbe essere app = wx.App(False) altrimenti si ottiene il “wx.App oggetto deve essere creato prima.” errore. 26 voti favorevoli e nessuno se ne è andata? Funziona in Windows senza passare wx istanza di una variabile?
    • Che non hanno wx? Molte persone?
  5. 36

    Presa direttamente da una risposta a questo post: Come ottenere le dimensioni dello schermo in Tkinter?

    import tkinter as tk
    
    root = tk.Tk()
    
    screen_width = root.winfo_screenwidth()
    screen_height = root.winfo_screenheight()
    • Se si dispone di display esterni, esteso a fianco del display primario, questo metodo dia la somma di tutti i display, le risoluzioni, non la risoluzione di visualizzazione corrente.
    • Per di più la schermata di passaggio, vedere la mia risposta.
  6. 20

    Su Windows 8.1 non ricevo la corretta risoluzione da ctypes o tk.
    Altre persone stanno avendo lo stesso problema per ctypes: getsystemmetrics restituisce sbagliato la dimensione dello schermo
    Per ottenere la corretta piena risoluzione di un alto DPI del monitor in windows 8.1, uno deve chiamare SetProcessDPIAware e utilizzare il codice riportato di seguito:

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

    Tutti I Dettagli Qui Sotto:

    Ho scoperto che questo è perché windows è la segnalazione di una scala di risoluzione. Sembra che python è di default un sistema di dpi’ applicazione. Tipi di DPI applicazioni sono elencate di seguito:
    http://msdn.microsoft.com/en-us/library/windows/desktop/dn469266%28v=vs.85%29.aspx#dpi_and_the_desktop_scaling_factor

    In sostanza, piuttosto che la visualizzazione di contenuti la completa risoluzione del monitor, che consentirebbe, in caratteri minuscoli, il contenuto viene scalata fino a quando i caratteri sono abbastanza grandi.

    Sul mio monitor mi esce:

    Fisico risoluzione: 2560 x 1440 (220 DPI)

    Segnalato python risoluzione: 1555 x 875 (158 DPI)

    Per questo sito di windows: http://msdn.microsoft.com/en-us/library/aa770067%28v=vs.85%29.aspx
    La formula per il segnalati sistema di risoluzione effettiva è:
    (reported_px*current_dpi)/(96 dpi) = physical_px

    Sono in grado di ottenere la corretta risoluzione a schermo intero, e la corrente di DPI con il seguente codice.
    Nota che io chiamo SetProcessDPIAware() per consentire il programma per vedere la reale risoluzione.

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

    Che è tornato:

    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

    Sono in esecuzione windows 8.1 con un 220 DPI in grado di monitorare.
    La mia scala della visualizzazione imposta il mio attuale DPI a 158.

    Io uso il 158 per assicurarsi che il mio matplotlib trame sono la giusta dimensione con:
    da pylab importazione rcParams
    rcParams[‘figura.dpi’] = curr_dpi

    • Hai un sacco di buone informazioni qui, ma la risposta stessa è sepolto nel mezzo. Per rendere un po ‘ più facile da leggere, puoi chiarire esattamente che cosa la risposta è e poi fornire le informazioni di base?
    • Ho modificato il mio post per mostrare la risposta all’inizio, poi entrare nei dettagli. Grazie per il feedback.
    • Sembra che c’è un difetto nei calcoli qui, che è facile da individuare è possibile calcolare un diagonale dalla segnalato la larghezza e l’altezza (in centimetri). Il mio schermo 13,3 pollici di diagonale è stato segnalato come a 15 pollici. Sembra Tkinter è l’utilizzo corretto pixel, ma non è a conoscenza di ridimensionamento dpi così reporting sbagliato mm dimensioni.
    • Questo non funziona su Windows 10, c’è il SetSystemDPIAware() non sembra fare la differenza. Tuttavia, chiamare ctypes.windll.shcore.SetProcessDpiAwareness(2) invece sembra fare il trucco.
    • Grazie questo funziona perfettamente su schermo 4K win10
    • restituisce l’errore OSError: [WinError 126] The specified module could not be found.
    • Io sono in Win 7, però.
    • Questo codice non funziona in Windows 7 a 64 bit. Sto diventando una finestra di larghezza e altezza della finestra che sono fuori strada. Il winfo_screenmmwidth() funzione produce risultati non corretti. Tutte le idee?
    • se fossi in te cercherei le altre input_value a: user32.GetSystemMetrics(input_value) I valori possibili sono elencati qui: docs.microsoft.com/en-us/windows/desktop/api/winuser/… e scavare in ciò che il vostro attuale risultati riportati sono da wx, che sono da user32, qual è la differenza, e se tale differenza è da un DPI problema.
    • Grazie! Proverò e tornare a voi.
    • Ho guardato attraverso il MS documentazione di cui ci si è collegati. Purtroppo non ci sono metodi per l’individuazione dei dpi o di qualsiasi tasso di conversione. Tutto è in pixel. Secondo le specifiche tecniche sul mio monitor, sembra restituire il giusto numero di pixel. Ma la densità è sicuramente superiore a 96 dpi, in quanto non ho un 20″ wide monitor. user32 è tornato a numeri molto vicino a quello che tkinter è.
    • in quei documenti elencati come tali metodi non sono in grado di riconoscere dpi. Una ricerca di DPI in quei documenti mostra che si dovrebbe guardare in docs.microsoft.com/en-us/windows/desktop/api/winuser/… e docs.microsoft.com/en-us/windows/desktop/hidpi/…
    • Grande, grazie! Vado a controllare che una volta sono tornato con la mia macchina Windows. Adesso ho un lavoro sperimentale-intorno, dove posso fisicamente misurato il mio monitor e ho preso un empiriche dpi. Funziona abbastanza bene, ma questo sarebbe ovviamente più elegante se io sono riuscito a farlo funzionare.

  7. 15

    E per completezza, Mac OS X

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

    vi darà una lista di tuple contenenti tutte le dimensioni dello schermo (se più di un monitor presente)

  8. 13

    Se si utilizza il Qt toolkit specificamente PySide, è possibile effettuare le seguenti operazioni:

    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

    Qui è un breve programma in Python che consentirà di visualizzare le informazioni sulla configurazione multi-monitor:

    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)  

    Ecco un esempio di output:

    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)
    • Non gtk.Window() ottenere il gdk_default_root_window? È che come si sono determinati .get_screen contiene tutti i monitor?
    • Lo chiedo perchè nel mio codice Im cercando di replicare il codice, lo sto facendo in jsctypes, e si continua a dirmi 0 monitor: gist.github.com/yajd/55441c9c3d0711ee4a38#file-gistfile1-txt-L3
    • È un po ‘ da quando ho scritto quel codice, ma, se ricordo bene, che cosa gtk.Window() non fa altro che creare una nuova finestra (vedi qui). La finestra è solo un modo per utilizzare get_screen per ottenere le informazioni sul monitor. Ritorna la schermata con la finestra che è (o sarebbe, se mai fosse visualizzato). Credo dipenda dalla configurazione di X se che “schermo” che contiene tutti i “monitor”. Sul mio sistema con Twinview.
    • Grazie @starfry! Ho bisogno di trovare un cross soluzione che ottiene tutti i monitor e le loro dimensioni, indipendentemente dalla schermi. Hai avuto chacne di sviluppare qualcosa di simile? 🙂
  10. 8

    Sto usando un get_screen_resolution metodo in uno dei miei progetti come quello qui sotto, che è sostanzialmente una catena di importazione. È possibile modificare questo in base alle Vostre esigenze, eliminando le parti che non sono necessari e spostare più probabile che porti verso l’alto nella catena.

    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)
    • Grazie per la condivisione di questo, ma potrebbe essere stato accorciato un sacco utilizzando una funzione per gestire l’if-else casi
  11. 6

    XWindows versione:

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

    Nel caso In cui si dispone di PyQt4 installato, provare il seguente codice:

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

    Per PyQt5, il seguente lavoro:

    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))
  13. 5

    Vecchia questione, ma questo non è presente.
    Sono nuovo di python quindi, per favore, dimmi se questo è un “cattivo” soluzione.
    Questa soluzione è compatibile con Windows e MacOS solo e funziona solo per la schermata principale – ma il sistema operativo non è menzionato nella domanda.

    Misurare le dimensioni da prendere uno screenshot. Come screensize dovrebbe cambiare questo deve essere fatto solo una volta.
    Ci sono più soluzioni eleganti se si dispone di una gui toolkit come GTK, wx, … installato.

    vedere Cuscino

    pip install Pillow

    from PIL import ImageGrab
    
    img = ImageGrab.grab()
    print (img.size)
  14. 3

    Usando Linux
    Invece di regexp prendere la prima linea e prendere la corrente i valori di risoluzione.

    Corrente risoluzione del display :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

    Ciò è stato fatto su xrandr 1.3.5, non so se l’output è diverso in altre versioni, ma questo dovrebbe rendere più facile per capire.

    • purtroppo non è molto buona, con configurazioni multimonitor. non python colpa, ma utilizzando questo può avere risultati imprevisti…
  15. 2

    Per ottenere bits per 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))

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

    Un’altra versione che utilizza 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)
  17. 2

    Utilizzando pygame:

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

    [1]

    Tuttavia, se si sta cercando di impostare la finestra alle dimensioni dello schermo, si potrebbe semplicemente voler fare:

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

    per impostare il display in modalità a schermo intero. [2]

    • Confermato che funziona su Windows 🙂 Che bel non-Windows metodo specifico!
  18. 1

    Provare pyautogui:

    import pyautogui
    resolution = pyautogui.size()
    print(resolution) 
    • Si dovrebbe davvero aggiungere qualche spiegazione del perché questo codice dovrebbe funzionare – è inoltre possibile aggiungere commenti nel codice stesso – nella sua forma attuale, essa non fornisce alcuna spiegazione, che può aiutare il resto della comunità per capire cosa hai fatto per risolvere/rispondere alla domanda. Ma questa è anche una vecchia questione – con l’accettazione di una risposta…
    • Grande, funziona su Windows 🙂
  19. 0

    Si potrebbe utilizzare PyMouse. Per ottenere la dimensione dello schermo basta usare il screen_size() attributo:

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

    a restituirà una tupla, (X, Y), dove X è la posizione orizzontale e Y è in posizione verticale.

    Link alla funzione di documentazione.

  20. 0

    Su Linux possiamo utilizzare il modulo 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())
  21. 0

    È un po ‘ fastidioso per schermo retina, io uso tkinter per ottenere il falso, dimensione, utilizzo pilllow afferrare per ottenere un reale dimensione :

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

    Se si sta lavorando su sistema operativo Windows, è possibile utilizzare il modulo OS per farlo:

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

    Essa restituisce una tupla (Y,X) dove Y è la dimensione orizzontale e X è la dimensione verticale. Questo codice funziona su Python 2 e Python 3

  23. 0

    Espansione @user2366975‘s risposta, per ottenere l’attuale dimensione dello schermo in configurazioni multi-schermo, usando Tkinter (codice in 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

    (Dovrebbe funzionare cross-platform, testato su Linux)

  24. 0

    Un cross-platform e modo semplice per farlo è tramite TKinter che viene fornito con quasi tutte le versioni di python, quindi non devi installare nulla:

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

Lascia un commento