Guía de Coordenadas PyAutoGUI: size(), Multimonitor, Corrección de DPI

Los tres bugs de coordenadas de PyAutoGUI

Los problemas de coordenadas con PyAutoGUI casi siempre caen en una de estas tres categorías:

1. Offset del clic en pantallas con DPI alto: pyautogui.click(960, 540) no aterriza donde esperas porque PyAutoGUI usa coordenadas lógicas mientras la aplicación de destino usa coordenadas físicas. Cubierto en nuestra guía de escalado DPI.
2. Tamaño de pantalla incorrecto: pyautogui.size() devuelve 2560×1440 en tu pantalla 4K porque Windows le está dando la resolución lógica (escalada). Tus scripts calculan centros erróneos, porcentajes erróneos, todo erróneo.
3. Desalineación de la región de captura: pyautogui.screenshot(region=(x, y, w, h)) captura un área diferente a la que especificaste, porque las coordenadas de la región están en espacio lógico pero la captura usa el búfer de píxeles físicos.

pyautogui.size() vs tu resolución real

¿Qué devuelve realmente pyautogui.size() en una pantalla 4K? Depende de tu escalado:

Con un escalado del 150 % en 4K, PyAutoGUI cree que tu pantalla solo tiene 2560 píxeles de ancho. Cuando hace clic en lo que cree que es el centro (1280, 720), Windows traduce eso al píxel físico (1920, 1080) — que por casualidad es el centro real. Pero cualquier otra posición estará desplazada por el factor de escala.

La solución completa: configuración de PyAutoGUI consciente del DPI

Pon esto al principio de tu script — antes de importar PyAutoGUI:

import ctypes
import sys

# Corrección #1: Decir a Windows que queremos píxeles físicos reales
if sys.platform == 'win32':
    try:
        # Conciencia DPI por monitor (mejor para multimonitor)
        ctypes.windll.shcore.SetProcessDpiAwareness(2)
    except Exception:
        # Alternativa: conciencia DPI a nivel de sistema
        ctypes.windll.user32.SetProcessDPIAware()

# AHORA importamos PyAutoGUI — verá los píxeles reales
import pyautogui

# Verificar que la corrección funcionó
w, h = pyautogui.size()
print(f"Screen size: {w}×{h}")
# En una pantalla 4K al 150%, esto debería mostrar 3840×2160

¿Por qué SetProcessDpiAwareness(2) en vez de SetProcessDPIAware()?

Si tienes una pantalla de portátil 4K al 150 % y un monitor externo de 1080p al 100 %, SetProcessDpiAwareness(2) asegura que PyAutoGUI vea 3840×2160 en la pantalla del portátil y 1920×1080 en el externo — los valores reales de cada pantalla. Para más detalles sobre cómo funcionan las coordenadas entre monitores diferentes, consulta nuestra guía de coordenadas multimonitor.

Corregir los offsets en la región de captura de pantalla

El problema de la región de captura es traicionero. Sin la corrección DPI, el parámetro region usa coordenadas lógicas — así que ocurre esto (el ejemplo asume un escalado del 150 % en una pantalla 4K; tu DPR detectado puede variar):

# SIN la corrección (escalado al 150 % en 4K):
# Quieres capturar los 960×540 píxeles de la esquina superior izquierda
img = pyautogui.screenshot(region=(0, 0, 960, 540))
# Pero en realidad captura la zona lógica superior izquierda de 960×540
# que se mapea a píxeles físicos (0, 0, 1440, 810) — mucho más de lo que querías

# CON SetProcessDpiAwareness(2):
# Ahora la región usa píxeles físicos correctamente
img = pyautogui.screenshot(region=(0, 0, 960, 540))
# Captura exactamente los 960×540 píxeles físicos de la esquina superior izquierda ✓

Multimonitor: coordenadas de pantalla virtual explicadas

En una configuración multimonitor, PyAutoGUI trabaja con una única pantalla virtual que abarca todos tus monitores. El monitor principal empieza en (0, 0). Los demás se extienden desde ahí:

• Un monitor a la derecha del principal empieza en X = primary_width (asumiendo que ambos usan el mismo escalado DPI — las configuraciones con DPI mixto son más complicadas)
• Un monitor a la izquierda del principal tiene coordenadas X negativas (por ejemplo, −1920 a −1)
• Un monitor por encima del principal tiene coordenadas Y negativas

# Comprueba el tamaño de tu pantalla virtual
import ctypes
import pyautogui

# Tras la corrección DPI:
print(pyautogui.size())   # Tamaño del monitor principal
x, y = pyautogui.position()
print(f"Current mouse position: ({x}, {y})")
# Valores negativos significan que estás en un monitor a la izquierda/arriba

Para los cálculos completos de coordenadas para obtener el centro, los offsets y las posiciones de los bordes de cualquier monitor, consulta nuestra guía de coordenadas multimonitor.

Por qué locateOnScreen() devuelve coordenadas incorrectas

pyautogui.locateOnScreen('button.png') es una de las funciones más útiles de PyAutoGUI — y una de las que más falla en pantallas con DPI alto. El problema (el ejemplo asume un escalado del 150 % en una pantalla 4K):

1. Haces una captura de pantalla de un botón en tu pantalla 4K (la imagen es de 3840×2160 píxeles físicos)
2. Recortas el botón y lo guardas como button.png
3. locateOnScreen() hace una captura — pero sin conciencia DPI, Windows devuelve una imagen de tamaño lógico (2560×1440) que ha sido remuestreada y difuminada por el sistema operativo (virtualización DPI). Los píxeles ya no coinciden exactamente con tu imagen de referencia.
4. Intenta encontrar tu botón nítido recortado a 4K dentro de esta captura borrosa y reducida — y falla o devuelve coordenadas incorrectas

La solución: Tras llamar a SetProcessDpiAwareness(2), las capturas internas de PyAutoGUI obtienen píxeles físicos en crudo sin remuestreo del SO. Tu imagen de referencia y la captura de búsqueda están ahora a la misma resolución y nitidez, así que locateOnScreen() funciona correctamente.

Script listo para usar

Copia y pega esto en tu proyecto. Gestiona la conciencia DPI, la detección multimonitor y te da funciones auxiliares para clics independientes de la resolución:

"""
Configuración de PyAutoGUI consciente del DPI — coloca esto al principio de cualquier script.
Funciona en Windows, macOS y Linux. Compatible con multimonitor.

CRÍTICO: La conciencia DPI DEBE configurarse antes de importar pyautogui,
de lo contrario cachea la resolución lógica en la importación.
"""
import ctypes
import sys

# --- Configurar conciencia DPI ANTES de importar pyautogui ---
if sys.platform == 'win32':
    try:
        ctypes.windll.shcore.SetProcessDpiAwareness(2)
    except Exception:
        try:
            ctypes.windll.user32.SetProcessDPIAware()
        except Exception:
            pass

# AHORA es seguro importar pyautogui
import pyautogui

def get_screen_info():
    """Devuelve información útil de la pantalla."""
    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):
    """Hace clic en un porcentaje del tamaño de pantalla (0.0 a 1.0).
    Independiente de la resolución — funciona en cualquier pantalla."""
    w, h = pyautogui.size()
    pyautogui.click(int(w * x_pct), int(h * y_pct))

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

# Ejemplo: hacer clic en el centro de la pantalla
click_relative(0.5, 0.5)

Preguntas frecuentes