Bagaimana cara mendapatkan resolusi monitor dengan Python?

126

Apa cara termudah untuk mendapatkan resolusi monitor (sebaiknya dalam tuple)?

persegi panjang
sumber
Apakah Anda menggunakan toolkit UI tertentu? (mis. GTK, wxPython, Tkinter, dll)
detly
11
Dengan Tkintermodul, Anda dapat melakukannya dengan cara ini . Ini adalah bagian dari pustaka Python standar dan berfungsi pada sebagian besar platform Unix dan Windows.
martineau
1
Gambaran yang baik tentang berbagai teknik untuk UI umum diberikan di tautan ini
ImportanceOfBeingErnest

Jawaban:

75

Di Windows:

from win32api import GetSystemMetrics

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

Jika Anda bekerja dengan layar resolusi tinggi, pastikan interpreter python Anda adalah HIGHDPIAWARE.

Berdasarkan postingan ini .

Robus
sumber
9
Untuk solusi lengkap multiplatform, lihat jawaban
Dhruv Reshamwala
1
Saat menggunakan beberapa monitor, ini hanya akan mengembalikan ukuran layar utama.
Stevoisiak
1
Bagaimana Anda mengatur interpreter python highdpiaware? Ini akan berguna untuk dimasukkan dalam jawaban.
eric
121

Di Windows, Anda juga dapat menggunakan ctypes dengan GetSystemMetrics():

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

sehingga Anda tidak perlu menginstal paket pywin32; itu tidak membutuhkan apa pun yang tidak disertakan dengan Python itu sendiri.

Untuk pengaturan multi-monitor, Anda dapat mengambil lebar dan tinggi gabungan dari monitor virtual:

import ctypes
user32 = ctypes.windll.user32
screensize = user32.GetSystemMetrics(78), user32.GetSystemMetrics(79)
jcao219.dll
sumber
11
Catatan penting: nilai yang dikembalikan mungkin tidak benar jika penskalaan DPI digunakan (yaitu: sering kali terjadi pada tampilan 4k), Anda harus memanggil SetProcessDPIAware sebelum menginisialisasi komponen GUI (dan bukan sebelum memanggil fungsi GetSystemMetrics). Ini berlaku untuk sebagian besar jawaban di sini (GTK, dll) di platform win32.
totaam
1
Untuk beberapa monitor, Anda dapat menggunakan GetSystemMetrics (78) dan GetSystemMetrics (79)
Derek
@ Derek Apa GetSystemMetrics(78)dan GetSystemMetrics(79)kembali?
Stevoisiak
@StevenVascellaro Lebar / tinggi layar virtual, dalam piksel. msdn.microsoft.com/en-us/library/windows/desktop/…
Derek
94

Saya membuat modul PyPI karena alasan ini:

pip install screeninfo

Kode:

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

Hasil:

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

Ini mendukung lingkungan multi monitor . Tujuannya adalah menjadi lintas platform; untuk saat ini mendukung Cygwin dan X11 tetapi permintaan tarik sangat diterima.

rr-
sumber
2
Berfungsi dengan baik pada Windows tetapi Mac saya mendapatkan Kesalahan berikut: ImportError: Tidak dapat memuat X11
Chris Lucian
5
Berfungsi dengan baik di Ubuntu. Diuji di Ubuntu 16.04.
Dhruv Reshamwala
3
FYI, penskalaan DPI Windows masih berlaku. Baris ini akan memberi tahu Windows bahwa Anda menginginkan resolusi mentah dan tidak berskala: "import ctypes; user32 = ctypes.windll.user32; user32.SetProcessDPIAware ()". 1) Jawaban Anda harus di atas; kerja bagus. 2) Komentar saya khusus Windows, bukan khusus perpustakaan (yaitu screeninfo) 3) kode robek dan diuji dari KobeKomentar John di sini: stackoverflow.com/a/32541666/2616321
Jason2616321
6
Modul berguna (+1). Saya harus menginstal beberapa persyaratan (misalnya pip install cython pyobjus) sebelum saya dapat menggunakannya di OSX
George Profenza
45

Jika Anda menggunakan wxWindows, Anda dapat melakukan:

