[WIP] Portuguese tutorials

literate_notebooks/src-PT-BR/01_constructors.jl

@@ -0,0 +1,144 @@
+# # Introdução ao DataFrames
+# **[Bogumił Kamiński](http://bogumilkaminski.pl/about/), 23 de Maio de 2018**
+#
+# Tradução de [Jose Storopoli](https://storopoli.io).
+#
+# Vamos começar carregando o pacote `DataFrames`
+
+using DataFrames
+
+# ## Construtores e conversões
+
+# -
+
+# ### Construtores
+#
+# Nesta seção, você verá as diferentes maneiras de criar um `DataFrame` usando o construtor `DataFrame()`
+#
+# Primeiramente, é possível criar um `DataFrame` vazio
+
+DataFrame() # DataFrame vazio
+
+# Podemos também passar argumentos de palavras-chave (*keyword arguments*) no construtor para adicionar colunas ao `DataFrame`.
+
+DataFrame(A=1:3, B=rand(3), C=randstring.([3,3,3]))
+
+# Podemos criar um `DataFrame` a partir de um dicionário, caso em que as chaves do dicionário serão usadas para criar as colunas do `DataFrame`.
+
+x = Dict("A" => [1,2], "B" => [true, false], "C" => ['a', 'b'])
+DataFrame(x)
+
+# Em vez de criar explicitamente um dicionário primeiro, como acima, poderíamos passar argumentos `DataFrame` com a sintaxe dos pares chave-valor do dicionário.
+#
+# Observe que, neste caso, usamos símbolos para denotar os nomes das colunas e os argumentos não são ordenados. Por exemplo, o símbolo `:A`produz`A` que será o nome da primeira coluna aqui:
+
+DataFrame(:A => [1,2], :B => [true, false], :C => ['a', 'b'])
+
+# Aqui criamos um `DataFrame` a partir de um vetor de vetores, e cada vetor se torna uma coluna.
+
+DataFrame([rand(3) for i in 1:3])
+
+# Por enquanto, podemos construir um único `DataFrame` a partir de um `Vector` atômico, criando um `DataFrame` com uma única linha. Em versões futuras de DataFrames.jl, isso gerará um erro.
+
+DataFrame(rand(3))
+
+# Em vez disso, use um vetor transposto se você tiver um vetor atômico (dessa forma, você passa efetivamente uma array bidimensional para o construtor o que é compatível).
+
+DataFrame(transpose([1, 2, 3]))
+
+# Passe um segundo argumento para dar nomes às colunas.
+
+DataFrame([1:3, 4:6, 7:9], [:A, :B, :C])
+
+# Aqui nós criamos um `DataFrame` de uma matriz,
+
+DataFrame(rand(3, 4))
+
+# e aqui nós fazemos o mesmo mas também passando nomes de colunas.
+
+DataFrame(rand(3, 4), Symbol.('a':'d'))
+
+# Podemos também construir um `DataFrame` não-inicializado.
+#
+# Aqui passamos os tipos de coluna, nomes e número de linhas; obtemos `missing` na coluna `:C` porque `Any >: Missing`.
+
+DataFrame([Int, Float64, Any], [:A, :B, :C], 1)
+
+# Aqui criamos um `DataFrame`, mas a coluna`:C` é #undef e o Jupyter tem problemas para exibi-la. (Isso funciona OK no REPL.)
+#
+# Isto será consertado na próxima versão do DataFrames!
+
+DataFrame([Int, Float64, String], [:A, :B, :C], 1)
+
+# Para inicializar um `DataFrame` com nomes de colunas, mas sem linhas use
+
+DataFrame([Int, Float64, String], [:A, :B, :C], 0)
+
+# Essa sintaxe permite uma maneira rápida de criar um `DataFrame` homogêneo:
+
+DataFrame(Int, 3, 5)
+
+# Esse exemplo é similar, mas possui colunas não-homogêneas.
+
+DataFrame([Int, Float64], 4)
+
+# Finalmente, podemos criar um `DataFrame` copiando um `DataFrame` existente.
+#
+# Note que `copy` cria uma cópia raza.
+
+y = DataFrame(x)
+z = copy(x)
+(x === y), (x === z), isequal(x, z)
+
+# ### Conversões para Matrizes
+#
+# Vamos começar criando um `DataFrame` com duas linhas e duas colunas.
+
+x = DataFrame(x=1:2, y=["A", "B"])
+
+# Podemos criar uma matriz passando esse `DataFrame` para `Matrix`.
+
+Matrix(x)
+
+# Isso funciona mesmo se `DataFrame` possuir alguns `missing`s:
+
+x = DataFrame(x=1:2, y=[missing,"B"])
+
+# -
+
+Matrix(x)
+
+# Nos dois exemplos de matriz anteriores, Julia criou matrizes com elementos do tipo `Any`. Podemos ver mais claramente que o tipo de matriz é inferido quando passamos, por exemplo, um `DataFrame` de inteiros para`Matrix`, criando um `Array` 2D de `Int64`s:
+
+x = DataFrame(x=1:2, y=3:4)
+
+# -
+
+Matrix(x)
+
+# No próximo exemplo, Julia identifica corretamente que `Union` é necessário para expressar o tipo resultante de `Matrix` (que contém `missing`s).
+
+x = DataFrame(x=1:2, y=[missing,4])
+
+# -
+
+Matrix(x)
+
+# Note que não conseguimos forçar uma conversão de valores `missing` para `Int`s!
+
+Matrix{Int}(x)
+
+# ### Lidando com nomes de colunas duplicados
+#
+# Nós podemos passar o argumento de palavra-chave `makeunique` para permitir o uso de nomes duplicados de colunas (eles serão "deduplicados")
+
+df = DataFrame(:a => 1, :a => 2, :a_1 => 3; makeunique=true)
+
+# Caso contrário, nomes duplicados não serão permitidos no futuro.
+
+df = DataFrame(:a => 1, :a => 2, :a_1 => 3)
+
+# Um construtor que recebe nomes de coluna como argumentos de palavra-chave é um caso excepcional.
+# Não é permitido usar `makeunique` aqui para permitir nomes duplicados.
+
+df = DataFrame(a=1, a=2, makeunique=true)

