tutorial paso a paso para agregar la funcionalidad de captura de pantalla al asistente de voz, siguiendo exactamente la estructura que muestran las imágenes.

📸 Tutorial: Agregar captura de pantalla al asistente de voz

📦 Paso 1: Instalar la librería `pyautogui`

Primero necesitas instalar la librería que permite capturar la pantalla. Abre la terminal (CMD) y ejecuta:

pip install pyautogui

Deberías ver un mensaje similar a:

Collecting pyautogui
Successfully installed pyautogui-x.x.x

📝 Paso 2: Importar la librería en el código

Al inicio de tu archivo Python, agrega la importación de pyautogui junto con las otras librerías:

import pyttsx3
import speech_recognition as sr
import datetime
import pywhatkit
import time
import pyjokes
import pyautogui  # 👈 NUEVA LIBRERÍA PARA CAPTURAS

📸 Paso 3: Crear la función para capturar pantalla

Después de la función chiste(), agrega esta nueva función:

def captura_pantalla():
    """Captura la pantalla y la guarda en el escritorio"""
    try:
        hablar('Capturando la pantalla...')
        
        # Tomar la captura de pantalla
        captura = pyautogui.screenshot()
        
        # Guardar la captura en el escritorio (ajusta la ruta según tu usuario)
        # Para Windows:
        ruta = 'C://Users/edudu/Desktop/captura.png'
        
        # Para que funcione en cualquier computadora, puedes usar:
        # import os
        # escritorio = os.path.join(os.path.expanduser("~"), "Desktop")
        # ruta = os.path.join(escritorio, "captura.png")
        
        captura.save(ruta)
        
        print(f"📸 Captura guardada en: {ruta}")
        hablar("Captura guardada en el escritorio")
        
    except Exception as e:
        print(f"Error al capturar pantalla: {e}")
        hablar("No pude capturar la pantalla, hubo un error")

Explicación:

pyautogui.screenshot() toma una captura de toda la pantalla.
.save() guarda la imagen en la ruta especificada.
Se usa try/except para manejar posibles errores.

🎤 Paso 4: Agregar el comando en la función `escuchar()`

Dentro del bucle principal escuchar(), en la sección donde se procesan los comandos, agrega la condición para detectar la frase "captura la pantalla":

# Dentro de la función escuchar(), después de los otros comandos

# Comando para captura de pantalla
elif 'captura la pantalla' in text or 'captura pantalla' in text or 'toma captura' in text:
    captura_pantalla()

Debe quedar algo así en tu código:

# ========== COMANDOS ==========

# Comando para salir
if "adiós" in text or "adios" in text or "salir" in text or "hasta luego" in text:
    hablar("Hasta luego, que tengas un buen día")
    break

# Comando para mostrar ayuda
elif "comandos" in text or "ayuda" in text or "qué puedes hacer" in text:
    mostrar_comandos()

# Comando para fecha/día
elif "dia" in text or "día" in text or "fecha" in text or "hoy" in text:
    hoy = datetime.datetime.now()
    respuesta = f"Hoy es {hoy.day} del {hoy.month} del {hoy.year}"
    print(f"📅 {respuesta}")
    hablar(respuesta)

# Comando para hora
elif "hora" in text:
    ahora = datetime.datetime.now()
    if ahora.minute == 0:
        respuesta = f"Son las {ahora.hour} en punto"
    elif ahora.minute < 10:
        respuesta = f"Son las {ahora.hour} con cero {ahora.minute}"
    else:
        respuesta = f"Son las {ahora.hour} con {ahora.minute}"
    print(f"⏰ {respuesta}")
    hablar(respuesta)

# Comando para YouTube
elif 'busca en youtube' in text:
    busqueda_youtube(text)

# Comando para chistes
elif "chiste" in text or "chistes" in text or "cuéntame un chiste" in text:
    chiste()

