dia2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Alcance (Scope - Ambito de una variable)\n",
    "El alcance hace referencia a los limites en el que existe una variable \n",
    "\n",
    "- El alcance puede ser de dos tipos \n",
    "- Alcance global \n",
    "- Alcance local "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distancia 10\n",
      "Distancia a Mcal lopez 1\n"
     ]
    }
   ],
   "source": [
    "# Variables locales \n",
    "# Variables globales \n",
    "\n",
    "# Funcion avanzar que haga referencia a un recorrido en movil hasta San Lorenzo y que puede cambiar y ser un recorrido hasta Mcal Lopez \n",
    "\n",
    "distancia_mcal_lopez = 1 # variables de alcance global \n",
    "def avanzar():\n",
    "    distancia_final_sanlo = 10 # variable de alcance local \n",
    "    print(\"Distancia\", distancia_final_sanlo)\n",
    "    print(\"Distancia a Mcal lopez\", distancia_mcal_lopez)\n",
    "avanzar()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parametros y argumentos \n",
    "\n",
    "En resumen: \n",
    "\n",
    "- Parametro es un valor que la funcion espera recibir \n",
    "- Argumentos son el valor que se envia al llamar a la funcion \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "auto vendido con estas caracteristicas azul 2009 camioneta\n",
      "auto vendido con estas caracteristicas verde 2004 audi\n"
     ]
    }
   ],
   "source": [
    "# Vamos a hacer una funcion que venda autos para la concesionaria Censu y utilizaremos parametros y argumentos con las caracteristicas de los autos \n",
    "\n",
    "# la funcion va a tener como parametros las caracteristicas de los autos a vender color, anho \n",
    "\n",
    "# funcion vender autos \n",
    "\n",
    "def vender_autos(color, anho, tipo_auto): #defino mis parametros \n",
    "    print(\"auto vendido con estas caracteristicas\", color, anho, tipo_auto)\n",
    "vender_autos(\"azul\", 2009, \"camioneta\") # al llamar a la funcion le pasamos los argumentos 1 ra venta de auto \n",
    "vender_autos(\"verde\", 2004, \"audi\") # 2 da venta de auto \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge \n",
    "\n",
    "Dada la función que acabamos de crear, definir un parametro mas sobre el auto que quiere vender y concatenar al momento de imprimir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "auto vendido con estas caracteristicas, azul, 2009, camioneta, diesel\n",
      "auto vendido con estas caracteristicas, verde, 2004, audi, biogas\n",
      "auto vendido con estas caracteristicas, rojo, 2022, kia, nafta\n"
     ]
    }
   ],
   "source": [
    "def vender_autos(color, anho, tipo_auto,combustible): #defino mis parametros \n",
    "    print(f\"auto vendido con estas caracteristicas, {color}, {anho}, {tipo_auto}, {combustible}\")\n",
    "vender_autos(\"azul\", 2009, \"camioneta\",\"diesel\") # al llamar a la funcion le pasamos los argumentos 1 ra venta de auto \n",
    "vender_autos(\"verde\", 2004, \"audi\", \"biogas\") # 2 da venta de auto\n",
    "vender_autos('rojo',2022,'kia', \"nafta\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Control de ventas automor\n",
      "El auto que vendiste tiene estas características. Es de blanco, 2022, Hyundai, y New Santa Fe, ¡SEGUÍ ASÍ!. ¡Buenas ventas!\n"
     ]
    }
   ],
   "source": [
    "print(\"Control de ventas automor\")\n",
    "def venta_de_autos(color, anho, marca, modelo):\n",
    "    print(f\"El auto que vendiste tiene estas características. Es de {color}, {anho}, {marca}, y {modelo}, ¡SEGUÍ ASÍ!. ¡Buenas ventas!\")\n",
    "venta_de_autos(\"blanco\", 2022, \"Hyundai\", \"New Santa Fe\")\n",
    "#venta_de_autos(\"plata\", 2022, \"Maserati\",\"Levante\")\n",
    "#venta_de_autos(\"gris\", 2022, \"Geely\", \"Emgrand Gx3\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El vehiculo que ha sido vendido es de color azul del anho 2009 tipo camioneta de la marca Mercedes\n",
      "El vehiculo que ha sido vendido es de color verde del anho 2004 tipo Sportage de la marca Kia\n"
     ]
    }
   ],
   "source": [
    "def vender_autos(color, anho, tipo_auto,marca_de_auto): #defino mis parametros \n",
    "    print(f\"El vehiculo que ha sido vendido es de color {color} del anho {anho} tipo {tipo_auto} de la marca { marca_de_auto}\")\n",
    "vender_autos(\"azul\", 2009, \"camioneta\",\"Mercedes\") \n",
    "vender_autos(\"verde\", 2004,\"Sportage\", \"Kia\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operadores de relacion y su interpretacion \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ubicar teclas en la computadora \n",
    "# menor que  < ---> cerca de la tecla shift \n",
    "# menor o igual que <= ----> cerca de la tecla delete \n",
    "# > mayor que ---> cerca de la tecla shift \n",
    "# >= mayor e igual que ---> cerca de la tecla shift y delete\n",
    "# == igual ---> cerca de la tecla delete \n",
    "# != diferente ---> cerca de la parte numerica de arriba\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Condicionales \n",
    "\n",
    "Son criterios \n",
    "Se tiene que cumplir o no cumplir \n",
    "Son condiciones \n",
    "\n",
    "Tenemos palabras en python que nos ayudan a hacer estas verificaciones y son 3 principales:\n",
    "\n",
    "- if (si): el if se ejecuta siempre que la expresion que comprueba devuelve True \n",
    "- elif (sino si): se encadena a un if u a otro elif para comprobar multiples condiciones, siempre que no ejecutan las anteriores \n",
    "- else (sino): se encandena a un if para comprobar el caso contrario (en el que no se cumpla la condicion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Es mayor puede ingresar\n"
     ]
    }
   ],
   "source": [
    "# Un programa que le sirva al guardia de un bar para verificar la edad de los clientes \n",
    "\n",
    "edad = 20\n",
    "\n",
    "if edad < 18: \n",
    "    print(\"Es menor no puede ingresar. Lo siento mucho\")\n",
    "else:\n",
    "    print(\"Es mayor puede ingresar\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No puedo vender el auto\n"
     ]
    }
   ],
   "source": [
    "#color = input(\"Ingresa un color de auto\")\n",
    "color = \"azul\"\n",
    "modelo_auto = \"mercedes\"\n",
    "\n",
    "if color == \"verde\" and modelo_auto == \"mercedes\": \n",
    "    # condicion verifica la igualdad \n",
    "    print(\"Puedo vender el auto tengo en stock\")\n",
    "else:\n",
    "    print(\"No puedo vender el auto\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dos condicionales a la vez\n",
    "\n",
    "- si es verde y (and) barato quiero comprar ---> se cumplen ambas condiciones para que se verdadero\n",
    "- si es rojo o (or) azul quiero comprar ---> se cumple 1 sola y ya es verdadero \n",
    "- not convierte el valor \n",
    "# Mas detalle \n",
    "- and: verdadero solo si los dos elementos son verdaderos \n",
    "- or: verdadero si cualquiera de los elementos es verdadero \n",
    "- not: cambia el valor de Falso a Verdadero y viceversa "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mini Challenge\n",
    "\n",
    "- Escribir un programa que verifique dos condiciones para la concesionaria Censu \n",
    "\n",
    "- considerar la relacion de color y la relacion de modelo que quiera el cliente \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Mas explicacion sobre condicionales \n",
    "\n",
    "color_auto = \"azul\"\n",
    "marca_auto = \"mercedes\"\n",
    "\n",
    "print(color_auto == \"azul\" or marca_auto == \"toyota\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Paginas utilizadas googleadas \n",
    "\n",
    "-  https://www.freecodecamp.org/espanol/news/operadores-basicos-en-python-con-ejemplos/ Explicaciones de ayuda que googleamos\n",
    "-  https://www.mclibre.org/consultar/python/lecciones/python-if-else.html  diagrama de flujo "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge \n",
    "\n",
    "Escribir un programa en el que se pregunte al usuario por una temperatura (en grados Celsius), imprima la temperatura escrita, y luego clasificar la temperatura ingresada en los siguientes niveles:\n",
    "\n",
    "Entre -10 y 18 grados, que imprima \"Fresquete\".\n",
    "Entre 19 y 30 grados, que imprima \"Calor'i\".\n",
    "Entre 31 y 45 grados, que imprima \"Hakuuuuuu\".\n",
    "Para todo lo demás, imprimir \"Ñamano mba'e!\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ñamano mba'e!\n"
     ]
    }
   ],
   "source": [
    "temperatura = int(input(\"ingrese temperatura\"))\n",
    "\n",
    "if temperatura >= -10 and temperatura <= 18:\n",
    "    print(\"Fresquete\")\n",
    "elif temperatura >= 19 and temperatura <= 30:\n",
    "    print(\"Calor'i\")\n",
    "elif temperatura >= 31 and temperatura <= 45:\n",
    "    print(\"Hakuuuuuu\")\n",
    "else:\n",
    "    print(\"Ñamano mba'e!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La temperatura es: -15 °\n",
      "Fresquete\n"
     ]
    }
   ],
   "source": [
    "temp = int(input(\"Ingresa la temperatura:\"))\n",
    "print(\"La temperatura es:\",temp,\"°\")\n",
    "\n",
    "\n",
    "if temp == -10 or temp <= 18:\n",
    "    print(\"Fresquete\")\n",
    "elif temp == 19 or temp <= 30:\n",
    "    print(\"Calor'i\")\n",
    "elif temp == 31 or temp <= 45:\n",
    "    print(\"Hakuuuuuu\")\n",
    "else:\n",
    "    print(\"Ñamano mba'e!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La temperatura es: 20\n",
      "CALOR'I\n"
     ]
    }
   ],
   "source": [
    "temperatura = int(input(\"Ingrese la temperatura en grados Celsiu\"))\n",
    "print(\"La temperatura es:\",temperatura)\n",
    "\n",
    "if -10 <= temperatura <= 18:\n",
    "    print(\"FRESQUETE\")\n",
    "elif 19 <= temperatura <= 30:\n",
    "    print(\"CALOR'I\")\n",
    "elif 31 <= temperatura <= 45:\n",
    "    print(\"HAKU\")\n",
    "else:\n",
    "    print(\"NHAMANO MBA'E\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bucles infitos y su utilidad \n",
    "\n",
    "Ciclo While permite repetir la ejecucion de un grupo de instrucciones mientras se cumpla una condicion, mientras la condicion sea verdadera True.\n",
    "\n",
    "Al momento de que la condicion deje de ser cierta el bucle va a parar. \n",
    "\n",
    "- Pagina de info para mirar diagrama de flujo https://www.mclibre.org/consultar/python/lecciones/python-while.html#:~:text=El%20bucle%20while,-Un%20bucle%20while&text=Python%20eval%C3%BAa%20la%20condici%C3%B3n%3A,mientras%20la%20condici%C3%B3n%20sea%20cierta\n",
    "\n",
    "-  Un ciclo while se corta cuando se modifica la condicion y deja de ser cierta: deja de ser True \n",
    "- **Formas de cortar un ciclo while**\n",
    "  - Se puede dar el corte modificando la condicion \n",
    "  - Se pueden utilizar una palabra reservada break "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "Programa Terminado\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "\n",
    "# Un programa que nos permita imprimir 3 numeros, modificar la condicion \n",
    "\n",
    "numero_modificador = 1\n",
    "\n",
    "while numero_modificador <= 3: #establecer la condicion \n",
    "    print(numero_modificador) # cuerpo del bucle while instrucciones \n",
    "    numero_modificador = numero_modificador + 1 # contador o sea fuimos adicionando a cada ejecucion\n",
    "print(\"Programa Terminado\") # fuera del cuerpo del bucle porque no hay tab \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El numero es correcto\n",
      "Hola Mundo\n"
     ]
    }
   ],
   "source": [
    "# Vamos a hacer un pedido de contrasenha y que le solicite al usuario varias veces hasta que meta la correcta, palabras reservadas \n",
    "\n",
    "# Necesitamos definir una contrasenha \n",
    "\n",
    "numero_secreto = 1 # esta es la contrasenha correcta del usuario \n",
    "\n",
    "while True: # en esta linea decimos que siempre es True \n",
    "    numero_ingresado = int(input(\"Introduce un numero\"))\n",
    "    # variable de alcance local \n",
    "    if numero_ingresado == numero_secreto:\n",
    "        print(\"El numero es correcto\")\n",
    "        break \n",
    "    else: \n",
    "        print(\"El numero es incorrecto\")\n",
    "\n",
    "\n",
    "while True:\n",
    "    print(\"Hola Mundo\")\n",
    "    break \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge \n",
    "Escribir un programa que almacene una contraseña en una variable, y pregunte al usuario por la contraseña hasta que introduzca la contraseña correcta.\n",
    "\n",
    "Cuando el usuario ingrese la contrasena correcta, imprimir un mensaje secreto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "la contraseña es incorrecta\n",
      "la contraseña es incorrecta\n",
      "la contraseña ingresada es correcta\n"
     ]
    }
   ],
   "source": [
    "contraseña= \"12121212opo\"\n",
    "while True: \n",
    "    contraseña_ingresada= input(\"Introduce la contraseña correcta\")\n",
    "    if contraseña_ingresada == contraseña:\n",
    "        print(\"la contraseña ingresada es correcta\")\n",
    "        break\n",
    "    else: \n",
    "        print(\"la contraseña es incorrecta\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "not even at the 8th time?\n",
      "not even at the 10th time?\n",
      "las manzanas envenenadas solo eran 2 entre las sanas\n"
     ]
    }
   ],
   "source": [
    "contrasenha=2\n",
    "while True:\n",
    "    ingrese_un_numero=int(input(\"ingrese un valor\"))\n",
    "    if ingrese_un_numero==contrasenha:\n",
    "        print(f\"las manzanas envenenadas solo eran {contrasenha} entre las sanas\")\n",
    "        break\n",
    "    else:\n",
    "        print(f\"not even at the {ingrese_un_numero}th time?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tienes 3 intentos para escribir los datos correctos\n",
      "Piplub es el mejor grupo\n"
     ]
    }
   ],
   "source": [
    "print (\"Tienes 3 intentos para escribir los datos correctos\")\n",
    "contador = 1\n",
    "while contador <= 3 :\n",
    "    usuario = input (\"Ingrese el Usuario\")\n",
    "    contrasenha = input (\"Ingrese la Contrasenha\")\n",
    "    if usuario == \"piplub\" and contrasenha == \"piplub2022\":\n",
    "        print (\"Piplub es el mejor grupo\")\n",
    "        break\n",
    "    else:\n",
    "        print(\"Siga Participando\")\n",
    "        if contador == 3:\n",
    "            print(\"Cagaste capo bloqueaste todo\")\n",
    "        contador = contador + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listas \n",
    "\n",
    "- Una lista es una agrupacion de objetos, que pueden ser de distintos tipos de datos. \n",
    "- Construimos listas utilizando [] y separando por comas. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['pan', 'leche', 'cereal', 'cafe', 'coca cola', 'comida de gato', 'pan dulce', 'pancho', 'sandia']\n",
      "pan\n",
      "comida de gato\n",
      "pancho\n",
      "Clau\n",
      "['pan', 'leche', 'cereal', 'cafe', 'coca cola', 'comida de gato', 'pan dulce', 'pancho', 'sandia', 'jugo ades manzana']\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# Trabajemos armando una lista de supermercado \n",
    "\n",
    "lista_cosas_supermercado = [ \"pan\", \"leche\", \"cereal\", \"cafe\", \"coca cola\", \"comida de gato\", \"pan dulce\", \"pancho\", \"sandia\" ]\n",
    "\n",
    "# Listas pueden ser de diferentes tipos de datos \n",
    "lista_bool = [True, False, True, False]\n",
    "lista_numeros = [1,2,3,4,5,6]\n",
    "lista_remixada = [True, \"manzana\", 10, [1,2,3,4, \"Clau\"]]\n",
    "\n",
    "# Acceder a elementos de una lista \n",
    "# Indices son numeros enteros que indican la ubicacion de los objetos \n",
    "# El primer elemento de una lista siempre comienza en el 0 \n",
    "\n",
    "# Imprimir la lista completa de lista supermercado\n",
    "print(lista_cosas_supermercado) \n",
    "# Imprimir el primer elemento de la lista supermercado \n",
    "print(lista_cosas_supermercado[0]) #se accede por medio de corchetes\n",
    "print(lista_cosas_supermercado[5])\n",
    "print(lista_cosas_supermercado[7]) \n",
    "# Acceder a elementos dentro de lista de listas \n",
    "print(lista_remixada[3][4]) # se hace referencia al nombre de lista principal y a la posicion de la lista que esta dentro y ahi al indice del elemento \n",
    "\n",
    "# Agregar elementos a mi lista metodo append \n",
    "# append agrega elementos al final de la lista \n",
    "\n",
    "lista_cosas_supermercado.append(\"jugo ades manzana\")\n",
    "print(lista_cosas_supermercado)\n",
    "\n",
    "# Contar cuantos elementos tiene mi lista se utiliza len \n",
    "\n",
    "print(len(lista_cosas_supermercado))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['empanada de pollo', 'cafe', 'coca cola', 'comida de gato', 'pan dulce', 'pancho', 'jugo ades manzana']\n",
      "['empanada de pollo', 'coca cola', 'comida de gato', 'pan dulce', 'pancho', 'jugo ades manzana']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Modificar elementos de una lista \n",
    "lista_cosas_supermercado[0] = \"empanada de pollo\"\n",
    "print(lista_cosas_supermercado)\n",
    "\n",
    "# El metodo remove permite remover elementos de una lista por el nombre \n",
    "#lista_cosas_supermercado.remove(\"leche\")\n",
    "#print(lista_cosas_supermercado)\n",
    "# El metodo pop permite eliminar po la posicion \n",
    "lista_cosas_supermercado.pop(1)\n",
    "print(lista_cosas_supermercado)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge \n",
    "\n",
    "Crear una lista de 5 elementos. Luego, seguir los siguientes pasos.\n",
    "\n",
    "- Agregar un elemento al final de la lista.\n",
    "\n",
    "- Modificar el segundo elemento.\n",
    "\n",
    "- Eliminar el tercer elemento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PANIFICADOS DE HARINA BLANCA\n",
      "['Focaccia', 'Baguette', 'Ciabatta', 'Fougasse', 'Campo', 'Lactal']\n",
      "['Focaccia', 'MIGA', 'Ciabatta', 'Fougasse', 'Campo', 'Lactal']\n",
      "['Focaccia', 'MIGA', 'Fougasse', 'Campo', 'Lactal']\n"
     ]
    }
   ],
   "source": [
    "print(\"PANIFICADOS DE HARINA BLANCA\")\n",
    "lista=[\"Focaccia\",\"Baguette\",\"Ciabatta\",\"Fougasse\",\"Campo\",\"Lactal\"]\n",
    "print(lista)\n",
    "lista[1]=\"MIGA\"\n",
    "print(lista)\n",
    "lista.remove(\"Ciabatta\")\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bucles iteradores: for \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Iterar:** significa realizar un proceso repetidas veces con el fin de llegar a un resultado deseado \n",
    "- **Iteraciones:** una acción repetida una cierta cantidad de veces, pero en cada repetición se tiene en cuenta el valor anterior.\n",
    "- **Utilidad:**\n",
    "    - Nos sirve cuando queremos repetir algo una cantidad de veces\n",
    "    - Que se utiliza para recorrer elementos como por ejemplo los de una listas de elementos, y tambien las palabras que son conjunto de caracteres \n",
    "    - Tambien podemos generar rangos utilizando  range\n",
    "\n",
    "- **En resumen:**\n",
    "    - El bucle for se utiliza para recorrer los elementos de un objeto iterable (lista, conjunto, string,etc …) y ejecutar un bloque de código. En cada paso de la iteración se tiene en cuenta a un único elemento del objeto iterable, sobre el cuál se pueden aplicar una serie de operaciones. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "Hola Buen dia\n",
      "1\n",
      "Hola Buen dia\n",
      "2\n",
      "Hola Buen dia\n",
      "3\n",
      "Hola Buen dia\n",
      "4\n",
      "Hola Buen dia\n"
     ]
    }
   ],
   "source": [
    "# Hacer un programa que imprima Buen dia 5 veces \n",
    "# for palabra reservada \n",
    "# iterador pueden verlo como una variable \n",
    "# in palabra clave \n",
    "\n",
    "for saludo in range(5): # por cada interacion en rango 5 imprimir Hola Buen dia \n",
    "    print(saludo)\n",
    "    print(\"Hola Buen dia\") \n",
    "\n",
    "lista_numeros = [1,2,3,4,5]\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# in es una palabra clave propiamente es un operador de pertenencia \n",
    "\n",
    "- Un operador de pertenencia se emplea para identificar pertenencia en alguna secuencia (listas, strings) \n",
    "- **in** devuelve True si el valor especificado se encuentra en la secuencia. En caso contrario devuelve False.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "palabra = \"Hola\"\n",
    "\n",
    "resultado_busqueda = \"a\" in palabra \n",
    "print(resultado_busqueda)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tambien podemos utilizar las listas para realizar acciones utilizando los valores de las listas. \n",
    "Las listas son datos iterables \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "toyota\n",
      "kia\n",
      "mercedes\n",
      "BMW\n",
      "audi\n"
     ]
    }
   ],
   "source": [
    "# Hacer un programa que imprima los elementos de una lista de marcas \n",
    "\n",
    "lista_marcas = [\"toyota\", \"kia\", \"mercedes\", \"BMW\", \"audi\"]\n",
    "\n",
    "for iterador_marca_de_autos in lista_marcas:\n",
    "    print(iterador_marca_de_autos) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge \n",
    "\n",
    "Escribir un programa en el que se pregunte al usuario por una frase y una letra, y muestre por pantalla el número de veces que aparece la letra en la frase.\n",
    "\n",
    "- Pedir al usuario una frase (input)\n",
    "\n",
    "- Guardar la frase ingresada en una variable\n",
    "\n",
    "- Pedir al usuario una letra\n",
    "\n",
    "- Iterar (en?) la frase letra por letra para encontrar la letra buscada\n",
    "\n",
    "- Contar cuantas veces aparece la letra en la frase\n",
    "\n",
    "- Imprimir el total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jahuga pue\n",
      "-------------------\n",
      "Elegi una frase:P\n",
      "Tu frase es: yo soy tu padreeeee\n",
      "Y que letra queres ver cuantas veces hay?\n",
      "Tu letra es: e\n",
      "-------------------\n",
      "La letra: 'e' en la frase: 'yo soy tu padreeeee' aparece '5' veces.\n"
     ]
    }
   ],
   "source": [
    " ''' print(\"Jahuga pue\")\n",
    "print(\"-------------------\")\n",
    "print(\"Elegi una frase:P\")\n",
    "frase = input(\"Ingresa una frase:D!\")\n",
    "print(\"Tu frase es:\", frase)\n",
    "print(\"Y que letra queres ver cuantas veces hay?\")\n",
    "letra = input(\"Ingresa una letra:D!\")\n",
    "print(\"Tu letra es:\", letra)\n",
    "\n",
    "contador_letra = 0 \n",
    "for letra_iterable in frase:\n",
    "    if letra_iterable == letra:\n",
    "        contador_letra += 1\n",
    "        contador_letra = contador_letra + 1 \n",
    "print(\"-------------------\")\n",
    "print(f\"La letra: '{letra}' en la frase: '{frase}' aparece '{contador_letra}' veces.\") ''' "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BIenvenido al buscador de letras  ˶ᵔ ᵕ ᵔ˶ \n",
      "hola mundooo\n",
      "Tu letra a buscar es o\n",
      "Se repite 12 veces (っ- ‸ - ς)!\n"
     ]
    }
   ],
   "source": [
    "#Primero nos presentamos\n",
    "print (\"BIenvenido al buscador de letras  ˶ᵔ ᵕ ᵔ˶ \")\n",
    "#Luego pedimos la informacion al usaurio \n",
    "frasesita = input(\"Por favor ingrese alguna frase\")\n",
    "print(frasesita)\n",
    "#luego la lera que esta buscando\n",
    "letrita = input(\"Por favor ingrese la letra que desea buscar\")\n",
    "print(\"Tu letra a buscar es\", letrita)\n",
    "#ahora empezamos el proceso o codigo de busqueda que se basa en for o por la variable de tu frase en la variable de la letra \n",
    "c = (0)\n",
    "\n",
    "for letrita in frasesita:\n",
    "    if letrita in frasesita:\n",
    "        c = c + 1\n",
    "print(\"Se repite\", c, \"veces (っ- ‸ - ς)!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frase = input(\"Ingresar una frase\") #esto es un input para que el usuario pueda ingresar informacion \n",
    "# los input se almacenan en variables \n",
    "letra = input(\"Ingresar una letra\")\n",
    "contador = 0\n",
    "\n",
    "for iterador in frase:\n",
    "    if letra == iterador: #ocurre la verificacion\n",
    "        contador = contador + 1 #esto es el contador\n",
    "contador = str(contador)\n",
    "\n",
    "print(\"la frase es\", frase)\n",
    "print(\"la cantidad de veces que aparece la letra es \" + contador)\n",
    "print(f\"La cantidad de veces que aparece la letra es {contador}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Presentación del proyecto "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Vamos al sitio web de wordle:** https://lapalabradeldia.com/  \n",
    "    - Palabra del dia TROYA\n",
    "\n",
    "**Conceptos que ya aprendimos y nos serviran para el proyecto:**\n",
    "\n",
    "  - Variables\n",
    "  - Tipos de datos\n",
    "  - Concatenación\n",
    "  - Operadores lógicos\n",
    "  - Condicionales (control de flujo)\n",
    "  - Funciones (propias & built-in)\n",
    "  - Bucles\n",
    "  - Listas\n",
    "\n",
    "<img src=\"./assets/reglaswordle.png\" style=\"width: 600px;\">\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.4 64-bit",
   "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.10.4"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}