literate_notebooks/src-PT-BR/02_basicinfo.jl

@@ -0,0 +1,77 @@
+# # Introdução ao DataFrames
+# **[Bogumił Kamiński](http://bogumilkaminski.pl/about/), 23 de Maio de 2018**
+#
+# Tradução de [Jose Storopoli](https://storopoli.io).
+
+using DataFrames # carregar o pacote
+
+# ## Obtendo informações básicas sobre um data frame
+#
+# Vamos começar criando um objeto `DataFrame`, `x`, para que possamos aprender como obter informações sobre um data frame.
+
+x = DataFrame(A=[1, 2], B=[1.0, missing], C=["a", "b"])
+
+# A função padrão `size` é uma maneira de obter as dimensões do `DataFrame`,
+
+size(x), size(x, 1), size(x, 2)
+
+# assim como `nrow` e `ncol` oriundas do R; `length` retorna o número de colunas.
+
+nrow(x), ncol(x), length(x)
+
+# `describe` retorna estatísticas descritivas básicas dos dados do seu `DataFrame`.
+
+describe(x)
+
+# Use `showcols` para conseguir informações sobre as colunas armazenadas em um DataFrame.
+
+showcols(x)
+
+# `names` retornará os nomes de todas as colunas,
+
+names(x)
+
+# e `eltypes` retorna os seus tipos.
+
+eltypes(x)
+
+# Vamos criar um DataFrame grande
+
+y = DataFrame(rand(1:10, 1000, 10));
+
+# com isso podemos usar `head` para ter uma visão rápida das linhas superiores
+
+head(y)
+
+# e `tail` para ver suas linhas inferiores.
+
+tail(y, 3)
+
+# ### As funções *get* e *set* mais elementares
+#
+# Dado o `DataFrame` `x`, aqui estão três maneiras de capturar uma de suas colunas como um `Vector`:
+
+x[1], x[:A], x[:, 1]
+
+# Para capturar apenas uma linha como `DataFrame`, podemos indexar assim:
+
+x[1, :]
+
+# Podemos capturar uma única célula ou elemento com a mesma sintaxe usada para capturar um elemento de uma array.
+
+x[1, 1]
+
+# Atribuição pode ser feita em intervalos para um escalar,
+
+x[1:2, 1:2] = 1
+x
+
+# ou para um vetor de comprimento igual ao número de linhas atribuídas,
+
+x[1:2, 1:2] = [1,2]
+x
+
+# ou para outro data frame de tamanho correspondente.
+
+x[1:2, 1:2] = DataFrame([5 6; 7 8])
+x

literate_notebooks/src-PT-BR/03_missingvalues.jl

