Introducción a los DataFrames en Julia (11ª parte – ¡Hola Julia!)

Hasta ahora hemos visto las bases del lenguaje con las que se puede realizar muchas tareas. Pero tanto en R como en Python un elemento básico para el tratamiento de los datos es el DataFrame. Algo que no es diferente en Julia. Por lo que en esta entrada vamos a realizar una introducción a los DataFrames en Julia.

Importación de DataFrames

Para trabajar con los DataFrames es necesario importar el paquete del mismo nombre. Un paquete que viene en la distribución estándar de Julia, por lo que no es necesario instalarlo para poder trabajar con este. Así para crear un DataFrames solo tenemos que usar using DataFrames y posteriormente llamar al constructor.

using DataFrames

DataFrame()

Creación de un DataFrame básico en Julia

Ahora que se ha importado la librería se podemos crear un DataFrame básico para posteriormente trabajar con ellos. Así la sintaxis básica para crear un DataFrame en Julia es

using Random

A = 1:3
B = rand(3)
C = randstring.([4,4,4])
D = 12

DataFrame("A" => A, "B" => B, "C" => C, "D" => D)

3×4 DataFrame
│ Row │ A     │ B        │ C      │ D     │
│     │ Int64 │ Float64  │ String │ Int64 │
├─────┼───────┼──────────┼────────┼───────┤
│ 1   │ 1     │ 0.761577 │ a3Cl   │ 12    │
│ 2   │ 2     │ 0.631399 │ 0Hhf   │ 12    │
│ 3   │ 3     │ 0.987393 │ YKRH   │ 12    │

Vemos que hemos que en ese código se han creado tres vectores de diferente tipo y un escalar. Asignando cada uno de estos objetos a una columna con un nombre, que se indica mediante una cadena de texto, mediante el uso del operador =>. Obteniendo un DataFrame que tiene cuatro columnas de diferente tipo. Nótese que para en el caso del escalar se ha asignado el mismo valor a todas las filas.

En Analytics Lane

La caverna del consumo, o cómo Greenspan miraba calzoncillos para hacer política monetaria – El bestiario de los indicadores económicos absurdos (parte 1)

Métodos alternativos para crear un DataFrame

El mismo DataFrame que hemos visto en el ejemplo anterior se puede crear de diferentes maneras. Por ejemplo, asignado los valores a símbolos con el operador = o creado un diccionario para construir el DataFrame a partir con este.

DataFrame(A = A, B = B, C = C, D = D)

dict = Dict("A" => A, "B" => B, "C" => C, "D" => D)
DataFrame(dict)

Creación del DataFrame en Julia a partir de matrices

Los DataFrames también se pueden construir a partir de una matriz, en este caso solo se tiene que inyectar la matriz en el constructor.

DataFrame(rand(3 ,3))

3×3 DataFrame
│ Row │ x1       │ x2       │ x3       │
│     │ Float64  │ Float64  │ Float64  │
├─────┼──────────┼──────────┼──────────┤
│ 1   │ 0.347456 │ 0.751013 │ 0.840584 │
│ 2   │ 0.531412 │ 0.2913   │ 0.858707 │
│ 3   │ 0.863199 │ 0.702161 │ 0.228352 │

A las columnas se les asignará el nombre x seguido de su ordinal comenzado por 1. Si se desea dar un nombre a las columnas se pueden pasar como segundo parámetro en un vector de símbolos.

DataFrame(rand(3, 3), Symbol.(["A", "B", "C"]))

3×3 DataFrame
│ Row │ A         │ B        │ C        │
│     │ Float64   │ Float64  │ Float64  │
├─────┼───────────┼──────────┼──────────┤
│ 1   │ 0.424402  │ 0.321412 │ 0.590043 │
│ 2   │ 0.731513  │ 0.808899 │ 0.825533 │
│ 3   │ 0.0507963 │ 0.511899 │ 0.447414 │

O, en otros casos como el anterior, utilizandO, en otros casos como el anterior donde se usan letras ordenadas para asignar los nombres a las columnas, se puede emplear el operador :.

