Pythonでモニター解像度を取得するにはどうすればよいですか?


125

(できればタプルで)モニターの解像度を取得する最も簡単な方法は何ですか?


特定のUIツールキットを使用していますか?(例:GTK、wxPython、Tkinterなど)
確実に2010年

11
ではTkinterモジュール、あなたはそれを行うことができますこの方法で。標準のPythonライブラリの一部であり、ほとんどのUnixおよびWindowsプラットフォームで動作します。
martineau

1
一般的なUIのさまざまな手法の概要については、このリンク
ImportanceOfBeingErnest

回答:


74

Windowsの場合:

from win32api import GetSystemMetrics

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

高解像度画面で作業している場合は、PythonインタープリターがHIGHDPIAWAREであることを確認してください。

この投稿に基づく。


9
マルチプラットフォームの完全なソリューションについては、この回答を
Dhruv Reshamwala

1
複数のモニターを使用している場合、これはプライマリディスプレイのサイズのみを返します。
Stevoisiak

1
Pythonインタープリターをどのように設定しますhighdpiawareか?これは回答に含めると便利です。
エリック

120

Windowsでは、ctypesをGetSystemMetrics()次のように使用することもできます。

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

pywin32パッケージをインストールする必要がないように。Python自体に付属していないものは必要ありません。

マルチモニター設定の場合、仮想モニターの幅と高さを組み合わせて取得できます。

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

11
重要な注意:DPIスケーリングが使用されている場合(つまり、4kディスプレイでよくあることです)、返される値は正しくない場合があります。GetComponentMetrics関数を呼び出す前ではなく、GUIコンポーネントを初期化する前にSetProcessDPIAwareを呼び出す必要があります。これは、win32プラットフォームでのほとんどの回答(GTKなど)に当てはまります。
totaam 2014

1
マルチモニターの場合、GetSystemMetrics(78)とGetSystemMetrics(79)を使用できます
Derek

@Derek何GetSystemMetrics(78)GetSystemMetrics(79)返しますか?
Stevoisiak 2018

@StevenVascellaro仮想画面の幅/高さ(ピクセル単位)。msdn.microsoft.com/en-us/library/windows/desktop/...
デレク・

93

この理由でPyPIモジュールを作成しました:

pip install screeninfo

コード:

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

結果:

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

マルチモニター環境に対応しています。その目標はクロスプラットフォームになることです。現時点では、CygwinとX11をサポートしていますが、プルリクエストは大歓迎です。


2
Windowsでうまく動作しますが、Macでは次のエラーが発生します:ImportError:X11をロードできませんでした
Chris Lucian

5
Ubuntuでうまく動作します。Ubuntu 16.04でテスト済み。
Dhruv Reshamwala 2016

3
参考までに、Windows DPIスケーリングは引き続き適用されます。この行は、Windowsに生のスケーリングされていない解像度が必要であることを通知します: "import ctypes; user32 = ctypes.windll.user32; user32.SetProcessDPIAware()"。1)あなたの答えはトップでなければなりません。よくやった。2)私のコメントは、ライブラリ固有ではなく(つまり、screeninfo)、Windows固有です。3)ここでKobeJohnのコメントからリッピングおよびテストされたコード: stackoverflow.com/a/32541666/2616321
Jason2616321

6
便利なモジュール(+1)。pip install cython pyobjusOSXで使用する前に、いくつかの要件(例
:)

45

wxWindowsを使用している場合は、次のようにするだけです。

import wx

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

これは最高です... wxを持っていない人は?:)加えて、数行のコードの代わりに一連のコードを目にします。これが私のデフォルトの方法になりました。ありがとうございます。
m3nda 2015年

1
これがなければなりませんapp = wx.App(False)それ以外の場合は、あなたが得る「wx.Appオブジェクトが最初に作成する必要があります。」エラー。26票、誰もチェックしなかった?wxインスタンスを変数に割り当てなくてもWindowsで動作しますか?
m3nda 2015年

2
誰がwxを持っていないのですか?多くの人?
沼地

43

この投稿への回答から直接引用:Tkinterで画面サイズを取得する方法?

import tkinter as tk