import wx

app = wx.App(False) # the wx.App object must be created first.    
print(wx.GetDisplaySize())  # returns a tuple
Ned Batchelder
sumber
Ini yang terbaik ... siapa yang tidak punya wx? :) ditambah beberapa baris, bukan sekumpulan kode di mata Anda. Sekarang ini adalah metode default saya, terima kasih.
m3nda
1
Ini harus app = wx.App(False)jika tidak, anda mendapatkan "objek wx.App harus diciptakan pertama." kesalahan. 26 suara dan tidak ada yang memeriksa? Apakah bekerja di Windows tanpa memasukkan instance wx ke variabel?
m3nda
2
Siapa yang tidak punya wx? Banyak orang?
rawa
43

Diambil langsung dari jawaban untuk posting ini: Bagaimana cara mendapatkan ukuran layar di Tkinter?

import tkinter as tk

root = tk.Tk()

screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()
pengguna2366975
sumber
8
Jika Anda memiliki layar eksternal yang diperluas ke samping layar utama, metode ini akan memberikan jumlah semua resolusi layar, bukan resolusi layar saat ini.
jadelord
Untuk langkah beberapa layar lihat jawaban saya .
norok2
29

Di Windows 8.1, saya tidak mendapatkan resolusi yang benar dari ctypes atau tk. Orang lain mengalami masalah yang sama untuk ctypes: getsystemmetrics mengembalikan ukuran layar yang salah Untuk mendapatkan resolusi penuh yang benar dari monitor DPI tinggi di windows 8.1, seseorang harus memanggil SetProcessDPIAware dan menggunakan kode berikut:

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

Detail Lengkap Di Bawah:

Saya menemukan bahwa ini karena windows melaporkan resolusi berskala. Tampaknya python secara default adalah aplikasi 'system dpi aware'. Jenis aplikasi yang mendukung DPI tercantum di sini: http://msdn.microsoft.com/en-us/library/windows/desktop/dn469266%28v=vs.85%29.aspx#dpi_and_the_desktop_scaling_factor

Pada dasarnya, daripada menampilkan konten dalam resolusi monitor penuh, yang akan membuat font menjadi kecil, konten ditingkatkan hingga font cukup besar.

Di monitor saya, saya mendapatkan:
Resolusi fisik: 2560 x 1440 (220 DPI)
Resolusi python yang dilaporkan: 1555 x 875 (158 DPI)

Per situs windows ini: http://msdn.microsoft.com/en-us/library/aa770067%28v=vs.85%29.aspx Rumus untuk resolusi efektif sistem yang dilaporkan adalah: (Report_px * current_dpi) / (96 dpi ) = physical_px

Saya bisa mendapatkan resolusi layar penuh yang benar, dan DPI saat ini dengan kode di bawah ini. Perhatikan bahwa saya memanggil SetProcessDPIAware () untuk memungkinkan program melihat resolusi sebenarnya.

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

Yang mengembalikan:

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

Saya menjalankan windows 8.1 dengan monitor berkemampuan 220 DPI. Skala tampilan saya mengatur DPI saya saat ini ke 158.

Saya akan menggunakan 158 untuk memastikan plot matplotlib saya memiliki ukuran yang tepat dengan: from pylab import rcParams rcParams ['figure.dpi'] = curr_dpi

spacether
sumber
Anda memiliki banyak informasi bagus di sini, tetapi jawabannya sendiri terkubur di tengah-tengah. Untuk membuatnya lebih mudah dibaca, dapatkah Anda menjelaskan dengan tepat apa jawabannya dan kemudian memberikan informasi latar belakang?
skrrgwasme
Saya mengedit posting saya untuk menunjukkan jawabannya di awal, lalu masuk ke detailnya. Terima kasih untuk umpan baliknya.
spacether
1
Sepertinya ada kesalahan dalam penghitungan di sini, yang mudah dikenali jika Anda menghitung ukuran diagonal dari lebar dan tinggi yang dilaporkan (dalam inci). Layar saya dengan diagonal 13,3 inci dilaporkan sebagai 15 inci. Tampaknya Tkintermenggunakan piksel yang benar, tetapi tidak mengetahui penskalaan dpi sehingga melaporkan ukuran mm yang salah.
Primer
Ini tidak berfungsi pada Windows 10, di sana SetSystemDPIAware () tampaknya tidak membuat perbedaan. Namun, memanggil ctypes.windll.shcore.SetProcessDpiAwareness (2) tampaknya berhasil.
Klamer Schutte
@Klamerte: ctypes.windll.shcore.SetProcessDpiAwareness(2)mengembalikan kesalahan OSError: [WinError 126] The specified module could not be found.
Adrian Keister
21

