12. Función Bienvenida

 

Tutorial: Creando un Asistente de Voz con Bienvenida en Python

En este tutorial, vamos a mejorar nuestro asistente de voz añadiéndole una función de bienvenida. Cada vez que el programa se ejecute, nos saludará antes de empezar a escuchar comandos. Usaremos las bibliotecas speech_recognition y pyttsx3.

Requisitos Previos

Asegúrate de tener instaladas las bibliotecas necesarias. Si no las tienes, puedes instalarlas con pip:

bash
python -m pip install speechrecognition pyttsx3

Nota: Para speech_recognition en Windows, a veces es necesario instalar también PyAudio. Si tienes problemas, puedes encontrar instrucciones en línea para tu sistema operativo.


import pyttsx3

engine = pyttsx3.init()

def bienvenida() :
    """Función que da un mensaje de bienvenida por voz."""
    engine.say("Bienvenido de vuelta.")
    engine.runAndWait()

bienvenida()

Paso 1: Configuración Inicial

Primero, creamos un nuevo archivo Python, por ejemplo asistente.py, y escribimos el código de configuración básica. Este código importa las librerías y configura la voz de nuestro asistente.

python
# asistente.py

import speech_recognition as sr
import pyttsx3

# Inicializamos el motor de texto a voz
engine = pyttsx3.init()

# Obtenemos la lista de voces disponibles y seleccionamos una (en este caso, el índice 2, que podría ser una voz en español)
voces = engine.getProperty('voices')
# Es posible que el índice de la voz en español varíe. Prueba con 0, 1, 2, etc.
engine.setProperty('voice', voces[2].id)

# Inicializamos el reconocedor de voz (esta línea estaba comentada en la primera imagen)
listener = sr.Recognizer()

# ... el resto del código irá aquí

Explicación:

  • import speech_recognition as sr: Nos permite usar la biblioteca para reconocer voz.

  • import pyttsx3 as ptts: Nos permite que el programa "hable".

  • engine = pyttsx3.init(): Inicializa el motor de texto a voz.

  • engine.setProperty('voice', voces[2].id): Selecciona una voz específica. El índice 2 es un ejemplo; puede que en tu sistema tengas que usar 0 o 1 para obtener una voz en español.

Paso 2: Crear la Función de Bienvenida

Ahora, siguiendo el video, vamos a crear una función dedicada para el saludo inicial. Esto hace el código más organizado.

python
# asistente.py

import speech_recognition as sr
import pyttsx3

# Inicializamos el motor de texto a voz
engine = pyttsx3.init()

# Obtenemos la lista de voces disponibles y seleccionamos una
voces = engine.getProperty('voices')
engine.setProperty('voice', voces[2].id) # Ajusta el índice según sea necesario

listener = sr.Recognizer()

# --- NUEVA FUNCIÓN DE BIENVENIDA ---
def bienvenida():
    """Función que hace que el asistente diga un mensaje de bienvenida."""
    mensaje = "Bienvenido de vuelta"
    engine.say(mensaje)
    engine.runAndWait()
# ------------------------------------

# ... el resto del código irá aquí

Explicación:

  • def bienvenida():: Definimos una función llamada bienvenida.

  • engine.say("Bienvenido de vuelta"): Añade el texto "Bienvenido de vuelta" a la cola de mensajes para hablar.

  • engine.runAndWait(): Procesa la cola de mensajes, es decir, "habla" el mensaje y espera a que termine para continuar con el programa.

Paso 3: Integrar la Bienvenida en el Bucle Principal

En los videos anteriores, probablemente tenías un bucle infinito (while True) que se encargaba de escuchar todo el tiempo. Ahora, vamos a llamar a la función bienvenida() antes de que ese bucle comience. De esta forma, el programa saludará una vez al iniciar y luego pasará al modo de escucha continua.

El código de la tercera y cuarta imagen muestra el bucle de escucha. Vamos a unificarlo y añadir la llamada a bienvenida().

python
# asistente.py

import speech_recognition as sr
import pyttsx3

# Inicialización
engine = pyttsx3.init()
voces = engine.getProperty('voices')
# IMPORTANTE: Asegúrate de que el índice de la voz (2) sea el correcto para español.
# Si no funciona, prueba con 0, 1, etc.
engine.setProperty('voice', voces[2].id)
listener = sr.Recognizer()

# Función de bienvenida
def bienvenida():
    engine.say("Bienvenido de vuelta")
    engine.runAndWait()

# --- EJECUCIÓN PRINCIPAL ---

# 1. DAMOS LA BIENVENIDA (solo una vez al iniciar el programa)
bienvenida()

