Wie erhalte ich die Monitorauflösung in Python?

125

Was ist der einfachste Weg, um die Monitorauflösung zu erhalten (vorzugsweise in einem Tupel)?

Rechteck
quelle
Verwenden Sie ein bestimmtes UI-Toolkit? (zB GTK, wxPython, Tkinter usw.)
Detly
11
Mit dem TkinterModul können Sie dies auf diese Weise tun . Es ist Teil der Standard-Python-Bibliothek und funktioniert auf den meisten Unix- und Windows-Plattformen.
Martineau
1
Einen guten Überblick über verschiedene Techniken für gängige Benutzeroberflächen finden Sie unter diesem Link
ImportanceOfBeingErnest

Antworten:

74

Unter Windows:

from win32api import GetSystemMetrics

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

Wenn Sie mit einem hochauflösenden Bildschirm arbeiten, stellen Sie sicher, dass Ihr Python-Interpreter HIGHDPIAWARE ist.

Basierend auf diesem Beitrag.

Robus
quelle
9
Eine vollständige Lösung für
mehrere Plattformen finden Sie
1
Bei Verwendung mehrerer Monitore wird nur die Größe der primären Anzeige zurückgegeben.
Stevoisiak
1
Wie stellen Sie den Python-Interpreter ein highdpiaware? Dies wäre nützlich, um es in die Antwort aufzunehmen.
Eric
120

In Windows können Sie ctypes auch verwenden mit GetSystemMetrics():

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

damit Sie das pywin32-Paket nicht installieren müssen; Es braucht nichts, was nicht mit Python selbst geliefert wird.

Bei Multi-Monitor-Setups können Sie die kombinierte Breite und Höhe des virtuellen Monitors abrufen:

import ctypes
user32 = ctypes.windll.user32
screensize = user32.GetSystemMetrics(78), user32.GetSystemMetrics(79)
jcao219
quelle
11
Wichtiger Hinweis: Die zurückgegebenen Werte sind möglicherweise falsch, wenn die DPI-Skalierung verwendet wird (dh häufig bei 4k-Anzeigen). Sie müssen SetProcessDPIAware aufrufen, bevor Sie die GUI-Komponenten initialisieren (und nicht, bevor Sie die GetSystemMetrics-Funktion aufrufen). Dies gilt für die meisten Antworten hier (GTK usw.) auf der win32-Plattform.
Totaam
1
Für mehrere Monitore können Sie GetSystemMetrics (78) und GetSystemMetrics (79)
Derek
@Derek Was macht GetSystemMetrics(78)und GetSystemMetrics(79)zurück?
Stevoisiak
@StevenVascellaro Die Breite / Höhe des virtuellen Bildschirms in Pixel. msdn.microsoft.com/en-us/library/windows/desktop/…
Derek
93

Ich habe aus diesem Grund ein PyPI-Modul erstellt :

pip install screeninfo

Der Code:

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

Ergebnis:

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

Es unterstützt Umgebungen mit mehreren Monitoren . Ihr Ziel ist es, plattformübergreifend zu sein. Im Moment unterstützt es Cygwin und X11, aber Pull-Anfragen sind absolut willkommen.

rr-
quelle
2
Funktioniert gut unter Windows, aber Mac Ich erhalte den folgenden Fehler: ImportError: X11 konnte nicht geladen werden
Chris Lucian
5
Funktioniert hervorragend unter Ubuntu. Getestet unter Ubuntu 16.04.
Dhruv Reshamwala
3
Zu Ihrer Information, die Windows DPI-Skalierung gilt weiterhin. Diese Zeile teilt Windows mit, dass Sie die rohe, nicht skalierte Auflösung wünschen: "import ctypes; user32 = ctypes.windll.user32; user32.SetProcessDPIAware ()". 1) Ihre Antwort sollte oben sein; Gut gemacht. 2) Mein Kommentar ist Windows-spezifisch, nicht bibliotheksspezifisch (dh Bildschirminfo). 3) Code aus KobeJohns Kommentar hier gerippt und getestet: stackoverflow.com/a/32541666/2616321
Jason2616321
6
Handliches Modul (+1). Ich musste ein paar Anforderungen installieren (z. B. pip install cython pyobjus), bevor ich es unter OSX verwenden konnte
George Profenza
45

