Comment puis-je connaître la taille de l'écran de mon ordinateur portable ?

Une autre option consiste à utiliser xrandr est le commandement :

xrandr | grep ' connected'

Sortie :

DVI-I-1 connected primary 1680x1050+0+0 (normal left inverted right x axis y axis) 473mm x 296mm
VGA-1 connected 1280x1024+1680+0 (normal left inverted right x axis y axis) 376mm x 301mm

(attention à l'espace avant connected sinon disconnected sera incluse)

Différences importantes entre xdpyinfo y xrandr

• En xrandr énumère les écrans séparément (dans le cas de plusieurs moniteurs), xdpyinfo produit un seul ensemble de dimensions pour tous les écrans ("taille du bureau" au lieu de la taille de l'écran)

• Comme l'a remarqué @agold, il y a une (grande) différence entre les deux, qui semble trop importante pour être une simple différence d'arrondi :

  xrandr: 473mm x 296mm
  xdpyinfo: 445x278

Il semble lié à un insecte en xdpyinfo . Voir aussi aquí .

Si vous insistez sur les pouces

Utilisez le petit script ci-dessous ; il indique la taille de votre (vos) écran(s) en pouces ; largeur / hauteur / diagonale (pouces)

#!/usr/bin/env python3
import subprocess
# change the round factor if you like
r = 1

screens = [l.split()[-3:] for l in subprocess.check_output(
    ["xrandr"]).decode("utf-8").strip().splitlines() if " connected" in l]

for s in screens:
    w = float(s[0].replace("mm", "")); h = float(s[2].replace("mm", "")); d = ((w**2)+(h**2))**(0.5)
    print([round(n/25.4, r) for n in [w, h, d]])

Pour l'utiliser :

Copiez le script dans un fichier vide, enregistrez-le sous le nom de get_dimensions.py , l'exécuter par la commande :

python3 /path/to/get_dimensions.py

Sortie sur mes deux écrans :

width - height - diagonal (inches)

[18.6, 11.7, 22.0]
[14.8, 11.9, 19.0]

Editer

Fantaisie version du même script (avec quelques améliorations et une sortie plus agréable), ressemblant à :

Screen  width   height  diagonal
--------------------------------
DVI-I-1 18.6    11.7    22.0
VGA-1   14.8    11.9    19.0

Le script :

#!/usr/bin/env python3
import subprocess
# change the round factor if you like
r = 1

screens = [l.split() for l in subprocess.check_output(
    ["xrandr"]).decode("utf-8").strip().splitlines() if " connected" in l]

scr_data = []
for s in screens:
    try:
        scr_data.append((
            s[0],
            float(s[-3].replace("mm", "")),
            float(s[-1].replace("mm", ""))
            ))
    except ValueError:
        pass

print(("\t").join(["Screen", "width", "height", "diagonal\n"+32*"-"]))
for s in scr_data:
    scr = s[0]; w = s[1]/25.4; h = s[2]/25.4; d = ((w**2)+(h**2))**(0.5)
    print(("\t").join([scr]+[str(round(n, 1)) for n in [w, h, d]]))

EDIT 2 (mai 2019)

"En quelque sorte" sur demande (dans un commentaire), une version modernisée / plus avancée / améliorée (pas d'appels système, pas d'analyse mais utilisation de Gdk.Display), faisant à peu près exactement la même chose :

#!/usr/bin/env python3
import gi
gi.require_version('Gdk', '3.0')
from gi.repository import Gdk

dsp = Gdk.Display.get_default()
n_mons = dsp.get_n_monitors()

print(("\t").join(["Screen", "width", "height", "diagonal\n"+32*"-"]))

for i in range(n_mons):
    mon = dsp.get_monitor(i)
    mon_name = mon.get_model()
    w = mon.get_width_mm()/25.4
    h = mon.get_height_mm()/25.4
    d = ((w**2)+(h**2))**(0.5)
    print(("\t").join([mon_name]+[str(round(n, 1)) for n in [w, h, d]]))

Sortie :

Screen  width   height  diagonal
--------------------------------
eDP-1   20.0    11.3    23.0
HDMI-1  18.6    11.7    22.0

Je laisserai la réponse originale, puisqu'il semble inapproprié de supprimer la réponse qui a généré les votes existants après une si longue période.

Au cas où vous souhaiteriez une réponse plus générale, vous pouvez découper la page le nœud gordien et d'utiliser un moyen de communication physique qui n'est pas trop risqué. règle pour cela. Conformément à la ce wiki La taille d'un écran est généralement décrite par la longueur de son diagonale " :

Si vous avez une règle qui n'affiche que centimètres vous pouvez utiliser le simple conversion :

1 cm = 0.393701 in
(or 2.54 cm = 1 in)

Ainsi, si votre règle mesure 30 centimètres , votre écran est 11.811 pouces. Vous pouvez également utiliser google avec une requête de la forme 30 cm to in .

Crédits d'image : https://en.wikipedia.org/wiki/File:Display_size_measurements.png

Que diriez-vous de ceci :

xrandr | awk '/ connected/{print sqrt( ($(NF-2)/10)^2 + ($NF/10)^2 )/2.54" inches"}'

Xdpyinfo est un utilitaire permettant d'afficher des informations sur un serveur X. Il permet d'examiner les capacités d'un serveur, les valeurs prédéfinies pour divers paramètres utilisés dans la communication entre les clients et le serveur, ainsi que les différents types d'écrans et de visuels disponibles.

La commande pour obtenir la taille du moniteur est la suivante :

xdpyinfo | grep dimensions

Résultat

dimensions:    1366x768 pixels (361x203 millimeters)

C'est quelque chose qui me posait problème (lorsque je voulais changer de moniteur et que je voulais savoir quelle était la taille de mon ancien moniteur), j'ai donc écrit un Shell Shell qui trouve la taille du moniteur pour vous.

J'ai utilisé le xdpyinfo de la première réponse pour obtenir les dimensions de l'écran et construire en conséquence. Le script calcule essentiellement la diagonale à partir des dimensions de l'écran, en convertissant les millimètres en pouces, et affiche le résultat.

URL du référentiel : https://github.com/abhishekvp/WhatsMyScreenSize

J'espère que cela vous aidera !