# 2. INICIAMOS EL BUCLE DE ESCUCHA CONTINUA
while True:
    try:
        # Usamos el micrófono como fuente de audio
        with sr.Microphone() as source:
            print('Escuchando...')
            # Escuchamos hasta 5 segundos de silencio para considerar que se ha terminado de hablar
            audio = listener.listen(source, phrase_time_limit=5)

        print('Reconociendo...')
        # Enviamos el audio a Google Speech Recognition (gratuito, necesita internet)
        text = listener.recognize_google(audio, language='es-US')
        print(f"Has dicho: {text}")

        # Aquí puedes agregar la lógica para procesar el texto (comandos, preguntas, etc.)

    except Exception as e:
        # Si ocurre un error (no se entiende el audio, sin micrófono, etc.), lo manejamos
        print('No pude entenderlo bien, repítelo por favor.')
        # Podemos imprimir el error específico para depuración (opcional)
        # print(e)

Explicación del código completo:

  1. Importaciones y Configuración: Importamos las librerías y configuramos la voz y el reconocedor.

  2. Definición de la función bienvenida(): Como en el paso 2.

  3. bienvenida(): Llamamos a la función inmediatamente después de su definición. Esto hace que el programa hable nada más empezar.

  4. while True: Este es el bucle infinito que mantiene el programa corriendo y escuchando.

    • with sr.Microphone() as source: Abre el micrófono como fuente de audio.

    • print('Escuchando...'): Muestra un mensaje en la consola.

    • audio = listener.listen(source, phrase_time_limit=5): Escucha y guarda el audio. Deja de escuchar después de 5 segundos de silencio.

    • text = listener.recognize_google(audio, language='es-US'): Envía el audio a Google y recibe el texto transcrito en español de Estados Unidos (útil para acentos latinos). Requiere conexión a internet.

    • print(f"Has dicho: {text}"): Muestra el texto reconocido.

    • except Exception as e: Si algo sale mal (no se entiende la voz, no hay micrófono, etc.), se ejecuta este bloque y mostramos un mensaje de error amigable.

Paso 4: ¡Ejecutar y Probar!

Guarda el archivo asistente.py y ejecútalo desde tu terminal:

bash
python asistente.py

Escucharás la bienvenida "Bienvenido de vuelta". Inmediatamente después, la consola mostrará "Escuchando...". Puedes hablar y verás cómo tu voz se transcribe en la consola. Si no te entiende, te pedirá que lo repitas.

¡Felicidades! Has creado un asistente de voz que ahora te da una calurosa bienvenida. Este es un gran paso para hacerlo más interactivo y personal. En los próximos videos, podrás empezar a añadir comandos para que realice acciones específicas.

12. Función Bienvenida - El Primer Saludo de tu Asistente

Explicación para principiantes:
Ahora vamos a crear la primera impresión que tu asistente dará. Una función de bienvenida es como el "¡Hola!" que dice un recepcionista cuando entras a un lugar. Es amigable, personal y establece el tono para toda la interacción.

Objetivo de esta lección:

  • Crear una función reutilizable para saludos

  • Entender por qué usar funciones en programación

  • Personalizar el mensaje de bienvenida

  • Integrar la bienvenida con otras funcionalidades

Analogía:
Imagina que tu asistente es un anfitrión en una fiesta:

  • Sin función: Cada vez que llega un invitado, tienes que recordar y repetir todo el saludo

  • Con función: Tienes un saludo preparado que solo necesitas "llamar" cuando llega alguien

🧩 ¿Qué es una Función y Por Qué Usarla?

Problema sin funciones:

python

# ❌ CÓDIGO REPETITIVO E INEFICIENTE

print("Bienvenido de vuelta")

engine.say("Bienvenido de vuelta")

engine.runAndWait()


# Más tarde en el código...

print("Bienvenido de vuelta")  # ¡Otra vez lo mismo!

engine.say("Bienvenido de vuelta")

engine.runAndWait()


# Y otra vez más...

print("Bienvenido de vuelta")  # ¡Se repite otra vez!

engine.say("Bienvenido de vuelta")

engine.runAndWait()

Solución con funciones:

python

# ✅ FUNCIÓN REUTILIZABLE

def bienvenida():

    print("Bienvenido de vuelta")

    engine.say("Bienvenido de vuelta")

    engine.runAndWait()


# Usar la función cuando sea necesario

bienvenida()  # Primera vez

bienvenida()  # Segunda vez (sin repetir código)

bienvenida()  # Tercera vez (el mismo código funciona)

Beneficios de usar funciones:

  1. 🚀 Eficiencia: Escribes una vez, usas muchas veces

  2. 🔧 Mantenimiento: Cambias en un solo lugar

  3. 🧠 Claridad: El código es más fácil de entender

  4. 🔄 Reutilización: Puedes usar la misma función en diferentes programas

🎯 Paso 1: Crear tu Primera Función de Bienvenida

