Como obtenho resolução de monitor em Python?

125

Qual é a maneira mais simples de obter a resolução do monitor (de preferência em uma tupla)?

rectangletangle
fonte
Você está usando um kit de ferramentas de interface do usuário específico? (por exemplo, GTK, wxPython, Tkinter, etc)
detly 28/06
11
Com o Tkintermódulo, você pode fazer desta maneira . Faz parte da biblioteca padrão do Python e funciona na maioria das plataformas Unix e Windows.
27510 martineau
1
Uma boa visão geral sobre diferentes técnicas para UIs comuns é dado em neste link
ImportanceOfBeingErnest

Respostas:

74

No Windows:

from win32api import GetSystemMetrics

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

Se você estiver trabalhando com uma tela de alta resolução, verifique se o seu interpretador python é HIGHDPIAWARE.

Com base neste post.

Robus
fonte
9
Para solução completa multiplataforma, consulte esta resposta
Dhruv Reshamwala
1
Ao usar vários monitores, isso retornará apenas o tamanho da tela principal.
Stevoisiak 31/07
1
Como você define o intérprete python highdpiaware? Isso seria útil para incluir na resposta.
eric
120

No Windows, você também pode usar ctypes com GetSystemMetrics():

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

para que você não precise instalar o pacote pywin32; não precisa de nada que não seja fornecido com o próprio Python.

Para configurações de vários monitores, você pode recuperar a largura e a altura combinadas do monitor virtual:

import ctypes
user32 = ctypes.windll.user32
screensize = user32.GetSystemMetrics(78), user32.GetSystemMetrics(79)
jcao219
fonte
11
Nota importante: os valores retornados podem estar incorretos se a escala de DPI for usada (ou seja, geralmente o caso em 4k é exibido), você deve chamar SetProcessDPIAware antes de inicializar os componentes da GUI (e não antes de chamar a função GetSystemMetrics). Isso é verdade para a maioria das respostas aqui (GTK, etc) na plataforma win32.
totaam 29/09/14
1
Para vários monitores, você pode usar GetSystemMetrics (78) e GetSystemMetrics (79)
Derek
@Derek O que faz GetSystemMetrics(78)e GetSystemMetrics(79)retorna?
Stevoisiak
@StevenVascellaro A largura / altura da tela virtual, em pixels. msdn.microsoft.com/en-us/library/windows/desktop/…
Derek
93

Eu criei um módulo PyPI por esse motivo:

pip install screeninfo

O código:

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

Resultado:

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

Ele suporta ambientes com vários monitores . Seu objetivo é ser multiplataforma; por enquanto, suporta Cygwin e X11, mas solicitações pull são totalmente bem-vindas.

rr-
fonte
2
Funciona muito bem em Windows, mas Mac recebo o seguinte erro: ImportError: não foi possível carregar o X11
Chris Lucian
5
Funciona muito bem no Ubuntu. Testado no Ubuntu 16.04.
Dhruv Reshamwala
3
FYI, a escala de DPI do Windows ainda se aplica. Essa linha informará ao Windows que você deseja a resolução bruta e sem escala: "import ctypes; user32 = ctypes.windll.user32; user32.SetProcessDPIAware ()". 1) Sua resposta deve ser superior; bom trabalho. 2) Meu comentário é específico do Windows-, não biblioteca específica (ou seja screeninfo) 3) Código rasgado e testado de comentário de KobeJohn aqui: stackoverflow.com/a/32541666/2616321
Jason2616321
6
Módulo prático (+1). Eu tive que instalar um par de requisitos (por exemplo pip install cython pyobjus) antes que eu pudesse usá-lo em OSX embora
George Profenza
45

Se você estiver usando o wxWindows, poderá simplesmente:

import wx

app = wx.App(False) # the wx.App object must be created first.    
print(wx.GetDisplaySize())  # returns a tuple
Ned Batchelder
fonte
Este é o melhor ... quem não tem wx? :) mais algumas linhas em vez de um monte de código em seus olhos. Agora esse é o meu método padrão, obrigado.
M3nda 26/10/2015
1
Este deve ser app = wx.App(False)de outra forma de obter o "objeto wx.App deve ser criado em primeiro lugar." erro. 26 votos e ninguém verificou? Funciona no Windows sem atribuir a instância wx a uma variável?
M3nda 26/10/2015
2
Quem não tem wx? Muitas pessoas?
marsh
43

Retirado diretamente de uma resposta a este post: Como obter o tamanho da tela no Tkinter?

import tkinter as tk

root = tk.Tk()

screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()
user2366975
fonte
8
Se você tiver telas externas estendidas para além da tela principal, esse método forneceria a soma de todas as resoluções de tela, não a resolução atual.
jadelord
Para uma etapa de tela múltipla, veja minha resposta .
Norok2 6/07/19
29

