03_Estructuras_de_Control__Grupo_3.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "85A2pMjuxtj3"
      },
      "source": [
        "#**1.0 | CONDICIONALES**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fj1FtSbn9Uw9",
        "outputId": "c7380c20-8bf6-4cd0-e9cb-4c632a865766"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Mayor de edad\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 1.1\n",
        "# Asignación basada en una condición\n",
        "edad = 20\n",
        "mensaje = \"Mayor de edad\" if edad >= 18 else \"Menor de edad\"\n",
        "print(mensaje)  # Output: Mayor de edad\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tGzYTrwnQfRr",
        "outputId": "568775ee-a95a-4fe1-a843-c051b53ae26a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "División por cero no permitida\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 1.2\n",
        "# Operación matemática condicional\n",
        "a = 10\n",
        "b = 0\n",
        "resultado = a / b if b != 0 else \"División por cero no permitida\"\n",
        "print(resultado)  # Output: 2.0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Avj-VPjGQjex",
        "outputId": "3341f383-db94-422e-fb55-79e557ab29fa"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Introduzca su nota: 10\n",
            "F\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 1.3\n",
        "#  Anidar if\n",
        "nota = int(input(\"Introduzca su nota: \"))\n",
        "\n",
        "if nota >= 90:\n",
        "    grado = 'A'\n",
        "else:\n",
        "    if nota >= 80:\n",
        "        grado = 'B'\n",
        "    else:\n",
        "        if nota >= 70:\n",
        "            grado = 'C'\n",
        "        else:\n",
        "            if nota >= 60:\n",
        "                grado = 'D'\n",
        "            else:\n",
        "                grado = 'F'\n",
        "\n",
        "print(grado)  # Output: B"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OBDnUpfwQo5P",
        "outputId": "bbb4b3f8-006c-4684-f72c-19b49695f2e2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Puede conducir\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 1.4\n",
        "# Uso de and\n",
        "edad = 25\n",
        "tiene_licencia = True\n",
        "\n",
        "if edad >= 18 and tiene_licencia:\n",
        "    print(\"Puede conducir\")\n",
        "else:\n",
        "    print(\"No puede conducir\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dtGdvZbeJYT4"
      },
      "source": [
        "#**2.0 | Bucles**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8sA_xconOMjP"
      },
      "source": [
        "### La principal diferencia entre for y while es que el bucle for se utiliza para iterar sobre una secuencia de elementos (como listas, tuplas, conjuntos, diccionarios) y se sabe de antemano cuántas veces se ejecutará, mientras que el bucle while se utiliza para repetir un bloque de código mientras una condición lógica sea verdadera, sin conocer necesariamente el número de iteraciones de antemano."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rGM8QCymKWqa"
      },
      "source": [
        "*2.1 | For*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vWZeW-a9KGie"
      },
      "outputs": [],
      "source": [
        "#Ejemplo 2.1.1\n",
        "#Bucle for iterando sobre lista de números\n",
        "numeros = [1, 2, 3, 4, 5]\n",
        "for numero in numeros:\n",
        "    print(numero)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5fXx7vL5Kush"
      },
      "outputs": [],
      "source": [
        "#Ejemplo 2.1.2\n",
        "#Bucle for para imprimir la segunda letra de cada elemento de una lista\n",
        "\n",
        "frutas = [\"manzana\", \"banana\", \"cereza\", \"dátil\"]\n",
        "\n",
        "Bucle for para recorrer cada fruta en la lista\n",
        "for fruta in frutas:\n",
        "   # Imprimir la segunda letra de la fruta\n",
        "    print(fruta[1])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1KZmLSOHKfk0"
      },
      "source": [
        "*2.2 | While*"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "x9jsrpjrLS4u"
      },
      "outputs": [],
      "source": [
        "#Ejemplo 2.2.1\n",
        "# Bucle while sencillo\n",
        "\n",
        "#Inicialización de la variable i con el valor 0\n",
        "i = 0\n",
        "\n",
        "#Bucle while que se ejecuta mientras i sea menor que 3\n",
        "while i < 3:\n",
        "    # Imprimir el valor actual de i\n",
        "    print(i)\n",
        "    # Incrementar el valor de i en 1 en cada iteración\n",
        "    i += 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "351M5WpFNsv9"
      },
      "outputs": [],
      "source": [
        "#Ejemplo 2.2.2\n",
        "# Bucle while para imprimir la segunda letra de cada elemento de una lista\n",
        "frutas = [\"manzana\", \"banana\", \"cereza\", \"dátil\"]\n",
        "\n",
        "#Inicialización del índice para el bucle while\n",
        "i = 0\n",
        "\n",
        "while i < len(frutas):\n",
        "    # Verificar si la longitud de la fruta actual es mayor o igual a 2\n",
        "    if len(frutas[i]) >= 2:\n",
        "        # Imprimir el segundo carácter de la fruta actual\n",
        "        print(frutas[i][1])\n",
        "    # Incrementar el índice para pasar a la siguiente fruta\n",
        "    i += 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "giT4ccvTOnGb"
      },
      "outputs": [],
      "source": [
        "#Ejemplo 2.3\n",
        "# Bucle while para encontrar una fruta\n",
        "frutas = [\"manzana\", \"banana\", \"cereza\", \"kiwi\", \"dátil\"]\n",
        "\n",
        "#Índice inicial\n",
        "i = 0\n",
        "\n",
        "#Bucle while para buscar la palabra \"kiwi\"\n",
        "while i < len(frutas) and frutas[i] != \"kiwi\":\n",
        "    # Pasar a la siguiente palabra\n",
        "    i += 1\n",
        "\n",
        "#Verificar si se encontró la palabra\n",
        "if frutas[i] == \"kiwi\":\n",
        "    print(\"La palabra 'kiwi' está en la lista.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r1l7YDF888Ga"
      },
      "source": [
        "# **3.0 | LISTAS**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rmakoext9Bdy",
        "outputId": "bd1fa74e-814e-473f-aa06-f10e30504b98"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Edad 1: 20\n",
            "[20, 84, 18, 41, 36, 25]\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 3.1\n",
        "# Crear lista de enteros\n",
        "edades= [20,84,18,41,36,25]\n",
        "\n",
        "print(\"Edad 1:\",edades[0])\n",
        "print(edades)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Cqcjbhw2rjey",
        "outputId": "798034c0-badb-46e3-930e-012a7c863a32"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['Lisy', 'Isabel', 'Daniel', 'Sergio']\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 3.1.1\n",
        "# Borrar un elemento de la lista: remove\n",
        "nombres = [\"Lisy\", \"Isabel\", \"Daniel\", \"Andrea\", \"Sergio\"]\n",
        "nombres.remove(\"Andrea\")\n",
        "print(nombres)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yw12Aiuirln_",
        "outputId": "b7c4bb9b-d0d3-425e-ef93-1c3aa016921f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[]\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 3.1.2\n",
        "# .clear (elimina todos los elementos de una lista)\n",
        "nombres = [\"Lisy\", \"Isabel\", \"Daniel\", \"Andrea\", \"Sergio\"]\n",
        "nombres.clear()\n",
        "print(nombres)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nmtBwaUTtGDK",
        "outputId": "f5ac4e3b-6960-4b90-9942-5d293b47142f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['Lisy', 'Isabel', 'Daniel', 'Andrea', 'Sergio', 'Pepito']\n",
            "Nombre 6: Pepito\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 3.1.3\n",
        "# .append (añadir elementos a la lista)\n",
        "\n",
        "nombres= [\"Lisy\", \"Isabel\", \"Daniel\", \"Andrea\", \"Sergio\"]\n",
        "\n",
        "nombres.append(\"Pepito\")\n",
        "print(nombres) # Mostramos la cadena con todos los valores de la lista\n",
        "print(\"Nombre 6:\",nombres[5])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qta-Th-PE1W-",
        "outputId": "26a875e0-9c5a-467e-bc6d-0cd4fc7531a5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['Lisy', 'Isabel', 'Daniel', 'Andrea', 'Sergio']\n",
            "Nombre 3: Daniel\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 3.2\n",
        "# Creando listas de cadenas\n",
        "nombres= [\"Lisy\", \"Isabel\", \"Daniel\", \"Andrea\", \"Sergio\"]\n",
        "\n",
        "print(nombres)\n",
        "print(\"Nombre 3:\",nombres[2])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xV2gnJJPA0Hh",
        "outputId": "c5210cd8-c069-41fa-847a-b1794b9bd2a3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['Jazmin', 'Rosa']\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 3.2.1\n",
        "# Segmentacion\n",
        "flores = [\"Jazmin\", \"Rosa\", \"Orquidea\", \"Margarita\"] #se crea la lista teniendo en cuenta su estructura\n",
        "flores_before_Orquidea = flores[0:2] # se crea una sublista que contenga las flores desde indice 0 y hasta el indice 1. No incluye el elemento de la posicion 2\n",
        "print(flores_before_Orquidea) #se imprime en pantalla la lista con los dos elementos solicitados"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T1o-dkP9B7q4",
        "outputId": "597490f7-97f7-4a38-bc61-fad04e048cf9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[['Io', 'Europa', 'Ganimedes', 'Calisto', 'Amaltea', 'Himalia', 'Elara', 'Pasifae', 'Sinope', 'Lysithea', 'Mimas', 'Encélado', 'Tetis', 'Dione', 'Rhea', 'Titán']]\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 3.2.2\n",
        "# Combinacion\n",
        "lunas_de_jupiter = [ \"Io\", \"Europa\", \"Ganimedes\", \"Calisto\", \"Amaltea\", \"Himalia\", \"Elara\", \"Pasifae\", \"Sinope\", \"Lysithea\" ] #se crea una lista\n",
        "lunas_de_saturno = [ \"Mimas\", \"Encélado\", \"Tetis\", \"Dione\", \"Rhea\", \"Titán\" ] # se crea una segunda lista\n",
        "lunas_de_jupiter_y_saturno = [lunas_de_jupiter + lunas_de_saturno] # se crea la combinacion de las dos listas anteriores usando el operativo +\n",
        "print(lunas_de_jupiter_y_saturno) # se imprime el resultado de la combinacion de las dos listas anteriores"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A652pCnqkNLL",
        "outputId": "f4f08bc4-0205-460c-cba4-7fd19fdf5013"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 3.3\n",
        "# Count\n",
        "frutas = ['manzana', 'banana', 'naranja', 'manzana', 'pera', 'manzana']\n",
        "cantidad_manzanas = frutas.count('manzana')\n",
        "print(cantidad_manzanas)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sEXy3BU5lY_B",
        "outputId": "5d90af03-8edd-4b37-d8f2-f808d1132b97"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 3.4\n",
        "# Index (indicar la posicion del elemento dentro de la lista)\n",
        "numeros = [10, 20, 30, 40, 50]\n",
        "indice_30 = numeros.index(30)\n",
        "print(indice_30)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6RxSTZzflzia",
        "outputId": "d2eefd10-2e3d-444c-e10d-ec8f742108a2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(1986, 1945, 2006, 2017, 2004, 1999)\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 3.5\n",
        "# Convertir una lista  a tupla\n",
        "\n",
        "desceso = [1986, 1945, 2006, 2017, 2004, 1999]\n",
        "desceso_tupla = tuple(desceso)\n",
        "print(desceso_tupla)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P-zVq4wymVqq",
        "outputId": "5a574d0e-e9c5-4cf2-e370-7842d949b553"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "None\n",
            "None\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 3.5\n",
        "# .sort\n",
        "notas= [1,10,6,7,4,9]\n",
        "\n",
        "notas_ascendente = notas.sort() #modifica la lista original pero no devuelve una lista ordenada\n",
        "notas_descendente = notas.sort(reverse=True)\n",
        "\n",
        "print(notas_ascendente)\n",
        "print(notas_descendente)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WC2Il4oVnb-M",
        "outputId": "bb2a24c0-1f9b-4b53-e7b1-27bfb92dba95"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1, 4, 6, 7, 9, 10]\n",
            "[10, 9, 7, 6, 4, 1]\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 3.6\n",
        "# .sorted\n",
        "\n",
        "[1, 10, 6, 7, 4, 9]\n",
        "notas_ascendente = sorted(notas) #para mantener la version original de la lista se puede usar sorted\n",
        "notas_descendente = sorted(notas, reverse=True) #devuelve una lista ordenada\n",
        "\n",
        "print(notas_ascendente)\n",
        "print(notas_descendente)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ERJpczVOm9Yh",
        "outputId": "dbf360b2-75e7-4e6f-93f8-89f94e90ed8c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[3, 2, 1]\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 3.7\n",
        "# .reverse (revertir el orden de una lista)\n",
        "numeros = [1, 2, 3]\n",
        "numeros.reverse()\n",
        "print(numeros)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p0aA9iNCnFBo",
        "outputId": "71b2ed13-3ef9-42a6-c942-55cec29a642d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Los habitantes de Narnia son  4\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 3.8\n",
        "# len\n",
        "habitantes_de_narnia = ['Aslan', 'Digory', 'Edmund', 'Lucy']\n",
        "cantidad = len(habitantes_de_narnia) #con len se mide la cantidad de elementos que hay en la lista\n",
        "print(\"Los habitantes de Narnia son \",cantidad)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HBGapCo0nSfw",
        "outputId": "248ba7f4-55ec-4dcb-fb25-3c946395542b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 3.9\n",
        "# in\n",
        "nombres = [\"Pepe\", \"Luis\", \"Alex\", \"Andrea\", \"Rosa\", \"Sara\"]\n",
        "\n",
        "print(\"Andrea\" in nombres)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vG-Jn2q7AgiP"
      },
      "source": [
        "#**4.0 | TUPLAS**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ce2HxpTKveNv",
        "outputId": "d4e7020d-7294-4f7e-98cf-0446aebf95ae"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Producto 1:  Manzana\n",
            "('Manzana', 'Pera', 'Naranja', 'Tomate', 'Sandía')\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 4.1\n",
        "# Crear una tupla\n",
        "productos = (\"Manzana\", \"Pera\", \"Naranja\", \"Tomate\", \"Sandía\")\n",
        "\n",
        "# A diferencia de las listas, las tuplas se declaran con paréntesis () y no con corchetes []\n",
        "\n",
        "print(\"Producto 1: \",productos[0])\n",
        "print(productos)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rmsjd0A6tSk1",
        "outputId": "cd85e51b-3804-4a5c-ef1a-99d10b6c8aa3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "El índice de Manzana es: 0\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 4.2\n",
        "# .index (saber el índice de un elemento específico de la lista)\n",
        "\n",
        "productos = (\"Manzana\", \"Pera\", \"Naranja\", \"Tomate\", \"Sandía\")\n",
        "\n",
        "print(\"El índice de Manzana es:\", productos.index(\"Manzana\"))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8t5DLaemtY5q"
      },
      "outputs": [],
      "source": [
        "#Ejemplo 4.3\n",
        "# -count (contar el número de veces que está un elemento en la tupla)\n",
        "\n",
        "personajes = (\"Leonard\", \"Sheldon\", \"Rajesh\", \"Penny\", \"Howard\", \"Rajesh\")\n",
        "\n",
        "print(\"Este personaje está\", personajes.count(\"Rajesh\"), \"veces en la tupla\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9SQE_EGjtbLe"
      },
      "outputs": [],
      "source": [
        "#Ejemplo 4.4\n",
        "# len (Obtener el número total de personajes en la tupla)\n",
        "\n",
        "personajes = (\"Leonard\", \"Sheldon\", \"Rajesh\", \"Penny\", \"Howard\", \"Rajesh\")\n",
        "\n",
        "total_personajes = len(personajes)\n",
        "\n",
        "print(f\"El número total de personajes en la tupla es: {total_personajes}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-vfpJwwuOyXb",
        "outputId": "b03dafab-6a94-42bc-f212-6c97eb2d56df"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Este animal no forma parte del zoológico.\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 4.5\n",
        "# Utilizamos al mismo tiempo las tuplas y los condicionales. En este caso, trabajamos con la tupla de animales de un zoo.\n",
        "animales_del_zoo = (\"jirafa\", \"león\", \"tigre\", \"cebra\", \"elefante\", \"rinoceronte\", \"pantera\", \"cocodrilo\", \"hipopótamo\", \"serpiente\", \"gorila\", \"chimpancé\", \"ballena\", \"orca\", \"delfín\", \"tortuga\", \"pingüino\", \"águila\", \"halcón\", \"mariposa\", \"abeja\", \"escorpión\", \"murciélago\", \"araña\", \"tiburón\", \"ballena\", \"pez payaso\", \"iguana\", \"camaleón\", \"lombriz\")\n",
        "\n",
        "# Verificar si un nombre de animal está en la tupla de animales\n",
        "animal_buscado = \"cabra\"\n",
        "if animal_buscado in animales_del_zoo:\n",
        "    print(\"El animal forma parte del zoológico.\")\n",
        "else:\n",
        "    print(\"Este animal no forma parte del zoológico.\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/"
        },
        "id": "ALepD27NgZUN",
        "outputId": "6ae97935-d9e9-4b7c-96f0-ea27ee004585"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Las coordenadas de Salamanca son: (40.427, -3.679)\n"
          ]
        }
      ],
      "source": [
        "# Ejemplo 4.6\n",
        "#Tupla dentro de tupla que contiene los nombres y coordenadas de los barrios, datos que no varían con el tiempo.\n",
        "\n",
        "tupla_barrios = (\n",
        "    (\"Delicias\", (40.398, -3.695)),\n",
        "    (\"La Elipa\", (40.422, -3.657)),\n",
        "    (\"Retiro\", (40.415, -3.684)),\n",
        "    (\"Chamberí\", (40.434, -3.703)),\n",
        "    (\"Malasaña\", (40.426, -3.704)),\n",
        "    (\"Salamanca\", (40.427, -3.679)),\n",
        "    (\"Chamartín\", (40.457, -3.676)),\n",
        "    (\"Barrio de las Letras\", (40.414, -3.699)),\n",
        "    (\"Arganzuela\", (40.398, -3.693)),\n",
        "    (\"Moncloa-Aravaca\", (40.435, -3.718))\n",
        ")\n",
        "\n",
        "while True:\n",
        "    # Pedir al usuario el nombre del barrio\n",
        "    nombre_barrio = input(\"Ingrese el nombre del barrio (o 'salir' para finalizar): \")\n",
        "\n",
        "    # Verificar si el usuario quiere salir del bucle\n",
        "    if nombre_barrio.lower() == \"salir\":\n",
        "        break\n",
        "\n",
        "    # Buscar el nombre del barrio en la tupla y mostrar sus coordenadas si se encuentra\n",
        "    for nombre, coordenadas in tupla_barrios:\n",
        "        if nombre.lower() == nombre_barrio.lower():\n",
        "            print(f\"Las coordenadas de {nombre} son: {coordenadas}\")\n",
        "            break\n",
        "    else:\n",
        "        # Mostrar un mensaje si el barrio no está en la lista\n",
        "        print(f\"El barrio '{nombre_barrio}' no está en la lista.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RRUz_uWM7zB5"
      },
      "source": [
        "#**5.0 | Comprensión de listas//list comprehension**\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FDp8Sj2eBeoK"
      },
      "outputs": [],
      "source": [
        "#Ejemplo 5.1\n",
        "# Crear una lista de cuadrados de los primeros 10 números:\n",
        "\n",
        "cuadrados = [x ** 2 for x in range(10)]\n",
        "\n",
        "print(cuadrados)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KxsAZnR3-FtM"
      },
      "outputs": [],
      "source": [
        "#Ejemplo 5.2.1\n",
        "# Filtrar números impares y elevarlos al cubo\n",
        "numeros = range(10)\n",
        "cubos_impares = [x**3 for x in numeros if x % 2 != 0]\n",
        "print(cubos_impares)  # [1, 27, 125, 343, 729]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BkNg8p_FY9nE",
        "outputId": "e4cd367a-ab35-42e7-a665-1e132ec39047"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1, 27, 125, 343, 729]\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 5.2.2\n",
        "# Filtrar números impares y elevarlos al cubo SIN LIST COMPREHENSIONS\n",
        "numeros = range(10)\n",
        "cubos_impares = []\n",
        "\n",
        "for x in numeros:\n",
        "    if x % 2 != 0:\n",
        "        cubos_impares.append(x**3)\n",
        "\n",
        "print(cubos_impares)  # [1, 27, 125, 343, 729]\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E5reg4JhYMeQ"
      },
      "source": [
        "Comparando los dos enfoques (5.2.1vs5.2.2), es evidente que las list comprehensions permiten escribir código más conciso y limpio, lo que puede mejorar la mantenibilidad y la comprensión del código."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-vhsLP-ULXmc",
        "outputId": "732460ef-53a6-4f24-afca-da20ee75b81f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['la jirafa', 'el león', 'el tigre', 'la cebra', 'el elefante', 'el rinoceronte', 'la pantera', 'el cocodrilo', 'el hipopótamo', 'la serpiente', 'el gorila', 'el chimpancé', 'la ballena', 'la orca', 'el delfín', 'la tortuga', 'el pingüino', 'el águila', 'el halcón', 'la mariposa', 'la abeja', 'el escorpión', 'el murciélago', 'la araña', 'el tiburón', 'la ballena', 'el pez payaso', 'la iguana', 'el camaleón', 'la lombriz']\n",
            "[6, 4, 5, 5, 8, 11, 7, 9, 10, 9, 6, 9, 7, 4, 6, 7, 8, 6, 6, 8, 5, 9, 10, 5, 7, 7, 10, 6, 8, 7]\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 5.3\n",
        "#Cadena de animales de la selva\n",
        "animales_de_la_selva = \"la jirafa, el león, el tigre, la cebra, el elefante, el rinoceronte, la pantera, el cocodrilo, el hipopótamo, la serpiente, el gorila, el chimpancé, la ballena, la orca, el delfín, la tortuga, el pingüino, el águila, el halcón, la mariposa, la abeja, el escorpión, el murciélago, la araña, el tiburón, la ballena, el pez payaso, la iguana, el camaleón, la lombriz\"\n",
        "\n",
        "# Separar la cadena en una lista de palabras\n",
        "palabras = animales_de_la_selva.split(\", \")\n",
        "\n",
        "# Filtrar y calcular la longitud de las palabras excluyendo \"el\", \"la\" y el espacio adicional\n",
        "longitud_palabras = [len(palabra[3:]) for palabra in palabras if palabra[:3] in [\"el \", \"la \"]]\n",
        "\n",
        "print(palabras)\n",
        "print(longitud_palabras)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uBrWzM5JEMG8",
        "outputId": "f07116ea-7799-438e-8c78-6514fbf1564e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['APPLE', 'BANANA', 'CHERRY', 'DATE', 'ELDERBERRY', 'FIG', 'GRAPE', 'HONEYDEW', 'KIWI', 'LEMON']\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 5.4\n",
        "# Convertir toda la lista a MAYÚSCULAS\n",
        "\n",
        "# Lista de 10 frutas\n",
        "fruits = [\"apple\", \"banana\", \"cherry\", \"date\", \"elderberry\", \"fig\", \"grape\", \"honeydew\", \"kiwi\", \"lemon\"]\n",
        "\n",
        "# Convertir cada fruta a mayúsculas usando comprensión de listas\n",
        "uppercase_fruits = [fruit.upper() for fruit in fruits]\n",
        "\n",
        "# Imprimir la lista resultante\n",
        "print(uppercase_fruits)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fOTe88a1ilqg",
        "outputId": "77d275ab-27ac-4377-e315-021fe40fceb9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[('Ana', 23, 'Valencia'), ('Joaquín', 34, 'Bilbao'), ('Beatriz', 29, 'Barcelona'), ('Juan', 19, 'Madrid'), ('Elena', 42, 'Sevilla')]\n"
          ]
        }
      ],
      "source": [
        "#Ejemplo 5.5\n",
        "# zip\n",
        "nombres = [\"Ana\", \"Joaquín\", \"Beatriz\", \"Juan\", \"Elena\"]\n",
        "edades = (23, 34, 29, 19, 42)\n",
        "ciudades = {\"Madrid\", \"Barcelona\", \"Sevilla\", \"Valencia\", \"Bilbao\"}\n",
        "\n",
        "# Usando zip con diferentes tipos de iterables\n",
        "combinados = zip(nombres, edades, ciudades)\n",
        "print(list(combinados))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IOUQ86LLVETo"
      },
      "source": [
        "#**6.0 | EJERCICIO**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KO-K31S6Unnt",
        "outputId": "bf53d9ee-ffb0-42f4-aaa8-63be48f096e7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Estudiantes menores de 18 años:\n",
            "Juan\n",
            "Pedro\n",
            "Luis\n",
            "\n",
            "Estudiantes de 18 años o más:\n",
            "María\n",
            "Ana\n"
          ]
        }
      ],
      "source": [
        "#Lista de estudiantes con sus nombres y edades\n",
        "estudiantes = [(\"Juan\", 16), (\"María\", 19), (\"Pedro\", 17), (\"Ana\", 20), (\"Luis\", 15)]\n",
        "\n",
        "# Crear listas para estudiantes menores de 18 y mayores de 18 años\n",
        "menores_de_18 = []\n",
        "mayores_de_18 = []\n",
        "\n",
        "# Organizar a los estudiantes en los grupos correspondientes\n",
        "for nombre, edad in estudiantes:\n",
        "    if edad < 18:\n",
        "        menores_de_18.append(nombre)\n",
        "    else:\n",
        "        mayores_de_18.append(nombre)\n",
        "\n",
        "# Imprimir los nombres de los estudiantes en cada grupo\n",
        "print(\"Estudiantes menores de 18 años:\")\n",
        "for nombre in menores_de_18:\n",
        "    print(nombre)\n",
        "\n",
        "print(\"\\nEstudiantes de 18 años o más:\")\n",
        "for nombre in mayores_de_18:\n",
        "    print(nombre)\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "85A2pMjuxtj3",
        "r1l7YDF888Ga",
        "vG-Jn2q7AgiP",
        "RRUz_uWM7zB5",
        "IOUQ86LLVETo"
      ],
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}