Versión básica:

python

import pyttsx3


# Inicializar motor de voz

engine = pyttsx3.init()


def bienvenida_basica():

    """Función simple de bienvenida"""

    print("¡Bienvenido!")

    engine.say("¡Bienvenido!")

    engine.runAndWait()


# Llamar a la función

bienvenida_basica()

Versión mejorada con parámetros:

python

import pyttsx3


engine = pyttsx3.init()


def bienvenida_personalizada(nombre_usuario="amigo"):

    """Bienvenida que incluye el nombre del usuario"""

    mensaje = f"¡Bienvenido de vuelta, {nombre_usuario}!"

    

    print(mensaje)

    engine.say(mensaje)

    engine.runAndWait()


# Diferentes formas de usar la función

bienvenida_personalizada()  # Usa valor por defecto: "¡Bienvenido de vuelta, amigo!"

bienvenida_personalizada("Carlos")  # Personalizado: "¡Bienvenido de vuelta, Carlos!"

bienvenida_personalizada("Ana")  # Personalizado: "¡Bienvenido de vuelta, Ana!"

Te ayudo a convertir las imágenes en código funcional y crear un tutorial explicativo. Primero, unificaré todo el código en un programa completo y funcional:

Código Completo

python
# Importar las librerías necesarias
import speech_recognition as sr
import pyttsx3

# Inicializar el reconocedor de voz
listener = sr.Recognizer()

# Inicializar el motor de texto a voz
engine = pyttsx3.init()

# Configurar la voz (opcional - selecciona el índice que prefieras)
voces = engine.getProperty('voices')
engine.setProperty('voice', voces[2].id)  # Cambia el índice según tu preferencia

def bienvenida():
    """Función para dar un mensaje de bienvenida por voz"""
    engine.say("Bienvenido de vuelta.")
    engine.runAndWait()

# Llamar a la función de bienvenida
bienvenida()

# Bucle principal del programa
while True:
    try:
        # Escuchar a través del micrófono
        with sr.Microphone() as source:
            print('Escuchando...')
            audio = listener.listen(source, phrase_time_limit=5)
        
        print('Reconociendo...')
        # Reconocer el audio usando Google Speech Recognition
        text = listener.recognize_google(audio, language='es-US')
        print(f"Texto reconocido: {text}")
        
        # Aquí puedes agregar lógica para responder basada en el texto
        if "hola" in text.lower():
            engine.say("Hola, ¿cómo estás?")
            engine.runAndWait()
            
    except sr.UnknownValueError:
        print('No pude entenderlo bien, repítelo por favor')
    except sr.RequestError as e:
        print(f"Error con el servicio de reconocimiento: {e}")
    except Exception as e:
        print(f'Error inesperado: {e}')

Tutorial Explicativo

Paso 1: Instalación de dependencias

Antes de ejecutar el código, necesitas instalar las librerías requeridas:

bash
pip install speechrecognition pyttsx3 pyaudio

Nota para Windows: Si tienes problemas instalando PyAudio, puedes usar:

bash
pip install pipwin
pipwin install pyaudio

Paso 2: Explicación del código por secciones

Importaciones y configuración inicial

python
import speech_recognition as sr
import pyttsx3

  • speech_recognition: Permite capturar audio y convertirlo a texto

  • pyttsx3: Convierte texto a voz (síntesis de voz)

python
listener = sr.Recognizer()

  • Crea un objeto que se encargará de "escuchar" y reconocer el audio

python
engine = pyttsx3.init()
voces = engine.getProperty('voices')
engine.setProperty('voice', voces[2].id)

  • Inicializa el motor de texto a voz

  • Obtiene las voces disponibles en el sistema

  • Selecciona una voz específica (índice 2 - normalmente voz femenina en español)

Función de bienvenida

python
def bienvenida():
    engine.say("Bienvenido de vuelta.")
    engine.runAndWait()

  • engine.say(): Añade texto a la cola de reproducción

  • engine.runAndWait(): Reproduce el texto y espera a que termine

Bucle principal

python
while True:
    with sr.Microphone() as source:
        print('Escuchando...')
        audio = listener.listen(source, phrase_time_limit=5)

  • sr.Microphone(): Accede al micrófono del sistema

  • phrase_time_limit=5: Limita la grabación a 5 segundos máximo

python
text = listener.recognize_google(audio, language='es-US')

  • Envía el audio a Google Speech Recognition

  • language='es-US': Especifica que el audio está en español (latinoamericano)

Paso 3: Mejoras y personalizaciones

Puedes expandir el código con funcionalidades adicionales:

python
# Diccionario de comandos
comandos = {
    "hola": "¡Hola! ¿En qué puedo ayudarte?",
    "adiós": "Hasta luego, ¡que tengas un buen día!",
    "hora": "Lo siento, aún no sé decir la hora"
}

