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.
Tabla de contenidos
- 1 Creación de un DataFrame en Julia
- 2 Cambiando el nombre de las columnas
- 3 Conflictos al cambiar los nombres
- 4 Combinar varios DataFrames
- 5 Introducir el valor en el medio de un DataFrame
- 6 Subconjunto de columnas en DataFrames de Julia
- 7 Copiar o referenciar columnas en DataFrames
- 8 La importancia de las columnas en DataFrames de Julia
- 9 Publicaciones de la serie ¡Hola 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.
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!
- ¡Hola Julia!
- Primeros pasos con Julia
- Cadenas de texto en Julia
- Bucles en Julia
- Funciones en Julia
- Vectores, tuplas y diccionarios en Julia
- Estructuras en Julia
- Utilizar los tipos en Julia
- Tipos de datos en Julia
- Tipos y funciones paramétricos en Julia
- Introducción a los DataFrames en Julia
- Obtener información básica de los DataFrames de Julia
- El tipo de dato Missing de Julia
- Columnas en DataFrames de Julia
- Filas en DataFrames de Julia
- Combinar DataFrames en Julia
- Guardar y leer archivos CSV en Julia
- Guardar y leer archivos Excel en Julia
- Introducción a Genie
- Libros sobre Julia
Deja una respuesta