E.M1Untitled-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluación - Lola Martorell Baños\n",
    "*MÓDULO 1 - PHYTON* "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Tres estructuras principales con las que vamos a trabajar:\n",
    "\n",
    "     - 'inventario' (lista de diccionarios): Una estructura para almacenar los productos en el inventario.\n",
    "     - 'clientes' (diccionario): Una estructura para llevar un registro de los clientes de la tienda.\n",
    "     - 'ventas_totales' (float): Una variable para llevar un registro de las ventas totales de la tienda."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Empezamos definiendo qué son los diccionarios ---> Los diccionarios en Python son estructuras de datos que permiten almacenar y organizar información en pares clave - valor. Cada elemento en un diccionario está compuesto por una clave única y su respectivo valor asociado. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ¿Cómo debemos actuar con ellas? \n",
    "\n",
    "Vamos a ir separándolas por puntos para una mayor explicación:\n",
    "\n",
    "     - 'INVENTARIO'\n",
    "\n",
    "     Cada producto debe ser representado como un diccionario con las siguientes claves: 'nombre', 'precio' y 'cantidad'.  Al principio deberá ser una lista vacía."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creamos una lista vacía para comenzar a trabajar en ella: \n",
    "\n",
    "inventario = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "      - 'CLIENTES' \n",
    "\n",
    "      Cada cliente debe ser representado como un diccionario con las siguientes claves: 'nombre' y 'email'. Al inicio deberá ser un diccionario vacío. Además, cada cliente debe tener un historial de compras."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creamos lista de clientes:\n",
    "\n",
    "clientes = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "      - 'VENTAS_TOTALES'\n",
    "      \n",
    "       Una variable para llevar un registro de las ventas totales de la tienda. Inicializándolo con valor 0.\n",
    "       \n",
    "\n",
    "¿Pero qué es una variable? ---> Las variables son contenedores para almacenar datos. Nos permiten realizar cálculos, realizar seguimiento de resultados y organizar nuestros datos de manera eficiente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "ventas_totales = 0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una vez tenemos nuestras estructuras claras, comenzamos a trabajar con ellas: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. `agregar_producto(nombre, precio, cantidad)`: Esta función agrega un producto al inventario o actualiza su cantidad si ya existe. Debe recibir el nombre, precio y cantidad del producto como parámetros.\n",
    "- Itera a través del inventario y compara los nombres de los productos con el nombre proporcionado.\n",
    "- Si el producto ya existe, actualiza la cantidad.\n",
    "- Si no existe, agrega un nuevo producto al inventario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "def agregar_productos(nombre, precio, cantidad):\n",
    "\n",
    "# verificamos si el producto existe \n",
    "    producto_existe = False\n",
    "\n",
    "# verificamos si el producto ya está en el inventario\n",
    "    for producto in inventario:\n",
    "        if producto ['nombre'] == nombre:\n",
    "            print ('Este producto ya existe, actualizaremos la cantidad')\n",
    "            producto['cantidad'] += cantidad\n",
    "            producto_existe = True\n",
    "            break\n",
    "\n",
    "# si el producto no existe, se agrega a inventario        \n",
    "    if not producto_existe:\n",
    "        nuevo_productos = {\n",
    "                'nombre' : nombre,\n",
    "                'precio' : precio,\n",
    "                'cantidad' : cantidad\n",
    "            }\n",
    "        inventario.append(nuevo_productos)\n",
    "        print('producto agregado al inventario')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "producto agregado al inventario\n",
      "producto agregado al inventario\n"
     ]
    }
   ],
   "source": [
    "# probamos codigo\n",
    "agregar_productos('vestido', 40 , 25)\n",
    "agregar_productos('jersey', 35 , 15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "def agregar_producto(nombre, precio, cantidad):\n",
    "    for producto in inventario:\n",
    "        if producto ['nombre'] == nombre: \n",
    "            producto ['cantidad'] += cantidad\n",
    "            return\n",
    "        \n",
    "nuevo_producto = {'nombre' : 'pantalon', 'precio': 35, 'cantidad': 22}\n",
    "inventario.append(nuevo_producto)\n",
    "     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nombre': 'pantalon', 'precio': 35, 'cantidad': 22}\n"
     ]
    }
   ],
   "source": [
    "print(nuevo_producto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. `ver_inventario()`: Muestra el inventario de productos con sus detalles.\n",
    "- Utiliza un bucle `for` para recorrer el inventario.\n",
    "- Imprime los detalles (nombre, precio, cantidad) de cada producto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ver_inventario():\n",
    "    for producto in inventario:\n",
    "        print(f\"'nombre':{producto['nombre']}, 'precio': ${producto['precio']}, 'cantidad': {producto['cantidad']}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ver_inventario():\n",
    "    if not inventario:\n",
    "        print(\"el diccionario está vacío\")\n",
    "    else:\n",
    "        for producto in inventario:\n",
    "            print(f\"nombre: {producto['nombre']}, Precio: ${producto['precio']}, Cantidad: {producto['cantidad']}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nombre: vestido, Precio: $40, Cantidad: 25\n",
      "nombre: jersey, Precio: $35, Cantidad: 15\n",
      "nombre: pantalon, Precio: $35, Cantidad: 22\n"
     ]
    }
   ],
   "source": [
    "ver_inventario()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. `buscar_producto(nombre)`: Busca un producto en el inventario por nombre y muestra sus detalles si se encuentra. Debe recibir el nombre del producto\n",
    "como parámetro.\n",
    "- Utiliza un bucle `for` para recorrer el inventario.\n",
    "- Compara los nombres de los productos con el nombre proporcionado.\n",
    "- Si se encuentra el producto, imprime sus detalles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creamos función para buscar un producto en el inventario:\n",
    "\n",
    "def buscar_producto(nombre):\n",
    "\n",
    "    for producto in inventario:\n",
    "        if producto['nombre'] == nombre:\n",
    "            print(f\"Nombre: {producto['nombre']}, Precio: ${producto['precio']}, Cantidad: {producto['Cantidad']}\")\n",
    "            break\n",
    "        else:\n",
    "            print(\"No hay ningún producto 'nombre', en el inventario\")\n",
    "            break\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nombre: vestido, Precio: $40, Cantidad: 25\n"
     ]
    }
   ],
   "source": [
    "buscar_producto('vestido')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No hay ningún producto 'nombre', en el inventario\n"
     ]
    }
   ],
   "source": [
    "buscar_producto('camisa')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. `actualizar_stock(nombre, cantidad)`: Actualiza el stock de un producto en el inventario. Debe recibir el nombre del producto y la cantidad a agregar o quitar como parámetros.\n",
    "- Utiliza un bucle `for` para recorrer el inventario.\n",
    "- Busca el producto por nombre.\n",
    "- Actualiza la cantidad según la entrada del usuario.\n",
    "- Si el producto no esta en el inventario muestra un mensaje indicándolo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "def actualizar_stock(vestido, cantidad):\n",
    "    for producto in inventario:\n",
    "        if producto['nombre'] == vestido:\n",
    "            producto['cantidad'] += 20\n",
    "            if producto['cantidad'] < 10:\n",
    "                producto['cantidad'] = 0                  #ANOTACIÓN APUNTES: No puede haber cantidad negativa\n",
    "            print(f\"Stock de {vestido} actualizado. Nueva cantidad: {producto['cantidad']}\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stock de vestido actualizado. Nueva cantidad: 45\n",
      "nombre: vestido, Precio: $40, Cantidad: 45\n",
      "nombre: jersey, Precio: $35, Cantidad: 15\n",
      "nombre: pantalon, Precio: $35, Cantidad: 22\n"
     ]
    }
   ],
   "source": [
    "actualizar_stock('vestido', 13)     \n",
    "ver_inventario()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. `eliminar_producto(nombre)`: Elimina un producto del inventario por nombre. Debe recibir el nombre del producto como parámetro.\n",
    "- Utiliza un bucle `for` para recorrer el inventario.\n",
    "- Busca el producto por nombre.\n",
    "- Elimina el producto del inventario si existe.\n",
    "- Si el producto no esta en el inventario muestra un mensaje indicándolo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eliminar_producto(vestido):\n",
    "    for prenda in inventario:\n",
    "        if prenda['nombre'] == vestido:\n",
    "            inventario.remove(prenda)\n",
    "            print(f\"Prenda {vestido} eliminado del inventario.\")\n",
    "            return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prenda vestido eliminado del inventario.\n"
     ]
    }
   ],
   "source": [
    "eliminar_producto('vestido')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. `calcular_valor_inventario()`: Calcula y muestra el valor total del inventario.\n",
    "- Utiliza un bucle for para calcular el valor total del inventario.\n",
    "- Itera a través del inventario y suma el valor de cada producto (precio x cantidad). Es decir, calcula el valor total del inventario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcular_valor_inventario():\n",
    "    valor_total = 0.0\n",
    "    for producto in inventario:\n",
    "        valor_total += producto['precio'] * producto['cantidad']\n",
    "    print(f\"El valor total del inventario es: ${valor_total}\")\n",
    "    return valor_total "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El valor total del inventario es: $1295.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1295.0"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calcular_valor_inventario()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. `realizar_compra()`: Permite a un cliente realizar una compra seleccionando productos del inventario. Debe interactuar con el cliente para seleccionar productos y calcular el costo total de la compra.\n",
    "- Utiliza un bucle `while` para permitir al cliente realizar múltiples compras.\n",
    "- Muestra el inventario y solicita al cliente ingresar el nombre del producto que desea comprar.\n",
    "- Registra los productos seleccionados en un carrito y actualiza el inventario.\n",
    "- Calcula el costo total de la compra."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "inventario = [\n",
    "    {'nombre': 'vestido', 'precio': 40, 'Cantidad': 25},\n",
    "{'nombre': 'jersey', 'precio': 35, 'Cantidad': 15},\n",
    "{'nombre': 'pantalon', 'precio': 35, 'Cantidad': 22}\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "ventas_totales = 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creamos función para mostrar el inventario:\n",
    "\n",
    "def ver_inventario():\n",
    "    print(\"inventario disponible: \")\n",
    "    for producto in inventario:\n",
    "        print(f\"Nombre: {producto['nombre']}, Precio: ${producto['precio']}, Cantidad: {producto['cantidad']}\")\n",
    "    \n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 unidades de pantalon agregadas al carrito.\n"
     ]
    }
   ],
   "source": [
    "#Función para realizar la compra\n",
    "\n",
    "def realizar_compra():\n",
    "    carrito = []\n",
    "    total_compra = 0.0\n",
    "\n",
    "    while True:\n",
    "        ver_inventario() \n",
    "        nombre_producto = input(\"introducir nombre del producto que deseas comprar o salir para finalizar\")\n",
    "\n",
    "        if nombre_producto.lower() == 'salir':\n",
    "            break\n",
    "\n",
    "nombre_producto = 'pantalon'  \n",
    "#Lo añado de forma manual porque no hay manera de que funcione con input... \n",
    "\n",
    "#Buscamos el producto en el inventario \n",
    "\n",
    "producto_encontrado = None\n",
    "for producto in inventario:\n",
    "    if producto ['nombre'].lower() == nombre_producto.lower():\n",
    "        producto_encontrado = producto\n",
    "        break\n",
    "\n",
    "if producto_encontrado:\n",
    "            cantidad_deseada = int(input(f\"¿Cuántas unidades de {nombre_producto} deseas comprar?: \"))\n",
    "\n",
    "\n",
    "# Verificamos si hay suficiente cantidad en el inventario\n",
    "total_compra = 0.0\n",
    "carrito = []\n",
    "if cantidad_deseada <= producto_encontrado['Cantidad']:\n",
    "                \n",
    "                # Agregar al carrito\n",
    "        carrito.append({\n",
    "            'nombre': producto_encontrado['nombre'],\n",
    "            'precio': producto_encontrado['precio'],\n",
    "            'cantidad': cantidad_deseada\n",
    "        })\n",
    "        total_compra += producto_encontrado['precio'] * cantidad_deseada\n",
    "            # Actualizamos el inventario\n",
    "        producto_encontrado['Cantidad'] -= cantidad_deseada\n",
    "        print(f\"{cantidad_deseada} unidades de {nombre_producto} agregadas al carrito.\")\n",
    "\n",
    "else:\n",
    "    print(f\"Lo siento, solo hay {producto_encontrado['Cantidad']} unidades de {nombre_producto} en stock.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Resumen de tu compra:\n",
      "pantalon - 20 unidades - $35 c/u\n",
      "Total a pagar: $700.0\n",
      "¡Gracias por tu compra! Ventas totales hasta ahora: $700.0\n"
     ]
    }
   ],
   "source": [
    "# Finalizar la compra y mostrar el total\n",
    "if carrito:\n",
    "    print(\"\\nResumen de tu compra:\")\n",
    "    for item in carrito:\n",
    "       print(f\"{item['nombre']} - {item['cantidad']} unidades - ${item['precio']} c/u\")\n",
    "\n",
    "    print(f\"Total a pagar: ${total_compra}\")\n",
    "            # Actualizamos las ventas totales\n",
    "    global ventas_totales\n",
    "    ventas_totales += total_compra\n",
    "    print(f\"¡Gracias por tu compra! Ventas totales hasta ahora: ${ventas_totales}\")\n",
    "else:\n",
    "    print(\"No se ha realizado ninguna compra.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# EJERCICIOS VOLUNTARIOS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. `procesar_pago()`: Procesa el pago de una compra, calcula el cambio y muestra un mensaje de confirmación.\n",
    "- Utiliza un bloque `try...except` para manejar excepciones.\n",
    "- Solicita al cliente ingresar la cantidad total y la cantidad de pago usando un input.\n",
    "- Calcula el cambio y muestra un mensaje de pago exitoso o un error en caso de monto insuficiente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Definimos la función para procesar el pago. \n",
    "\n",
    "def procesar_pago(total_compra):\n",
    "    \n",
    "    try:\n",
    "        cantidad_pago = float(input(f\"El total de la compra es ${total_compra}. Ingrese la cantidad de pago: $\"))\n",
    "        if cantidad_pago < total_compra:\n",
    "            print(\"Error: La cantidad de pago es insuficiente.\")\n",
    "        else:\n",
    "            # Calcular el cambio\n",
    "            cambio = cantidad_pago - total_compra\n",
    "            print(f\"Pago exitoso. Su cambio es: ${cambio:.2f}. ¡Gracias por su compra!\")\n",
    "    \n",
    "    except ValueError:\n",
    "        print(\"Error: Por favor, ingrese un número válido.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pago exitoso. Su cambio es: $4.50. ¡Gracias por su compra!\n"
     ]
    }
   ],
   "source": [
    "total_compra = 75.50  # Este valor podría ser el resultado de la función realizar_compra()\n",
    "procesar_pago(total_compra)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9. `agregar_cliente(nombre, email)`: Agrega un nuevo cliente al registro de clientes. Debe recibir el nombre y el correo electrónico del cliente como parámetros.\n",
    "- Agrega un cliente al diccionario de clientes con su nombre y correo electrónico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cliente Cliente1 agregado exitosamente.\n",
      "Cliente Cliente2 agregado exitosamente.\n"
     ]
    }
   ],
   "source": [
    "# Iniciamos el diccionario de clientes\n",
    "clientes = {}\n",
    "\n",
    "def agregar_cliente(nombre, email):\n",
    "    \n",
    "    if nombre in clientes:\n",
    "        print(\"Error: El cliente ya existe.\")\n",
    "    else:\n",
    "        # Agregar cliente al diccionario\n",
    "        clientes[nombre] = {'email': email, 'compras': []}\n",
    "        print(f\"Cliente {nombre} agregado exitosamente.\")\n",
    "\n",
    "# Ejemplo de uso\n",
    "agregar_cliente(\"Cliente1\", \"cliente1@email.com\")\n",
    "agregar_cliente(\"Cliente2\", \"cliente2@email.com\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Cliente1': {'email': 'cliente1@email.com', 'compras': []}, 'Cliente2': {'email': 'cliente2@email.com', 'compras': []}}\n"
     ]
    }
   ],
   "source": [
    "# Podemos mostrar el registro de clientes\n",
    "\n",
    "print(clientes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10. `ver_clientes()`: Muestra la lista de clientes registrados con sus nombres y correos electrónicos.\n",
    "- Utiliza un bucle `for` para recorrer la base de datos de clientes.\n",
    "- Imprime los detalles de cada cliente (nombre y correo electrónico)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: El cliente ya existe.\n",
      "Error: El cliente ya existe.\n",
      "Clientes registrados:\n",
      "Nombre: Cliente1, Email: cliente1@email.com\n",
      "Nombre: Cliente2, Email: cliente2@email.com\n"
     ]
    }
   ],
   "source": [
    "def ver_clientes():\n",
    "\n",
    "    if not clientes:\n",
    "        print(\"No hay clientes registrados.\")\n",
    "    else:\n",
    "        print(\"Clientes registrados:\")\n",
    "        for nombre, detalles in clientes.items():\n",
    "            print(f\"Nombre: {nombre}, Email: {detalles['email']}\")\n",
    "\n",
    "# Primero, vamos a agregar algunos clientes para poder verlos\n",
    "agregar_cliente(\"Cliente1\", \"cliente1@email.com\")\n",
    "agregar_cliente(\"Cliente2\", \"cliente2@email.com\")\n",
    "\n",
    "# Ahora, llamamos a la función para ver la lista de clientes\n",
    "ver_clientes()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "11. `registrar_compra(nombre_cliente, carrito)`: Registra una compra para un cliente, actualiza las ventas totales y agrega la compra al historial del cliente. Debe recibir el nombre del cliente y el carrito de compras como parámetros.\n",
    "- Busca al cliente en el diccionario de clientes.\n",
    "- Si el cliente no esta en el diccionario de clientes, muestra que no se puede realizar la acción por que el cliente no está en el diccionario.\n",
    "- Calcula el total de la compra y registra la compra, incluyendo los productos y el total."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: El cliente ya existe.\n",
      "Compra registrada para Cliente1. Total de la compra: $115.00.\n",
      "Ventas totales: $115.00\n"
     ]
    }
   ],
   "source": [
    "# Iniciamos las ventas totales\n",
    "ventas_totales = 0.0\n",
    "\n",
    "def registrar_compra(nombre_cliente, carrito):\n",
    "    \n",
    "    global ventas_totales\n",
    "\n",
    "    # Verificamos si el cliente está en el diccionario de clientes\n",
    "    if nombre_cliente not in clientes:\n",
    "        print(f\"Error: El cliente '{nombre_cliente}' no está registrado.\")\n",
    "        return\n",
    "\n",
    "    # Calculamos el total de la compra\n",
    "    total_compra = sum(item['precio'] * item['cantidad'] for item in carrito)\n",
    "\n",
    "    # Actualizar el historial de compras del cliente\n",
    "    clientes[nombre_cliente]['compras'].append({\n",
    "        'productos': carrito,\n",
    "        'total': total_compra\n",
    "    })\n",
    "\n",
    "    # Actualizamos las ventas totales\n",
    "    ventas_totales += total_compra\n",
    "\n",
    "    # Mostramos mensaje de confirmación\n",
    "    print(f\"Compra registrada para {nombre_cliente}. Total de la compra: ${total_compra:.2f}.\")\n",
    "\n",
    "# Primero, agregamos un cliente y algunos productos al carrito\n",
    "agregar_cliente(\"Cliente1\", \"cliente1@email.com\")\n",
    "\n",
    "# Hacemos simulación del carrito de compras\n",
    "carrito = [\n",
    "    {'nombre': 'vestido', 'precio': 40, 'cantidad': 2},  # 2 vestidos a $40\n",
    "    {'nombre': 'jersey', 'precio': 35, 'cantidad': 1}  # 1 jersey a $35\n",
    "]\n",
    "\n",
    "# Registramos la compra\n",
    "registrar_compra(\"Cliente1\", carrito)\n",
    "\n",
    "# Mostrar las ventas totales\n",
    "print(f\"Ventas totales: ${ventas_totales:.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "12. `ver_compras_cliente(nombre_cliente)`: Muestra el historial de compras de un cliente. Debe recibir el nombre del cliente como parámetro.\n",
    "- Busca al cliente en el diccionario de clientes.\n",
    "- Muestra las compras realizadas por el cliente, incluyendo detalles de productos y totales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compra registrada para Cliente1. Total de la compra: $115.00.\n",
      "Historial de compras para Cliente1:\n",
      "\n",
      "Compra #1:\n",
      " - Producto: Camisa, Precio: $20, Cantidad: 2\n",
      " - Producto: Pantalón, Precio: $30, Cantidad: 1\n",
      "Total de la compra: $70.00\n",
      "\n",
      "Compra #2:\n",
      " - Producto: vestido, Precio: $40, Cantidad: 2\n",
      " - Producto: jersey, Precio: $35, Cantidad: 1\n",
      "Total de la compra: $115.00\n",
      "\n",
      "Compra #3:\n",
      " - Producto: vestido, Precio: $40, Cantidad: 2\n",
      " - Producto: jersey, Precio: $35, Cantidad: 1\n",
      "Total de la compra: $115.00\n",
      "\n",
      "Compra #4:\n",
      " - Producto: vestido, Precio: $40, Cantidad: 2\n",
      " - Producto: jersey, Precio: $35, Cantidad: 1\n",
      "Total de la compra: $115.00\n",
      "\n",
      "Compra #5:\n",
      " - Producto: vestido, Precio: $40, Cantidad: 2\n",
      " - Producto: jersey, Precio: $35, Cantidad: 1\n",
      "Total de la compra: $115.00\n"
     ]
    }
   ],
   "source": [
    "def ver_compras_cliente(nombre_cliente):\n",
    "    \n",
    "    # Verificamos si el cliente está en el diccionario de clientes\n",
    "    if nombre_cliente not in clientes:\n",
    "        print(f\"Error: El cliente '{nombre_cliente}' no está registrado.\")\n",
    "        return\n",
    "\n",
    "    # Obtener las compras del cliente\n",
    "    compras = clientes[nombre_cliente]['compras']\n",
    "\n",
    "    # Verificamos si el cliente no tiene compras\n",
    "    if not compras:\n",
    "        print(f\"{nombre_cliente} no tiene historial de compras.\")\n",
    "        return\n",
    "\n",
    "    # Mostrar historial de compras\n",
    "    print(f\"Historial de compras para {nombre_cliente}:\")\n",
    "    for i, compra in enumerate(compras, start=1):\n",
    "        print(f\"\\nCompra #{i}:\")\n",
    "        for item in compra['productos']:\n",
    "            print(f\" - Producto: {item['nombre']}, Precio: ${item['precio']}, Cantidad: {item['cantidad']}\")\n",
    "        print(f\"Total de la compra: ${compra['total']:.2f}\")\n",
    "\n",
    "# Primero, registramos una compra para el cliente\n",
    "registrar_compra(\"Cliente1\", carrito)\n",
    "\n",
    "# Ahora, creamos la función para ver el historial de compras\n",
    "ver_compras_cliente(\"Cliente1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "13. `calcular_ventas_totales()`: Muestra las ventas totales de la tienda.\n",
    "- Suma los totales de todas las compras realizadas y muestra el total de ventas totales en la tienda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total de ventas en la tienda: $530.00\n"
     ]
    }
   ],
   "source": [
    "def calcular_ventas_totales():\n",
    "    \n",
    "    #Iniciamos con la variable de total_ventas\n",
    "    total_ventas = 0.0  \n",
    "\n",
    "    # Recorremos el diccionario de clientes\n",
    "    for cliente in clientes.values():\n",
    "        # Acceder a las compras del cliente\n",
    "        for compra in cliente['compras']:\n",
    "            total_ventas += compra['total']  # Sumar el total de cada compra\n",
    "\n",
    "    # Mostrar el total de ventas\n",
    "    print(f\"Total de ventas en la tienda: ${total_ventas:.2f}\")\n",
    "\n",
    "# Calculamos el total de las ventas\n",
    "calcular_ventas_totales()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}