Wenn Sie wxWindows verwenden, können Sie einfach Folgendes tun:

import wx

app = wx.App(False) # the wx.App object must be created first.    
print(wx.GetDisplaySize())  # returns a tuple
Ned Batchelder
quelle
Dies ist der beste ... wer hat kein wx? :) plus ein paar Zeilen statt ein paar Codes auf deinen Augen. Dies ist jetzt meine Standardmethode, danke.
m3nda
1
Dies sollten app = wx.App(False)Sie bekommen sonst das „das wx.App Objekt muss erst geschaffen werden.“ Error. 26 Stimmen und niemand hat nachgesehen? Funktioniert es unter Windows, ohne einer Variablen eine wx-Instanz zuzuweisen?
m3nda
2
Wer hat nicht wx? Viele Leute?
Sumpf
43

Entnommen direkt aus einer Antwort auf diesen Beitrag: Wie erhalte ich die Bildschirmgröße in Tkinter?

import tkinter as tk

root = tk.Tk()

screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()
user2366975
quelle
8
Wenn Sie externe Anzeigen neben der primären Anzeige haben, gibt diese Methode die Summe aller Bildschirmauflösungen an, nicht die aktuelle Anzeigeauflösung.
Jadelord
Für einen Schritt mit mehreren Bildschirmen siehe meine Antwort .
Norok2
29

Unter Windows 8.1 erhalte ich weder von ctypes noch von tk die richtige Auflösung. Andere Benutzer haben das gleiche Problem bei ctypes: getsystemmetrics gibt eine falsche Bildschirmgröße zurück. Um die korrekte volle Auflösung eines Monitors mit hoher DPI unter Windows 8.1 zu erhalten, muss SetProcessDPIAware aufgerufen und der folgende Code verwendet werden:

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

Vollständige Details unten:

Ich habe herausgefunden, dass dies daran liegt, dass Windows eine skalierte Auflösung meldet. Es scheint, dass Python standardmäßig eine "System-dpi-fähige" Anwendung ist. Hier sind Arten von DPI-fähigen Anwendungen aufgeführt: http://msdn.microsoft.com/en-us/library/windows/desktop/dn469266%28v=vs.85%29.aspx#dpi_and_the_desktop_scaling_factor

Anstatt Inhalte in voller Monitorauflösung anzuzeigen, wodurch Schriftarten winzig werden, wird der Inhalt grundsätzlich vergrößert, bis die Schriftarten groß genug sind.

Auf meinem Monitor wird Folgendes angezeigt:
Physikalische Auflösung: 2560 x 1440 (220 DPI)
Gemeldete Python-Auflösung: 1555 x 875 (158 DPI)

Auf dieser Windows-Website: http://msdn.microsoft.com/en-us/library/aa770067%28v=vs.85%29.aspx Die Formel für die gemeldete effektive Systemauflösung lautet: (gemeldete_px * aktuelle_dpi) / (96 dpi ) = Physical_px

Ich kann die richtige Vollbildauflösung und die aktuelle DPI mit dem folgenden Code erhalten. Beachten Sie, dass ich SetProcessDPIAware () aufrufe, damit das Programm die tatsächliche Auflösung sehen kann.

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

Was zurückkam:

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

Ich verwende Windows 8.1 mit einem 220 DPI-fähigen Monitor. Meine Anzeigeskalierung setzt meine aktuelle DPI auf 158.

Ich werde die 158 verwenden, um sicherzustellen, dass meine Matplotlib-Plots die richtige Größe haben mit: vom Pylab-Import rcParams rcParams ['figure.dpi'] = curr_dpi

