Wie bekomme ich die monitor-Auflösung in Python?

Was ist der einfachste Weg, um monitor-Auflösung (vorzugsweise in einem Tupel)?

Sind Sie mit einem UI-toolkit? (zB. GTK, wxPython, Tkinter, etc)
Mit der Tkinter - Modul, die Sie tun können, es, dieser Art. Es ist Teil der standard-Python-Bibliothek und funktioniert auf den meisten Unix-und Windows-Plattformen.
Einen guten überblick über verschiedene Techniken für die gemeinsame UIs erhalten Sie unter diesen link

InformationsquelleAutor rectangletangle | 2010-06-27

53

Unter Windows:
```
from win32api import GetSystemMetrics

print("Width =", GetSystemMetrics(0))
print("Height =", GetSystemMetrics(1))
```
Wenn Sie mit hoher Auflösung, stellen Sie sicher, dass Ihre python-interpreter HIGHDPIAWARE.

Basierend auf diese post.

Für plattformübergreifende Komplettlösung, finden Sie diese Antwort
Wenn Sie mehrere Monitore verwenden, diese liefern nur die Größe der primären Anzeige.
Wie legen Sie den python-interpreter zu highdpiaware? Dies wäre nützlich, um in die Antwort.

InformationsquelleAutor Robus
96

In Windows können Sie auch mit ctypes mit GetSystemMetrics():
```
import ctypes
user32 = ctypes.windll.user32
screensize = user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)
```
so dass Sie nicht brauchen, zu installieren der pywin32-Paket;
es muss nicht alles, was nicht kommen mit Python selbst.

Für multi-monitor-setups, die Sie abrufen können, die kombinierte Breite und Höhe des virtuellen Monitors:
```
import ctypes
user32 = ctypes.windll.user32
screensize = user32.GetSystemMetrics(78), user32.GetSystemMetrics(79)
```
Es funktioniert sogar auf Wein.
Wichtiger Hinweis: die zurückgegebenen Werte können falsch sein, wenn die DPI-Skalierung verwendet (z.B.: oft bei 4k-displays), Sie zu rufen SetProcessDPIAware vor der Initialisierung der GUI-Komponenten (und nicht vor dem aufrufen der GetSystemMetrics-Funktion). Dies gilt für die meisten Antworten hier (GTK, etc) auf der win32-Plattform.
Für mehrere Monitore benutzen, können Sie GetSystemMetrics(78) und GetSystemMetrics(79)
Was bedeutet GetSystemMetrics(78) und GetSystemMetrics(79) zurück?
Die Breite/Höhe des virtuellen Bildschirms in Pixel. msdn.microsoft.com/en-us/library/windows/desktop/...

InformationsquelleAutor jcao219
59

Erstellte ich eine PyPI-Modul aus diesem Grund:
```
pip install screeninfo
```
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 multi-monitor-Umgebungen. Sein Ziel ist cross-Plattform; für jetzt ist es unterstützt Cygwin-X11, aber pull-requests sind Total willkommen.

Funktioniert Super auf Windows, aber Mac bekomme ich die folgende Fehlermeldung: ImportError: Konnte nicht geladen, X11
Funktioniert gut auf Ubuntu. Getestet auf Ubuntu 16.04.
FYI, Windows DPI-Skalierung immer noch gilt. Diese Linie wird Ihnen sagen Windows Sie wollen die rohen, unskalierten Auflösung: "import ctypes; user32 = ctypes.windll.user32; user32.SetProcessDPIAware()". 1) Ihre Antwort sollte top sein; gute Arbeit. 2) Mein Kommentar ist Windows-spezifisch, nicht bibliotheksspezifischen (z.B. screeninfo) 3) code gerippt und getestet von KobeJohn Kommentar hier: stackoverflow.com/a/32541666/2616321
Praktisches Modul (+1). Ich hatte mit der Installation ein paar Anforderungen (z.B. pip install cython pyobjus), bevor ich es nutzen kann, obwohl auf OSX