while True:
    try:
        with sr.Microphone() as source:
            print('Escuchando...')
            audio = listener.listen(source, phrase_time_limit=5)
        
        text = listener.recognize_google(audio, language='es-US')
        print(f"Tú: {text}")
        
        # Buscar respuesta en el diccionario
        respuesta = None
        for comando in comandos:
            if comando in text.lower():
                respuesta = comandos[comando]
                break
        
        if respuesta:
            engine.say(respuesta)
            engine.runAndWait()
        else:
            print("Comando no reconocido")
            
    except Exception as e:
        print("Error:", e)

Paso 4: Solución de problemas comunes

  1. Error de micrófono: Verifica que tu micrófono esté conectado y funcionando

  2. Voces no disponibles: Cambia el índice de voz (prueba con 0, 1, etc.)

  3. Problemas de conexión: El reconocimiento de Google requiere internet

Paso 5: Ejecución del programa

  1. Guarda el código en un archivo asistente_voz.py

  2. Ejecuta en terminal: python asistente_voz.py

  3. Habla claramente cerca del micrófono

  4. El programa reconocerá tu voz y responderá


🌟 Paso 2: Bienvenida Inteligente Basada en la Hora

python

import pyttsx3

import datetime


engine = pyttsx3.init()


def bienvenida_inteligente(nombre="amigo"):

    """Saluda diferente según la hora del día"""

    

    # Obtener hora actual

    hora_actual = datetime.datetime.now().hour

    

    # Determinar saludo según la hora

    if 5 <= hora_actual < 12:

        saludo = f"¡Buenos días, {nombre}!"

    elif 12 <= hora_actual < 19:

        saludo = f"¡Buenas tardes, {nombre}!"

    else:

        saludo = f"¡Buenas noches, {nombre}!"

    

    # Mensaje completo

    mensaje = f"{saludo} Es un placer verte de nuevo. ¿En qué puedo ayudarte hoy?"

    

    print(mensaje)

    engine.say(mensaje)

    engine.runAndWait()


# Probar en diferentes momentos del día

bienvenida_inteligente("María")

Visualización de cómo funciona:

text

Hora actual: 9:00 AM → "¡Buenos días, María!"

Hora actual: 3:00 PM → "¡Buenas tardes, María!"

Hora actual: 9:00 PM → "¡Buenas noches, María!"

🎨 Paso 3: Bienvenida con Animación Visual

python

import pyttsx3

import time


engine = pyttsx3.init()


def bienvenida_con_estilo(nombre="usuario"):

    """Bienvenida con efectos visuales y auditivos"""

    

    print("\n" + "=" * 50)

    print(" " * 15 + "🤖 ASISTENTE VIRTUAL")

    print("=" * 50)

    

    # Animación de carga

    print("\nIniciando...", end="", flush=True)

    for _ in range(3):

        print(".", end="", flush=True)

        time.sleep(0.3)

    print(" ✅\n")

    

    # Mensaje principal

    mensaje_principal = f"¡Hola, {nombre}! Soy tu asistente virtual."

    

    # Efecto de escritura

    for letra in mensaje_principal:

        print(letra, end="", flush=True)

        time.sleep(0.02)

    print()

    

    # Decir el mensaje

    engine.say(mensaje_principal)

    engine.runAndWait()

    

    # Mensaje adicional

    time.sleep(0.5)

    print("\n💡 Puedo ayudarte con:")

    print("   • Decir la hora y fecha")

    print("   • Buscar información en internet")

    print("   • Realizar cálculos matemáticos")

    print("   • Y mucho más...")

    

    engine.say("Estoy listo para ayudarte. ¿Qué necesitas?")

    engine.runAndWait()


# Probar la bienvenida con estilo

bienvenida_con_estilo("Alex")

Salida visual:

text

==================================================

               🤖 ASISTENTE VIRTUAL

==================================================


Iniciando... ✅


¡Hola, Alex! Soy tu asistente virtual.


💡 Puedo ayudarte con:

   • Decir la hora y fecha

   • Buscar información en internet

   • Realizar cálculos matemáticos

   • Y mucho más...

🔧 Paso 4: Integrar la Función Bienvenida en tu Asistente Completo

Estructura organizada del asistente:

python

"""

ASISTENTE VIRTUAL COMPLETO CON BIENVENIDA

Estructura modular y organizada

"""


import pyttsx3

import speech_recognition as sr

import datetime


