Curso

Home

1. Descrição

Fico grato por se interessar pelo curso. O fluxo de dados hodierno exige uma capacitação de manipulação dos mesmos para fins de: predição, interpretação, análises, entre outros. Este curso tem por objetivo promover a familiarização do interlocutor ao ambiente do RStudio, a fim de conhecer suas possibilidades. Irei trabalhar com processos básicos no R, como também processos Estatísticos inferenciais e descritivos, por meio de medidas quantitativas e amostrais. Com uma base teórica sólida, por meio do material, o aluno poderá aplicar habilidades necessárias para resolução de problemas práticos.

2. Conhecendo o R

Para um desenvolvimento intuitivo com o curso, o interlocutor poderá instalar o R em seu dispositivo. ATENÇÃO: é necessário instalar o R GUI primeiro, para assim instalar o RStudio!

Identifique o seu Sistema Operacional. Após identificado, entre no link de acordo com o seu SO. Siga as instruções fornecidas para cada documentação, leia os termos de uso para assim instalar o R em seu dispositivo. Instale primeiro o R GUI e posteriormente o RStudio.

2.1 R GUI vs. RStudio

Podemos encontrar algumas possibilidades para desenvolver os scripts em R. Dentre as possibilidades, encontramos o R GUI e o Rstudio. De modo geral, com vantagem sob o R GUI, o RStudio apresenta um ambiente totalmente amigável com informações organizadas, com falicidade de acesso para várias guias, entre outros. Por fim, usarei o RStudio, mas fique a vontade para utilizar qualquer um :)

2.2 Links

Windows
R GUI
RStudio (Open Source)
MAC
R GUI
RStudio (Open Source)
Linux
Versões disponíveis até o momento (08/2020): Debian, Fedora, Ubuntu, Suse e Redhat.
R GUI
RStudio (Open Source)

2.3 A interface do RStudio

Com o RStudio aberto, encontramos seções divididas em 4 telas. Nelas encontramos o ambiente, onde podemos encontrar nossas variáveis, o histórico de cógidos e nossas conecxões. Já no suporte podemos encontrar todos os pacotes instalados no nosso dispotivo (irei comentar deles posteriormente :)), como também a visualização dos plots, do diretório e a aba “help”. Diretamente no console podemos executar códigos livremente, entretanto, sua comunicação e resposta é imediata ao apertar “enter” (não temos como visualizar e alterar um script de várias linhas). Por fim, no espaço de scripts é onde programamos todos os nossos códigos e afins, nele executamos o código selecionando ele e apertando Ctrl+ENTER.

2.4 Criando um R Notebook

Para um visual mais limpo, podemos criar um R Notebook. Nele podemos dividir nossos códigos em blocos e executá-los separadamente. Para criar um basta ir em File>New File>R Notebook.

2.5 Declarando variáveis

Durante a produção dos nossos códigos, constantemente precisaremos declarar valores e armazená-los em variáveis. São úteis para guardar resultados para futuras operações/manipulações e visualizações.

x = 1 #Lê-se: x recebe 1
y <- 2 #Lê-se: y recebe 2
x #Visualizar a variável no console

## [1] 1

print(y) #Visualizar a variável no console

## [1] 2

2.6 Pacotes

2.6.1 Conhecendo os pacotes

No repositório do CRAN podemos encontrar vários pacotes que a comunidade disponibiliza.
Mas o que são pacotes?

Quando trabalhamos com o R, geralmente precisamos de funcionalidades que tão além das funções nativas no próprio R. Justamente por esse motivo que há milhares de pacotes disponíveis no repositório! Tidyverse, dplyr, ggplot2, tidyr são alguns dos milhares de disponíveis. Recomendo que leia a documentação daquele que te interessar. É claro, não precisa ler sobre todos, mas se disponha a conhecer aqueles que te interessar :). Clique no link para conhecer mais sobre os pacotes.

2.6.2 Utilizando os Pacotes

Quando instalamos o RStudio, o mesmo já vem com alguns pacotes instalados nativamente. Esses pacotes ficam armazenados no diretório ondee você orientou na instalação para o realocar os repositórios.Para instalar um pacote, utilizamos o comando install.packages("nome do pacote", dependencies = T), onde entre aspas é o nome do pacote, e dependencies = TRUE siginifica a instalação respectiva de possíveis dependências que um pacote possa ter. Essa é a maneira mais simples de instalar um pacote do repositório CRAN, para instalar pacotes do GitHub utilize a função devtools::install_github().
Ao necessitar da utilização do pacote, podemos carregá-lo ao momento em que precisamos utilizando a função library(nome do pacote) ou require(). A partir do momento em que você fechar o RStudio, seja pela função close() ou pelo “xzinho”, o pacote será descarregado. Podemos também, utilizar apenas uma função do pacote, caso a capacidade de memória seja limitada. Para isso utilizamos nome_do_pacote::função(). Caso necessitamos rodar um código dependente de um pacote, é usual utilizar: if(!require(nome_do_pacote)) install.packages("nome_do_pacote")
E caso você precise saber a documentação de um pacote específico, basta utilizar o comando browseVignettes(), onde, entre parênteses, é passado o nome do pacote entre aspas.

2.7 Funções Básicas

help(mean) #Função ajuda
?mean #Função ajuda
#Ou apenas, pressione "F1" 
citation() #Como citar o R em referências
ls() #Todas as variáveis decladaras
rm(a) #Remover uma varíavel
rm(list=ls()) #Remover todas as variáveis
getwd() #Diretório ativo no momento
setwd() #Alterar o diretório

3. Operadores

3.1 Operadores lógicos

3.2 Operadores Aritméticos

3.3 Prática

#Armazenando valores nas variáveis
#Podemos usar o = ou o <-
s = 2 
v = 3

resultado = s + v #Armazenando a operação em uma variável
resultado #Visualizando o resultado

## [1] 5

s - v #Subtração

## [1] -1

s/v #Divisão

## [1] 0.6666667

s*v #Multiplicação

## [1] 6

s**v #Potência

## [1] 8

s^v #Potência

## [1] 8

s^2 #Potência

## [1] 4

sqrt(s) #Raiz Quadrada

## [1] 1.414214

s > v #Operador lógico "maior que"

## [1] FALSE

s==v  #Operador lógico "exatamente igual a"

## [1] FALSE

v > s #Operador lógico "maior que"

## [1] TRUE

s <= 3 #Operador lógico "menor ou igual a"

## [1] TRUE

s != v #Operador lógico "diferente de"

## [1] TRUE

s & 1 < v #Operador lógico "elemento E elemento são menores que"

## [1] TRUE

(s | 3) > 1 #Operador lógico "elemento OU elemento são maiores que". Observe que, apesar do 3 ser maior que 1, a variável s não é! O R prioriza os valores FALSE.

## [1] FALSE

4. Algumas Classes/Estruturas

Quando declaramos variáveis, as mesmas admitem classes e tipos diferentes. Existem mais de 20 estruturas disponíveis para que possamos trabalhar. Estou listando abaixo as principais:

a = 1.5 #Numeric/Dobule (Assumimos como todos os valores Reais)

b = 1L #Integer (Assumimos como todo e qualquer valor Inteiro)

c = TRUE #Booleano/Logical (Valores lógicos)

Quando tratamos de valores boobleanos, atribuímos como:
TRUE = 1 (100%)
FALSE = 0 (0%)

d = "Palavra" #Character 

e = 1 + 3i #Complex

idade = 18
class(idade) #Visualizando a classe da idade

## [1] "numeric"

t = as.factor(idade) #Alterando a classe/tipo

class(t)

## [1] "factor"

5. O retorno de mensagens

Geralmente quando queremos que uma mensagem ou variável retorne no console, utilizamos a função print() ou paste().

print("Alguma coisa") #Retorna somente character ou uma variável

## [1] "Alguma coisa"

nome = "Matheus"
idade = 18

paste("Olá tudo bem? Meu nome é", nome, "e eu tenho", idade, "anos.") #Permite juntar character e numeric

## [1] "Olá tudo bem? Meu nome é Matheus e eu tenho 18 anos."

paste0("Olá tudo bem?", nome) #Concatena qualquer coisa (sem espaços)

## [1] "Olá tudo bem?Matheus"

6. Vetores

6.1 O que são vetores?

Os vetores são basicamente matrizes compostas por apenas uma coluna, de ordem nx1. Quando temos um vetor 1x1 o chamamos de escalar. ¹ Quando trabalhamos com uma Linguagem como o R, imergimos constantemente no âmbito matricial. De fato, não é necessário um conhecimento profundo sobre esse ambiente para manusear, mas recomendo fortemente um estudo limiar sobre álgebra linear. Tenho duas indicações totalmente gratuitas, por meio audiovisual, que você pode aprender :). Primeiro, uma playlist no youtube do canal 3Blue1Brown (os vídeos possuem legenda, caso não tenha facilidade em entender o inglês). Como também um material fantástico do Khan Academy sobre álgebra linear.

6.2 Vetores no R

Para criar um vetor no R, utilizamos a função c(), implementamos valores separados por vírgula “,”. Basicamente fazemos a combinação de unidades, entretanto, vale salientar que os vetores NÃO são flexíveis com suas classes. Por exemplo, quando criamos um vetor apenas com números, a classe geral do vetor é numeric. Entretanto, se adicionarmos uma unidade character, o vetor todo se transforma em character!

