Paquete_DataFrames.ipynb

{
    "cells": [
    {
 	    "cell_type": "markdown", 
 	    "source": [ 
 		"# Paquete DataFrames" 
 	    ], 
 	    "metadata": {} 
	},
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "## DataFrames.jl\n",
                "Es un paquete que nos permite explorar información tabulándola. Este paquete es alternativo y equivalente al famoso paquete 'Pandas' de Python.\n",
                "\n",
                "Como el nombre del paquete lo indica, la información se maneja en una estructuta de datos llamada 'dataframe', el cual es similar a una tabla u hoja de cálculo (como la de Excel). Por lo tanto, el paquete nos permite explorar un dataset, transformarlo y almacenar la información.\n",
                "\n",
                "Junto a [`DataFrames`](https://dataframes.juliadata.org/v0.17/##DataFrames.jl-1) se puede utilizar el paquete [`Queryverse`](https://www.queryverse.org/), el cual permite tener a mano diferentes herramientas útiles para: trabajar con archivos, manipular datos y explorarlos; por tanto, permite tener mayor eficiencia.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "using Pkg; Pkg.activate(\".\"); Pkg.instantiate() ##Activando enviroment local\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 453
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Los paquetes `DataFrames` y `Queryverse` pueden ser añadidos a Julia y luego ser cargados de la forma usual. Se utilizará el paquete Plots, para realizar algunas gráficas y de esta forma visualizar datos.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "using Plots, Queryverse, DataFrames ##Importando librerías\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 454
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Cargando archivos\n",
                "En Julia existen diversos paquetes que permiten cargar archivos, como el paquete `CSV`. Sin embargo, el paquete `Queryverse` permite usar la función `load`, que permite leer no solo archivos $^*$.csv sino también archivos: $^*$.xls, $^*$.xlsx, $^*$.dta, $^*$.sav, entre otros.\n",
                "\n",
                "Ahora cargaremos el dataset que se estará utilizando para mostrar las bondades del paquete `DataFrames`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "datatrain = load(\"./titanic/train.csv\");\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 455
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "A continuación se muestra cómo se carga los datos de una archivo $^*$.xlsx, en el cual se especifica el nombre de la hoja de cálculo (en el caso particular del ejemplo 'train').\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "datatest = load(\"./titanic/test.xlsx\", \"test\");\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 456
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Ahora podemos comprobar que los datos efectivamente ha sido cargado en las variables de ambos archivos.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(datatrain)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 457
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "datatest;\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 458
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "A menudo se requerirá que los datos deban ser contenidos en un dataframe, para ello se utiliza el constructor `DataFrame` del paquete `DataFrames`. Podrá notar la mejora en la presentación de la tablas cuando se utiliza el paquete mencionado. \n",
                "\n",
                "Existen varias maneras de crear el dataframe, la primera es:\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftest = DataFrame(datatest)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 459
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "La segunda es más elegante y se utiliza pipe sintax:\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftrain = datatrain |> DataFrame;\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 460
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "typeof(datatrain), typeof(dftrain)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 461
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Como nota adicional, el método `load` también admite pasar como parámetro un `String` con la una url de donde el conjunto de datos pueda ser descargado, el archivo se guarda en el directorio que contiene el archivo que es ejecutado..\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Trabajando con los datos\n",
                "\n",
                "A continuación, se discutirán sobre alguna de las funciones implementadas en DataFrames para trabajar con los datos tabulados. \n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Obteniendo información del dataset\n",
                "Existe un conjunto de funciones que nos permite tener un overview del dataset que se ha cargado. Lo anterior será importante para dar un manejo adecuado a los datos.\n",
                "\n",
                "Para obtener las columnas del dataframe se utiliza el método `names`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "names(dftrain)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 462
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "names(dftest)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 463
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Las dimensiones de dataframe se puede obtener con el método `size`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "size(dftrain)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 464
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "size(dftest)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 465
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Una descripción del contenido de las columnas puede realizarse con el método `describe`. El método entrega información estadística de las columnas y varias propiedades.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "describe(dftrain);\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 466
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "describe(dftest)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 467
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Renombrando las columnas\n",
                "\n",
                "Renombrar una columna es útil cuando los nombres no son descriptivos y legibles.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "rename!(dftrain, :PassengerId=>\"Id\", :Pclass=>\"Class\", :Sex=>\"Gender\")\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 468
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "rename!(dftest, :PassengerId=>\"Id\", :Pclass=>\"Class\", :Sex=>\"Gender\")\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 469
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Accediendo a los elementos de un dataframe\n",
                "Diferentes formas puede ser aplicado para acceder a los elementos de un dataframe. A continuación se muestran algunas.\n",
                "\n",
                "**Mediante el punto (.col)**\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftrain.Name ###Retorna un array\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 470
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "**Mediante el símbolo ([:col])**\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftrain[:Age] ###Retorna un Array\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 471
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "**Mediante índice**\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftrain[1,5]  ###Un elemento específico\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 472
        },
        {
            "cell_type": "markdown",
            "source": [
                "En el ejemplo anterior se accedió a solo un dato de la columna, para acceder a toda la columna ser realiza con (:)\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftrain[:,5] ###Retorna un Array\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 473
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftrain[:,[5]] ###Retorna un DataFrame\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 474
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Se puede acceder a un conjunto de columnas a la vez\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftrain[:,[1,4,5,3]] ###Retorna un DataFrame\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 475
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftrain[:,[:Id,:Name,:Gender,:Class]] ###Retorna un DataFrame\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 476
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Es posible que, en lugar de indicar cada columna y dependiendo del nombre que posean las columnas, estas puedan ser indicadas por medio de una expresión regular indicado con `r\\\"--\\\"`. Lo anterior trata de hacer match con los nombres de las columnas y cuando se encuentre alguna coincidencia del nombre de la columna con la regla descrita por la expresión regular esta es devuelta.\n",
                "\n",
                "En los ejemplos anteriores se accedió a todas las filas de las columnas, sin embargo, puede accederse a un grupo limitado como se muestra a continuación\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftrain[50:100,[:Id,:Name,:Gender,:Class]];\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 477
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftrain[[50,75,100],[:Id,:Name,:Gender,:Class]];\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 478
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "**Mediante una condición**\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftrain[dftrain.Class.==2,:];\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 479
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Note como en el ejemplo anterior se utiliza broadcasting. La manera en que funciona lo anterior es de la siguiente forma: \n",
                "\n",
                "Primero se genera un vector con valores booleanos.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "arraybool = dftrain.Class.==2;\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 480
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Luego el arreglo se pasa en el lugar del primer índice cuado se desea acceder a los elementos del dataframe, el arreglo filtra los datos que serán mostrados (todas las filas que coincidan con el valor booleano true).\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftrain[arraybool,:];\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 481
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Para mayor legibilidad en el código, lo mejor será usar un conjunto de funciones que nos permiten hacer filtrado de la información, por ejemplo usar el método `filter`. Usar dichos métodos nos permitirá crear condiciones más robustas, complejas y claras.\n",
                "\n",
                "En el ejemplo que sigue se utiliza el paquete `Pipe`, el cual mejora la utilidad del uso de `pipe`, teniendo la posibilidad de usar funciones y pasar argumentos.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "Pkg.add(\"Pipe\"); using Pipe;\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 482
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@pipe dftrain |> filter(x->x.Class==2,_)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 483
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "De igual manera, el paquete `Queryverse` proporciona la macro `@filter` para realizar el filtrado, como se muestra a continuación.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftrain |> @filter _.Class==2\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 484
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Para la primera coincidencia se puede usar la función `findfirst`\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@pipe dftrain |> findfirst(x->x==2,_.Class) |> dftrain[_,:]\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 485
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "**Funciones del paquete**\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "first(dftrain,6);\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 486
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "last(dftrain,6);\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 487
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Funciones útiles\n",
                "El paquete `DataFrames` dispone de varias funciones que pueden ser de utilidad cuando se manipula y se transforman datos. A continuación se mencionan algunos de ellos.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@pipe dftrain |> colwise(sum,_[[:Survived,:Class]])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 488
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "La función `colwise` realiza operaciones por columnas cuando es necesario, en este caso el ejemplo no traduce a algo útil, pero ilustra el uso de la función.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Para columnas que no son numéricas puede usarse la función `countmap`, que cuenta el número de veces que aparece un determinado elemento en la serie (columna) de datos. Para el uso se instala y se importa el paquete `StatsBase`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "Pkg.add(\"StatsBase\"); using StatsBase\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 489
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@pipe dftrain |> countmap(_[:Gender])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 490
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@pipe dftrain |> countmap(_[:Embarked ])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 491
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Otra función interesante es `unique`, que devuelve un array con los valores no duplicados.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "genders = dftrain[:Gender] |> unique\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 492
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftrain[:TotalFamily] = dftrain.SibSp + dftrain.Parch\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 493
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftest[:TotalFamily] = dftest.SibSp + dftest.Parch\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 494
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftrain[:new] = dftrain.SibSp + dftrain.Parch; \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 495
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dftrain\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 496
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "En el ejemplo anterior una columna, con el nombre `TotalFamily`, fue añadida al dataframe. Una columna adicional es agregado, `new`, para ilustrar cómo se elimina.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "select!(dftrain,Not([:new]))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 497
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Para eliminar una fila del dataframe se puede usar la función `delete!` y para añadir una fila se puede usar la función `push!`. En `delete!` se indica el dataframe y el índice de la fila que debe ser eliminada.\n",
                "\n",
                "Existen otro conjunto de funciones que son de utilizada cuando se requiere realizar una consulta compleja en la data, el paquete `Queryverse` por contener el módulo `Query` ofrece opciones interesantes que pueden ser consultados en los siguientes enlaces: [link₁](https://www.queryverse.org/2019/02/02/query-v0.11/), [lin₂](https://www.queryverse.org/Query.jl/stable/standalonequerycommands/##Standalone-query-operators-1), [lin₃](https://www.queryverse.org/Query.jl/stable/linqquerycommands/#LINQ-Style-Query-Commands-1). \n",
                "\n",
                "Más funciones puede ser encontrado en la siguiente [introducción](https://en.wikibooks.org/wiki/Introducing_Julia/DataFrames) al paquete `DataFrames`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Manejo de fechas\n",
                "Es usual que al indagar en los datos y transformarlos se manejen fechas. En Julia ello se realiza con el paquete `Dates`, el cual nos permite dar formato a las fechas y realizar operaciones con ellas.\n",
                "\n",
                "Para construir un objeto tipo fecha se pueden usar los constructores `Date` y `DateTime`, los cuales diferen en la precisión (día y milisegundos respectivamente). \n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "Pkg.add(\"Dates\"); using Dates\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 498
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "Date(2021), Date(2021,5), Date(2021,6,4)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 499
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "DateTime(2021), DateTime(2021,5), DateTime(2021,6,4)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 500
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "En algunas ocasiones se encontrará necesario dar formato a una cadena de caracteres que representan una fecha, para ello en los constructores se especifica el formato de la cadena de texto, en el cual existen diferentes opciones.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "Date(\"2021-3\",\"yyyy-m\"), Date(\"2021/08/9\",\"yy/mm/d\"), Date(\"20210809\",\"yyyymmdd\"), Date(\"21-3\",\"yyyy-m\")\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 501
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Si existen muchos datos de fecha a formatear y tienen un formato similar, es más eficiente crear el formato primero y luego usarlo en el constructor, por ejemplo: `dateformat=DateFormat(\\\"dd/mm/yyyy\\\")`.\n",
                "\n",
                "En los ejemplos se puede notar que exite un error para la última fecha, cuando ocurre esas situaciones se debe parsear la cadena de texto para ser convertido a una cadena tipo fecha.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "parse(Dates.Date,\"2021-3\",Dates.DateFormat(\"yyyy-m\"))\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 502
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Para conocer más sobre el manejo de fechas revisar esta [documentación](https://docs.julialang.org/en/v1/stdlib/Dates/##Dates).\n",
                "md\n"
            ],
            "metadata": {}
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Respondiendo interrogantes y visualización de datos\n",
                "Para ilustrar cómo se utilizan algunas de las funciones más avanzadas, mencionadas hacia el final de la sección  'Funciones útiles', podemos dar respuesta a las siguientes preguntas:\n",
                "+ ¿Cuántas personas iban en el titanic?\n",
                "+ ¿Cuántos hombres y mujeres sobrevivieron?\n",
                "+ ¿Cuál fué el top 10 de edad que más sobrevivieron?\n",
                "+ ¿Cuál fue el top 10 de edad que no lograron sobrevivir?\n",
                "\n",
                "\n",
                "El paquete `StatPlots` ofrece una macro `@df`, el cual se usa junto con `Plots` para graficar datos de dataframe.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "Pkg.add(\"StatsPlots\"); using StatsPlots\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 503
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "A continuación una rutina para responder la primera interrogante.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "begin ###Preparamos los datos para unir los dataframes\n",
                "\tsurvivedtest = @pipe load(\"./titanic/gender_submission.csv\") |> \n",
                "\t\t\t\t\tDataFrame |> \n",
                "\t\t\t\t\trename!(_,:PassengerId=>\"Id\") |>\n",
                "\t\t\t\t\tFloat64.(_)\n",
                "\tdftest₁ = @from i in dftest begin\n",
                "\t\t\t  @join j in survivedtest on i.Id equals j.Id\n",
                "\t\t\t  @select {i.Id, j.Survived, i.Class,i.Name, i.Gender, i.Age, i.SibSp, i.Parch, i.Ticket, i.Fare, i.Cabin, i.Embarked, i.TotalFamily}\n",
                "\t\t\t  @collect DataFrame\n",
                "\tend\n",
                "end;\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 504
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "df = vcat(dftrain[:,:], dftest₁[:,:]); ###Se deben unir los dataframes\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 505
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "describe(df);\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 506
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### ¿Cuántas personas iban en el titanic?\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "length(df[:Id])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 507
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### ¿Cuántos hombres y mujeres sobrevivieron?\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "genders\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 508
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "👨 = df |> @filter(_.Gender==\"male\" && _.Survived==1) |> collect |> length\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 509
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "👩 = df |> @filter(_.Gender==\"female\" && _.Survived==1) |> collect |> length\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 510
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### ¿Cuál fué el top 10 de edad que más sobrevivieron?\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "agesurviver = df[df.Survived.==1, [:Age]] |> \n",
                "\t\t\t\tdropmissing |> \n",
                "\t\t\t\t@groupby(_[:Age]) |>\n",
                "\t\t\t\t@map({Edadesₛ=key(_), Countₛ=length(_)}) |>\n",
                "\t\t\t\tDataFrame;\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 511
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "agesurviver\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 512
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@pipe sort!(agesurviver,[:Countₛ],rev=true) |> first(_,10)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 513
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@pipe df[df.Survived.==1, [:Age]] |> \n",
                "\t\tdropmissing |> \n",
                "\t\tgroupby(_,:Age)  |> \n",
                "\t\tcombine(_,:Age=>length=>:Countₛ) |> \n",
                "\t\tsort(_,[:Countₛ],rev=true) |> \n",
                "\t\tfirst(_,10)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 514
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### ¿Cuál fue el top 10 de edad que no lograron sobrevivir?\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "notagesurviver = df[df.Survived.==0, [:Age]] |> \n",
                "\t  \t\t\t dropmissing |> \n",
                "\t\t\t\t @groupby(_[:Age]) |>\n",
                "\t\t\t\t @map({Edadesₙₛ=key(_), Countₙₛ=length(_)}) |>\n",
                "\t\t\t\t DataFrame;\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 515
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@pipe sort!(notagesurviver,[:Countₙₛ],rev=true) |> first(_,10)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 516
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@pipe df[df.Survived.==0, [:Age]] |> \n",
                "\t\tdropmissing |> \n",
                "\t\tgroupby(_,:Age)  |> \n",
                "\t\tcombine(_,:Age=>length=>:Countₛ) |> \n",
                "\t\tsort(_,[:Countₛ],rev=true) |> \n",
                "\t\tfirst(_,10)\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 517
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "#### Gráfica con Plots\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dfplotₛ = DataFrame();\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 518
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dfplotₛ[:Gender] = @pipe df[df.Survived.==1, [:Gender]] |> \n",
                "\t\t\tmap(x->x==\"male\" ? 0 : 1, _[:Gender])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 519
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dfplotₙₛ = DataFrame();\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 520
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "dfplotₙₛ[:Gender] = @pipe df[df.Survived.==0, [:Gender]] |> \n",
                "\t\t\tmap(x->x==\"male\" ? 0 : 1, _[:Gender])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 521
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@df dfplotₛ plot(:Gender, seriestype=:histogram, legend=:none, bar_width=0.9, xticks=([0.15,1.15],[\"Varón\", \"Mujer\"]), title=\"Sobrevivientes\")\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 522
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@df dfplotₙₛ plot(:Gender, seriestype=:histogram, legend=:none, bar_width=0.9, xticks=([0.15,1.15],[\"Varón\", \"Mujer\"]), title=\"No Sobrevivientes\")\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 523
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "f = DataFrame(a = 1:10, b = 10 * rand(10), c = 10 * rand(10));\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 524
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@df f plot(:a, [:b :c])\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 525
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Paquete PlutoUI\n",
                "Este paquete es que agrega syntactic sugar para alguna de las funcionalidades de Pluto. [`PlutoUI`](https://github.com/fonsp/PlutoUI.jl) puede ser implementado para colocar widgets en el cuaderno y hacer más interactivo el programa que se escriba.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "Pkg.add(\"PlutoUI\"); using PlutoUI;\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 526
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@bind gender Select(genders) \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 527
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "@bind number Slider(1:9) \n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 528
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "gender, number\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 529
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "### Utilidades de `Queryverse`\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "datatrain |> @vlplot(:point,x=:Survived,y=:Pclass,color=\"Sex:n\")\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 530
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "Es posible realizar una gráfica como se muestra en el ejemplo, donde no se usa `Plots.jl`.\n",
                "\n"
            ],
            "metadata": {}
        },
        {
            "outputs": [],
            "cell_type": "code",
            "source": [
                "datatrain |> Voyager\n",
                "",
                ""
            ],
            "metadata": {},
            "execution_count": 531
        },
        {
            "cell_type": "markdown",
            "source": [
                "\n",
                "`Voyager` es una utilidad que permite explorar de forma rápida los gráficos, ofreciendo la posibilidad de visualizarlos con gráficos.\n",
                "\n"
            ],
            "metadata": {}
        }
    ],
    "nbformat_minor": 2,
    "metadata": {
        "language_info": {
            "file_extension": ".jl",
            "mimetype": "application/julia",
            "name": "julia",
            "version": "1.5.1"
        },
        "kernelspec": {
            "name": "julia-1.5",
            "display_name": "Julia 1.5.1",
            "language": "julia"
        }
    },
    "nbformat": 4
}