class AsistenteVirtual:

    def __init__(self, nombre_asistente="Alex"):

        self.nombre = nombre_asistente

        self.engine = pyttsx3.init()

        self.listener = sr.Recognizer()

        

        # Configurar voz

        self.configurar_voz()

    

    def configurar_voz(self):

        """Configura la voz del asistente"""

        # Buscar voz en español

        voces = self.engine.getProperty('voices')

        for voz in voces:

            if voz.languages and any('es' in lang.lower() for lang in voz.languages):

                self.engine.setProperty('voice', voz.id)

                break

        

        # Ajustes de voz

        self.engine.setProperty('rate', 180)    # Velocidad normal

        self.engine.setProperty('volume', 0.9)  # Volumen alto

    

    def bienvenida(self):

        """Función de bienvenida principal"""

        hora_actual = datetime.datetime.now().hour

        

        # Saludo según hora

        if 5 <= hora_actual < 12:

            saludo = "Buenos días"

        elif 12 <= hora_actual < 19:

            saludo = "Buenas tardes"

        else:

            saludo = "Buenas noches"

        

        mensaje = f"{saludo}. Soy {self.nombre}, tu asistente virtual. ¿En qué puedo ayudarte?"

        

        print(f"🤖 {self.nombre}: {mensaje}")

        self.engine.say(mensaje)

        self.engine.runAndWait()

    

    def escuchar(self):

        """Escucha comandos de voz"""

        try:

            with sr.Microphone() as source:

                print("🎤 Escuchando...")

                audio = self.listener.listen(source, phrase_time_limit=5)

                

                texto = self.listener.recognize_google(audio, language='es-ES')

                texto = texto.lower()

                

                print(f"👤 Tú: {texto}")

                return texto

        except:

            return ""

    

    def procesar_comando(self, comando):

        """Procesa los comandos recibidos"""

        if 'hora' in comando:

            self.decir_hora()

        elif 'fecha' in comando:

            self.decir_fecha()

        elif 'gracias' in comando:

            self.agradecer()

        elif 'adiós' in comando or 'salir' in comando:

            self.despedida()

            return False  # Indicar que hay que terminar

        else:

            self.respuesta_generica()

        

        return True  # Continuar ejecución

    

    def decir_hora(self):

        """Dice la hora actual"""

        hora = datetime.datetime.now().strftime("%H:%M")

        mensaje = f"Son las {hora}"

        

        print(f"🤖 {self.nombre}: {mensaje}")

        self.engine.say(mensaje)

        self.runAndWait()

    

    def decir_fecha(self):

        """Dice la fecha actual"""

        fecha = datetime.datetime.now().strftime("%d de %B de %Y")

        mensaje = f"Hoy es {fecha}"

        

        print(f"🤖 {self.nombre}: {mensaje}")

        self.engine.say(mensaje)

        self.runAndWait()

    

    def agradecer(self):

        """Responde a un agradecimiento"""

        mensaje = "De nada, es un placer ayudarte"

        

        print(f"🤖 {self.nombre}: {mensaje}")

        self.engine.say(mensaje)

        self.runAndWait()

    

    def despedida(self):

        """Función de despedida"""

        mensaje = "Hasta luego, que tengas un excelente día"

        

        print(f"🤖 {self.nombre}: {mensaje}")

        self.engine.say(mensaje)

        self.runAndWait()

    

    def respuesta_generica(self):

        """Respuesta cuando no entiende el comando"""

        mensaje = "No entendí ese comando. Puedo ayudarte con: hora, fecha, o puedes despedirte diciendo adiós"

        

        print(f"🤖 {self.nombre}: {mensaje}")

        self.engine.say(mensaje)

        self.runAndWait()

    

    def runAndWait(self):

        """Wrapper para engine.runAndWait()"""

        self.engine.runAndWait()

    

    def ejecutar(self):

        """Función principal que ejecuta el asistente"""

        # 1. Bienvenida

        self.bienvenida()

        

        # 2. Bucle principal de escucha

        while True:

            # 3. Escuchar comando

            comando = self.escuchar()

            

            if comando:

                # 4. Procesar comando

                continuar = self.procesar_comando(comando)

                

                # 5. Verificar si hay que terminar

                if not continuar:

                    break


# Crear y ejecutar el asistente

if __name__ == "__main__":

    mi_asistente = AsistenteVirtual(nombre_asistente="Jarvis")

    mi_asistente.ejecutar()

🚀 Paso 5: Mejoras Creativas para la Bienvenida

Bienvenida con humor:

python

def bienvenida_divertida():

    """Bienvenida con toques de humor"""

    import random

    

    chistes_bienvenida = [

        "¡Hola! Soy tu asistente, pero no me pidas que te haga la tarea... aún.",

        "¡Bienvenido de vuelta! Yo también extrañaba tener a alguien a quien dar órdenes.",

        "¡Hola humano! No te preocupes, no soy Skynet... todavía.",

        "¡Saludos! Estaba aburrido esperándote. ¿Trajiste café?",

        "¡Hola! Prometo no volverme loco como HAL 9000."

    ]

    

    chiste = random.choice(chistes_bienvenida)

    

    print(f"🤖: {chiste}")

    engine.say(chiste)

    engine.runAndWait()