@@ -0,0 +1,113 @@
+# # Introdução ao DataFrames
+# **[Bogumił Kamiński](http://bogumilkaminski.pl/about/), 23 de Maio de 2018**
+#
+# Tradução de [Jose Storopoli](https://storopoli.io).
+
+using DataFrames # carregar o pacote
+
+# ## Lidando com valores faltantes
+#
+# Um tipo de *singleton* `Missings.Missing` nos permite lidar com valores ausentes.
+
+missing, typeof(missing)
+
+# As arrays criam automaticamente um tipo de união `Union` apropriado.
+
+x = [1, 2, missing, 3]
+
+# `ismissing` verifica se o valor passado é faltante (`missing`).
+
+ismissing(1), ismissing(missing), ismissing(x), ismissing.(x)
+
+# Podemos extrair o tipo combinado com `Missing` de uma `Union` por meio de
+#
+# (Isso é útil para matrizes!)
+
+eltype(x), Missings.T(eltype(x))
+
+# comparações de `missing` produzem `missing`.
+
+missing == missing, missing != missing, missing < missing
+
+# Isso também ocorre quando os `missing`s são comparados com valores de outros tipos.
+
+1 == missing, 1 != missing, 1 < missing
+
+# `isequal`, `isless`, e `===` produzem resultado de tipo `Bool`.
+
+isequal(missing, missing), missing === missing, isequal(1, missing), isless(1, missing)
+
+# Nos próximos exemplos, vemos que muitas (mas não todas) funções coseguem lidar com `missing`.
+
+map(x -> x(missing), [sin, cos, zero, sqrt]) # parte 1
+
+# -
+
+map(x -> x(missing, 1), [+, - , *, /, div]) # parte 2
+
+# -
+
+map(x -> x([1,2,missing]), [minimum, maximum, extrema, mean, any, float]) # parte 3
+
+# `skipmissing` retorna um iterador ignorando os valores `missing`s. Podemos usar `collect` e `skipmissing` para criar um array que exclui esses valores `missing`s.
+
+collect(skipmissing([1, missing, 2, missing]))
+
+# Da mesma forma, aqui combinamos `collect` e `Missings.replace` para criar uma array que substitui todos os valores `missing`s por algum valor (`NaN` neste caso).
+
+collect(Missings.replace([1.0, missing, 2.0, missing], NaN))
+
+# Uma outra maneira de fazer o mesmo:
+
+coalesce.([1.0, missing, 2.0, missing], NaN)
+
+# Cuidado: `nothing` também seria substituído aqui (para Julia 0.7 um comportamento mais sofisticado de `coalesce` que permite evitar este problema está planejado).
+
+coalesce.([1.0, missing, nothing, missing], NaN)
+
+# Você pode usar `recode` se tiver tipos de saída homogêneos.
+
+recode([1.0, missing, 2.0, missing], missing => NaN)
+
+# Você pode usar `unique` ou `levels` para obter valores únicos com ou sem `missing`s, respectivamente.
+
+unique([1, missing, 2, missing]), levels([1, missing, 2, missing])
+
+# No próximo exemplo, convertemos `x` em `y` com `allowmissing`, onde `y` tem um tipo que aceita `missing`s.
+
+x = [1,2,3]
+y = allowmissing(x)
+
+# Então, nós convertemos de volta com `disallowmissing`. Isso falharia se `y` contivesse valores `missing`!
+
+z = disallowmissing(y)
+x, y, z
+
+# No próximo exemplo, mostramos que o tipo de cada coluna de `x` é inicialmente `Int64`. Depois de usar `allowmissing!` Para aceitar valores `missing`s nas colunas 1 e 3, os tipos dessas colunas se tornam `Union`s de `Int64` e `Missings.Missing`.
+
+x = DataFrame(Int, 2, 3)
+println("Antes: ", eltypes(x))
+allowmissing!(x, 1) # fazer com que a primeira coluna aceite `missing`s
+allowmissing!(x, :x3) # fazer com que a coluna `:x3` aceite `missing`s
+println("Depois: ", eltypes(x))
+
+# Neste próximo exemplo, usaremos `completecases` para encontrar todas as linhas de um `DataFrame` que possuem dados completos.
+
+x = DataFrame(A=[1, missing, 3, 4], B=["A", "B", missing, "C"])
+println(x)
+println("Casos completos:\n", completecases(x))
+
+# Podemos usar `dropmissing` ou `dropmissing!` para remover as linhas com dados incompletos de um `DataFrame` para criar um novo `DataFrame` ou modificar o original *in-place*.
+
+y = dropmissing(x)
+dropmissing!(x)
+[x, y]
+
+# Quando usamos `showcols` em um `DataFrame` eliminando os valores `missing`s, as colunas ainda permitem valores `missing`s.
+
+showcols(x)
+
+# Uma vez que excluímos valores valores `missing`s, podemos usar com segurança `disallowmissing!` para que as colunas não aceitem mais valores `missing`s.
+
+disallowmissing!(x)
+showcols(x)