PyAutoGUI-Koordinaten-Leitfaden: size(), Multi-Monitor, DPI-Skalierungs-Fixes

Die drei PyAutoGUI-Koordinaten-Bugs

PyAutoGUI-Koordinatenprobleme lassen sich fast immer einer dieser drei Kategorien zuordnen:

1. Klick-Offset auf hochauflösenden Displays: pyautogui.click(960, 540) landet nicht dort, wo Sie es erwarten, weil PyAutoGUI logische Koordinaten verwendet, während die Zielanwendung physische Koordinaten nutzt. Behandelt in unserem DPI-Skalierungs-Leitfaden.
2. Falsche Bildschirmgröße gemeldet: pyautogui.size() gibt 2560×1440 auf Ihrem 4K-Display zurück, weil Windows ihm die logische (skalierte) Auflösung liefert. Ihre Skripte berechnen falsche Mittelpunkte, falsche Prozentwerte — einfach alles.
3. Screenshot-Region-Versatz: pyautogui.screenshot(region=(x, y, w, h)) erfasst einen anderen Bereich als den angegebenen, weil die Regionskoordinaten im logischen Raum liegen, der Screenshot aber den physischen Pixelbuffer verwendet.

pyautogui.size() vs. Ihre echte Auflösung

Was liefert pyautogui.size() tatsächlich auf einem 4K-Display? Das hängt von Ihrer Skalierung ab:

Bei 150 % Skalierung auf 4K denkt PyAutoGUI, Ihr Bildschirm sei nur 2560 Pixel breit. Wenn es das als Mitte ansieht und auf (1280, 720) klickt, übersetzt Windows das in den physischen Pixel (1920, 1080) — was zufällig die echte Mitte ist. Aber jede andere Position wird um den Skalierungsfaktor danebenliegen.

Die Komplettlösung: DPI-fähiges PyAutoGUI-Setup

Setzen Sie das an den Anfang Ihres Skripts — vor dem Import von PyAutoGUI:

import ctypes
import sys

# Fix #1: Windows mitteilen, dass wir echte physische Pixel wollen
if sys.platform == 'win32':
    try:
        # Per-Monitor-DPI-Awareness (optimal für Multi-Monitor)
        ctypes.windll.shcore.SetProcessDpiAwareness(2)
    except Exception:
        # Fallback: Systemweite DPI-Awareness
        ctypes.windll.user32.SetProcessDPIAware()

# JETZT PyAutoGUI importieren — es sieht jetzt echte Pixel
import pyautogui

# Prüfen, ob der Fix funktioniert hat
w, h = pyautogui.size()
print(f"Screen size: {w}×{h}")
# Auf einem 4K-Display mit 150 % sollte jetzt 3840×2160 stehen

Warum SetProcessDpiAwareness(2) statt SetProcessDPIAware()?

Wenn Sie einen 4K-Laptopbildschirm mit 150 % und einen externen 1080p-Monitor mit 100 % haben, stellt SetProcessDpiAwareness(2) sicher, dass PyAutoGUI auf dem Laptop 3840×2160 und auf dem externen Monitor 1920×1080 sieht — die echten Werte für jedes Display. Mehr dazu, wie Koordinaten über verschiedene Monitore hinweg funktionieren, in unserem Multi-Monitor-Koordinaten-Leitfaden.

Screenshot-Region-Offsets korrigieren

Das Screenshot-Region-Problem ist tückisch. Ohne den DPI-Fix verwendet der region-Parameter logische Koordinaten — und dann passiert Folgendes (Beispiel assumes 150 % Skalierung auf einem 4K-Display; Ihr ermittelter DPR kann abweichen):

# OHNE den Fix (150 % Skalierung auf 4K):
# Sie wollen die oberen linken 960×540 Pixel erfassen
img = pyautogui.screenshot(region=(0, 0, 960, 540))
# Tatsächlich erfasst es die logischen oberen 960×540
# was physisch (0, 0, 1440, 810) entspricht — deutlich mehr als gewollt

# MIT SetProcessDpiAwareness(2):
# Jetzt verwendet die Region korrekt physische Pixel
img = pyautogui.screenshot(region=(0, 0, 960, 540))
# Erfasst exakt die oberen linken 960×540 physischen Pixel ✓

Multi-Monitor: Virtuelle Bildschirmkoordinaten erklärt