Bienvenida para diferentes días de la semana:

python

def bienvenida_segun_dia():

    """Bienvenida que cambia según el día de la semana"""

    import datetime

    

    dias_semana = {

        0: "Lunes",

        1: "Martes", 

        2: "Miércoles",

        3: "Jueves",

        4: "Viernes",

        5: "Sábado",

        6: "Domingo"

    }

    

    hoy = datetime.datetime.now().weekday()

    nombre_dia = dias_semana[hoy]

    

    mensajes = {

        "Lunes": "¡Ánimo con el inicio de semana! ¿En qué puedo ayudarte?",

        "Martes": "¡Buen martes! El mejor día para ser productivo.",

        "Miércoles": "¡Ya es miércoles! Mitad de semana alcanzada.",

        "Jueves": "¡Casi viernes! ¿Qué planes tienes para el fin de semana?",

        "Viernes": "¡Por fin viernes! ¿Listo para descansar?",

        "Sábado": "¡Feliz sábado! Día perfecto para relajarse.",

        "Domingo": "¡Domingo! Último día para cargar energías."

    }

    

    mensaje = f"Hoy es {nombre_dia}. {mensajes[nombre_dia]}"

    

    print(f"📅: {mensaje}")

    engine.say(mensaje)

    engine.runAndWait()

Bienvenida con nombre guardado:

python

def bienvenida_con_memoria():

    """Bienvenida que recuerda el nombre del usuario"""

    import json

    import os

    

    # Archivo para guardar datos

    ARCHIVO_DATOS = "datos_usuario.json"

    

    # Cargar datos existentes

    if os.path.exists(ARCHIVO_DATOS):

        with open(ARCHIVO_DATOS, 'r') as f:

            datos = json.load(f)

        nombre = datos.get("nombre", "amigo")

        visitas = datos.get("visitas", 0) + 1

    else:

        nombre = input("👤 ¿Cuál es tu nombre? ")

        visitas = 1

    

    # Guardar datos actualizados

    datos_actualizados = {

        "nombre": nombre,

        "visitas": visitas,

        "ultima_visita": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    }

    

    with open(ARCHIVO_DATOS, 'w') as f:

        json.dump(datos_actualizados, f, indent=2)

    

    # Mensaje personalizado

    if visitas == 1:

        mensaje = f"¡Hola {nombre}! Es la primera vez que nos vemos. ¡Encantado de conocerte!"

    else:

        mensaje = f"¡Bienvenido de vuelta, {nombre}! Esta es tu visita número {visitas}. ¿Cómo has estado?"

    

    print(f"🤖: {mensaje}")

    engine.say(mensaje)

    engine.runAndWait()

    

    return nombre

📊 Diagrama de Flujo de la Función Bienvenida

text

┌─────────────────────────────────────────────┐

│       EJECUCIÓN DEL PROGRAMA                │

├─────────────────────────────────────────────┤

│ 1. Inicializar motor de voz (pyttsx3)      │

│ 2. Configurar voz (español, velocidad, etc)│

├─────────────────────────────────────────────┤

│          LLAMAR A FUNCIÓN BIENVENIDA       │

├─────────────────────────────────────────────┤

│ 3. Obtener hora actual                     │

│    ↓                                        │

│ 4. Determinar saludo según hora:           │

│    • Mañana → "Buenos días"                │

│    • Tarde → "Buenas tardes"               │

│    • Noche → "Buenas noches"               │

│    ↓                                        │

│ 5. Construir mensaje completo:             │

│    "Saludo + Nombre + Mensaje ayuda"       │

│    ↓                                        │

│ 6. Imprimir mensaje en consola             │

│    ↓                                        │

│ 7. Decir mensaje por voz                   │

│    ↓                                        │

│ 8. engine.runAndWait() → Esperar a terminar│

└─────────────────────────────────────────────┘

🎮 Ejercicios Prácticos

Ejercicio 1: Bienvenida con Emojis

python

def bienvenida_con_emojis():

    """Crea una bienvenida con emojis visuales"""

    emojis = ["🤖", "👋", "🌟", "✨", "🚀", "💫", "🎯", "💡"]

    

    # Tu código aquí: Crear una bienvenida que use al menos 3 emojis diferentes

    # Pista: Puedes usar print() con emojis y engine.say() sin emojis

Ejercicio 2: Bienvenida Bilingüe

python

