Ejercicio 5.1 - Sentencias de control (bucle for).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sentencias de control -> Bucles for"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#1. Usando la siguiente lista:\n",
    "**temperaturas = [2,45,67,23, 45,66,12,1,34,67,99,98,67,64, 44, 100]**\n",
    "\n",
    "Crea tres listas nuevas, donde:\n",
    "- En la primera tengamos temperaturas entre 0 - 10, llama a la nueva lista **bajas_temp**.\n",
    "- En la segunda tengamos temperaturas entre 11- 20, llama a la nueva lista **medias_temp**.\n",
    "- En la tercera tengamos temperaturas por encima de 20, llama a la nueva lista **altas_temp**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 1]\n",
      "[12]\n",
      "[45, 67, 23, 45, 66, 34, 67, 99, 98, 67, 64, 44, 100]\n"
     ]
    }
   ],
   "source": [
    "temperaturas = [2,45,67,23, 45,66,12,1,34,67,99,98,67,64, 44, 100]\n",
    "bajas_temp = []\n",
    "medias_temp = []\n",
    "altas_temp = []\n",
    "\n",
    "for grados in temperaturas:\n",
    "    if 0 < grados <= 10:\n",
    "        bajas_temp.append(grados)\n",
    "    elif 11 < grados <= 20:\n",
    "        medias_temp.append(grados)\n",
    "    else:\n",
    "        altas_temp.append(grados)\n",
    "print(bajas_temp)\n",
    "print(medias_temp)\n",
    "print(altas_temp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#2. Las temperaturas están grados centígrados. Para cada una de las listas creadas en el ejercicio anterior, convertid las temperaturas a grados fahrenheit.\n",
    "- *la relacion de grados celsius y fahrenheit es:*\n",
    "*(0 °C × 9 / 5) + 32 = 32 °F*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[35.6, 33.8]\n"
     ]
    }
   ],
   "source": [
    "bajas_temp_f = []\n",
    "\n",
    "for grados in bajas_temp:\n",
    "    bajas_temp_f.append((grados*9/5)+32)\n",
    "print(bajas_temp_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[53.6]\n"
     ]
    }
   ],
   "source": [
    "medias_temp_f = []\n",
    "\n",
    "for grados in medias_temp:\n",
    "    medias_temp_f.append((grados*9/5)+32)\n",
    "print(medias_temp_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[113.0, 152.6, 73.4, 113.0, 150.8, 93.2, 152.6, 210.2, 208.4, 152.6, 147.2, 111.2, 212.0]\n"
     ]
    }
   ],
   "source": [
    "altas_temp_f = []\n",
    "\n",
    "for grados in altas_temp:\n",
    "    altas_temp_f.append((grados*9/5)+32)\n",
    "print(altas_temp_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([35.6, 33.8],\n",
       " [53.6],\n",
       " [113.0,\n",
       "  152.6,\n",
       "  73.4,\n",
       "  113.0,\n",
       "  150.8,\n",
       "  93.2,\n",
       "  152.6,\n",
       "  210.2,\n",
       "  208.4,\n",
       "  152.6,\n",
       "  147.2,\n",
       "  111.2,\n",
       "  212.0])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"SOLUCION PROFE\"\"\" #CORRECTO LAS DOS FORMAS\n",
    "todas = bajas_temp.copy() , medias_temp.copy() , altas_temp.copy()\n",
    "todas\n",
    "\n",
    "for lista in todas:\n",
    "    for indice in range(len(lista)):\n",
    "        lista[indice] = (lista[indice] *  9 / 5) + 32\n",
    "todas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#3. Define e imprime un rango de 0 a 6 (excluido)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in range(6):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#4. Define e imprime un rango de 3 a 6 ambos incluidos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "for i in range(3,7):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#5. Define e imprime un rango de 5 a 9 ambos excluidos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "7\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for i in range(6,9):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#6. Define e imprime un rango de 3 números que empiece en 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "for i in range(2,7,2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#7. Define e imprime un rango que empiece en 2, aumentando cada paso por 3, que pare antes de llegar al número 13."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "5\n",
      "8\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "for i in range(2,13,3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#8. Define e imprime un rango con todos los valores impares que hay hasta 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,11,2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#9. Crea una lista nueva donde tengamos los números de la lista **temperaturas** elevados al cuadrado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 2025, 4489, 529, 2025, 4356, 144, 1, 1156, 4489, 9801, 9604, 4489, 4096, 1936, 10000]\n"
     ]
    }
   ],
   "source": [
    "lista_nueva = []\n",
    "for temperatura_cuadrada in temperaturas:\n",
    "    lista_nueva.append(temperatura_cuadrada**2)\n",
    "print(lista_nueva)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4,\n",
       " 2025,\n",
       " 4489,\n",
       " 529,\n",
       " 2025,\n",
       " 4356,\n",
       " 144,\n",
       " 1,\n",
       " 1156,\n",
       " 4489,\n",
       " 9801,\n",
       " 9604,\n",
       " 4489,\n",
       " 4096,\n",
       " 1936,\n",
       " 10000]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"SOLUCION PROFE\"\"\" #CORRECTO LAS DOS FORMAS\n",
    "\n",
    "lista = [2,45,67,23, 45,66,12,1,34,67,99,98,67,64, 44, 100]\n",
    "\n",
    "lista_cuadrado = [i**2 for i in lista]\n",
    "lista_cuadrado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#10. Crea una lista nueva donde tengamos el resto de la división de cada uno de los números entre 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 1, 1, 1, 1, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "lista_nueva2 = []\n",
    "for division in lista_nueva:\n",
    "    if division % 2 != 0:\n",
    "        lista_nueva2.append(division % 2)\n",
    "print(lista_nueva2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"SOLUCION PROFE\"\"\" #CORRECTO LAS DOS FORMAS\n",
    "\n",
    "lista_resto = [i % 2 for i in lista]\n",
    "lista_resto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#11. Crea una lista nueva donde tengamos solo los elementos pares de la lista **temperaturas**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 66, 12, 34, 98, 64, 44, 100]\n"
     ]
    }
   ],
   "source": [
    "lista_nueva3 = []\n",
    "for pares in temperaturas:\n",
    "    if pares % 2 == 0:\n",
    "        lista_nueva3.append(pares)\n",
    "print(lista_nueva3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 66, 12, 34, 98, 64, 44, 100]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"SOLUCION PROFE\"\"\" #CORRECTO LAS DOS FORMAS\n",
    "lista_pares = [i for i in lista if i % 2 == 0]  #list compehension --> for para avanzados\n",
    "lista_pares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#12. Crea una lista nueva donde tengamos solo los elementos que sean menores que 50."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 45, 67, 23, 45, 66, 12, 1, 34, 67, 99, 98, 67, 64, 44, 100]\n",
      "[2, 45, 23, 45, 12, 1, 34, 44]\n"
     ]
    }
   ],
   "source": [
    "print(temperaturas)\n",
    "lista_nueva4 = []\n",
    "\n",
    "for valores in temperaturas:\n",
    "    if valores < 50: \n",
    "        lista_nueva4.append(valores)\n",
    "print(lista_nueva4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 45, 23, 45, 12, 1, 34, 44]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"SOLUCION PROFE\"\"\" #CORRECTO LAS DOS FORMAS\n",
    "lista_menores50 = [i for i in lista if i < 50]\n",
    "lista_menores50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#13. Crea una lista donde tengamos los valores \"par\" e \"impar\" en función de los valores de la lista original. La lista resultante tiene que ser como la que indicamos a continuación:\n",
    "\n",
    "**lista_strings = [\"par\",\"impar\",\"impar\",\"impar\", \"impar\",\"par\",\"par\",\"impar\",\"par\",\"impar\",\"impar\",\"par\",\"impar\",\"par\", \"par\", \"par\"]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['par', 'impar', 'impar', 'impar', 'impar', 'par', 'par', 'impar', 'par', 'impar', 'impar', 'par', 'impar', 'par', 'par', 'par']\n"
     ]
    }
   ],
   "source": [
    "lista_strings = []\n",
    "\n",
    "\n",
    "\n",
    "for numeros in lista_nueva:\n",
    "    if numeros % 2 == 0:\n",
    "        lista_strings.append(\"par\")\n",
    "    else: \n",
    "       lista_strings.append(\"impar\")\n",
    "\n",
    "\n",
    "print(lista_strings)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['par', 'impar', 'impar', 'impar', 'impar', 'par', 'par', 'impar', 'par', 'impar', 'impar', 'par', 'impar', 'par', 'par', 'par']\n"
     ]
    }
   ],
   "source": [
    "lista_strings2 = []\n",
    "\n",
    "for numeros2 in lista_nueva:\n",
    "    if numeros2 % 2 == 0:\n",
    "        lista_strings2.append(\"par\")\n",
    "    elif numeros2 % 2 != 0:\n",
    "        lista_strings2.append(\"impar\")\n",
    "\n",
    "print(lista_strings2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['par', 'impar', 'impar', 'impar', 'impar', 'par', 'par', 'impar', 'par', 'impar', 'impar', 'par', 'impar', 'par', 'par', 'par']\n"
     ]
    }
   ],
   "source": [
    "lista_strings3 = []\n",
    "\n",
    "for numeros3 in lista_nueva:\n",
    "    if numeros3 % 2 == 0:\n",
    "        lista_strings3.append(\"par\")\n",
    "        continue\n",
    "    else:\n",
    "        lista_strings3.append(\"impar\")\n",
    "\n",
    "print(lista_strings3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['par',\n",
       " 'impar',\n",
       " 'impar',\n",
       " 'impar',\n",
       " 'impar',\n",
       " 'par',\n",
       " 'par',\n",
       " 'impar',\n",
       " 'par',\n",
       " 'impar',\n",
       " 'impar',\n",
       " 'par',\n",
       " 'impar',\n",
       " 'par',\n",
       " 'par',\n",
       " 'par']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"SOLUCION PROFE\"\"\" # TODO CORRECTO\n",
    "\n",
    "lista_string = [\"par\" if i % 2 == 0 else \"impar\" for i in lista ]\n",
    "lista_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#14. Pide al usuario un número entero positivo y suma los números pares e impares por separado hasta ese número."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[5], line 6\u001b[0m\n\u001b[0;32m      2\u001b[0m suma_pares \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m \n\u001b[0;32m      3\u001b[0m suma_impares \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[1;32m----> 6\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m numero \u001b[38;5;129;01min\u001b[39;00m numero_entero_positivo:\n\u001b[0;32m      7\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m numero \u001b[38;5;241m%\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m      8\u001b[0m         suma_pares \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m numero\n",
      "\u001b[1;31mTypeError\u001b[0m: 'int' object is not iterable"
     ]
    }
   ],
   "source": [
    "numero_entero_positivo = int(input(\"Dame un número entero positivo por favor\"))\n",
    "suma_pares = 0 \n",
    "suma_impares = 0 #se pone fuera porque quieres ver una suma del total del for. Todo lo que pae en el for se va a reflejar aquí. \n",
    "\n",
    "\n",
    "for i in numero_entero_positivo: #esto está mal porque le estás diciendo que te sume un único número. Por eso, necesitas darle un rango como se ve en la solución de la profe\n",
    "    if i % 2 == 0:\n",
    "        suma_pares += i\n",
    "    else:\n",
    "        suma_impares += i\n",
    "\n",
    "    \n",
    "print(suma_impares)\n",
    "print(suma_pares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Suma de números pares: 30\n",
      "Suma de números impares: 25\n"
     ]
    }
   ],
   "source": [
    "\"\"\"SOLUCION PROFE\"\"\"\n",
    "\n",
    "numero = int(input(\"Ingresa un número entero positivo: \"))\n",
    "suma_pares = 0\n",
    "suma_impares = 0\n",
    "for i in range(1, numero + 1): #el rango empieza por uno, acaba en el número del INPUT y le sumas 1 para que te incluya también ese número \n",
    "    if i % 2 == 0:\n",
    "        suma_pares += i\n",
    "    else:\n",
    "        suma_impares += i\n",
    "print(f\"Suma de números pares: {suma_pares}\")\n",
    "print(f\"Suma de números impares: {suma_impares}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#15. Pide al usuario ingresar una cadena y cuenta cuántas veces aparece cada vocal (a, e, i, o, u) en la cadena."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hay 7 vocales\n",
      "hola buenos dias\n"
     ]
    }
   ],
   "source": [
    "cadena = input(\"escribeme algo hoy\").lower()\n",
    "\n",
    "contador_vocal = 0\n",
    "\n",
    "for i in cadena: \n",
    "      if i in \"aeiou\":\n",
    "          contador_vocal += 1\n",
    "print(f\"hay {contador_vocal} vocales\") #depende de a qué nivel lo pongas te imprime el bucle o te imprime el resultado final \n",
    "print(cadena)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"SOLUCION PROFE\"\"\"  \n",
    "\n",
    "\n",
    "frase = input(\"Que frase quieres\")\n",
    "vocales = {\"a\": 0, \"e\": 0, \"i\": 0, \"o\":0, \"u\": 0}\n",
    "\n",
    "for k, value in vocales.items(): \n",
    "    vocales[k] += frase.count(k)"
   ]
  }
 ],
 "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
}