Python_CoderDojo07.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python_CoderDojo07.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "THEjhFle1jKe",
        "WhpGf5K6INN3"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/seldoncode/Python_CoderDojo/blob/main/Python_CoderDojo07.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q632aWzYdN5h"
      },
      "source": [
        "# Tipos de datos\n",
        "* int → Enteros\n",
        "* float → Flotantes, decimales\n",
        "* str → String, cadenas\n",
        "* bool → Booleanos (True,False)\n",
        "* list → Listas, ejemplo [1,2,3]\n",
        "\n",
        "Con la función ```type()``` podemos saber de que tipo es cada dato."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zcPxgJlycz1m",
        "outputId": "0e442320-7fad-4854-de9d-17c3cd99fd33"
      },
      "source": [
        "type(5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NNxm1Wm2eNab",
        "outputId": "299940b3-529e-40f7-a1cc-4d11dbb98b3a"
      },
      "source": [
        "type(8/2)   # 8/2 da como resultado 4.0 que es un número decimal o flotante "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5Ph5mjRrefI2",
        "outputId": "1abe4dbf-fce9-4aac-f422-0b669ba061d4"
      },
      "source": [
        "type(\"Hola\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aJY6SH_nelHM",
        "outputId": "a18f76b9-70ed-4b5e-b4d8-f62a7ef95f58"
      },
      "source": [
        "type(2==8/4)   # la condición lógica da True que es un booleano"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "bool"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MK_h3U_Nev0w",
        "outputId": "16a6ac14-de72-4a22-96eb-794139231300"
      },
      "source": [
        "l = [\"Madrid\",\"Berlín\",\"Paris\",\"Roma\"]    # definimos la lista l que contiene cuatro elementos de tipo str\n",
        "type(l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0luPskwKfJOZ"
      },
      "source": [
        "# Accediendo a los caracteres de un string\n",
        "* Los caracteres de un string comienzan a numerarse por cero.\n",
        "* Se denomina índice (index) al número con el que nos referimos a la posición de cada caracter.\n",
        "* Ejemplo:\n",
        " - \"Hola\" tiene cuatro caracteres y el index comienza por cero\n",
        "   * índice 0: 'H'\n",
        "   * índice 1: 'o'\n",
        "   * índice 2: 'l'\n",
        "   * índice 3: 'a'\n",
        "\n",
        "| Index | Caracter |\n",
        "|------:|---------:|\n",
        "|      0|       'H'|\n",
        "|      1|       'o'|\n",
        "|      2|       'l'|\n",
        "|      3|       'a'|\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "OlNcduGAhTiN",
        "outputId": "a41f1270-7bc4-427f-fe37-e6565c5328fe"
      },
      "source": [
        "palabra = \"Hola\"\n",
        "palabra[0]            # así accedemos al caracter de índice 0"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'H'"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "HO3ZufkAhgxc",
        "outputId": "466112e5-3130-4dc1-b181-ea1796303de4"
      },
      "source": [
        "palabra[1]            # así accedemos al caracter de índice 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'o'"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "zjqMrRYihiPK",
        "outputId": "a11c5ac7-6973-42f5-f0a7-ed09e1a82bcf"
      },
      "source": [
        "palabra[2]            # así accedemos al caracter de índice 2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'l'"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "aHdSooMNhhty",
        "outputId": "d24a085e-10d3-4e92-de08-febbf9af8c7d"
      },
      "source": [
        "palabra[3]            # así accedemos al caracter de índice 3"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'a'"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "3C6OCkNehu2Q",
        "outputId": "0f99be8d-0beb-4ce8-e293-f80cd8c561d7"
      },
      "source": [
        "\"Avión\"[1]             # accedemos a la letra 'v' ya que ocupa el índice 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'v'"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CbR9x-vgiBuh"
      },
      "source": [
        "## Índices negativos\n",
        "Podemos acceder a los índices negativos.\n",
        "-1 hace referencia al último caracter."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "56DBvN_riNMs",
        "outputId": "c95fb98f-4ad9-4951-c345-3562a74da91f"
      },
      "source": [
        "print(palabra[-1])      # 'a'\n",
        "print(palabra[-2])      # 'l'\n",
        "print(palabra[-3])      # 'o'\n",
        "print(palabra[-4])      # 'H'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a\n",
            "l\n",
            "o\n",
            "H\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QBC4iZoIvpbc"
      },
      "source": [
        "## Slicing strings\n",
        "Podemos recortar una cadena tomando unos cuantos caracteres."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "2qZ19swzy5nS",
        "outputId": "f5f720e8-05aa-4a12-9c6f-35d8e106b2a8"
      },
      "source": [
        "cadena = \"Buenos Aires\"\n",
        "cadena[0:5]              # recortamos la cadena desde el caracter de índice 0 al índice 4"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Bueno'"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "LPlQjYdKz303",
        "outputId": "775bd7c8-8f17-430e-8325-75fc4d6c795e"
      },
      "source": [
        "cadena[:5]               # si no se pone el inicio se comienza desde el índice cero"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Bueno'"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "2dKOjaiY02lx",
        "outputId": "ef387256-a37b-4668-902b-bdf3fb07ff11"
      },
      "source": [
        "cadena[2:6]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'enos'"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "7SkRukJF1X6r",
        "outputId": "9baf300a-d63e-4aad-ac83-c49df3ee3dfa"
      },
      "source": [
        "cadena[7:12]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Aires'"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "0aFZxZ4N136X",
        "outputId": "7e805e51-d738-4a26-f77a-23c4596bc28e"
      },
      "source": [
        "cadena[7:]               # si no ponemos el final se obtiene hasta el último caracter"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Aires'"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vJbVU1ozz4ae"
      },
      "source": [
        "### Slicing y variables"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IhTPqtsE2Ek7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "7150b556-39d2-4d75-cf12-e1e4bf5fdb7e"
      },
      "source": [
        "a = \"Frecuencia\"\n",
        "b = \"casa\"\n",
        "c = a[:3] + b[2:]\n",
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Fresa'"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "THEjhFle1jKe"
      },
      "source": [
        "### Reto 7.1. Construir palabras usando otras\n",
        "Usando las variables:\n",
        "* a = \"ovillo\"\n",
        "* b = \"transformara\"\n",
        "* c = \"amoroso\"\n",
        "\n",
        "costruya la variable:\n",
        "\n",
        "* d = \"maravilloso\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cX_bc2Ns8r18"
      },
      "source": [
        "# Longitud de una cadena\n",
        "Podemos calcular la logitud de una cadena alfanumérica con:\n",
        "\n",
        "```len(string)```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KstYRrjY9R3a",
        "outputId": "c6e070af-6c47-40e7-d9f6-9681ec655425"
      },
      "source": [
        "len(\"Hola\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5GQwVgb49Z0x",
        "outputId": "a549ea53-ecd5-4fae-9985-a85f2425a6cd"
      },
      "source": [
        "a = \"Buenos días\"    # el espacio cuenta como un caracter más\n",
        "len(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "11"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xjUH_z3M-X-y"
      },
      "source": [
        "# Listar todos los caracteres que componen una palabra o frase\n",
        "### Accediendo a los caracteres del string  \n",
        "Usaremos un bucle ```while``` y recorreremos todos los caracteres, accediendo a ellos de forma individual.\n",
        "\n",
        "Como variable auxiliar del ```while``` utilizaremos la letra ```i``` que hace referencia al index del string."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nXDUUlqb_Cjr",
        "outputId": "d430def7-6a32-4ef0-8024-05fc71f7f474"
      },
      "source": [
        "palabra = \"Playa\"           # la longitud de Playa es 5\n",
        "i=0                         # inicializamos la variable auxiliar i que hace referencia al index del string\n",
        "while i <= len(palabra)-1:    # la variable i, que hace referencia la index de cada caracter, toma los valores 0, 1, 2, 3, 4\n",
        "  print(palabra[i])         # imprimimos el caracter i-ésimo (el de índice i que toque en cada ciclo del loop)\n",
        "  i += 1                    # incrementa el valor de i (index) de uno en uno\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "P\n",
            "l\n",
            "a\n",
            "y\n",
            "a\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CkcgHLFYBiWP"
      },
      "source": [
        "El siguiente código es una variante del código anterior.  \n",
        "¿Cuál te gusta más?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cYuH2XetBmpi",
        "outputId": "8871f241-86e5-49fb-adf4-5c491ec97f09"
      },
      "source": [
        "palabra = \"Playa\"\n",
        "i=0\n",
        "while i<len(palabra):       # la variable auxiliar i toma los valores 0, 1, 2, 3, 4 de esta forma recorre los 5 caracteres de Playa por su índice\n",
        "  print(palabra[i])\n",
        "  i += 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "P\n",
            "l\n",
            "a\n",
            "y\n",
            "a\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1O8d2GO9Dvu_"
      },
      "source": [
        "## Contar cuantas veces aparece un caracter en una frase\n",
        "Contar cuantas veces aparece la letra 'i' acentuada o sin acentuar en la siguiente frase:\n",
        "\n",
        "En un lugar de la Mancha, de cuyo nombre no quiero acordarme, no ha mucho tiempo que vivía un hidalgo de los de lanza en astillero, adarga antigua, rocín flaco y galgo corredor."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9XXhXThLEI7r",
        "outputId": "fb694146-3a64-4e2a-a504-8fbb72e724b7"
      },
      "source": [
        "frase = '''\n",
        "En un lugar de la Mancha, de cuyo nombre no quiero acordarme, \n",
        "no ha mucho tiempo que vivía un hidalgo de los de lanza en astillero, \n",
        "adarga antigua, rocín flaco y galgo corredor.'''\n",
        "\n",
        "contador = 0\n",
        "n=0\n",
        "while n < len(frase):\n",
        "  if frase[n]=='i' or frase[n]=='í':\n",
        "    contador += 1\n",
        "  n += 1\n",
        "\n",
        "print(contador)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "66b-B4EQGVBb"
      },
      "source": [
        "## Los string son inmutables\n",
        "Podemos acceder al contenido de un caracter dentro de un string pero no podemos cambiarlo."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "jIJPVE_qGeog",
        "outputId": "2048a7d8-fc82-4c76-9770-b3ffc063cdfa"
      },
      "source": [
        "palabra = \"libro\"\n",
        "palabra[4]               # podemos acceder a la última letra por su índice"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'o'"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pkBcDHoYHOO4"
      },
      "source": [
        "#palabra[4] = 'e'        # ERROR: no podemos cambiar la última letra ya que los strings son inmutables"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RlaZ_VabHM7z"
      },
      "source": [
        "Con el siguiente truco podemos modificar el contenido de una palabra cambiando una letra."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "WAUimwn7Hq6Z",
        "outputId": "517984fc-5700-4168-d60b-61940242a5bf"
      },
      "source": [
        "palabra =  \"libro\"\n",
        "palabra = palabra[:-1] + 'e'        # tomamos parte de la palabra con slicing y con el signo + concatenamos con el caracter que queremos cambiar\n",
        "palabra"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'libre'"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WhpGf5K6INN3"
      },
      "source": [
        "### Reto 7.2. Cambar una palabra cambiando una parte de ella\n",
        "Convierte la palabra 'gato' en 'gota' modificando el string."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fnhsMR6V9oae"
      },
      "source": [
        "# Instrucción ```in```\n",
        "## Ver si un caracter está en una palabra\n",
        "Con la partícula ```in``` podemos comprobar si un caracter se encuentra en un stgring."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X2RF1Vht9y-u",
        "outputId": "e0ac193f-674f-44c9-9094-2e8a45e232cf"
      },
      "source": [
        "'h' in 'ahora'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eP69rfOk930I",
        "outputId": "5ef37aa4-2356-4b61-d1ce-22c4eb8d570e"
      },
      "source": [
        "'e' in \"España\"       # los string son case-sensitive (sesibles a mayúsculas y minúsculas)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dwqZCOyQOF6Q",
        "outputId": "7fdc4f5d-8e5a-4fc0-ef49-8ac313f297a8"
      },
      "source": [
        "'sp' in \"España\"      # tambień podemos ver si varios caracteres están en un string"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ToZns9DtOeMX",
        "outputId": "0dab2157-3400-4807-f312-95905719f475"
      },
      "source": [
        "'cosmo' not in 'astronauta'   # también funciona:  not in"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "byRCicxpQgIH"
      },
      "source": [
        "## Funciones ```lower()``` y ```upper()```\n",
        "* La función ```lower()``` conviente un string todo a minúsculas.\n",
        "* La función ```upper()``` conviente un string todo a mayúsculas."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q_zC2ZEJRUf6",
        "outputId": "7f850519-5208-4cfa-c863-6e8778b15c3e"
      },
      "source": [
        "frase = \"En Los Ángeles vive Ana\"\n",
        "print(frase.lower())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "en los ángeles vive ana\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oeZx4ABjSEE5",
        "outputId": "be201135-3399-45d4-ceef-5a4b871702f9"
      },
      "source": [
        "frase = \"En Los Ángeles vive Ana\"\n",
        "print(frase.upper())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "EN LOS ÁNGELES VIVE ANA\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x-P053coOx5b"
      },
      "source": [
        "### Vocales de una palabra\n",
        "Dada una palabra o frase contar cuántas vocales tiene, incluyendo las que llevan o no llevan tilde.\n",
        "\n",
        "vocales = \"aeiouáéíóú\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HvIzPErWPu5l",
        "outputId": "e17a9901-5adc-4f1a-8bc0-d90411e97bd0"
      },
      "source": [
        "palabra = \"América\"\n",
        "palabra = palabra.lower()  # convertimos todo a minúsculas\n",
        "vocales = \"aeiouáéíóú\"\n",
        "i = 0                      # i es el índice\n",
        "num_voc = 0\n",
        "while i < len(palabra):\n",
        "  if palabra[i] in vocales:\n",
        "    num_voc += 1\n",
        "  i += 1\n",
        "print(\"El número de vocales es\", num_voc)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "El número de vocales es 4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DP0ACJVYTjX7"
      },
      "source": [
        "### Reto 7.1. Vocales y consonantes de una palabra\n",
        "Dada una palabra calcular el número de vocales y consonantes que tiene.\n",
        "\n",
        "consonantes = \"bcdfghjklmnñpqrstvwxyz\"\n",
        "\n",
        "¿En su código ha usado ```elif```?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B3gFhO1vXTI9"
      },
      "source": [
        "# Tuplas\n",
        "Una tupla es una estructura de datos que contiene varios elementos.\n",
        "\n",
        "Son un tipo de datos secuencia al igual que los string o las listas.\n",
        "\n",
        "Los elementos se guardan entre paréntesis.\n",
        "\n",
        "Se parecen a las listas, pero en las listas los datos van entre corchetes [1,2,3] y existen diferencias entre ambas estructuras de datos secuencia."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i6yXKlG0XlBO",
        "outputId": "df4eb711-2f84-4b3a-8c52-4a3ee896601d"
      },
      "source": [
        "mitupla = (1,2,3)         # los datos van entre paréntesis\n",
        "mitupla\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 2, 3)"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f26M6Lr8X4tH",
        "outputId": "e67ddb0d-fafd-4d46-c5c0-11ceb6be229b"
      },
      "source": [
        "otratupla = (90,'Hola',3.14,(1,2,3),True)   # una tupla puede incluir diferentes tipos de datos, incluso otras tuplas\n",
        "otratupla"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(90, 'Hola', 3.14, (1, 2, 3), True)"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XfvFOAZ1ZPeG"
      },
      "source": [
        "### Concatenando tuplas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9-mt0wrHZUDH",
        "outputId": "db2b76ce-e050-451e-b5a3-7e83a26fdef1"
      },
      "source": [
        "t1 = (1,2,3)\n",
        "t2 = (4,5,6,7)\n",
        "t3 = t1 + t2          # concatemamos tuplas\n",
        "t3"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 2, 3, 4, 5, 6, 7)"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V3iL5FfRaMbN",
        "outputId": "22d462b9-44d0-43d9-e187-8013dce556c0"
      },
      "source": [
        "t1+t2 == t2+t1       # las tuplas son estructuras de datos ordenadas. El orden importa"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z3Ka53_8aZ97"
      },
      "source": [
        "### Accediendo a los elementos de una tupla por su índice"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "q0IrY6YsafRO",
        "outputId": "04940ebe-8b72-45f3-de9a-06d3a12de1b3"
      },
      "source": [
        "t = ('Madrid','París','Berlín','Roma','Londres','Amsterdam')\n",
        "t[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Madrid'"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2aOdvCBka74d",
        "outputId": "b379b62a-fa5d-4656-af77-b1402d791633"
      },
      "source": [
        "t[2:4]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('Berlín', 'Roma')"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NFrBQln_bFAe",
        "outputId": "e33ba9f3-519a-46b9-c566-b2c9bec3cf6a"
      },
      "source": [
        "t[4:5]   # devuelve solo un elemento pero en forma de tupla, observe la coma"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('Londres',)"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bL7xwyyLbjrB"
      },
      "source": [
        "## Trabajando con tuplas\n",
        "### Longitud"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lqVXbTDZbqhm",
        "outputId": "f7b9addf-67e0-4d03-fba2-3428123ed38c"
      },
      "source": [
        "len(t)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bXGO5fSVbs8H"
      },
      "source": [
        "### Creando una tupla\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dMLxDt0-lnLy",
        "outputId": "339c4c9b-4645-4e9a-8d2f-550ae4e30d1c"
      },
      "source": [
        "a = (1)      # esto no es una tupla de un elemento\n",
        "print(a)     # no se imprime con paréntesis ya que no es una tupla\n",
        "type(a)      # comprobamos que no es una tupla"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SxTjVwsnl7xA",
        "outputId": "758ff485-5e7c-40c7-f32d-b2b8413010d7"
      },
      "source": [
        "b = (1,)     # para que sea una tupla de un elemento, además de los paréntesis, tenemos que poner una coma\n",
        "print(b)     # aparece entre paréntesis porque si es una tupla\n",
        "type(b)      # comprobamos que es de tipo tupla"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1,)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BMixpTDSnPAz"
      },
      "source": [
        "### Convirtiendo una lista en una tupla\n",
        "Podemos convertir una lista en una tupla."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0-m7b_mcmTkj",
        "outputId": "415ff40d-18cf-4174-9803-5d1544e4505b"
      },
      "source": [
        "c = tuple([1,2,3]) # La lista va entre corchetes [1,2,3] y se conviente en tupla con la función tuple()\n",
        "print(c)           # aparece entre paréntesis porque si es una tupla\n",
        "type(c)            # comprobamos que es de tipo tupla"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 2, 3)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xPos6txe_MgG"
      },
      "source": [
        "## Dadas tres tuplas construir otra con parte de sus elementos\n",
        "Disponemos de las tres tuplas con lugares.  \n",
        "Deseamos crear una tupla que obtenga de las tuplas dadas solo las capitales."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EkA94bEy_LwV",
        "outputId": "95337df7-acad-4b26-996e-576e027ce305"
      },
      "source": [
        "geo1 = (\"Alemánia\",\"Madrid\",\"Italia\")\n",
        "geo2 = (\"Dinamarca\",\"Noruega\",\"Londres\")\n",
        "geo3 = (\"Dublín\",\"Portugal\")\n",
        "solucion1 = geo1[1:2]+geo2[2:]+geo3[0:1]\n",
        "solucion1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('Madrid', 'Londres', 'Dublín')"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QYj6ue_ZAcCh",
        "outputId": "fa93d58c-5ca0-43cf-ee51-3159ea096ef4"
      },
      "source": [
        "solucion2 = (geo1[1],geo2[2],geo3[0])\n",
        "solucion2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('Madrid', 'Londres', 'Dublín')"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SNGj9e91A2gg",
        "outputId": "082d948b-5341-4eef-92a9-a0469d9158a0"
      },
      "source": [
        "solucion3 = (geo1[1],)+(geo2[2],)+(geo3[0],)\n",
        "solucion3"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('Madrid', 'Londres', 'Dublín')"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G62BJ_rEBK0n"
      },
      "source": [
        "# Listas\n",
        "* Son otros de los datos secuencia.\n",
        "* Son los más utilizados.  \n",
        "* Los elementos vas entre corchetes.\n",
        "* En las listas los elementos van ordenados. El orden importa."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ui9-1D1XBcG9"
      },
      "source": [
        "lista = [1,2,3,4]\n",
        "lista"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s0VOZrmCBhLR",
        "outputId": "4eb41948-5676-4b64-9232-04ade44e73e0"
      },
      "source": [
        "l = [\"Rojo\",\"Verde\",\"Azul\",\"Rosa\",\"Naranja\"]\n",
        "l"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Rojo', 'Verde', 'Azul', 'Rosa', 'Naranja']"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2wFKwqgHBprF"
      },
      "source": [
        "### Las listas no son inmutables\n",
        "* Se pueden cambiar sus elementos.  \n",
        "* Las tuplas son inmutables. El cambio siguiente no se puede hacer en tuplas.\n",
        "* Cambiar el último color de la lista l por \"Amarillo\".\n",
        "* Las tuplas son más rápidas que las listas. Esto no se nota con pocos elementos."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rh2W_ZXgCDGY",
        "outputId": "defd312d-71f3-40ba-d848-db5fa53c0459"
      },
      "source": [
        "l[-1] = \"Amarillo\"        # el índice -1 hace referencia al último elemento\n",
        "l"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Rojo', 'Verde', 'Azul', 'Rosa', 'Amarillo']"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sjDUFWjEDAVl"
      },
      "source": [
        "#### Elige entre tupla o lista\n",
        "Tenemos que elegir entre tupla o lista para los dos siguientes conjuntos de datos:\n",
        "* Los días de la semana\n",
        "* Los días de entrenamiento"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "olbT4rH3DYhw",
        "outputId": "1aaadd76-7647-4a9d-d65f-f47452dda079"
      },
      "source": [
        "# Para las días de la semana elegimos tupla ya que no cambiarán\n",
        "dias_semana = (\"lun\",\"mar\",\"mié\",\"jue\",\"vie\",\"sáb\",\"dom\")\n",
        "# Para los días de entrenamiento elegiremos lista ya que pueden cambiar\n",
        "dias_entrenamiento = [\"lun\",\"mié\",\"vie\"]\n",
        "print(dias_semana)\n",
        "print(dias_entrenamiento)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('lun', 'mar', 'mié', 'jue', 'vie', 'sáb', 'dom')\n",
            "['lun', 'mié', 'vie']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "inr90OISK795"
      },
      "source": [
        "## Añadir elementos a una tupla"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v0zVViBcKm4p",
        "outputId": "8f701c03-6c22-4c14-f480-0d64c3a6b328"
      },
      "source": [
        "t = ()                 # tupla vacía\n",
        "t = t + (1,2)          # añadimos a la tupla inicial otra tupla con dos elementos\n",
        "t += (3,4,5)\n",
        "t"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 2, 3, 4, 5)"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RHjT472FLnLm"
      },
      "source": [
        "### Añadimos elementos a una lista"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1SUFa7oKLs0F",
        "outputId": "46f0e335-833e-4218-fe68-f2b8c932ccac"
      },
      "source": [
        "l = []                 # lista vacía\n",
        "l = l + [1,2]          # añadimos a la lista inicial otra lista con dos elementos\n",
        "l += [3,4,5]\n",
        "l"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5]"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0rujzElkMS9A",
        "outputId": "42552ecd-af8d-43c9-abef-404294d0679e"
      },
      "source": [
        "l = 3*l                 # repite tres veces la lista\n",
        "l"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SxDDDw9jMR_K"
      },
      "source": [
        "## Crear una lista añadiendo elementos\n",
        "Partiendo de una lista vacía y usando un ```while``` crear una lista con los números del 1 al 20."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Wh6G7RirND3N",
        "outputId": "3b21e4b7-4156-466c-96af-a2c0a9c76580"
      },
      "source": [
        "lis = []                # creamos una lista vacía\n",
        "i = 1                   # inicializamos el 1 el contador del while\n",
        "\n",
        "while i<=20:            # mientras i sea menor o igual a 20\n",
        "  lis += [i]            # añadimos al final de la lista el nuevo elemento\n",
        "  i += 1                # aumenta el contador en 1 en cada ciclo del loop\n",
        "\n",
        "print(lis)              # finalmente, fura del bucle, imprimimos la lista"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lxxxLNpcOBn3"
      },
      "source": [
        "### Reto 7.2. Construir una lista con los impares\n",
        "Partiendo de una lista vacía ir añadiendo elementos, usando un ```while``` hasta obtener una lista con los números **impares** entre 1 y 50. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IF8PiDE9PG9w"
      },
      "source": [
        "# Range\n",
        "* Tipo de datos secuencia\n",
        "* Podemos construir una estructura iterable con números usando range.\n",
        "* Lo que se obtiene es un dato de tipo range."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7LoO7lh0PZEc",
        "outputId": "819e8b5e-55ab-4416-c9b9-6c571f341334"
      },
      "source": [
        "range(5,20)          # rango con origen en 5 y final en 20, excluido el úlitmo, el 20 no entra        "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "range(5, 20)"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J_YFoY5bPhvh",
        "outputId": "d9566a2f-31d4-4c42-a2ed-c1d99384f893"
      },
      "source": [
        "r1 = range(10)       # si no se pone el origen se entiende que es cero, va de 0 a 9\n",
        "type(r1)             # vemos que es un objeto de tipo range\n",
        "print(r1)            # al imprimir el objeto no se ven los números\n",
        "print(list(r1))      # para que se vean se ha de convertir en lista usando list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "range(0, 10)\n",
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SAk447eDQ5AN",
        "outputId": "e8fadd3c-a3c8-438d-cc87-3938e907400f"
      },
      "source": [
        "10 in range(10)      # el último elemento no está incluido"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b4tLTe81REU4"
      },
      "source": [
        "### Range con salto\n",
        "Si usamos un tercer argumento estaremos poniendo el salto (step)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t82ZFUooRP-9",
        "outputId": "4da2afcf-1db8-4951-94c4-45e70999751f"
      },
      "source": [
        "list(range(5,50,5))        # va de 5 en 5. El paso o salto es 5. El 50 no se incluye."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[5, 10, 15, 20, 25, 30, 35, 40, 45]"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ivsJKXaxRw3-"
      },
      "source": [
        "### Juego: pedir impares dentro de un intervalo\n",
        "Pedir contínuamente impares enteros dentro del intervalo 10, 100, ambos incluidos, hasta que se proporcione un número que no cumpla esas condiciones, en cuyo caso finaliza el juego.  \n",
        "Ir imprimiendo los números y usar ```while``` y ```range```."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wE1irEcOXYnG"
      },
      "source": [
        "#### Solución 1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YCcF0xaHWGQB",
        "outputId": "ebc0109f-b821-47a7-b30f-ae612cd90030"
      },
      "source": [
        "n = int(input(\"Diga un número entero impar entre 10 y 100: \"))\n",
        "while n in range(11,101,2):                # mientras n esté entre los impares del rango 11 a 100\n",
        "  print(\"Estamos en el rango.\")\n",
        "  n = int(input(\"Diga otro número entero impar entre 10 y 100: \"))\n",
        "else:\n",
        "  print(\"Estamos fuera del rango.\")\n",
        "  print(\"Fin del programa.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Diga un número impar entre 10 y 100: 11\n",
            "Estamos en el rango.\n",
            "Diga otro número impar entre 10 y 100: 13\n",
            "Estamos en el rango.\n",
            "Diga otro número impar entre 10 y 100: 99\n",
            "Estamos en el rango.\n",
            "Diga otro número impar entre 10 y 100: 101\n",
            "Estamos fuera del rango.\n",
            "Fin del programa.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yuf67PEqXcw_"
      },
      "source": [
        "#### Solución 2 Usando una bandera lógica (flag)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fpdt-UqXXjUP",
        "outputId": "28ea5353-d3df-4fb3-8a8a-0e94ac42c0c9"
      },
      "source": [
        "jugando = True                          # inicializamos la bandera como True\n",
        "while jugando:                          # mientras la bandera se True. La 1ª vez se entra seguro al loop\n",
        "  n = int(input(\"Diga un número entero impar entre 10 y 100: \"))\n",
        "  if n in range(11,101,2):\n",
        "    print(\"Estamos en el rango.\")\n",
        "  else:\n",
        "    print(\"Estamos fuera del rango.\")\n",
        "    print(\"Fin del programa.\")\n",
        "    jugando = False\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Diga un número entero impar entre 10 y 100: 11\n",
            "Estamos en el rango.\n",
            "Diga un número entero impar entre 10 y 100: 16\n",
            "Estamos fuera del rango.\n",
            "Fin del programa.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UXS8V50YZQIF"
      },
      "source": [
        "### Juego: adivina los colores\n",
        "* Se crea una lista de cinco colores secretos.\n",
        "* El jugador va diciendo colores y por cada uno que adivine gana un punto.\n",
        "* Por cada color acertado se van diciendo los puntos conseguidos.\n",
        "* El juego termina cuando falla un color.\n",
        "* Cuando termina el juego se informa de los puntos obtenidos."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XVHcdJGkZstU",
        "outputId": "4bf4107a-aa23-47ad-a270-4a69ef9dbbf7"
      },
      "source": [
        "colores = [\"rojo\",\"verde\",\"azul\",\"rosa\",\"naranja\"]\n",
        "puntos = 0\n",
        "jugando = True         # bandera lógica\n",
        "while jugando:\n",
        "  color = input(\"Diga un color de la lista secreta: \").lower()\n",
        "  if color in colores:\n",
        "    puntos += 1\n",
        "    print(f\"¡Bien, acertó!. Tiene {puntos} puntos.\")\n",
        "  else:\n",
        "    print(\"No acertó el color.\")\n",
        "    print(f\"Ha finalizado el juego con {puntos} puntos.\")\n",
        "    jugando = False\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Diga un color de la lista secreta: Azul\n",
            "¡Bien, acertó!. Tiene 1 puntos.\n",
            "Diga un color de la lista secreta: roSa\n",
            "¡Bien, acertó!. Tiene 2 puntos.\n",
            "Diga un color de la lista secreta: amarillo\n",
            "No acertó el color.\n",
            "Ha finalizado el juego con 2 puntos.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PTVu_aiVecGi"
      },
      "source": [
        "### Reto 7.3. Adivina el número\n",
        "* Genere de forma aleatória un número entero entre 1 y 100, ambos incluidos. Este será el número secreto que se ha de adivinar.\n",
        "* Pida al usuario que diga un número en ese rango hasta que lo adivine.\n",
        "* Por cada número que diga el usuario se ha de responder indicando:\n",
        " - Si se ha ganado el juego. Esto sucederá cuando el número proporcionado por el usuario coincide con el número secreto.\n",
        " - Si el número secreto es mayor que el número dicho, se mostrará la frase: \"El nº secreto es mayor.\"\n",
        " - Si el número secreto es menor que el número dicho, se mostrará la frase: \"El nº secreto es menor.\"\n",
        "* Cuando se adivide el número se felicitará al usuario, se dirá cuál era el número secreto y se dirá en cuantas tiradas lo ha conseguido adivinar."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MB_P3GQmoDmx"
      },
      "source": [
        "# Diferencias entre tuplas y listas"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-RPJmFWuoupq"
      },
      "source": [
        "Las tuplas y listas funcionan de manera muy parecida. Las tuplas ocupan menos memoria y se ejecutan más rapido. Pero la principal diferencia es que se pueden cambiar los valores de los elementos de las listas, en el caso de las tuplas no."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5SiRQwbcmfKj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0142ecc1-756c-4199-9677-7172242e00ac"
      },
      "source": [
        "mitupla = (1,2,3)\n",
        "milista =[10,20,30]\n",
        "milista[0]= 7\n",
        "milista"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[7, 20, 30]"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3wS87Mtzm9Z6"
      },
      "source": [
        "#Este codigo da error\n",
        "#mitupla[0] = 8"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "39CCxJiNnJDF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "22b13e58-9a29-4c87-ccec-8d3bf15d97fc"
      },
      "source": [
        "tupla1 = ('a','b')\n",
        "tupla2 = ('c','d')\n",
        "tupla_total = tupla1 + tupla2\n",
        "print(tupla_total)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('a', 'b', 'c', 'd')\n"
          ]
        }
      ]
    }
  ]
}