Ejercicio 6 - Funciones.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# EJERCICIO 6. FUNCIONES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "#1. Escribe una función que reciba una cadena de texto como parámetro y \n",
    "#   devuelva un diccionario con las frecuencias de cada letra en la cadena. Los espacios no deben ser considerados.\n",
    "\n",
    "def funcion1(texto):\n",
    "    diccionario = {}  #donde voy a guardar\n",
    "    for i in texto:\n",
    "        if i == \" \":\n",
    "            continue\n",
    "        elif i in diccionario: \n",
    "           diccionario[i] += 1\n",
    "        else:\n",
    "            diccionario[i] = 1 \n",
    "    return diccionario\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'H': 1, 'o': 4, 'y': 1, 'c': 1, 'm': 1, 's': 1, 'p': 1, 'a': 1}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "funcion1(\"Hoy como sopa\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "#2. Escribe una función que reciba una cadena de texto como parámetro y \n",
    "#   devuelva una lista con todas las palabras que tienen más de 5 letras\n",
    "\n",
    "def funcion2(texto): \n",
    "    lista_caracteres = []\n",
    "    texto_lista = texto.split()\n",
    "    for i in texto_lista: \n",
    "         if len(i) > 5:  \n",
    "           lista_caracteres.append(i)\n",
    "         else: \n",
    "           pass\n",
    "    return lista_caracteres\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Buenos']"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "funcion2(\"Buenos dias como estas\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "def funcion3(lista): \n",
    "    lista_caracteres = []\n",
    "    for i in lista: \n",
    "         if len(i) > 5:  \n",
    "           lista_caracteres.append(i)\n",
    "         else: \n",
    "           pass\n",
    "    return lista_caracteres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['bernardo']"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "funcion3([\"pedro\", \"juan\", \"marta\", \"bernardo\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['caramelo', 'alcachofa']"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "funcion2(\"caramelo alcachofa juan marta sol uno a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "#3. Crea una función que tome una lista de palabras como entrada y \n",
    "#   devuelva una lista de palabras que contengan más de una vocal.\n",
    "\n",
    "def funcion4(lista):\n",
    "   \n",
    "    vocales_lista = []\n",
    "    for i in lista: \n",
    "        if \"a\" in i:\n",
    "            vocales_lista.append(i)\n",
    "        elif \"a\" in i:\n",
    "            vocales_lista.append(i)\n",
    "        elif \"e\" in i:\n",
    "            vocales_lista.append(i)\n",
    "        elif \"i\" in i:\n",
    "            vocales_lista.append(i)\n",
    "        elif \"o\" in i:\n",
    "            vocales_lista.append(i)\n",
    "        elif \"u\" in i:\n",
    "            vocales_lista.append(i)\n",
    "        else: \n",
    "            pass\n",
    "    return vocales_lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Marta', 'Sara', 'Valladolid', 'Getefe']"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "funcion4([\"Marta\", \"Sara\", \"Valladolid\", \"Getefe\", \"SNDT\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['programación', 'bootcamp', 'hola', 'computadora', 'aprendizaje']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"SOLUCION PROFE\"\"\"\n",
    "# Definir una función que filtre palabras con más de una vocal  \n",
    "def palabras_con_mas_de_una_vocal(lista_de_palabras):\n",
    "    resultado = []\n",
    "    \n",
    "    for palabra in lista_de_palabras:\n",
    "        # Contar las vocales en la palabra\n",
    "        contador_vocales = 0\n",
    "        for letra in palabra:\n",
    "            if letra.lower() in \"aeiou\":\n",
    "                contador_vocales += 1\n",
    "        \n",
    "        # Si la palabra tiene más de una vocal, agregarla al resultado\n",
    "        if contador_vocales > 1:\n",
    "            resultado.append(palabra)\n",
    "    \n",
    "    return resultado\n",
    "palabras = [\"python\", \"programación\", \"bootcamp\", \"hola\", \"computadora\", \"aprendizaje\"]\n",
    "palabras_con_mas_de_una_vocal(palabras)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#4. Crea una función que tome una lista de números y calcule la suma de todos los números pares en la lista\n",
    "\n",
    "\n",
    "\n",
    "def funcion5(lista):\n",
    "    suma = 0\n",
    "    for i in lista: \n",
    "        if i % 2 == 0:\n",
    "            suma += i\n",
    "    return suma\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "funcion5([2,3,4,5,6,7,8,10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numeros = [2,3,4,5,6,7,8,10]\n",
    "funcion5(numeros)  #funcionaria tanto como está hecho arriba como aquí "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#5. Escribe una función que tome una lista de números como entrada y calcule el promedio de esos números.\n",
    "\n",
    "\n",
    "def promedio(*args):\n",
    "    return round((sum(args)/len(args)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "promedio(2,3,4,5,6,7,2,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"SOLUCION PROFE\"\"\"\n",
    "\n",
    "def calcular_promedio(lista):\n",
    "    if len(lista) == 0:\n",
    "        return 0\n",
    "    suma = sum(lista)\n",
    "    promedio = round(suma / len(lista))\n",
    "    return promedio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numeros2 = [2,3,4,5,6,7,2,1]\n",
    "calcular_promedio(numeros2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "#6. Crea una función que determine el próximo año en el que las cifras del año de tu cumpleaños no se repitan. \n",
    "#   La función toma un año de tu cumpleaños como entrada y calcula el próximo año en el que las cifras no se repitan, \n",
    "#   es decir, todas las cifras en el año son diferentes entre sí.\n",
    "\n",
    "\n",
    "\"\"\"SOLUCION PROFE: NO LO ENTIENDO\"\"\"\n",
    "\n",
    "def cumpleaños(año):\n",
    "    felicidades = año + 1\n",
    "    \n",
    "    while len(set(str(felicidades))) != 4:\n",
    "        felicidades += 1\n",
    "    return felicidades\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2013"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cumpleaños(1991)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#7. Crea una función que determine cuántos pasteles puedes hornear según una receta y los ingredientes disponibles. \n",
    "#   La función toma dos diccionarios como entrada: receta, que contiene los ingredientes necesarios para un pastel, \n",
    "#   y disponible, que contiene la cantidad disponible de cada ingrediente. Sus parámetros de entrada son:\n",
    "\n",
    "\"\"\" \n",
    "- receta: Un diccionario que representa los ingredientes necesarios para un pastel, \n",
    "        donde las claves son los nombres de los ingredientes y los valores son las cantidades necesarias de cada ingrediente.\n",
    "\n",
    "- disponible: Un diccionario que representa la cantidad disponible de cada ingrediente, \n",
    "  donde las claves son los nombres de los ingredientes y los valores son las cantidades disponibles. \"\"\"\n",
    "\n",
    "receta1 = {'flour': 500, 'sugar': 200, 'eggs': 1}\n",
    "ingredientes1 = {'flour': 1200, 'sugar': 1200, 'eggs': 5, 'milk': 200}\n",
    "\n",
    " \n",
    "# output: con estos ingredientes solo puedo hacer 2 bizcochos\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"SOLUCION PROFE\"\"\"\n",
    "\n",
    "def pasteles(receta, disponible):\n",
    "    numero = []  # ···¿esto porqué es una lista?¿Para qué?\"\"\"\n",
    "    for ingrediente in receta: \n",
    "        if ingrediente not in disponible:  #si el ingrediente(elemento de la receta) NO está en disponible (ingredientes1), devuelveme 0\n",
    "            return 0 \n",
    "        else: \n",
    "            numero.append(disponible[ingrediente] // receta[ingrediente])  #NO ENTIENDO ESTO ~~~#para todo loq ue si que coindida añádemelo a la lista y ????\n",
    "    return min(numero)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "receta1 = {'flour': 500, 'sugar': 200, 'eggs': 1}\n",
    "ingredientes1 = {'flour': 1200, 'sugar': 1200, 'eggs': 5, 'milk': 200}\n",
    "\n",
    "pasteles(receta1, ingredientes1)  #¿Porqué da resultado dos si hay 3... es verdad que hay menos azúcar pero no entiendo la función de arriba... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#8. BONUS: 8. Crea una función llamada fibonacci que tome un número n como argumento y \n",
    "#   devuelva una lista con los primeros n números de la serie Fibonacci.\n",
    "\n",
    "def fibonacci(n):\n",
    "    n = numeros\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicios de funciones con parámetros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#1. Crea una función que tome un número arbitrario de cadenas de texto como argumentos y \n",
    "#   devuelva una cadena de texto que sea la concatenación de todas ellas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#2. Crea una función que tome un número arbitrario de argumentos y devuelva el producto de todos ellos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#3. Crea una función que tome un número arbitrario de diccionarios como argumentos y \n",
    "#   devuelva el valor mínimo entre todos los valores de los diccionarios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#4. Crea una función que tome un número arbitrario de listas y \n",
    "#   devuelva un diccionario donde las listas originales se combinan usando los índices como claves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#5. Crea una función que tome el tipo de figura geométrica (por ejemplo, \"cuadrado\", \"triángulo\", \"círculo\") como argumento de palabra clave y los argumentos necesarios para calcular el área de esa figura. \n",
    "#   La función debe devolver el área calculada. Soluciona este ejercicio con kwargs Por ejemplo:\n",
    "\n",
    "# esta función calcula el area de un cuadrado, para hacerlo solo necesitamos saber su lado  \n",
    "area_figura(tipo=\"cuadrado\", lado=5)\n",
    "\n",
    "# si quisieramos calcular la de un triángulo necesitaríamos su base y su altura, \n",
    "# y si quisieramos calcular de un círculo necesitaríamos su radio. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#6. Crea una función que tome argumentos de palabra clave para los ingredientes y pasos de una receta y \n",
    "#   devuelva una descripción completa de la receta. Resuelvelo con kwargs. Esta función toma como entrada una serie de detalles sobre la receta, como el nombre de la receta, los ingredientes necesarios y los pasos para prepararla. Luego, la función genera y devuelve una descripción detallada de la receta en forma de cadena de texto. Los parámetros que debe recibir la función son:\n",
    "\n",
    "\"\"\"\n",
    "- nombre_receta: Un argumento de palabra clave que representa el nombre de la receta.\n",
    "\n",
    "- ingredientes: Un argumento de palabra clave que es un diccionario donde las claves son los nombres de los ingredientes \n",
    "              y los valores son las cantidades necesarias de cada ingrediente.\n",
    "\n",
    "- pasos: Un argumento de palabra clave que contiene los pasos necesarios para preparar la receta en forma de una cadena de texto. \"\"\"\n",
    "\n",
    "# Al final tendremos que ver algo como esto:\n",
    "\n",
    "'''\n",
    "Receta: Pastel de Chocolate\n",
    "Ingredientes:\n",
    "    - 200g de chocolate\n",
    "    - 150g de harina\n",
    "    - 100g de azúcar\n",
    "Pasos:\n",
    "    1. Mezclar el chocolate con la harina.\n",
    "    2. Agregar el azúcar y mezclar bien.\n",
    "'''\n",
    "\n",
    "\n",
    "nombre_receta:\n",
    "\n",
    "ingredientes: \n",
    "\n",
    "pasos: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#7. Crea una función que tome argumentos de palabra clave para los ingresos y gastos de una empresa y \n",
    "#   genere un informe financiero. Resyelvelo con kwargs. La función calcula y presenta un informe financiero simple. \n",
    "\n",
    "#   Este informe incluye detalles sobre los ingresos, los gastos y el balance de una entidad financiera, \n",
    "#   como una empresa o una persona. La función toma como entrada los ingresos y los gastos, y \n",
    "#   calcula el balance restando los gastos de los ingresos. \n",
    "\n",
    "#   Luego, genera una descripción del informe financiero en forma de cadena de texto. \n",
    "\n",
    "#   Los parámetros que recibe la función son:\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "- ingresos: Un argumento de palabra clave que representa la cantidad total de ingresos (dinero ganado) que se desea informar. \n",
    "            Por defecto, se establece en 0 si no se proporciona ningún valor.\n",
    "\n",
    "- gastos: Un argumento de palabra clave que representa la cantidad total de gastos (dinero gastado) que se desea informar. \n",
    "          Por defecto, se establece en 0 si no se proporciona ningún valor.\"\"\"\n",
    "\n",
    "#Al final tendremos algo como esto:\n",
    "\n",
    "'''\n",
    "Ingresos: $50000\n",
    "Gastos: $35000\n",
    "Balance: $15000\n",
    "'''\n",
    "\n",
    "ingresos =\n",
    "gastos = "
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}