Dan untuk kelengkapannya, Mac OS X

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

akan memberi Anda daftar tupel yang berisi semua ukuran layar (jika ada beberapa monitor)

cobbal
sumber
15

Jika Anda menggunakan Qttoolkit secara khusus PySide, Anda dapat melakukan hal berikut:

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

Menggunakan Linux, cara paling sederhana adalah dengan menjalankan perintah bash

xrandr | grep '*'

dan mengurai outputnya menggunakan regexp.

Anda juga dapat melakukannya melalui PyGame: http://www.daniweb.com/forums/thread54881.html

Pavel Strakhov
sumber
Bagaimana Anda menggunakan pygame untuk mendapatkan resolusi layar?
Jamie Twells
11

Berikut adalah program Python kecil cepat yang akan menampilkan informasi tentang pengaturan multi-monitor Anda:

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)  

Berikut contoh keluarannya:

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)
starfry
sumber
Apakah gtk.Window()mendapatkan gdk_default_root_window? Begitukah cara Anda yakin .get_screenberisi semua monitor?
yatg
Saya bertanya karena dalam kode saya, saya mencoba mereplikasi kode Anda, saya melakukannya di jsctypes, dan terus memberi tahu saya 0 monitor: gist.github.com/yajd/55441c9c3d0711ee4a38#file-gistfile1-txt-L3
yatg
2
Sudah lama sejak saya menulis kode itu tetapi, jika saya ingat dengan benar, yang gtk.Window()dilakukan adalah membuat jendela baru (lihat di sini ). Jendela hanyalah cara yang digunakan get_screenuntuk mendapatkan informasi monitor. Ini mengembalikan layar tempat jendela aktif (atau akan, jika pernah ditampilkan). Saya kira itu tergantung pada konfigurasi X apakah "layar" itu berisi semua "monitor". Itu terjadi di sistem saya dengan Twinview.
Starfry
Terima kasih @starfry! Saya perlu menemukan solusi silang yang mendapatkan semua monitor dan dimensinya terlepas dari layarnya. Apakah Anda pernah memiliki chacne untuk mengembangkan sesuatu seperti itu? :)
yatg
Alternatif untuk versi toolkit yang lebih baru: `` python
satyagraha
9

Saya menggunakan metode get_screen_resolution di salah satu proyek saya seperti di bawah ini, yang pada dasarnya adalah rantai impor. Anda dapat memodifikasi ini sesuai dengan kebutuhan Anda dengan melepaskan bagian-bagian yang tidak diperlukan dan memindahkan lebih banyak port ke atas dalam rantai.

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
sumber
1
Terima kasih telah membagikan ini, tetapi ini bisa banyak dipersingkat dengan menggunakan fungsi untuk menangani kasus if-else
Udayraj Deshmukh
8

Pertanyaan lama tapi ini hilang. Saya baru mengenal python jadi tolong beri tahu saya jika ini adalah solusi yang "buruk". Solusi ini hanya didukung untuk Windows dan MacOS dan hanya berfungsi untuk layar utama - tetapi os tidak disebutkan dalam pertanyaan.

Ukur ukurannya dengan mengambil tangkapan layar. Karena screensize tidak boleh berubah, ini harus dilakukan hanya sekali. Ada solusi yang lebih elegan jika Anda memiliki toolkit gui seperti GTK, wx, ... terinstal.

lihat Bantal

pip install Pillow

from PIL import ImageGrab

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

Versi XWindows:

#!/usr/bin/python

import Xlib
import Xlib.display

resolution = Xlib.display.Display().screen().root.get_geometry()
print str(resolution.width) + "x" + str(resolution.height)
kue
sumber
6

