module_4/4_02.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4.2. Adquisición y guardado de datos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Formatos disponibles para lectura y escritura\n",
    "- Múltiples formas de importar y exportar datos en pandas:\n",
    "<center>\n",
    "<img src=\"imgs/data_1.png\"  alt=\"drawing\" width=\"600\"/>\n",
    "<br/>\n",
    "<img src=\"imgs/data_2.png\"  alt=\"drawing\" width=\"600\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ficheros de tipo texto.\n",
    "\n",
    "- Probablemente, una de las formas más recurrentes de trabajo para el análisis de datos\n",
    "- La librería pandas, nos ofrece funciones para trabajar con ficheros en múltiples formatos.\n",
    "\n",
    "### Lectura de ficheros en formato texto.\n",
    "- Para la lectura usamos la función <b>read_csv</b>.\n",
    "- Los parámetros más importantes/comunes de esta función son los siguientes:<br/>\n",
    "\n",
    "|Función|Descripcción|\n",
    "|----|---|\n",
    "|`path`| Ruta del fichero del que se va a realizar la lectura.|\n",
    "|`sep`| Carácter(es) que se utilizan como separador de campos en el fichero.|\n",
    "|`header`| Índice de la fila que contiene los nombres de las columnas (None en caso de no haber).|\n",
    "|`index_col`| Índice de la columna o secuencia de índices que se deben usar como índice de filas de los datos.|\n",
    "|`names`| Secuencia que contiene los nombres de las columnas (usado junto con header=None).|\n",
    "|`skiprows`| Número de filas o secuencia de índices de fila que se deben ignorar en la carga.|\n",
    "|`na_values`| Secuencia de valores que, de encontrarse en el fichero, deben ser tratados como NaN.|\n",
    "|`dtype`| Diccionario en el que las claves serán nombres de columnas y los valores serán tipos de NumPy a los que se debe convertir su contenido.|\n",
    "|`parse_dates`| IMPORTANTE: Flag que indica si Python debe intentar parsear datos con formato semejante a las fechas como fechas. Puede ser un listado de nombres de columnas para el parseo como fecha.|\n",
    "|`keep_date_col`| Si se unen columnas para parsear como fecha, indica si se deben eliminar del DataFrame resultante las columnas originales.|\n",
    "|`converters`| Diccionario en el que las claves serán nombres de columnas y los valores funciones que se deberán aplicar al contenido de dichas columnas durante la carga.|\n",
    "|`dayfirst`| Indica si al parsear fechas se debe esperar el día primero o el mes. |\n",
    "|`date_parser`| Función a utilizar para tratar de parsear fechas.|\n",
    "|`nrows`| Número de filas a leer desde el principio del fichero.|\n",
    "|`chunksize`| IMPORTANTE: Cuando tenemos un fichero muy grande, no hay porqué leerlo entero. Tamaño a utilizar para la lectura incremental del fichero.|\n",
    "|`skip_footer`| Número de filas a ignorar del final del fichero.|\n",
    "|`enconding`| Codificación a esperar del fichero leído.|\n",
    "|`squeeze`| Flag que indica que si los datos leídos sólo contienen una columna el resultado sea una Serie en lugar de un DataFrame.|\n",
    "|`thousands`| Carácter a utilizar para detectar el separador de miles.|\n",
    "|`decimal`| Carácter a utilizar para detectar el separador de decimales.|\n",
    "|`skip_blank_lines`| Flag que indica si se deben ignorar las líneas en blanco.|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Leemos un fichero con read_csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "df = pd.read_csv('test_data/ex1.csv', header=0)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si el fichero no tiene encabezado, tenemos que poner header = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.read_csv('test_data/ex2.csv', header=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos especificar nosotros los nombres de las columnas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "pd.read_csv('test_data/ex2.csv', names=['a', 'b', 'c', 'd', 'message'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos especificar qué columna queremos que sea el índice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "names = ['a', 'b', 'c', 'd', 'message']\n",
    "pd.read_csv('test_data/ex2.csv', \n",
    "            names=names, \n",
    "            index_col='message')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- ex3.txt tiene un separador extraño \n",
    "- Podemos especificar el separador, para poder lerr el fichero correctamente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "result = pd.read_csv('test_data/ex3.txt', sep='\\s+')\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El ejemplo 4 tiene varios comentarios\n",
    "\n",
    "Por lo que querremos obviarlos a la hora de leer el fichero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.read_csv('test_data/ex4.csv', skiprows=[0, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el ejemplo 5 tenemos un fichero con NAs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "result = pd.read_csv('test_data/ex5.csv')\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podríamos especificar qué valor hay en el fichero que equivale a NA\n",
    "\n",
    "Por ejemplo, el Banco de España usa un _ para los NA\n",
    "\n",
    "Podríamos decir que, al cargar los datos, esos valores los convirtiera a NAs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "result = pd.read_csv('test_data/ex5.csv', na_values=['NULL'])\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos especificar, para cada columna, qué valores equivaldrían a NAs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "sentinels = {\n",
    "    'message': ['foo', 'NA'], # Si en la columna message, aparece foo, o NA, lo convertirá a NA\n",
    "    'something': ['two'] # Si en la columna something aparece two, lo convertirá a NA\n",
    "}\n",
    "pd.read_csv('test_data/ex5.csv', na_values=sentinels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true
   },
   "source": [
    "### Lectura de ficheros grandes por tramos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imaginemos que tenemos un fichero muy grande, que no podemos cargar en memoria (o que no queremos)\n",
    "\n",
    "Podríamos leer el fichero por tramos\n",
    "\n",
    "En este caso, leemos las últimas líneas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "result = pd.read_csv('test_data/ex6.csv')\n",
    "result.tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podríamos indicar cuantas líneas queremos que lea, desde el principio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "pd.read_csv('test_data/ex6.csv', nrows=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos usar chunksize para indicar: \"quiero que me leas, cada 1000 registros\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "chunker = pd.read_csv('test_data/ex6.csv', chunksize=1000)\n",
    "chunker"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como véis, no nos devuelve el trozo leído.\n",
    "\n",
    "Para leer el fichero, usamos un bucle for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "chunker = pd.read_csv('test_data/ex6.csv', chunksize=1000)\n",
    "for piece in chunker:\n",
    "    print(piece.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true
   },
   "source": [
    "### Escritura de ficheros en formato texto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Para escribir datos en forma de texto usamos la función <b>to_csv</b>. \n",
    "- Por defecto, el fichero seleccionado será sobreescrito.\n",
    "- Los parámetros más comunes de esta función son:<br/>\n",
    "\n",
    "|Función|Descripcción|\n",
    "|----|---|\n",
    "|`path`| Ruta del fichero que se utilizará para la escritura.|\n",
    "|`sep`| Carácter utilizado como separador de campos.|\n",
    "|`na_rep`| Cadena que se deberá utilizar para darle representación a los valores NaN.|\n",
    "|`float_format`| Indicador de formato para los números en coma flotante.|\n",
    "|`columns`| Secuencia de selección del conjunto de columnas que se desea volcar al fichero.|\n",
    "|`header`| Flag o secuencia de cadenas que indica si se debe volcar la cabecera al fichero.|\n",
    "|`index`| Flag que indica si el índice debe ser incluido o no como una columna más en el fichero.|\n",
    "|`index_label`| Nombre que se le debe dar a la columna de índice en el fichero.|\n",
    "|`mode`| Modo de apertura del fichero. Por defecto, \"w\".|\n",
    "|`encoding`| Codificación a utilizar en la escritura del fichero.|\n",
    "|`line_terminator`| Carácter(es) a utilizar para indicar una final de registr|\n",
    "|`date_format`| Indicador de formato a utilizar para escribir fechas.|\n",
    "|`decimal`| Carácter a utilizar como separador de decimales|\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Leemos un fichero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "data = pd.read_csv('test_data/ex5.csv')\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sobreescribimos el fichero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "data.to_csv('out.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si ponemos la barra vertical como separador, lo guardará como indicamos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "data.to_csv('out.csv', sep='|')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos que los Nan los guarde como Null, podemos especificarlo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "data.to_csv('out.csv', na_rep='NULL')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos indicar si queremos que guarde los índices de filas y columnas, o no."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "data.to_csv('out.csv', index=False, header=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No guardamos el índice de filas, pero sí el índice de columnas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "data.to_csv('out.csv', index=False, columns=['a', 'b', 'c'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Trabajo con otros formatos\n",
    "### Lectura de Ficheros Excel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos crear un fichero, que es un objeto que tiene cada hoja del excel y recuperamos del objeto, la hoja 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "xlsx = pd.ExcelFile('test_data/ex1.xlsx')\n",
    "frame = pd.read_excel(xlsx, 'Sheet1')\n",
    "frame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O podemos leer una hoja en concreto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame = pd.read_excel('test_data/ex1.xlsx', 'Sheet1')\n",
    "frame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A la hora de guardar, podmos guardar una hoja en concreto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "writer = pd.ExcelWriter('test_data/ex2.xlsx')\n",
    "frame.to_excel(writer, 'Sheet1')\n",
    "writer.save()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O guardar el excel completo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "frame.to_excel('test_data/ex2.xlsx')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "# Ejercicios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4.2.1.** Lee los datos del fichero train.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4.2.2.** Iguala las filas 3 a 20 y columnas 6 a 10 a cero. Escribe el fichero en train_mod.csv."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4.2.3.** Realiza las siguientes tareas:\n",
    "\n",
    "- Carga los csvs de datos ibex_div, ibex, NTGY, REE, SAN \n",
    "- Une todos los datos en un único Dataframe\n",
    "- Grafica el DF: las diferencias de escala no nos permiten ver bien el gráfico\n",
    "- Haz que todas las series empiecen en el mismo punto, dividiendo cada valor de las columnas, por el valor que tienen en la 1ª fila"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}