WIP: Add spanish translation, Literate.jl backend

literate_notebooks/src-ES/01_constructors.jl

@@ -0,0 +1,145 @@
+# # Introducción a DataFrames
+# **[Bogumił Kamiński](http://bogumilkaminski.pl/about/), May 23, 2018**
+# (Traducción por Miguel Raz, Abril 16 2021)
+# 
+# Empecemos cargando el paquete de `DataFrames`.
+
+using DataFrames
+
+# ## Constructores y conversiones
+
+#-
+
+# ### Constructores
+# 
+# En esta secciónn, verás distintas maneras de crear un `DataFrame` usando el constructor `DataFrame()`.
+# 
+# Primero, creemos un DataFrame vacío.
+
+DataFrame() #  DataFrame vacío
+
+# O podemos llamar al constructor usando keyword arguments para agregar columnas al `DataFrame`.
+
+DataFrame(A=1:3, B=rand(3), C=randstring.([3,3,3]))
+
+# Podemos creat el `DataFrame` de un diccionario, en cuyo caso las llaves del diccionario estarán ordenadas para crear las columnas del `DataFrame`.
+
+x = Dict("A" => [1,2], "B" => [true, false], "C" => ['a', 'b'])
+DataFrame(x)
+
+# En vez de explícitamente crear el diccionario primero, como hicimos arriba, podríamos pasar argumentos de `DataFrame` con la sintaxis de pares llave-valor de un diccionario.
+# 
+# Notar que en este caso, usamos símbolos para denotar los nombres de las columnas y los argumentos no están ordenados. Por ejemplo, `:A`, el símbolo, produce `A`, el nombre de la primera columna:
+
+DataFrame(:A => [1,2], :B => [true, false], :C => ['a', 'b'])
+
+# Aquí creamos un `DataFrame` de un vector de vectores, donde cada vector se convierte en una columna.
+
+DataFrame([rand(3) for i in 1:3])
+
+#  Por ahora podemos construir un `DataFrame` de un `Vector` de átomos, creando un `DataFrame` con una sola hilera. En versiones futuras de DataFrames.jl, esto arrojará un error.
+
+DataFrame(rand(3))
+
+# Si tienes un vector de átomos, es mejor usar un vector transpuesto (pues efectivamente uno pasa un arreglo bidimensional, lo cual sí tiene soporte.)
+
+DataFrame(transpose([1, 2, 3]))
+
+# Pasa un segundo argumento para darle nombre a las columnas.
+
+DataFrame([1:3, 4:6, 7:9], [:A, :B, :C])
+
+# Aquí creamos un `DataFrame` de una matriz,
+
+DataFrame(rand(3,4))
+
+# y aquí hacemos lo mismo pero también pasamos los nombres de las columnas.
+
+DataFrame(rand(3,4), Symbol.('a':'d'))
+
+# También podemos pasar un DataFrame no inicializado.
+# 
+# Aquí pasamos los tipos de las columnas, nombres y número de hileras; obtemenos un `missing` en la columna :C porque `Any >: Missing`:
+
+DataFrame([Int, Float64, Any], [:A, :B, :C], 1)
+
+# Aquí nosotros creamos un `DataFrame`, pero la columna `:C` es `#undef` y Jupyter tiene problemas para mostrarlo (Esto funciona en el REPL sin problemas.)
+# 
+
+DataFrame([Int, Float64, String], [:A, :B, :C], 1)
+
+# Para inicializar un `DataFrame` con nombres de columnas, pero sin filas, usamos
+
+DataFrame([Int, Float64, String], [:A, :B, :C], 0) 
+
+# Esta sintaxis nos da una manera rápida de crear un `DataFrame` homogéneo.
+
+DataFrame(Int, 3, 5)
+
+# El ejemplo es similar, pero tiene columnas no-homogéneas.
+
+DataFrame([Int, Float64], 4)
+
+# Finalmente, podemos creat un `DataFrame` copiando uno anterior.
+# 
+# Notar que `copy` crea un copia superficial.
+
+y = DataFrame(x)
+z = copy(x)
+(x === y), (x === z), isequal(x, z)
+
+# ### Conversión a matrices
+# 
+# Let's start by creating a `DataFrame` with two rows and two columns.
+# Empecemos creando un `DataFrame` con dos filas y dos columnas. 
+
+x = DataFrame(x=1:2, y=["A", "B"])
+
+# Podemos crear una matriz pasando este `DataFrame` a `Matrix`.
+
+Matrix(x)
+
+# Este funciona aún si el `DataFrame` tiene `missing`s:
+
+x = DataFrame(x=1:2, y=[missing,"B"])
+
+#-
+
+Matrix(x)
+
+# En los dos ejemplos de matrices pasados, Julia creó matrices con elementos de tipo `Any`. Podemos ver más claramente qué tipo de matriz es inferido cuando pasamos, por ejemplo, un `DataFrame` de enteros a `Matrix`, creando un arreglo 2D de `Int64`s: 
+
+x = DataFrame(x=1:2, y=3:4)
+
+#-
+
+Matrix(x)
+
+# En el próximo ejemplo, Julia correctamente identifica que el tipo `Union` se necesita para expresar el tipo resultante de `Matrix` (el cual contiene `missing`s).
+
+
+x = DataFrame(x=1:2, y=[missing,4])
+
+#-
+
+Matrix(x)
+
+# ¡Notemos que no podemos covertir forzosamente valores `missings` a `Int`s!
+
+Matrix{Int}(x)
+
+# ### Lidiando con nombres de columnas repetidos
+# 
+# Podemos pasar el keyword argument `makeunique` para permitir usar nombres duplicados (se desduplican)
+
+df = DataFrame(:a=>1, :a=>2, :a_1=>3; makeunique=true)
+
+# Si no es así, los duplicados no se permitirán después.
+
+df = DataFrame(:a=>1, :a=>2, :a_1=>3)
+
+# Una excepción es un constructor al que se le pasan los nombres de columnas como keyword arguments.
+# No puedes pasar `makeunique` para permitir duplicados en este caso.
+
+df = DataFrame(a=1, a=2, makeunique=true)
+