Memperluas jawaban @ user2366975 , untuk mendapatkan ukuran layar saat ini dalam pengaturan multi-layar menggunakan Tkinter (kode di 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

(Seharusnya berfungsi lintas platform, hanya diuji di Linux)

norok2
sumber
5

Coba kode berikut:

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

Jika Anda menginstal PyQt4, coba kode berikut:

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

Untuk PyQt5, berikut ini akan berfungsi:

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))
Harsh Kumar Narula
sumber
5

Sebuah platform silang dan cara mudah untuk melakukannya adalah dengan menggunakan TKinter yang hadir dengan hampir semua versi python sehingga Anda tidak perlu menginstal apapun:

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

Menggunakan Linux Sebagai ganti regexp, ambil baris pertama dan hapus nilai resolusi saat ini.

Resolusi tampilan saat ini: 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

Ini dilakukan pada xrandr 1.3.5, saya tidak tahu apakah outputnya berbeda pada versi lain, tetapi ini seharusnya membuatnya mudah untuk diketahui.

Alex R
sumber
sayangnya tidak terlalu bagus dengan pengaturan multimonitor. bukan kesalahan python, tetapi menggunakan ini mungkin memiliki hasil yang tidak terduga ...
black_puppydog
2

Untuk mendapatkan bit per piksel:

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 di 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,
pengguna3757097
sumber
2

Coba pyautogui:

import pyautogui
resolution = pyautogui.size()
print(resolution) 
Tyler
sumber
Anda benar-benar harus menambahkan beberapa penjelasan tentang mengapa kode ini harus berfungsi - Anda juga dapat menambahkan komentar di kode itu sendiri - dalam bentuknya saat ini, tidak memberikan penjelasan apa pun yang dapat membantu komunitas lainnya untuk memahami apa yang Anda lakukan untuk menyelesaikannya. Aku jawab pertanyaannya. Tapi ini juga pertanyaan yang sangat lama - dengan jawaban yang diterima ...
ishmaelMakitla
2

Versi lain menggunakan 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
sumber
2

Menggunakan pygame :

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

[1]

Namun, jika Anda mencoba menyetel jendela ke ukuran layar, Anda mungkin ingin melakukan:

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

untuk mengatur tampilan Anda ke mode layar penuh. [2]

Tom Burrows
sumber
Dikonfirmasi berfungsi pada Windows :) Sungguh metode khusus non-Windows yang bagus!
Lukasz Czerwinski
1

Anda bisa menggunakan PyMouse . Untuk mendapatkan ukuran layar cukup gunakan screen_size()atribut:

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

aakan mengembalikan tupel (X, Y),, di mana Xposisi horizontal danY posisi vertikal.

Tautan ke fungsi dalam dokumentasi.

Simon
sumber
1

Jika Anda menggunakan OS Windows, Anda dapat menggunakan modul OS untuk mendapatkannya:

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

Ini akan mengembalikan tupel (Y, X) di mana Y adalah ukuran vertikal dan X adalah ukuran horizontal. Kode ini berfungsi pada Python 2 dan Python 3

Diroallu
sumber
0

Di Linux kita bisa menggunakan modul subprocess

import subprocess
cmd = ['xrandr']
cmd2 = ['grep', '*']
p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
p2 = subprocess.Popen(cmd2, stdin=p.stdout, stdout=subprocess.PIPE)
p.stdout.close()

resolution_string, junk = p2.communicate()
resolution = resolution_string.split()[0]
resolution = resolution.decode("utf-8") 
width = int(resolution.split("x")[0].strip())
heigth = int(resolution.split("x")[1].strip())
kamran kausar
sumber
0

Agak merepotkan untuk retina screen, saya menggunakan tkinter untuk mendapatkan ukuran palsu, gunakan pilllow grab untuk mendapatkan ukuran sebenarnya:

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

Untuk versi PyGtk yang lebih baru:

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

Untuk Linux, Anda dapat menggunakan ini:

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.dll
sumber
0

Skrip utilitas menggunakan pynputperpustakaan. Posting di sini untuk 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.dll
sumber