Taller_22_expresiones_regulares.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/SantiagoMaya10/PPI-MayaRestrepo-2024-2s/blob/main/Taller_22_expresiones_regulares.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## «*He aprendido a no intentar convencer a nadie. El trabajo de convencer es una falta de respeto, es un intento de colonización del otro*».\n",
        "### [José Saramago](https://es.wikipedia.org/wiki/Jos%C3%A9_Saramago)"
      ],
      "metadata": {
        "id": "cr-wZpWhC2dt"
      }
    },
    {
      "metadata": {
        "id": "tpFFfpLa7D_R"
      },
      "cell_type": "markdown",
      "source": [
        "# Taller 22 expresiones regulares en Python\n",
        "\n",
        "Los objetivos de este taller son:\n",
        "\n",
        "* Comprender qué son las expresiones regulares y su importancia en el procesamiento de texto.\n",
        "\n",
        "* Aprender la sintaxis básica de las expresiones regulares en Python.\n",
        "\n",
        "* Practicar la aplicación de expresiones regulares en la manipulación y búsqueda de texto.\n",
        "\n",
        "* Familiarizarse con herramientas y recursos para trabajar eficientemente con expresiones regulares."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Definición y conceptos básicos\n",
        "\n",
        "Las **expresiones regulares** (*regex* o *regexp*) son secuencias de caracteres que definen un patrón de búsqueda.\n",
        "\n",
        "Estos patrones se utilizan para encontrar cadenas de texto que coincidan con ciertos criterios dentro de un texto más grande.\n",
        "\n",
        "Los patrones de búsqueda pueden incluir caracteres literales (como letras y números) y metacaracteres (que representan clases de caracteres, repeticiones, posiciones en el texto, y otros más)."
      ],
      "metadata": {
        "id": "Q1cx54I9GtOj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Información adicional y herramientas online para trabajar con expresiones regulares\n",
        "\n",
        "Información adicional:\n",
        "\n",
        "[W3Schools](https://www.w3schools.com/python/python_regex.asp)\n",
        "\n",
        "Herramientas online:\n",
        "\n",
        "* [Regex101](https://regex101.com/)\n",
        "* [Regexr](https://regexr.com/)"
      ],
      "metadata": {
        "id": "A9nrBZ68QOe3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Sintaxis básica de las expresiones regulares en Python"
      ],
      "metadata": {
        "id": "iKHsn1KcZibB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Caracteres literales y metacaracteres\n",
        "\n",
        "Los caracteres literales representan sus mismos valores en una expresión regular.\n",
        "\n",
        "Caracteres literales: a, b, 123, y similares.\n",
        "\n",
        "Los metacaracteres son caracteres con un significado especial en expresiones regulares.\n",
        "\n",
        "Metacaracteres: cualquier carácter (excepto nueva línea), * (0 o más repeticiones), + (1 o más repeticiones), ? (0 o 1 repetición).\n"
      ],
      "metadata": {
        "id": "tcByS5IlZmVA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar la librería requerida\n",
        "import re\n",
        "\n",
        "# Crear una cadena de texto de referencia\n",
        "texto = \"Python es genial!\"\n",
        "\n",
        "# Ejemplo de caracteres literales\n",
        "# 'es' coincide con los caracteres literales 'es'\n",
        "coincidencias_0 = re.findall(r'es', texto)\n",
        "\n",
        "# Resultado: ['es']\n",
        "print(coincidencias_0)\n",
        "\n",
        "# Ejemplo de metacaracteres\n",
        "# \\w+ coincide con una o más ocurrencias de cualquier carácter alfanumérico\n",
        "coincidencias_1 = re.findall(r'Py\\w+n', texto)\n",
        "\n",
        "# Resultado: ['Python']\n",
        "print(coincidencias_1)"
      ],
      "metadata": {
        "id": "HS7nRQ0NaLPX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Clases de caracteres y cuantificadores:\n",
        "\n",
        "Las clases de caracteres permiten especificar un conjunto de caracteres que coinciden con uno cualquiera de ellos.\n",
        "\n",
        "Los cuantificadores se utilizan para especificar la cantidad de veces que se debe repetir un carácter o un conjunto de caracteres.\n",
        "\n",
        "Ejemplo:\n",
        "\n",
        "Clases de caracteres:\n",
        "* [A-Z] (cualquier letra mayúscula)\n",
        "* [a-z] (cualquier letra minúscula)\n",
        "* [0-9] (cualquier dígito)\n",
        "* [aeiou] (cualquier vocal)\n",
        "\n",
        "Cuantificadores:\n",
        "* {m} (exactamente m repeticiones)\n",
        "* {m, n} (entre m y n repeticiones)\n",
        "* {m,} (al menos m repeticiones)\n",
        "* {,n} (hasta n repeticiones)"
      ],
      "metadata": {
        "id": "TmFK29cJGEbr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar la librería requerida\n",
        "import re\n",
        "\n",
        "# Ejemplo de clases de caracteres y cuantificadores\n",
        "texto = \"La contraseña es 123456\"\n",
        "\n",
        "# Coincide con exactamente seis dígitos\n",
        "coincidencias_2 = re.findall(r'\\d{6}', texto)\n",
        "\n",
        "# Resultado: ['123456']\n",
        "print(coincidencias_2)"
      ],
      "metadata": {
        "id": "TWXOJH2PHTJE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Grupos de captura y grupos sin captura:\n",
        "\n",
        "Los grupos de captura permiten extraer partes específicas de una cadena coincidente.\n",
        "\n",
        "Los grupos sin captura agrupan subexpresiones sin realizar capturas.\n",
        "\n",
        "Ejemplo:\n",
        "\n",
        "Grupo de captura:\n",
        "* (\\w+) (captura una palabra)\n",
        "* (\\d{3}) (captura un número de tres dígitos)\n",
        "\n",
        "Grupo sin captura:\n",
        "* (?:\\w+) (agrupa una palabra sin captura)\n",
        "* (?:\\d{3}) (agrupa un número de tres dígitos sin captura)"
      ],
      "metadata": {
        "id": "1EDPIR4GIBGd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar la librería requerida\n",
        "import re\n",
        "\n",
        "# Ejemplo de grupos con captura\n",
        "numero_telefono = \"El número de teléfono es 555-1234567\"\n",
        "\n",
        "# Dos grupos de captura para el código de área y el número\n",
        "patron_0 = r'(\\d{3})-(\\d{7})'\n",
        "\n",
        "# Encontrar todas las coincidencias\n",
        "coincidencias_3 = re.findall(patron_0, numero_telefono)\n",
        "\n",
        "# Resultado: [('555', '1234567')]\n",
        "print(coincidencias_3)\n",
        "\n",
        "# Ejemplo de grupos sin captura\n",
        "texto = \"Este es un ejemplo de expresión regular\"\n",
        "\n",
        "# Grupo sin captura para \"un\" seguido de una palabra\n",
        "patron_1 = r'(?:un\\s)(\\w+)'\n",
        "\n",
        "# Encontrar todas las coincidencias\n",
        "coincidencias_4 = re.findall(patron_1, texto)\n",
        "\n",
        "# Resultado: ['ejemplo']\n",
        "print(coincidencias_4)"
      ],
      "metadata": {
        "id": "yyofobvPH7Cj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Uso de caracteres especiales como \\b, ^, $,\n",
        "\n",
        "Los caracteres especiales tienen un significado especial en expresiones regulares y se utilizan para representar ciertas posiciones en el texto, como el inicio o el final de una línea, límites de palabra.\n",
        "\n",
        "Ejemplo:\n",
        "\n",
        "* ^: coincide con el inicio de una cadena o línea.\n",
        "* $: coincide con el final de una cadena o línea.\n",
        "* \\b: límite de palabra"
      ],
      "metadata": {
        "id": "JPT0g79GKJBD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar la librería requerida\n",
        "import re\n",
        "\n",
        "# Ejemplo de uso de caracteres especiales:\n",
        "texto = \"Python es un lenguaje de programación. Python es poderoso\"\n",
        "\n",
        "# Coincide solo si la cadena comienza con 'Python'\n",
        "patron_inicio = r'^Python'\n",
        "\n",
        "# Coincide solo si la cadena termina con 'poderoso'\n",
        "patron_final = r'poderoso$'\n",
        "\n",
        " # Coincide solo con la palabra 'Python' como una palabra completa\n",
        "patron_palabra = r'\\bPython\\b'\n",
        "\n",
        "# Buscar el inicio de la cadena\n",
        "inicio = re.findall(patron_inicio, texto)\n",
        "print(\"Coincidencias al inicio:\", inicio)\n",
        "\n",
        "# Buscar el final de la cadena\n",
        "final = re.findall(patron_final, texto)\n",
        "print(\"Coincidencias al final:\", final)\n",
        "\n",
        "# Buscar la palabra 'Python' como una palabra completa\n",
        "palabra = re.findall(patron_palabra, texto)\n",
        "print(\"Coincidencias de palabra completa:\", palabra)"
      ],
      "metadata": {
        "id": "nYUMQ8KbJTU5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Librería *re*\n",
        "\n",
        "La librería ***re*** de Python proporciona funciones para trabajar con expresiones regulares."
      ],
      "metadata": {
        "id": "JwUkS4dsMPlw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## re.match(patrón, cadena)\n",
        "\n",
        "Esta función intenta hacer coincidir el patrón especificado al principio de la cadena. Si hay una coincidencia, devuelve un objeto de coincidencia; de lo contrario, devuelve *None*."
      ],
      "metadata": {
        "id": "4sO1OSPjND-E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar la librería requerida\n",
        "import re\n",
        "\n",
        "# Crear una cadena de texto de referencia\n",
        "cadena = \"Python es un lenguaje de programación\"\n",
        "\n",
        "# Crear un patrón de referencia\n",
        "patrón = r'Python'\n",
        "\n",
        "# Buscar el patrón en la cadena\n",
        "resultado = re.match(patrón, cadena)\n",
        "\n",
        "# Mostrar el resultado\n",
        "if resultado:\n",
        "    print(\"Se encontró una coincidencia:\", resultado.group())\n",
        "else:\n",
        "    print(\"No se encontró ninguna coincidencia\")"
      ],
      "metadata": {
        "id": "Uki6CgL5Nzvu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## re.search(patrón, cadena)\n",
        "\n",
        "Esta función busca en toda la cadena una coincidencia con el patrón especificado. Si se encuentra una coincidencia, devuelve **un** objeto de coincidencia; de lo contrario, devuelve *None*."
      ],
      "metadata": {
        "id": "6BaRIh47OFWe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar la librería requerida\n",
        "import re\n",
        "\n",
        "# Crear una cadena de texto de referencia\n",
        "cadena = \"Python es un lenguaje de programación\"\n",
        "\n",
        "# Crear un patrón de referencia\n",
        "patrón = r'lenguaje'\n",
        "\n",
        "# Buscar el patrón en la cadena\n",
        "resultado = re.search(patrón, cadena)\n",
        "\n",
        "# Mostrar el resultado\n",
        "if resultado:\n",
        "    print(\"Se encontró una coincidencia:\", resultado.group())\n",
        "else:\n",
        "    print(\"No se encontró ninguna coincidencia\")"
      ],
      "metadata": {
        "id": "yXoBWMeHOQ4N"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## re.findall(patrón, cadena)\n",
        "\n",
        "Esta función encuentra todas las coincidencias del patrón en la cadena y devuelve **una lista** de todas las coincidencias."
      ],
      "metadata": {
        "id": "69-AHNLbOsH3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar la librería requerida\n",
        "import re\n",
        "\n",
        "# Crear una cadena de texto de referencia\n",
        "cadena = \"Python es un lenguaje de programación. Python es poderoso\"\n",
        "\n",
        "# Crear un patrón de referencia\n",
        "patrón = r'Python'\n",
        "\n",
        "# Buscar el patrón en la cadena\n",
        "resultado = re.findall(patrón, cadena)\n",
        "\n",
        "# Mostrar el resultado\n",
        "print(\"Coincidencias encontradas:\", resultado)"
      ],
      "metadata": {
        "id": "AlDoSIYhO14x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## re.sub(patrón, reemplazo, cadena)\n",
        "\n",
        "Esta función busca todas las coincidencias del patrón en la cadena y las **reemplaza** con el texto especificado en el argumento de reemplazo."
      ],
      "metadata": {
        "id": "COsr98cSPDyv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar la librería requerida\n",
        "import re\n",
        "\n",
        "# Crear una cadena de texto de referencia\n",
        "cadena = \"Python es un lenguaje de programación\"\n",
        "\n",
        "# Crear un patrón de referencia\n",
        "patrón = r'lenguaje'\n",
        "\n",
        "# Reemplazar el patrón en la cadena\n",
        "reemplazo = \"idioma\"\n",
        "\n",
        "# Buscar el patrón en la cadena\n",
        "resultado = re.sub(patrón, reemplazo, cadena)\n",
        "\n",
        "# Mostrar el resultado\n",
        "print(\"Cadena modificada:\", resultado)"
      ],
      "metadata": {
        "id": "LhDHY3pNPM-e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejemplos de usos de expresiones regulares"
      ],
      "metadata": {
        "id": "y9xh-61jW8AC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Validación de formatos de datos\n",
        "\n",
        "Verificación de números de teléfono, direcciones de correo electrónico, códigos postales."
      ],
      "metadata": {
        "id": "F9aX3QkHXCfE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar la librería requerida\n",
        "import re\n",
        "\n",
        "def verificar_texto(texto):\n",
        "    \"\"\"Verifica la presencia de números de teléfono, direcciones de correo\n",
        "    electrónico y códigos postales en un texto.\n",
        "\n",
        "    Args:\n",
        "        texto (str): El texto en el que se buscarán los patrones.\n",
        "\n",
        "    Returns:\n",
        "        tuple: Una tupla que contiene listas de números de teléfono,\n",
        "        direcciones de correo electrónico  códigos postales encontrados en el\n",
        "        texto, respectivamente.\n",
        "    \"\"\"\n",
        "    # Patrón para verificar números de teléfono\n",
        "    patron_telefono = r'\\b\\d{3}-\\d{3}-\\d{4}\\b'\n",
        "\n",
        "    # Patrón para verificar direcciones de correo electrónico\n",
        "    patron_correo = r'\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b'\n",
        "\n",
        "    # Patrón para verificar códigos postales (formato de 5 dígitos)\n",
        "    patron_codigo_postal = r'\\b\\d{5}\\b'\n",
        "\n",
        "    # Buscar números de teléfono en el texto\n",
        "    telefonos = re.findall(patron_telefono, texto)\n",
        "\n",
        "    # Buscar direcciones de correo electrónico en el texto\n",
        "    correos = re.findall(patron_correo, texto)\n",
        "\n",
        "    # Buscar códigos postales en el texto\n",
        "    codigos_postales = re.findall(patron_codigo_postal, texto)\n",
        "\n",
        "    return telefonos, correos, codigos_postales\n",
        "\n",
        "# Texto de ejemplo para verificar\n",
        "texto_ejemplo = \"\"\"\n",
        "Mi número de teléfono es 123-456-7890 y mi correo es ejemplo@gmail.com.\n",
        "Vivo en la calle 1234 y mi código postal es 12345.\n",
        "Puedes llamarme al 555-123-4567 o escribirme a otroejemplo@hotmail.com.\n",
        "\"\"\"\n",
        "\n",
        "# Verificar el texto de ejemplo\n",
        "telefonos, correos, codigos_postales = verificar_texto(texto_ejemplo)\n",
        "\n",
        "# Mostrar los resultados\n",
        "print(\"Números de teléfono encontrados:\", telefonos)\n",
        "print(\"Direcciones de correo electrónico encontradas:\", correos)\n",
        "print(\"Códigos postales encontrados:\", codigos_postales)"
      ],
      "metadata": {
        "id": "NRZ3Zb4sX8ym"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Búsqueda de patrones específicos en un texto\n",
        "\n",
        "Encontrar palabras clave, fechas, direcciones."
      ],
      "metadata": {
        "id": "ySHv_M1dXRqB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar la librería requerida\n",
        "import re\n",
        "\n",
        "def encontrar_informacion(texto):\n",
        "    \"\"\"Encuentra palabras clave, fechas y direcciones en un texto.\n",
        "\n",
        "    Args:\n",
        "        texto (str): El texto en el que se buscarán los patrones.\n",
        "\n",
        "    Returns:\n",
        "        tuple: Una tupla que contiene listas de palabras clave, fechas y\n",
        "        direcciones encontradas en el texto, respectivamente.\n",
        "    \"\"\"\n",
        "    # Patrón para buscar palabras clave (ejemplo: \"importante\", \"urgente\",\n",
        "    # \"importante\", etc.)\n",
        "    patron_palabra_clave = r'\\b(importante|urgente|crítico)\\b'\n",
        "\n",
        "    # Patrón para buscar fechas en formato dd/mm/yyyy\n",
        "    patron_fecha = r'\\b(\\d{1,2}/\\d{1,2}/\\d{4})\\b'\n",
        "\n",
        "    # Patrón para buscar direcciones (ejemplo: \"calle 123\", \"avenida principal\",\n",
        "    # \"plaza central\", etc.)\n",
        "    patron_direccion = r'\\b(calle|avenida|plaza)\\s[A-Za-z]+\\s\\d+\\b'\n",
        "\n",
        "    # Buscar palabras clave en el texto\n",
        "    palabras_clave = re.findall(patron_palabra_clave, texto)\n",
        "\n",
        "    # Buscar fechas en el texto\n",
        "    fechas = re.findall(patron_fecha, texto)\n",
        "\n",
        "    # Buscar direcciones en el texto\n",
        "    direcciones = re.findall(patron_direccion, texto)\n",
        "\n",
        "    return palabras_clave, fechas, direcciones\n",
        "\n",
        "# Texto de ejemplo para verificar\n",
        "texto_ejemplo = \"\"\"\n",
        "La reunión es muy importante y urgente. Se llevará a cabo el 15/02/2024 en la\n",
        "calle principal 123. No olvides traer el informe crítico. La dirección es\n",
        "avenida central 456. Nos vemos allí.\n",
        "\"\"\"\n",
        "\n",
        "# Encontrar información en el texto de ejemplo\n",
        "palabras_clave, fechas, direcciones = encontrar_informacion(texto_ejemplo)\n",
        "\n",
        "# Mostrar los resultados\n",
        "print(\"Palabras clave encontradas:\", palabras_clave)\n",
        "print(\"Fechas encontradas:\", fechas)\n",
        "print(\"Direcciones encontradas:\", direcciones)"
      ],
      "metadata": {
        "id": "q52y2ZKnX9-J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Filtrado y limpieza de datos en conjuntos de texto grandes"
      ],
      "metadata": {
        "id": "3sg9cF80XfHC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar la librería requerida\n",
        "import re\n",
        "\n",
        "def limpiar_texto(texto):\n",
        "    \"\"\"Filtra y limpia un texto eliminando caracteres no deseados y\n",
        "    palabras comunes.\n",
        "\n",
        "    Args:\n",
        "        texto (str): El texto que se va a limpiar.\n",
        "\n",
        "    Returns:\n",
        "        str: El texto limpio.\n",
        "    \"\"\"\n",
        "    # Convertir todo el texto a minúsculas\n",
        "    texto = texto.lower()\n",
        "\n",
        "    # Eliminar caracteres no alfabéticos excepto espacios\n",
        "    texto = re.sub(r'[^a-z\\s]', '', texto)\n",
        "\n",
        "    # Eliminar palabras comunes que no aportan significado\n",
        "    palabras_inutiles = {'el', 'la', 'los', 'las', 'un', 'una', 'unos', 'unas',\n",
        "                         'de', 'del', 'al', 'con', 'para', 'por', 'sobre',\n",
        "                         'entre', 'hacia'}\n",
        "\n",
        "    # Dividir el texto en palabras\n",
        "    palabras = texto.split()\n",
        "\n",
        "    # Crear una lista para almacenar las palabras filtradas\n",
        "    palabras_filtradas = []\n",
        "\n",
        "    # Filtrar palabras comunes\n",
        "    for palabra in palabras:\n",
        "        if palabra not in palabras_inutiles:\n",
        "          palabras_filtradas.append(palabra)\n",
        "\n",
        "    # Reconstruir el texto limpio\n",
        "    texto_limpio = ' '.join(palabras_filtradas)\n",
        "\n",
        "    return texto_limpio\n",
        "\n",
        "# Texto de ejemplo\n",
        "texto_ejemplo = \"\"\"\n",
        "En un lugar de la Mancha, de cuyo nombre no quiero acordarme, no ha mucho tiempo\n",
        " que vivía un hidalgo de los de lanza en astillero, adarga antigua, rocín flaco\n",
        "  y galgo corredor.\n",
        "\"\"\"\n",
        "\n",
        "# Limpiar el texto de ejemplo\n",
        "texto_limpio = limpiar_texto(texto_ejemplo)\n",
        "\n",
        "# Mostrar el texto limpio\n",
        "print(\"Texto limpio:\")\n",
        "print(texto_limpio)\n"
      ],
      "metadata": {
        "id": "Bp-XO5CoiGgp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Ejercicios"
      ],
      "metadata": {
        "id": "hfp66KZgVdSA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 00\n",
        "\n",
        "Validación de dirección de correo electrónico. Diseñar un programa que valide si una cadena ingresada por el usuario es una dirección de correo electrónico válida o no. La dirección de correo electrónico válida debe seguir el formato estándar de \"usuario@dominio.com\".\n",
        "\n",
        "   *Texto de referencia:* \"Por favor, envíe su solicitud a john.doe@example.com. Asegúrese de incluir su nombre completo y número de teléfono en el cuerpo del correo electrónico.\""
      ],
      "metadata": {
        "id": "4kpeP548VfWv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Resuelva en esta celda el ejercicio\n",
        "import re\n",
        "\n",
        "email_regex = r'[\\w\\.-]+@[\\w\\S-]+\\.[\\w\\S-]+'\n",
        "\n",
        "correo_ingresado = input(\"ingrese correo: \")\n",
        "\n",
        "matches = re.match(email_regex, correo_ingresado)\n",
        "\n",
        "if (matches):\n",
        "    print(\"¡El correo es válido!\")\n",
        "else:\n",
        "    print(\"El correo no es válido :((\")\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "n2v2uvLkZD0s",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8808195a-0758-4793-85ab-49f28c18c2d3"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ingrese correo: john.doe@example.com\n",
            "¡El correo es válido!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 01\n",
        "\n",
        "Extracción de números de teléfono. Escribir un programa que extraiga todos los números de teléfono válidos de un texto dado. Los números de teléfono válidos deben seguir el formato XXX-XXX-XXXX.\n",
        "\n",
        "   *Texto de referencia:* \"Puede comunicarse con nuestro servicio al cliente llamando al 555-123-4567. También puede enviar un mensaje de texto al número 555-987-6543 para obtener ayuda rápida.\"\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "AWpJFnkfZE8X"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Resuelva en esta celda el ejercicio\n",
        "\n",
        "phone_number_regex = r'\\d{3}-\\d{3}-\\d{4}'\n",
        "\n",
        "phone = input(\"Write phone number: \")\n",
        "\n",
        "valid_numbers = re.findall(phone_number_regex, phone)\n",
        "\n",
        "if(len(valid_numbers) == 0):\n",
        "    print(\"Not valid phone numbers\")\n",
        "else:\n",
        "    print(\"Valid phone numbers found:\")\n",
        "    print(valid_numbers)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "nEHnjFNraLvf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "db5608c3-4c3b-496d-ebec-4b8a7f6615ea"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Write phone number: Puede comunicarse con nuestro servicio al cliente llamando al 555-12-4567. También puede enviar un mensaje de texto al número 555-987-653 para obtener ayuda rápida.\n",
            "Not valid phone numbers\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 02\n",
        "\n",
        "Búsqueda de fechas. Desarrolle un programa que identifique y extraiga todas las fechas válidas en un texto dado. Las fechas válidas deben estar en formato \"DD/MM/AAAA\".\n",
        "\n",
        "   *Texto de referencia:* \"La reunión está programada para el 15/02/2024. Por favor, confirme su asistencia antes de esa fecha. Recuerde que el plazo para enviar el informe es el 28/02/2024.\""
      ],
      "metadata": {
        "id": "0hEyKcvlaM1p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Resuelva en esta celda el ejercicio\n",
        "\n",
        "date_regex = r'\\d{2}\\/\\d{2}\\/\\d{4}'\n",
        "\n",
        "date = input(\"Write dates: \")\n",
        "\n",
        "valid_dates = re.findall(date_regex, date)\n",
        "\n",
        "if(len(valid_dates) == 0):\n",
        "    print(\"Not valid dates found\")\n",
        "else:\n",
        "    print(\"Valid dates found:\")\n",
        "    print(valid_dates)\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "yN0MvrQ4ao7v",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c47dd457-ea11-44ff-bfb9-f83380aae625"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Write dates: La reunión está programada para el 15/02/2024. Por favor, confirme su asistencia antes de esa fecha. Recuerde que el plazo para enviar el informe es el 28/02/2024.\n",
            "Valid dates found:\n",
            "['15/02/2024', '28/02/2024']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 03\n",
        "\n",
        "Validación de contraseñas seguras. Cree un programa que valide si una contraseña ingresada por el usuario es segura o no. Una contraseña segura debe tener al menos ocho caracteres de longitud y contener al menos una letra mayúscula, una letra minúscula, un número y un carácter especial.\n",
        "\n",
        "   *Texto de referencia:* \"Su contraseña debe tener al menos 10 caracteres de longitud y contener al menos una letra mayúscula, una letra minúscula, un número y un carácter especial. Por favor, elija una contraseña segura.\""
      ],
      "metadata": {
        "id": "qj50yF_aP_yM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Resuelva en esta celda el ejercicio\n"
      ],
      "metadata": {
        "id": "YDbBS606QSxx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 04\n",
        "\n",
        "Extracción de URLs. Escriba un programa que extraiga todas las URLs válidas de un texto dado. Las URLs válidas deben comenzar con \"http://\" o \"https://\".\n",
        "\n",
        "   *Texto de referencia:* \"Visite nuestro sitio web en https://www.ejemplo.com para obtener más información sobre nuestros productos y servicios. También puede seguirnos en Twitter en https://twitter.com/ejemplo.\""
      ],
      "metadata": {
        "id": "4852xGV9QBaQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Resuelva en esta celda el ejercicio\n"
      ],
      "metadata": {
        "id": "xNrof7kmQUED"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 05\n",
        "\n",
        "Conteo de palabras. Diseñe un programa que cuente cuántas veces aparece una palabra específica en un texto dado. La búsqueda no debe diferenciar mayúsculas ni minúsculas. Es decir que «casa»\n",
        "y «Casa» deben ser consideradas la misma palabra.\n",
        "\n",
        "  *Texto de referencia:* \"La conferencia comenzará a las nueve de la mañana. Por favor, llegue temprano para registrarse. La duración de cada sesión será de una hora.\""
      ],
      "metadata": {
        "id": "ztj4sS1hQDtc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Resuelva en esta celda el ejercicio\n"
      ],
      "metadata": {
        "id": "jg0TczRIQVsk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 06\n",
        "\n",
        "Reemplazo de palabras. Cree un programa que reemplace todas las ocurrencias de una palabra específica por otra en un texto dado. El usuario debe ingresar la palabra a buscar y la palabra de reemplazo.\n",
        "\n",
        "   *Texto de referencia:* \"La comida vegetariana es una excelente opción para mantenerse saludable. Por favor, asegúrese de incluir una variedad de vegetales en su dieta diaria.\""
      ],
      "metadata": {
        "id": "hATd-LMUQGP_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Resuelva en esta celda el ejercicio\n"
      ],
      "metadata": {
        "id": "KWFwRqE7QX0H"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 07\n",
        "\n",
        "Validación de código postal. Desarrolle un programa que valide si un código postal ingresado por el usuario es válido o no. El código postal válido debe tener un formato específico, como \"XXXXX\" o \"XXXXX-XXXX\".\n",
        "\n",
        "   *Texto de referencia:* \"Nuestra dirección es 12345 Main Street, Anytown, USA. El código postal es 54321-6789. Asegúrese de incluir el código postal correcto al completar el formulario.\""
      ],
      "metadata": {
        "id": "ZNOMGOKfQHkc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Resuelva en esta celda el ejercicio\n"
      ],
      "metadata": {
        "id": "EFyBSu0OQZ5X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 08\n",
        "\n",
        "Extracción de direcciones IP. Escriba un programa que extraiga todas las direcciones IP válidas de un texto dado. Las direcciones IP válidas deben seguir el formato \"XXX.XXX.XXX.XXX\", donde cada parte puede tener uno, dos o tres dígitos.\n",
        "\n",
        "   *Texto de referencia:* \"La dirección IP de nuestro servidor es 192.168.1.1. Asegúrese de configurar correctamente la dirección IP en su dispositivo para accedera la red”"
      ],
      "metadata": {
        "id": "k1SR_Y-RQJC1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Resuelva en esta celda el ejercicio\n"
      ],
      "metadata": {
        "id": "1Wky-Hp7Qa1P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Ejercicio 09\n",
        "\n",
        "Búsqueda de hashtags. Diseñe un programa que identifique y extraiga todos los hashtags de un texto dado. Los hashtags deben comenzar con el símbolo \"#\" y pueden contener letras, números y guiones bajos.\n",
        "\n",
        "Texto de referencia: \"Únase a la conversación en las redes sociales utilizando el hashtag #ejemplo. Comparta sus experiencias y obtenga actualizaciones sobre nuestros últimos productos y promociones.\""
      ],
      "metadata": {
        "id": "VlxrpT47QKdX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Resuelva en esta celda el ejercicio\n"
      ],
      "metadata": {
        "id": "lwx5c9ecQeTD"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}