In einem Multi-Monitor-Setup arbeitet PyAutoGUI mit einem einzigen virtuellen Bildschirm, der sich über alle Ihre Monitore erstreckt. Der primäre Monitor beginnt bei (0, 0). Die anderen setzen sich daran fort:

• Ein Monitor rechts neben dem primären beginnt bei X = primary_width (vorausgesetzt, beide Monitore verwenden dieselbe DPI-Skalierung — gemischte DPI-Setups sind kniffliger)
• Ein Monitor links neben dem primären hat negative X-Koordinaten (z. B. −1920 bis −1)
• Ein Monitor über dem primären hat negative Y-Koordinaten

# Virtuelle Bildschirmgröße prüfen
import ctypes
import pyautogui

# Nach DPI-Fix:
print(pyautogui.size())   # Größe des primären Monitors
x, y = pyautogui.position()
print(f"Current mouse position: ({x}, {y})")
# Negative Werte bedeuten: Sie sind auf einem Monitor links/oberhalb

Die vollständige Koordinatenmathematik zur Berechnung der Mitte, Offsets und Randpositionen jedes Monitors finden Sie in unserem Multi-Monitor-Koordinaten-Leitfaden.

Warum locateOnScreen() falsche Koordinaten liefert

pyautogui.locateOnScreen('button.png') ist eine der nützlichsten PyAutoGUI-Funktionen — und eine der fehleranfälligsten auf hochauflösenden Displays. Das Problem (Beispiel assumes 150 % Skalierung auf einem 4K-Display):

1. Sie machen einen Screenshot eines Buttons auf Ihrem 4K-Display (das Bild hat 3840×2160 physische Pixel)
2. Sie schneiden den Button aus und speichern ihn als button.png
3. locateOnScreen() macht einen Screenshot — aber ohne DPI-Awareness liefert Windows ein logisch skaliertes Bild (2560×1440), das vom Betriebssystem hochskaliert und unscharf wurde (DPI-Virtualisierung). Die Pixel stimmen nicht mehr exakt mit Ihrem Referenzbild überein.
4. Es versucht, Ihren scharfen 4K-ausgeschnittenen Button in diesem unscharfen, verkleinerten Screenshot zu finden — und scheitert oder liefert falsche Koordinaten.

Die Lösung: Nach dem Aufruf von SetProcessDpiAwareness(2) erfasst PyAutoGUIs interner Screenshot rohe physische Pixel ohne OS-Resampling. Ihr Referenzbild und der Such-Screenshot sind jetzt auf derselben Auflösung und Schärfe, sodass locateOnScreen() korrekt funktioniert.

Fertiges Skript zum direkten Einsatz

Kopieren Sie dieses Skript in Ihr Projekt. Es kümmert sich um DPI-Awareness, Multi-Monitor-Erkennung und bietet Hilfsfunktionen für auflösungsunabhängige Klicks:

"""
PyAutoGUI DPI-fähiges Setup — oben in jedes Skript kopieren.
Funktioniert auf Windows, macOS und Linux. Multi-Monitor-sicher.

WICHTIG: DPI-Awareness MUSS vor dem Import von pyautogui gesetzt werden,
da dieser die logische Auflösung beim Import zwischenspeichert.
"""
import ctypes
import sys

# --- DPI-Awareness VOR dem Import von pyautogui setzen ---
if sys.platform == 'win32':
    try:
        ctypes.windll.shcore.SetProcessDpiAwareness(2)
    except Exception:
        try:
            ctypes.windll.user32.SetProcessDPIAware()
        except Exception:
            pass

# JETZT ist es sicher, pyautogui zu importieren
import pyautogui

def get_screen_info():
    """Liefert nützliche Bildschirminformationen."""
    w, h = pyautogui.size()
    return {
        'width': w,
        'height': h,
        'center': (w // 2, h // 2),
        'total_pixels': w * h,
    }

def click_relative(x_pct, y_pct):
    """Klickt an einem Prozentwert der Bildschirmgröße (0.0 bis 1.0).
    Auflösungsunabhängig — funktioniert auf jedem Bildschirm."""
    w, h = pyautogui.size()
    pyautogui.click(int(w * x_pct), int(h * y_pct))

# --- Anwendung ---
info = get_screen_info()
print(f"Primary screen: {info['width']}×{info['height']}")
print(f"Center: {info['center']}")

# Beispiel: Bildschirmmitte anklicken
click_relative(0.5, 0.5)

Häufig gestellte Fragen