InformationsquelleAutor rr-
42

Wenn du mit wxWindows, Sie können einfach tun:
```
import wx

app = wx.App(False) # the wx.App object must be created first.    
print(wx.GetDisplaySize())  # returns a tuple
```
+1 für ein cross-Plattform-Antwort.
Das ist das beste... wer nicht haben wx? 🙂 plus ein paar Zeilen, statt ein Haufen von code auf Ihre Augen. Dies ist nun meine Standard-Methode, danke.
Dies sollte app = wx.App(False) sonst bekommen Sie die "wx.App-Objekt muss zuerst erstellt werden." - Fehler. 26 Stimmen und niemand hat, überprüfen? Funktioniert in Windows ohne assing wx-Instanz an eine variable?
Wer nicht haben wx? Viele Menschen?

InformationsquelleAutor Ned Batchelder
33

Direkt aus eine Antwort zu diesem post: Wie man die Bildschirmgröße in Tkinter?
```
import tkinter as tk

root = tk.Tk()

screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()
```
Wenn Sie externe displays erweitert, um neben dem primären Bildschirm, wird diese Methode geben würde, die Summe aller displays Auflösungen, die nicht der aktuellen display-Auflösung.

InformationsquelleAutor user2366975
19

Auf Windows 8.1 bin ich nicht immer die korrekte Auflösung von entweder ctypes oder die tk.
Andere Leute haben das gleiche problem für ctypes: getsystemmetrics gibt falsche Bildgröße
Um die richtige volle Auflösung von high-DPI-monitor auf windows 8.1, die muss man rufen SetProcessDPIAware und verwenden Sie den folgenden code:
```
import ctypes
user32 = ctypes.windll.user32
user32.SetProcessDPIAware()
[w, h] = [user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)]
```
Vollständigen Details Unter:

Fand ich heraus, dass dies ist, weil windows meldet einer skalierten Auflösung. Es wird angezeigt, dass python ist standardmäßig ein 'system dpi aware" - Anwendung. Arten von DPI aware Anwendungen sind hier aufgelistet:
http://msdn.microsoft.com/en-us/library/windows/desktop/dn469266%28v=vs.85%29.aspx#dpi_and_the_desktop_scaling_factor

Im Grunde, eher als Anzeige von Inhalten, die volle Auflösung des Monitors, die Schriften winzig, der Inhalt wird skaliert, bis die Schriften groß genug sind.

Auf meinem monitor, den ich bekommen:

Physikalische Auflösung: 2560 x 1440 (220 DPI)

Berichtet python-Auflösung: 1555 x 875 (158 DPI)

Pro das windows-Website: http://msdn.microsoft.com/en-us/library/aa770067%28v=vs.85%29.aspx
Die Formel für gemeldete system-effektive Auflösung:
(reported_px*current_dpi)/(96 dpi) = physical_px

