Columnas en DataFrames de Julia (14ª parte – ¡Hola Julia!)

A la hora de trabajar con objetos tipo DataFrame es importante conocer el funcionamiento de las columnas. Los objetos que hacen referencia a las características de los datos. Algo que no es una excepción en Julia. Por eso en esta entrada se mostrará algunos métodos para seleccionar el contenido, cambiar el nombre o el símbolo, comprobar el tipo de dato y otras operaciones importantes de las columnas en DataFrames de Julia.

Creación de un DataFrame en Julia

En esta ocasión, para trabajar con las columnas de los DataFrames, se puede crear un objeto a partir de una matriz aleatoria. Para lo que se puede usar la función rand() después de haber fijado la semilla para obtener unos resultados reproducibles.

using DataFrames
using Random

Random.seed!(1)

df = DataFrame(rand(Int8, 3, 4))

3×4 DataFrame
│ Row │ x1   │ x2   │ x3   │ x4   │
│     │ Int8 │ Int8 │ Int8 │ Int8 │
├─────┼──────┼──────┼──────┼──────┤
│ 1   │ -82  │ -63  │ -62  │ -77  │
│ 2   │ -126 │ 53   │ -69  │ 92   │
│ 3   │ 103  │ -18  │ 82   │ 100  │

En ejemplo anterior se ha indicado que se cree una matriz de 3 por cuatro de tipo entero. Por lo que el DataFrame obtenido tendrá cuatro columnas de tipo Int8. Cada una de las columnas tiene como nombre x seguido del número de la columna original en la matriz.

En Analytics Lane

Programador de tareas de Windows: Guía definitiva para automatizar tu trabajo (BAT, PowerShell y Python)

Cambiando el nombre de las columnas

Los nombres de las columnas del DataFrame creado en la sección anterior no son significativos. Pero se puede cambiar con el método rename(). Al cual se le debe pasar el DataFrame y el nombre de la columna original y el nuevo nombre. Obteniendo como respuesta un nuevo DataFrame con los nuevos nombres.

df = rename(df, "x1" => "A")

3×4 DataFrame
│ Row │ A    │ x2   │ x3   │ x4   │
│     │ Int8 │ Int8 │ Int8 │ Int8 │
├─────┼──────┼──────┼──────┼──────┤
│ 1   │ -82  │ -63  │ -62  │ -77  │
│ 2   │ -126 │ 53   │ -69  │ 92   │
│ 3   │ 103  │ -18  │ 82   │ 100  │

La función rename() crea un nuevo DataFrame, lo que puede no ser interesante cuando trabajamos con objetos grandes. Por lo que es más aconsejable usar la función con el símbolo de admiración (rename!()) para que los cambios se apliquen sobre el mismo objeto. Además, también se puede usar la posición en lugar del nombre para indicar la columna que se desea reemplazar.

rename!(df, 3 => :third)

3×4 DataFrame
│ Row │ A    │ x2   │ third │ x4   │
│     │ Int8 │ Int8 │ Int8  │ Int8 │
├─────┼──────┼──────┼───────┼──────┤
│ 1   │ -82  │ -63  │ -62   │ -77  │
│ 2   │ -126 │ 53   │ -69   │ 92   │
│ 3   │ 103  │ -18  │ 82    │ 100  │

Algo que también se puede hacer con una función que modifique el nombre de las columnas. Por ejemplo, concatenar el nombre de la columna consigo mismo.

rename!(c -> c^2, df)

3×4 DataFrame
│ Row │ AA   │ x2x2 │ thirdthird │ x4x4 │
│     │ Int8 │ Int8 │ Int8       │ Int8 │
├─────┼──────┼──────┼────────────┼──────┤
│ 1   │ -82  │ -63  │ -62        │ -77  │
│ 2   │ -126 │ 53   │ -69        │ 92   │
│ 3   │ 103  │ -18  │ 82         │ 100  │

Quizás puede ser más interesante poder cambiar el nombre de todas las columnas a la vez. Para lo que solamente tendremos que pasar un vector con los nombres de las columnas.

