analsis_basico_texto.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manejo de Texto\n",
    "\n",
    "> _Preparado por: [Juan Javier Santos Ochoa](https://twitter.com/jjsantoso) ([LNPP](https://www.lnpp.mx/))_\n",
    "\n",
    "En esta sesión aprenderemos a realizar manejo básico del texto y sacar información que pueda resultar útil.\n",
    "\n",
    "En Python una cadena de texto es un objeto denominado *str* o *string*. Un *string* se puede crear de diferentes formas:\n",
    "1. Colocando texto entre comillas dobles \": \n",
    "\n",
    "```python\n",
    "\"puedo usar 'comillas' simples adentro\"\n",
    "```\n",
    "2.  Colocando texto entre comillas simples ':\n",
    "```python\n",
    "'puedo usar \"comillas\" dobles adentro'\n",
    "```\n",
    "3. Usando comillas triples (tres comillas simples '''):\n",
    "```python\n",
    "'''Puedo escribir \n",
    "varias lineas \n",
    "de texto'''\n",
    "```\n",
    "4. usando el constructor str():\n",
    "```python\n",
    "str(2)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import re\n",
    "from sklearn.feature_extraction.text import strip_accents_ascii\n",
    "from string import punctuation\n",
    "from wordcloud import WordCloud\n",
    "from collections import Counter\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = [0, 2, 3]\n",
    "str(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operaciones con objetos string\n",
    "Con las cadenas de texto podemos usar las operaciones:\n",
    "* suma: $+$ \n",
    "* multiplicación: $*$ \n",
    "* Igual o diferente: $==$ o $!=$\n",
    "* \"mayor que\" o \"menor que\": $>$ o $<$\n",
    "* Además se puede usar los operadores **in** y **not in**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "h = \"hola\"\n",
    "m = 'mundo'\n",
    "# Suma\n",
    "print(\"la suma de los dos string es:\", h + m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiplicación\n",
    "print(\"Aquí asociamos y multiplicamos:\", (h + m + ' ') * 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Comparación lexicográfica. Para ver el orden usar ord(\"\")\n",
    "print(\"¿'hola' es mayor que 'mundo'?\", h > m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"¿'mundo' es mayor que 'hola'?\", m > h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Contenido en\n",
    "print(\"¿'mundo' contiene la letra t?\", 'mu' in m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Podemos extraer parte de un texto indexando con corchetes y la posición o un rango."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('la primera letra es:', h[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Las primeras 3 letras son:', h[0:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Las últimas 2 letras son:', h[-2:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* El texto es iterable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in m:\n",
    "    print(i*2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Para contar el número de carácteres puedo usar la función `len()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(m+h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Métodos de objetos *string*\n",
    "    \n",
    "Los métodos son funciones que se aplican sobre el objeto. Algunos de los métodos útiles para cadenas de texto son los siguientes:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mayúsculas y minúsculas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = \"Esta es una Cadena de Texto\"\n",
    "#\"Solo la primera letra en mayúscula:\"\n",
    "L.capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Todo en mayúscula\n",
    "L.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Todo en minúscula\n",
    "L.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# La primera letra de cada palabra en mayúscula:\n",
    "L.title()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### isalpha, isdigit, isalnum, isupper, islower\n",
    "Verifica si **todos** los caracteres de un texto son:\n",
    "* alfabéticos `.isalpha()`\n",
    "* numéricos `.isdigit()`\n",
    "* alfanuméricos `.isalnum()`\n",
    "* En mayúsculas `.isupper()`\n",
    "* En minúsculas `.islower()`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'salu2'.isalpha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'01002'.isdigit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'salu2!'.isalnum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'Hola'.isupper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'hola'.islower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### count\n",
    "Cuenta cuantas veces aparece un conjuto de caracteres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L.lower().count('es')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### replace\n",
    "\n",
    "Reemplaza un caracter por otro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L.replace('a', 'x').replace('o', 'e')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### split\n",
    "Construye una lista a partir de \"romper\" un texto. Cada elemento en que se rompe el texto se convierte en un elemento de la lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "L2 = 'Esta es una idea. Esta es otra. Estan separadas por puntos'\n",
    "R1 = L2.split('.')\n",
    "R1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L3 = '''Esta es una idea.\n",
    "Esta es otra. Estan separadas\n",
    "por puntos'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L3.split('\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### join\n",
    "\n",
    "Hace lo opuesto de `.split()`. Toma como argumento una lista y los une en un solo texto, usando un separador entre cada elemento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "R1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "';'.join(R1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'|'.join(['uno','dos','tres'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strip\n",
    "Remueve espacios en blanco (incluídos saltos de línea y tabulaciones) al princio o al final del texto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'    Hola mundo   \\n\\t\\t'.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Expresiones regulares\n",
    "\n",
    "Una expresion regular (regex) es un conjunto de caracteres que sigue una sintaxis determinada para encontrar coincidencias en cadenas de texto. Con las regex podemos recuperar un texto que se ajusta a ciertos patrones, por ejemplo, podemos buscar si hay nombres propios, fechas, cantidades de medida y otro tipo de información que usualmente siguen ciertas reglas gramaticales o de escritura.\n",
    "\n",
    "La sintaxis de las regex se siguen por ciertas reglas o expresiones que funcionan de manera más o menos igual en varios lenguajes de programación populares.\n",
    "\n",
    "La librería `re` tiene varios métodos, pero en este tutorial solo usaremos el método `re.findall` que nos regresa una lista con todas las coincidencias encontradas.\n",
    "\n",
    "Para usar la librería necesitamos suministrar un patrón y un texto.\n",
    "```{python}\n",
    "re.findall(patron,texto)\n",
    "```\n",
    "El patrón es un conjunto de caracteres con la sintaxis de expresiones regulares que indica los patrones que queremos extraer del texto. El patrón es sensible a mayúsculas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##ejemplo\n",
    "patron = r'[A-Z]'\n",
    "texto = 'Este es un texto de Prueba' \n",
    "re.findall(patron, texto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el ejemplo anterior, el patrón `[A-Z]` es una expresión regular para indicar que buscamos las letras de la A a la Z, en mayúsculas. En Python, añadimos la letra `r` para indicar que es un raw string y así evitar tener que poner un \\ antes de algunos caracteres especiales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "patron = r'e'\n",
    "re.findall(patron, texto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este ejemplo buscamos todas las apariciones de la letra `'e'`. Esta expresión solo nos regresará el caracter que buscamos por cada una de las veces que lo encontró en el texto, **es importante notar que no nos regresará la palabra de la cual proviene.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "patron = r'texto'\n",
    "texto = 'Este texto es un pretexto para hacer una prueba'\n",
    "re.findall(patron, texto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este ejemplo, al buscar los caracteres 'texto', nos devuelve cualquier coincidencia que encuentre, sin importar si los caracteres conforman toda una palabra o solo hacen parte de ella. **Más adelante veremos cómo acotar la búsqueda a palabras enteras**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clases de caracteres\n",
    "\n",
    "Hay varias clases de caracteres que usualmente nos interesan más, como por ejemplo, los caracteres **alfabéticos**, los **numéricos** o los **espacios en blanco**. En las expresiones regulares hay una forma de abreviar la búsqueda segun el tipo de caracter:\n",
    "\n",
    "* `\\w`  caracteres alfanuméricos, es decir, los caracteres a-z, A-Z, 0-9 y también los guiones bajos _\n",
    "* `\\d` caracteres numéricos, es decir 0-9\n",
    "* `\\s` espacio en blanco, incluyendo tabulaciones y saltos de linea\n",
    "* si colocamos la letra de la clase de caracter en mayúscula, entonces la regex busca el patrón contrario, es decir, \\W busca todos los carateres que no son alfanuméricos, \\D todos los que no son números y \\S todos los que no son espacios en blanco"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "patron = r'\\w' # Todos los caracteres alfanuméricos\n",
    "texto = 'jjsantos01@cide.edu'\n",
    "print(re.findall(patron, texto))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "patron = r'\\d\\d' # Todos los caracteres numéricos\n",
    "texto = 'jjsantos01@cide7.edu'\n",
    "print(re.findall(patron,texto))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "patron = r'\\D' # Todos los caracteres no numéricos\n",
    "texto = 'jjsantos01@cide.edu'\n",
    "print(re.findall(patron,texto))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operadores \"Codiciosos\"  (greedy match)\n",
    "\n",
    "Estos son operadores que se colocan junto a un caracter y también ayudan a definir la cantidad de caracteres que se desea buscar:\n",
    "* $+$ : encuentra caracteres similares al de la izquierda 1 o más veces\n",
    "* $*$ : encuentra caracteres similares al de la izquierda 0 o más veces\n",
    "* $?$ : encuentra caracteres similares al de la izquierda 0 o 1 vez\n",
    "\n",
    "Estos son muy útiles para encontrar derivaciones de alguna palabra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## SOLO BUSCA programa\n",
    "patron = r'programa'\n",
    "texto = 'Este programa esta programado en el presupuesto y se programara tambien el proximo año con los demas programas'\n",
    "re.findall(patron, texto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# todas las palabras que contienen programa y al menos un caracter alfanumerico\n",
    "patron = r'programa\\w+'\n",
    "texto = 'Este programa esta programado en el presupuesto y se programara tambien el proximo año con los demas programas'\n",
    "re.findall(patron,texto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# todas las palabras que contienen programa e incluye también las que tienen más caracteres\n",
    "patron = r'programa\\w*'\n",
    "texto = 'Este programa esta programado en el presupuesto y se programara tambien el proximo año con los demas programas'\n",
    "print(re.findall(patron,texto))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# todas las palabras que contienen programa e incluye también las que tienen maximo un caracter mas\n",
    "patron = r'programa\\w?'\n",
    "texto = 'Este programa esta programado en el presupuesto y se programara tambien el proximo año con los demas programas'\n",
    "print(re.findall(patron,texto))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Palabras\n",
    "Usamos la sequencia `\\b` para definir los límites iniciales o finales de una palabra:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "texto = 'Este texto es un pretexto para hacer una prueba con textos'\n",
    "patron = r'\\btextos?\\b'\n",
    "re.findall(patron, texto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "texto = 'Este programa esta programado en el presupuesto y se programara tambien el proximo año con los demas programas'\n",
    "patron = r'\\b\\w*programa\\w?\\b'\n",
    "print(re.findall(patron, texto))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Buscar varios patrones en una sola expresión\n",
    "\n",
    "Para buscar simultaneamente varios patrones usando una sola expresión regular podemos usar el operador `|` (barra vertical)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "texto = 'Este programa esta programado en el presupuesto y se programara tambien el proximo año con los demas programas'\n",
    "patron = r'\\bprograma\\b|pres\\w+|prox\\w+'\n",
    "re.findall(patron,texto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "texto = 'Este programa esta programado en el presupuesto y se programara tambien el proximo año con los demas programas'\n",
    "patron = r'(programa\\w*|pres\\w+|prox\\w+) (est\\w+|tamb\\w+)'\n",
    "re.findall(patron, texto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Procesamiento y exploración\n",
    "\n",
    "* Si tenemos archivos de texto simple (`.txt`) podemos abrirlos con `open()`, como cualquier archivo en Python y luego usar el método `.read()`\n",
    "* A continuación listamos algunos de los procedimientos de preprocesamiento y exploración básicos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('datos/pdf1.txt', 'r', encoding='utf8') as txtfile:\n",
    "    texto1 = txtfile.read()\n",
    "\n",
    "with open('datos/pdf2.txt', 'r', encoding='utf8') as txtfile:\n",
    "    texto2 = txtfile.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tokenizar\n",
    "* Tokenizar consiste en dividir el texto entero en componentes más pequeños. Cada componente se conoce como token. Lo más usual es tokenizar por palabras, aunque también es posible dividir un texto por oraciones, párrafos o incluso por caracteres."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Palabras\n",
    "* Para tokenizar por palabras solo basta con aplicar el método `.split()` a un objeto de texto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "texto1.split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Oraciones\n",
    "\n",
    "* Para tokenizar por oraciones aplicamos el método `.split('.')` a un objeto de texto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "texto1.split('.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Párrafos\n",
    "* Para tokenizar por párrafos aplicamos el método `.splitlines()` a un objeto de texto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "texto1.splitlines()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Limpiar texto\n",
    "\n",
    "* Antes de hacer cualquier anális tenemos que preprocesar el texto para homogeneizarlo y remover algunas palabras o caracteres que pueden ser irrelevantes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Minúsculas y remover acentos\n",
    "* Podemos usar el método `.lower()` para convertir todo a minúsculas.\n",
    "* sklearn tiene la función `strip_accents_ascii`, dentro del módulo `sklearn.feature_extraction.text`, para remover acentos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "strip_accents_ascii(texto1.lower())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stopwords\n",
    "\n",
    "* Las stopwords son palabras muy comunes que usualmente no aportan mucha información. Estas palabras suelen ser artículos o preposiciones.\n",
    "* En español podemos usar la lista de stopwords que viene en la librería [`nltk`](https://www.nltk.org/), dentro del módulo `stopwords`. La librería ya viene instalada en Anaconda.\n",
    "* Dependiendo de la aplicación, podemos agregar nuestras propias stopwords.\n",
    "* A continuación vamos a usar las stopwords de nltk que están guardadas en el archivo `datos/stopwords_spanol.csv` y creamos una función que las remueve de cualquier texto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stops = pd.read_csv('datos/stopwords_spanol.csv')['stopwords'].tolist()\n",
    "def remueve_stopwords(texto):\n",
    "    p = [t for t in texto.split() if t.lower() not in stops]\n",
    "    return ' '.join(p)\n",
    "\n",
    "remueve_stopwords(texto1)[0:1000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Remover puntuación y números\n",
    "\n",
    "* También puede ser útil remover signos de puntucación y números\n",
    "* Dentro de la librería `string` se encuentra la variable `punctuation` que contiene los principales signos de puntuación. En español debemos agregarle algunos signos de apertura (¡¿)\n",
    "* Usamos el método `re.sub()` de la librería `re`, ya que permite usar expresiones regulares para hacer múltiples reemplazos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def remueve_puntuacion(texto, remueve_numeros=True):\n",
    "    pat = '[!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~¡¿\\d]'\n",
    "    if not remueve_numeros:\n",
    "        pat = '[!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~¡¿]'\n",
    "    return re.sub(pat, '', texto)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "remueve_puntuacion(texto1)[0:1000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "remueve_puntuacion(texto2, remueve_numeros=False)[0:1000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extraer información\n",
    "\n",
    "* Ahora que tenemos algunas funciones para preprocesar el texto podemos usar las expresiones regulares para encontrar información de interés en el texto, como nombres propios, direcciones, números, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nombres propios\n",
    "\n",
    "* Los nombres propios se caracterizan por que son varias palabras seguidas en las que la primera letra es mayúscula, mientras las demás son minúsculas.\n",
    "* A continuación generamos un patrón para detectar nombres propios compuestos de al menos tres palabras."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "pat_nprop = r'(?:\\b[A-Z][a-z]+\\b\\s?){3,}'\n",
    "re.findall(pat_nprop, remueve_stopwords(strip_accents_ascii(texto1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "re.findall(pat_nprop, remueve_stopwords(strip_accents_ascii(texto2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Números\n",
    "\n",
    "* Podemos extraer patrones numéricos, como por ejemplo números de teléfono, número de folios o cantidades de dinero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Números de folio\n",
    "pat_fol = r'(folios?(?:\\,? \\d+)+)'\n",
    "re.findall(pat_fol, texto1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "# Dinero\n",
    "pat_din = r'\\$\\s?[\\d\\,\\.]+'\n",
    "re.findall(pat_din, texto2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "re.findall(pat_din, texto1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lugar\n",
    "\n",
    "* Podemos encontrar ubicaciones genéricas como calles, avenidas, colonias o estaciones del metro. También podemos intentar recuperar el nombre del lugar si está escrito como nombre propio o si tiene números."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pat_lugar = r'(?:[Cc]olonia|[Bb]oulevard|\\b[Cc]ol\\b\\.?|[Aa]venida|\\b[Aa]v\\b.?|\\b[Cc]alle\\w*|[Cc]alz\\w*|\\b[Ee]je\\b|\\b[Pp]laza|\\b[Mm]etro\\w*|[Zz]ona|[Jj]ardin\\w*|[Ee]stacion)\\s?(?:[A-Z][\\w\\.]* [A-Z][\\w\\.]* [A-Z][\\w\\.]*|[A-Z][\\w\\.]* [A-Z][\\w\\.]*|[A-Z][\\w\\.]*|\\d+|(?=.*))+'\n",
    "re.findall(pat_lugar, remueve_stopwords(texto2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "re.findall(pat_lugar, texto1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fecha\n",
    "\n",
    "* Las fechas suelen tener patrones muy particulares, como dd/mm/yyyy o yyyy-mm-dd, por lo que suele ser fácil captarlas en un texto.\n",
    "* A continuación usamos un patrón que captura fechas de la forma `\"{dia} de {mes} del {año}\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pat_fecha = r'(\\d{1,2} de (?:enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre) del? \\d{4})'\n",
    "re.findall(pat_fecha, texto1, re.I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "re.findall(pat_fecha, texto2, re.I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Leyes, artículos, fracciones\n",
    "\n",
    "* Podemos encontrar referencias a legislaciones anteponiendo las palabras ley, código, estatuto, etc y esperando que el nombre de la norma esté escrito como nombre propio.\n",
    "* También podemos buscar Títulos, Artículos o Fracciones de las leyes.\n",
    "* Remover las stopwords ayuda mucho."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ley\n",
    "pat_art = r'(?:Ley|Codigo|Estatuto)(?:\\s\\b[A-Z]\\w+\\b)+'\n",
    "re.findall(pat_art, remueve_stopwords(texto1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "re.findall(pat_art, remueve_stopwords(texto2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Articulos\n",
    "pat_art = r'articulos?(?:\\,?\\s?\\d+°?)+'\n",
    "re.findall(pat_art, remueve_stopwords(texto2), re.I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fracciones\n",
    "pat_fracc = r'fracci\\w+(?:\\,?\\s?[IVX]+)+'\n",
    "re.findall(pat_fracc, remueve_stopwords(texto1), re.I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Palabras más comunes\n",
    "\n",
    "\n",
    "* Para conocer las palabras más populares usamos la función `Counter` dentro de la librería nativa `collections`. Los objetos tipo `Counter` reciben como input una lista de elementos, en este caso palabras y tienen el método `.most_common()` para mostrar los elementos más comunes.\n",
    "* Antes de buscar las palabras más comunes, preprocesamos el texto para evitar palabras no relevantes se filtren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text1_prep = remueve_stopwords(remueve_puntuacion(strip_accents_ascii(texto1[0:7500].lower())))\n",
    "conteo = Counter(text1_prep.split())\n",
    "conteo.most_common(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text2_prep = remueve_stopwords(remueve_puntuacion(strip_accents_ascii(texto2.lower())))\n",
    "conteo = Counter(text2_prep.split())\n",
    "conteo.most_common(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## WordClouds\n",
    "\n",
    "* Las _wordclouds_ o nubes de palabras, son gráficos que muestran los términos más frecuentes de un texto.\n",
    "* Para hacer wordclouds instalamos la librería `wordcloud`\n",
    "```\n",
    "pip install wordcloud\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wordcloud = WordCloud(max_font_size=50, max_words=100, collocations=False, background_color=\"white\")\n",
    "wordcloud.generate(text1_prep)\n",
    "plt.imshow(wordcloud, interpolation='bilinear')\n",
    "plt.axis(\"off\")\n",
    "plt.show()\n",
    "# Guardamos\n",
    "wordcloud.to_file(\"imagenes/texto1.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "wordcloud = WordCloud(max_font_size=50, max_words=100, collocations=False, background_color=\"white\")\n",
    "wordcloud.generate(text2_prep)\n",
    "plt.imshow(wordcloud, interpolation='bilinear')\n",
    "plt.axis(\"off\")\n",
    "plt.show()\n",
    "# Guardamos\n",
    "wordcloud.to_file(\"imagenes/texto2.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí pueden encontrar un [tutorial sobre wordcloud](https://www.datacamp.com/community/tutorials/wordcloud-python)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # Métodos de string en un DataFrame de Pandas\n",
    " * Cuando tenemos muchos textos que pertenecen a una colección de documentos puede ser mejor guardarlos en un archivo de datos tabulares, como excel, csv o SQL.\n",
    " * La ventaja es que podemos hacer el procesamiento utilizando funciones vectorizadas, que son más eficientes que si aplicamos los mismos procedimientos a cada texto de forma individual.\n",
    " * Podemos leer el conjunto de textos usando la librería [Pandas](https://pandas.pydata.org/) que tiene muchas funciones de utilidad para el procesamiento de datos.\n",
    " * Las variables que son de tipo string en un `DataFrame` tienen un conjunto de métodos especiales para este tipo de datos. A estos métodos se acceden escribiendo `.str` después de una `Serie`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "pd.options.display.max_colwidth=300 # opción para poder ver hasta 300 caracteres en Jupyter\n",
    "plt.style.use('ggplot')\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Leemos los datos\n",
    "debates = pd.read_excel('datos/debates_presidenciales_2018.xlsx')\n",
    "debates.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "debates['nombre_corto'].unique()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reemplazar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "## Reemplazar, se puede usar una regex\n",
    "debates['nombre_corto'] = debates['nombre_corto'].str.replace('López Obrador', 'AMLO')\n",
    "debates['nombre_corto'].unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "debates['dialogo'].str.replace('Andrés Manuel López Obrador|Andres Manuel', 'AMLO').head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# En la base de datos hay un error, algunos presentadores fueron tratados como candidatos\n",
    "debates.query('rol==\"Candidato\"')['nombre_corto'].unique()\n",
    "## Corregiremos el rol para los presentadores\n",
    "presentadores = ['Warketin','Puig', 'Curzio']\n",
    "debates.loc[debates['nombre_corto'].isin(presentadores), 'rol'] = 'Moderador'\n",
    "debates.loc[debates['nombre_corto']=='Voz en off', 'rol'] = 'Voz en off'\n",
    "debates.query('rol==\"Candidato\"')['nombre_corto'].unique()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Número de caracteres\n",
    "\n",
    "Usamos el método `.str.len()` de las series."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "debates['N_caracteres'] = debates['dialogo'].str.len()\n",
    "debates.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Número de palabras\n",
    "\n",
    "Usamos el método `.str.count()`, que funciona con expresiones regulares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "debates['N_palabras'] = debates['dialogo'].str.count('\\w+')\n",
    "debates.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "debates_npalabras = debates.query('rol==\"Candidato\"')\\\n",
    "            .groupby(['nombre_corto','num_debate'])\\\n",
    "            .sum()[['N_palabras','N_caracteres']]\n",
    "\n",
    "debates_npalabras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Usamos el método `.groupby()` para agrupar los datos a partir de una o más variables, y luego aplicamos el método `.sum()` para sumar el `DataFrame` agrupado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "debates_npalabras['N_palabras'].unstack('num_debate')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "## Grafica de número de palabras de cada candidato, desagregadas por número de debate\n",
    "ax = debates_npalabras['N_palabras'].unstack('num_debate').plot.bar()\n",
    "ax.legend(loc=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "## Grafica de número de palabras de cada candidato, desagregadas por número de debate\n",
    "ax = debates_npalabras['N_palabras'].unstack('num_debate')\\\n",
    "    .plot.pie(subplots=True, legend=False, figsize=(12, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Contar ocurrencia de palabras\n",
    "\n",
    "Usamos el método `.str.count()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Contar cuántas veces se mencionaron a los candidatos en el diálogo\n",
    "debates['mencion_meade'] = debates['dialogo'].str.count('José Antonio Meade|Jose Antonio|Meade|José')\n",
    "debates['mencion_anaya'] = debates['dialogo'].str.count('Ricardo Anaya|Ricardo|Anaya')\n",
    "debates['mencion_amlo'] = debates['dialogo'].str.count('Andrés Manuel López Obrador|Andrés Manuel|López Obrador|Andres|AMLO')\n",
    "debates['mencion_bronco'] = debates['dialogo'].str.count('Jaime Rodríguez Calderon|Jaime Rodríguez|Jaime|Bronco')\n",
    "debates['mencion_zavala'] = debates['dialogo'].str.count('Margarita Zavala|Margarita|Zavala')\n",
    "debates.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Suma total de menciones\n",
    "debates.filter(regex='num_|N_|mencion_').groupby('num_debate').sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> El método `.filter()` sirve para filtrar las columnas usando expresiones regulares."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "## Grafica de Suma de menciones, desagregadas por número de debate\n",
    "ax = debates.groupby('num_debate').sum().filter(like='mencion_')\\\n",
    "    .plot(kind='bar')\n",
    "ax.get_legend().set_bbox_to_anchor((0.5, -0.1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "## Grafica de Suma de menciones, desagregadas por nombre_corto de candidato\n",
    "debates.query('rol==\"Candidato\"')\\\n",
    "    .groupby('nombre_corto')\\\n",
    "    .sum()\\\n",
    "    .filter(like='mencion_')\\\n",
    "    .plot(kind='bar')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contiene\n",
    "\n",
    "Usamos el método `.str.contains()` para identificar si una serie contiene una serie de caracteres. Se usan expresiones regulares y retorna una serie de booleanos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "debates['dialogo'].str.contains('balazos|canallín|suerte')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "debates.loc[debates['dialogo'].str.contains('balazos|canallín|suerte'), ['nombre_corto', 'dialogo']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Subconjunto\n",
    "\n",
    "Para seleccionar un subconjunto de caracteres basados en la posición usamos el método `.str[]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Obtenemos los primeros 10 caracteres de cada diálogo\n",
    "debates['dialogo'].str[0:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encontrar caracteres/palabras\n",
    "\n",
    "Con el método `.str.findall()` podemos buscar una expresión regular en el texto y nos retorna una serie con una lista para cada fila con las coincidencias encontradas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Todos los números\n",
    "debates['dialogo'].str.findall('\\d+')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Todos los números, incluyendo la palabra anterior y posterior, si la hay\n",
    "debates['dialogo'].str.findall('\\w+\\s\\w+\\s\\d+\\s?\\w*')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## split\n",
    "\n",
    "El método `str.split()` sirve para separar el texto según un caracter separador. El resultado es una lista con los elementos separados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "debates['dialogo'].str.split('.')#.str.len()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando el resultado de una operación es una serie que contiene listas, se puede acceder al resultado de cada lista usando `str[]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "debates['dialogo'].str.split('.').str[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'hola. mundo.'.split('.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Otras funciones str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "debates['dialogo'].head().str.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "debates['dialogo'].head().str.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "debates['dialogo'].head().str.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Apply\n",
    "\n",
    "El método `.apply()` es un método que permite aplicar una función a cada uno de los elementos de una serie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "debates['dialogo'].apply(strip_accents_ascii)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Número de caracteres únicos en cada diálogo\n",
    "debates['dialogo'].apply(lambda x: len(set(x)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## sumar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Colapsamos todo el texto en una sola variable. Cada oración\n",
    "texto_debate = debates['dialogo'].add('\\n').sum()\n",
    "print(texto_debate[0:1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wordcloud = WordCloud(max_font_size=50, max_words=100, collocations=False, background_color=\"white\")\n",
    "wordcloud.generate(remueve_stopwords(texto_debate))\n",
    "plt.imshow(wordcloud, interpolation='bilinear')\n",
    "plt.axis(\"off\")\n",
    "plt.show()\n",
    "# Guardamos\n",
    "wordcloud.to_file(\"imagenes/debate.png\")"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernel_info": {
   "name": "python3"
  },
  "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.6.4"
  },
  "nteract": {
   "version": "0.15.0"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}