# 👇 NUEVO COMANDO PARA CAPTURA DE PANTALLA 👇
# Comando para captura de pantalla
elif 'captura la pantalla' in text or 'captura pantalla' in text or 'toma captura' in text:
    captura_pantalla()

# Comando no reconocido
else:
    hablar("No tengo una respuesta para eso")
    print("💡 Tip: Di 'comandos' para ver lo que puedo hacer")

📋 Paso 5: Actualizar la lista de comandos

Para que el usuario sepa que puede pedir capturas de pantalla, actualiza la función mostrar_comandos():

def mostrar_comandos():
    """Muestra los comandos disponibles"""
    print("\n📋 COMANDOS DISPONIBLES:")
    print("  • 'hora' - Te digo la hora")
    print("  • 'fecha', 'día' o 'hoy' - Te digo la fecha")
    print("  • 'busca en youtube [lo que quieras]' - Busca en YouTube")
    print("  • 'chiste' o 'cuéntame un chiste' - Te cuento un chiste")
    print("  • 'captura la pantalla' - Toma una captura de pantalla")  # 👈 NUEVO
    print("  • 'comandos' - Muestro esta lista")
    print("  • 'adiós' o 'salir' - Salgo del programa")
    print("-" * 40)
    hablar("Puedes preguntarme la hora, la fecha, buscar en YouTube, pedirme un chiste o tomar capturas de pantalla")

🔧 Paso 6: Mejorar la ruta de guardado (opcional)

Para que la captura se guarde automáticamente en el escritorio de cualquier usuario, puedes usar esta versión mejorada de la función:

import os  # Agregar al inicio si no está

def captura_pantalla():
    """Captura la pantalla y la guarda en el escritorio"""
    try:
        hablar('Capturando la pantalla...')
        
        # Tomar la captura de pantalla
        captura = pyautogui.screenshot()
        
        # Obtener la ruta del escritorio automáticamente
        escritorio = os.path.join(os.path.expanduser("~"), "Desktop")
        
        # Crear nombre de archivo con fecha y hora
        ahora = datetime.datetime.now()
        nombre_archivo = f"captura_{ahora.strftime('%Y%m%d_%H%M%S')}.png"
        ruta = os.path.join(escritorio, nombre_archivo)
        
        # Guardar la captura
        captura.save(ruta)
        
        print(f"📸 Captura guardada en: {ruta}")
        hablar(f"Captura guardada en el escritorio como {nombre_archivo}")
        
    except Exception as e:
        print(f"Error al capturar pantalla: {e}")
        hablar("No pude capturar la pantalla, hubo un error")

Ventajas de esta versión:

Funciona en cualquier computadora sin necesidad de cambiar la ruta.
El nombre del archivo incluye fecha y hora para no sobrescribir.
Usa os.path.expanduser("~") para encontrar la carpeta del usuario.

✅ Paso 7: Probar el asistente

Ejecuta el programa y prueba el comando:

👤 Dijiste: captura la pantalla
🤖: Capturando la pantalla...
📸 Captura guardada en: C:\Users\edudu\Desktop\captura_20260320_143025.png
🤖: Captura guardada en el escritorio como captura_20260320_143025.png

📊 Estructura final del código

Tu código ahora debería tener esta estructura general:

import pyttsx3
import speech_recognition as sr
import datetime
import pywhatkit
import time
import pyjokes
import pyautogui  # 👈 PARA CAPTURAS
import os          # 👈 PARA RUTAS (opcional)

# Inicializar reconocimiento de voz
listener = sr.Recognizer()

def hablar(texto):
    # ... código existente ...

def bienvenida():
    # ... código existente ...

def mostrar_comandos():
    # ... código actualizado con captura de pantalla ...

def busqueda_youtube(busca):
    # ... código existente ...

def chiste():
    # ... código existente ...