vetor1 = c(1,5,6) #vetor numérico
vetor2 = c("A","B","C") #vetor character
vetor3 = c(TRUE,FALSE,T) #vetor lógico

str(vetor3) #Resumo prático do vetor

##  logi [1:3] TRUE FALSE TRUE

6.3 Manipulando vetores

Quando criamos um vetor, há situações em que precisamos acessar as posições, acessar os valores por uma condição lógica ou precisamos acrescentar valores. Para essas situações, podemos acessar posições utilizando os colchetes vetor[1]. Nessa ocasião, o valor que estará dentro dos colchetes se refere à posição do valor.
Caso queremos atribuir uma condição lógica, podemos utilizar os operadores lógicos. vetor[vetor > 0], nesse exemplo percebemos que estamos extraindo todos os valores do vetor que são maiores que 0.

Para tornar mais didático, imagine um vetor = c(-1, 2, 4, -10). Observe que os valores menores ou iguais a 0 são -1 e -10. Se eu rodar o script vetor > 0, ele retornará: FALSE, TRUE, TRUE, FALSE. Perceba que, ele retorna um valor booleano.

Portanto, na condição vetor[vetor > 0], estamos dizendo para o script buscar as posições que são verdadeiras TRUE. Basicamente: vetor[c(FALSE, TRUE, TRUE, FALSE)]. Diante disso, retornará no console as posições 2 e 3, ou seja, os valores 2 e 4.

Quando queremos acrescentar um valor, podemos atribuir uma posição a mais do tamanho do vetor. Imagine que um vetor tenha tamanho 3. Caso quiséssemos acrescentar a posição 4, basta rodar: vetor[4] = 1. Nesse caso, estamos acrescentando o número 1 à posição 4. O mesmo vale para alterar valores, como por exemplo: vetor[3] = 50. Nesse caso, a posição 3 está sendo alterada para o valor 50. Podemos também colocar valores negativos, indicando a impressão de todo o vetor menos a posição indicada.

vetor1[1] #Primeira posição do meu vetor

## [1] 1

vetor1[vetor1%%2 == 1] #Atribuição lógica

## [1] 1 5

vetor1[4] = 10 #Acrescentando valores ao vetor

vetor1[-1] #Retorna todo o vetor, menos a primeira posição

## [1]  5  6 10

6.4 Operações com vetores

Ao criar vetores, podemos necessitar de realizar operações com os mesmos.
Para realizar a soma de todos os valores de um vetor, basta utilizar a função sum. Entretanto, caso você queira realizar a soma de cada elemento entre dois vetores, podemos apenas somá-los: vetor1 + vetor2. Para multiplicar um vetor por um escalar, podemos apenas multiplicá-lo vetor1 * 3. Podemos concatenar vetores, apenas com a função c(). Caso queira conhecer mais sobre as operações, recomendo este documento da Ecologia da USP.

vetor1 = c(1,2)
vetor2 = c(10,20)
sum(vetor1) #Somando todos os elementos do vetor1

## [1] 3

vetor1 + vetor2 #Somando vetor com vetor

## [1] 11 22

vetor1*2 #Multiplicando um vetor por um escalar

## [1] 2 4

concatenar = c(vetor1,vetor2) #vetor dentro de vetor
concatenar

## [1]  1  2 10 20

6.5 A criação de sequências

Por vezes, precisamos criar sequências. Um jeito bem simples de criar uma sequência é utilizando a notação :, onde antes colocamos o valor inicial e depois o valor final da nossa sequência. Essa notação gera uma sequência linear de 1 em 1.
Podemos, também, utilizar a função rep() para gerar a repetição de um valor por uma determinada unidade. Ademais, podemos usar a função seq() para gerar uma sequência com início, fim, e “step” (de quanto em quanto).

x = 1:10 #Criando uma sequência simples em vetor, valor inicial:valor final
x

##  [1]  1  2  3  4  5  6  7  8  9 10

y = rep(1,5) #sistema de repetição
y

## [1] 1 1 1 1 1

seq(1,100, 2) #sequência de 1 a 100, iniciando em 1 pulando de 2 em 2

##  [1]  1  3  5  7  9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49
## [26] 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99

6.6 Encontrando a posição de um elemento

Há momentos em que o nosso vetor abrange uma quantidade exorbitante de elementos, e queremos achar o valor da posição de um elemento qualquer. Para tal situação, utilizamos a função which().

vetor = c(5,9,8,7,6,4,0,10,59,98,99,48,56,20,15,35,674,7485,41,6985,41,41,8541,96,854196,8541,69541,65,41,65241,652,41,52,1,52,152,15,1,51,5,465,5,416,2,65,4,897,498,54,658,416,52,136,524,65,46,521,32,84,654,165) #Criando um vetor

which(vetor == 524) #Encontrando a posição do elemento 524

## [1] 54

7. Listas

7.1 O que são listas?

Em paralelo com os vetores, as listas são cojuntos de unidades geradas no R. Diferentemente do vetor, as listas oferecem suporte para todos os tipos de estruturas sem a alteração por completo. Justamente por esse fator, encontramos uma flexibilidade maior com o seu manuseio. Nelas, podemos agrupar argumentos de todas as classes, como também podemos agrupar vetores de diferentes classes.

7.2 Como criar uma lista?

Podemos criar uma lista no R utilizando o comando list(). Seus parâmetros podem ser qualquer tipo de valor ou estrutura.

vetor4 = c(1,2,3) #Criando um vetor numérico
vetor5 = c("Matheus", "Llorente") #Criando um vetor com character

lista = list(vetor4, vetor5) #Juntando os vetores sem alterar sua estrutura
lista

## [[1]]
## [1] 1 2 3
## 
## [[2]]
## [1] "Matheus"  "Llorente"

7.3 Manipulação de listas

De uma maneira parecida com os vetores, podemos fazer uma busca direta com posições. Entretanto, como temos vetores ao invés de valores unitários, nas listas fazemos uma busca como: [[POSIÇÃO]]. O valor da posição se remete à posição em que o vetor está na lista. Para buscar posições dentro dos vetores das listas, utilizamos mais um colchete: lista[[POSIÇÃO DO VETOR]][POSIÇÃO NO VETOR]
Observe

lista[[1]] #Extraindo o primeiro vetor da lista

## [1] 1 2 3

lista[[1]][2] #Extraindo a segunda posição do primeiro vetor da lista

## [1] 2

8. Matrizes

8.1 O que é uma matriz?

Continuando com a álgebra linear, entramos no conceito de matriz. De modo geral, uma matriz A é composta por N elementos, com uma ordem m x n, sendo que m representa o número de linhas de uma matriz e n o número de colunas de uma matriz, em que m e n são números naturais. Utilizamos elas em vários âmbitos, desde a ampliação matricial de coeficientes de um sistema linear, montagens de fluxos de circuitos elétricos, até a Machine Learning e Deep Learning (Nesses ambientes entra o conceito de um tensor). Sua utilidade é infinita, e recorrentemente utilizamos elas em nossos modelos.²

8.2 A matriz no R

As matrizes no R são paralelas com os vetores. Uma de suas características é o fato de não aceitar mais de um tipo de estrutura/classe. Para criar uma matriz, utilizaremos a função matrix().

x = c(1:10) #Criando um vetor
 
z = matrix(x, nrow = 2, ncol = 5, byrow = F) #Transformando em matriz
p = matrix(x, nrow = 2, ncol = 5, byrow = T) #Criando uma matriz 

#Primeira instância: Colocar o "data", o vetor que vai virar matriz
#Segunda instância: Colocar o número de linhas
#Terceira instância: Colocar o número de colunas
#Observação: o número de linhas vezes o número de colunas deve ser igual ao tamanho do meu vetor
#Quarta instância: ordenar por linhas (byrow = T) ou colunas (byrow = F)

z #A matriz

##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    3    5    7    9
## [2,]    2    4    6    8   10

8.3 Manipulando matrizes

Da mesma forma com os vetores, ao criar uma matriz surgem situações em que precisamos acessar as posições, acessar os valores por uma condição lógica ou precisamos acrescentar valores. Para essas situações, podemos acessar posições utilizando os colchetes matriz[1]. Nessa ocasião, o valor que estará dentro dos colchetes se refere à posição do valor. Entretanto, em uma matriz a ordenação de posição inicia da primeira coluna elemento por elemento até a última coluna. De modo didático, vamos partir do exemplo da matriz p anterior.

p

##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    2    3    4    5
## [2,]    6    7    8    9   10

p[5] #Posição

## [1] 3

Observe que a quinta posição corresponde justamente ao número 3. Ou seja, partindo da primeira coluna, a quina posição é o número 3.