def bienvenida_bilingue(idioma='es'):

    """Bienvenida en diferentes idiomas"""

    mensajes = {

        'es': "¡Hola! Bienvenido a tu asistente virtual",

        'en': "Hello! Welcome to your virtual assistant", 

        'fr': "Bonjour! Bienvenue à votre assistant virtuel",

        'pt': "Olá! Bem-vindo ao seu assistente virtual"

    }

    

    # Tu código aquí: Seleccionar mensaje según idioma y mostrarlo

Ejercicio 3: Bienvenida con Estado de Ánimo

python

def bienvenida_con_animacion():

    """Pregunta el estado de ánimo y responde acorde"""

    estados = {

        'feliz': "¡Me alegra que estés feliz! Vamos a hacer algo divertido",

        'triste': "Lamento que estés triste. ¿Puedo contarte un chiste?",

        'cansado': "Entiendo que estés cansado. ¿Te ayudo con algo sencillo?",

        'emocionado': "¡Yo también me emociono! ¿Qué te gustaría hacer?"

    }

    

    # Tu código aquí: Preguntar estado y responder adecuadamente

📋 Checklist de una Buena Función Bienvenida

Una función de bienvenida ideal debería:

  • ✅ Saludar amablemente al usuario

  • ✅ Identificarse (nombre del asistente)

  • ✅ Ser contextual (hora del día, día de semana)

  • ✅ Ser personalizable (aceptar nombre de usuario)

  • ✅ Ser informativa (decir qué puede hacer el asistente)

  • ✅ Tener buen timing (pausas adecuadas)

  • ✅ Ser reutilizable (funcionar en diferentes contextos)

  • ✅ Tener manejo de errores (por si algo falla)

❓ Cuestionario de Repaso

Pregunta 1:

¿Cuál es el principal beneficio de crear una función bienvenida() en lugar de escribir el código directamente?

  • A) Hace que el programa sea más lento

  • B) Permite reutilizar el código sin repetirlo

  • C) Obliga al usuario a dar su nombre

  • D) Hace que la voz suene mejor

Respuesta correcta: B
Explicación: Las funciones permiten escribir código una vez y usarlo muchas veces, evitando repeticiones y haciendo el programa más fácil de mantener.

Pregunta 2:

En la función bienvenida_inteligente(), ¿qué hace datetime.datetime.now().hour?

  • A) Obtiene los minutos actuales

  • B) Obtiene la hora actual (0-23)

  • C) Obtiene el día del mes

  • D) Obtiene el año actual

Respuesta correcta: B
Explicación: .now().hour devuelve la hora actual como un número entre 0 y 23, lo que permite adaptar el saludo a la hora del día.

Pregunta 3:

Si quieres que tu función bienvenida() acepte el nombre del usuario como parámetro, ¿cómo la definirías?

  • A) def bienvenida():

  • B) def bienvenida(nombre_usuario):

  • C) def bienvenida print(nombre):

  • D) def bienvenida = nombre:

Respuesta correcta: B
Explicación: Los parámetros van entre paréntesis después del nombre de la función. def bienvenida(nombre_usuario): crea una función que acepta un parámetro llamado nombre_usuario.

Pregunta 4:

¿Qué hace engine.runAndWait() después de engine.say()?

  • A) Aumenta el volumen

  • B) Espera a que termine de hablar antes de continuar

  • C) Cambia la velocidad del habla

  • D) Reinicia el motor de voz

Respuesta correcta: B
Explicación: runAndWait() procesa todos los textos en cola y espera a que termine de hablar antes de ejecutar la siguiente línea de código.

Pregunta 5:

¿Por qué es útil tener una bienvenida que cambie según la hora del día?

  • A) Hace el código más complicado

  • B) Hace que el asistente parezca más inteligente y atento

  • C) Obliga al usuario a mirar el reloj

  • D) Aumenta la velocidad del programa

Respuesta correcta: B
Explicación: Un saludo contextual (buenos días/tardes/noches) hace que la interacción sea más natural y personal, mejorando la experiencia del usuario.

Pregunta 6 (Bonus):

En la estructura del asistente completo, ¿qué patrón sigue el método ejecutar()?

  • A) Patrón de bucle infinito con salida condicional

  • B) Patrón de ejecución única

  • C) Patrón recursivo

  • D) Patrón aleatorio

Respuesta correcta: A
Explicación: Usa while True: para crear un bucle infinito que solo se rompe cuando el usuario dice "adiós", lo cual es un patrón común en aplicaciones interactivas.

🌟 ¡Tu Asistente Ahora es Cordial y Profesional!

Has aprendido a crear una función de bienvenida que:

  1. ✅ Saluda amablemente al usuario

  2. ✅ Se adapta al contexto (hora del día)

  3. ✅ Es personalizable (acepta nombres)

  4. ✅ Es reutilizable (se puede llamar múltiples veces)

  5. ✅ Se integra perfectamente con el resto del asistente