Raumhalter
quelle
Sie haben hier viele gute Informationen, aber die Antwort selbst ist in der Mitte vergraben. Können Sie zur besseren Lesbarkeit genau klären, wie die Antwort lautet, und dann die Hintergrundinformationen bereitstellen?
skrrgwasme
Ich habe meinen Beitrag bearbeitet, um die Antwort am Anfang anzuzeigen, und bin dann auf die Details eingegangen. Danke für die Rückmeldung.
Spacether
1
Es sieht so aus, als ob es hier einen Fehler in den Berechnungen gibt, der leicht zu erkennen ist. Sie berechnen eine diagonale Größe aus der angegebenen Breite und Höhe (in Zoll). Mein Bildschirm mit einer Diagonale von 13,3 Zoll wurde als 15 Zoll angegeben. Es scheint Tkinter, dass korrekte Pixel verwendet werden, ist sich jedoch der dpi-Skalierung nicht bewusst, sodass falsche mm-Größen gemeldet werden.
Primer
Dies funktioniert unter Windows 10 nicht, da die SetSystemDPIAware () keinen Unterschied zu machen scheint. Der Aufruf von ctypes.windll.shcore.SetProcessDpiAwareness (2) scheint jedoch den Trick zu tun.
Klamer Schutte
@KlamerSchutte: Gibt einen ctypes.windll.shcore.SetProcessDpiAwareness(2)Fehler zurück OSError: [WinError 126] The specified module could not be found.
Adrian Keister
21

Und der Vollständigkeit halber Mac OS X.

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

gibt Ihnen eine Liste von Tupeln mit allen Bildschirmgrößen (wenn mehrere Monitore vorhanden sind)

Cobbal
quelle
15

Wenn Sie das QtToolkit speziell verwenden PySide, können Sie Folgendes tun:

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

Unter Linux ist es am einfachsten, den Befehl bash auszuführen

xrandr | grep '*'

und analysieren Sie die Ausgabe mit Regexp.

Sie können dies auch über PyGame tun: http://www.daniweb.com/forums/thread54881.html

Pavel Strakhov
quelle
Wie benutzt man Pygame, um die Bildschirmauflösung zu erhalten?
Jamie Twells
11

Hier ist ein kurzes kleines Python-Programm, das Informationen zu Ihrem Multi-Monitor-Setup anzeigt:

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)  

