Python'da nasıl monitör çözünürlüğü elde ederim?


126

Monitör çözünürlüğünü elde etmenin en basit yolu nedir (tercihen bir demet halinde)?


Belirli bir UI araç takımı kullanıyor musunuz? (örn. GTK, wxPython, Tkinter, vb.)
detly

11
TkinterModül ile bu şekilde yapabilirsiniz . Standart Python kitaplığının bir parçasıdır ve çoğu Unix ve Windows platformunda çalışır.
martineau

1
Ortak kullanıcı arayüzleri için farklı tekniklere iyi bir genel bakış bu bağlantıda
ImportanceOfBeingErnest

Yanıtlar:


75

Windows'ta:

from win32api import GetSystemMetrics

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

Yüksek çözünürlüklü ekranla çalışıyorsanız, python yorumlayıcınızın HIGHDPIAWARE olduğundan emin olun.

Dayanarak bu yazı.



1
Birden fazla monitör kullanıldığında, bu yalnızca birincil ekranın boyutunu döndürür.
Stevoisiak

1
Python yorumlayıcısını nasıl olacak şekilde ayarlarsınız highdpiaware? Bu, yanıta dahil etmek faydalı olacaktır.
eric

121

Windows'ta ctype'ları şunlarla da kullanabilirsiniz GetSystemMetrics():

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

böylece pywin32 paketini kurmanıza gerek kalmaz; Python ile gelmeyen hiçbir şeye ihtiyacı yoktur.

Çoklu monitör kurulumları için, sanal monitörün birleşik genişliğini ve yüksekliğini geri alabilirsiniz:

import ctypes
user32 = ctypes.windll.user32
screensize = user32.GetSystemMetrics(78), user32.GetSystemMetrics(79)

11
Önemli not: DPI ölçeklendirme kullanılıyorsa döndürülen değerler yanlış olabilir (yani: genellikle 4k ekranlardaki durum), GUI bileşenlerini başlatmadan önce SetProcessDPIAware'i çağırmanız gerekir (GetSystemMetrics işlevini çağırmadan önce değil). Bu, win32 platformundaki yanıtların çoğu (GTK vb.) İçin geçerlidir.
totaam

1
Birden fazla monitör için GetSystemMetrics (78) ve GetSystemMetrics (79)
Derek

@Derek ne yapar GetSystemMetrics(78)ve GetSystemMetrics(79)geri döner?
Stevoisiak

@StevenVascellaro Sanal ekranın piksel cinsinden genişliği / yüksekliği. msdn.microsoft.com/en-us/library/windows/desktop/…
Derek

94

Bu nedenle bir PyPI modülü oluşturdum :

pip install screeninfo

Kod:

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

Sonuç:

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

Çoklu monitör ortamlarını destekler . Amacı, çapraz platform olmaktır; şimdilik Cygwin ve X11'i destekliyor ancak çekme istekleri kesinlikle kabul ediliyor.


2
Windows ama Mac'te harika çalışıyor Aşağıdaki Hatayı alıyorum: ImportError: X11 yüklenemedi
Chris Lucian

5
Ubuntu'da harika çalışıyor. Ubuntu 16.04'te test edilmiştir.
Semih Reshamwala

3
Bilginize, Windows DPI ölçeklendirmesi hala geçerlidir. Bu satır, Windows'a ham, ölçeklenmemiş çözünürlüğü istediğinizi söyleyecektir: "import ctypes; user32 = ctypes.windll.user32; user32.SetProcessDPIAware ()". 1) Cevabınız en üstte olmalıdır; aferin. 2) Yorumum Windows'a özel, kitaplığa özgü değil (ör. Screeninfo) 3) kod, KobeJohn'un buradaki yorumundan kopyalanmış ve test edilmiştir: stackoverflow.com/a/32541666/2616321
Jason2616321

6
Kullanışlı modül (+1). pip install cython pyobjusOSX'te kullanmadan önce birkaç gereksinim (örneğin )
yüklemem gerekiyordu

45

WxWindows kullanıyorsanız, şunları yapabilirsiniz:

import wx

app = wx.App(False) # the wx.App object must be created first.    
print(wx.GetDisplaySize())  # returns a tuple

Bu en iyisi ... kimin wx'i yok? :) artı birkaç satır yerine bir sürü kod gözünüze. Bu artık benim varsayılan yöntemim, teşekkür ederim.
m3nda

1
Bu olmalı app = wx.App(False)aksi takdirde olsun "wx.App nesne ilk oluşturulmalıdır." hata. 26 oy ve kimse kontrol etmedi mi? Windows'ta wx örneğini bir değişkene atamadan çalışıyor mu?
m3nda

2
Kimlerde wx yok? Birçok insan?
marsh


30

Windows 8.1'de, ctypes veya tk'den doğru çözünürlüğü alamıyorum. Başkaları da ctypes için aynı sorunu yaşıyor : getystemmetrics yanlış ekran boyutu döndürüyor Windows 8.1'de yüksek DPI monitörün doğru tam çözünürlüğünü elde etmek için SetProcessDPIAware'i çağırmalı ve aşağıdaki kodu kullanmalısınız:

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