def captura_pantalla():  # 👈 NUEVA FUNCIÓN
    try:
        hablar('Capturando la pantalla...')
        captura = pyautogui.screenshot()
        
        # Versión simple:
        captura.save('C://Users/edudu/Desktop/captura.png')
        
        # Versión mejorada (recomendada):
        # escritorio = os.path.join(os.path.expanduser("~"), "Desktop")
        # ahora = datetime.datetime.now()
        # nombre = f"captura_{ahora.strftime('%Y%m%d_%H%M%S')}.png"
        # ruta = os.path.join(escritorio, nombre)
        # captura.save(ruta)
        
        hablar("Captura guardada en el escritorio")
    except Exception as e:
        print(f"Error: {e}")
        hablar("No pude capturar la pantalla")

def escuchar():
    # ... código existente con el nuevo comando ...

if __name__ == "__main__":
    # ... código existente ...

🎯 Resumen

Paso	Acción
1	Instalar `pyautogui` con `pip install pyautogui`
2	Importar `import pyautogui`
3	Crear función `captura_pantalla()`
4	Agregar `elif 'captura la pantalla' in text:` en `escuchar()`
5	Actualizar `mostrar_comandos()`
6	(Opcional) Mejorar con rutas dinámicas
7	¡Probar!

🎉 ¡Funcionalidades completas!

Ahora tu asistente de voz puede:

🕐 Decir la hora
📅 Decir la fecha
🎬 Buscar en YouTube
😂 Contar chistes
📸 Capturar la pantalla

¡Todo con comandos de voz! 🚀

**************************************

22. Captura de Pantalla con Python: Tutorial para Principiantes

📸 Introducción: Tu asistente fotógrafo de pantalla

¿Necesitas tomar una captura de pantalla rápidamente? ¡Ahora puedes pedírselo a tu asistente virtual! Vamos a enseñarle a tomar "fotos" de tu pantalla con un simple comando de voz. Es como tener un fotógrafo personal para tu computadora.

Analoǵía: Tomar una captura de pantalla es como usar una cámara:

Tu pantalla = Lo que quieres fotografiar
pyautogui = La cámara digital
El archivo PNG = La foto impresa

🖼️ ¿Cómo funciona? Esquema visual

text

🎤 TÚ: "Captura la pantalla"

↓

🤖 ASISTENTE: Detecta "captura" y "pantalla"

↓

📷 PYAUTOGUI: Toma "foto" de toda la pantalla

↓

💾 GUARDA: Crea archivo "captura.png" en escritorio

↓

🔊 ASISTENTE: "Capturando la pantalla..."

↓

✅ RESULTADO: ¡Tienes tu captura guardada!

🛠️ Lo que necesitaremos

Librería: pyautogui

Ya viene con pywhatkit (que ya instalaste)
Si no la tienes: pip install pyautogui
¿Qué hace? Controla el mouse, teclado y toma capturas

bash

# Solo si no la tienes instalada:

pip install pyautogui

⚠️ Importante: pyautogui necesita permisos en algunos sistemas:

Windows: Funciona directamente
Mac: Puede pedir permisos de accesibilidad
Linux: Usa scrot o similar

✍️ Código paso a paso explicado

Paso 1: Importar la librería

python

import pyautogui

¿Qué contiene pyautogui?

screenshot() → Toma capturas
click() → Haz clic con el mouse
typewrite() → Escribe texto
press() → Presiona teclas

Paso 2: Detectar el comando de captura

python

# En tu función principal:

if 'captura' in comando and 'pantalla' in comando:

capturar_pantalla()

También puedes usar:

python

# Variaciones que funcionarán:

if any(palabra in comando for palabra in

['captura pantalla', 'toma captura', 'screenshot']):

capturar_pantalla()

Ejemplos que activarán la función:

"Captura la pantalla"
"Toma una captura"
"Haz un screenshot"
"Guarda lo que hay en pantalla"

Paso 3: Crear la función principal

python

def capturar_pantalla():

"""

Toma una captura de pantalla completa y la guarda

"""

# 1. Informar al usuario

hablar("Capturando la pantalla...")

# 2. Tomar la captura