Hier ist ein Beispiel für die Ausgabe:

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)
Sternenhimmel
quelle
Bekommt gtk.Window()das gdk_default_root_window? Sind Sie so sicher, dass .get_screenalle Monitore enthalten sind?
Yatg
Ich frage, weil ich in meinem Code versuche, Ihren Code zu replizieren, ich mache es in jsctypes und es sagt mir immer wieder 0 Monitore: gist.github.com/yajd/55441c9c3d0711ee4a38#file-gistfile1-txt-L3
yatg
2
Es ist eine Weile her, dass ich diesen Code geschrieben habe, aber wenn ich mich richtig erinnere, was gtk.Window() wird ein neues Fenster erstellt (siehe hier ). Das Fenster ist nur eine Möglichkeit get_screen, um die Monitorinformationen abzurufen. Es gibt den Bildschirm zurück, auf dem sich das Fenster befindet (oder wäre, wenn es jemals angezeigt würde). Ich denke, es hängt von der X-Konfiguration ab, ob dieser "Bildschirm" alle "Monitore" enthält. Es funktioniert auf meinem System mit Twinview.
starfry
Danke @starfry! Ich musste eine Kreuzlösung finden, die alle Monitore und ihre Abmessungen unabhängig von den Bildschirmen erfasst. Hattest du Chacne, um so etwas zu entwickeln? :)
yatg
Alternative für spätere Toolkit-Versionen: `` `Python
Satyagraha
9

Ich verwende eine get_screen_resolution-Methode in einem meiner Projekte wie dem folgenden, bei dem es sich im Grunde um eine Importkette handelt. Sie können dies gemäß Ihren Anforderungen ändern, indem Sie die nicht benötigten Teile entfernen und die Anschlüsse in der Kette mit größerer Wahrscheinlichkeit nach oben verschieben.

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
quelle
1
Vielen Dank für das Teilen, aber es hätte viel verkürzt werden können, indem eine Funktion zur Behandlung der If-else-Fälle verwendet wurde
Udayraj Deshmukh
8

Alte Frage, aber das fehlt. Ich bin neu in Python. Bitte sagen Sie mir, ob dies eine "schlechte" Lösung ist. Diese Lösung wird nur für Windows und MacOS unterstützt und funktioniert nur für den Hauptbildschirm - aber das Betriebssystem wird in der Frage nicht erwähnt.

Messen Sie die Größe, indem Sie einen Screenshot machen. Da sich die Bildschirmgröße nicht ändern sollte, muss dies nur einmal durchgeführt werden. Es gibt elegantere Lösungen, wenn Sie ein GUI-Toolkit wie GTK, wx, ... installiert haben.

siehe Kissen

pip install Pillow

from PIL import ImageGrab

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

XWindows-Version:

#!/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
quelle
6

Erweitern Sie die Antwort von @ user2366975 , um die aktuelle Bildschirmgröße in einem Multi-Screen-Setup mit Tkinter (Code in Python 2/3) zu erhalten:

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

(Sollte plattformübergreifend funktionieren, nur unter Linux getestet)

norok2
quelle
5

Versuchen Sie den folgenden Code:

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

Wenn Sie PyQt4 installiert haben, versuchen Sie den folgenden Code:

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

Für PyQt5 funktioniert Folgendes:

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))
Harte Kumar Narula
quelle
5

Eine plattformübergreifende und einfache Möglichkeit, dies zu tun, ist die Verwendung von TKinter, das mit fast allen Python-Versionen geliefert wird, sodass Sie nichts installieren müssen:

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

Verwenden von Linux Anstelle von regulärem Ausdruck nehmen Sie die erste Zeile und die aktuellen Auflösungswerte heraus.

Aktuelle Auflösung der Anzeige: 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

Dies wurde unter xrandr 1.3.5 durchgeführt. Ich weiß nicht, ob die Ausgabe in anderen Versionen unterschiedlich ist, aber dies sollte es einfacher machen, dies herauszufinden.

Alex R.
quelle
Leider nicht sehr gut mit Multimonitor-Setups. Nicht Pythons Schuld, aber die Verwendung kann unerwartete Ergebnisse haben ...
black_puppydog
2

So erhalten Sie Bits pro 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))

Parameter 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,
user3757097
quelle
2

Versuchen Sie pyautogui:

import pyautogui
resolution = pyautogui.size()
print(resolution) 
Tyler
quelle
Sie sollten wirklich eine Erklärung hinzufügen, warum dieser Code funktionieren sollte - Sie können auch Kommentare in den Code selbst einfügen - in seiner aktuellen Form enthält er keine Erklärung, die dem Rest der Community helfen kann, zu verstehen, was Sie zur Lösung getan haben /beantworte die Frage. Aber dies ist auch eine sehr alte Frage - mit einer akzeptierten Antwort ...
ishmaelMakitla
2

Eine andere Version mit 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
quelle
2

Mit pygame :

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

[1]

Wenn Sie jedoch versuchen, Ihr Fenster auf die Größe des Bildschirms einzustellen, möchten Sie möglicherweise nur Folgendes tun:

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

um Ihr Display in den Vollbildmodus zu versetzen. [2]

Tom Burrows
quelle
Bestätigt, dass es unter Windows funktioniert :) Was für eine nette, nicht Windows-spezifische Methode!
Lukasz Czerwinski
1

Sie könnten PyMouse verwenden . Um die Bildschirmgröße zu erhalten, verwenden Sie einfach das screen_size()Attribut:

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

agibt ein Tupel zurück, (X, Y)wo Xist die horizontale Position undY die vertikale Position ist.

Link zur Funktion in der Dokumentation.

Simon
quelle
1

Wenn Sie unter Windows arbeiten, können Sie das Betriebssystemmodul verwenden, um es abzurufen:

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

Es wird ein Tupel (Y, X) zurückgegeben, wobei Y die vertikale Größe und X die horizontale Größe ist. Dieser Code funktioniert unter Python 2 und Python 3

Diroallu
quelle
0

Unter Linux können wir ein Unterprozessmodul verwenden

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

Es ist ein wenig lästig für Retina-Bildschirm, ich benutze tkinter, um die falsche Größe zu erhalten, benutze Pilllow Grab, um die richtige Größe zu erhalten:

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

Für spätere Versionen von 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
quelle
0

Für Linux können Sie Folgendes verwenden:

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

Hilfsskript mit pynputBibliothek. Posting hier für 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)
Olumidesan
quelle