Inmersion_en_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Tutorial_Python.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "[View in Colaboratory](https://colab.research.google.com/github/lost-h3aven/Inmersion_en_Python3/blob/master/Inmersion_en_Python.ipynb)"
      ]
    },
    {
      "metadata": {
        "id": "ZDkmiXmehj5E",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Inmersión en Python 3\n",
        "#### Escrito por Mark Pilgrim\n",
        "####Traducción por José Miguel Gonzáles Aguilera\n",
        "![alt text](https://pythonizame.s3.amazonaws.com/media/thumbs/Book/inmersion-en-python-3/image/42b38d02-5976-11e5-964d-04015fb6ba01.png.400x400_q85.png)\n",
        "\n",
        "---\n",
        "\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "kJ-526xpnjau",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Capítulo 0: Instalación\n",
        "\n",
        "En capítulo 0 podrán ver los pasos necesarios para la instalación de python 3 desde dieferentes sistemas operativos, tales como:\n",
        "\n",
        "\n",
        "*   Windows\n",
        "*   Mac OS X\n",
        "*   Ubuntu Linux\n",
        "\n",
        "Posteriormente muestra el uso de la consola interactiva de python.\n",
        "\n",
        "Finalmente se hace mención de algunos editores e IDEs para python.\n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "7OEQS4ydnk3H",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Capítulo 1: Tu primer programa en Python"
      ]
    },
    {
      "metadata": {
        "id": "aD2G6zbctctz",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "6af71ef0-65d5-4355-d2cb-77023f3775ca"
      },
      "cell_type": "code",
      "source": [
        "# parahumanos.py\n",
        "\n",
        "SUFIJOS = {1000: [ 'KB' , 'MB' , 'GB' , 'TB' , 'PB' , 'EB' , 'ZB' , 'YB' ] ,\n",
        "           1024: [ 'KiB ' , 'MiB ' , 'GiB ' , 'TiB ' , 'PiB ' , 'EiB ' , ' ZiB ' ,'YiB ' ]}\n",
        "\n",
        "def tamanyo_aproximado(tamanyo , un_kilobyte_es_1024_bytes=True):\n",
        "\n",
        "  if tamanyo < 0 :\n",
        "    raise ValueError('El número debe ser no negativo')\n",
        "    \n",
        "  multiplo = 1024 if un_kilobyte_es_1024_bytes else 1000\n",
        "  for sufijo in SUFIJOS [multiplo]:\n",
        "    tamanyo /= multiplo\n",
        "    if tamanyo < multiplo:\n",
        "      return '{0:.1f} {1}'.format(tamanyo, sufijo)\n",
        "      \n",
        "  raise ValueError('Número demasiado grande')\n",
        "  \n",
        "if __name__ == '__main__':\n",
        "  print (tamanyo_aproximado(1000000000000, False))\n",
        "  print (tamanyo_aproximado(1000000000000))"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1.0 TB\n",
            "931.3 GiB \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "dt854efSrnh1",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "###Funciones\n",
        "En Python únicamente hay que declarar la función, como en el siguiente ejemplo:\n",
        "\n",
        "\n",
        "```\n",
        "def tamanyo aproximado ( tamayo , un_kilo_byte_es_1024_bytes=True ) :\n",
        "```\n",
        "\n",
        "La palabra reservada **def** inicia la declaración de la función, seguida del nombre que se le quiere dar a la misma, seguida de los parámetros de la función entre paréntesis. Separándolos por comas en caso de que sean varios parámetros.\n",
        "\n",
        "En Python ni siquiera se especifica si se retorna o no un valor.\n",
        "\n",
        "Python permite que los parámetros de una función tengan valores por defecto; si la función se llama (para ejecutarla) si indicar el parámetro, Python usará el valor por defecto para asignarlo al parámetro que no se ha especificado en la llamada a la función. \n",
        "\n",
        "\n",
        "\n",
        "Por ejemplo, se manda llamar la función \"tamanyo_aproximado\" sin definir el segundo parámetro, y se puede observar que la variable toma un TRUE por default.\n"
      ]
    },
    {
      "metadata": {
        "id": "McgLa8z-rUZq",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0380852d-ccbf-42a6-9da4-fc3f06175780"
      },
      "cell_type": "code",
      "source": [
        "tamanyo_aproximado(4000)"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'3.9 KiB '"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "metadata": {
        "id": "DPSJZAoj2s32",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f774be17-1080-4844-c0c0-3d2b1c6a885b"
      },
      "cell_type": "code",
      "source": [
        "tamanyo_aproximado(4000,False)"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'4.0 KB'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "metadata": {
        "id": "pDmDpsgv480U",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "###Import\n",
        "Cuando importas un módulo, Python busca en varios lugares hasta encontrarlo. En concreto, busca en todos los directorios que se encuentren definidos en la variable **sys.path**. Como se trata de una lista, puedes verla fácilmente o modificarla con los métodos estándares de manipulación de listas."
      ]
    },
    {
      "metadata": {
        "id": "0VPNbiOg6Nsp",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "###Identar código\n",
        "\n",
        "Las funciones de Python no tienen **begin** o **end**, y tampoco existen llaves que marquen donde comienza y acaba el código de una función. El único delimitador es el símbolo de los dos puntos (:) y el propio indentado del código.\n",
        "\n",
        "\n",
        "*   Los bloques de código se definen por su indentado. Por \"bloque de código\" se entiende lo siguiente: funciones, sentencias if, bucles for, bucles while y similar. Al indentar se inicia el bloque y al desindentar se ánaliza. No existen llaves, corchetes o palabras clave para iniciar y ánalizar un bloque de forma explícita. Esto implica que los espacios en blanco son significativos, y deben ser consistentes. \n",
        "* En Python, la sentencia if debe contener un bloque de código. Si la expresión que sigue al if es verdadera, se ejecuta el bloque indentado que contiene el if, en caso contrario lo que se ejecuta es el bloque contenido en el else (si existe). \n",
        "* Las líneas que estan completamente en blanco no cuentan. Únicamente sirven para hacer más legible el c\u0013odigo, pero no cuentan como delimitadores de código. La función continúa en la línea siguiente.\n",
        "*   El bucle for también marca el comienzo de un bloque de código. Los bloques pueden contener múltiples líneas, siempre que estén indentadas con el mismo número de espacios. \n"
      ]
    },
    {
      "metadata": {
        "id": "-kYwL6wY9dnc",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "---\n",
        "###Capturar errores al importar\n",
        "Una de las excepciones internas de Python es ImportError, que se eleva cuando intentas importar un módulo y falla. Esto puede suceder por diversas causas, pero\n",
        "la más simple es que el módulo no exista en tu camino de búsqueda. Puedes utilizar esta excepción para incluir características opcionales a tu programa. También puedes utilizar un bloque try...except.\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "try :\n",
        "  import charde t\n",
        "except ImportError :\n",
        "  charde t = None\n",
        "```\n",
        "\n",
        "Posteriormente, en el código, puedes consultar la presencia de la librería con una simple sentencia if:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "if chardet:\n",
        "  #hacer algo\n",
        "else:\n",
        "  #seguir de todos modos\n",
        "```\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "H3zbZsdQABLU",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "## Capítulo 2: Tipos de datos nativos\n",
        "\n",
        "Python proporciona muchos tipos de dato nativos. A continuación se muestran los más importantes:\n",
        "\n",
        "* Booleanos: Su valor es True o False.\n",
        "* Números: Pueden ser enteros (1, 2, 3,...),  flotantes (1.1, 1.2, 1.3,...), fracciones (1/2, 1/3, 2/3,...), o incluso números complejos (i = √ (-1)).\n",
        "* Cadenas: Son secuencias de caracteres Unicode.\n",
        "* Bytes y arrays de bytes: por ejemplo, un fichero de imágenes JPEG.\n",
        "* Listas: Son secuencias ordenadas de valores.\n",
        "* Tuplas: Son secuencias ordenadas e inmutables de valores.\n",
        "* Conjuntos: Son \"bolsas\" de valores sin ordenar.\n",
        "* Diccionarios: Son \"bolsas\" sin ordenar de parejas clave-valor. Es posible buscar directamente por clave."
      ]
    },
    {
      "metadata": {
        "id": "U4bIx0HpDCmt",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "###Trigonometría\n",
        "También puedes hacer cálculos trigonométricos en Python.\n",
        "\n",
        "A continuación se muestran algunas funciones del módulo **math**.\n",
        "\n",
        "1. El módulo **math** tiene definida una constante que almacena el valor del número π, la razón de la circunferencia de un círculo respecto de su diámetro.\n",
        "2. En el módulo** math** se encuentran todas las funciones trigonométricas básicas, incluidas sin(), cos(), tan() y variantes como asin().\n",
        "3. Python no tiene precisión infinita, tan(π/4) debería devolver 1.0, no 0.99999999999999989.\n"
      ]
    },
    {
      "metadata": {
        "id": "faOwpWM1DZAD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "3a3bdb5a-4252-4691-ad42-bfaab5c41c4d"
      },
      "cell_type": "code",
      "source": [
        "import math\n",
        "math . pi"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.141592653589793"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 36
        }
      ]
    },
    {
      "metadata": {
        "id": "ueVIqbpVDgl5",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ab700a4a-7570-47ba-91aa-3d22485ebb38"
      },
      "cell_type": "code",
      "source": [
        "math.sin(math.pi/2)"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "metadata": {
        "id": "Av-sI039Dsy3",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "824cce51-4830-4383-e40a-bdfefe4ae0b6"
      },
      "cell_type": "code",
      "source": [
        "math.tan(math.pi/4)"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.9999999999999999"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 39
        }
      ]
    },
    {
      "metadata": {
        "id": "WRNT3PHNFkPL",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "###Listas\n",
        "\n",
        "En Python las variables se pueden nombrar como se quiera, ya que Python mantiene el tipo de datos internamente.\n",
        "\n",
        "Una lista de Python es mucho más que un array de Java (aunque puede utilizarse como si lo fuese si eso es lo que se desea). Una analogía mejor sería pensar en la clase ArrayList de Java, que puede almacenar un número arbitrario de objetos y expandir su tamaño dinámicamente al añadir nuevos elementos."
      ]
    },
    {
      "metadata": {
        "id": "UJcPU7sDFrkC",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "999476cb-8b42-421d-d547-81fa9576f24c"
      },
      "cell_type": "code",
      "source": [
        "lista = ['a', 'b', 'jmgaguilera', 'z', 'ejemplo']\n",
        "lista"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['a', 'b', 'jmgaguilera', 'z', 'ejemplo']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        }
      ]
    },
    {
      "metadata": {
        "id": "8qCWyC4lGKvj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e44334f7-5e05-4bed-a814-452244a4c813"
      },
      "cell_type": "code",
      "source": [
        "lista[0]"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'a'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "metadata": {
        "id": "w5z-k8K7GOte",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "51fddefe-c071-489c-845b-a8c248a5c767"
      },
      "cell_type": "code",
      "source": [
        "lista[-2]"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'z'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 45
        }
      ]
    },
    {
      "metadata": {
        "id": "kfkLzCssGkqv",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Existen cuatro maneras de a~nadir elementos a una lista:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "# lista = lista + [nuevoElemento, nuevoElementoN]\n",
        "```\n",
        "\n",
        "\n",
        "```\n",
        "# lista.append(nuevoElemento)\n",
        "```\n",
        "\n",
        "\n",
        "```\n",
        "# lista.extend(\"nuevoElemento\",\"nuevoElementoN\")\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "# lista.insert(nuevoElemento, \"NuevoElemento\")\n",
        "```\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "oiQncRm0Ha2I",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "cad73578-b41b-4495-c9e8-458cc8488bef"
      },
      "cell_type": "code",
      "source": [
        "lista = lista + [2.0, 3]\n",
        "lista"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['a', 'b', 'jmgaguilera', 'z', 'ejemplo', 2.0, 3]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "metadata": {
        "id": "KuT5XF7LH-ch",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "245d2229-ddb7-47ff-f283-86477fdf8a0a"
      },
      "cell_type": "code",
      "source": [
        "lista.append(True)\n",
        "lista"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['a', 'b', 'jmgaguilera', 'z', 'ejemplo', 2.0, 3, True]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 47
        }
      ]
    },
    {
      "metadata": {
        "id": "UbioGSLpIDXZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c89685eb-c9e3-45fb-d27f-7a187bada9f3"
      },
      "cell_type": "code",
      "source": [
        "lista.extend([\"cuatro\",\"omega\"])\n",
        "lista"
      ],
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['a', 'b', 'jmgaguilera', 'z', 'ejemplo', 2.0, 3, True, 'cuatro', 'omega']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 49
        }
      ]
    },
    {
      "metadata": {
        "id": "r30nRl5vINAM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "outputId": "e7b473ac-a0ed-43e3-8448-b1229ab9f15e"
      },
      "cell_type": "code",
      "source": [
        "lista.insert(0, \":)\")\n",
        "lista"
      ],
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[':)',\n",
              " 'a',\n",
              " 'b',\n",
              " 'jmgaguilera',\n",
              " 'z',\n",
              " 'ejemplo',\n",
              " 2.0,\n",
              " 3,\n",
              " True,\n",
              " 'cuatro',\n",
              " 'omega']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 50
        }
      ]
    },
    {
      "metadata": {
        "id": "LLak9ZjoJV2n",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Otro método de interés que tiene las listas es **pop()**, que permite eliminar elementos de una lista de un modo especial."
      ]
    },
    {
      "metadata": {
        "id": "90-uI_wKJcIN",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a7f23366-0b4d-4ff9-ce47-e847cf126c6c"
      },
      "cell_type": "code",
      "source": [
        "lista.pop(5)\n",
        "lista"
      ],
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[':)', 'a', 'b', 'jmgaguilera', 'z', 2.0, 3, True, 'cuatro', 'omega']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 51
        }
      ]
    },
    {
      "metadata": {
        "id": "Z_zLDNw6J0jt",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "###Tuplas\n",
        "Una tupla es una lista inmutable. Una tupla no se puede modificar después de haberla creado.\n",
        "\n",
        "Las tuplas se definen de la misma forma que las listas. La única diferencia es que los elementos se cierran entre paréntesis en lugar de corchetes.\n",
        "Las tuplas son más rápidas que las listas. Si lo que defines es un conjunto estático de valores y todo lo que vas a hacer es iterar a través de ellos, lo mejor es que uses una tupla en lugar de una lista.\n",
        "\n",
        "\n",
        "*   Es más seguro, puesto que proteges contra escritura los datos que no necesitas modificar.\n",
        "*   Las tuplas se pueden convertir en listas y viceversa. La función interna **tuple()** puede recibir como parámetro una lista y devuelve una tupla con los mismos elementos que tenga la lista, y la función **list()** toma como parámetro una tupla y retorna una lista.\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "5-aqlJPAKaNZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e7179960-6410-4458-ddfe-ce9432fba656"
      },
      "cell_type": "code",
      "source": [
        "tupla = ( \"a\" , \"b\" , \"mpilgrim\" , \" z \" , \" ejemplo \" )\n",
        "tupla"
      ],
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('a', 'b', 'mpilgrim', ' z ', ' ejemplo ')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 53
        }
      ]
    },
    {
      "metadata": {
        "id": "ZVR_w4XTL_Rx",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "###Diccionarios\n",
        "Un diccionario es un conjunto desordenado de parejas clave-valor. Cuando añades una clave a un diccionario, tienes que añadir también un valor para esa clave. Los diccionarios de Python están optimizados para recuperar fácilmente el valor cuando conoces la clave, no al revés."
      ]
    },
    {
      "metadata": {
        "id": "wEUgbim6MYel",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "263bce8f-f2e6-4cb0-dde7-41744ee35a74"
      },
      "cell_type": "code",
      "source": [
        "diccionario= { 'servidor':'db.diveintopython3.org', 'basedatos':'mysql'}\n",
        "diccionario"
      ],
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'basedatos': 'mysql', 'servidor': 'db.diveintopython3.org'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 55
        }
      ]
    },
    {
      "metadata": {
        "id": "Zx9pcHE_NDWD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "da4682c0-70b0-4e05-c76e-a9ca2b2d0e33"
      },
      "cell_type": "code",
      "source": [
        "diccionario ['servidor']"
      ],
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'db.diveintopython3.org'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 56
        }
      ]
    },
    {
      "metadata": {
        "id": "XjMcvF11Ncwp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "c25ac515-3a43-41a0-b855-53d0084d8944"
      },
      "cell_type": "code",
      "source": [
        "diccionario ['basedatos'] = 'blog'\n",
        "diccionario ['usuario'] = 'Paty :)'\n",
        "diccionario"
      ],
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'basedatos': 'blog',\n",
              " 'servidor': 'db.diveintopython3.org',\n",
              " 'usuario': 'Paty :)'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 57
        }
      ]
    },
    {
      "metadata": {
        "id": "dpFGrPCvN6lm",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Los diccionarios no se usan únicamente con cadenas de texto. Los valores de un diccionario pueden ser de cualquier tipo, incluidos enteros, booleanos, cualquier objeto o incluso otros diccionarios. Y en un mismo diccionario, no es necesario que todos los valores sean del mismo tipo, puedes mezclarlos según lo necesites. Los tipos de datos que pueden ser claves de un diccionario están más limitados, pero pueden ser cadenas de texto, enteros, y algunos tipos más. También es factible mezclar diferentes tipos de clave en un mismo diccionario.\n",
        "Anteriormente, en el primer código, ya se ha utilizado diccionarios con valores diferentes a cadenas de texto.\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "SUFIJOS = {1000: [ 'KB' , 'MB' , 'GB' , 'TB' , 'PB' , 'EB' , 'ZB' , 'YB' ] ,\n",
        "  1024: [ 'KiB ' , 'MiB ' , 'GiB ' , 'TiB ' , 'PiB ' , 'EiB ' , ' ZiB ' , 'YiB ' ] }\n",
        "```\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "BX9khicyO_8e",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "## Capítulo 3: Comprensiones\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "kd0k1HegnZkg",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "###Ficheros y directorios\n",
        "Python 3 posee un módulo denominado **os** que es la contracción de \"operating system\". El módulo **os** contiene un gran número de funciones para recuperar | y en algunos casos, modificar información sobre directorios, ficheros, procesos y variables del entorno local. Python hace un gran esfuerzo por ofrecer una API unificada en todos los sistemas operativos que soporta, por lo que los programas pueden funcionar en casi cualquier ordenador con el mínimo de código específico posible."
      ]
    },
    {
      "metadata": {
        "id": "TymAgo7BQAuW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "eb71b8ca-d001-4810-9901-1d2a7ea56ac7"
      },
      "cell_type": "code",
      "source": [
        "import os\n",
        "print (\"Directorio actual: \", os.getcwd( ))"
      ],
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Directorio actual:  /content\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "-sYrBzK_QitX",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "El módulo **os.path** contiene funciones para manipular nombres de ficheros y directorios.\n",
        "La función **os.path.join()** construye un nombre completo de fichero o directorio (nombre de path) a partir de uno o más partes. En este caso únicamente tiene que concatenar las cadenas."
      ]
    },
    {
      "metadata": {
        "id": "0B7KCeaaqRzo",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e51c2dcc-b722-4478-8d3f-326fdc03e73e"
      },
      "cell_type": "code",
      "source": [
        "print (os.path.join('/content/', 'parahumanos.py'))"
      ],
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/content/parahumanos.py\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "D02RwAVHqsyO",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "El módulo ** glob** es otra herramienta incluida en la librería estándar de Python.\n",
        "Proporciona una forma sencilla de acceder al contenido de un directorio desde un programa. Utiliza los caracteres comodín que suelen usarse en una consola de línea de comandos."
      ]
    },
    {
      "metadata": {
        "id": "-YWMz3oNq6er",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "32e3a61d-e906-49bc-b56d-071225acbebd"
      },
      "cell_type": "code",
      "source": [
        "import glob\n",
        "glob.glob('content/*.*')"
      ],
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 69
        }
      ]
    },
    {
      "metadata": {
        "id": "tBo--3pWr9gv",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "###Listas por comprensión\n",
        "Proporcionan una forma compacta de crear una lista a partir de otra mediante la realización de una operación a cada uno de los elementos de la lista original."
      ]
    },
    {
      "metadata": {
        "id": "Nn1kl6tLsQJl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "1f5e54f7-0134-4bea-a13f-ff2734d09981"
      },
      "cell_type": "code",
      "source": [
        "una_lista = [ 1 , 9 , 8 , 4 ]\n",
        "[elem * 2 for elem in una_lista]"
      ],
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[2, 18, 16, 8]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 73
        }
      ]
    },
    {
      "metadata": {
        "id": "QPpyaW9nsssw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "391ba434-e1e8-4fa0-9f0b-5ce100d8e701"
      },
      "cell_type": "code",
      "source": [
        "una_lista"
      ],
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 9, 8, 4]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 74
        }
      ]
    },
    {
      "metadata": {
        "id": "YO5Af1VGtDZF",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "## Capítulo 4: Cadenas de texto"
      ]
    },
    {
      "metadata": {
        "id": "KZD5sRPSvSN_",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "###Inmersión\n",
        "\n",
        "En Python 3 todas las cadenas de texto son secuencias de caracteres Unicode. En Python 3 no existen cadenas codificadas en UTF-8 o en CP-1252. No es correcto decir ¿Es esta cadena una cadena codificada en UTF-8?. UTF-8 es una forma de codificar caracteres en una secuencia de bytes. Si quieres convertir una cadena de caracteres en una secuencia de bytes en una codificación de caracteres particular, Python 3 puede ayudarte con ello. Si quieres tomar una secuencia de bytes y convertirla en una cadena de texto, también te puede ayudar Python 3. Los bytes no son caracteres, los bytes son bytes. Los caracteres son una abstracción. Una cadena es una secuencia de esas abstracciones."
      ]
    },
    {
      "metadata": {
        "id": "nZ6cL18_u42n",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "650fd6f4-d709-4255-97ce-59d46b4c6ca3"
      },
      "cell_type": "code",
      "source": [
        "s=\"방탄소년단 Python\"\n",
        "len(s)"
      ],
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 76
        }
      ]
    },
    {
      "metadata": {
        "id": "pUNsWfrlv1Rc",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "fb1d7cf0-4960-459e-dafd-ddf61ca39318"
      },
      "cell_type": "code",
      "source": [
        "s[4]"
      ],
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'단'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 80
        }
      ]
    },
    {
      "metadata": {
        "id": "ODJEPHRgwMfV",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Python 3 permite formatear valores en cadenas de texto. Aunque este sistema permite expresiones muy complejas, su uso más básico consiste en insertar un valor en una cadena de texto en el lugar definido por un \"marcador\".\n",
        "\n",
        "En el siguiente ejemplo, se comprueba que las cadenas de texto son objetos, y los objetos tienen métodos, como ya sabes. Segundo, la expresión completa se\n",
        "evalúa a una cadena. Tercero, {0} y {1} son campos de reemplazo, que se sustituyen con los parámetros que se pasen al método format()."
      ]
    },
    {
      "metadata": {
        "id": "i_C5u80swktr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b027a7c9-1caa-4493-ee22-d652903034f4"
      },
      "cell_type": "code",
      "source": [
        "usuario = \"Paty\"\n",
        "clave = \"azúl\"\n",
        "\"La clave de {0} es {1}\".format(usuario,clave)"
      ],
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'La clave de Paty es azúl'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 82
        }
      ]
    },
    {
      "metadata": {
        "id": "FXPFr-qDx5J0",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "### Especificaciones de formato\n",
        "\n",
        "Los especificadores de formato te permiten indicar cómo se debe efectuar la sustitución del texto, como sucede con la función printf() en el lenguaje C. Puedes añadir ceros o espacios de relleno delante del número, alinear cadenas, controlar la precisión de decimales o convertir el número a hexadecimal.\n",
        "\n",
        "Dentro del campo de sustitución se utiliza el símbolo de dos puntos (**:**) para marcar el comienzo del especificador de formato. El especificador de formato **.1** significa que se \"redondee a la décima más próxima\" (que se muestre únicamente un dígito después del punto decimal). El especificador \"f\" indica que el número debe mostrarse en formato punto fijo (por oposición a la notación exponencial u otra representación de un número). Si la variable tamanyo vale 698.24 y la variable sufijo vale \"GB\" la cadena formateada resultante es \"698.2 GB\", porque 698.24 se redondea con un solo dígito después del punto decimal."
      ]
    },
    {
      "metadata": {
        "id": "_I6P4cHJzl7g",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b44a5cf8-0da1-407a-f41d-3f02830c0295"
      },
      "cell_type": "code",
      "source": [
        "'{0:.1f} {1}'.format(698.24,'GB')"
      ],
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'698.2 GB'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 83
        }
      ]
    },
    {
      "metadata": {
        "id": "ApZozeMt0Iuh",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "###Otros métodos habituales de manipulación de cadenas\n",
        "Además de formatearlas, es posible hacer muchas otras cosas de utilidad con las cadenas de texto."
      ]
    },
    {
      "metadata": {
        "id": "j6i4FjrZ0YuQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "c2e7aa61-12e6-4d8b-b922-0def039b0814"
      },
      "cell_type": "code",
      "source": [
        "s = '''Los archivos terminados son el re-\n",
        "... sultado de años de estudio cientí-\n",
        "... co convinados con la\n",
        "... experiencia de años. '''\n",
        "s.splitlines( )"
      ],
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Los archivos terminados son el re-',\n",
              " 'sultado de años de estudio cientí-',\n",
              " 'co convinados con la',\n",
              " 'experiencia de años. ']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 84
        }
      ]
    },
    {
      "metadata": {
        "id": "7WS0CcE41B47",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        },
        "outputId": "a34a130a-488a-425f-e050-f6d32177599f"
      },
      "cell_type": "code",
      "source": [
        "print(s.lower())\n",
        "s.lower().count('l')"
      ],
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "los archivos terminados son el re-\n",
            "sultado de años de estudio cientí-\n",
            "co convinados con la\n",
            "experiencia de años. \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 85
        }
      ]
    },
    {
      "metadata": {
        "id": "gA9-HuYk1Y7u",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Pongamos un caso muy común. Supón que tienes una cadena de texto en forma de parejas clave-valor, clave1=valor1&clave2=valor2, y quieres dividirla y crear un\n",
        "diccionario de la forma {clave1: valor1, clave2: valor2}."
      ]
    },
    {
      "metadata": {
        "id": "eoUVC2XF1glO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "97dba42f-fd8f-462f-9f4c-e67c32ad3a69"
      },
      "cell_type": "code",
      "source": [
        "consulta = 'usuario=pilgrim&basededatos=master&clave=PapayaWhip'\n",
        "una_lista = consulta.split('&')\n",
        "una_lista"
      ],
      "execution_count": 86,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['usuario=pilgrim', 'basededatos=master', 'clave=PapayaWhip']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 86
        }
      ]
    },
    {
      "metadata": {
        "id": "_YgDyo1b168i",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a5a692b4-d43d-410a-b2e3-42f5d5f11f89"
      },
      "cell_type": "code",
      "source": [
        "una_lista_de_listas = [ v.split('=',1) for v in una_lista]\n",
        "una_lista_de_listas"
      ],
      "execution_count": 87,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[['usuario', 'pilgrim'], ['basededatos', 'master'], ['clave', 'PapayaWhip']]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 87
        }
      ]
    },
    {
      "metadata": {
        "id": "VMnJB7sB2O8s",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "eefa6a69-b528-44aa-ec8a-1fcff301feef"
      },
      "cell_type": "code",
      "source": [
        "a_dict = dict(una_lista_de_listas)\n",
        "a_dict"
      ],
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'basededatos': 'master', 'clave': 'PapayaWhip', 'usuario': 'pilgrim'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 88
        }
      ]
    },
    {
      "metadata": {
        "id": "OGNEYTMM2oNA",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "---\n",
        "\n",
        "###Troceado de cadenas\n",
        "\n",
        "Cuando ya has definido una cadena puedes recuperar cualquier parte de ella creando una nueva cadena de texto. A esto se denomina troceado/particionado de\n",
        "cadenas. Esto funciona de forma idéntica a como funciona para las listas, lo que tiene sentido, porque las cadenas de texto no son más que cadenas de caracteres."
      ]
    },
    {
      "metadata": {
        "id": "mqHvz2IR27UQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "8de1c9c1-568b-4f02-c75e-8b60a45f6158"
      },
      "cell_type": "code",
      "source": [
        "una_cadena = 'Mi vocabulario comienza donde el tuyo termina'\n",
        "una_cadena [3:14]"
      ],
      "execution_count": 89,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'vocabulario'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 89
        }
      ]
    },
    {
      "metadata": {
        "id": "hUdvf4i53JK6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "bc55fdba-b943-441f-9b24-775ecca1d320"
      },
      "cell_type": "code",
      "source": [
        "una_cadena [3:-3]"
      ],
      "execution_count": 90,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'vocabulario comienza donde el tuyo term'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 90
        }
      ]
    },
    {
      "metadata": {
        "id": "kE-1ZtBz3SKw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f92a0c50-fdc8-406f-b907-7821a7093200"
      },
      "cell_type": "code",
      "source": [
        "una_cadena [:23]"
      ],
      "execution_count": 91,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Mi vocabulario comienza'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 91
        }
      ]
    },
    {
      "metadata": {
        "id": "AFm2y37R3e0X",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "15be8495-8eea-4fe1-93b6-93d1af56c2d9"
      },
      "cell_type": "code",
      "source": [
        "una_cadena [23:]"
      ],
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "' donde el tuyo termina'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 92
        }
      ]
    },
    {
      "metadata": {
        "id": "KmHCQoAZ3ngn",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "###Cadenas de texto y bytes\n",
        "\n",
        "Los bytes son bytes; los caracteres son una abstracción. A una secuencia inmutable de caracteres Unicode se le llama cadena de texto. Una secuencia inmutable\n",
        "de números entre el 0 y el 255 es un objeto que se denomina bytes."
      ]
    },
    {
      "metadata": {
        "id": "B563hyJ63yYS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e5ea9cad-0619-4573-acc3-c70ab9b2c492"
      },
      "cell_type": "code",
      "source": [
        "by = b'abcd\\x65'\n",
        "by"
      ],
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "b'abcde'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 97
        }
      ]
    },
    {
      "metadata": {
        "id": "b1GeUFBE4IqV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ad333207-d0c6-4960-fd6f-9888b364cb77"
      },
      "cell_type": "code",
      "source": [
        "type (by)"
      ],
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "bytes"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 98
        }
      ]
    },
    {
      "metadata": {
        "id": "S8oXqjbL4tjw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "299d4458-bdda-4817-f428-50a162f647c2"
      },
      "cell_type": "code",
      "source": [
        "len(by)"
      ],
      "execution_count": 99,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 99
        }
      ]
    },
    {
      "metadata": {
        "id": "CCVlUhyJ40M8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "7485aa02-a662-47d3-c85f-dab48d5cca83"
      },
      "cell_type": "code",
      "source": [
        "by += b'\\xff'\n",
        "by"
      ],
      "execution_count": 100,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "b'abcde\\xff'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 100
        }
      ]
    },
    {
      "metadata": {
        "id": "ExRdadp55Dm5",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "3d23a804-18ac-4de1-8bee-07836cb5c1f6"
      },
      "cell_type": "code",
      "source": [
        "len(by)"
      ],
      "execution_count": 101,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 101
        }
      ]
    },
    {
      "metadata": {
        "id": "JIB3YrO-5L5R",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "64e1101c-59ce-4bc5-d46d-8f37ab578616"
      },
      "cell_type": "code",
      "source": [
        "by [0]"
      ],
      "execution_count": 102,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "97"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 102
        }
      ]
    },
    {
      "metadata": {
        "id": "4vpUnjvA5QC8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        },
        "outputId": "c308ff0d-bfd5-43b7-a3e7-69a244615158"
      },
      "cell_type": "code",
      "source": [
        "by[0]=102"
      ],
      "execution_count": 103,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-103-71e4c770fe7c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mby\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m102\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'bytes' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "metadata": {
        "id": "hAdq41D65gQa",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Un objeto bytes es inmutable; no puedes asignar bytes individuales. Si necesitas modificar bytes individuales de un objeto bytes, es necesario particionar y concatener para crear un nuevo objeto bytes que contenga los elementos deseados. La alternativa es convertir el objeto bytes en un bytearray que sí permite modificación."
      ]
    },
    {
      "metadata": {
        "id": "PTKNZjD95wpQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "8ce4db0d-da0c-44e4-8e46-246f52951f01"
      },
      "cell_type": "code",
      "source": [
        "by = b'abcd\\x65'\n",
        "barr = bytearray(by)\n",
        "barr"
      ],
      "execution_count": 105,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "bytearray(b'abcde')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 105
        }
      ]
    },
    {
      "metadata": {
        "id": "nsKDXvuK6Dh4",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c370cdae-4c10-4306-fa7c-76a7e2007c53"
      },
      "cell_type": "code",
      "source": [
        "len(barr)"
      ],
      "execution_count": 106,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 106
        }
      ]
    },
    {
      "metadata": {
        "id": "FpRMWMQL6NfQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "63c2a191-53da-4354-c904-cb27c34dcff5"
      },
      "cell_type": "code",
      "source": [
        "barr[0] = 102\n",
        "barr"
      ],
      "execution_count": 107,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "bytearray(b'fbcde')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 107
        }
      ]
    },
    {
      "metadata": {
        "id": "t4AN4LZc6ehT",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "La relación que existe entre las cadenas de texto y los bytes: los objetos bytes tienen un método decode() que toma como parámetro una tabla de codificación de caracteres y retorna una cadena. Y las cadenas de texto tienen un método denominado encode() que toma una tabla de codificación de caracteres y retorna un objeto bytes. En el ejemplo anterior, la decodificación fue relativamente directa -- convertir una secuencia de bytes que estaba en la codificación de caracteres ASCII en una cadena de texto. Pero el mismo proceso funciona con cualquier tabla de codificación de caracteres siempre que dicha tabla soporte los caracteres existentes en la cadena |incluso con codificaciones heredadas (previas a Unicode)."
      ]
    },
    {
      "metadata": {
        "id": "1Xqo83MF7IKI",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "94db15cf-c9fc-457a-ce0c-92e3f8e279c6"
      },
      "cell_type": "code",
      "source": [
        "s = '방탄소년단 Python'\n",
        "len(s)"
      ],
      "execution_count": 108,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 108
        }
      ]
    },
    {
      "metadata": {
        "id": "a6tSnJl-7TFH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ce210076-c286-4ba9-828a-08a22b2911a9"
      },
      "cell_type": "code",
      "source": [
        "by = s.encode('utf-8')\n",
        "by"
      ],
      "execution_count": 109,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "b'\\xeb\\xb0\\xa9\\xed\\x83\\x84\\xec\\x86\\x8c\\xeb\\x85\\x84\\xeb\\x8b\\xa8 Python'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 109
        }
      ]
    },
    {
      "metadata": {
        "id": "XxX4BXYJ7gSm",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c621d19d-5004-468c-a9c0-77706495b1e6"
      },
      "cell_type": "code",
      "source": [
        "len(by)"
      ],
      "execution_count": 110,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "22"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 110
        }
      ]
    },
    {
      "metadata": {
        "id": "WT35UidG7mDA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ed0812aa-cf88-411a-e608-be29edfef737"
      },
      "cell_type": "code",
      "source": [
        "by = s.encode('gb18030')\n",
        "by"
      ],
      "execution_count": 111,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "b'\\x830\\xf32\\x835\\x8c7\\x832\\x811\\x828\\xd83\\x829\\x843 Python'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 111
        }
      ]
    },
    {
      "metadata": {
        "id": "aZXrPWyl73n0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4464a040-8471-45ac-bba1-400855bbcebd"
      },
      "cell_type": "code",
      "source": [
        "len(by)"
      ],
      "execution_count": 112,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "27"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 112
        }
      ]
    },
    {
      "metadata": {
        "id": "0klmnCT28AGW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "6f9f80eb-e8b4-4788-9e46-9e330c4e243c"
      },
      "cell_type": "code",
      "source": [
        "by = s.encode('utf-16')\n",
        "by"
      ],
      "execution_count": 113,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "b'\\xff\\xfe)\\xbc\\xc4\\xd0\\x8c\\xc1D\\xb1\\xe8\\xb2 \\x00P\\x00y\\x00t\\x00h\\x00o\\x00n\\x00'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 113
        }
      ]
    },
    {
      "metadata": {
        "id": "QHXiNqO88ITO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "09917e3a-c966-42fa-fa9d-60e329c71c61"
      },
      "cell_type": "code",
      "source": [
        "len(by)"
      ],
      "execution_count": 114,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "26"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 114
        }
      ]
    },
    {
      "metadata": {
        "id": "4XmZuhNm8Nti",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ffc6f68f-3c5f-4df4-81ea-3a17666d253c"
      },
      "cell_type": "code",
      "source": [
        "vuelta= by.decode('utf-16')\n",
        "vuelta"
      ],
      "execution_count": 116,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'방탄소년단 Python'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 116
        }
      ]
    },
    {
      "metadata": {
        "id": "OBwUBVma8cRj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a928451b-f354-44cf-f237-6d106f6f40b4"
      },
      "cell_type": "code",
      "source": [
        "vuelta==s"
      ],
      "execution_count": 117,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 117
        }
      ]
    },
    {
      "metadata": {
        "id": "XjZnIjeB8tQj",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Python 3 asume que el código fuente -cadafichero.py- está codificado en UTF-8."
      ]
    },
    {
      "metadata": {
        "id": "Xy4G_dnek4NG",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "## Capítulo 5: Expresiones regulares"
      ]
    },
    {
      "metadata": {
        "id": "GLItsKuek_BT",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "### Inmersión\n",
        "\n",
        "Todo lenguaje de programación moderno dispone de funciones internas para trabajar con cadenas. En Python las cadenas de texto tienen métodos para buscar y reemplazar: index(), **find()**, split(), **count()**, replace(), etc. Pero esos métodos están limitados a los casos más simples. Por ejemplo, el método **index()** busca por una única subcadena, y la búsqueda siempre distingue entre mayúsculas y minúsculas.\n",
        "\n",
        "Para poder hacer búsquedas que no distingan entre ellas debes utilizar **s.lower()** o **s.upper()** y asegurarte de que tus cadenas de búsqueda se encuentran en el mismo caso. Los métodos **replace()** y **split()**.\n",
        "\n",
        "Las expresiones regulares son una forma poderosa y (en su mayor parte) estándar de búsqueda, reemplazo y análisis de texto con patrones de caracteres complejos. Aunque la sintaxis de las expresiones regulares es compacta y muy diferente del código normal, el resultado puede resultar ser más legible que una solución manual que utilice un montón de funciones de cadenas de texto encadenadas. Incluso existe un modo estándar de incluir comentarios dentro de las expresiones regulares, por lo que puedes incluir una documentación detallada dentro de ellas."
      ]
    },
    {
      "metadata": {
        "id": "cv-XzeZOoHou",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "A continuación se muestra una serie de ejemplos que se inspiran en un problema de la vida real que tuve en el trabajo hace varios años, cuando necesité depurar y estandarizar una lista de direcciones postales exportadas de un sistema heredado antes de importarlas en un nuevo sistema. Este ejemplo muestra la forma en la que abordé el problema:"
      ]
    },
    {
      "metadata": {
        "id": "8n1k05lOmwg2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "9980b408-27c9-4c9b-92f6-cc26b5917492"
      },
      "cell_type": "code",
      "source": [
        "s ='100 NORTH MAIN ROAD'\n",
        "s.replace('ROAD', 'RD.')"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'100 NORTH MAIN RD.'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "metadata": {
        "id": "LLgTVpa3m_Hd",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "3a7b14f4-9e12-489b-f7f6-4ce51bcd4bc0"
      },
      "cell_type": "code",
      "source": [
        "s = '100 NORTH BROAD ROAD'\n",
        "s.replace('ROAD', 'RD.')"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'100 NORTH BRD. RD.'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "metadata": {
        "id": "TyGM_2OHnaFI",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "92df0b9a-05a0-4795-8894-fdec674f1cd0"
      },
      "cell_type": "code",
      "source": [
        "s [:-4 ] + s [-4:].replace('ROAD', 'RD.')"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'100 NORTH BROAD RD.'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "metadata": {
        "id": "i5PJtvNOnvF6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0ec102f4-62ab-40a3-f9c3-cd7964b75488"
      },
      "cell_type": "code",
      "source": [
        "import re\n",
        "re.sub('ROAD$', 'RD.',s)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'100 NORTH BROAD RD.'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "metadata": {
        "id": "9DXmR1L8oGRv",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "daa533ac-27cf-49f1-cd40-a93697e30c21"
      },
      "cell_type": "code",
      "source": [
        "s = '100 BROAD'\n",
        "re.sub('ROAD$', 'RD.',s)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "' 100 BRD.'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "metadata": {
        "id": "c0l9__6EopoZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f4e1d119-5587-475a-aefb-e1dd28d2a449"
      },
      "cell_type": "code",
      "source": [
        "re.sub('nbROAD$', 'RD.',s)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "' 100 BROAD'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "metadata": {
        "id": "VCvlECP2oyG6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "9ff16e99-d86c-45a6-e08d-f04a3e6858ec"
      },
      "cell_type": "code",
      "source": [
        "re.sub(r'\\bROAD$', 'RD.',s)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "' 100 BROAD'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "metadata": {
        "id": "jU725o8WpRxD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "fca0d5be-789d-4357-b4bf-2f4e27ed0665"
      },
      "cell_type": "code",
      "source": [
        "s = '100 BROAD ROAD APT. 3'\n",
        "re.sub(r'\\bROAD$', 'RD.',s)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'100 BROAD ROAD APT. 3'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "metadata": {
        "id": "F1jZ0Y8SpmKp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "dceb8011-c81a-4a8d-f015-28efadd08f14"
      },
      "cell_type": "code",
      "source": [
        "re.sub(r'\\bROAD\\b', 'RD.',s)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'100 BROAD RD. APT. 3'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "metadata": {
        "id": "IagGeJQlp3Me",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "###Caso de estudio: números romanos\n",
        "\n",
        "\n",
        "En los números romanos existen siete caracteres que se repiten y combinan de diferentes formas para representar números:\n",
        "\n",
        "\n",
        "* I = 1\n",
        "* V = 5\n",
        "* X = 10\n",
        "* L = 50\n",
        "* C = 100\n",
        "* D = 500\n",
        "* M = 1000\n",
        "\n",
        "Existen una reglas generales para construir números romanos:\n",
        "\n",
        "\n",
        "\n",
        "* Los caracteres son aditivos, I es 1, II es 2 y III es 3. VI es 6 (literalmente 5 + 1), VII es 7 (5+1+1) y XVIII es 18 (10+5+1+1+1).\n",
        "\n",
        "* Los caracteres que representan unidades, decenas, centenas y unidades de millar (I, X, C y M) pueden aparecer juntos hasta tres veces como máximo. Para el 4 debes restar del carácter V, L ó D (cinco, cincuenta, quinientos) que se encuentre más próximo a la derecha. \n",
        "* No se puede representar el cuatro como IIII, en su lugar hay que poner IV (5-1). El número 40 se representa como XL (10 menos que 50: 50-10). 41 = XLI, 42 = XLII, 43 = XLIII y luego 44 = XLIV (diez menos que cincuenta más uno menos que cinco: 50-10+5-1).\n",
        "* De forma similar, para el número 9, debes restar del número siguiente más próximo que represente unidades, decenas, centenas o unidades de millar (I,\n",
        "X, C y M). 8 = VIII, pero 9 = IX (1 menos que 10), no 9 = VIIII puesto que el carácter I no puede repetirse cuatro veces seguidas. El número 90 se representa con XC y el 900 con CM.\n",
        "* Los caracteres V, L y D no pueden repetirse; el número 10 siempre se representa como X y no como VV. El número 100 siempre se representa como C y nunca\n",
        "como LL.\n",
        "* Los números romanos siempre se escriben de los caracteres que representan valores mayores a los menores y se leen de izquierda a derecha por lo que el orden de los caracteres importa mucho. {DC es el número 600; CD otro número, el 400 (500 - 100). CI es 101, mientras que IC no es un número romano válido porque no puedes restar I del C4}."
      ]
    },
    {
      "metadata": {
        "id": "8Bw4hJJ7sScX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b15facbc-b0df-4e53-e4f9-e623ac8e02c2"
      },
      "cell_type": "code",
      "source": [
        "import re\n",
        "pattern = '^M?M?M?$'\n",
        "re.search(pattern, 'M')"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 1), match='M'>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "metadata": {
        "id": "PXOOev62slQS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b9de36d5-a59f-429a-959b-ec213d37d68f"
      },
      "cell_type": "code",
      "source": [
        "re.search(pattern, 'MM')"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 2), match='MM'>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "metadata": {
        "id": "jDEh77FQtH9w",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "038761e9-b9ea-458b-cf22-ce8806565a4b"
      },
      "cell_type": "code",
      "source": [
        "re.search(pattern, 'MMM')"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 3), match='MMM'>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "metadata": {
        "id": "52TUkNFjtUeF",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "re.search(pattern, 'MMMM')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "onaFEHoftfOe",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "14e21130-5422-4b7c-d673-4f3d6d069ac4"
      },
      "cell_type": "code",
      "source": [
        "re.search(pattern, '')"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 0), match=''>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "metadata": {
        "id": "4_j8RcVit1Z_",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "###A la búsqueda de coincidencias de las centenas\n",
        "\n",
        "Las centenas son más difíciles que los miles, porque existen varias formas exclusivas de representación dependiendo del valor.\n",
        "* 100 = C\n",
        "* 200 = CC\n",
        "* 300 = CCC\n",
        "* 400 = CD\n",
        "* 500 = D\n",
        "* 600 = DC\n",
        "* 700 = DCC\n",
        "* 800 = DCCC\n",
        "* 900 = CM\n",
        "Por lo que existen cuatro patrones posibles:\n",
        "* CM\n",
        "* CD\n",
        "* De cero a tres caracteres C (Cero si el lugar de las centenas vale cero).\n",
        "* D, seguido de cero a tres caracteres C.\n",
        "\n",
        "Los dos últimos patrones se pueden combinar:\n",
        "* Una D opcional, seguida de cero a tres caracteres C.\n",
        "\n",
        "Este ejemplo muestra cómo validar las centenas de un número romano.\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "F7CaxdUyuil6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "aa3525af-d781-4161-8447-ca5aa3129d8d"
      },
      "cell_type": "code",
      "source": [
        "import re\n",
        "pattern = '^M?M?M?(CM|CD|D?C?C?C?)$'\n",
        "re.search(pattern, 'MCM')"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 3), match='MCM'>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "metadata": {
        "id": "_bNFD18Gu57W",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "75cfe9cb-30b7-4214-e533-874c4e64862f"
      },
      "cell_type": "code",
      "source": [
        "re.search(pattern, 'MD')"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 2), match='MD'>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "metadata": {
        "id": "Ncz77KPJvAtu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "852ecfbf-b3cd-454c-f837-c1f71bb7e6a3"
      },
      "cell_type": "code",
      "source": [
        "re.search(pattern, 'MMMCCC')"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 6), match='MMMCCC'>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "metadata": {
        "id": "Xppt3i2dvMu7",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "re.search(pattern, 'MCMC')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "TXV7TJnHvPi3",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "720abb8d-10cf-4a8e-ce56-696426e18284"
      },
      "cell_type": "code",
      "source": [
        "re.search(pattern, '')"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 0), match=''>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "metadata": {
        "id": "9_sYj-POveEN",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "###Utilización de sintaxis {n,m}\n",
        "\n",
        "En la sección anterior viste casos de caracteres que se podían repetir hasta tres veces. Existe otra forma de representar esto en las expresiones regulares que puede resultar más legible. "
      ]
    },
    {
      "metadata": {
        "id": "Ea3EmXE2v4mK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "1c3d6ab7-d47a-4826-ca99-8a22a4551637"
      },
      "cell_type": "code",
      "source": [
        "import re\n",
        "pattern= '^M{0,3}$'\n",
        "re.search(pattern, 'M')"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 1), match='M'>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "metadata": {
        "id": "Ev44BEgKwHj5",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "7421d1a7-bdf9-4d0c-85b6-e710c0e59d4d"
      },
      "cell_type": "code",
      "source": [
        "pattern= '^M{0,3}$'\n",
        "re.search(pattern, 'MM')"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 2), match='MM'>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "metadata": {
        "id": "8_QznAQAwWgy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "9bcd5da4-ce53-48eb-94ef-dbddf82e0ea2"
      },
      "cell_type": "code",
      "source": [
        "pattern= '^M{0,3}$'\n",
        "re.search(pattern, 'MMM')"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 3), match='MMM'>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "metadata": {
        "id": "l8HVD772wg4Y",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "re.search(pattern, 'MMMM')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Qi4zz4VrxF6F",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "###Comprobación de las decenas y unidades\n",
        "\n",
        "Vamos a completar la expresión regular de búsqueda de números romanos para incluir a las decenas y unidades. Este ejemplo incluye las decenas."
      ]
    },
    {
      "metadata": {
        "id": "x3QABUuexTqU",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "66bcf56e-2fed-4bda-de39-214dfa60259b"
      },
      "cell_type": "code",
      "source": [
        "pattern= '^M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)$'\n",
        "re.search(pattern, 'MCMXL')"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 5), match='MCMXL'>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 36
        }
      ]
    },
    {
      "metadata": {
        "id": "mpz96TEIxx3m",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "6d381d26-a1d3-45bb-e538-3ed2f988fb8b"
      },
      "cell_type": "code",
      "source": [
        "re.search(pattern, 'MCML')"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 4), match='MCML'>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "metadata": {
        "id": "YdDpsUiEx8Kr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "713af82d-ff82-4d1c-ab3f-9c98c2bb159c"
      },
      "cell_type": "code",
      "source": [
        "re.search(pattern, 'MCMLX')"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 5), match='MCMLX'>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "metadata": {
        "id": "YPJjC6FzyHUw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "be858910-422c-4deb-d554-a4ee11ed5c5c"
      },
      "cell_type": "code",
      "source": [
        "re.search(pattern, 'MCMLXXX')"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 7), match='MCMLXXX'>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 39
        }
      ]
    },
    {
      "metadata": {
        "id": "1Flo0aFwyMS4",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "re.search(pattern, 'MCMLXXXX')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "KsOjarOuyTGe",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "La expresión para las unidades sigue un patrón idéntico. \n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "pattern = '^M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)(IX|IV|V?I?I?I?)$ '\n",
        "```\n",
        "Cómo quedaría utilizando la sintaxis {n,m}  En el siguiente ejemplo observas el resultado.\n"
      ]
    },
    {
      "metadata": {
        "id": "y66o8oohyXpj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "07f8849d-09ea-4fc8-b4ec-24384da865f8"
      },
      "cell_type": "code",
      "source": [
        "pattern = '^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$'\n",
        "re.search(pattern, 'MDLV')"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 4), match='MDLV'>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "metadata": {
        "id": "6iFQv_B8zlt6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "68f44319-1e05-4a71-d686-a592c709f33b"
      },
      "cell_type": "code",
      "source": [
        "re.search(pattern, 'MMDCLXVI')"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 8), match='MMDCLXVI'>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        }
      ]
    },
    {
      "metadata": {
        "id": "5tyzR1q2zqZD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "1f8802c3-c923-4754-e0a4-46d8ca65ea99"
      },
      "cell_type": "code",
      "source": [
        "re.search(pattern, 'MMMDCCCLXXXVIII')"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 15), match='MMMDCCCLXXXVIII'>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 44
        }
      ]
    },
    {
      "metadata": {
        "id": "kmRCXSWAzuJ6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "875a1b59-4fd0-4a90-f1f1-9374d84fdda1"
      },
      "cell_type": "code",
      "source": [
        "re.search(pattern, 'I')"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<_sre.SRE_Match object; span=(0, 1), match='I'>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 45
        }
      ]
    },
    {
      "metadata": {
        "id": "pIBZN3R9z3Fx",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "###Expresiones regulares detalladas\n",
        "Python te permite hacer documentación incrustada mediante el uso de las expresiones regulares detalladas.\n",
        "Se diferencia de una expresión regular compacta en dos cosas:\n",
        "* Los espacios en blanco se ignoran: espacios, tabuladores y retornos de carro o saltos de línea. No se tienen en cuenta para el cumplimiento o no de la expresión\n",
        "regular. Si quieres que exista realmente tal coincidencia será necesario que incluyas el carácter de escape delante de ellos.\n",
        "* Se ignoran los comentarios. Un comentario en una expresión regular detallada es exactamente igual que en Python: comienza en el carácter # termina al\n",
        "acabarse la línea. En este caso, el comentario está incluido en una cadena de texto de varias líneas en lugar de estar directamente en ti código fuente, pero\n",
        "por lo demás es exactamente lo mismo."
      ]
    }
  ]
}