Ich bin in der Lage zu Holen die richtige Vollbild-Auflösung, und die aktuelle DPI-mit dem code unten.
Beachten Sie, dass nenne ich SetProcessDPIAware (), um das Programm zu sehen, die echte Auflösung.
```
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))    
```
Welche zurückgegeben:
```
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 bin mit windows 8.1 mit 220 DPI-fähigen monitor.
Mein display Skalierung setzt meine aktuelle DPI-bis 158.

Werde ich das 158 um sicherzustellen, dass meine matplotlib Grundstücke sind die richtige Größe mit:
from pylab import rcParams
rcParams['Abbildung.dpi'] = curr_dpi

Sie haben eine Menge guter Informationen hier, aber die Antwort selbst ist begraben in der Mitte. Um es ein bisschen einfacher zu Lesen, können Sie das klären, genau das, was die Antwort ist und dann bieten hintergrund Informationen?
Ich bearbeitet meine post zeigen, die Antwort in der Anfang, dann in die details. Vielen Dank für das feedback.
Es sieht aus wie es ein Fehler in den Berechnungen hier, was leicht zu erkennen ist es Berechnung einer diagonalen Größe von der gemeldeten Breite und Höhe (in Zoll). Mein Bildschirm mit 13,3 Zoll Diagonale wurde berichtet, als 15 Zoll. Es scheint Tkinter ist, mit richtigen Pixel, aber ist nicht bewusst, das die dpi-Skalierung damit die Berichterstattung falsch, mm-Größen.
Dies funktioniert nicht auf Windows 10, da die SetSystemDPIAware() scheint nicht, einen Unterschied zu machen. Allerdings ruft ctypes.windll.shcore.SetProcessDpiAwareness(2) stattdessen scheint um den trick zu tun.
Vielen Dank das funktioniert perfekt auf 4K-Bildschirm win10

InformationsquelleAutor spacether
15

Sowie für die Vollständigkeit, Mac OS X
```
import AppKit
[(screen.frame().size.width, screen.frame().size.height)
    for screen in AppKit.NSScreen.screens()]
```
wird Ihnen eine Liste von Tupeln, die alle Bildschirm-Größen (wenn mehrere Monitore vorhanden)

InformationsquelleAutor cobbal

Wenn Sie die Qt toolkit speziell 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()

InformationsquelleAutor MadeOfAir

12

Linux zu verwenden, ist der einfachste Weg zum ausführen von bash-Befehl
```
xrandr | grep '*'
```
machen und analysieren Sie Ihre Ausgabe mit regexp.

Auch Sie können es tun, durch PyGame: http://www.daniweb.com/forums/thread54881.html

Wie verwenden Sie pygame, um die Bildschirm-Auflösung?
stackoverflow.com/a/19954583/344347

InformationsquelleAutor Pavel Strakhov
12

Hier ist eine schnelle kleine Python-Programm, das anzeigen der Informationen über Ihre multi-monitor-setup:
```
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 der 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)
```
Tut gtk.Window() Holen Sie sich die gdk_default_root_window? Ist, dass, wie Sie sicher sind .get_screen enthält alle Monitore?
Ich Frage, weil in meinem code, ich versuche zu replizieren deinen code, ich mache es in jsctypes, und es sagt mir 0-Monitore: gist.github.com/yajd/55441c9c3d0711ee4a38#file-gistfile1-txt-L3
Es ist eine Weile her, seit ich schrieb, dass der code aber, wenn ich mich Recht erinnere, was gtk.Window() tut, ist erstellen Sie ein neues Fenster (siehe hier). Das Fenster ist nur ein Weg, um get_screen um die monitor-Informationen. Es gibt den Bildschirm, der das Fenster auf ist (oder wäre, wenn es überhaupt angezeigt wird). Ich denke, es hängt von der X-Konfiguration, ob das "Bildschirm" enthält alle "Monitore". Es funktioniert auf meinem system mit Twinview.
Danke @starfry! Ich benötigte eine Kreuz-Lösung, die bekommt alle Monitore und deren Abmessungen unabhängig von den Bildschirmen. Haben Sie hatte keine chacne etwas zu entwickeln? 🙂

InformationsquelleAutor starfry

Ich bin mit einem get_screen_resolution Methode in einem meiner Projekte, wie das unten, das ist im Grunde eine import-Kette. Sie können ändern Sie diese nach Ihren Bedürfnissen, indem die Teile, die nicht benötigt werden und mehr bewegen dürfte ports nach oben in der Kette.

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)

Vielen Dank für das teilen dieses, aber es hätte verkürzt eine Menge durch die Verwendung einer Funktion zur Verarbeitung der if-else-Fällen

InformationsquelleAutor Martin Hansen

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)

InformationsquelleAutor cpoakes

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

meta.stackoverflow.com/questions/256359/...

InformationsquelleAutor Taghouti Tarek

In den Fall, Sie haben PyQt4 installiert ist, 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 die folgenden arbeiten:

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

InformationsquelleAutor Harsh Kumar Narula

5

Alte Frage, aber dieses fehlt.
Ich bin neu in python, also bitte sagen Sie mir, ob dies eine "schlechte" Lösung.
Diese Lösung unterstützt wird für Windows und MacOS nur, und es funktioniert nur für den Hauptbildschirm - aber das os ist nicht in der Frage genannten.

Messen Sie die Größe, indem Sie einen screenshot. Als Auflösung sollten Sie nicht ändern, dies muss nur einmal gemacht werden.
Es gibt elegantere Lösungen, wenn Sie ein gui-toolkit wie GTK, wx, ... installiert.

sehen Kissen
```
pip install Pillow
```
```
from PIL import ImageGrab