captura = pyautogui.screenshot()

# 3. Definir dónde guardarla

ruta = "C:/Users/TuUsuario/Desktop/captura.png"

# 4. Guardar la imagen

captura.save(ruta)

# 5. Confirmar

hablar("Captura guardada en el escritorio")

📁 Entendiendo las rutas de archivos

Estructura típica de rutas:

text

C:/Users/TuNombre/Desktop/captura.png

│ │ │ │ │

│ │ │ │ └── Nombre del archivo + extensión

│ │ │ └───────────── Carpeta destino (Escritorio)

│ │ └─────────────────────── Tu nombre de usuario

│ └───────────────────────────── Carpeta de usuarios

└────────────────────────────────── Disco principal

Formas de escribir rutas:

python

# Windows (con barras normales)

ruta1 = "C:/Users/Juan/Desktop/captura.png"

# Windows (con doble barra)

ruta2 = "C:\\Users\\Juan\\Desktop\\captura.png"

# Usando path relativo (desde donde se ejecuta el script)

ruta3 = "./capturas/captura.png"

💡 Consejo: Usa barras normales (/) aunque estés en Windows, Python las entiende.

🎯 Código completo mejorado

python

# ASISTENTE VIRTUAL - CAPTURA DE PANTALLA

import pyautogui

import os

import time

from datetime import datetime

import pyttsx3

# Configuración de voz

engine = pyttsx3.init()

def hablar(texto):

engine.say(texto)

engine.runAndWait()

def capturar_pantalla_completa():

"""

Toma captura de toda la pantalla

"""

hablar("Tomando captura de pantalla completa...")

try:

# Tomar la captura

captura = pyautogui.screenshot()

# Crear carpeta si no existe

carpeta_capturas = "C:/Users/TuUsuario/Desktop/CapturasAsistente"

if not os.path.exists(carpeta_capturas):

os.makedirs(carpeta_capturas)

# Generar nombre único con fecha y hora

fecha_hora = datetime.now().strftime("%Y%m%d_%H%M%S")

nombre_archivo = f"captura_{fecha_hora}.png"

ruta_completa = f"{carpeta_capturas}/{nombre_archivo}"

# Guardar la imagen

captura.save(ruta_completa)

# Confirmación

mensaje = f"Captura guardada como {nombre_archivo}"

hablar(mensaje)

print(f"✅ {mensaje}")

print(f"📁 Ubicación: {ruta_completa}")

return ruta_completa

except Exception as e:

error_msg = f"Error al capturar pantalla: {e}"

hablar("No pude tomar la captura")

print(f"❌ {error_msg}")

return None

def capturar_region_personalizada():

"""

Captura solo una región específica de la pantalla

Pide coordenadas o usa valores por defecto

"""

hablar("¿Quieres capturar toda la pantalla o solo una parte?")

# Aquí podrías agregar código para escuchar la respuesta

# Por ahora usaremos valores por defecto

hablar("Capturando región central de la pantalla...")

try:

# Obtener tamaño de la pantalla

ancho, alto = pyautogui.size()

# Definir región central (mitad de la pantalla)

izquierda = ancho // 4

superior = alto // 4

derecha = ancho * 3 // 4

inferior = alto * 3 // 4

# Tomar captura de la región

captura = pyautogui.screenshot(region=(izquierda, superior,

derecha - izquierda,

inferior - superior))

# Guardar

carpeta = "C:/Users/TuUsuario/Desktop/CapturasAsistente"

if not os.path.exists(carpeta):

os.makedirs(carpeta)

fecha_hora = datetime.now().strftime("%Y%m%d_%H%M%S")

ruta = f"{carpeta}/region_{fecha_hora}.png"

captura.save(ruta)

hablar("Región capturada exitosamente")

print(f"📍 Captura de región guardada: {ruta}")

return ruta

except Exception as e:

hablar("Error al capturar la región")

print(f"Error: {e}")

return None

def captura_automatica_con_retraso(segundos=3):