No Windows 8.1, não estou obtendo a resolução correta de ctypes ou tk. Outras pessoas estão tendo o mesmo problema para ctypes: getsystemmetrics retorna tamanho de tela errado Para obter a resolução completa correta de um monitor de alto DPI no Windows 8.1, é necessário chamar SetProcessDPIAware e usar o seguinte código:

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

Detalhes completos abaixo:

Eu descobri que isso ocorre porque o Windows está relatando uma resolução em escala. Parece que o python é, por padrão, um aplicativo 'sistema dpi consciente'. Os tipos de aplicativos compatíveis com DPI estão listados aqui: http://msdn.microsoft.com/en-us/library/windows/desktop/dn469266%28v=vs.85%29.aspx#dpi_and_the_desktop_scaling_factor

Basicamente, em vez de exibir o conteúdo com a resolução completa do monitor, o que tornaria as fontes pequenas, o conteúdo é ampliado até que as fontes sejam grandes o suficiente.

No meu monitor, recebo:
Resolução física: 2560 x 1440 (220 DPI)
Resolução de python relatada: 1555 x 875 (158 DPI)

Por este site do Windows: http://msdn.microsoft.com/en-us/library/aa770067%28v=vs.85%29.aspx A fórmula para a resolução efetiva do sistema relatada é: (reports_px * current_dpi) / (96 dpi ) = Physical_px

Consigo obter a resolução de tela cheia correta e o DPI atual com o código abaixo. Observe que eu chamo SetProcessDPIAware () para permitir que o programa veja a resolução real.

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

O que retornou:

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

Estou executando o Windows 8.1 com um monitor capaz de 220 DPI. Meu dimensionamento de exibição define meu DPI atual para 158.

Usarei o 158 para garantir que meus gráficos matplotlib tenham o tamanho certo com: from pylab import rcParams rcParams ['figure.dpi'] = curr_dpi

espaçador
fonte
Você tem muitas informações boas aqui, mas a resposta em si está enterrada no meio. Para torná-lo um pouco mais fácil de ler, você pode esclarecer exatamente qual é a resposta e , em seguida, fornecer a informação de fundo?
Skrrgwasme # 23/14
Editei minha postagem para mostrar a resposta no começo e entrar em detalhes. Obrigado pelo feedback.
Spacether # 24/14
1
Parece que há uma falha nos cálculos aqui, e é fácil identificá-lo. Você calcula um tamanho diagonal a partir da largura e altura relatadas (em polegadas). Minha tela com 13,3 polegadas de diagonal foi relatada como 15 polegadas. Parece que Tkinterestá usando pixels corretos, mas não está ciente da escala de dpi, relatando tamanhos de mm incorretos.
Primer
Isso não funciona no Windows 10, pois o SetSystemDPIAware () não parece fazer a diferença. No entanto, chamar ctypes.windll.shcore.SetProcessDpiAwareness (2) parece fazer o truque.
Klamer Schutte
@KlamerSchutte: ctypes.windll.shcore.SetProcessDpiAwareness(2)retorna erro OSError: [WinError 126] The specified module could not be found.
Adrian Keister
21

E para completar, o Mac OS X

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

fornecerá uma lista de tuplas contendo todos os tamanhos de tela (se houver vários monitores)

cobbal
fonte
15

Se você estiver usando o Qtkit de ferramentas especificamente PySide, poderá fazer o seguinte:

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

Usando o Linux, a maneira mais simples é executar o comando bash

xrandr | grep '*'

e analise sua saída usando regexp.

Além disso, você pode fazer isso através do PyGame: http://www.daniweb.com/forums/thread54881.html

Pavel Strakhov
fonte
Como você usa o pygame para obter a resolução da tela?
Jamie Twells
11

Aqui está um pequeno programa Python rápido que exibirá as informações sobre a configuração de vários monitores:

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)  

Aqui está um exemplo de sua saída:

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
fonte
Recebe gtk.Window()o gdk_default_root_window? É assim que você tem certeza de que .get_screencontém todos os monitores?
yatg 17/07/2015
Eu pergunto porque no meu código estou tentando replicar seu código, estou fazendo isso em jsctypes, e ele continua me dizendo 0 monitores: gist.github.com/yajd/55441c9c3d0711ee4a38#file-gistfile1-txt-L3
yatg
2
Faz um tempo desde que escrevi esse código, mas, se bem me lembro, o que gtk.Window()faz é criar uma nova janela (veja aqui ). A janela é apenas uma maneira de usar get_screenpara obter as informações do monitor. Retorna a tela em que a janela está (ou estaria, se alguma vez fosse exibida). Eu acho que depende da configuração do X se essa "tela" contém todos os "monitores". Isso acontece no meu sistema com o Twinview.
starfry
Obrigado @starfry! Eu precisava encontrar uma solução cruzada que obtesse todos os monitores e suas dimensões, independentemente da tela. Você já teve alguma chance de desenvolver algo assim? :)
yatg
Alternativa para versões posteriores do kit de ferramentas: `` python
satyagraha
9