rename!(df, string.('a':'d'))

3×4 DataFrame
│ Row │ a    │ b    │ c    │ d    │
│     │ Int8 │ Int8 │ Int8 │ Int8 │
├─────┼──────┼──────┼──────┼──────┤
│ 1   │ -82  │ -63  │ -62  │ -77  │
│ 2   │ -126 │ 53   │ -69  │ 92   │
│ 3   │ 103  │ -18  │ 82   │ 100  │

Conflictos al cambiar los nombres

Es posible intercambiar el nombre de las columnas, pero se tiene que hacer en la misma operación ya que en caso contrario tendremos un error porque no puede existir dos columnas con el mismo nombre.

rename!(df, "a"=>"d", "d"=>"a")

3×4 DataFrame
│ Row │ d    │ b    │ c    │ a    │
│     │ Int8 │ Int8 │ Int8 │ Int8 │
├─────┼──────┼──────┼──────┼──────┤
│ 1   │ -82  │ -63  │ -62  │ -77  │
│ 2   │ -126 │ 53   │ -69  │ 92   │
│ 3   │ 103  │ -18  │ 82   │ 100  │

Si se intenta hacer en dos pasos tendremos un error.

rename!(df, "a"=>"d")
rename!(df, "d"=>"a")

ArgumentError: Tried renaming to :d, when it already exists in the Index.

En el caso de asignar un vector con los nombres se puede usar la propiedad makeunique para evitar que los conflictos.

rename(df, fill(:a, 4), makeunique=true)

3×4 DataFrame
│ Row │ a    │ a_1  │ a_2  │ a_3  │
│     │ Int8 │ Int8 │ Int8 │ Int8 │
├─────┼──────┼──────┼──────┼──────┤
│ 1   │ -82  │ -63  │ -62  │ -77  │
│ 2   │ -126 │ 53   │ -69  │ 92   │
│ 3   │ 103  │ -18  │ 82   │ 100  │

Combinar varios DataFrames

Los DataFrames se pueden combinar horizontalmente para crear nuevos objetos. El método para combinar horizontalmente es hcat() en el que solamente se le tiene que pasar los DataFrames a combinar. Obteniendo como respuesta el nuevo. Si los dos DataFrames tienen columnas con el mismo nombre se puede evitar los problemas fijando la propiedad makeunique a verdadero.

df2 = hcat(df, df, makeunique=true)

3×8 DataFrame
│ Row │ d    │ b    │ c    │ a    │ d_1  │ b_1  │ c_1  │ a_1  │
│     │ Int8 │ Int8 │ Int8 │ Int8 │ Int8 │ Int8 │ Int8 │ Int8 │
├─────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┼──────┤
│ 1   │ -82  │ -63  │ -62  │ -77  │ -82  │ -63  │ -62  │ -77  │
│ 2   │ -126 │ 53   │ -69  │ 92   │ -126 │ 53   │ -69  │ 92   │
│ 3   │ 103  │ -18  │ 82   │ 100  │ 103  │ -18  │ 82   │ 100  │

Otra opción es combinar un vector con un DataFrame. Si el vector se pasa como primer parámetro se insertará al principio del nuevo DataFrame, mientras que es si es el segundo parámetro se insertará al final. Lo que se puede ver en el siguiente ejemplo.

df2 = hcat(df, [1, 2, 3])

3×5 DataFrame
│ Row │ d    │ b    │ c    │ a    │ x1    │
│     │ Int8 │ Int8 │ Int8 │ Int8 │ Int64 │
├─────┼──────┼──────┼──────┼──────┼───────┤
│ 1   │ -82  │ -63  │ -62  │ -77  │ 1     │
│ 2   │ -126 │ 53   │ -69  │ 92   │ 2     │
│ 3   │ 103  │ -18  │ 82   │ 100  │ 3     │

Algo que se puede hacer de una forma más compacta si se usan corchetes.