"""

Toma captura después de un retraso

Útil para capturar menús desplegables, etc.

"""

hablar(f"Tomaré la captura en {segundos} segundos...")

for i in range(segundos, 0, -1):

hablar(str(i))

time.sleep(1)

hablar("¡Capturando!")

return capturar_pantalla_completa()

def procesar_comando_captura(comando):

"""

Procesa diferentes tipos de comandos de captura

"""

comando_lower = comando.lower()

# Captura completa

if any(palabra in comando_lower for palabra in

['captura pantalla', 'toma captura', 'screenshot completo']):

capturar_pantalla_completa()

# Captura con retraso

elif 'captura en' in comando_lower or 'en segundos' in comando_lower:

try:

# Extraer número de segundos

palabras = comando_lower.split()

for palabra in palabras:

if palabra.isdigit():

segundos = int(palabra)

captura_automatica_con_retraso(segundos)

return

except:

captura_automatica_con_retraso(3) # Valor por defecto

# Captura de región

elif any(palabra in comando_lower for palabra in

['captura región', 'captura parte', 'captura área']):

capturar_region_personalizada()

# Por defecto: captura completa

else:

capturar_pantalla_completa()

# Diagrama visual del proceso:

"""

🎤 TÚ DICES: "Captura la pantalla"

↓

🤖 ASISTENTE: Detecta palabras clave

↓

⏱️ PREPARACIÓN: "Capturando la pantalla..."

↓

📷 PYAUTOGUI: screenshot() toma "foto" digital

↓

💾 GUARDADO: save("ruta/captura.png")

↓

🗂️ ORGANIZACIÓN: Carpeta + nombre único

↓

🔊 CONFIRMACIÓN: "Captura guardada como captura_20231215_143022.png"

↓

🖼️ RESULTADO: Archivo PNG listo para usar

"""

🎨 Formatos de imagen disponibles

python

# Puedes guardar en diferentes formatos:

captura.save("captura.png") # PNG - Calidad alta, sin pérdida

captura.save("captura.jpg") # JPG - Más compresión

captura.save("captura.bmp") # BMP - Sin compresión, archivo grande

captura.save("captura.tiff") # TIFF - Alta calidad para impresión

Recomendación: Usa PNG para capturas de pantalla porque:

Mantiene calidad perfecta
Soporta transparencias
Es el estándar para capturas

✨ Características avanzadas

1. Captura de ventana específica:

python

import pygetwindow as gw

def capturar_ventana_activa():

"""Captura solo la ventana activa"""

ventana_activa = gw.getActiveWindow()

if ventana_activa:

# Obtener posición y tamaño

x, y, ancho, alto = ventana_activa.left, ventana_activa.top, ventana_activa.width, ventana_activa.height

captura = pyautogui.screenshot(region=(x, y, ancho, alto))

captura.save("ventana_activa.png")

2. Miniaturas automáticas:

python

from PIL import Image

def crear_miniatura(ruta_original, tamaño=(200, 150)):

"""Crea una versión mini de la captura"""

imagen = Image.open(ruta_original)

imagen.thumbnail(tamaño)

imagen.save(ruta_original.replace(".png", "_miniatura.png"))

3. Captura múltiple:

python

def captura_rapida(n=5, intervalo=1):

"""Toma varias capturas seguidas"""

for i in range(n):

nombre = f"captura_rapida_{i+1}.png"

pyautogui.screenshot().save(nombre)

time.sleep(intervalo)

hablar(f"Captura {i+1} de {n}")

🚨 Solución de problemas comunes

Problema 1: Permisos en Mac

bash

# En Mac, ve a:

# Preferencias del Sistema → Seguridad y Privacidad → Accesibilidad

# Agrega Terminal o VS Code a la lista de apps permitidas

Problema 2: Ruta no encontrada

python

# Verifica que la carpeta exista

import os

ruta = "C:/Users/TU_NOMBRE/Desktop/captura.png"