root = tk.Tk()

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

8
プライマリディスプレイの横に拡張された外部ディスプレイがある場合、この方法では、現在のディスプレイ解像度ではなく、すべてのディスプレイ解像度の合計が得られます。
jadelord

複数画面のステップについては、私の答えを参照しください。
norok2

29

Windows 8.1では、ctypesまたはtkのいずれからも適切な解像度が得られません。他の人々がctypesに対して同じ問題を抱えていますgetsystemmetricsが誤った画面サイズ返します Windows 8.1で高DPIモニターの正しい完全解像度を取得するには、SetProcessDPIAwareを呼び出して、次のコードを使用する必要があります。

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

以下の完全な詳細:

これは、Windowsがスケーリングされた解像度を報告しているためであることがわかりました。Pythonはデフォルトで「システムdpi対応」アプリケーションのようです。DPI対応アプリケーションのタイプは次のとおりです。 。http //msdn.microsoft.com/en-us/library/windows/desktop/dn469266%28v=vs.85%29.aspx#dpi_and_the_desktop_scaling_factor

基本的に、コンテンツをモニタのフル解像度で表示してフォントを小さくするのではなく、フォントが十分に大きくなるまでコンテンツを拡大します。

私のモニターでは:
物理的な解像度:2560 x 1440(220 DPI)
報告されたpythonの解像度:1555 x 875(158 DPI)

このWindowsサイトごと:http : //msdn.microsoft.com/en-us/library/aa770067%28v=vs.85%29.aspx 報告されたシステムの有効解像度の式は次のとおりです:(reported_px * current_dpi)/(96 dpi )= physical_px

以下のコードで正しい全画面解像度と現在のDPIを取得できます。プログラムが実際の解像度を確認できるように、SetProcessDPIAware()を呼び出すことに注意してください。

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

返されたもの:

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

220 DPI対応のモニターでWindows 8.1を実行しています。ディスプレイのスケーリングにより、現在のDPIが158に設定されます。

私は158を使用して、私のmatplotlibプロットが正しいサイズであることを確認します。from pylab import rcParams rcParams ['figure.dpi'] = curr_dpi


ここには多くの良い情報がありますが、答え自体は真ん中に埋もれています。あなたは答えが何であるかを正確に明らかにすることができ、それが少し読みやすくするために、その後、背景情報を提供?
skrrgwasme 2014年

最初に回答を表示するように投稿を編集してから、詳細に進みました。フィードバックをお寄せいただきありがとうございます。
spacether 2014年

1
ここでの計算に欠陥があるように見えます。これは、報告された幅と高さ(インチ単位)から対角サイズを計算することで簡単に見つけることができます。対角13.3インチの画面が15インチと報告されました。Tkinter正しいピクセルを使用しているようですが、dpiスケーリングを認識していないため、誤ったmmサイズが報告されます。
プライマー2015

これはWindows 10では機能しませんが、SetSystemDPIAware()は違いをもたらさないようです。ただし、代わりにctypes.windll.shcore.SetProcessDpiAwareness(2)を呼び出すとうまくいくようです。
Klamer Schutte 2017

@KlamerSchutte:ctypes.windll.shcore.SetProcessDpiAwareness(2)エラーを返しますOSError: [WinError 126] The specified module could not be found
エイドリアンキースター

21

そして完全性のために、Mac OS X

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

すべての画面サイズを含むタプルのリストが表示されます(複数のモニターが存在する場合)


15

Qt特にツールキットを使用している場合PySideは、次のことができます。

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

Linuxを使用する場合、最も簡単な方法はbashコマンドを実行することです

xrandr | grep '*'

そして、正規表現を使用してその出力を解析します。

また、PyGameを介してそれを行うことができます:http ://www.daniweb.com/forums/thread54881.html


どのようにしてpygameを使用して画面解像度を取得しますか?
Jamie Twells、2014年

11

マルチモニターのセットアップに関する情報を表示する簡単なPythonプログラムを次に示します。

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)  

その出力の例を次に示します。

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)

ないgtk.Window()取得gdk_default_root_window.get_screenすべてのモニターが含まれているという確信はありますか?
yatg 2015