df2 = [df DataFrame(A=[1,2,3])]

Introducir el valor en el medio de un DataFrame

En los ejemplos anteriores se han insertado las columnas al final o al principio de un DataFrame. Si se quiere insertar en el medio, solamente tendremos que usar la función insertcols para ello.

insertcols!(df, 2, "A" => [1,2,3])

3×5 DataFrame
│ Row │ d    │ A     │ b    │ c    │ a    │
│     │ Int8 │ Int64 │ Int8 │ Int8 │ Int8 │
├─────┼──────┼───────┼──────┼──────┼──────┤
│ 1   │ -82  │ 1     │ -63  │ -62  │ -77  │
│ 2   │ -126 │ 2     │ 53   │ -69  │ 92   │
│ 3   │ 103  │ 3     │ -18  │ 82   │ 100  │

Subconjunto de columnas en DataFrames de Julia

Para obtener un subconjunto de las columnas en DataFrames de Julia se puede emplear un vector con las posiciones deseadas,

df[:, [1,3,4,5]]

Un vector de datos booleanos.

df[:, [true, false, true, true, true]]

O un vector con los nombre o símbolos que hacen referencia a las columnas.

df[:, [:a, :b, :c, :d]]

Además de esto también se puede indicar que no se incluya una columna mediante Not().

df[:, Not(2)]

En todos esto ejemplo se ha obtenido como resultado el siguiente DataFrame.

3×4 DataFrame
│ Row │ a    │ b    │ c    │ d    │
│     │ Int8 │ Int8 │ Int8 │ Int8 │
├─────┼──────┼──────┼──────┼──────┤
│ 1   │ -77  │ -63  │ -62  │ -82  │
│ 2   │ 92   │ 53   │ -69  │ -126 │
│ 3   │ 100  │ -18  │ 82   │ 103  │

Copiar o referenciar columnas en DataFrames

En los ejemplos que hemos visto hasta ahora siempre se ha utilizado : para hacer referencia a todas las filas. Pero, como se ha visto en otras entradas de la serie, también se puede usar !. La diferencia entre estos dos operadores es que el primero crea una copia mientras que el segundo crea una referencia. Lo que se puede con el siguiente ejemplo

df[:, :a] === df[:, :a] # false
df[!, :a] === df[!, :a] # true

Usará un operador u otro tiene importantes consecuencias, si copiamos una columna y luego la modificamos solamente se ve afectada una de las dos.

df[!, :A] = df[:, :a]
df[1, :A] = 0

3×6 DataFrame
│ Row │ d    │ A    │ b    │ c    │ a    │ B     │
│     │ Int8 │ Int8 │ Int8 │ Int8 │ Int8 │ Int64 │
├─────┼──────┼──────┼──────┼──────┼──────┼───────┤
│ 1   │ -82  │ 0    │ -63  │ -62  │ -77  │ 10    │
│ 2   │ -126 │ 92   │ 53   │ -69  │ 92   │ 11    │
│ 3   │ 103  │ 100  │ -18  │ 82   │ 100  │ 12    │

Pero si referenciamos las columnas, al realizar un cambio en una de ellas también afectará a la otra.

df[!, :A] = df[!, :a]
df[1, :A] = 0

3×6 DataFrame
│ Row │ d    │ A    │ b    │ c    │ a    │ B     │
│     │ Int8 │ Int8 │ Int8 │ Int8 │ Int8 │ Int64 │
├─────┼──────┼──────┼──────┼──────┼──────┼───────┤
│ 1   │ -82  │ 0    │ -63  │ -62  │ 0    │ 10    │
│ 2   │ -126 │ 92   │ 53   │ -69  │ 92   │ 11    │
│ 3   │ 103  │ 100  │ -18  │ 82   │ 100  │ 12    │

La importancia de las columnas en DataFrames de Julia

Saber trabajar de forma eficiente con las columnas de los DataFrames de Julia es clave para sacar provecho de esa herramienta. Por lo que las opciones vistas en la entrad puede ser clave.

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