4_Colecciones_de_datos_.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "6 Colecciones de datos.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z25yJxZlhGr_"
      },
      "source": [
        "#Colecciones\n",
        "Una colección permite agrupar varios objetos bajo un mismo nombre. Por ejemplo, si necesitamos almacenar en nuestro programa los nombres de unos alumnos, será más conveniente ubicarlos a todos dentro de una misma colección de nombre alumnos, en lugar de crear los objetos alumno1, alumno2, etc.\n",
        "\n",
        "En Python existen tres colecciones básicas, a saber: las listas, las tuplas y los diccionarios.\n",
        "\n",
        "##Listas\n",
        "Una lista es un conjunto ordenado de objetos. Por objetos entendemos cualquiera de los tipos de dato ya mencionados, incluso otras listas.\n",
        "\n",
        "Para crear una lista, especificamos sus elementos entre corchetes y separados por comas."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6aabax-IhAy7"
      },
      "source": [
        "lenguajes = [\"Python\", \"Java\", \"C\", \"C++\"]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jgLemc9OhSTc"
      },
      "source": [
        "Dado que se trata de una colección ordenada, accedemos a cada uno de los elementos a partir de su posición, comenzando desde el 0.\n",
        "##IMPORTANTE \n",
        "El primer elemento está en la posición 0"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mRoWpoREhYra"
      },
      "source": [
        "lenguajes[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oyrFPMrohR2S"
      },
      "source": [
        "lenguajes[1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "53eKN-V4h6PE"
      },
      "source": [
        "(En Python, las cadenas de caracteres pueden estar formadas tanto por comillas dobles como por comillas simples).\n",
        "\n",
        "La posición de un elemento, también conocida como índice, aumenta de izquierda a derecha cuando éste es positivo. Indicando un número negativo, los elementos se obtienen de derecha a izquierda."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6pKcNQ9_h-DF"
      },
      "source": [
        "lenguajes[-1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g75Kgnssh-Zu"
      },
      "source": [
        "lenguajes[-2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7zYUU_v3iHzV"
      },
      "source": [
        "lenguajes[0] == lenguajes [-4]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kSl2x8IJiik4"
      },
      "source": [
        "Para cambiar un elemento, combinamos la nomenclatura descrita con la asignación."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NmuJvdkbij6Y"
      },
      "source": [
        "lenguajes[1] = \"Rust\"\n",
        "lenguajes"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RMDEBa6HitrU"
      },
      "source": [
        "Para eliminar un elemento, utilizamos la palabra reservada del."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iC2jna1witYY"
      },
      "source": [
        "del lenguajes[1]\n",
        "lenguajes"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9nRm3KVAi4zH"
      },
      "source": [
        "Fíjense que cuando un elemento es eliminado, a excepción del último, todos los que lo suceden se ruedan una posición hacia la izquierda.\n",
        "\n",
        "La operación inversa es la de insertar un elemento en una posición determinada, desplazando el resto que le sucede una posición hacia la derecha, vía el método insert()."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fB-R1K_Yi-8d"
      },
      "source": [
        "# Insertar la cadena \"Elixir\" en la posición 1.\n",
        "lenguajes.insert(1, \"Elixir\")\n",
        "lenguajes"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yMMA2HGujEUs"
      },
      "source": [
        "Por último, la operación más común es la de agregar un elemento al final de la lista. Para ello empleamos append()."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dndRFI9njEIv"
      },
      "source": [
        "lenguajes.append(\"Haskell\")\n",
        "lenguajes\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v2G-7XzbjOVo"
      },
      "source": [
        "##Tuplas\n",
        "Las tuplas, al igual que las listas, son colecciones ordenadas. No obstante, a diferencia de éstas, son inmutables. Es decir, una vez asignados los elementos, no pueden ser alterados. En términos funcionales, podría decirse que las tuplas son un subconjunto de las listas, por cuanto soportan las operaciones con índices para acceder a sus elementos, pero no así las de asignación."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9c_LEljdjWWy"
      },
      "source": [
        "# Indicamos los elementos entre paréntesis.\n",
        "lenguajes = (\"Python\", \"Java\", \"C\", \"C++\")\n",
        "lenguajes[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nJn2zJtPjax1"
      },
      "source": [
        "lenguajes[-1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "57AhQVRtjff0"
      },
      "source": [
        "Un intento por eliminar un elemento de una tupla o asignarle un nuevo valor arrojará un error.\n",
        "\n",
        "Ahora bien, si las listas hacen todo lo que hace una tupla, ¿para qué, entonces, existen las tuplas? Sencillamente porque una tupla, justamente por carecer de todas las funcionalidades de mutación de elementos, es un objeto más liviano y que se crea más rápido.\n",
        "\n",
        "La función del programador será la de dirimir si para una determinada colección ordenada de objetos le conviene más una lista o una tupla, según sus elementos deban ser alterados en el futuro o no."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aVcyu_7Qjnlg"
      },
      "source": [
        "##Diccionarios\n",
        "Los diccionarios, a diferencia de las listas y las tuplas, son colecciones no ordenadas de objetos. Además, sus elementos tienen una particularidad: siempre conforman un par clave-valor. Es decir, cuando añadimos un valor a un diccionario, se le asigna una clave única con la que luego se podrá acceder a él (pues la posición ya no es un determinante).\n",
        "\n",
        "Para crear un diccionario, indicamos los pares clave-valor separados por comas y estos, a su vez, separados por dos puntos."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h5Heo-RcjnDc"
      },
      "source": [
        "d = {\"Python\": 1991, \"C\": 1972, \"Java\": 1996}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jqpl1h4Xjyc-"
      },
      "source": [
        "En este ejemplo, creamos un diccionario con tres elementos, cuyas claves son \"Python\", \"C\" y \"Java\" y sus valores los años en los que fueron creados, a saber: 1991, 1972 y 1996, respectivamente.\n",
        "\n",
        "Para acceder a cualquiera de los valores, debemos indicar su clave entre corchetes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bi0vC2uLj1Iu",
        "outputId": "6017a586-e3e3-48b0-9e13-93b7c7ccd109"
      },
      "source": [
        "d[\"Java\"]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1996"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vPPLHtxOj9S-"
      },
      "source": [
        "Las operaciones de añadir, modificar o eliminar valores son similares a las de las listas."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ncA1Az7Gj-KD"
      },
      "source": [
        "# Añadir un par clave/valor.\n",
        "d[\"Elixir\"] = 2011"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GeWoleMQkHlz"
      },
      "source": [
        "# Modificar uno existente.\n",
        "d[\"Python\"] = 3000"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dyuIRdDokJsR"
      },
      "source": [
        "# Eliminar.\n",
        "del d[\"C\"]\n",
        "d"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S0LKan6LkSUj"
      },
      "source": [
        "Las claves típicamente serán números o cadenas, aunque bien podrían ser de cualquier otro tipo de dato inmutable (todos los vistos hasta ahora son inmutables, a excepción de las listas y los diccionarios). Además, nunca puede haber claves repetidas, ya que actúan como identificadores únicos para un valor determinado. Los valores, en cambio, pueden ser de cualquier tipo de dato, ¡incluyendo otros diccionarios!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wUneMQ5YkTtL"
      },
      "source": [
        "#Operaciones comunes en colecciones\n",
        "Hemos visto cómo del se aplica tanto a listas como a diccionarios. Existen varias funciones que operan sobre distintos tipos de colecciones. Por ejemplo, la función incorporada len() retorna el número de elementos en una colección."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m4kiW09mkdQ1"
      },
      "source": [
        "len([1, 2, 3, 4])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I00nx3rdkfe7"
      },
      "source": [
        "len({\"Python\": 1991, \"C\": 1972})"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DncB8KFjkhkE",
        "outputId": "4721e496-6244-4942-8e46-6fff3723cc12"
      },
      "source": [
        "len((\"¡Hola, mundo!\",))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HrjBf96skm2X"
      },
      "source": [
        "En la tercera llamada pasamos como argumento una tupla que contiene un solo elemento (una cadena). No obstante, dado que para definir tuplas se emplean paréntesis, es necesario añadir una coma al final para que Python entienda que se trata de una tupla en lugar de una expresión (los paréntesis también son utilizados para agrupar expresiones, como en matemática).\n",
        "\n",
        "Una cadena es, en rigor, una colección de caracteres. Por ello también soporta las operaciones de acceso a sus elementos (¡no así las de asignación, ya que son inmutables!)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "llhNR8IDk0OH"
      },
      "source": [
        "s = \"¡Hola, mundo!\"\n",
        "s[4]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DymUakW_k4td"
      },
      "source": [
        "len(s)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JzavpqrFk_XN"
      },
      "source": [
        "Por último, para saber si un elemento está dentro de una colección, empleamos la palabra reservada in."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zLjUAsjvlAd9"
      },
      "source": [
        "10 in (1, 2, 3, 4)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qJlzhQ7YlFFF"
      },
      "source": [
        "\"mundo\" in \"¡Hola, mundo!\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l4b_iskxlEFI"
      },
      "source": [
        "\"Python\" in {\"Python\": 1991, \"C\": 1972}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "__KhxqOElNP9"
      },
      "source": [
        "Nótese que el operador in en los diccionarios actúa sobre las claves, no sobre los valores."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4t4rWMxnZNXg"
      },
      "source": [
        "#«Slicing»\n",
        "Las listas, tuplas y cadenas soportan una propiedad llamada slicing. No hay un concepto en español que haya ocupado definitivamente su lugar, así que mantendremos el término original. Se trata de una funcionalidad de las colecciones ordenadas que nos permite acceder a un subconjunto de ellas. Consideremos la siguiente lista."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D7M0vdsVZV1U"
      },
      "source": [
        "lenguajes = [\"Python\", \"C\", \"C++\", \"Java\", \"Elixir\"]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cJFNiS-pZcow"
      },
      "source": [
        "Usando la nomenclatura coleccion[inicio:fin], podemos obtener una porción de ella según los límites indicados."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kEk-rP7VZdqH"
      },
      "source": [
        "# Obtiene desde el segundo elemento (índice 1) inclusive hasta el cuarto.\n",
        "lenguajes[1:4]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AEuzZF4MZky4"
      },
      "source": [
        "Si inicio o fin están ausentes, por defecto serán 0 y len(coleccion) (es decir, todos los elementos de la colección), respectivamente."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9GcSxeMVZp0V"
      },
      "source": [
        "lenguajes[1:]\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dOIUuKknZu3T"
      },
      "source": [
        "lenguajes[1:len(lenguajes)]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_y_KAsB2Zuhr"
      },
      "source": [
        "lenguajes[:4]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eALCT8Q6ZuXF"
      },
      "source": [
        "lenguajes[0:4]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "opfNIcZVZuN9"
      },
      "source": [
        "lenguajes[:]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q6PaveThZuDx"
      },
      "source": [
        "lenguajes[0:len(lenguajes)]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ajlzEhrdaYoe"
      },
      "source": [
        "El segundo indicador (fin) puede ser un número negativo, lo cual comienza la cuenta desde el final de la colección."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kgPBGjF0acen"
      },
      "source": [
        "# Todos los elementos a excepción del último.\n",
        "lenguajes[:-1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K0mKddWVai5a"
      },
      "source": [
        "Un tercer número indica el intervalo según el cual se obtienen elementos de la colección (1 por defecto)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FSWclHH-ahy1"
      },
      "source": [
        "lenguajes[::2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vCg0IDsgarTC"
      },
      "source": [
        "lenguajes[1:-1:2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2UMZ1KVxax4W"
      },
      "source": [
        "Si el intervalo es negativo, los elementos se empiezan a obtener en modo inverso, de modo que coleccion[::-1] retorna todos sus elementos al revés."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XHtcTRJta0z_"
      },
      "source": [
        "lenguajes[::-1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bJ7p3b2ta1oR"
      },
      "source": [
        "Como mencionamos al principio, estas propiedades son también aplicables a tuplas y cadenas, del mismo modo."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ukbkvz4Da7_l"
      },
      "source": [
        "s = \"¡Hola, mundo!\"\n",
        "s[1::2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_efuvotEa_FA"
      },
      "source": [
        "s[::-1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qUFsEU6rbFLO"
      },
      "source": [
        "#«Unpacking»\n",
        "La traducción más fiel para este concepto sería desempaquetamiento. La propiedad de unpacking nos permite \"desempaquetar\" los elementos de una colección en variables individuales."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RM6KkahTbPTD"
      },
      "source": [
        "t = (1, 2, 3)\n",
        "a, b, c = t\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cKNFiTfCbY7l"
      },
      "source": [
        "b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jVSFXWmfbdb0"
      },
      "source": [
        "c"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T2QlNpDDbeZ9"
      },
      "source": [
        "¡Sencillo! Si no ha quedado lo suficientemente claro, el código anterior es similar al siguiente."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gqo32j4jbl-6"
      },
      "source": [
        "t = (1, 2, 3)\n",
        "a = t[0]\n",
        "b = t[1]\n",
        "c = t[2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1ZfY_DnqbqOm"
      },
      "source": [
        "Para que esta operación no arroje un error, el número de objetos separados por comas a la izquierda del signo igual debe coincidir con el número de elementos dentro de la colección a la derecha. Aunque vía slicing podemos, por ejemplo, desempaquetar los primeros dos elementos."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DLmFCqBPbzVO"
      },
      "source": [
        "a, b = t[:2]\n",
        "\n",
        "#O bien los últimos dos.\n",
        "\n",
        "b, c = t[-2:]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DHy88j5sb6Np"
      },
      "source": [
        "Esta propiedad de las colecciones ordenadas nos permitirá hablar de una última cosa."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S6MZZZU5b7Eh"
      },
      "source": [
        "#Enumerando colecciones\n",
        "Python incluye una función llamada enumerate(), que obtiene como argumento una colección y retorna sus elementos enumerados, como se observa a continuación."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pvneI9jwcBS1"
      },
      "source": [
        "lenguajes = [\"Python\", \"C\", \"C++\", \"Java\"]\n",
        "list(enumerate(lenguajes))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3y1vrpexcFLx"
      },
      "source": [
        "(enumerate() opera del mismo modo que range(), en el sentido que no retorna una lista sino un objeto iterable cuyos elementos son generados al tiempo en que son utilizados, para optimizar el rendimiento del código. Por ello, para ver todos sus elementos al mismo tiempo, es necesario convertirlo a una lista).\n",
        "\n",
        "El valor de retorno es un iterable cuyos elementos son tuplas, dentro de las cuales el primer elemento indica la posición del segundo en la colección pasada como argumento.\n",
        "\n",
        "Ahora bien, esto es sumamente útil cuando, al recorrer una colección con un bucle for, estamos interesados tanto en los elementos como en sus posiciones."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bLgqV10gcPwh"
      },
      "source": [
        "for i, lenguaje in enumerate(lenguajes):\n",
        "  print(i, lenguaje)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KDnAxzYschNS"
      },
      "source": [
        "Lo cual es mucho más pythonico y rápido que:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7W19IY4RcgFj"
      },
      "source": [
        "# ¡¡¡Menos legible y más lento!!!\n",
        "for i in range(len(lenguajes)):\n",
        "  print(i, lenguajes[i])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lRHZ-OL7nWe2"
      },
      "source": [
        "\n",
        "https://recursospython.com/guias-y-manuales/30-metodos-de-las-cadenas/\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ObrtoXfMlgpj"
      },
      "source": [
        "#Métodos de las cadenas\n",
        "El tipo de dato str es una clase incorporada cuyas instancias incluyen variados métodos ─más de treinta─ para analizar, transformar, separar y unir el contenido de las cadenas de caracteres. Detallamos los que consideramos más relevantes para tener siempre a mano."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jRjzB3w0lugl"
      },
      "source": [
        "##Métodos de análisis\n",
        "El método count() retorna el número de veces que se repite un conjunto de caracteres especificado."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CoVrAAcik_El"
      },
      "source": [
        "s = \"Hola mundo\"\n",
        "s.count(\"Hola\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lV955qCEdPID"
      },
      "source": [
        "Los métodos find() e index() retornan la ubicación (comenzando desde el cero) en la que se encuentra el argumento indicado."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DImIEq1QdSCE"
      },
      "source": [
        "s.find(\"mundo\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "laaMngxPdaVw"
      },
      "source": [
        "s.index(\"mundo\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pZL3_vDgdkGV"
      },
      "source": [
        "Difieren en que este último lanza ValueError cuando el argumento no es encontrado, mientras que el primero retorna -1."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pcNutvo-dj2o"
      },
      "source": [
        "s.find(\"world\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ar2SM_wvdsZs"
      },
      "source": [
        "s.index(\"world\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tY4jjmgMdxbE"
      },
      "source": [
        "En ambos métodos la búsqueda ocurre de izquierda a derecha. Para buscar un conjunto de caracteres desde el final, utilícense del mismo modo rfind() y rindex()."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WmXVNOcFd1T-"
      },
      "source": [
        "s = \"C:/python36/python.exe\"\n",
        "s.find(\"/\")  # Retorna la primera ocurrencia."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dCjYZXmsd5EV"
      },
      "source": [
        "s.rfind(\"/\")  # Retorna la última."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kLmrBgg8d86M"
      },
      "source": [
        "startswith() y endswith() indican si la cadena en cuestión comienza o termina con el conjunto de caracteres pasados como argumento, y retornan True o False en función de ello."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1Pyz4uxveA8O"
      },
      "source": [
        "s = \"Hola mundo\"\n",
        "s.startswith(\"Hola\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AMfOt-NfeFBJ"
      },
      "source": [
        "s.endswith(\"mundo\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aRlNvO_XeGIr"
      },
      "source": [
        "s.endswith(\"world\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s2gHhdFYeMM_"
      },
      "source": [
        "Ambos métodos son preferidos ante la opción de emplear slicing."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nbkxbBUjeLuh"
      },
      "source": [
        "# Se prefiere startswith().\n",
        "s[:4] == \"Hola\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QUpxnDsjeR4x"
      },
      "source": [
        "Los métodos isdigit(), isnumeric() e isdecimal() determinan si todos los caracteres de la cadena son dígitos, números o números decimales."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m0KIxhVKeTHn"
      },
      "source": [
        "\"1234\".isnumeric()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T28_Ii4DeWkC"
      },
      "source": [
        "\"1234\".isdecimal()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dutgEeSreWYa"
      },
      "source": [
        "\"abc123\".isdigit()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ssZ2Wnr_ebM6"
      },
      "source": [
        "Si bien estas definiciones resultam a priori similares, no lo son. La primera, isdigit(), considera caracteres que pueden formar números, incluidos aquellos correspondientes a lenguas orientales. isnumeric() es más amplia, pues incluye también caracteres de connotación numérica que no necesariamente son dígitos (por ejemplo, una fracción). La última, isdecimal(), es la más restrictiva al tener en cuenta únicamente números decimales; esto es, formados por dígitos del 0 al 9.\n",
        "\n",
        "Las siguientes seis funciones de análisis son bastante explicativas por sí mismas."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LbzvYDZHeiv6"
      },
      "source": [
        "# Determina si todos los caracteres son alfanuméricos.\n",
        "\"abc123\".isalnum()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E9jrqfASejzd"
      },
      "source": [
        "# Determina si todos los caracteres son alfabéticos.\n",
        "\"abcdef\".isalpha()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lvadfL7zejvF"
      },
      "source": [
        "\"abc123\".isalpha()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E0xmTTwUejo0"
      },
      "source": [
        "# Determina si todas las letras son minúsculas.\n",
        "\"abcdef\".islower()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xo4hN_R2ejie"
      },
      "source": [
        "# Mayúsculas.\n",
        "\"ABCDEF\".isupper()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kxnZJMeNejOx"
      },
      "source": [
        "# Determina si la cadena contiene todos caracteres imprimibles.\n",
        "\"Hola \\t mundo!\".isprintable()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_J8-1pGde6bu"
      },
      "source": [
        "# Determina si la cadena contiene solo espacios.\n",
        "\"Hola mundo\".isspace()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nXDRnE8Te6Rk"
      },
      "source": [
        "\"    \".isspace()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GHI7fqlefCWt"
      },
      "source": [
        "#Métodos de transformación\n",
        "Recuérden que las cadenas son inmutables; por ende, todos los métodos a continuación no actúan sobre el objeto original sino que retornan uno nuevo.\n",
        "\n",
        "capitalize() retorna la cadena con su primera letra en mayúscula."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n-Cs-R_vfEwj"
      },
      "source": [
        "\"hola mundo\".capitalize()\n",
        "'Hola mundo'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F8gd_ijlfPoW"
      },
      "source": [
        "encode() codifica la cadena con el mapa de caracteres especificado y retorna una instancia del tipo bytes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3RTQMEeOfQcq"
      },
      "source": [
        "\"Hola mundo\".encode(\"utf-8\")\n",
        "b'Hola mundo'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f--YwTmdfVeq"
      },
      "source": [
        "Los métodos center(), ljust() y rjust() alinean una cadena en el centro, la izquierda o la derecha respectivamente. Toman un argumento, la cantidad de caracteres respecto de la cual se producirá la alineación."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p-IQNOGIfX8R"
      },
      "source": [
        "\"Hola\".center(10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nFAMcmUTfYgQ"
      },
      "source": [
        "\"Hola\".ljust(10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hKO6_uHffYUk"
      },
      "source": [
        "\"Hola\".rjust(10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9bTkOGgifl0t"
      },
      "source": [
        "Estos métodos son especialmente útiles al imprimir en forma de tabla para que ésta se mantenga alineada. Un segundo argumento indica con qué caracter se deben llenar los espacios vacíos (por defecto un espacio en blanco)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "--d6EaDhfrtP"
      },
      "source": [
        "\"Hola\".center(10, \"*\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pxU4F7lof2ig"
      },
      "source": [
        "lower() y upper() retornan una copia de la cadena con todas sus letras en minúsculas o mayúsculas según corresponda."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "duRvJyMTf4_t"
      },
      "source": [
        "\"Hola Mundo!\".lower()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sJi4lEw7f8Fz"
      },
      "source": [
        "\"Hola Mundo!\".upper()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X5Guatq-fpIF"
      },
      "source": [
        "swapcase(), por su parte, cambia las mayúsculas por minúsculas y viceversa."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P0QlaHeYgD1f"
      },
      "source": [
        "\"Hola Mundo!\".swapcase()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zcf2uvVkgMLn"
      },
      "source": [
        "Las funciones strip(), lstrip() y rstrip() remueven los espacios en blanco que preceden y/o suceden a la cadena."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8cfOfOi3gP8H"
      },
      "source": [
        "s = \" Hola mundo! \"\n",
        "s.strip()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jvw-qw8ggPuH"
      },
      "source": [
        "# Remueve los de la derecha.\n",
        "s.rstrip()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YVe5KBttgPZt"
      },
      "source": [
        "# Remueve los de la izquierda.\n",
        "s.lstrip()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TsRjQk1WgdiV"
      },
      "source": [
        "Por último, el método replace() ─ampliamente utilizado─ reemplaza una cadena por otra."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ad_88foQggPb"
      },
      "source": [
        "s = \"Hola mundo\"\n",
        "s.replace(\"mundo\", \"world\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7MLIbUUAgkn5"
      },
      "source": [
        "#Métodos de separación y unión\n",
        "El método de división de una cadena según un caracter separador más empleado es split(), cuyo separador por defecto son espacios en blanco y saltos de línea."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9f9q4BOhgm29"
      },
      "source": [
        "\"Hola mundo!\\nHello world!\".split()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HEpMBnwhgwSk"
      },
      "source": [
        "O bien, para separar únicamente según saltos de línea:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gu-75Kp7gzK9"
      },
      "source": [
        "# Equivalente a split(\"\\n\").\n",
        "\"Hola mundo!\\nHello world!\".splitlines()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o5NlF9bcg6uB"
      },
      "source": [
        "Un segundo argumento en split() indica cuál es el máximo de divisiones que puede tener lugar (-1 por defecto para representar una cantidad ilimitada)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ebZscFR8g9hm"
      },
      "source": [
        "\"Hola mundo hello world\".split(\" \", 2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wpDtymW6g_NI"
      },
      "source": [
        "Un segundo método de separación es partition(), que retorna una tupla de tres elementos: el bloque de caracteres anterior a la primera ocurrencia del separador, el separador mismo, y el bloque posterior."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ywQHxE2ghFe-"
      },
      "source": [
        "s = \"Hola mundo. Hello world!\"\n",
        "s.partition(\" \")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WVyC0fbXhI8z"
      },
      "source": [
        "rpartition() opera de forma similar, pero realizando la búsqueda de derecha a izquierda."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2ho_AXMohJ3f"
      },
      "source": [
        "s.rpartition(\" \")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fMUFuygdhPRi"
      },
      "source": [
        "Por último, el método join() ─sumamente útil─, que debe ser llamado desde una cadena que actúa como separador para unir dentro de una misma cadena resultante los elementos de una lista."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nEQOjRenhTNu"
      },
      "source": [
        "\" \".join([\"Hola\", \"mundo\"])\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uqrLyKhwhUIq"
      },
      "source": [
        "\", \".join([\"C\", \"C++\", \"Python\", \"Java\"])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TPTURvgahdy-"
      },
      "source": [
        "Como puede observarse, split() y join() son exactamente contrarios."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_eHDnTWEheyC"
      },
      "source": [
        "sep = \" \"\n",
        "sep.join(\"Hola mundo!\".split(sep))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "azHaP2ttip8f"
      },
      "source": [
        "#Formando cadenas de caracteres\n",
        "\n",
        "Construir una única cadena de caracteres a partir de otras más pequeñas es algo que estarás haciendo practicamente siempre sea en Python o en cualquier otro lenguaje. Por esta razón, tener un buen dominio de las herramientas para llevarlo a cabo es fundamental para diseñar un mejor código: más eficiente, más legible. En este artículo intentaré transmitirle al lector los diversos métodos del formateo de cadenas y, por supuesto, recomendarte la manera «estándar» o correcta de hacerlo en Python.\n",
        "\n",
        "Comencemos por observar una de las formas más básicas de concatenar dos cadenas.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jiTXw7M0i5nI"
      },
      "source": [
        "nombre = \"Juan\"\n",
        "\"Tu nombre es: \" + nombre"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0SLeiUzQjANL"
      },
      "source": [
        "El operador de suma, cuando es utilizado entre dos cadenas, opera añadiendo la segunda inmediatamente luego de la primera. Generalmente este método es correcto y eficiente para pequeñas uniones como la anterior, pero se torna un tanto molesto cuando intentamos conformar una cadena a partir de numerosos fragmentos."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T7TT3c9QjHWu"
      },
      "source": [
        "apellido = \"Pérez\"\n",
        "sexo = \"Masculino\"\n",
        "\"Tu nombre es: \" + nombre + \". Apellido: \" + apellido + \". Sexo: \" + sexo + \".\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LKBThN9MjLkH"
      },
      "source": [
        "Incluso deberemos convertir (utilizando la función str) cualquier objeto que no sea una cadena para que la operación se concrete; por ejemplo, un entero."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ugUaqxuwjPbs"
      },
      "source": [
        "edad = 20  #Se interpreta como número entero (int), no como texto (str)\n",
        "\"Tu nombre es \" + nombre + \" y tienes \" + str(edad) + \" años.\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GT-eIr8Zjz2a"
      },
      "source": [
        "##Nuevo método en Python 3.6 para crear cadenas de caracteres\n",
        "En Python 3.6 surgen las denominadas «f-strings» o «cadenas-f». Cuando una cadena esté precedida por una «f», utilizando llaves se podrán ubicar expresiones dentro de la misma que serán luego ejecutadas."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jtp_lRQakA6N"
      },
      "source": [
        "nombre = \"Juan\"\n",
        "edad = 20\n",
        "altura = 1.75\n",
        "f\"Te llamas {nombre}, tienes {edad} años y mides {altura} metros.\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8cJd2cGdkNJa"
      },
      "source": [
        "Nótese que son expresiones, no simples identificadores, a diferencia de los métodos anteriores."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KuIASQqskOOc"
      },
      "source": [
        "f\"Tu nombre al revés es {nombre[::-1]}.\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YBfhEApCkOmK"
      },
      "source": [
        "f\"Dentro de 5 años tendrás {edad + 5} años.\""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}