literate_notebooks/src-ES/02_basicinfo.jl

@@ -0,0 +1,79 @@
+# # Introduction to DataFrames
+# # Introducción a DataFrames
+# **[Bogumił Kamiński](http://bogumilkaminski.pl/about/), May 23, 2018**
+# Traducción por Miguel Raz, Abril 17, 2021
+
+using DataFrames # cargar el paquete
+
+# ## Obteniendo información básica de un DataFrame
+#
+# 
+# Empecemos creando un objeto `DataFrame`, llamado `x`, para que podamos aprender como sacarle información.
+
+x = DataFrame(A = [1, 2], B = [1.0, missing], C = ["a", "b"])
+
+# La función estándar `size` nos dice las dimensiones del `DataFrame`,
+
+size(x), size(x, 1), size(x, 2)
+
+# y al igual que `nrow	 y `ncol` de R; `length`; nos da el número de columnas.
+
+nrow(x), ncol(x), length(x)
+
+# `describe` nos da estadísticas descriptivas básicas de nuestro `DataFrame`. 
+
+describe(x)
+
+# Usa `showcols` para obetner información sobre columnas guardadas en un DataFrame.
+
+showcols(x)
+
+# `names` regresa el nombre de todas las columnas,
+
+names(x)
+
+# y `eltypes` el de sus tipos.
+
+eltypes(x)
+
+# Aquí creamos un DataFrame más grande
+
+y = DataFrame(rand(1:10, 1000, 10));
+
+# y usamos `head` para asomarnos a sus primeras filas
+
+head(y)
+
+# y `tail` para sus últimas filas.
+
+tail(y, 3)
+
+# ### Operaciones elementales para asignar y sacar
+# 
+# Dado un objeto DataFrame llamado `x`, aquí hay 3 maneras de tomar una de sus columnas como un `Vector`:
+
+x[1], x[:A], x[:, 1]
+
+# Para tomar una hilera de un DataFrame, lo indexamos como sigue
+
+x[1, :]
+
+# Podemos agarrar una sola celda o elemento con la misma sintaxis que usamos para elementos de arreglos.
+
+x[1, 1]
+
+# Asignar también se puede hacer con rangos a un escalar,
+
+x[1:2, 1:2] = 1
+x
+
+# a un vector de longitud igual al número de filas asignadas,
+
+x[1:2, 1:2] = [1,2]
+x
+
+# o a otro DataFrame de tamaño igual.
+
+x[1:2, 1:2] = DataFrame([5 6; 7 8])
+x
+

literate_notebooks/src-ES/03_missingvalues.jl