Aşağıda Tam Ayrıntılar:

Bunun pencerelerin ölçeklenmiş bir çözünürlük bildirmesinden kaynaklandığını öğrendim. Python'un varsayılan olarak bir 'sistem dpi duyarlı' uygulaması olduğu görülmektedir. DPI uyumlu uygulama türleri burada listelenmiştir: http://msdn.microsoft.com/en-us/library/windows/desktop/dn469266%28v=vs.85%29.aspx#dpi_and_the_desktop_scaling_factor

Temel olarak, yazı tiplerini küçültecek şekilde içeriği tam monitör çözünürlüğünde görüntülemek yerine, yazı tipleri yeterince büyük olana kadar içerik ölçeklenir.

Monitörümde şunu elde ediyorum:
Fiziksel çözünürlük: 2560 x 1440 (220 DPI)
Bildirilen python çözünürlüğü: 1555 x 875 (158 DPI)

Bu Windows sitesine göre: http://msdn.microsoft.com/en-us/library/aa770067%28v=vs.85%29.aspx Rapor edilen etkin sistem çözünürlüğü için formül: (report_px * current_dpi) / (96 dpi ) = Physical_px

Aşağıdaki kodla doğru tam ekran çözünürlüğünü ve güncel DPI değerini alabiliyorum. Programın gerçek çözünürlüğü görmesine izin vermek için SetProcessDPIAware () 'i çağırdığımı unutmayın.

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

Hangi geri döndü:

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

Windows 8.1'i 220 DPI uyumlu bir monitörle çalıştırıyorum. Ekran ölçeklemem mevcut DPI'mı 158'e ayarlıyor.

Matplotlib grafiklerimin doğru boyutta olduğundan emin olmak için 158'i kullanacağım: pylab'dan rcParams rcParams ['figure.dpi'] = curr_dpi


Burada birçok iyi bilginiz var, ancak cevabın kendisi ortada gömülü. Okumayı biraz kolaylaştırmak için, cevabın tam olarak ne olduğunu açıklayabilir ve ardından arka plan bilgilerini sağlayabilir misiniz?
skrrgwasme

Başta cevabı göstermek için gönderimi düzenledim, sonra ayrıntılara girdim. Geri dönüşünüz için teşekkür ederiz.
spacether

1
Görünüşe göre buradaki hesaplamalarda bir kusur var, bunu tespit etmek kolaydır, rapor edilen genişlik ve yükseklikten (inç cinsinden) çapraz bir boyut hesaplarsınız. 13,3 inç diyagonal ekranım 15 inç olarak bildirildi. Görünüşe Tkintergöre doğru pikseller kullanıyor, ancak dpi ölçeklemesinin farkında değil, bu nedenle yanlış mm boyutları bildiriyor.
Primer

Bu, Windows 10'da çalışmıyor, orada SetSystemDPIAware () bir fark yaratmıyor gibi görünüyor. Ancak, bunun yerine ctypes.windll.shcore.SetProcessDpiAwareness (2) 'yi çağırmak hile yapıyor gibi görünüyor.
Klamer Schutte

@KlamerSchutte: ctypes.windll.shcore.SetProcessDpiAwareness(2)hata döndürür OSError: [WinError 126] The specified module could not be found.
Adrian Keister

21

Ve eksiksizlik için Mac OS X

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

size tüm ekran boyutlarını içeren bir tuple listesi verecektir (birden fazla monitör varsa)


15

QtAraç setini özel olarak kullanıyorsanız PySide, aşağıdakileri yapabilirsiniz:

from PySide import QtGui
import sys

app = QtGui.QApplication(sys.argv)
screen_rect = app.desktop().screenGeometry()
width, height = screen_rect.width(), screen_rect.height()


11

İşte çoklu monitör kurulumunuzla ilgili bilgileri gösterecek küçük bir Python programı:

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)  

İşte çıktısının bir örneği:

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)

Does gtk.Window()olsun gdk_default_root_window? .get_screenTüm monitörleri içerdiğinden emin misin?
yatg

Soruyorum çünkü kodumda kodunuzu kopyalamaya çalışıyorum, bunu jsctype'larda yapıyorum ve bana 0 monitör söylüyor: gist.github.com/yajd/55441c9c3d0711ee4a38#file-gistfile1-txt-L3
yatg

2
Bu kodu yazmayalı epey oldu, ancak doğru hatırlıyorsam, gtk.Window()yeni bir pencere yaratmaktır ( buraya bakın ). Pencere get_screen, monitör bilgilerini almanın bir yolu . Pencerenin açık olduğu ekranı döndürür (veya daha önce gösterilmiş olsaydı olurdu). Sanırım bu "ekranın" tüm "monitörleri" içerip içermemesi X konfigürasyonuna bağlı. Twinview ile sistemimde çalışıyor.
yıldız kızartması