carpeta = os.path.dirname(ruta)

if not os.path.exists(carpeta):

os.makedirs(carpeta) # Crea la carpeta si no existe

Problema 3: Captura en blanco/negra

Asegúrate de que la pantalla no esté apagada
pyautogui captura lo que se muestra físicamente
Si usas múltiples monitores, captura todos

📊 Resumen de funciones de captura

Función	Descripción	Ejemplo de uso
screenshot()	Captura completa	pyautogui.screenshot()
screenshot(region=(x,y,ancho,alto))	Captura región específica	region=(0,0,800,600)
.save("ruta.png")	Guarda la imagen	captura.save("foto.png")
size()	Obtiene tamaño pantalla	ancho, alto = pyautogui.size()

✅ Resumen clave

pyautogui.screenshot() toma la captura
.save("ruta/archivo.png") guarda la imagen
Usa nombres únicos con fecha/hora para no sobrescribir
PNG es el mejor formato para capturas
Siempre informa al usuario antes y después

📝 Cuestionario de repaso

Pregunta 1

¿Qué función de pyautogui usamos para capturar pantalla?
a) capture()
b) screenshot()
c) take_picture()
d) save_screen()

Pregunta 2

¿Qué formato es mejor para capturas de pantalla?
a) JPG porque es más pequeño
b) PNG porque mantiene calidad
c) BMP porque es universal
d) GIF porque es animado

Pregunta 3

Si quieres capturar solo parte de la pantalla, ¿qué parámetro usas?
a) area=
b) section=
c) region=
d) part=

Pregunta 4

¿Por qué es buena idea usar fecha/hora en el nombre del archivo?
a) Para hacerlo más largo
b) Para evitar sobrescribir capturas anteriores
c) Porque es obligatorio
d) Para organizar por meses

Pregunta 5

Si el comando es "captura en 5 segundos", ¿qué debería hacer?
a) Capturar inmediatamente
b) Esperar 5 segundos y luego capturar
c) Tomar 5 capturas seguidas
d) Capturar cada 5 segundos

Respuestas del cuestionario

b) screenshot() - Literalmente "captura de pantalla" en inglés
b) PNG porque mantiene calidad - Sin compresión pérdida, ideal para texto
c) region= - Define región con (x, y, ancho, alto)
b) Para evitar sobrescribir capturas anteriores - Cada captura tiene nombre único
b) Esperar 5 segundos y luego capturar - Útil para capturar menús o transiciones

🎁 Reto final: Personaliza tu función

Desafío 1: Captura con marca de agua

python

def captura_con_marca_de_agua():

from PIL import Image, ImageDraw, ImageFont

captura = pyautogui.screenshot()

# Agregar texto

dibujo = ImageDraw.Draw(captura)

fecha = datetime.now().strftime("%d/%m/%Y %H:%M")

dibujo.text((10, 10), f"Captura: {fecha}", fill=(255, 0, 0))

captura.save("captura_marca.png")

Desafío 2: Compartir automáticamente

python

def captura_y_compartir():

ruta = capturar_pantalla_completa()

# Copiar al portapapeles

import pyperclip

pyperclip.copy(f"Captura: {ruta}")

hablar("Ruta copiada al portapapeles")

Desafío 3: Captura programada

python

def captura_cada_x_segundos(segundos=60, total=10):

"""Toma capturas automáticas cada X segundos"""

for i in range(total):

hablar(f"Captura automática {i+1} de {total}")

capturar_pantalla_completa()

time.sleep(segundos)

🎉 ¡Felicidades!

Ahora tu asistente puede:

✅ Tomar capturas de pantalla completas
✅ Guardarlas organizadamente
✅ Usar nombres únicos con fecha/hora
✅ Capturar regiones específicas
✅ Esperar antes de capturar

Próximo paso: Agregar edición básica (recortar, rotar), subir a la nube automáticamente, o convertir a PDF. ¡Tu asistente fotógrafo está listo