img = ImageGrab.grab()
print (img.size)
```
InformationsquelleAutor lumos0815
3

Unter Linux
Statt regexp nehmen Sie die erste Zeile, und nehmen Sie Sie heraus, die aktuelle Auflösung Werte.

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 geschah auf xrandr 1.3.5, ich weiß nicht, ob die Ausgabe ist anders in anderen Versionen, aber dies sollte einfach herauszufinden.

leider nicht sehr gut mit multimonitoring-setups. nicht-python-Fehler, aber mit diesem kann unerwartete Folgen haben...

InformationsquelleAutor Alex R

Um 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,

InformationsquelleAutor user3757097

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)

InformationsquelleAutor sirex

2

Mit pygame:
```
import pygame
pygame.init()
infos = pygame.display.Info()
screen_size = (infos.current_w, infos.current_h)
```
[1]

Jedoch, wenn Sie versuchen, Ihre Fenster, um der Größe des Bildschirms, können Sie nur wollen, zu tun:
```
pygame.display.set_mode((0,0),pygame.FULLSCREEN)
```
Ihre Anzeige auf Vollbild-Modus. [2]

Bestätigt, es funktioniert auf Windows 🙂 Was für eine schöne nicht-Windows-spezifische Methode!

InformationsquelleAutor tburrows13
1

Versuchen pyautogui:
```
import pyautogui
resolution = pyautogui.size()
print(resolution) 
```
Sie sollte wirklich fügen Sie einige Erklärung, warum dieser code sollte funktionieren - Sie können auch fügen Sie Kommentare in den code selbst - in seiner aktuellen form, Sie bietet keine Erklärung, die helfen können, den rest der community zu verstehen, was Sie getan haben, um zu lösen/beantworten die Frage. Aber das ist auch eine sehr alte Frage - mit einer Antwort akzeptiert...
Toll, es funktioniert auf Windows 🙂

InformationsquelleAutor Tyler
0

Könnten Sie PyMouse. Um den Bildschirm Größe verwenden Sie einfach die screen_size() Attribut:
```
from pymouse import PyMouse
m = PyMouse()
a = m.screen_size()
```
a zurückkehren wird, ein Tupel, (X, Y), wo X ist die horizontale position und die Y ist die vertikale position.

Link-Funktion in der Dokumentation.

InformationsquelleAutor Simon

Unter Linux, die wir verwenden können, subprocess-Modul

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

InformationsquelleAutor kamran kausar

Es ist ein wenig lästig für den retina-Bildschirm, ich nutze tkinter, um die gefälschte Größe, pilllow greifen, um wirkliche Größe :

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

InformationsquelleAutor NicolasLi

0

Wenn Sie arbeiten, auf Windows OS, die Sie verwenden können, OS-Modul, um es zu bekommen:
```
import os
cmd = 'wmic desktopmonitor get screenheight, screenwidth'
size_tuple = tuple(map(int,os.popen(cmd).read().split()[-2::]))
```
Wird es wieder ein Tupel (Y,X) wo Y ist die horizontale Größe und X ist die vertikale Größe. Dieser code funktioniert auf Python 2 und Python 3

InformationsquelleAutor Diroallu

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.