Teşekkürler @starfry! Ekranlardan bağımsız olarak tüm monitörleri ve boyutlarını alan bir çapraz çözüm bulmam gerekiyordu. Böyle bir şey geliştirmek için herhangi bir şakanız oldu mu? :)
yatg

Daha sonraki araç seti sürümleri için alternatif: `` `` python
satyagraha

9

Temelde bir ithalat zinciri olan aşağıdaki gibi projelerimden birinde get_screen_resolution yöntemi kullanıyorum. Bunu ihtiyaçlarınıza göre, ihtiyaç duyulmayan parçaları kaldırarak ve zincirde daha olası bağlantı noktalarını yukarı doğru hareket ettirerek değiştirebilirsiniz.

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)

1
Bunu paylaştığınız için teşekkürler, ancak aksi takdirde durumların üstesinden gelmek için bir işlev kullanılarak çok kısaltılmış olabilirdi
Udayraj Deshmukh

8

Eski soru ama bu eksik. Python'da yeniyim, bu yüzden lütfen bana bunun "kötü" bir çözüm olup olmadığını söyleyin. Bu çözüm yalnızca Windows ve MacOS için desteklenir ve yalnızca ana ekran için çalışır - ancak soruda işletim sisteminden bahsedilmemiştir.

Bir ekran görüntüsü alarak boyutu ölçün. Ekran boyutunun değişmemesi gerektiğinden, bunun yalnızca bir kez yapılması gerekir. GTK, wx, ... gibi bir gui araç setiniz varsa daha zarif çözümler vardır.

bkz Yastık

pip install Pillow

from PIL import ImageGrab

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

6

XWindows sürümü:

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

Tkinter (Python 2 / 3'te kod) kullanarak çoklu ekran kurulumunda mevcut ekran boyutunu elde etmek için @ user2366975'in cevabını genişletmek :

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

(Çapraz platformda çalışmalı, yalnızca Linux'ta test edilmelidir)



5

PyQt4'ün kurulu olması durumunda, aşağıdaki kodu deneyin:

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

PyQt5 için aşağıdakiler çalışacaktır:

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

Çapraz platform ve bunu yapmanın kolay yolu, neredeyse tüm python sürümleriyle birlikte gelen TKinter'ı kullanmaktır, böylece hiçbir şey yüklemenize gerek kalmaz:

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

3

Linux Kullanmak Regexp yerine ilk satırı alın ve mevcut çözünürlük değerlerini çıkarın.

Mevcut ekran çözünürlüğü: 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

Bu xrandr 1.3.5'te yapıldı, çıktının diğer sürümlerde farklı olup olmadığını bilmiyorum, ancak bu anlaşılmasını kolaylaştıracak.


maalesef çoklu monitör kurulumlarında pek iyi değil.
python'un

2

Piksel başına bit almak için:

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

gdi32'deki parametreler:

#/// 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

Pyautogui'yi deneyin:

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

Bu kodun neden çalışması gerektiğine dair gerçekten bir açıklama eklemelisiniz - kodun kendisine de yorum ekleyebilirsiniz - mevcut haliyle, topluluğun geri kalanının çözmek için ne yaptığınızı anlamasına yardımcı olabilecek herhangi bir açıklama sağlamaz. / soruyu cevapla. Ama bu aynı zamanda çok eski bir soru - kabul edilmiş bir cevabı var ...
ishmaelMakitla

2

Kullanan başka bir sürüm 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)

2

Pygame kullanarak :

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

[1]

Ancak, pencerenizi ekranın boyutuna ayarlamaya çalışıyorsanız, şunları yapmak isteyebilirsiniz:

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

Ekranınızı tam ekran moduna ayarlamak için. [2]


Windows'ta çalıştığı doğrulandı :) Windows'a özgü olmayan ne güzel bir yöntem!
Lukasz Czerwinski

1

PyMouse'u kullanabilirsiniz . Ekran boyutunu elde etmek için şu screen_size()özelliği kullanın :

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

abir demet dönecek (X, Y), burada Xyatay pozisyon ve Ydikey pozisyondur.

Belgelerde işleve bağlantı.


1

Windows işletim sistemi üzerinde çalışıyorsanız, bunu elde etmek için işletim sistemi modülünü kullanabilirsiniz:

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

Y'nin dikey boyut ve X'in yatay boyut olduğu bir demet (Y, X) döndürecektir . Bu kod Python 2 ve Python 3 üzerinde çalışır


0

Linux'ta alt işlem modülünü kullanabiliriz

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

Retina ekranı için biraz zahmetli, sahte boyutu elde etmek için tkinter kullanıyorum, gerçek boyutu elde etmek için pilllow kepçe kullanıyorum:

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

PyGtk'in sonraki sürümleri için:

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

Linux için şunu kullanabilirsiniz:

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)

0

pynputKitaplığı kullanan yardımcı program komut dosyası . Ref için burada yayınlanıyor:

 
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)
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.