it-swarm.com.de

Wie erhalte ich eine Monitorauflösung in Python?

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

79
rectangletangle

Unter Windows:

from win32api import GetSystemMetrics

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

Wenn Sie mit einem Bildschirm mit hoher Auflösung arbeiten, stellen Sie sicher, dass Ihr Python-Interpreter HIGHDPIAWARE ist.

Basierend auf diesem post.

48
Robus

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

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

damit Sie das pywin32-Paket nicht installieren müssen.

Bei Multimonitor-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)
91
jcao219

Ich habe ein PyPI-Modul aus diesem Grund 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)

Unterstützt Multi-Monitor-Umgebungen. Ihr Ziel ist es, plattformübergreifend zu sein. Zur Zeit werden Cygwin und X11 unterstützt, aber Pull-Anfragen sind absolut willkommen.

55
rr-

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
41
Ned Batchelder

Direkt aus einer Antwort auf diesen Beitrag entnommen: Wie bekomme ich die Bildschirmgröße in Tkinter?

import tkinter as tk

root = tk.Tk()

screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()
29
user2366975

Unter Windows 8.1 bekomme ich weder von ctypes noch von tk ..__ die richtige Auflösung. Andere Leute haben das gleiche Problem für ctypes: getsystemmetrics liefert falsche Bildschirmgröße Um die korrekte volle Auflösung eines Hochs zu erhalten DPI-Monitor unter Windows 8.1 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. Arten von DPI-fähigen Anwendungen sind hier aufgelistet: http://msdn.Microsoft.com/de-de/library/windows/desktop/dn469266%28v=vs.85%29.aspx#dpi_and_the_desktop_scaling_factor

Grundsätzlich wird der Inhalt nicht mit der vollen Bildschirmauflösung angezeigt, wodurch die Schriftarten winzig werden, sondern der Inhalt wird so lange vergrößert, bis die Schriftarten groß genug sind.

Auf meinem Monitor bekomme ich:
Physikalische Auflösung: 2560 x 1440 (220 DPI)
Gemeldete Pythonauflösung: 1555 x 875 (158 DPI)

Pro Windows-Site: http://msdn.Microsoft.com/de-de/library/aa770067%28v=vs.85%29.aspx .__ Die Formel für die gemeldete effektive Systemauflösung lautet: (gemeldete_px * aktuelle_dpi)/(96 dpi) = physische_px

Ich kann die korrekte Vollbildauflösung und den aktuellen DPI-Wert mit dem folgenden Code abrufen. __ 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))    

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 verwende Windows 8.1 mit einem 220 DPI-fähigen Monitor .... Meine Skalierung der Anzeige setzt meine aktuelle DPI auf 158.

Ich verwende 158, um sicherzustellen, dass meine Matplotlib-Plots die richtige Größe haben, mit: Aus pylab import rcParams RcParams ['figure.dpi'] = curr_dpi

19
spacether

Und zur Vollständigkeit Mac OS X

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

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

15
cobbal

Wenn Sie das Qt-Toolkit speziell PySide verwenden, 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()
13
MadeOfAir

Unter Linux ist der einfachste Weg, den Bash-Befehl auszuführen

xrandr | grep '*'

und parsen seine Ausgabe mit Regexp. 

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

12
Pavel Strakhov

Hier ist ein kurzes kleines Python-Programm, das Informationen zu Ihrem Multimonitor-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 seine 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)
12
starfry

Ich verwende in einem meiner Projekte eine get_screen_resolution-Methode wie das unten stehende, das im Wesentlichen eine Importkette ist. Sie können dies je nach Ihren Bedürfnissen ändern, indem Sie die nicht benötigten Teile entfernen und wahrscheinlichere Ports in der Kette 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)
8
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)
6
cpoakes

Alte Frage, aber das fehlt. Ich bin neu in Python, also sagen Sie mir bitte, ob dies eine "schlechte" Lösung ist . Diese Lösung wird nur für Windows und Mac unterstützt und funktioniert nur für den Hauptbildschirm die Frage. 

Messen Sie die Größe mit einem Screenshot. 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. 

sehen Kissen

pip install Pillow

from PIL import ImageGrab

img = ImageGrab.grab
print (img.size)
5
lumos0815

Falls 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 wird folgendes funktionieren:

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))
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
5
Taghouti Tarek

Verwenden Sie Linux Statt regexp, 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 bei anderen Versionen anders ist, aber dies sollte es leicht machen, dies herauszufinden.

3
Alex R

Eine andere Version, die xrandr verwendet:

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

Erweitern Sie die Antwort von @ user2366975 , um die aktuelle Bildschirmgröße in einem Multiscreen-Setup mit Tkinter abzurufen (Code 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

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

2
norok2

pygame verwenden:

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 vielleicht Folgendes tun:

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

um den Vollbildmodus Ihrer Anzeige einzustellen. [2]

2
tburrows13

Um Bits pro Pixel zu erhalten:

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

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 zurückgegeben (Y, X) wobei Y die vertikale Größe und X die horizontale Größe ist. Dieser Code funktioniert mit Python 2 und Python 3

1
Diroallu

Versuchen Sie pyautogui: 

import pyautogui
resolution = pyautogui.size()
print(resolution) 
1
Tyler

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

Es ist ein wenig lästig für den 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
0
NicolasLi

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

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

a gibt einen Tupel zurück, (X, Y), wobei X die horizontale Position und Y die vertikale Position ist.

Link zur Funktion in der Dokumentation.

0
Simon

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

Unter Linux können wir ein Subprozess-Modul 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())
0
kamran kausar