@@ -0,0 +1,115 @@
+# # Introduction to DataFrames
+# # Introducción a DataFrames
+# **[Bogumił Kamiński](http://bogumilkaminski.pl/about/), May 23, 2018**
+# (Traducción de Miguel Raz Guzmán Macedo)
+
+using DataFrames # cargar paquete
+
+# ## Manejo de valores faltantes
+# 
+# Un tipo singulete `Missings.Missing` permite lidiar con valores faltantes
+
+missing, typeof(missing)
+
+# Los arreglos automaticamente crean una unión de tipos apropiada.
+
+x = [1, 2, missing, 3]
+
+# `ismissing` checa si se le pasa un valor faltante.
+
+ismissing(1), ismissing(missing), ismissing(x), ismissing.(x)
+
+# Podemos extrar el tipo combinado con Missing de una `Union` via
+# 
+# (¡Esto es muy útil para los arreglos!)
+
+eltype(x), Missings.T(eltype(x))
+
+# comparaciones de `missing` producen `missing`.
+
+missing == missing, missing != missing, missing < missing
+
+# Eso también es cierto cuando `missing`s se comparan con valores de otros tipos.
+
+1 == missing, 1 != missing, 1 < missing
+
+# `isequal`, `isless`, y `===` producen resultados de tipo `Bool`.
+#
+
+isequal(missing, missing), missing === missing, isequal(1, missing), isless(1, missing)
+
+# En los próximos ejemplos, vemos que muchas (no todas) funciones manejan `missing`.
+
+map(x -> x(missing), [sin, cos, zero, sqrt]) # part 1
+
+#-
+
+map(x -> x(missing, 1), [+, - , *, /, div]) # part 2 
+
+#-
+
+map(x -> x([1,2,missing]), [minimum, maximum, extrema, mean, any, float]) # part 3
+
+# `skipmissing` regresa un iterador que salta valores faltantes. Podemos usar `collect` y `skipmissing` para crear un arreglo que excluye estos valores faltantes.
+
+collect(skipmissing([1, missing, 2, missing]))
+
+# Similarmente, aquí combinamos `collect` y `Missings.replace` para crear un arreglo que reemplaza todos los valores faltantes con algún valor (`NaN`, en este caso).
+
+collect(Missings.replace([1.0, missing, 2.0, missing], NaN))
+
+# Otra manera de hacer esto es:
+
+coalesce.([1.0, missing, 2.0, missing], NaN)
+
+# Cuidado: `nothing` también sería reemplazado aquí (Para Julia 0.7 un comportamiento más sofisticado de `coalesce` permite que esquivemos este problema.)
+
+coalesce.([1.0, missing, nothing, missing], NaN)
+
+# Puedes usar `recode` si tienes tipos homogéneos en el output.
+
+recode([1.0, missing, 2.0, missing], missing=>NaN)
+
+# Puedes usar `unique` o `levels` para obtener valores únicos con o sin missings, respectivamente.
+
+unique([1, missing, 2, missing]), levels([1, missing, 2, missing])
+
+# En este ejemplo, convertimos `x` a `y` con `allowmissing`, donde `y` tiene un tipo que acepta missings.
+
+x = [1,2,3]
+y = allowmissing(x)
+
+# Después, lo convertimos de regreso con `disallowmissing`. ¡Esto falla si `y` contiene valores faltantes!
+
+z = disallowmissing(y)
+x,y,z
+
+# En el próximo ejemplo, mostramos que el tipo de cada columna de `x` es inicialmente `Int64`. Después de usar `allowmissing!`, aceptamos valores faltantes en las columnas 1 y 3. Los tipos de esas columnas se convierten en `Union`es de `Int64` y `Missings.Missing`.
+
+x = DataFrame(Int, 2, 3)
+println("Before: ", eltypes(x))
+allowmissing!(x, 1) # Hacer que la primera columna permita valores faltantes
+allowmissing!(x, :x3) # Hacer que la columna :x3 acepte valores faltantes
+println("After: ", eltypes(x))
+
+# En este ejemplo, usaremos `completecases` para encontrar todas las hileras de un `DataFrame` que tengan datos completos.
+
+x = DataFrame(A=[1, missing, 3, 4], B=["A", "B", missing, "C"])
+println(x)
+println("Complete cases:\n", completecases(x))
+
+# Podemos usar `dropmissing` o `dropmissing!` para quitar las filas con datos incompletos de un `DataFrame` y crear un nuevo `DataFrame` o mutar el original en su lugar.
+
+y = dropmissing(x)
+dropmissing!(x)
+[x, y]
+
+# Cuando llamamos `showcols` en un `DataFrame` con valores faltantes que les hicimos `drop`, las columnes siguen permitiendo valores faltantes.
+
+showcols(x)
+
+# Como ya excluimos los valores faltantes, podemos usar `disallowmissing!` con seguridad para que las columnas ya no puedan aceptar valores faltantes.
+
+disallowmissing!(x)
+showcols(x)
+