Skip to content

Instantly share code, notes, and snippets.

@harpiechoise

harpiechoise/Textos a profundidad.ipynb

Created June 1, 2019 04:18
Show Gist options
  • Star 2 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save harpiechoise/1ce67cc6589549932bf847c32933e35c to your computer and use it in GitHub Desktop.
Save harpiechoise/1ce67cc6589549932bf847c32933e35c to your computer and use it in GitHub Desktop.
Download ZIP
Display the source blob
Display the rendered blob
Raw
Textos a profundidad.ipynb
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1. Formateo de Strings\n",
"\n",
"Cuando programamos en cualquier lenguaje, lo que pocos saben manejar al 100%, es el formateo de cadenas, siendo que puedes darle formato a cualquier cadena de texto o variable de texto. Vamos con lo mas basico"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Mi nombre es: Jaime\n"
]
}
],
"source": [
"persona = \"Jaime\"\n",
"print('Mi nombre es: {}'.format(persona))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Este es el uso basico de la funcion de **strings** format, pero si tienes una version reciente python puedes hacer mas cosas con esta funcion, vamos a hechar un vistazo "
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Mi nombre es: Jaime\n"
]
}
],
"source": [
"print(f'Mi nombre es: {persona}')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Tambien podemos incluir un diccionario y acceder a sus datos"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Valor de a: 1, Valor de b: 2\n"
]
}
],
"source": [
"d = {'a': 1, 'b' : 2}\n",
"print(f\"Valor de a: {d['a']}, Valor de b: {d['b']}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Tambien podemos hacer lo mismo con listas"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Primer Elemento: Hola, Segundo elemento: Adios\n"
]
}
],
"source": [
"l = [\"Hola\", \"Adios\"]\n",
"print(f\"Primer Elemento: {l[0]}, Segundo elemento: {l[1]}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Tambien podemos hacerlo con tuplas"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[('Libro', 'Topico', 'Paginas'),\n",
" ('Algoritmos', 'Estructuras de datos', 600),\n",
" ('Machine Learning', 'IA', 800),\n",
" ('Python', 'Desarrollo', 900)]"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"libros = [('Libro', 'Topico', 'Paginas'), ('Algoritmos', 'Estructuras de datos', 600), ('Machine Learning', 'IA', 800), ('Python', 'Desarrollo', 900)]\n",
"libros"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Aqui tenemos una lista de tuplas las cuales vamos a formatear en diversas formas "
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Libro Topico Paginas\n",
"Algoritmos Estructuras de datos 600\n",
"Machine Learning IA 800\n",
"Python Desarrollo 900\n"
]
}
],
"source": [
"for libro, topico, paginas in libros:\n",
" print(f\"{libro} {topico} {paginas}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Aqui tenemos algo que se parece a una lista pero se ve muy mal formateada, pero gracias a las nuevas formas de formatear cadenas podemos mostrarla de una manera mas legible"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Libro Topico Paginas \n",
"Algoritmos Estructuras de datos 600\n",
"Machine Learning IA 800\n",
"Python Desarrollo 900\n"
]
}
],
"source": [
"for libro, topico, paginas in libros:\n",
" print(f\"{libro:{30}} {topico:{30}} {paginas:{10}}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Lo que python entiendes que le estas diciendo es: **Agrega la cantidad de espacios despues de los dos puntos** osea, tenemos **libro:{30}** que significa, la variable libro seguida de **30 espacios** pero auna asi la palabra Paginas queda rara, por la forma en que python trata de concatenar las cadenas con los numeros por eso se ve asi, pero por suerte hay muchas maneras de solucionarlo y veremos la mas simple"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Libro Topico Paginas\n",
"Algoritmos Estructuras de datos 600\n",
"Machine Learning IA 800\n",
"Python Desarrollo 900\n"
]
}
],
"source": [
"for libro, topico, paginas in libros:\n",
" print(f\"{libro:{30}} {topico:{30}} {paginas:>{10}}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Al poner el signo **\">\"** le estamos diciendo a python que alinie a la derecha el texto y ahora se ve mucho mejor nuestro print.\n",
"\n",
"Otra buena utilidad que tenemos en la funcion de formateo de Python son las fechas, podemos formatear fechas de forma sencilla, veamos como hacerlo a continuacion"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2019-05-31 00:00:00\n"
]
}
],
"source": [
"from datetime import datetime\n",
"hoy = datetime(year=2019, month=5, day=31)\n",
"print(f'{hoy}')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Asi mostrariamos una fecha cualquiera con format, pero la libreria datetime tiene muchas mas utilidades par mostrar fechas y formatearlas, por ejemplo"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"May 31, 2019\n"
]
}
],
"source": [
"print(f'{hoy:%B %d, %Y}')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Para mas formas de estas etiquetas ver la siguiente pagina.\n",
"\n",
"**<a href=\"http://strftime.org/\" style=\"color:green;\">Etiquetas de strftime</a>**\n",
"\n",
"Pero esto tampoco acaba aqui, ya que hay mucha mas informacion sobre la funcion de formateo de strings en python, pero ya te lo dejo a ti. Para saber mas visita esta pagina\n",
"\n",
"**<a href=\"https://docs.python.org/3/library/string.html#format-specification-mini-language\" style=\"color:green;\"> Formateo de cadenas en python </a>**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2. Archivos de Texto\n",
"\n",
"### 2.1 Archivos txt\n",
"\n",
"Aqui veremos como trabajar con archivos de texto en python. Empezaremos con el archivo de texto mas basico que sería el txt, escribiremos un archivo de texto de ejemplo"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting test.txt\n"
]
}
],
"source": [
"%%writefile test.txt\n",
"Hola, este es un archivo de texto basico.\n",
"Para hacer pruebas dentro de python"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Primero vamos a intentar abrir un archivo que no existe, para saber como manejar este error"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"ename": "FileNotFoundError",
"evalue": "[Errno 2] No such file or directory: 'noExiste.txt'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-12-39d4c4f7e595>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmyFile\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'noExiste.txt'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'noExiste.txt'"
]
}
],
"source": [
"myFile = open('noExiste.txt')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Si tienes esté error, significa que o escribiste mal el nombre del archivo, o la ubicacion del mismo, por eso asegurate que el interprete este situado en tu espacio de trabajo, ¿Y como se eso?, es simple, solo escribe **pwd** y veras donde esta ubicado el interprete"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'/home/harpie/NLP'"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pwd"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ahora procederemos a abrir el archivo de texto, y leer sus contenidos. "
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"myFile = open('test.txt')"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"<_io.TextIOWrapper name='test.txt' mode='r' encoding='UTF-8'>"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"myFile"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Si inspeccionamos el objeto **myFile** vemos que es un objeto de tipo **TextIOWrapper**, el nombre es **test.txt** y el modo por defecto de la funcion **open** es **r, que significa lectura**, es decir que no podemos escribir el archivo, solo leer sus contenidos, y el charset es **UTF-8**"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Hola, este es un archivo de texto basico.\\nPara hacer pruebas dentro de python\\n'"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"myFile.read()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La funcion read, nos devuelve los contenidos del archivo como una cadena de texto. \n",
"\n",
"Ahi un detalle que mortifica a los principiantes de python y es el siguiente."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"''"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"myFile.read()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**No se puede invocar a la funcion read 2 veces**, la explicacion de esto, es que cuando se lee un archivo, el **cursor** empieza en la posicion 0, y termina en la ultima posicion dependiendo de la cadena, entonces lo que resta es solo espacio en blanco, la forma de solucionar esto es reiniciar el cursor, de la siguiente manera "
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"myFile.seek(0)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"De esta manera podemos volver a leer el archivo"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
"contenido = myFile.read()"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hola, este es un archivo de texto basico.\n",
"Para hacer pruebas dentro de python\n",
"\n"
]
}
],
"source": [
"print(contenido)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Los **caracteres de escape** toman efecto cuando el contenido de imprime en pantalla con la funcion **print**, una vez que tenemos los contenidos del texto, necesitamos cerrar el archivo, porque si lo dejamos abierto, no podremos abrirlo hasta que matemos el proceso que esta accediendo a el"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [],
"source": [
"myFile.close()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Tambien tenemos mas funciones que podemos aplicar a los archivos, veremos la funcion readlines, veamosla"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['Hola, este es un archivo de texto basico.\\n', 'Para hacer pruebas dentro de python\\n']\n"
]
}
],
"source": [
"myFile = open('test.txt')\n",
"print(myFile.readlines())\n",
"myFile.close()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Como podemos ver aqui carga cada linea del archivo como un elemento de la lista, es como si aplicaramos la funcion **myFile.read().split('\\n')**.\n",
"\n",
"Ahora hablaremos un poco mas sobre los modos de como abrimos los archivos"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"myFile = open('test.txt', 'w+')\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"El modo **w+** nos permite leer y escribir en el archivo, es decir podemos hacer funciones de lectura y escritura por ejemplo"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"myFile.write('Texto Nuevo')\n",
"myFile.seek(0)"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [],
"source": [
"myFile.read()\n",
"myFile.close()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"No olvidemos que al escribir nuestro puntero de mismo modo termina en la ultima posicion por lo que tenemos que moverlo a la primera posicion para leer el contenido, pero la cosa no se queda aqui, tenemos muchas funciones mas para explorar que no cubrire para no extender este documento, pero puedes encontrarlas aqui\n",
"\n",
"**<a style=\"color:green;\" href=\"https://docs.python.org/3/library/functions.html#open\">Funcion Open</a>**\n",
"\n",
"**<a style=\"color:green;\" href=\"https://docs.python.org/3/library/io.html#io.TextIOBase\">TextIOBase</a>**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2.2 PDF\n",
"\n",
"Algo a recalcar es que no todos los archivos PDF son faciles de leer, dehecho, literalmente algunos se hacen a partir de imagenes, hay formas de extraer el texto en esos casos pero no son 100% fiables, una alternativa para extraer texto de un PDF a hecho con imagenes es **Tesserac OCR** aunque hay que recalcar que no es una forma fiable\n",
"\n",
"**<a href=\"https://github.com/tesseract-ocr/tesseract\" style='color:green;'> Tesseract OCR Repo </a>**\n",
"\n",
"Pero aqui trabajaremos con **PyPDF2** que es la forma de extraer informacion de un PDF hecho a base de texto, para eso usaremos el siguiente archivo\n",
"\n",
"**<a href=\"http://www.sld.cu/galerias/pdf/sitios/bmn/aprenda_a_buscar_en_google_1.pdf\" style=\"color:green;\"> PDF de ejemplo </a>**\n",
"\n",
"Para utilizar esta libreria debemos instalarla con el siguiente comando\n",
"\n",
"**pip install pyPDF2**\n",
"\n",
"vamos a ver como ocupar esta libreria"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [],
"source": [
"import PyPDF2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Primero tenemos que abrir un archivo como **BytesWrapper**, para no abrirlo como un archivo de texto, sino, un archivo de informacion binaria, para eso tenemos que abrir el archivo en modo **rb**"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [],
"source": [
"myFile = open('aprenda_a_buscar_en_google_1.pdf', 'rb')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Y se lo pasamos a **PyPDF2** de la siguiente forma"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"PdfReadWarning: Xref table not zero-indexed. ID numbers for objects will be corrected. [pdf.py:1736]\n"
]
}
],
"source": [
"pdf_reader = PyPDF2.PdfFileReader(myFile)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Vamos a **seleccionar la primera pagina** con el metodo **getPage**"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [],
"source": [
"pagina_uno = pdf_reader.getPage(0)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Y para Obtener el texto de la primera pagina debemos usar el metodo **extractText**"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [],
"source": [
"myText = pagina_uno.extractText()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Y como podemos ver aqui esta el texto de la primera pagina."
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"' Buscador GOOGLE http://manuales.ojobuscador.com/google/buscador/ fecha: 5.12.2006 · Aprender a Buscar en Google · Los Resultados de Google · Experto en Búsquedas en Google · Palabras Clave de Google · Búsquedas Concretas en Google Aprender a Buscar en Google Búsqueda básica Para ingresar una consulta en Google, simplemente tipee algunas palabras descriptivas y presione la tecla fiIntrofl (o haga clic en el botón de búsqueda en Google) para ver la lista de resultados relevantes. Google usa sofisticadas técnicas de búsqueda de texto que encuentran páginas que son importantes y relevantes para su búsqueda. Por ejemplo, cuando Google analiza una página, comprueba el contenido de las páginas vinculadas con esa página. Google también prefiere las páginas en las que los términos buscados están cerca unos de otros. Buscar: coches Consultas automáticas que incluyen fiandfl Google sólo le muestra aquellas páginas que incluyen todos los términos de la búsqueda. No es necesario incluir fiandfl entre sus términos. Para acotar la búsqueda un poco más, agregue más términos. Buscar: coches AND motos Buscar: coches motos Términos superfluos Google ignora las palabras y caracteres comunes, conocidos como términos superfluos. Google automáticamente descarta términos como fihttpfl y fi.com,fl, así como ciertos dígitos o letras, porque raramente estos términos ayudan a acotar la búsqueda y pueden demorarla en forma significativa. Use el signo fi+fl para incluir términos superfluos en su búsqueda. Asegúrese de incluir un espacio antes del signo fi+fl. Buscar: googlemania +com Buscar: googlemania com Búsquedas parciales Para proporcionarle los resultados más exactos, Google no usa fibúsquedas parcialesfl ni realiza búsquedas con ficomodinesfl. En otras palabras, Google busca exactamente los términos que ingresa en la casilla de búsqueda. Buscar fisalfl o fisal*fl no devolverá búsquedas que contengan fisalerofl o fisalamandrafl. Si tiene dudas, pruebe varias formas distintas: ficallefl y ficallesfl, por ejemplo. Buscar: calle Buscar: calle* ¿Importan los acentos y las mayúsculas? Las búsquedas Google no distinguen entre mayúsculas y minúsculas. Todas las letras, independientemente de como estén escritas, se consideran minúsculas. Buscar: google Buscar: GoOgLe Buscar: GOOGLE PDF created with pdfFactory Pro trial version www.pdffactory.com'"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"myFile.close()\n",
"myText"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Todavia se pueden hacer mas cosas con esta libreria, aqui te dejo su documentacion oficial**\n",
"\n",
"**<a href=\"https://pythonhosted.org/PyPDF2/\" style=\"color:green;\"> PyPDF2 Documentacion </a>**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Expresiones Regulares\n",
"\n",
"Ahora imaginemos que necesitas encontrar un numero de telefono en un texto, podriamos hacer esto"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\"+56 9 8888 8888\" in \"Cintia: +56 9 8888 8888\" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Entonces pudimos encontrar un numero de telefono dentro de una cadena, pero el problema es el siguiente, **¿Como encuentro el numero de telefono de alguien si yo no me se su numero?**, okay, si nos ponemos a pensar, sabemos de memoria el patron de un numero de telefono, el cual es, codigo de area seguido por un 9 en el caso de chile, y 8 digitos que tienen un espacio en el cuarto, aqui es donde entran en juego las **Expresiones Regulares**, entonces se que mi patron es el siguiente\n",
"\n",
"**+## # #### ####**\n",
"\n",
"donde los simbolos de gato son digitos, si nos vamos al siguiente link podremos encontrar la tabla de **expresiones regulares en python**, que nos servira para formar nuestro patron\n",
"\n",
"**<a href=\"https://www.rexegg.com/regex-quickstart.html\" style=\"color:green;\"> Tabla de expresiones regulares </a>**\n",
"\n",
"Entonces tenemos que para encontrar un digito nos sirve la expresion **\\d** entonces nuestro patron nos quedaria asi\n",
"\n",
"**+\\d\\d \\d \\d\\d\\d\\d \\d\\d\\d\\d**\n",
"\n",
"Pero aun no esta completo, porque segun nuestra tabla los espacios tambien cuentan como una expresion que es **\\s**\n",
"\n",
"**+\\d\\d\\s\\d\\s\\d\\d\\d\\d\\s\\d\\d\\d\\d**\n",
"\n",
"Entonces nuestra expresion quedaria algo asi, pero se ve mal, pero podemos arreglarla segun la documentacion podemos poner la cantidad de expresiones seguidas que estamos buscando de la siguiente manera **\\d{2}** (Dos numeros seguidos), por lo que quedaria asi\n",
"\n",
"**+\\d{2}\\s\\d\\s\\d{4}\\s\\d{4}**\n",
"\n",
"y como el caracter \"+\" significa uno o mas, debemos hacerle un \"escape\" anteponiendo en backslash \"\\\"\n",
"\n",
"**\\+\\d{2}\\s\\d\\s\\d{4}\\s\\d{4}**\n",
"\n",
"Por lo que ahora es mas legible ahora probemosla \n",
"\n",
"para indicarle a python que nuestra cadena es una expresion regular debemos anteponer una \"r\" \n",
"\n",
"**r\"cadena\"**\n",
"\n",
"y para usar las utilidades de expresiones regulares debemos importar el modulo **re**"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [],
"source": [
"import re\n",
"patron = r\"\\+\\d{2}\\s\\d\\s\\d{4}\\s\\d{4}\"\n",
"texto = \"Este es mi numero: +56 9 4444 4444\""
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"<re.Match object; span=(19, 34), match='+56 9 4444 4444'>"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"re.search(patron, texto)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Para devolver la cadena debemos usar el metodo group"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [],
"source": [
"texto = re.search(patron, texto).group()"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'+56 9 4444 4444'"
]
},
"execution_count": 36,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"texto"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ahora imaginemos que queremos encontrar el telefono y el RUN(Rol Unico Nacional) dentro de un texto en la misma expresion, el patron del RUN es el siguiente\n",
"\n",
"**##.###.###-@**\n",
"\n",
"donde los gatos son \\d entonces hagamos el patron y el @ arroba puede ser o letra o digito por lo que usare el wildcard character que seria el \".\", nuestra expresion quedaria asi\n",
"\n",
"**\\d{2}.\\d{3}.\\d{3}-.**\n",
"\n",
"entonces para buscar 2 elementos tenemos que usar el OR de las regex que es el caracter llamado \"pipe\" **|**\n",
"por lo que la expresion regular quedaria asi\n",
"\n",
"**\\d{2}\\.\\d{3}\\.\\d{3}-. | \\+\\d{2}\\s\\d\\s\\d{4}\\s\\d{4}**\n",
"\n",
"y para encontrar varias expresiones debemos usar el **FindAll**"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [],
"source": [
"texto = \"Este es mi numero: +56 9 4444 4444 y mi rut: 19.452.452-K\"\n",
"patron = r\"\\d{2}\\.\\d{3}\\.\\d{3}-.|\\+\\d{2}\\s\\d\\s\\d{4}\\s\\d{4}\""
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['+56 9 4444 4444', '19.452.452-K']"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"re.findall(patron, texto)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Y para ir cerrando este capitulo veremos las ultimas expresiones importantes.\n",
"\n",
"**$** significa \"Termina Con\" por ejemplo quiero econtrar un numero al final de una cadena "
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'2'"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"re.search(r\"\\d$\", \"Me gusta el numero: 2\").group()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"y la expresion ̣̣**^** significa \"empieza por\""
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'1'"
]
},
"execution_count": 40,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"re.search(r\"^\\d\", \"1 El numero mas solitario\").group()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Tambien los **braces** y el simbolo de elevado **^** significan exclusion por ejemplo para que me devuelva toda la frase menos el numero tendria que hacer la siguiente expresion regular."
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['M',\n",
" 'e',\n",
" ' ',\n",
" 'g',\n",
" 'u',\n",
" 's',\n",
" 't',\n",
" 'a',\n",
" ' ',\n",
" 'e',\n",
" 'l',\n",
" ' ',\n",
" 'n',\n",
" 'u',\n",
" 'm',\n",
" 'e',\n",
" 'r',\n",
" 'o',\n",
" ':',\n",
" ' ']"
]
},
"execution_count": 41,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"re.findall(r\"[^\\d]\", \"Me gusta el numero: 2\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Aqui me esta devolviendo todos los caracteres menos los numeros, si quiero juntarlos debo hacerlo agregando un \"+\" al final"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['Me gusta el numero: ']"
]
},
"execution_count": 42,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"re.findall(r\"[^\\d]+\", \"Me gusta el numero: 2\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Esto nos puede servir para remover los simbolos y puntuaciones"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['Es esto', ' una cadena', ' con muchos simbolos']"
]
},
"execution_count": 43,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"re.findall(r\"[^!.,?]+\", \"Es esto. una cadena!, con muchos simbolos?\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**r\"[^!.,?]+\"** esta expresion quiere decir que estoy removiendo los signos de exclamacion pundos comas y los signos de cierre de interrogacion.\n",
"\n",
"Tambien podemos buscar palabras de texto variable, osea la cantidad que sea de expresiones que sigan un patron, por ejemplo"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['ultimo-ejemplo', 'mostrare-aqui']"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"re.findall(r\"[\\w]+-[\\w]+\", \"Este es el ultimo-ejemplo que mostrare-aqui\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Como ultimo ejemplo vamos a extraer emails de un txt con expresiones regulares, para eso cree un txt lleno de mails, entonces voy a hacer un patron para encontrarlos, un mail tiene el siguiente patron\n",
"\n",
"jcrispis@gmail.com \n",
"\n",
"tenemos palabras a un lado, un arroba, palabras a otro seguido de un .com ahora intenta implementar tu un patron que sea capaz de encontrar estos mails\n",
"\n",
"**<a href=\"https://gist.github.com/retronym/f9419787089149ad3a59835c2e1ab81a\" style=\"color:green;\">mails.txt</a>**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Si lo lograste \n",
"\n",
"## Felicidades\n",
"\n",
"Si no, aqui te va la solucion, entonces dijimos que que para tomar cualquier palabras enteras y numeros usamos [\\w]+, entonces nuestra expresion quedaria así\n",
"\n",
"**[\\w]+@[\\w]+.com**\n",
"\n",
"Para expresar un punto lo debemos hacer con la expresion \\.\n",
"\n",
"**[\\w]+@[\\w]+\\.com**\n",
"\n",
"y la extension cumple con un texto entonces usamos [\\w]+\n",
"\n",
"**[\\w]+@[\\w]+\\.[\\w]+**\n",
"\n",
"probemos nuestra expresion"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [],
"source": [
"myFile = open('mails.txt', 'r')\n",
"content = myFile.read()"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['6b656e6a69@gmail.com',\n",
" 'ChristopherDavenport@outlook.com',\n",
" 'moors@typesafe.com',\n",
" 'adriaan@lightbend.com',\n",
" 'scott@gmail.com',\n",
" 'antoine@gourlay.fr',\n",
" 'cokasaki@gmail.com',\n",
" 'contact@pablofranciscoperez.info',\n",
" 'cvarming@twitter.com',\n",
" 'wijnand@gmail.com',\n",
" 'dbarclay@savi.com',\n",
" 'sakky@gmail.com',\n",
" 'a@47deg.com',\n",
" 'dima@lookout.com',\n",
" 'petrashko@gmail.com',\n",
" 'edmundnoble@gmail.com',\n",
" 'hao@optimizely.com',\n",
" 'ichoran@gmail.com',\n",
" 'jakob@odersky.com',\n",
" 'janekdb@gmail.com',\n",
" 'jzaugg@gmail.com',\n",
" 'rytz@gmail.com',\n",
" 'rytz@typesafe.com',\n",
" 'masgui@gmail.com',\n",
" 'pociecha@gmail.com',\n",
" 'miles@milessabin.com',\n",
" 'mitchellxb@gmail.com',\n",
" 'oscar@stripe.com',\n",
" 'nsp@cvogt.org',\n",
" 'paulkernfeld@gmail.com',\n",
" 'paulp@improving.org',\n",
" 'atry@gmail.com',\n",
" 'rjolly@users.sourceforge',\n",
" 'seth@tisue.net',\n",
" 'simon@ochsenreither.de',\n",
" 'sjrdoeraene@gmail.com',\n",
" 'snytt@gmail.com',\n",
" 'szeiger@novocode.com',\n",
" 'timothywspence@gmail.com',\n",
" 'ridge@googlemail.com',\n",
" 'glushak@gmail.com',\n",
" 'ureche@gmail.com',\n",
" 'tai@gmail.com']"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"re.findall('[\\w]+@[\\w]+\\.[\\w]+', content)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 4. Agradecimientos\n",
"Si llegaste hasta aqui, dejame agradecertelo, si quieres apoyar este proyecto comparte esta publicacion, hasta otro dia, adios"
]
},
{
"cell_type": "code",
"execution_count": null,
"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.7.2"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment