Tutorial 39 - Expresiones regulares.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "759010b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hay un mono\n"
     ]
    }
   ],
   "source": [
    "#Las expresiones regulares permiten localizar y modificar strings de forma muy poderosa\n",
    "#Trabajan casi exactamente de la misma manera en cada lenguaje de programacion\n",
    "\n",
    "#Las Expresiones Regulares (Regex) se usan para:\n",
    "#1. Buscar un string especifico en una gran cantidad de informacion\n",
    "#2. Verificar que un string tiene el formato correcto (Email, telefono)\n",
    "#3. Encontrar un string y reemplazarlo por otro\n",
    "#4. Formatear datos en el formato correcto para, por ejemplo, importar\n",
    "\n",
    "#importar el modulo Regex\n",
    "import re\n",
    "\n",
    "#------------ Encontrar una coincidencia -------------\n",
    "\n",
    "#Buscar un mono en el string\n",
    "if re.search(\"mono\", \"El mono estaba con los monos\"):\n",
    "    print(\"Hay un mono\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "cda59af6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mono \n",
      "monos\n"
     ]
    }
   ],
   "source": [
    "#------------ Encontrar todas las coincidencias -------------\n",
    "import re\n",
    "\n",
    "#findall() devuelve una lista de coincidencias\n",
    "# el . es usado para matchear cada 1 caracter o espacio \n",
    "\n",
    "todosLosMonos = re.findall(\"mono.\", \"El mono estaba con los monos\")\n",
    "for i in todosLosMonos:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ef16c35b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 8)\n",
      "mono \n",
      "(23, 28)\n",
      "monos\n"
     ]
    }
   ],
   "source": [
    "#finditer devuelve un iterador de los objetos coincidentes\n",
    "#se puede usar span para obtener la locacion\n",
    "\n",
    "elStr = \"El mono estaba con los monos\"\n",
    "\n",
    "for i in re.finditer(\"mono.\",elStr):\n",
    "    \n",
    "    #Span devuelve una tupla\n",
    "    locTupla = i.span()\n",
    "    \n",
    "    print(locTupla)\n",
    "    \n",
    "    #Segmentar la coincidencia con los valores de la tupla\n",
    "    print(elStr[locTupla[0]:locTupla[1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "624b4cb6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rat\n",
      "mat\n",
      "fat\n",
      "pat\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "#---------------- Coincidir una de varias letras -----------------\n",
    "\n",
    "#Los corchetes coincidirán cualquiera de los caracteres que contienen\n",
    "#sin incluir variaciones mayucuslas y minusculas\n",
    "#a no ser que esten listadas\n",
    "\n",
    "animalStr = \"Cat rat mat fat pat\"\n",
    "\n",
    "todosLosAnimales = re.findall(\"[crmfp]at\", animalStr)  #probar cambiando c por C\n",
    "for i in todosLosAnimales:\n",
    "    print(i)\n",
    "\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "9b773b9a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cat\n",
      "mat\n",
      "fat\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Tambien podemos buscar por caracteres en un rango\n",
    "#Incluir mayusculas y minusculas\n",
    "\n",
    "animalStr = \"Cat rat mat fat pat\"\n",
    "algunosAnimales = re.findall(\"[c-mC-M]at\", animalStr)\n",
    "\n",
    "#esto se lee asi: el rango 1 es de 'c' a 'm' y el rango 2 es de 'C' a 'M'\n",
    "#pat no esta incluido xq la 'p' queda afuera del rango\n",
    "\n",
    "for i in algunosAnimales:\n",
    "    print(i)\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "55a51a9d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mat\n",
      "fat\n",
      "pat\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Usar ^ para omitir caracteres entre corchetes\n",
    "\n",
    "animalStr = \"Cat rat mat fat pat\"\n",
    "algunosAnimales = re.findall(\"[^Cr]at\", animalStr) #omito los que comienzan con 'C' y 'r'\n",
    "\n",
    "for i in algunosAnimales:\n",
    "    print(i)\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d7701a5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "owl owl mat pat\n"
     ]
    }
   ],
   "source": [
    "#----------- Reemplazar todas las coincidencias ----------------\n",
    "\n",
    "#Reemplazar items coincidentes en un string\n",
    "\n",
    "import re\n",
    "\n",
    "owlComida = \"rat cat mat pat\"\n",
    "\n",
    "#Se puede compilar un regex en objetos de patrones, el cual provee metodos adicionales\n",
    "\n",
    "regex = re.compile(\"[cr]at\")\n",
    "\n",
    "#sub() reemplaza items que coinciden con el regex en el string con el string definido en el 1er atributo\n",
    "owlComida = regex.sub(\"owl\", owlComida)\n",
    "print(owlComida)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1397ec9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Encuentra \\algo:  None\n",
      "Encuentra \\algo:  <re.Match object; span=(8, 13), match='\\\\algo'>\n",
      "Encuentra \\algo:  <re.Match object; span=(8, 13), match='\\\\algo'>\n"
     ]
    }
   ],
   "source": [
    "#----------- Resolver problemas de barra invertida (\\\\) ----------------\n",
    "\n",
    "#Regex usa las barras invertidas para designar caracteres especiales\n",
    "#pero python hace lo mismo dentro de los strings, lo que puede causar problemas\n",
    "\n",
    "#Intentemos obtener \"\\\\algo\" del string\n",
    "import re\n",
    "randStr = \"Aca hay \\\\algo\"\n",
    "\n",
    "#Esto no lo encontraría:\n",
    "print(\"Encuentra \\\\algo: \",re.search(\"\\\\algo\", randStr))\n",
    "\n",
    "#Esto si, pero hay que ponerlo con 4 barras, lo cual es un desprolijo:\n",
    "print(\"Encuentra \\\\algo: \",re.search(\"\\\\\\\\algo\", randStr))\n",
    "\n",
    "#Se puede resolver usando raw strings, que no tratan a la barras como algo especial:\n",
    "print(\"Encuentra \\\\algo: \",re.search(r\"\\\\algo\", randStr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "89e3657d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coincidencias:  2\n",
      "Coincidencias:  ['F.B.I', 'I.R.S']\n",
      "Coincidencias:  ['F.B.I.', 'I.R.S.']\n"
     ]
    }
   ],
   "source": [
    "##----------- Coincidir cualquier caracter ------------------\n",
    "\n",
    "#Ya vimos que con . coincidimos cualquier caracter, pero qué si queremos coincidir un punto?\n",
    "#Usamos \\.\n",
    "#Se hace lo mismo con [, ] y otros\n",
    "\n",
    "import re\n",
    "\n",
    "randStr = \"F.B.I. I.R.S. CIA\"\n",
    "\n",
    "print(\"Coincidencias: \", len(re.findall(\".\\..\\..\", randStr)))  #Es decir que . = cualquier caracter, y\n",
    "print(\"Coincidencias: \", re.findall(\".\\..\\..\", randStr))       # \\. = puntos\n",
    "print(\"Coincidencias: \", re.findall(\".\\..\\..\\.\", randStr))     # Aca se imprimen con los 3 puntos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9bde79be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Este es un\n",
      "string muy largo que\n",
      "utiliza varias lineas\n",
      "Este es un string muy largo que utiliza varias lineas\n"
     ]
    }
   ],
   "source": [
    "##----------- Coincidir espacios en blanco ------------------\n",
    "import re\n",
    "\n",
    "randStr = \"\"\"Este es un\n",
    "string muy largo que\n",
    "utiliza varias lineas\"\"\"\n",
    "\n",
    "print(randStr)\n",
    "\n",
    "#Remover saltos de linea\n",
    "regex = re.compile(\"\\n\")\n",
    "\n",
    "randStr = regex.sub(\" \", randStr)\n",
    "print(randStr)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "079d3d44",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Tambien se puede coincidir:\n",
    "# \\b : backspace\n",
    "# \\f : Form Feed\n",
    "# \\r : Carriage Return\n",
    "# \\t : Tab\n",
    "# \\v : Vertical Tab\n",
    "\n",
    "#Quizas debas remover \\r\\n en Windows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e0adf0fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coincidencias:  5\n",
      "Coincidencias:  ['1', '2', '3', '4', '5']\n"
     ]
    }
   ],
   "source": [
    "##----------- Coincidir cualquier numero ------------------\n",
    "# \\d se puede usar en vez de [0-9]\n",
    "# \\D es lo mismo para [^0-9]\n",
    "\n",
    "import re\n",
    "\n",
    "randStr = \"123as4 5\"\n",
    "\n",
    "print(\"Coincidencias: \", len(re.findall(\"\\d\", randStr)))\n",
    "print(\"Coincidencias: \", re.findall(\"\\d\", randStr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5764acd5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Este es un codigo postal\n",
      "Coincidencias:  3\n",
      "Coincidencias:  ['12345', '123456', '1234567']\n"
     ]
    }
   ],
   "source": [
    "##----------- Coincidir multiples numeros ------------------\n",
    "# Se puede hacer poniendo despues de la \\d {numOfValues}\n",
    "\n",
    "import re\n",
    "\n",
    "#Coincidir solamente 5 numeros\n",
    "if re.search(\"\\d{5}\", \"12345\"):\n",
    "    print(\"Este es un codigo postal\")\n",
    "\n",
    "#Se puede coincidir dentro de un rango\n",
    "#Coincidir valores que esten entre 5 y 7 digitos\n",
    "\n",
    "numStr = \"123 12345 123456 1234567\"\n",
    "print(\"Coincidencias: \", len(re.findall(\"\\d{5,7}\", numStr)))\n",
    "print(\"Coincidencias: \", re.findall(\"\\d{5,7}\", numStr))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5bb580f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Es un telefono valido\n",
      "Es un nombre valido\n"
     ]
    }
   ],
   "source": [
    "##----------- Coincidir cualquier letra o numero ------------------\n",
    "# \\w es lo mismo que [a-zA-Z0-9]\n",
    "# \\W es lo mismo que [^a-zA-Z0-9_]\n",
    "\n",
    "import re\n",
    "\n",
    "numTel = \"412-555-1212\"\n",
    "nombre = \"Jorge\"\n",
    "\n",
    "#Chequear que sea un telefono valido\n",
    "if re.search(\"\\w{3}-\\w{3}-\\w{4}\", numTel):\n",
    "    print(\"Es un telefono valido\")\n",
    "\n",
    "#Chequear si el nombre es valido, entre 2 y 20 caracteres\n",
    "if re.search(\"\\w{2,20}\", nombre):\n",
    "    print(\"Es un nombre valido\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "752dc034",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El nombre es completo\n"
     ]
    }
   ],
   "source": [
    "##----------- Coincidir espacios en blanco ------------------\n",
    "# \\s es lo mismo que [\\f\\n\\r\\t\\v]\n",
    "# \\S es lo mismo que [^\\f\\n\\r\\t\\v]\n",
    "\n",
    "#Chequear que el nombre y apellido sean validos con un espacio en blanco que los separe\n",
    "\n",
    "import re\n",
    "nombreCompleto = \"Ernestina Arias\"\n",
    "\n",
    "if re.search(\"\\w{2,20}\\s\\w{2,20}\", nombreCompleto):\n",
    "    print(\"El nombre es completo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ef9a3b03",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coincidencias:  3\n",
      "Coincidencias:  ['a', 'a', 'a']\n"
     ]
    }
   ],
   "source": [
    "##----------- Coincidir uno o mas ------------------\n",
    "# '+' coincide uno o mas caracteres\n",
    "\n",
    "import re\n",
    "randStr = \"a alamo abrazo conejo\"\n",
    "\n",
    "#Coincidir 'a' seguida de uno o mas caracteres\n",
    "print(\"Coincidencias: \", len(re.findall(\"a+\", \"a as ape bug\")))\n",
    "print(\"Coincidencias: \", re.findall(\"a+\", \"a as ape bug\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "53d3523e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cantidad de emails correctos:  1\n",
      "Emails correctos:  ['db@aol.com']\n"
     ]
    }
   ],
   "source": [
    "##----------- Ejercicio ------------------\n",
    "#Crear un Regex que coincida direcciones de email de una lista\n",
    "# 1. 1 a 20 letras (minusculas y mayusculas), numeros, mas ._%+-\n",
    "# 2. Un simbolo @\n",
    "# 3. 2 a 20 letras (minusculas y mayusculas), numeros, mas .-\n",
    "# 4. Un punto\n",
    "# 5. 2 a 3 letras (minusculas y mayusculas)\n",
    "\n",
    "import re\n",
    "\n",
    "emailLista = \"db@aol.com m@.com @apple.com db@.com\"  #Solo la primera es valida\n",
    "\n",
    "print(\"Cantidad de emails correctos: \",len(re.findall(\"[\\w._%+-]{1,20}@[\\w.-]{2,20}.[\\w]{2,3}\",emailLista)))\n",
    "print(\"Emails correctos: \",re.findall(\"[\\w._%+-]{1,20}@[\\w.-]{2,20}.[\\w]{2,3}\",emailLista))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c15cd514",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}