Proyecto sugerido: Crea un asistente con diferentes perfiles de bienvenida:

  • Modo formal: Para uso profesional

  • Modo casual: Para uso personal

  • Modo divertido: Con chistes y emojis

  • Modo minimalista: Solo lo esencial

📌 Tarea práctica:

  1. Crea 3 versiones diferentes de la función bienvenida()

  2. Haz que el usuario pueda elegir cuál usar

  3. Añade un efecto sorpresa (como un sonido o animación)

  4. Comparte tu mejor bienvenida en los comentarios

🎉 ¡Tu asistente ya tiene personalidad y calidez!
En la próxima lección, crearemos la función hablar() que hará que tu asistente pueda comunicarse fluidamente en cualquier situación.

https://www.youtube.com/watch?v=Pj9KbAKpQyk

https://www.youtube.com/watch?v=-0tIy8wWtzE

https://www.youtube.com/watch?v=YqSSId7xfwU

https://www.youtube.com/watch?v=MjK-j7YJ5YI


https://www.youtube.com/watch?v=l2G8-iQYfoA



https://www.youtube.com/watch?v=t-YO0XeHczU

Comentarios

Publicar un comentario

Entradas más populares de este blog

1-7. Transforma tu audio a texto

https://docs.google.com/presentation/d/e/2PACX-1vQALlzBy_iPdW3SCPiIx-glkhsG4OKexjhqrRvQd8mGPiAfMWyRU8Vde9T7ygB-MWr30o6EJ5Ubpaiy/pub?start=true&loop=false&delayms=3000   7. Transforma tu Audio a Texto - Los "Oídos" de tu Asistente Explicación para principiantes: En esta lección vamos a crear la parte más mágica de nuestro asistente: convertir tu voz en texto que Python pueda entender. Es como enseñarle a tu computadora a escuchar y tomar notas de lo que dices. ¡Es el primer paso para una conversación real con tu asistente! Objetivo de esta lección: Configurar el reconocimiento de voz Capturar audio del micrófono Convertir audio en texto Manejar errores comunes Analogía: Piensa en esto como enseñarle a un amigo extranjero a entender español: Tu voz = Sonidos en español speech_recognition = Amigo que está aprendiendo Texto = Lo que tu amigo escribe después de entenderte 📦 Paso 3: Instalar la Librería de Reconocimiento de Voz ¿Qué es speech_recognition ? Es una librería...
Leer más

10. Haz que tu asistente hable

 https://docs.google.com/presentation/d/e/2PACX-1vTHAFRd6DI8h9_5SuA-ScwG28zy0CM7BxtMoks6vtUlj4v53h6xvaoB_oO7_ZducNACQ5FBXU6xzE74/pub?start=false&loop=false&delayms=3000 10. Haz que tu Asistente Hable - La "Boca" de tu Asistente Explicación para principiantes: ¡Es momento de darle voz a tu asistente! En esta lección vamos a transformar el texto en voz hablada. Imagina que hasta ahora tu asistente era como una persona sorda que solo podía leer lo que escribías. Ahora le vamos a dar la capacidad de responderte hablando, como Siri o Alexa. Objetivo de esta lección: Instalar y configurar pyttsx3 (motor de texto a voz) Hacer que el asistente diga cualquier texto Entender el flujo básico de síntesis de voz Prepararse para personalizar la voz Analogía: pyttsx3 es como un sintetizador vocal o un cantante robótico. Tú le das la letra (texto) y él la canta (habla) usando diferentes voces y estilos. 📦 Paso 1: Instalar la Librería pyttsx3 ¿Qué es pyttsx3? Es una librería Python ...
Leer más

8. NUEVO - Solución si tu micrófono no está captando tu audio

  https://docs.google.com/presentation/d/e/2PACX-1vQmcGg0EfbCv-ZVuqeEl7TLPKuaVyK6KsgHqpSRqeLTZ-mUFV8JlQ6a5pbH2WbLBGcXinzLTTBSKvPb/pub?start=false&loop=false&delayms=3000  8. NUEVO - Solución si tu Micrófono no Capta tu Audio Explicación para principiantes: Si tu asistente dice constantemente "No pude entenderlo bien" pero tú SÍ estás hablando, el problema está en la conexión entre tu voz y Python. Imagina que tu micrófono es un teléfono y Python es un amigo al otro lado de la línea. Si el teléfono está roto o mal configurado, tu amigo no te escuchará, ¡aunque tú estés gritando! Objetivo de esta lección: Diagnosticar problemas de captura de audio Configurar correctamente el micrófono en Windows Identificar programas que interfieren Probar soluciones paso a paso Estado actual del problema: python while True :      print ( 'Escuchando...' )   # ✅ Esto sí aparece     audio = listener . listen ( source )   # ⚠️ Aquí está e...
Leer más