私は私のコードでImはあなたのコードを複製しようとしているので、私はjsctypesでそれをやって尋ねると、それは私に0モニターを伝える保つ:gist.github.com/yajd/55441c9c3d0711ee4a38#file-gistfile1-txt-L3
yatg

2
そのコードを書いてからしばらく経ちますが、正しく思い出せばgtk.Window()、新しいウィンドウが作成されます(ここを参照)。ウィンドウget_screenは、モニター情報を取得するための単なる方法です。ウィンドウが表示されている画面を返します(表示された場合は表示されます)。その「画面」にすべての「モニター」が含まれているかどうかは、X構成に依存すると思います。Twinviewを使用している私のシステムでは問題ありません。
starfry 2015

ありがとう@starfry!画面に関係なく、すべてのモニターとその寸法を取得するクロスソリューションを見つける必要がありました。あなたはそのようなものを開発するために何かおかしなことがありますか?:)
yatg 2015

以降のツールキットバージョンの代替: `` `python
satyagraha '17

9

以下のようなプロジェクトの1つで、基本的にインポートチェーンであるget_screen_resolutionメソッドを使用しています。不要な部分を削除して必要に応じてこれを変更し、可能性の高いポートをチェーン内で上に移動できます。

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
これを共有していただきありがとうございます
。if

8

古い質問ですが、これはありません。私はPythonが初めてなので、これが「悪い」解決策であるかどうか教えてください。このソリューションは、WindowsとMacOSでのみサポートされており、メイン画面でのみ機能しますが、OSは質問に含まれていません。

スクリーンショットを撮ってサイズを測定します。画面サイズは変更すべきではないので、これは一度だけ実行する必要があります。GTK、wxなどのGUIツールキットがインストールされている場合は、よりエレガントなソリューションがあります。

枕を見る

pip install Pillow

from PIL import ImageGrab

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

6

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)

6

@ user2366975の答えを拡張して、Tkinter(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

(クロスプラットフォームで動作し、Linuxでのみテスト済み)



5

PyQt4がインストールされている場合は、次のコードを試してください。

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の場合、以下が機能します。

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

クロスプラットフォームでこれを行う簡単な方法は、ほとんどすべてのpythonバージョンに付属しているTKinterを使用することです。そのため、何もインストールする必要はありません。

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

3

regexpの代わりにLinuxを使用して、最初の行を取得し、現在の解像度の値を取り出します。

ディスプレイの現在の解像度: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

これはxrandr 1.3.5で行われました。他のバージョンで出力が異なるかどうかはわかりませんが、これで簡単に理解できるはずです。


残念ながら、マルチモニターのセットアップではあまり良くありません。Pythonのせいではありませんが、これを使用すると予期しない結果になる可能性があります...
black_puppydog

2

ピクセルあたりのビット数を取得するには:

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のパラメータ:

#/// 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を試してください:

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

このコードが機能する理由について説明を追加する必要があります。コード自体にコメントを追加することもできます。現在の形式では、コミュニティの他のメンバーが解決策を理解するのに役立つ説明は提供されていません。 /質問に答えて。しかし、これも非常に古い質問であり、回答は承認されています...
ishmaelMakitla

2

を使用する別のバージョン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の使用:

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

[1]

ただし、ウィンドウを画面のサイズに設定しようとしている場合は、次のようにします。

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

ディスプレイを全画面モードに設定します。[2]


Windowsで動作することを確認しました:)非Windows固有の素晴らしい方法です。
Lukasz Czerwinski


1

Windows OSで作業している場合は、OSモジュールを使用して取得できます。

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

それはタプル返され(Y、X)Yが垂直サイズであり、Xは水平サイズです。このコードはPython 2およびPython 3で動作します


0

Linuxでは、サブプロセスモジュールを使用できます。

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

網膜の画面では少し面倒です。私はtkinterを使用して偽のサイズを取得し、枕カバーを使用して実際のサイズを取得します。

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の以降のバージョンの場合:

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の場合、これを使用できます。

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

pynputライブラリを使用したユーティリティスクリプト。参考のためにここに投稿:

 
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)
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.