Estou usando o método get_screen_resolution em um dos meus projetos, como o abaixo, que é basicamente uma cadeia de importação. Você pode modificar isso de acordo com Suas necessidades, removendo as peças que não são necessárias e movendo as portas mais prováveis ​​para cima na cadeia.

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
fonte
1
Obrigado por compartilhar isso, mas poderia ter sido encurtado muito usando uma função para lidar com os casos if-else
Udayraj Deshmukh
8

Pergunta antiga, mas isso está faltando. Eu sou novo em python, então, me diga se esta é uma solução "ruim". Esta solução é suportada apenas para Windows e MacOS e funciona apenas na tela principal - mas o sistema operacional não é mencionado na pergunta.

Meça o tamanho fazendo uma captura de tela. Como o tamanho da tela não deve mudar, isso deve ser feito apenas uma vez. Existem soluções mais elegantes se você tiver um kit de ferramentas GUI como GTK, wx, ... instalado.

veja travesseiro

pip install Pillow

from PIL import ImageGrab

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

Versão do 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)
cpoakes
fonte
6

Expandindo a resposta de @ user2366975 , para obter o tamanho atual da tela em uma configuração de várias telas usando Tkinter (código em 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

(Deve funcionar em várias plataformas, testado apenas no Linux)

norok2
fonte
5

Tente o seguinte código:

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

Caso você tenha o PyQt4 instalado, tente o seguinte código:

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

Para o PyQt5, o seguinte funcionará:

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

Uma plataforma cruzada e uma maneira fácil de fazer isso é usar o TKinter, que vem com quase todas as versões do python, para que você não precise instalar nada:

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

Usando Linux Em vez de regexp, pegue a primeira linha e retire os valores de resolução atuais.

Resolução atual da tela: 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

Isso foi feito no xrandr 1.3.5, não sei se a saída é diferente em outras versões, mas isso deve facilitar a compreensão.

Alex R
fonte
infelizmente não é muito bom com configurações multimonitor. culpa não de python, mas usando isso pode ter resultados inesperados ...
black_puppydog
2

Para obter bits por pixel:

import ctypes
user32 = ctypes.windll.user32
gdi32 = ctypes.windll.gdi32

screensize = (user32.GetSystemMetrics(0), user32.GetSystemMetrics(1))
print "screensize =%s"%(str(screensize))
dc = user32.GetDC(None);

screensize = (gdi32.GetDeviceCaps(dc,8), gdi32.GetDeviceCaps(dc,10), gdi32.GetDeviceCaps(dc,12))
print "screensize =%s"%(str(screensize))
screensize = (gdi32.GetDeviceCaps(dc,118), gdi32.GetDeviceCaps(dc,117), gdi32.GetDeviceCaps(dc,12))
print "screensize =%s"%(str(screensize))

parâmetros no 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,
user3757097
fonte
2

Tente pyautogui:

import pyautogui
resolution = pyautogui.size()
print(resolution) 
Tyler
fonte
Você realmente deve adicionar algumas explicações sobre por que esse código deve funcionar - você também pode adicionar comentários no próprio código - em sua forma atual, ele não fornece nenhuma explicação que possa ajudar o resto da comunidade a entender o que você fez para resolver /Responda à pergunta. Mas esta é também uma questão muito antiga - com uma resposta aceita ...
ishmaelMakitla
2

Outra versão usando 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
fonte
2

Usando pygame :

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

[1]

No entanto, se você estiver tentando definir sua janela para o tamanho da tela, faça o seguinte:

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

para definir sua exibição no modo de tela cheia. [2]

Tom Burrows
fonte
Confirmado que funciona no Windows :) Que bom método não específico do Windows!
Lukasz Czerwinski 31/08/19
1

Você poderia usar o PyMouse . Para obter o tamanho da tela, use o screen_size()atributo:

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

aretornará uma tupla,, (X, Y)onde Xestá a posição horizontal e Ya posição vertical.

Link para funcionar na documentação.

Simon
fonte
1

Se você estiver trabalhando no sistema operacional Windows, poderá usar o módulo OS para obtê-lo:

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

Ele retornará uma tupla (Y, X) onde Y é o tamanho vertical e X é o tamanho horizontal. Este código funciona em Python 2 e Python 3

Diroallu
fonte
0

No Linux, podemos usar o módulo de subprocesso

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

É um pouco problemático para a tela da retina, eu uso o tkinter para obter o tamanho falso, use o pilllow grab para obter o tamanho real:

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

Para versões posteriores do 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))
satyagraha
fonte
0

Para Linux, você pode usar isto:

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

Script de utilitário usando a pynputbiblioteca. Publicando aqui para 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
fonte