Em paralelo com as posições, podemos extrair valores através da sua coordenada. Assim como a ordem de uma matriz é m por n, no colchetes podemos colocar o número da linha e o número da coluna de um elemento. Para isso, colocamos uma vírgula para separar linha de coluna nos colchetes, ou seja, `matriz[número da linha , número da coluna]. Caso nosso objetivo seja extrar apenas uma coluna ou uma linha, apenas não escrevemos nada antes ou depois da vírgula, assim indicando o valor que queremos.

p[1,2] #Coordenada

## [1] 2

p[1,] #Retorna a primeira linha

## [1] 1 2 3 4 5

p[,1] #Retorna a primeira coluna

## [1] 1 6

p[-1,] #Tudo menos a primeira linha

## [1]  6  7  8  9 10

Caso queremos atribuir uma condição lógica, podemos utilizar os operadores lógicos. matriz[matriz > 0], nesse exemplo percebemos que estamos extraindo todos os valores da matriz que são maiores que 0.

z[ z > 0 ] #Atribuição lógica

##  [1]  1  2  3  4  5  6  7  8  9 10

Na condição matriz[matriz > 0], estamos dizendo para o script buscar as posições que são verdadeiras TRUE.

8.4 Atribuindo nomes às colunas e às linhas

colnames(z) = c("Coluna1", "Coluna2", "Coluna3", "Coluna4", "Coluna5") #Atribuindo nomes as colunas
rownames(z) = c("Linha1", "Linha2") #Atribuindo nomes as linhas
z

##        Coluna1 Coluna2 Coluna3 Coluna4 Coluna5
## Linha1       1       3       5       7       9
## Linha2       2       4       6       8      10

8.5 Multiplicando elemento por elemento de matrizes

p

##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    2    3    4    5
## [2,]    6    7    8    9   10

z

##        Coluna1 Coluna2 Coluna3 Coluna4 Coluna5
## Linha1       1       3       5       7       9
## Linha2       2       4       6       8      10

p*z #Multiplicação de elementos equivalentes entre as matrizes

##        Coluna1 Coluna2 Coluna3 Coluna4 Coluna5
## Linha1       1       6      15      28      45
## Linha2      12      28      48      72     100

8.6 Multiplicação de matrizes no R

Para multiplicarmos matrizes precisamos ficar atentos que o produto da matriz AB é definido apenas quando o número de colunas em A é igual ao número de linhas em B. Da mesma forma, o produto da matriz BA é definido apenas quando o número de colunas em B é igual ao número de linhas em A.³

a = matrix(x, nrow = 2, ncol = 5, byrow = F)
b = matrix(x, nrow = 5, ncol = 2, byrow = F)

a%*%b #Multiplicação matricial

##      [,1] [,2]
## [1,]   95  220
## [2,]  110  260

8.7 Matriz inversa no R

y = c(1:4)
c = matrix(y, nrow = 2, ncol = 2, byrow = F)
solve(c) #Matriz inversa

##      [,1] [,2]
## [1,]   -2  1.5
## [2,]    1 -0.5

9. Dataframes

9.1 O que são Dataframes?

Por geral, de maneira grossa podemos enxergar um dataframe como uma planilha do Excel. Eles são basicamente tabelas de uma base de dados, sendo cada coluna correspondente à uma variável e cada linha à um registro do banco de dados. Sua aparência é bem similar à de uma matriz, entretanto há uma flexibilidade maior com relação à estrutuda de seus dados. Podemos encontrar em um único dataframe várias classes diferentes. Essa característica torna o mesmo extremamente útil para processos de análises de dados. ⁴

9.2 Dataframes no R

Quando tratamos de dataframes, precisamos da disposição de dados em formatos de vetores. Primordialmente, utilizamos a função data.frame() em que passamos vetores como parâmetros.

meux = c("A", "B", "C") #Vetor
meuy = c(1:3) #Vetor

meudata = data.frame(meux, meuy) #Criação do dataframe

9.3 Manipulando Dataframes

Diante dessa estrutura, seguimos os mesmos parâmetros de slicing (processo de manipulação). Entretanto, vale ressaltar que as posições agora assumem apenas as posições das colunas. Saliento, também, que é possível fazer uma busca colocando o nome do dataframe, cifrão e o nome da coluna data$coluna. Usarei frequentemente essa notação, dito que os mesmos retornar um vetor com os valores. Esse processo facilita na análise de dados.

meudata[2] #Posição da coluna (perceba que o data.frame atribui as colunas como posições, e retorna como coluna)

##   meuy
## 1    1
## 2    2
## 3    3

meudata$meuy #Retorna a coluna y em valores

## [1] 1 2 3

meudata[1,2] #Coordenada

## [1] 1

meudata[1,] #Retorna a primeira linha

##   meux meuy
## 1    A    1

meudata[,1] #Retorna a primeira coluna

## [1] A B C
## Levels: A B C

meudata[-1] #Tudo menos a primeira posição (note que a primeira posição é a primeira coluna INTEIRA)

##   meuy
## 1    1
## 2    2
## 3    3

meudata[-1,] #Tudo menos a primeira linha

##   meux meuy
## 2    B    2
## 3    C    3

9.3.1 Extraindo uma coluna

g = meudata$meuy #Atribuindo os valores da coluna a uma variável
g*2 #Multiplicando todos os valores por 2

## [1] 2 4 6

g[g%%2 == 1] #Atribuição lógica

## [1] 1 3

9.3.2 Nomeando as colunas

colnames(meudata) = c("Coluna1", "Coluna2") #Atribuindo nomes as colunas

9.3.3 Adicionando colunas

meudata[3] = c(4,5,6) #Adicionando uma nova coluna ao dataframe

9.4 Estudando o Dataframe

Geralmente, quando temos um dataset em mãos, procuramos um resumo geral de suas características. Essas informações podem ser elucidadas utilizando a função str(), ou a função glimpse(), do pacote dplyr. De forma mais clara, irei utilizar as duas funções no meudata.

str(meudata)

## 'data.frame':    3 obs. of  3 variables:
##  $ Coluna1: Factor w/ 3 levels "A","B","C": 1 2 3
##  $ Coluna2: int  1 2 3
##  $ V3     : num  4 5 6

if(!require(dplyr)) install.packages("dplyr")

## Loading required package: dplyr

## 
## Attaching package: 'dplyr'

## The following objects are masked from 'package:stats':
## 
##     filter, lag

## The following objects are masked from 'package:base':
## 
##     intersect, setdiff, setequal, union

dplyr::glimpse(meudata)

## Rows: 3
## Columns: 3
## $ Coluna1 <fct> A, B, C
## $ Coluna2 <int> 1, 2, 3
## $ V3      <dbl> 4, 5, 6

9.5 Salvando o Dataframe

Quando criamos um dataframe, fazemos suas análises, processamos os dados e queremos salvar esses resultados em um csv. Para isso, usamos a função write.table(nome_do_data, row.names = FALSE, file = "nome_do_data.csv", sep=";"). Observe que neste comando estamos definindo: o nome do dataframe, não queremos nomes nas linhas (esse parâmetros é importante, para que o seu cabeçalho não fique desorganizado), o nome do arquivo e sua extensão (csv) e também o separador. O arquivo será salvo no diretório atual (irei comentar sobre ele nos próximos tópicos).

write.table(meudata, row.names = FALSE, file="meudataa.csv", sep=";")

10. Importando Datasets

Ao invés de criar um dataframe, você precisa importar uma tabela já pronta? Sem preocupações! No R conseguimos importar datasets de vários lugares, como o SQL, Excel, aquivos txt, entre outros. Nesse caso irei focar nos 3 principais.

10.1 O diretório

É importante salientar que, quando importamos um dataset diretamente pelo código necessitamos da presença do arquivo em nosso diretório. Caso você não saiba seu diretório atual, basta executar o comando getwd(). Para alterar o diretório, utilizamos o comando setwd(), sendo que o parâmetro é o camanho do diretório onde está seu arquivo. Se você está utilizando o RStudio, é possível realizar esse processo sem o código. Basta ir em Session>Set Working Directory>Choose Directory.

10.2 Carregando o pacote “readr”

Por fins de facilitar o processo, iremos utilizar o pacote readr do R. É um pacote nativo, basta carregá-lo na sua sessão para sua utilização. Carregamos ele com a função library(readr)

library(readr)

10.3 Importando dados do Excel

Muitas vezes, temos uma planilha como todos os nossos dados para a análise. Basta utilizar a função read_excel() do pacote readr.

read_excel("nome_do_arquivo.xlsx")

De uma forma mais prática, no RStudio temos na seção “ambiente” a coluna “Environment” (ambiente). Nela, há a opção Import Dataset. Ao clicar em From Execel, selecionamos o arquivo desejado em Browse e delimitamos os parâmetros encontrados no canto inferior esquerdo de acordo com o que necessiamos.

Entretanto, há outra forma de importar dados do Excel. Podemos selecionar os dados na planilha, copiá-los e utilizar o comando read.table() para “colar” os dados em forma de data.frame.

x = read.table("clipboard", h = T)

10.4 Importando dados CSV

Muitos datasets estão dispostos neste formato. Para fazer a leitura, iremos utilizar o comando read_csv() do pacote readr.

read_csv("nome_do_arquibo.csv")

Da mesma forma como feita no passo anterior, podemos utilizar a seção Enviroment para realizar o nosso import. Ao clicar em Import Dataset, clicaremos em From Text (readr). O mesmo que fizemos para o Excel, iremos fazer com o CSV. Em Browse selecionamos o arquivo e no canto inferior esquerdo encontramos as características do nosso arquivo. É importante escolher corretamente se há um cabeçalho, se o separador (vírgula, ponto e vírgula, tabulação…) está correto! Leia todos os fatores antes de importar o arquivo. O nome da variável do dataset irá ser o mesmo do nome do arquivo. Para evitar conflitos, EVITE usar acentos e pontuações nos nomes dos arquivos.

10.5 Importando dados TXT

Para fazer a leitura, iremos utilizar o comando read.delim(") do pacote readr.

read_delim("nome_do_arquibo.txt")

Podemos também utilizar a seção Enviroment para realizar o nosso import. Ao clicar em Import Dataset, clicaremos em From Text (base). Imediatamente selecionamos o arquivo e encontraremos as características do nosso arquivo. É importante escolher corretamente se há um cabeçalho, se o separador (vírgula, ponto e vírgula, tabulação…) está correto! Leia todos os fatores antes de importar o arquivo. O nome da variável do dataset pode ser alterado na aba Name. Para evitar conflitos, EVITE usar acentos e pontuações nos nomes dos arquivos.

11 Estruturas lógicas

Em um processo de análise, há momentos em que necessitamos de uma lógica para continuar o progresso. Essas lógicas podem ser atribuídas às estruturas de repetição ou às estruturas condicionais.

11.1 Estruturas condicionais (IF)

number = 5 #Atribuindo um valor a minha variável
 
if(number > 0){ #"Se", o que está entre os parênteses for verdadeiro
  print("O número é positivo.") #Faça o que está dentro das {}
}else{ #Caso contrário
  print("O número é negativo.") #Faça o que está dentro das {}
}

## [1] "O número é positivo."

Podemos reescrever o códico acima em apenas uma linha. A primeira instância é a condição, a segunda é o retorno se verdadeiro e a terceita o retorno se falso.

ifelse(number>0, "Positivo", "Negativo") #Estrutura lógica em uma linha

## [1] "Positivo"

Há casos em que necessitamos de mais condições dentro de um laço. Diante disso, utilizamos o else if ao invés de somente else.

if(number == 5){
  print("O número é igual a 5")
}else if(number > 5){
  print("O número é maior que 5")
}else if(number < 5){
  print("O número é menor que 5")
}

## [1] "O número é igual a 5"

11.2 Estruturas de repetição (FOR)

z = c(1:10) #z é um vetor de 1 a 10

for(i in z){ #Perceba: o "i" irá percorrer todos os elementos de z
  print(i)
}

## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5
## [1] 6
## [1] 7
## [1] 8
## [1] 9
## [1] 10

11.3 Estruturas de repetição (WHILE)

a = 1 #"a" é uma variável que recebe o valor 1

while(a < 10){ #Enquanto o "a" for menor que 10, faça o que está dentro das {}
  print(a) 
  a = a + 1 #Perceba que, após a o script precisamos alterar o valor de "a" para evitar um loop infinito
}

## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5
## [1] 6
## [1] 7
## [1] 8
## [1] 9

12 Visualização de Dados

Quando temos dados em mãos, por vezes necessitamos da visualização deles através de gráficos. Há vários modos de de visualizar: usando os comandos nativos do R, utilizando o pacote ggplot2, o pacote dygraph, lattice, entre outros. Focarei nos comandos nativos do R para maior simplicidade. ATENÇÃO: fique atento à escala que está sendo utilizada, para fins de evitar uma falsa impressão dos dados.

12.1 Gráfico de dispersão

Vamos visualizar as primeiras linhas do dataset iris (nativo no R).

#Visualizando o dataset "iris"

head(iris)

##   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
## 1          5.1         3.5          1.4         0.2  setosa
## 2          4.9         3.0          1.4         0.2  setosa
## 3          4.7         3.2          1.3         0.2  setosa
## 4          4.6         3.1          1.5         0.2  setosa
## 5          5.0         3.6          1.4         0.2  setosa
## 6          5.4         3.9          1.7         0.4  setosa

Podemos relacionar duas variáveis em um gráfico de dispersão utilizando a função plot()

plot(iris$Sepal.Length, iris$Petal.Length)

plot(iris$Sepal.Length, iris$Petal.Length, xlab = "Eixo x", ylab = "Eixo y", main = "Título do Gráfico", col = "blue", pch = 20)#Atribuindo cores e formato aos elementos do gráfico

#xlab = Nome do eixo x
#ylab = Nome do eixo y
#main = Título do gráfico
#col =  Cor dos pontos
#pch =  Tipo de preenchimento

12.2 Gráfico de linhas

x = c(1,2,3,4,5,6)
y = c(11,25,39,48,56,90)
z = data.frame(x,y)

plot(z,  type = "l")

#type = "l" <- adicionando uma linha que interliga os pontos

12.3 Histograma

Quando analisamos histogramas, verificamos os fatores e suas frequências no cojunto de dados. Usamos frequentemente eles para análise de dispersão.

hist(iris$Sepal.Length)

hist(iris$Sepal.Length, xlab = "Sepal Length", ylab = "Frequência", main = "Sepal Length", col = "gray") #Atribuindo nomes aos eixos, ao título do gráfico e alterando a cor

12.4 Densidade

A densidade é outra forma visual de verificar a frequência dos dados.

densidade = density(iris$Sepal.Width) #Avaliando a densidade e atribuindo à variável densidade
plot(densidade) #Gerando um gráfico de densidade

12.5 Sobrepondo Gráficos

hist(iris$Sepal.Width, xlab = NULL, ylab = NULL, main = NULL, xaxt= "n", yaxt="n") #Criando um histograma, sem eixos, sem título e sem valores ("n" nos xaxt e yaxt)
par(new = TRUE) #New = True significa um novo gráfico que ficará sobreposto
densidade = density(iris$Sepal.Width) #Avaliando a densidade e atribuindo à variável densidade
plot(densidade, xlab = "Sepal Length", ylab = "Frequência", main = "Sepal Length") #Atribuindo nomes aos eixos, ao título do gráfico e alterando a cor

12.6 Boxplot

O gráfico de boxplot é claro conquanto à apresentação de um resumo estatístico dos dados. Vamos primeiramente visualizar um boxplot:

boxplot(iris$Sepal.Width, main = "Título", xlab = "Eixo", col = "gray") 

12.6.1 As caractetísticas do Boxplot

Nele visualizamos uma caixa que demonstra a alocação dos dados. A linha em destaque demonstra o ponto onde há a mediana dos dados. O topo da caixa se refere ao terceiro quartil, e o vale da caixa demonstra o primeiro quartil. O topo do gráfico demonstra o limite superior: calculamos ele, basicamente, multiplicando a amplitude interquartil (Q3 - Q1) por 1,5 e acrescentamos ao Q3. O mesmo processo se repete ao limite inferior, contando que devemos subtrair a amplitude (multiplicada por 1,5) pelo Q1. Os pontos que estão acima ou abaixo desses limites são chamados de outliers. Mas o que são outliers? Há como defini-lo como uma observação distante do padrão observado, sendo que pode ocorrer por: Entrada de dados errados no dataset, erros de experimento, um evento intencional ou até mesmo uma observação natural. Podemos encontrar um resumo básico utilizando a função boxplot.stats()

boxplot.stats(iris$Sepal.Width)

## $stats
## [1] 2.2 2.8 3.0 3.3 4.0
## 
## $n
## [1] 150
## 
## $conf
## [1] 2.935497 3.064503
## 
## $out
## [1] 4.4 4.1 4.2 2.0

12.7 Gráfico de Barras

12.7.1 Analisando

Vamos analisar o dataset InsectSprays (nativo no R) e verificar suas varíaveis

dplyr::glimpse(InsectSprays)

## Rows: 72
## Columns: 2
## $ count <dbl> 10, 7, 20, 14, 14, 12, 10, 23, 17, 20, 14, 13, 11, 17, 21, 11...
## $ spray <fct> A, A, A, A, A, A, A, A, A, A, A, A, B, B, B, B, B, B, B, B, B...

Percebemos que os dados estão distribuídos em duas colunas. A primeira é a quantidade, e a segunda é o fator atribuído. O dataset possui 6 levels, ou seja, 6 classificações. São elas: A, B, C, D e E. Como há vários valores atribuídos ao mesmo fator, precisamos agregar esses valores com a função aggregate().

agregar = aggregate(count ~ spray, data = InsectSprays, sum) 
#Colocamos primeiramente a variável que será agregada
#Separamos por um ~ e colocamos a coluna dos fatores
#Declaramos de onde os dados estão vindo
#Utilizamos a função "sum" para agregação (dito que necessitamos somar os valores)
agregar

##   spray count
## 1     A   174
## 2     B   184
## 3     C    25
## 4     D    59
## 5     E    42
## 6     F   200

12.7.2 Gerando o Gráfico

Com o dataframe agregado, podemos criar um gráfico de barras com a coluna agregada (count).

barplot(agregar$count, names.arg = agregar$spray) #names.arg estamos atribuindo nomes ao eixo X.

12.8 Dividindo a tela para alocação de vários gráficos

Geralmente, para construção de um relatório necessitamos alocar vários gráficos em uma tela só. É possível fazer isso utilizando a função split.screen(). Nela, passamos o parâmetro figs = c(n,m), sendo que: n = “número de linhas” e m = “número de colunas”. Para acessar as telas, utilizamos a função screen(). Após acessar todas as telas, precisamos fechar a seção com a função close.screen().

split.screen(figs = c(2,2)) #figs = c(2,2), ou seja, duas linhas e duas colunas

## [1] 1 2 3 4

screen(1)
    plot(iris$Sepal.Length, iris$Petal.Length, xlab = "Eixo x", ylab = "Eixo y", main = "Título do Gráfico")
screen(2)
    hist(iris$Sepal.Length, xlab = "Sepal Length", ylab = "Frequência", main = "Sepal Length", col = "gray")
screen(3)
    hist(iris$Sepal.Width, xlab = NULL, ylab = NULL, main = NULL, xaxt= "n", yaxt="n")
    par(new = TRUE)
    densidade = density(iris$Sepal.Width)
    plot(densidade, xlab = "Sepal Length", ylab = "Frequência", main = "Sepal Length")
screen(4)
    densidade = density(iris$Sepal.Width)
    plot(densidade)

close.screen(all = T)

13. Criando suas próprias funções

Durante a execução de um trabalho, codificamos vários processos repetitivos e geralmente carregamos a memória do sistema. Para tais ocasiões, você pode criar suas próprias funções utilizando o comando function().

subtrair = function(x,y){ #Criando a função, atribuindo os parâmetros
  resultado = x - y #Criando variáveis locais
  return(resultado) #Retornando o resultado
}

subtrair(10,7) #Executando a função

## [1] 3

Perceba que, na criação de uma função precisamos de:

“subtrair”: nome da função;
“function()”: = comando para criar a função;
“x e y”: parâmetros da função (podemos atribuir valores padrões ou até mesmo deixar sem parâmetros);
“{tudo o que está dentro das chaves}” = o corpo da função;
“resultado”: é uma variável local, apenas armazenada DENTRO da função, e não no ambiente R;
“return”: o que a função irá retornar.

13.1 Exemplo: Criando uma função para verificar se o número é par ou ímpar

verificar = function(x){
  
  if(x == 0){
    return("Zero não é par e nem ímpar!")}
  else if(typeof(x) != "integer"){
    return("O número não é inteiro!")
  }else if(x%%2 == 0){
    return("O número é par!")}
  else if(x%%2 == 1){
    return("O número é ímpar!")}
  }
  

verificar(1.2) #Número decimal

## [1] "O número não é inteiro!"

verificar(1L) #Para criar um número inteiro, como já vimos, basta colocar o "L" do lado do número

## [1] "O número é ímpar!"

verificar(2L)

## [1] "O número é par!"

verificar(0)

## [1] "Zero não é par e nem ímpar!"

14. O operador Pipe

Em um desenvolvimento, geralmente criamos várias variáveis para chegar em apenas um resultado. O processo de armazenar variáveis, dependendo do código, pode consumir exorbitantemente a memória do sistema, ocasionando lentidão, não tornando eficaz o desenvolvimento. Uma das maneiras de driblar esse obstáculo, é utilizando o pipe %>% (Para criar ele, basta apertar Ctrl+Shift+M).

14.1 Como funciona o pipe?

O operador não é nativo do R. Para utilizá-lo, podemos instalar o pacote magrittr.A utilização do operador garante a diminuição do tempo de desenvolvimento, como também facilita na análise e manutenção do script. Basicamente, seu objetivo é usar o resultado de uma operação como entrada para outra operação. Vamos à um exemplo de como utilizar:

#Calculando a raiz quadrada da soma de um vetor

x = c(20,30,40,50)
soma = sum(x)
raiz = sqrt(soma)

raiz

## [1] 11.83216

Observe que, neste caso precisamos definir 3 variáveis para chegar em apenas um resultado. Apesar ser serem poucas, em um processamento que exige várias transformações exige uma capacidade além disso!

#Utilizando o operador pipe

library(magrittr) #Carregando o pacote

raiz = x %>% sum %>% sqrt
raiz

## [1] 11.83216

Note que: 1º: criamos a variável raiz
2º: Colocamos o objeto a ser manipulado
3º: Calculamos a soma
4º: Calculamos a raiz quadrada da soma

15. Datas no R

Quando precisamos de datas no R, podemos trabalhar de várias formas com elas. A forma mais simples, é criando uma data em uma string e alterando sua classe com o comando as.Date(). Veja a seguir:

#Filtrando a data atual
data = Sys.time()
data

## [1] "2020-08-25 19:10:25 -03"

data = "2020-08-23"
data = as.Date(data)
class(data)

## [1] "Date"

Entretanto, há o pacote lubridate. Podemos utilizar a função dmy() do pacote, em que, uma de suas vantagens é estruturar várias formas de escrever uma data gerando o mesmo resultado.

#install.packages("lubridate") Instale o pacote, caso não tenha instalado ainda!

library(lubridate) #Carregando o pacote

## 
## Attaching package: 'lubridate'

## The following objects are masked from 'package:base':
## 
##     date, intersect, setdiff, union

dmy(14052002)

## [1] "2002-05-14"

dmy("14052002")

## [1] "2002-05-14"

dmy("14/05/2002")

## [1] "2002-05-14"

dmy("14-05-2002")

## [1] "2002-05-14"

Perceba que, apesar de escrever a mesma data de formas diferentes, a função reconheceu a data requerida. Dito isso, podemos utilizar algumas funções dele para manipular as datas.

data = dmy(14052002)

wday(data) #Dia da semana em número

## [1] 3

wday(data, label = TRUE) #Dia da semana abreviado

## [1] ter
## Levels: dom < seg < ter < qua < qui < sex < sáb

mday(data) #Dia do mês

## [1] 14

month(data) #Mês

## [1] 5

year(data) #Ano

## [1] 2002

data + ddays(1) #Adicionando um dia

## [1] "2002-05-15"

data + weeks(2) #Adicionando duas semanas semana

## [1] "2002-05-28"

data + weeks(1:3) #As 3 semanas após a data

## [1] "2002-05-21" "2002-05-28" "2002-06-04"

data + dyears(1) #Adicionando um ano

## [1] "2003-05-14 06:00:00 UTC"

16. Iterações básicas no R

Quando temos um vetor imenso e queremos aplicar uma função para cada valor do vetor, de primeira, podemos imaginar utilizar o loop for. Observe a seguinte situação:

vetor = c(1,2,3,4) #Criando um vetor

somar = function(x){ #Criando uma função simples
  return(x + 1)
  }

for(i in 1:length(vetor)){ #Somando a cada elemento do vetor o valor 1 
  vetor[i] = somar(vetor[i])
}

print(vetor)

## [1] 2 3 4 5

Por mais básico que seja, podemos utilizar a função map()do pacote purrr para acessar cada elemento e passar uma função.

#install.packages("purrr") Instale o pacote caso não tenha!
library(purrr)

## 
## Attaching package: 'purrr'

## The following object is masked from 'package:magrittr':
## 
##     set_names

vetor = c(1,2,3,4)
map(vetor, somar) #Primeiro o vetor, segundo a função

## [[1]]
## [1] 2
## 
## [[2]]
## [1] 3
## 
## [[3]]
## [1] 4
## 
## [[4]]
## [1] 5

Observe que, o retorno da função foi elemento por elemento. Entretanto, caso queremos o retorno em uma lista, basta usar a função map_dbl().

vetor = c(1,2,3,4)
map_dbl(vetor, somar)

## [1] 2 3 4 5

17. O pacote dplyr

Semelhante à linguagem SQL, o pacote dplyr tem funções fundamentais para filtros, seleções, entre outros que tornam o limiar da manipulação. Junto ao operador pipe %>% , seu uso torna o código mais legível e amigável para o interlocutor.

17.1 As principais funções do pacote dplyr

Suas principais funções são:
filter() filtra linhas do dataset
select() seleciona colunas do dataset
mutate() cria ou altera colunas do dataset

#Visualizando o dataset iris
head(iris)

Sepal.Length	Sepal.Width	Petal.Length	Petal.Width	Species
5.1	3.5	1.4	0.2	setosa
4.9	3.0	1.4	0.2	setosa
4.7	3.2	1.3	0.2	setosa
4.6	3.1	1.5	0.2	setosa
5.0	3.6	1.4	0.2	setosa
5.4	3.9	1.7	0.4	setosa

#Selecionando colunas específicas
iris %>% 
  select(Sepal.Length, Petal.Length)

Sepal.Length	Petal.Length
5.1	1.4
4.9	1.4
4.7	1.3
4.6	1.5
5.0	1.4
5.4	1.7

#Filtrando as colunas
iris %>% 
  select(Sepal.Length, Species) %>% 
  filter(Species == "setosa")

Sepal.Length	Species
5.1	setosa
4.9	setosa
4.7	setosa
4.6	setosa
5.0	setosa
5.4	setosa

#Criando uma nova coluna
iris %>% 
  select(Sepal.Length,Petal.Length) %>% 
  mutate(Mutiply = Sepal.Length * Petal.Length)

Sepal.Length	Petal.Length	Mutiply
5.1	1.4	7.14
4.9	1.4	6.86
4.7	1.3	6.11
4.6	1.5	6.90
5.0	1.4	7.00
5.4	1.7	9.18

18. Frequências

Estatisticamente, analisar as frequências de um fator no nosso banco de dados pode indicar várias análises. São úteis para todo tipo, desde a identificação da moda, como até analisar distribuições.

18.1 Frequências absolutas no R

Observe o dataset a seguir (nomeei ele de “dataf” e irei utilizá-lo nos próximos tópicos):

Genero	Massa	Estado
Feminino	75	RS
Masculino	47	RS
Masculino	71	SP
Masculino	81	SC
Trans	82	SC
Masculino	41	RS

## Rows: 50
## Columns: 3
## $ Genero <fct> Feminino, Masculino, Masculino, Masculino, Trans, Masculino,...
## $ Massa  <int> 75, 47, 71, 81, 82, 41, 54, 88, 77, 90, 45, 88, 68, 71, 88, ...
## $ Estado <fct> RS, RS, SP, SC, SC, RS, SP, SC, SC, SC, SC, SP, SP, SP, SP, ...

#Verificando a frequência absoluta dos Sexos

#É necessário que a coluna seja um fator!

table(dataf$Genero)

#Frequência absoluta cruzada

table(dataf$Genero, dataf$Estado)

Var1	Freq
Feminino	25
Masculino	17
Não Identificado	3
Trans	5

	RS	SC	SP
Feminino	6	9	10
Masculino	5	9	3
Não Identificado	0	2	1
Trans	0	4	1

Percebemos que no total, temos 25 Feminino, 17 Masculino, 3 Não foram Identificados e 5 Trans. Podemos segregar esses valores por Estado, como fiz com a tabela cruzada.

18.2 Frequências relativas no R

Ao invés do retorno por números absolutos, podemos retornar a probabilidade de cada fator no dataset.

#Total
prop.table(table(dataf$Genero))
#Segregado por Estado em referência o valor Total
prop.table(table(dataf$Genero, dataf$Estado))

Var1	Freq
Feminino	0.50
Masculino	0.34
Não Identificado	0.06
Trans	0.10

	RS	SC	SP
Feminino	0.12	0.18	0.20
Masculino	0.10	0.18	0.06
Não Identificado	0.00	0.04	0.02
Trans	0.00	0.08	0.02

19. Amplitude de um vetor

Podemos, por vezes necessitar de achar a amplitude de um vetor. Basicamente, é a subtração do valor máximo do valor mínimo do meu conjunto de dados. Podemos extrair separadamente esses valores, como também, podemos extraí-los juntos.

maximo = max(dataf$Massa) #O valor máximo
maximo

## [1] 90

minimo = min(dataf$Massa) #O valor mínimo
minimo

## [1] 40

range(dataf$Massa) #Os dois valores

## [1] 40 90

amplitude = maximo - minimo
amplitude

## [1] 50

20. Medidas de Centralidade

20.1 Média

A média é basicamente o ponto de equilíbrio das frequência em um histograma. Para calcular ela, usaremos a função mean().

mean(dataf$Massa)

## [1] 65.38

20.2 Mediana

Para calcular, organizamos o conjunto em rol (de forma crescente) e a posição central da lista é o que chamamos de mediana (segundo quartil). Utilizamos a função median().

median(dataf$Massa)

## [1] 65

20.3 Moda

De uma maneira geral, é o valor mais frequente do conjunto. Utilizaremos as preoposições de frequências estudadas no tópico 18.

a = c("A","A","A","A","A","B","B","B","C")
table(as.factor(a))

## 
## A B C 
## 5 3 1

#Gerando uma tabela de frequências relativas
prop.table(table(as.factor(a)))

## 
##         A         B         C 
## 0.5555556 0.3333333 0.1111111

21. Medidas de Variabilidade

21.1 Variância no R

matheus = c(10,5,3,8,9,4)


#Variância Populacional

media = mean(matheus)
amostra = length(matheus)

varpop = sum((matheus - media)^2)/amostra
varpop

## [1] 6.916667

#Variância Amostral


algumas = c(8,9,3)

varam = var(algumas)
varam

## [1] 10.33333

21.2 Desvio Padrão no R

#Populacional

sqrt(varpop) #Raiz quadrada da variância populacional

## [1] 2.629956

#Amostral
sd(algumas) #Função para calcular o desvio padrão amostral

## [1] 3.21455

22. Medidas não Centrais

salarios = c(1950,2520,4500,1800,3699,8000,5600,1658)
quartis = quantile(salarios)
quartis

##     0%    25%    50%    75%   100% 
## 1658.0 1912.5 3109.5 4775.0 8000.0

0% = Q0 (valor mínimo)
25% = Q1 (primeiro quartil -> mediana entre o valor mínimo e a mediana geral)
50% = Q2 (mediana)
75% = Q3 (terceiro quartil -> mediana entre o valor máximo e a mediana geral)
100% = Q4 (valor máximo)

23. Resumos Estatísticos

23.1 Summary

Ao invés de aplicarmos todas essas funções, o R nativamente oferece a função summary() que retorna um resumo com a maioria dessas variáveis.

summary(salarios)

##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##    1658    1912    3110    3716    4775    8000

Podemos acessar individualmente cada característica, utilizando o colchetes e indicando a indexação (como no slicing em qualquer estrutura do R).

summary(salarios)[2] #Filtrando o primeiro quartil

## 1st Qu. 
##  1912.5

23.2 Describe

Além da função summary, podemos utilizar a função describe() do pacote Hmisc.

#install.packages("Hmisc")
Hmisc::describe(dataf$Massa)

## dataf$Massa 
##        n  missing distinct     Info     Mean      Gmd      .05      .10 
##       50        0       33    0.998    65.38    18.61    42.00    45.00 
##      .25      .50      .75      .90      .95 
##    49.50    65.00    80.00    88.00    88.55 
## 
## lowest : 40 41 42 45 46, highest: 86 87 88 89 90

23.3 Resumos agrupados: Dplyr com Summarise

Podemos utilizar a função group_by para agrupar por algum fator, e utilizar a função summarise() para determinar as colunas com suas respectivas funções, todas do pacote dplyr.

library(dplyr) #Carregando o pacote

tabela = dataf %>% group_by(Genero) %>% #Agrupando por gênero
  summarise(
    Media = mean(Massa),
    Mediana = median(Massa),
    Maximo = max(Massa),
    Minimo = min(Massa),
    DesvioPadrao = sd(Massa),
    VarAmostral = var(Massa),
    .groups = 'drop'
)

tabela

Genero	Media	Mediana	Maximo	Minimo	DesvioPadrao	VarAmostral
Feminino	69.64000	71	90	42	15.35111	235.65667
Masculino	60.23529	58	90	40	17.14107	293.81618
Não Identificado	63.66667	61	71	59	6.42910	41.33333
Trans	62.60000	55	82	47	17.06751	291.30000

24 Amostras

Pode-se definir por geração o público alvo em que a pesquisa se direciona, e caso a pesquisa seja feita com toda a população chamamos de censo. Em modelos estatísticos, frequentemente trabalhamos com amostras, que são subconjuntos da população. Isso é devido ao fato de ser inviável, tanto financeiramente, quanto possível de análisar a população por geral. Nesse ramo, há diversos tipos de coletas de amostras, sendo que as mesmas devem evitar o enviesamento.

24.1 Amostra Simples

Definimos a amostra como um determinado número de elementos que é retirado de forma aleatória (toda população deve ter a mesma chance de participar). Podemos realizar a coleta no R da seguinte forma:

amostra1 = sample(c(1:1000), 150, replace = F) #Gerando 150 números aleatórios de 0 a 1000 sem reposição
amostra1

##   [1]  919  444  403  659   71  457  891  188  432  994  488  867  538  912  534
##  [16]  215  540  866  613  992  917  937  931  296  835  328  147  701  889  708
##  [31]  888   84   83  250  864  529  281  675  898  869  687  431   30   10  986
##  [46]  441  561  345  592  585  660   12  293  849  707  303  598  678  338  350
##  [61]  974  658 1000  107  752  543  518  775  840    4   43  189  911  913  171
##  [76]   39  810  216  747  291   58  914  395  184  737  456  904   22  170  961
##  [91]  884  588   63  987  950  417  573  886   70   59  643  484  804  203  227
## [106]  243  413  577  542  476  938  522  405  397  716  797  607  801  501  429
## [121]  778  205  475  104  210  471  671   66   88  358  601  309  142  294  421
## [136]  715  160  430  828  732  512  361  116  480   15  486  254  725  802  491

amostra2 = sample(c(0,1), 150, replace = T, prob = c(0.5,0.5)) #Gerando 150 números com chances de ser 0 (50% de probabilidade) ou 1 (50% de probabilidade)
amostra2

##   [1] 1 0 1 0 0 1 1 1 0 0 1 1 0 1 0 0 0 0 0 1 0 1 0 1 1 0 0 0 1 0 0 0 1 0 1 1 1
##  [38] 0 1 1 0 1 1 1 1 1 1 0 1 0 0 0 0 0 0 1 0 0 0 1 1 0 1 0 0 0 1 0 1 0 1 0 0 0
##  [75] 1 0 1 0 0 1 1 0 0 1 1 0 1 1 1 1 1 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1
## [112] 1 0 0 0 0 0 1 0 0 1 1 0 1 0 1 1 0 1 0 0 1 1 1 0 1 0 0 1 0 1 0 0 0 1 1 1 0
## [149] 0 0

Primeiramente, apenas estou gerando valores aleatórios utilizando a função sample(). Nela, primeiramente passamos o conjunto que será gerado, a quantidade de elementos, se haverá reposição ou não (caso o número de elementos do conjunto seja menor que a amostra, obrigatoriamente deve ter reposição) e também podemos declarar as probabilidades em um vetor (a ordem das probabilidades segue a ordem dos elementos no conjunto).
Perceba que, na segunda amostra estou criando um vetor de tamanho 150 com valores de 0 e 1.
Imagine um vetor gerado aleatoriamente com os valores (1,0,0,1). Caso atribuirmos uma condição lógica em que apenas retorna verdadeiro se a posição no vetor for exatamente igual à 1 vetor == 1, teremos o resultado (TRUE, FALSE, FALSE, TRUE). Portanto, se atribuirmos esse resultado à um vetor de 4 elementos, apenas o elemento 1 e o elemento 4 será retornado. Veja:

vetor = sample(c(0,1), nrow(dataf), replace = T, prob = c(0.7,0.3)) #Criando uma amostra do tamanho do número de linhas do dataf (nrow), com 70% para 0 e 30% para 1
table(vetor) #Visualizando a frequência

## vetor
##  0  1 
## 33 17

vetor == 1 #Visualizando a lógica

##  [1] FALSE FALSE  TRUE  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
## [13]  TRUE  TRUE FALSE FALSE  TRUE  TRUE  TRUE FALSE  TRUE FALSE  TRUE  TRUE
## [25] FALSE FALSE  TRUE FALSE FALSE FALSE FALSE  TRUE FALSE FALSE  TRUE FALSE
## [37]  TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE  TRUE FALSE  TRUE FALSE
## [49] FALSE  TRUE

amostrasimples = dataf[vetor == 1,] #Extraindo a amostra aleatória, onde estou filtrando as linhas que correspondem à TRUE (perceba que estou colocando antes da vírgula, pois estou filtrando as linhas!)

amostrasimples

##              Genero Massa Estado
## 3         Masculino    71     SP
## 4         Masculino    81     SC
## 13         Feminino    68     SP
## 14 Não Identificado    71     SP
## 17         Feminino    65     SC
## 18         Feminino    56     SC
## 19         Feminino    47     SC
## 21         Feminino    71     SP
## 23         Feminino    61     RS
## 24         Feminino    74     SC
## 27        Masculino    42     SC
## 32         Feminino    64     SP
## 35         Feminino    89     SP
## 37         Feminino    62     SP
## 45         Feminino    76     RS
## 47        Masculino    51     RS
## 50        Masculino    40     SC

24.1.1 Comparando os parâmetros da amostra com a população

Para efeitos de elucidação, vamos comparar a média da Massa da população com a média da Massa da nossa amostra coletada

mean(dataf$Massa) #Média Populacional

## [1] 65.38

mean(amostrasimples$Massa) #Média Amostral

## [1] 64.05882

24.2 Amostra Estratificada

Ao encontrar uma população que possui uma diversidade, por vezes, ao invés de coletar de forma totalmente aleatória, necessitamos de uma representatividade de cada grupo em nossa amostra. Para tal situação, há a amostra Estratificada. Para realizá-la, utilizarei o pacote sampling.

#install.packages("sampling")
library(sampling)

table(dataf$Genero) #Visualizando os gêneros

## 
##         Feminino        Masculino Não Identificado            Trans 
##               25               17                3                5

#Irei extrair aproximandamente, 30% de cada gênero
#Masculino = 5
#Feminino = 7
#N.I. = 1
#Trans = 2

amostraestrat = strata(data = dataf, stratanames = c("Genero"), size = c(5, 7, 1, 2), method = "srswor") #data é o dataset, stratnames é o fator, size é a representatividade e method Srswor = sem reposição / Srswr = com reposição
table(amostraestrat$Genero) #Perceba a representatividade determinada

## 
##         Feminino        Masculino Não Identificado            Trans 
##                5                7                2                1

head(amostraestrat) #Perceba a coluna "ID_unit", ela corresponde à linha no dataset original

##       Genero ID_unit      Prob Stratum
## 8   Feminino       8 0.2000000       1
## 19  Feminino      19 0.2000000       1
## 23  Feminino      23 0.2000000       1
## 30  Feminino      30 0.2000000       1
## 32  Feminino      32 0.2000000       1
## 4  Masculino       4 0.4117647       2

amostraestrat = dataf[amostraestrat$ID_unit,] #Selecionando a correspondência no dataset

24.2.1 Comparando os parâmetros da amostra com a população

Para efeitos de elucidação, vamos comparar a média da Massa da população com a média da Massa da nossa amostra coletada

mean(dataf$Massa) #Média Populacional

## [1] 65.38

mean(amostraestrat$Massa) #Média Amostral

## [1] 62.06667

24.3 Amostra Sistemática

Diferente das amostras anteriores, o processo aleatório nessa amostra se dá apenas na seleção de um único valor. Nela, podemos aplicar a soma de um escalar “x” à um valor “y” até um limite “z”. Imagine um vetor de 1 à 100, suponha que aleatoriamente selecionei o valor 4 e irei adicionar 10 até 100. Ou seja, o resultado será: 4, 14, 24… até 94. Nesse caso, podemos atribuir essa sistemática à correspondência das linhas no dataset. Para isso, utilizarei o pacote TeachingSampling.

#install.packages("TeachingSampling")
library(TeachingSampling)

amostrasist = S.SY(nrow(dataf), 2) #Gerar números que não ultrapassem o número de linhas do dataset. Gerar um número de forma aleatória e acrescentar de 2 em 2 até 50.
amostrasist

##       [,1]
##  [1,]    1
##  [2,]    3
##  [3,]    5
##  [4,]    7
##  [5,]    9
##  [6,]   11
##  [7,]   13
##  [8,]   15
##  [9,]   17
## [10,]   19
## [11,]   21
## [12,]   23
## [13,]   25
## [14,]   27
## [15,]   29
## [16,]   31
## [17,]   33
## [18,]   35
## [19,]   37
## [20,]   39
## [21,]   41
## [22,]   43
## [23,]   45
## [24,]   47
## [25,]   49

amostrasist = dataf[amostrasist,]
amostrasist

##              Genero Massa Estado
## 1          Feminino    75     RS
## 3         Masculino    71     SP
## 5             Trans    82     SC
## 7          Feminino    54     SP
## 9         Masculino    77     SC
## 11        Masculino    45     SC
## 13         Feminino    68     SP
## 15         Feminino    88     SP
## 17         Feminino    65     SC
## 19         Feminino    47     SC
## 21         Feminino    71     SP
## 23         Feminino    61     RS
## 25         Feminino    80     SP
## 27        Masculino    42     SC
## 29            Trans    49     SP
## 31         Feminino    84     RS
## 33         Feminino    42     SC
## 35         Feminino    89     SP
## 37         Feminino    62     SP
## 39 Não Identificado    59     SC
## 41        Masculino    46     SC
## 43         Feminino    90     SC
## 45         Feminino    76     RS
## 47        Masculino    51     RS
## 49         Feminino    87     SC

24.3.1 Comparando os parâmetros da amostra com a população

Para efeitos de elucidação, vamos comparar a média da Massa da população com a média da Massa da nossa amostra coletada

#Analisando a amostra e comparando

mean(dataf$Massa) #Média Populacional

## [1] 65.38

mean(amostrasist$Massa) #Média Amostral

## [1] 66.44

25. Distribuição Normal no R

De modo geral, ela é uma distribuição contínua que descreve as probabilidades dos possíveis valores de uma variável aleatória contínua. Utilizamos a Distribuição Normal Padrão (Z), em que referenciamos as probabilidades na tabela Z. Por geral, os valores quando estão normalmente distribuídos assumem um histograma em forma de “sino”, onde o centro é a média.

Podemos utilizá-la para calcular a probabilidade de um valor estar no intervalo maior que “x” ou menor que “x”. Seus parâmetros são: o desvio padrão da amostra, a média da amostra e o seu “x”. Ao calcular esse valor, encontramos o valor “z” que é referenciado pela tabela, como já dito anteriormente. Vale ressaltar que, os valores das probabilidades na tabela são aplicados apenas à suposição de “menor que”. Para encontrar um valor maior que, basta fazer 1 - p.
Entretanto, no R basta utilizar a função pnorm() para achar a probabilidade.

media = 8
dp = 2

pnorm(10, 8, 2, lower.tail = T) #1º valor, 2º média, 3º desvio padrão, 4º TRUE (menor que)

## [1] 0.8413447

pnorm(10, 8, 2, lower.tail = F) #1º valor, 2º média, 3º desvio padrão, 4º FALSE (maior que)

## [1] 0.1586553

25.1 Teste de Shapiro-Wilk no R

Nem todo conjunto está normalmente distribuído. Para verificar essa característica, há vários testes de hipótese. Nesse caso, iremos utilizar o teste de shapiro-wilk com a função shapiro.test(). Irei aplicar sobre a Massa do mesmo dataset já avaliado aqui!

length(dataf$Massa) #Verificando a quantidade de dados

## [1] 50

shapiro.test(dataf$Massa)

## 
##  Shapiro-Wilk normality test
## 
## data:  dataf$Massa
## W = 0.93308, p-value = 0.007238

Observe que, o p-value deu 0.007238. Nesse caso, com confiança de 95% podemos dizer que os dados não estão normalmente distribuídos. Vale ressaltar que, o conjunto deve ter, minimamente, 30 dados. Podemos também plotar o gráfico qqplot() para verificar a normalidade.

qqnorm(dataf$Massa)
qqline(dataf$Massa)

Perceba que, no gráfico os dados se apresentam em uma dispersão considerável da linha estimada. Como também, podemos plotar o gráfico de histograma e desnidade sobrepostos para avaliar a frequência.

hist(dataf$Massa, xlab = NULL, ylab = NULL, main = NULL)
par(new = T)
densidade = density(dataf$Massa)
plot(densidade, xaxt = "n", yaxt = "n", main = "Distribuição Normal")

26. Distribuição Binomial no R

Podemos declarar a Distribuição Binomial como uma distribuição discreta, em que descreve a probabilidade de ocorrência de cada valor de uma variável aleatória discreta (que tem valores contáveis). Para que uma distribuição seja binomial, devemos seguir alguns princípios:

Cada experimento tem apenas: Sucesso ou Fracasso? A probabilidade de sucesso é a mesma em cada experimento? Os experimentos são independentes? Usaremos a função dbinom().

dbinom(2,3, prob = 0.5) #Pontual

## [1] 0.375

#1º Número de eventos de sucesso
#2º Número total de eventos
#3º Probabilidade em cada evento para cada situação

pbinom(2,3,0.5) #Acumulativa

## [1] 0.875

#Podemos calcular a probabilidade acumulativa, ou seja,
#A probabilidade de cair 2 ou menos "caras"

pbinom(2,3,0.5, lower.tail = F) #Acumulativa

## [1] 0.125

#Ou calcular a probabilidade de dar mais que 2 caras

27. Distribuição de Poisson no R

Imagine a situação: O número médio de acidentes de carros por dia é de 2. Qual a probabilidade de ocorrerem 3 em um dia? Para esse caso, podemos utilizar a distribuição de poisson. No R, utilizamos a função dpois().

dpois(3,2) #Pontual

## [1] 0.180447

#Probabilidade de ocorrerem 3 ou menos?

ppois(3,2)

## [1] 0.8571235

#Probabilidade de ocorrerem MENOS que 3?

ppois(2,2)

## [1] 0.6766764

#Probabilidade de ocorrerem MAIS que 3?

ppois(3,2, lower.tail = F)

## [1] 0.1428765

28. Teste-t para uma amostra no R

Observe o dataset “alturas”. O mesmo contém a altura de 30 pessoas. Sabe-se que a média da altura do local onde elas vivem é 167cm, a altura média dessas pessoas é diferente da altura local deles? Descreveremos de forma apropriada.

Altura = c(174,166,159,171,157,169,176,159,160,172,173,172,177,165,170,160,161,162,158,165,169,171,165,161,164,178,165,157,180,172)
Pessoa = c(1:30)

alturas = data.frame(Pessoa,Altura)

dplyr::glimpse(alturas)

## Rows: 30
## Columns: 2
## $ Pessoa <int> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 1...
## $ Altura <dbl> 174, 166, 159, 171, 157, 169, 176, 159, 160, 172, 173, 172, ...

#Testando a normalidade dos dados
shapiro.test(alturas$Altura)

## 
##  Shapiro-Wilk normality test
## 
## data:  alturas$Altura
## W = 0.95199, p-value = 0.1911

Os dados precisam estar normalmente distribuídos. Nesse caso, aceitamos a normalidade dos dados (p > 0,05).

#Teste de T

t.test(alturas$Altura, mu = 167)

## 
##  One Sample t-test
## 
## data:  alturas$Altura
## t = -0.054332, df = 29, p-value = 0.957
## alternative hypothesis: true mean is not equal to 167
## 95 percent confidence interval:
##  164.4238 169.4429
## sample estimates:
## mean of x 
##  166.9333

Hipótese nula: média da amostra = média pop (p > 0.05)
Hipótese alternativa: média da amostra diferente da média pop (p <= 0.05)
O teste-t para uma amostra mostrou que a média de altura da amostra (166,93) não é diferente da média local (167). p = 0,957.

29. Referências bibliográficas

Eu agradeço por me acompanhar nessa jornada :) . O conhecimento é totalmente mutável e estamos em constante evolução. Encontramos uma porta aberta para uma infinidade de opções. Deixo algumas referências, sugestões, complementações a seguir caso queira se aprofundar.

29.1 Bibliografia Básica

Bussab W.O. e Morettin P.A., Estatística Básica, Saraiva, São Paulo, 9ed, 2017.
William N. Venables and Brian D. Ripley. Modern Applied Statistics with S. Fourth Edition.
Springer, New York, 2002. URL http://www.stats.ox.ac.uk/pub/MASS4/.
R Core Team (2020). R: A language and environment for statistical computing. R Foundation for Statistical Computing, Vienna, Austria. URL https://www.r-project.org/.
John Verzani. Using R for Introductory Statistics. Chapman & Hall/CRC, Boca Raton, FL, 2005. URL https://www.math.csi.cuny.edu/Statistics/R/simpleR/printable/simpleR.pdf.

29.2 Bibliografia Complementar

R CORE TEAM (2020) (org.). Available CRAN Packages By Name. 2020. Disponível em: https://cran.r-project.org/web/packages/available_packages_by_name.html. Acesso em: 09 ago. 2020.

30. Links úteis

30.1 Vídeos

O segredo da MERITOCRACIA, por Átila Iamarino https://www.youtube.com/watch?v=YINTTVjBrY4&t=622s
O SEGREDO da MERITOCRACIA. Direção de Paloma Sato. Produção de Paloma Sato. Realização de Atila Iamarino. Roteiro: Atila Iamarino. [S.I.]: Paloma Sato, 2019. (18 min.), P&B. Legendado. Disponível em: https://www.youtube.com/watch?v=YINTTVjBrY4&t=622s. Acesso em: 06 dez. 2019.
Por que todos deveriam aprender a programar? https://www.youtube.com/watch?v=mHW1Hsqlp6A
POR que todos deveriam aprender a programar?. [S.I.]: Kolaborativa, 2013. P&B. Legendado. Disponível em: https://www.youtube.com/watch?v=mHW1Hsqlp6A. Acesso em: 09 ago. 2020.
Análise de dados muda perfil de profissionais http://g1.globo.com/globo-news/conta-corrente/videos/t/todos-os-videos/v/analise -de-dados-muda-perfil-de-profissionais/6554158/

30.2 Sites

https://studio.code.org/courses (Lógicas de Programação)
https://rstudio.com/wp-content/uploads/2016/03/rstudio-IDE-cheatsheet-portuguese.pdf (IDE do RStudio)
https://edisciplinas.usp.br/pluginfile.php/4883125/mod_resource/content/1/Tutorial.pdf (Tutorial R/RStudio - FEA USP)
https://www.unicamp.br/~chibeni/textosdidaticos/condicional.pdf (Condicionais Lógicos - UNICAMP)
http://www.cienciaedados.com/o-poder-do-open-data/ (Datasets Públicos)
https://www.kaggle.com/ (Plataforma para Ciência de Dados)
https://oestatistico.com.br/ (Blog para Estatística)
https://www.r-bloggers.com/ (Conteúdo para o R)
https://rpubs.com/ (Documentos Analíticos para o R)
http://datascienceacademy.com.br/blog/fast-data-a-evolucao-do-big-data/ (FastData – A Evolução do Big Data)
http://datascienceacademy.com.br/blog/qual-a-diferenca-entre-o-analista-de-bie-o-cientista-de-dados/ (Qual a diferença entre o Analista de BI e o Cientista de Dados?)

30.3 Livros

Data Science Para Negócios (Tom Fawcett)
Data Smart: Usando Data Science Para Transformar Informação em Insight (John W. Foreman)
Big Data: A Revolution That Will Transform How We Live, Work, and Think (Kenneth Cukier)
R Para Data Science (Garrett Grolemund/ Tradução: Samantha Batista)

“Tudo que ensinas a uma criança, impede-a de descobrir.” Jean Piaget

Por Matheus Leite Llorente.

Sobre

Sobre

É um prazer em te conhecer!

Meu nome é Matheus Leite Llorente e sou discente de Ciências Atuariais pela Universidade Federal de São Paulo. Estudo DataScience desde os meus 16 anos de idade, desenvolvi aptidão em Programação, Análise de Banco de Dados, Análises Preditivas, e, também na Análise Estatística. Maximizo meu conhecimento em leituras, cursos, com Professores e Gestores na área para promover um conteúdo de qualidade para você :). Procurei desenvolver este curso com fins de difusão do conhecimento para constribuição científica tanto dentro da nossa Universidade como fora!

Espero que goste! :)
Caso queira conhecer mais sobre mim, me siga no Linkedin

---

1. MATHISFUN. Vectors. Disponível em: https://www.mathsisfun.com/algebra/vectors.html. Acesso em: 16 ago. 2020.↩︎

2. STATTREK. What is a Matrix? Disponível em: https://stattrek.com/matrix-algebra/matrix.aspx. Acesso em: 16 ago. 2020.↩︎

3. STATTREK. Matrix Multiplication: how to multiply a matrix by a matrix. How to Multiply a Matrix by a Matrix. Disponível em: https://stattrek.com/matrix-algebra/matrix-multiplication.aspx. Acesso em: 16 ago. 2020.↩︎

4. TORGO, Luis. Data Frames. Disponível em: https://www.dcc.fc.up.pt/~ltorgo/SebentaR/HTML/node16.html#:~:text=Um%20data%20frame%20%C3%A9%20semelhante,registo%20(linha)%20da%20tabela.. Acesso em: 17 ago. 2020.↩︎