DataFrame(rand(3,4), Symbol.('a':'d'))

3×4 DataFrame
│ Row │ a        │ b         │ c        │ d        │
│     │ Float64  │ Float64   │ Float64  │ Float64  │
├─────┼──────────┼───────────┼──────────┼──────────┤
│ 1   │ 0.297471 │ 0.0628647 │ 0.208568 │ 0.986928 │
│ 2   │ 0.112225 │ 0.861527  │ 0.513009 │ 0.235994 │
│ 3   │ 0.365246 │ 0.402313  │ 0.28596  │ 0.79416  │

Es importante que le primer dato sea una matriz, ya que el constructor no funciona si lo que se pasa es un vector. Así el siguiente código dará un error.

DataFrame(rand(3))

ArgumentError: 'Array{Float64,1}' iterates 'Float64' values, which doesn't satisfy the Tables.jl `AbstractRow` interface

Construcción de DataFrames vacíos

También se puede crear DataFrames vacíos, solamente con el nombre de la columna y tipo de dato. Para ello es necesario pasar un vector con los tipos de dato como primer parámetro y los nombres como segundo parámetro. Por ejemplo

DataFrame([Int, Float64, String], [:A, :B, :C])

0 rows × 3 columns
	A	B	C
	Int64	Float64	String

Copia de DataFrames y columnas

Si se quiere copiar un DataFrame se puede usar el método copy. Este generará un nuevo DataFrame igual al original copiando también su contenido, es decir, creando una copia profunda del objeto original.

df1 = DataFrame(a=1:2)
df2 = copy(df1)

df1 == df2 # true
df1 === df2 # false
df1.a == df2.a # true
df1.a === df2.a # false

En el caso de que no se desee realizar una copia profunda, evitando así duplicar el contenido del DataFrame en memoria, se puede modificar el valor de la opción copycols a falso. De este modo se creará un nuevo DataFrame, pero apuntando a los mismos vectores que el original.

df1 = DataFrame(a=1:2)
df2 = copy(df1, copycols=false)

df1 == df2 # true
df1 === df2 # false
df1.a == df2.a #true
df1.a === df2.a # true

Algo que se puede conseguir de forma más compacta utilizando el constructor DataFrame y con ! al final del nombres, esto es:

x = DataFrame(a=1:2)
y = DataFrame!(x)

df1 == df2 # true
df1 === df2 # false
df1.a == df2.a #true
df1.a === df2.a # true

El modificador copycols también se puede usar en el constructor, evitando de esta manera que realice una copia de los vectores.

a = [1, 2, 3]

df1 = DataFrame(a=a)
df2 = DataFrame(a=a, copycols=false)

df1.a === a # false
df2.a === a # true

Nótese que, con este modificador, usado tanto en copy como en DataFrame evita que se duplicar los vectores en memoria cuando puede ser innecesario. Algo que puede ser muy útil cuando se trabaja con conjuntos de datos grandes.

Los DataFrames en Julia

Hoy hemos visto el uso básico de los DataFrames en Julia. Una herramienta que como bien saben los usuarios de R y Python es básica para poder procesar de forma eficaz los datos de datos utilizados en nuestros análisis. Esto ha sido una primera toma de contacto, en la próxima entrega veremos cómo obtener información básica de estos objetos.

Publicaciones de la serie ¡Hola Julia!

1. ¡Hola Julia!
2. Primeros pasos con Julia
3. Cadenas de texto en Julia
4. Bucles en Julia
5. Funciones en Julia
6. Vectores, tuplas y diccionarios en Julia
7. Estructuras en Julia
8. Utilizar los tipos en Julia
9. Tipos de datos en Julia
10. Tipos y funciones paramétricos en Julia
11. Introducción a los DataFrames en Julia
12. Obtener información básica de los DataFrames de Julia
13. El tipo de dato Missing de Julia
14. Columnas en DataFrames de Julia
15. Filas en DataFrames de Julia
16. Combinar DataFrames en Julia
17. Guardar y leer archivos CSV en Julia
18. Guardar y leer archivos Excel en Julia
19. Introducción a Genie
20. Libros sobre Julia