1 Introdução

Esta página destina-se aqueles que desejam realizar análises estatísticas utilizando o RStudio. Para deixar a explicação mais leve, as explicações e exemplos serão orientados à execução, e muitos conceitos que fundamentam a Estatística e a programação não serão abordados.

1.1 O mundo digitalizado

1.2 A Estatística como ferramenta da apoio à decisão

1.3 O R e tutorial de instalação do R e do RStudio

A Linguagem R foi criada em 1991 por Ross Ihaka e Robert Gentleman no Departamento de Estatística da Universidade de Auckland, na Nova Zelândia. Ela é derivado da linguagem comercial S desenvolvida nos Bell Labs na década de 1970, o que lhe confere uma base sólida e intrínseca para a computação estatística e gráfica.
Em 1993 houve o anúncio público do R que enfrentava fárias restrições por ser derivada de uma linguagem comercializada. Por causa desse problema, seus criadores decidiram adotar o GNU General Public License, tornando o R um software livre. Isso permitiu que a linguagem fosse amplamente utilizada e desenvolvida pela comunidade, tendo a sua primeria versão (1.0.0) sido lançada em 2000.
Essa herança significa que o R foi projetado desde o início com estatísticos e pesquisadores em mente, incorporando estruturas de dados e funções otimizadas para manipulação, análise e visualização de dados de forma nativa. Sua sintaxe facilita as operações matriciais e vetoriais, comuns em estatística. Isso o torna uma ferramenta robusta e flexível para desenvolvimento de novos métodos estatísticos, simulações e análise de dados, sendo amplamente adotado em universidades e centros de pesquisa.
Atualmente, o R é oferecido de forma gratuita a partiri dos Comprehensive R Archive Network (CRAN) e é compatível com sistemas operacionais como Linux, Mac e Windows, além de poder ser operado diretamente na nuvem.  Uma grande comunidade ativa oferece suporte, documentação e recursos de aprendizado abundantes que aliada à sua arquitetura de pacotes permite o desenvolvimento de funcionalidades especializadas, tornando o R adaptável a praticamente qualquer domínio de análise (econometria, bioinformática, aprendizado de máquina, etc.), o que o tornou um software com Capacidades Gráficas Avançadas, com ferramentas poderosas para visualização de dados, desde gráficos básicos até visualizações interativas complexas.
O RStudio é um Ambiente de Desenvolvimento Integrado (IDE), também ofertado gratuitamente, que oferece ferramentas para aumentar a produtividade dos desenvolvedores. Também possui versões pagas que disponibilizam mais recursos.

Antes da instalação do RStudio, é necessário instalar o R.
A instalação do R é simples e é possível a partir dos links:
Repositório geral
R para Windows
R para Mac
R para linux

O R dispõe de ampla documentação que pode ser encontrada em:
Perguntas e respostas  

De forma similar, a instalação do RStudio é simples. Sugiro a versão free desktop.
Ao acessar o link, você irá perceber que existem 4 versões, sendo duas para desktop e duas para servidores. O RStudio Desktop, com o qual trabalharemos, destina-se aqueles que irão atuar individualmente; já os servidores, são para aqueles que trabalharão em equipes e com compartilhamento de informações, ou ainda, para uma empresa com muitos usuários do aplicativo.

As versões pagas possuem mais recursos e suporte. Preste atenção para baixar a solução pretendida (RStudio Desktop).
Atente para escolher a versão para o sistema operacional de seu computador.
Após instalar o R, então instale o RStudio.

Vídeo - Instalando o RStudio.

1.4 RStudio na WEB

Você ainda tem a oportunidade de trabalhar com o RStudio na web. Isso facilita àqueles que não têm uma estação de trabalho fixa e precisam salvar seus arquivos na nuvem, e também, aqueles que tem limitações de desempenho em seus computadores pessoais, ou ainda, aqueles que utilizam um computador do trabalho que tem restrições para instalar programas. 
Fique atento porque a versão free do RStudio Cloud tem limite de tempo para utilização. Portanto, fique logado somente o tempo em que estiver trabalhando, deslogando logo em seguida.

Para acessar o RStudio na nuvem, acesse o link RStudio Cloud, faça seu cadastro e comece a trabalhar.

Vídeo entenda o RStudio Cloud - Entenda o RStudio Cloud

1.5 Conhecendo o RStudio

O RStudio apresenta 4 grandes ambientes:
1. um local onde escreveremos os códigos; 2. um console em que veremos os resultados de nossos códigos; 3. um ambiente no qual podemos ver o estados de nossas variáveis; e 4. um pequeno navegador.

Cada um desses ambientes é dividido em abas com diversas funcionalidades. Para entender melhor, veja o vídeo a seguir.

Vídeo conhecendo o RStudio - Conhecendo o RStudio.

1.6 Pacotes

Pacotes no R são extensões da linguagem que agrupam funções, dados e documentação em um formato padronizado. Eles servem para expandir as capacidades básicas do R, permitindo realizar tarefas específicas como gráficos avançados, análise geoespacial ou bioestatística, sem precisar escrever códigos complexos.
Eles podem ser encontrados em repositórios em diversas partes do mundo, os CRAN que podem ser acessados pela internet normal https://cran.rstudio.org/. No entanto, no RStudio existe um caminho mais fácil, onde você pode acessar o menu Tools, Install Packages e digitar o nome do pacote desejado.
Esses pacotes são baixados e instalados no seu computador em um local específico, a biblioteca (library) onde ficam todos os pacotes. 

Os pacotes contém:
Funções: Códigos prontos para executar ações (ex: ggplot() para gráficos). Documentação: Manuais e arquivos de ajuda que explicam como usar as funções. Dados: Conjuntos de dados de exemplo para prática e testes. Metadados: Arquivos como o DESCRIPTION, que listam a versão, autor e dependências do pacote.
Depois de instalados, eles precisam ser “ligados” ou “chamados” para que funicionem no seu código, por isso, como boa prática, recomendo que logo no início de seu programa você crie um espaço para chama-los. Eles são “chamados” com o comando library(nome_do_pacote).

2 Programação básica

Neste tópico iremos entender os tipos de dados e as operações básicas.

2.1 Editor de texto para programação

No RStudio é possível se editar os programas e salvá-los. O editor do RStudio destaca as palavras reservadas (comandos) , facilitando o seu gerenciamento.
Recomendo que seja definida uma pasta onde devem ser guardados todos os códigos produzidos, isso facilitará a sua recuperação e a manutenção de um histórico de trabalho.

Sempre que for iniciar um código, faça um cabeçalho, indicando quem está escrevendo (no caso, você), a data de criação e alteração, o local, e a finalidade do código. Utilize o comando “#” no início da linha para para que essas informações não sejam entendidas como uma instrução ao computador.

O comentário serve para explicar algo sobre o código e é muito utilizado para a permitir o entendimento da lógica do programador.

# Isto é um comentário. O comentário é utilizado para documentar o código, explicando a lógica e ideias do programador.

2.2 Identificadores

Identificador é o nome pelo qual chamaremos um endereço na memória do computador. Esse endereço pode conter uma variável, uma estrutura de dados com diversos registros ou funções. A seguir vamos entender cada um desses nomes.

Preste bastante atenção: o RStudio é case sensitive, distingue as letras maiúsculas das minúsculas do nome desses identificadores, então, CUIDADO tenha muita atenção na atribuição dos nomes pois a digitação trocada de um caracter pode gerar erro no seu código. Por exemplo: se você digitar x é diferente do que digitar X.

Os identificadores também não podem ser iniciados com números ou **“_“, por exemplo, os identificadores são INVÁLIDOS:**:
1_media_idade
’_media’

Uma Boa Prática para quando for necessário identificar a variável com mais de uma palavra é ressaltar essas palavras com a primeira letra maiúscula ou separá-las com o **_, por exemplo:
MediaIdade - essa notação é chamada de CamelCase; ou
‘media_idade’ - essa notação é chamada de snake_case.

A escolha de bons identificadores é crucial para a legibilidade, manutenibilidade** e colaboração em projetos de R. Nomes descritivos e consistentes tornam o código mais fácil de entender não apenas para quem o escreveu (seja semanas ou meses depois), mas também para outros membros da equipe. Identificadores claros reduzem a ambiguidade, minimizam a necessidade de comentários excessivos e diminuem a probabilidade de erros de lógica ou de refatoração. Em projetos de longo prazo, a manutenção e a expansão do código são significativamente facilitadas quando as variáveis e funções possuem nomes que refletem claramente seu propósito e conteúdo, aderindo a convenções de estilo (como snake_case ou camelCase).

Vídeo Entendendo os identificadores.

2.3 Tipos de dados

De forma bastante simples, podemos entender uma variável em programação é um espaço de memória onde se armazenam dados para serem utilizados nas instruções (algoritmos).
O R trabalha com os seguintes tipos básicos de dados que podem ser organizados em estruturas de dados como vetores, matrizes, data frames e listas:

  • numéricos - não fazem distinção aparente entre inteiros ou reais, e a notação é em inglês, o “.” (ponto) separa a fração e a “,” (vírgula) separa os decimais.

    • Os tipos de dados numéricos são:

      • int - inteiros - utilizam menos memória e são representados por um ‘L’ após o numeral, ‘5L’, ;

      • dbl - representa números de ponto flutuante, ou números reais. Ocupam mais memória. Exemplo: Atribuindo o valor 5 a uma variável x:
        x <- 5L para inteiro, ou
        y <- 5 para flutuante.

x <- 5L # variável x recebe o numeral 5 inteiro
x
## [1] 5
y <- 5
y 
## [1] 5

Ao criar uma variável o computador cria um endereço capaz de armazenar dados. Esse endereço é o nome da variável, no caso ‘x’ e ‘y’.
Ambas as variáveis armazenam o valor 5, porém ‘x’ por ser inteiro, ocupa menos espaço de memória, enquanto ‘y’ permite cálculos mais precisos.
Essa diferença de espaço de memória é insignificante quando trabalhamos com poucos dados, mas pode ser bastante relevante quando se trabalha com grande quantidade de dados.

  • textos - armazenam valor em letras ou texto.

    • chr - representa vetores de caracteres ou strings
      Exemplo:
      Atribuindo um texto à uma variável a:
      a <- “O RStudio é uma ferramenta poderosa”
a <- "O RStudio é uma ferramenta poderosa." # variável a armazena texto
a
## [1] "O RStudio é uma ferramenta poderosa."

  • lógicos - armazenam verdadeiro (TRUE) ou falso (FALSE). Em R, os valores booleanos TRUE e FALSE são a própria essência do tipo de dado logical. Ou seja, o tipo de dado logical é o que armazena esses valores booleanos.

    • lgl - representa lógico, vetores que contêm apenas TRUE ou FALSE.
      Exemplo:
        # 1. Criar as variáveis
        verdadeiro <- TRUE
        falso <- FALSE

        2 # Imprimir 
## [1] 2
        print(verdadeiro) # Tipo é logical
## [1] TRUE
        print(as.numeric(verdadeiro)) # Converte para numérico
## [1] 1
        print(as.numeric(falso))   # Converte para numérico
## [1] 0

O R tem uma capacidade de coerção implícita que permite que logical seja tratado como numérico em certas operações: * TRUE é convertido para 1. * FALSE é convertido para 0. Exemplo:

        # 1. Criar as variáveis
        verdadeiro <- TRUE
        falso <- FALSE
        
        # 2. Realizar os cálculos com os valores implícitos das variáveis booleanas
        soma <- verdadeiro + verdadeiro + falso + falso + verdadeiro

        3 # Imprimir o resultado do passo '2'
## [1] 3
        print(soma) # Será apresentado o valor de 'verdadeiros' da sentença aritmética.
## [1] 3

  • datas - existem funções criadas para trabalharem com esse tipo de dados, facilitando muito as operações, em especial as séries temporais e os gráficos. As datas podem ser representadas por dois tipos de dados.

    • date - representa somente datas. Exemplo: Você está programando uma viagem e precisa calcular a duração entre duas datas. Calcule a diferença em dias entre essas duas datas.
        # 1. Criar as variáveis
        data_inicio <- as.Date("2026-01-26")
        data_fim <- as.Date("2026-02-10")

        # 2. Realizar os cálculos com as datas
        diferenca_dias <- data_fim - data_inicio
        
        3 # Imprimir a diferença calculada em '2'
## [1] 3
        print(diferenca_dias)
## Time difference of 15 days
-   dttm - representa datas e horas (uma data + uma hora). É utilizado o pacote **`lubridate`** e que possui o objeto 'POSIXct'.

Exemplo: Em muitas análises financeiras ou de séries temporais, é fundamental manipular datas e horas. Veja como você extrairia o ano, o mês e a hora desse objeto.

        # 1. Criar um objeto POSIXct (data e hora)
        data_hora <- as.POSIXct("2026-01-26 08:15:00", tz = "UTC")
        
        2 # Imprimir a variável 'data_hora'
## [1] 2
        print(data_hora)
## [1] "2026-01-26 08:15:00 UTC"
        # 3. Extrair ano, mês e hora
        ano <- format(data_hora, "%Y")
        mes <- format(data_hora, "%m")
        hora <- format(data_hora, "%H")

        4 # Imprimir os resultados
## [1] 4
        print(ano)
## [1] "2026"
        print(mes)
## [1] "01"
        print(hora)
## [1] "08"

  • fator - é um tipo de dado que o R utiliza para representar as variáveis categóricas, facilitando a criação de gráficos e as análises estatísticas. É utilizado em vetor, por isso, caso você não conheça sobre vetores no R, para melhor compreensão veja o tópico seguinte ‘Vetores’ antes.

    • fctr - é a representação desse tipo de dado. Exemplo: Você possui dados sobre o nível de qualidade de um equipamento, com as categorias “Bom”, “Regular”, “Ruim” que estão armazenados em vetor (pode ser a coluna de um data-frame) com algumas observações (``) e precisa extrair inoformações desse vetor.
        # 1. Criar um vetor com os níveis de qualidade dos equipamentos.
        qualidade_raw <- c("Bom", "Regular", "Bom", "Ruim","Regular","Bom","Bom")

        # 2. Definir os níveis em ordem
        niveis_qualidade <- c("Bom", "Regular", "Ruim")  
        
        # 3. Converter para fator com níveis ordenados
        qualidade_fator <- factor(qualidade_raw, levels = niveis_qualidade, ordered = TRUE)

        4 # Imprimir resultados
## [1] 4
        print(qualidade_fator)
## [1] Bom     Regular Bom     Ruim    Regular Bom     Bom    
## Levels: Bom < Regular < Ruim
        print(levels(qualidade_fator))
## [1] "Bom"     "Regular" "Ruim"

Para formulação de análises e gráficos, é muito útil o comando ‘table’ que faz a contagem dos fatores. Exemplo:

table(qualidade_fator)
## qualidade_fator
##     Bom Regular    Ruim 
##       4       2       1

2.3.1 Vetores

Vetores - podem armazenar números, caracter, boolenos, ou textos - os vetores armazenam apenas dados de um mesmo tipo.

Criando um vetor de números:
vetor <- c(10, 20, 30, 40, 50)

vetor <- c(10, 20, 30, 40, 50) # um vetor contendo 5 números
vetor
## [1] 10 20 30 40 50
# para chamar apenas um dado armazenado no vetor, utilize a notação vetor[posição].
vetor[2] # vai chamar o dado armazenado na segunda posição, no caso, o número 20
## [1] 20

Criando um vetor com nomes:
vetor_a <- c(“aluno”, “idade”, “série”)

vetor_a <- c("aluno", "idade", "série")  # um vetor contendo 3 nomes
vetor_a
## [1] "aluno" "idade" "série"
vetor_a[3] # chamando o dado da terceira posição, no caso a palavra "série"
## [1] "série"

2.3.1.1 Criando um vetor com sequência de dados

1:10 - este comando cria uma sequência de números variando de 1 até 10.
Caso essa sequencia seja adicionada ao uma variável, criaremos um vetor de 10 posições com essa sequência.
x <- 1:10 x <- seq(1:10) - este comando é similar ao de cima, no entanto ele pode ser incrementado com alguns argumento.

x <- seq(from = 1, to = 50, by = 2)

1:10 
##  [1]  1  2  3  4  5  6  7  8  9 10
x <- 1:10
x
##  [1]  1  2  3  4  5  6  7  8  9 10
x <- seq(1:10)
x
##  [1]  1  2  3  4  5  6  7  8  9 10
seq(from = 1, to = 10, by = 2)
## [1] 1 3 5 7 9
seq(from = 5, to = -5, by = -2)
## [1]  5  3  1 -1 -3 -5
seq(from = 1, to = 3, by = 0.2)
##  [1] 1.0 1.2 1.4 1.6 1.8 2.0 2.2 2.4 2.6 2.8 3.0

Podemos criar repetição de nomes ou números com o comando:
rep(“nome”, 5)

De forma similar, podemos atribuir essa repetição à uma variável, criando um vetor:
x <- rep(“nome”, 5)

rep("nome", 5)  
## [1] "nome" "nome" "nome" "nome" "nome"
x <- rep("nome", 5)  
x[3]
## [1] "nome"
rep(7, 5)  
## [1] 7 7 7 7 7

Podemos criar uma sequência de datas.

# 1. Criando uma variável com o tipo data
data_inicio <- as.Date("2023-01-01")

# 2. Criando a sequência de datas por mês com 24 meses
sequencia_datas_2023 <- seq(from = data_inicio, by = "month", length.out = 24)

3 # Imprimindo a sequencia de dados criada
## [1] 3
print(sequencia_datas_2023)
##  [1] "2023-01-01" "2023-02-01" "2023-03-01" "2023-04-01" "2023-05-01"
##  [6] "2023-06-01" "2023-07-01" "2023-08-01" "2023-09-01" "2023-10-01"
## [11] "2023-11-01" "2023-12-01" "2024-01-01" "2024-02-01" "2024-03-01"
## [16] "2024-04-01" "2024-05-01" "2024-06-01" "2024-07-01" "2024-08-01"
## [21] "2024-09-01" "2024-10-01" "2024-11-01" "2024-12-01"

2.3.2 Matrizes

Matrizes - armazenam matricialmente diversos dados de um mesmo tipo (ou texto, ou número ou booleano).

Vídeo criando vetores e matrizes - Criando vetores e matrizes

Criando uma matriz chamada mat:
mat <- matrix(data = c(10, 20, 30, 40), nrow = 2, ncol = 2)

data = representa os dados que serão inseridos na matriz.
c(10, 20, 30, 40) são os dados, no caso um conjunto de 4 números.
nrow = 2 indica que a matriz terá duas linhas.
ncol = 2 indica que a matriz terá duas colunas.
Como padrão, os dados serão organizados por coluna, ou seja, o preenchimento da matriz será realizado preenchendo-se a 1ª coluna e depois a 2ª coluna.

mat <- matrix(data = c(10, 20, 30, 40), nrow = 2, ncol = 2)   # uma matriz de 2 linhas e 2 colunas de zeros
mat
##      [,1] [,2]
## [1,]   10   30
## [2,]   20   40
# para chamar apenas um dado armazenado na matriz, utilize a notação matriz[linha, coluna]

mat[2,1] # chamará o valor armazenado na segunda linha e primeira coluna, no caso, o valor 20
## [1] 20

Criando uma matriz de texto chamada mat_a:
mat_a <- matrix(data = “aluno”, nrow = 2, ncol = 2)

1
## [1] 1
mat_a <- matrix(data = "aluno", nrow = 2, ncol = 2) # uma matriz de texto com a palavra aluno repetida 4 vezes.
mat_a 
##      [,1]    [,2]   
## [1,] "aluno" "aluno"
## [2,] "aluno" "aluno"
2
## [1] 2
mat_a1 <- matrix(data = c("aluno","classe","professor","teste"), nrow = 2, ncol = 2) # uma matriz de texto com as palavras aluno, classe, professor e teste.

# lembre-se que o preenchimento da matriz se dará por coluna
mat_a1
##      [,1]     [,2]       
## [1,] "aluno"  "professor"
## [2,] "classe" "teste"
mat_a1[2,1] # irá retornar o dado da 2ª linha 1ª coluna, no caso o valor 'classe'.
## [1] "classe"
3
## [1] 3
# para fazer o preenchimento por linha utilize a instrução byrow
mat_a1 <- matrix(data = c("aluno","classe","professor","teste"), nrow = 2, ncol = 2, byrow=TRUE) 
mat_a1
##      [,1]        [,2]    
## [1,] "aluno"     "classe"
## [2,] "professor" "teste"
mat_a1[2,1] # irá retornar o dado da 2ª linha 1ª coluna, no caso o valor 'professor'.
## [1] "professor"

2.3.2.1 Nomes das colunas e linhas da matriz

Podemos atribuir nomes às colunas e linhas de uma matriz

colnames(mat) <- c(“linha1”, “linha2”))
O comando acima atribui os nomes coluna1 e coluna2 para as colunas da matriz.

colnames(mat) <- c("coluna1", "coluna2")

mat
##      coluna1 coluna2
## [1,]      10      30
## [2,]      20      40

rownames(mat) <- c(“linha1”, “linha2”))
O comando acima atribui os nomes linha1 e linha 2 para as linhas da matriz.

rownames(mat) <- c("linha1", "linha2")

mat
##        coluna1 coluna2
## linha1      10      30
## linha2      20      40

Também podemos criar os nomes das coluna diretamente na matriz

dados <- c(10, 12, 11, 13, 8, 9, 10, 13, 12, 18, 17, 19)

# 2. Criando a matriz
matriz <- matrix(dados, 
                 nrow = 3, ncol = 4, byrow = TRUE,
                 dimnames = list(
                            c("Linha A", "Linha B", "Linha C"),
                            c("Coluna1", "Coluna2", "Coluna3", "Coluna4")))
# O nome da linhas é o primeiro vetor da lista; e as colunas o segundo vetor da lista
# Para entender o que é uma lista, veja o proximo tópico, 'Listas'

3 # Imprimindo a matriz
## [1] 3
print(matriz)
##         Coluna1 Coluna2 Coluna3 Coluna4
## Linha A      10      12      11      13
## Linha B       8       9      10      13
## Linha C      12      18      17      19

2.3.2.2 Chamadas de matrizes

As matrizes podem ser acessadas pelo número de suas linhas e colunas.
As matrizes que possuem nomes podem ser chamdas pelos nomes de suas linhas e colunas.

Criando uma matriz para praticar a chamada.

# Criando uma matriz com 3 disciplinas e 5 alunos
# este comando gerará um "warnnig" porque a sequencia 6:9 não é múltiplo de 5 (quantidade de linhas da matriz), mas foi feito propositalmente para haver variação de notas entre os alunos e disciplinas.
notas <- matrix(6:9, nrow = 5, ncol = 3) 

notas
##      [,1] [,2] [,3]
## [1,]    6    7    8
## [2,]    7    8    9
## [3,]    8    9    6
## [4,]    9    6    7
## [5,]    6    7    8
# Atribuindo nomes às colunas e linhas

colnames(notas) <- c("disciplina1", "disciplina2", "disciplina3")
rownames(notas) <- c("aluno1", "aluno2", "aluno3", "aluno4", "aluno5")

notas
##        disciplina1 disciplina2 disciplina3
## aluno1           6           7           8
## aluno2           7           8           9
## aluno3           8           9           6
## aluno4           9           6           7
## aluno5           6           7           8

2.3.2.3 Acessando um dado da matriz.

# Chamando a nota do aluno2, disciplina3. Repare que os nomes aparecem entre aspas dentro dos colchetes.
notas[2,3]
## [1] 9

ou,

notas["aluno2", "disciplina3"]
## [1] 9

2.3.2.4 Acessando uma linha da matriz.

# Chamando todas as notas do aluno3
notas[3,]
## disciplina1 disciplina2 disciplina3 
##           8           9           6

ou,

notas["aluno3",]
## disciplina1 disciplina2 disciplina3 
##           8           9           6

2.3.2.5 Acessando uma coluna da matriz.

# Chamando as colunas, no caso, as notas de uma disciplina
notas[,2]
## aluno1 aluno2 aluno3 aluno4 aluno5 
##      7      8      9      6      7

ou,

notas[,"disciplina2"]
## aluno1 aluno2 aluno3 aluno4 aluno5 
##      7      8      9      6      7

2.3.2.6 Acessando várias linhas e/ou colunas da matriz.

Ainda podemos chamar mais de uma linha (ou coluna) simultâneamente utilizando o intervalo desejado no comando c(incio:fim), no caso de serem sequenciais. Ou ainda, c(linha x, linha y, linha z). Ou ainda, a combinação de ambos: c(incio:fim, linha x).

Acessando as linhas 1 e 2 e a coluna 2

notas[c(1:2), 2]
## aluno1 aluno2 
##      7      8

ou,

notas[c(1:2), "disciplina2"]
## aluno1 aluno2 
##      7      8

Acessando as linhas 1, 2 e 5 e a coluna 2

notas[c(1:2,5), 2]
## aluno1 aluno2 aluno5 
##      7      8      7

ou,

notas[c(1:2,5), "disciplina2"]
## aluno1 aluno2 aluno5 
##      7      8      7

Acessando as linhas 1 e 2 e as colunas 2 e 3.

notas[1:2, c(2:3)]
##        disciplina2 disciplina3
## aluno1           7           8
## aluno2           8           9

2.3.2.7 Realizando operações com linhas ou colunas de uma matriz

Em matrizes numéricas é possível somar suas linas ou colunas.

# 1. Criando a matriz para exemplificar
matriz <- matrix(c(10, 12, 11, 13, 8, 9, 10, 13, 12, 18, 17, 19), 
                 nrow = 3, ncol = 4, byrow = TRUE,
                 dimnames = list(
                            c("Linha A", "Linha B", "Linha C"),
                            c("Coluna1", "Coluna2", "Coluna3", "Coluna4")))

2 # Imprimindo a matriz
## [1] 2
matriz
##         Coluna1 Coluna2 Coluna3 Coluna4
## Linha A      10      12      11      13
## Linha B       8       9      10      13
## Linha C      12      18      17      19
3 # Realizando a soma de linhas
## [1] 3
rowSums(matriz)
## Linha A Linha B Linha C 
##      46      40      66
4 # Realizando a soma de colunas
## [1] 4
colSums(matriz)
## Coluna1 Coluna2 Coluna3 Coluna4 
##      30      39      38      45

2.3.3 Data-frames

Data.frame é uma estrutura de dados similar a matriz. No entanto, cada coluna pode ter um tipo distinto de variável, por exemplo, uma coluna com tipo texto e outra com tipo numérico.

  • uma coluna pode ser chamada de variável (cuidado para não confundir!).
  • uma linha pode ser chamada de registro, observação ou caso.

Vídeo - Criando e manipulando data-frames e listas.

Criando um data.frame chamado df:
df <- data.frame(nome = c(“Adriano”, “José”, “Maria”, “Ana”), idade = c(55, 15, 23, 35))

# um data.frame com duas colunas, a primeira com nomes, e a segunda com idades.
# relembrando: os data.frames são tabelas que armazenam diversos tipos de dados - atenção, uma coluna, também chamada de variável, pode armazenar apenas um tipo de dado.
df <- data.frame(nome = c("Adriano", "José", "Maria", "Ana"), idade = c(55, 15, 23, 35))

df
##      nome idade
## 1 Adriano    55
## 2    José    15
## 3   Maria    23
## 4     Ana    35

Os data.frames, de forma similar às matrizes, podem receber nomes para as colunas e linhas. Os comandos são similares aos das matrizes.

colnames(df) <- c(“NOMES”, “IDADES”)

rownames(df) <- rep(“Aluno”,7)

# Atribuindo nomes às colunas e linhas de um data.frame df
colnames(df) <- c("NOMES", "IDADES")
rownames(df) <- c("Aluno1","Aluno2", "Aluno3", "Aluno4")

df
##          NOMES IDADES
## Aluno1 Adriano     55
## Aluno2    José     15
## Aluno3   Maria     23
## Aluno4     Ana     35

Também, de forma similar à matriz, podemos realizar as chamadas de um data.frame.

df[“Aluno1”,“IDADES”]

df["Aluno1","IDADES"]
## [1] 55

Ou ainda, podemos realizar as chamadas das colunas utilizando o “$”.

df$NOMES
## [1] "Adriano" "José"    "Maria"   "Ana"

Ou ainda, podemos realizar as chamadas das colunas utilizando o “$” e a linha desejada entre colchetes.

df$NOMES[3]
## [1] "Maria"
Resumo Comparativo de Acesso a Colunas no R.
Método Retorno Padrão Uso Principal
df$col Vetor Uso rápido no console e cálculos simples.
df[, "col"] Vetor Programação e seleção dinâmica.
df["col"] Data-frame Quando você precisa manter a estrutura de tabela.
df[[1]] Vetor Extração segura dentro de listas ou loops.

2.3.4 Listas

Lista é um tipo de variável que pode conter diversos tipos de dados, variáveis numéricas, texto, matrizes e df.

Criando uma lista chamada de lista utilizando as variáveis criadas anteriormente: lista <- list(a, x, vetor, vetor_a, mat, mat_a, df)

# Criando uma lista chamada 'lista'
lista <- list(texto = a, 
              vet = vetor, 
              vet_a = vetor_a, 
              mat_num = mat, 
              mat_nom = mat_a, 
              df =df) 
# uma lista armazena diversos tipos de estruturas de dados
# neste caso, a lista armazenou estruturas de dados criadas nos exemplos anteriores, uma variável contendo um nome (a), uma variável contendo um número (x), uma variável contendo um vetor (vetor), uma variável contendo um vetor de nomes (vetor_a), uma matriz (mat), e um data.frame (df)

print(lista)
## $texto
## [1] "O RStudio é uma ferramenta poderosa."
## 
## $vet
## [1] 10 20 30 40 50
## 
## $vet_a
## [1] "aluno" "idade" "série"
## 
## $mat_num
##        coluna1 coluna2
## linha1      10      30
## linha2      20      40
## 
## $mat_nom
##      [,1]    [,2]   
## [1,] "aluno" "aluno"
## [2,] "aluno" "aluno"
## 
## $df
##          NOMES IDADES
## Aluno1 Adriano     55
## Aluno2    José     15
## Aluno3   Maria     23
## Aluno4     Ana     35

2.3.4.1 Chamadas de listas

  1. O Operador de Cifrão ($).

    É a maneira mais amigável. Você digita o nome da lista, coloca o cifrão e o R já te mostra os nomes das “gavetas” nas quais os dados estão armazenados.
1 # Chamando o elemento 'a' da lista criada acima
## [1] 1
print(lista$texto)
## [1] "O RStudio é uma ferramenta poderosa."
2 # Chamando o 'vetor_a' da lista.
## [1] 2
print(lista$vet_a)
## [1] "aluno" "idade" "série"
3 # Chamando o 'df' da lista
## [1] 3
print(lista$df)
##          NOMES IDADES
## Aluno1 Adriano     55
## Aluno2    José     15
## Aluno3   Maria     23
## Aluno4     Ana     35
  1. Colchetes Duplos [[ ]] — dá acesso direto ao conteúdo.

    Imagine que os colchetes simples [ ] selecionam a gaveta inteira (com madeira e tudo), enquanto os colchetes duplos [[ ]] pegam apenas o que está dentro da gaveta. Repare que o nome da ‘gaveta’ vem entre aspas.
1 # chamando o conteúdo de lista$texto
## [1] 1
lista[["texto"]]
## [1] "O RStudio é uma ferramenta poderosa."
2 # Chamando o conteúdo de lista$df - utilizarei o 'print' para melhor visualização
## [1] 2
print(lista[["df"]])
##          NOMES IDADES
## Aluno1 Adriano     55
## Aluno2    José     15
## Aluno3   Maria     23
## Aluno4     Ana     35

Também podemos chamar o conteúdo da ‘gaveta’ pelo seu número sequencial.

1 # chamando o conteúdo de lista$texto
## [1] 1
lista[[1]]
## [1] "O RStudio é uma ferramenta poderosa."

Quando a gaveta tem subdivisões, para chamar o conteúdo de suas subdiviões, utilize dois estágios, primeiro chame a gaveta, e depois chame o seu conteúdo conforme os padrões utilizados para data.frame, matriz, vetor,….

1 # Chamando o dado que está na linha 1 e coluna 2 do df da lista
## [1] 1
lista$df[1,2]
## [1] 55
2 # Chamando a coluna 1 do df da lista - utilizei o print para facilitar a visualização
## [1] 2
print(lista$d[,1])
## [1] "Adriano" "José"    "Maria"   "Ana"

Resumo Visual

Comando O que você está fazendo? Resultado Prático
lista[1] Selecionando uma fatia da lista (a gaveta fechada). Uma nova Lista (menor).
lista[[1]] Abrindo a gaveta e pegando o conteúdo. O objeto original (Vetor, DF, etc).
lista$temp Acessando o conteúdo através do nome. O objeto original (igual ao [[ ]]).

Tabela: Resumo Visual de Acesso a Listas no R

Dica de Ouro: Se você estiver na dúvida sobre o que tem dentro da lista, use o comando str(lista). Ele mostra a estrutura completa e “desenha” os caminhos para você.

2.4 Comandos básicos

Os comando básicos são utilizados na maioria das atividades de quem trabalha com o RStudio.

2.4.1 Limpando variáveis

O comando para limpar as variáveis é:
rm(VARIÁVEL1, VARIÁVEL2,…)

x <- 3 # Criando a variável x
y <- 5 # Criando a variável y

rm(x,y)
#print(x) # Comando gerará a mensagem: 'Erro: objeto 'x' não encontrado'
#print(y) # Comando gerará a mensagem: 'Erro: objeto 'y' não encontrado'

O comando para limpar todas as variáveis do ambiente é:
rm(list=ls())
As variáveis podem ser limpas por meio do ícone da vassoura na aba “Enviroment”
Limpando as variáveis

Para limpar a memória utilizada pelo programa utiliza-se o comando:
gc(full = TRUE)

rm(list=ls())

gc(full = TRUE)
##           used (Mb) gc trigger  (Mb) max used (Mb)
## Ncells 1117305 59.7    2318038 123.8  1405292 75.1
## Vcells 1996591 15.3    8388608  64.0  3572567 27.3

2.4.2 Operações com strings

As variáveis podem receber diversos tipos de dados, mas NÃO É POSSÍVEL FAZER OPERAÇÕES ARITIMÉTICAS COM TEXTO

x <- 2 y <- “O valor de x é:”
z <- x + y - essa operação gerará erro

2.4.2.1 Comandos ‘paste() e paste0()’

O comando paste concatena (junta) as duas variáveis
z <- paste(y, x)
print(z)

Exemplos

Exemplo:

x <- 2
y <- "O valor de x é: "    

paste(y, x)
## [1] "O valor de x é:  2"

Exemplo:

x <- 2
y <- "Posso concatenar números - "    

paste(y, x, " - e textos")
## [1] "Posso concatenar números -  2  - e textos"

O comando paste0() é um comando de concatenação similar ao paste(), no entanto ele não cria espaços entre palavras.

Exemplo:

1 #paste("A","dri","a","no")
## [1] 1
paste("A","dri","a","no")
## [1] "A dri a no"
2 #paste0("A","dri","a","no")
## [1] 2
paste0("A","dri","a","no")
## [1] "Adriano"

O comando cat também imprime na tela, mas ele pode concatenar direto
cat(“O valor de x é:”, x)

Exemplo:

cat("O valor de x é: ", x)  
## O valor de x é:  2

2.4.2.2 Comandos ‘trimws()’, ‘toupper()’, ‘tolower()’ e ‘grep()’

O comando ‘trimws()’ remove os espaços em branco extras do início e do final de uma string.  O comando ‘toupper()’ transforma todas as letras para maiúscula.

        1  # Texto com espaços
## [1] 1
        texto_original <- "  Estatística com R  "
        print(texto_original)
## [1] "  Estatística com R  "
        2  # Remover espaços em branco do início e fim
## [1] 2
        texto_sem_espacos_extras <- trimws(texto_original)
        print(texto_sem_espacos_extras)
## [1] "Estatística com R"
        3  # Transformar para maiúsculas
## [1] 3
        texto_maiusculo <- toupper(texto_sem_espacos_extras)
        print(texto_maiusculo)
## [1] "ESTATÍSTICA COM R"
        4  # Transformar para minúsculas
## [1] 4
        texto_minusculo <- tolower(texto_sem_espacos_extras)
        print(texto_minusculo)
## [1] "estatística com r"

O comando ‘grep()’ localiza um padrão

# 1. Criando um vetor de nomes
frutas <- c("Maçã", "Banana", "Laranja", "Caju", "Graviola")

# 2. Buscar onde aparece o termo "aju"
resultado <- grep(pattern = "aju", x = frutas, ignore.case = TRUE)

3 # O resultado é '[1] 4' - pois "Caju" é o quarto elemento
## [1] 3
print(resultado)
## [1] 4
# 4. Prar retornar o nome que contém o reultado, inclua o parâmetro 'value = TRUE'
resultado <- grep(pattern = "aju", x = frutas, ignore.case = TRUE, value = TRUE)

5 # Imprimindo o novo resultado
## [1] 5
print(resultado)
## [1] "Caju"

2.4.3 Indo para a pasta de trabalho

O comando getwd() verifica o caminho da pasta em que você se encontra.

O comando setwd() permite que você vá para a pasta de trabalho desejada.

setwd(“C:/Users/ADRIANO LAURO/OneDrive/Documentos/Adriano/Trabalho/R/Dados/”)

Uma forma de encontrar o caminho de sua pasta de trabalho é copiando o endereço no Windows Explorer. Mas cuidado, nesse caso é necessário mudar as barras invertidas (típicas do Windows) para barras normais.

Utilize novamente o comando getwd() para verificar se você está na pasta desejada.

Outra forma é utilizando a library this_path - path em inglês é “caminho”. Essa biblioteca tem funções que facilitam a organização do trabalho. Veja os exemplos:

Chamando a biblioteca para poder utilizar suas funções:
library(this.path)

Colocando o caminho da pasta atual em uma variável chamada “caminho_atual”:
caminho_atual <- this.dir()

Sugere-se, para trabalhar com base de dados ou arquivos, que se crie uma pasta para os códigos fontes, uma pasta para as bases de dados ou arquivos e, uma pasta para os resultados. Desta forma os arquivos ficam organizados e facilitam o entendimento dos trabalhos e pesquisas.

Atenção! É necessário criar as pastas! Utilize o Windows Explores ou o navegador do próprio RStudio (Files - normalmente no canto inferior direito) para fazer isso. Os comandos abaixo NÃO criam as pastas, somente direcionam guardam os seus endereços.
Caminho para as bases de dados ou arquivos:
caminho_bases <- paste0(path, “/Bases/”)

Observação: o comando paste0() é um comando de concatenação similar ao paste(), que retira os espaços entre palavras. Neste caso, ele serve para evitar erro com espaços desnecessários no caminho.

Caminho para os resultados (arquivos gerados com os resultados) - gráficos, tabelas,…:
caminho_resultados <- paste0(path, “/Resultados/”)

Caminho para guardar os códigos fonte:
caminho_R <- paste0(path, “/R/”)

Observação: para criar uma variável subindo o nível (indo para a pasta de cima) da pasta atual, utilize o comando:

caminho_nivel_acima <- paste(rev(rev(strsplit(caminho_atual, “/”)[[1]])[-1]), collapse = “/”)

O comando acima utiliza as funções paste() de concatena (junta) textos;
A função strsplit() que separa as palavras de um texto - no caso, separa as palavras separadas pela barra “/”; e
A função rev() que inverte a ordem de um vetor - no caso, ela foi utilizada para tirar a última pasta do caminho, invertendo a ordem do vetor, retirando o primeiro campo e depois, voltando à ordem normal.

Exemplos

Para saber em que pasta você está trabalhando, utilize o comando getwd()

getwd()
## [1] "C:/Users/ADRIANO LAURO/OneDrive/Documentos/Adriano/Trabalho/R"

Para saber o que tem na pasta em que voce está trabalhando:
dir()

dir() # os resultados foram omitidos. Faça o teste você, no seu computador.

Você pode copiar esse caminho e ajustar a pasta desejada para o seu trabalho.
Para configurar a pasta onde vamos trabalhar, utilize o comando setwd, por exemplo:
setwd(“C:/Users/Documents/R/”)

setwd("~/Adriano/Trabalho/R")

2.4.4 Imprimindo uma informação no console

O comando print imprime no console o que está entre parentesis:
print(“Aluno”)

print("aluno")
## [1] "aluno"
x <- 5
print(x)
## [1] 5

2.4.5 Operadores aritiméticos

Os operadores do R são

  • ” + ” soma
  • ” - ” subtração
  • ” * ” multiplicação
  • ” / ” divisão
  • ” ^ ” exponenciação
  • ” %% ” resto de uma divisão

Exemplos de operações aritiméticas básicas

No R não é preciso declarar a variável
x <- 2 y <- 3

x <- 2
y <- 3

x
## [1] 2
y
## [1] 3

Operadores aritiméticos

x + y
## [1] 5
x - y
## [1] -1

Exemplo:

x * y
## [1] 6

Exemplo:

x / y
## [1] 0.6666667

Exemplo:

x ^ y # ou
## [1] 8
x ** y
## [1] 8

Exemplo:

y %% x # retorna o resto da divisão de 3 por 2, que é 1
## [1] 1

As variáveis numéricas do R se comunicam, isso quer dizer que o R entende número como número e que não precisamos distinguir o que é real e o que é inteiro.

x <- 1.34566932    
y <- 1    
z <- x + y    
z    
## [1] 2.345669

2.4.6 Operações básicas de comparação

  • ” == ” igual
  • ” != ” diferente
  • ” > ” maior
  • ” >= ” maior ou igual
  • ” < ” menor
  • ” <= ” menor ou igual

As operações de comparação retornam os valores TRUE (verdadeiro) ou FALSE (falso)

Exemplos de operações básicas de comparação

x <- 2
y <- 3
z <- 2

x == y # vai retornar FALSE, 2 é diferente de 3
## [1] FALSE

Exemplo:

x != y # vai retornar TRUE, 2 é diferente de 3
## [1] TRUE

Exemplo:

x < y # vai retornar TRUE, 2 é menor do que 3
## [1] TRUE

Exemplo:

x > y # vai retornar FALSE, 2 é menor do que 3
## [1] FALSE

Exemplo:

x >= y # vai retornar FALSE, 2 é menor do que 3
## [1] FALSE

Exemplo:

y >= y # vai retornar TRUE, 2 é igual a 2
## [1] TRUE

Exemplo:

y <= y # vai retornar TRUE, 2 é igual a 2
## [1] TRUE

2.4.7 Leitura do console

Serão apresentados os dois principais comandos, readline(), para leitura de textos e scan(), para leitura de números.

2.4.7.1 Comando readline()

O comando readline() lê uma informação texto da tela do prompt
print(“Digite um valor:”)

x <- readline()

Mas, preste atenção! O readline() lê string, não número. Se for digitado número, o computador entenderá esse número como texto.

print(x)

Exemplo

Execute os comandos no seu computador

print("Digite um valor: ")    
## [1] "Digite um valor: "
x <- readline()   # preste atenção! O readline() lê string, não número    
print(x)          # O retorno é "" porque não houve digitação no console
## [1] ""

2.4.7.2 Comando scan()

Para ler número, utilize a função scan()

cat(“Digite um valor:”)

x <- scan(nmax = 1)

Exemplo

Execute os comandos no seu computador

cat("Digite um valor: ")     
## Digite um valor:
x <- scan(nmax = 1)  

x
## numeric(0)

Como não houve digitação no console, o retorno é ## numeric(0)

2.4.8 Operadores Lógicos

Os operadores lógicos são:

  • ” & ” - e (and)
  • ” | ” - ou (or)
  • ” ! ” - negação

Uma boa forma de entender esses operadores é por meio da Tabela Verdade

tv <- data.frame(Variáveis = c("Verdadeiro", "Verdadeiro", "Verdadeiro", "Verdadeiro", "Falso", "Falso", " ", " "),
                 Operador = c("&","|","&","|","&","|", "!","!"),
                 Variáveis2 = c("Verdadeiro", "Verdadeiro","Falso", "Falso", "Falso","Falso", "Verdadeiro","Falso"), 
                 Resultado = c("Verdadeiro", "Verdadeiro","Falso", "Verdadeiro","Falso","Falso", "Falso", "Verdadeiro") )
tv
##    Variáveis Operador Variáveis2  Resultado
## 1 Verdadeiro        & Verdadeiro Verdadeiro
## 2 Verdadeiro        | Verdadeiro Verdadeiro
## 3 Verdadeiro        &      Falso      Falso
## 4 Verdadeiro        |      Falso Verdadeiro
## 5      Falso        &      Falso      Falso
## 6      Falso        |      Falso      Falso
## 7                   ! Verdadeiro      Falso
## 8                   !      Falso Verdadeiro
TRUE & TRUE
## [1] TRUE
TRUE | TRUE
## [1] TRUE
TRUE & FALSE
## [1] FALSE
TRUE | FALSE
## [1] TRUE
FALSE & FALSE
## [1] FALSE
FALSE | FALSE
## [1] FALSE

2.4.9 Criando números aleatórios

A criação de números aleatórios pode atender diversas distribuições de probabilidade.

Normal:
rnorm(100, mean = 7, sd = 1)
Onde 100 é a quantidade de números gerados;
mean = 7 é a média em torno da qual os números serão criados;
sd = 1 é o desvio padrão a partir do qual os números serão criados.

Uniforme: runif(n = 10, min = 5, max = 20) n = 10 - quantidade de números gerados min = 5 - valor mínimo gerado max = 20 - valor máximo gerado

Binomial: rbinom(quantidade, tamanho, probabilidade)

Exemplos

Exemplo distribuição normal

rnorm(10, mean = 7, sd = 1) 
##  [1] 6.723903 7.524796 8.451470 7.859572 6.415011 5.563655 5.738078 9.054268
##  [9] 6.612211 6.089230
# Plotando o histograma para melhor entendimento
hist(rnorm(n = 1000, mean = 5, sd = 2))

Exemplo distribuição uniforme

runif(n = 10, min = 5, max = 20) # Criando 10 números (n), com valor mínimo de 5 e valor máximo de 20
##  [1]  9.486840 11.257744  7.205385 13.421465  6.241066  9.100683 12.748431
##  [8] 12.568301 12.486633 13.033882
# Plotando o histograma para melhor entendimento
hist(runif(n = 1000, min = 5, max = 20))

Exemplo distribuição binomial

rbinom(10, 50, 0.5) 
##  [1] 30 28 24 31 25 23 27 26 24 19
# Plotando o histograma para melhor entendimento
hist(rbinom(1000, 50, 0.7))

2.4.10 Funções estatísticas básicas


As funções estatísticas básicas são, normalmente, aplicadas à vetores, matrizes, data-frames ou variáveis de uma lista.
Para exemplificar utilizaremos um vetor de x de 1 a 10, uma matriz chamada mat, e um data-frame disponível no R chamado mtcars.
Os dados são:

# Vetor x
x <- 1:10
x
##  [1]  1  2  3  4  5  6  7  8  9 10
# Matriz mat
mat <- matrix(1:25, nrow = 5, ncol = 5)
mat
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    6   11   16   21
## [2,]    2    7   12   17   22
## [3,]    3    8   13   18   23
## [4,]    4    9   14   19   24
## [5,]    5   10   15   20   25
# Data-frame mtcars - apresentando apenas as 3 primeiras linhas
head(mtcars, 3)
##                mpg cyl disp  hp drat    wt  qsec vs am gear carb
## Mazda RX4     21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
## Mazda RX4 Wag 21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
## Datsun 710    22.8   4  108  93 3.85 2.320 18.61  1  1    4    1


As funções estatísticas básicas são:

max(x) identifica o valor máximo de um vetor ou matriz.
Exemplos:

# Maior número do vetor x
max(x)
## [1] 10
# Maior número de mat
max(mat)
## [1] 25
# Maior número da 4 coluna de mat
max(mat[,4])
## [1] 20
# Maior número da terceira linha de mat
max(mat[3,])
## [1] 23
# Maior valor da variável hp no data-frame mtcars
max(mtcars$hp)
## [1] 335


min(x) identifica o menor valor de um vetor ou matriz.
Exemplos:

# Menor número do vetor x
min(x)
## [1] 1
# Menor número de mat
min(mat)
## [1] 1
# Menor número da 4 coluna de mat
min(mat[,4])
## [1] 16
# Menor número da terceira linha de mat
min(mat[3,])
## [1] 3
# Menor valor da variável hp no data-frame mtcars
min(mtcars$hp)
## [1] 52


mean(x) calcula a média dos valores de um vetor ou matriz.
Exemplos:

# Média dos números do vetor x
mean(x)
## [1] 5.5
# Média dos números de mat
mean(mat)
## [1] 13
# Média dos valores da quarta coluna de mat
mean(mat[,4])
## [1] 18
# Média dos números da terceira linha de mat
mean(mat[3,])
## [1] 13
# Média dos valores da variável hp no data-frame mtcars
mean(mtcars$hp)
## [1] 146.6875


median(x) calcula a mediana dos valores de um vetor ou matriz.
Exemplos:

# Mediana dos números do vetor x
median(x)
## [1] 5.5
# Mediana dos números de mat
median(mat)
## [1] 13
# Mediana dos valores da quarta coluna de mat
median(mat[,4])
## [1] 18
# Mediana dos números da terceira linha de mat
median(mat[3,])
## [1] 13
# Mediana dos valores da variável hp no data-frame mtcars
median(mtcars$hp)
## [1] 123


sd(x) identifica o desvio padrão (standart error) dos valores de um vetor ou matriz.
Exemplos:

# Desvio-padrão dos valores do vetor x
sd(x)
## [1] 3.02765
# Desvio-padrão dos valores de mat
sd(mat)
## [1] 7.359801
# Desvio-padrão dos valores da 4 coluna de mat
sd(mat[,4])
## [1] 1.581139
# Desvio-padrão dos valores da terceira lina de mat
sd(mat[3,])
## [1] 7.905694
# Desvio-padrão dos valores da variável hp no data-frame mtcars
sd(mtcars$hp)
## [1] 68.56287


summary(x) calcula um sumários estatístico dos valores de um vetor ou matriz: quartis, média, máximo e mínimo
Exemplos:

# Sumário estatístico dos valores do vetor x
summary(x)
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##    1.00    3.25    5.50    5.50    7.75   10.00
# Sumário estatístico dos valores de mat
summary(mat)
##        V1          V2           V3           V4           V5    
##  Min.   :1   Min.   : 6   Min.   :11   Min.   :16   Min.   :21  
##  1st Qu.:2   1st Qu.: 7   1st Qu.:12   1st Qu.:17   1st Qu.:22  
##  Median :3   Median : 8   Median :13   Median :18   Median :23  
##  Mean   :3   Mean   : 8   Mean   :13   Mean   :18   Mean   :23  
##  3rd Qu.:4   3rd Qu.: 9   3rd Qu.:14   3rd Qu.:19   3rd Qu.:24  
##  Max.   :5   Max.   :10   Max.   :15   Max.   :20   Max.   :25
# Sumário estatístico dos valores da 4 coluna de mat
summary(mat[,4])
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##      16      17      18      18      19      20
# Sumário estatístico dos valores da terceira lina de mat
summary(mat[3,])
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##       3       8      13      13      18      23
# Sumário estatístico dos valores da variável hp no data-frame mtcars
summary(mtcars$hp)
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##    52.0    96.5   123.0   146.7   180.0   335.0
# Sumário estatístico dos do data-frame mtcars
summary(mtcars)
##       mpg             cyl             disp             hp       
##  Min.   :10.40   Min.   :4.000   Min.   : 71.1   Min.   : 52.0  
##  1st Qu.:15.43   1st Qu.:4.000   1st Qu.:120.8   1st Qu.: 96.5  
##  Median :19.20   Median :6.000   Median :196.3   Median :123.0  
##  Mean   :20.09   Mean   :6.188   Mean   :230.7   Mean   :146.7  
##  3rd Qu.:22.80   3rd Qu.:8.000   3rd Qu.:326.0   3rd Qu.:180.0  
##  Max.   :33.90   Max.   :8.000   Max.   :472.0   Max.   :335.0  
##       drat             wt             qsec             vs        
##  Min.   :2.760   Min.   :1.513   Min.   :14.50   Min.   :0.0000  
##  1st Qu.:3.080   1st Qu.:2.581   1st Qu.:16.89   1st Qu.:0.0000  
##  Median :3.695   Median :3.325   Median :17.71   Median :0.0000  
##  Mean   :3.597   Mean   :3.217   Mean   :17.85   Mean   :0.4375  
##  3rd Qu.:3.920   3rd Qu.:3.610   3rd Qu.:18.90   3rd Qu.:1.0000  
##  Max.   :4.930   Max.   :5.424   Max.   :22.90   Max.   :1.0000  
##        am              gear            carb      
##  Min.   :0.0000   Min.   :3.000   Min.   :1.000  
##  1st Qu.:0.0000   1st Qu.:3.000   1st Qu.:2.000  
##  Median :0.0000   Median :4.000   Median :2.000  
##  Mean   :0.4062   Mean   :3.688   Mean   :2.812  
##  3rd Qu.:1.0000   3rd Qu.:4.000   3rd Qu.:4.000  
##  Max.   :1.0000   Max.   :5.000   Max.   :8.000


hist(x) faz um histograma dos valores de um vetor ou matriz
Exemplos:

# Histograma dos valores da variável hp no data-frame mtcars
hist(mtcars$hp)


Exemplos

Cálculos estatísticos com vetor contendo números que compõem uma distribuição uniforme.

# Distribuição uniforme
y <- runif(10000, min = 0, max = 100)
max(y)
## [1] 99.98592
min(y)
## [1] 5.995389e-05
mean(y)
## [1] 50.237
sd(y)
## [1] 29.01672
summary(y)
##     Min.  1st Qu.   Median     Mean  3rd Qu.     Max. 
##  0.00006 24.67052 50.32654 50.23700 75.62557 99.98592
hist(y)


Outro exemplo - cálculos estatísticos com vetor contendo números que compõem uma distribuição normal

# Vetor contendo 10000 elemento compondo uma distribuição normal com média 10 e desvio-padrão 2
y <- rnorm(10000, 10, 2)
max(y)
## [1] 17.04149
min(y)
## [1] 1.859349
mean(y)
## [1] 10.01469
sd(y)
## [1] 2.009977
hist(y)

summary(y)
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##   1.859   8.645   9.994  10.015  11.335  17.041

2.4.11 Arredondamentos

round(número a ser arredondado, quantidade de casas decimais) - arredonda para a quantidade de casas decimais desejada.

round(0.9384,1)
## [1] 0.9
round(0.9499999999,3)
## [1] 0.95

floor(número) - arredonda para o primeiro número inteiro inferior.

floor(0.93)
## [1] 0
floor(8.67)
## [1] 8
floor(-5.84)
## [1] -6

ceiling(número) - arredonda para o primeiro número inteiro superior.

ceiling(10.93)
## [1] 11
ceiling(-5.84)
## [1] -5

trunc(número) - retira as casas decimais do número.

trunc(0.93)
## [1] 0
trunc(10.93)
## [1] 10

2.4.12 Notação científica

O R automaticamente insere a notação científica para números muito grandes. Para forçar que os números não apareçam em notação científica, utilize o comando:
options(scipen = 999)

num <- 1234789012388889999999221
print(num)
## [1] 1.234789e+24
# Aplicando o comando "options(scipen = 999)"
options(scipen = 20)
print(num)
## [1] 1234789012388889965462200

2.5 Comandos de decisão

Os comandos de decisão são aqueles que permitem a escolha do caminho que se pretende seguir para a elaboração de um programa. Em outras palavras, são aqueles que decidem entre situações distintas.
Eles utilizam basicamente os comandos if, else, else if e ifelse. Veja como cada um deles funciona.

Esses comando são utilizados com os operadores de comparação:
- ” == ” igual
- ” != ” diferente
- ” > ” maior
- ” >= ” maior ou igual
- ” < ” menor
- ” <= ” menor ou igual

Eles também podem ser compostos com operadores lógicos:

  • ” & ” - e (and)
  • ” | ” - ou (or)
  • ” ! ” - negação

2.5.1 Comando if

O comando if compara duas variáveis e decide o caminho a tomar considerando o resultado.
Os comandos a serem executados após a decisão devem estar entre chaves ({ }).
Sua estrutura básica é:
Estrutura do if
Veja o exemplo.

x <- 2
y <- 3

if(x < y){
  cat("x é menor do que y e seu valor é:", x, "- o valor de y é: ", y)
}
## x é menor do que y e seu valor é: 2 - o valor de y é:  3


2.5.2 Comando if e else

Quando se deseja incluir um caminho alternativo ao comando if utiliza-se o comando else.
Sua estrutura básica é:
Estrutura do if e else if
Veja o exemplo.

x <- 4
y <- 3

if(x < y){
  cat("x é menor do que y e seu valor é: ", x,"- o valor de y é: ", y)
} else {
  cat("x é maior do que y e seu valor é: ", x ,"- o valor de y é: ", y)
}
## x é maior do que y e seu valor é:  4 - o valor de y é:  3


2.5.3 Comando if e else if

Quando se deseja incluir diversos caminhos alternativos ao comando if, utiliza-se o comando else if. Neste caso, é necessário incluir a condição.
Sua estrutura básica é:
Estrutura do if e else if
Veja o exemplo.

x <- "c"

if(x == "a"){
  cat("x é menor do que zero")
} else if(x == "b"){
  cat("x é maior do que 0")
} else if(x == "0"){
  cat("x é igual a zero")
} else if(x == "0"){
  cat("x não é 'a', nem 'b', nem '0'.")
}

# Sugere-se que o usuário altere os valoes de x e y e veja o comportamento da função.


2.5.4 Comando ifelse

A função ifelse é uma forma mais direta de executar o comando de decisão. Neste caso, não será possível incluir uma sequência de comandos se verdadeiro ou falso, será possível incluir apenas o valor do resultado da comparação.
Sua estrutura básica é:
Estrutura do ifelse
Veja o exemplo:

x <- 4
y <- 3

ifelse(x < y, x ,y)
## [1] 3


2.6 Comandos de repetição

Os comandos de repetição ou loop mais comuns são:
- for
- while
- repeat

Assim como os comandos de decisão, esses comandos são utilizados com os operadores de comparação:
- ” == ” igual
- ” != ” diferente
- ” > ” maior
- ” >= ” maior ou igual
- ” < ” menor
- ” <= ” menor ou igual

Eles também podem ser compostos com operadores lógicos:

  • ” & ” - e (and)
  • ” | ” - ou (or)
  • ” ! ” - negação

Vamos estudar cada um deles.

2.6.1 for

A sintaxe básica do for é:

for ( vetor a ser percorrido ){
sequência de comandos
}

Este comando repete o código entre chaves obedecendo a condição entre parêntesis.
Exemplo:

for(i in 1:5){
  print(i)
}
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

2.6.2 while

A sintaxe básica do while é:

while(condição){
sequência de comandos
}

“While” significa “enquanto”. Ou seja, os comandos entre chaves serão executados enquanto a condição entre parêntesis for verdadeira.
Atenção: é necessário definir a variável que vai gerar a condição antes de entrar no loop e garantir que essa variável atingirá uma condição diferente de “verdadeiro” durante o loop. Caso isso não ocorra o while entrará em loop infinito e exigirá interrupção forçada por parte do programador.
Exemplo:

i <- 1
while (i <= 5) {
  print(i)
  i <- i+1
}
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

2.6.3 repeat

O comando “repeat” se diferencia do “while” porque o teste da condição de parada está no fim dos comando, enquanto no comando “while” está no início da sequencia de comandos.
Veja sua sintaxe:

i <- 1 repeat {
sequência de comandos
if (Condição para que a repetição pare) break()
}

De forma similar ao comando “while” é necessário criar uma variável para teste da condição de parada antes do início do loop. E, dentro do loop é necessário assegurar que a condição de parada irá ocorrer, caso contrário o programa entrará em loop contínuo e exigirá ação do programador para forçar a parada.
Veja o exemplo:

i <- 1
repeat{
  print(i)

  i <- i+1
  if(i == 6) break
}
## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

Atenção: sugere-se manter o incremento de “i” logo acima do teste da condição de parada para evitar dificuldades de interpretação.

2.7 Funções


Video Criando funções
Quando desejamos realizar uma bloco de comandos repetidamente para gerar um resultado específico, criamos uma função. Podemos dizer, a grosso modo que uma função é um programa dentro de um programa principal e é criada para “economizar” linhas de código, padronizar procedimentos, facilitar a escrita e o entendimento do programa.

A sintaxe básica da função é:

identificador = function( argumento1, argumento2, …){

código
código
código

return( argumentos de retorno )
}

Alguns cuidados você deve ter ao criar uma função:

- Identificador - deve obedecer as mesmas regras do identificador das variáveis, ou seja, diferencia as letras maiúsculas e minúsculas, não pode começar com números, deve seguir um padrão que facilite a identificação de sua ação e de que é uma função.

- argumentos - os argumentos podem ser estruturas numéricas, de texto, vetores, matrizes ou data-frames. É importante que esses comandos sejam compreendidos e tenham um padrão para que não ocorram erros nos comandos internos da função. Caso um argumento seja destinado a receber um valor numérico e receba um texto, na execução interno da função ocorrerá um erro. Esse tipo de situação deve ser tratado.

- comandos - seguem os mesmos padrões dos comandos de um programa, com loops, comandos de decisão,….
- return - este comando retorna ao programa de onde é chamada o resultado do processamento executado dentro da função.

2.7.1 Exemplo com criação de funções

Veja o exemplo:

# Criando a função
maior <- function(a, b){
  ifelse( a>b, return(a), return(b))
}

# Chamando a função
a <- 5
b <- 10
c <- 15

maior(a,b)
## [1] 10
maior(c,a)
## [1] 15


# Função com string

nome_completo <- function(primeiro_nome, segundo_nome){
   
  return(cat(primeiro_nome, segundo_nome))  
  
}

nome_completo("Adriano", "Lauro")
## Adriano Lauro

3 Lendo e salvando planilhas texto e Excel

Esta seção permitirá a você ler dados de planilhas ou tabelas para que sejam trabalhados no R.
Existem muitas bases de dados de acesso livre disponíveis para pesquisas e análises que poderão ser acessadas com as instruções abaixo.
Também é possível copiar uma tabela do Excel ou do Word e carrega-la diretamente no RStudio.

3.1 Principais tipos de arquivos

Os mais comuns tipos de dados disponíveis são aqueles organizados em forma de tabelas.
Essas dados podem ser guardados em uma infinidade de formatos, sendo os mais conhecidos “.txt”, “.dat”, “.csv”, “.xls”, “.xlsx”.
O comando básico para a leitura desses dados é o read.table. Desse comando derivam diversos outros como o read.csv, read.csv2,…

Normalmente, quando se lê um arquivo, “jogamos” essas informações em uma variável tipo data-frame, mas existem tipos de dados oriundos de bibliotecas específicas, como por exemplo a tibble que é oriunda do tydverse, ou o rds, xt, ou xts.específicos para séries temporais.

Os principais pacotes para leitura e gravação de arquivos de dados (Planilhas) são, para planilhas no Excel, readxl e openxlsx. Para arquivos txt ou csv, o readr.

library(readr)
library(readxl) 
library(openxlsx)

3.2 Leitura de Dados

O R permite que se leia diversos tipos de dados e os armazene em uma variável. É possível ler formatos de dados oriundos de banco de dados, planilhas, textos, links,… Ele ainda pode se conectar diretamente a um banco de dados.

O read.table é um pacote que pode realizar essas ações e seus parâmetros são:

“file =” - aqui é atribuído o caminho do arquivo no seu computador (também pode ser o caminho da internet).

“sep =” - indica o separador das colunas. As colunas são separadas por ponto e vírgula; por vírgulas; por “|”; ou por espaços “. Para identificar como elas estão separadas, tente abrir o arquivo”.csv”, “.txt”, “.dat” em um editor de textos tipo o notepad, wordpad, notepad++, ou vi, e identifique qual símbolo é utilizado. Outra forma de fazer isso é identificando o formato em um dicionário de dados ou instruções “leiame”, “readme”.

Os arquivos “.xls”, ou “.xlsx” são lidos por pacotes específicos (readxl) e não é necessário a identificação dos separadores. Ao serem abertos por editores de texto apresentarão uma série de símbolos ilegíveis. Portanto, essa técnica de abertura no editor de textos não pode ser utilizada para esses tipos de arquivos.

3.2.1 Lendo dados da web

Utilize a função read.table

qualidade_ar <- read.table(file = “https://1drv.ms/f/c/e902693b2d6a9c3d/IgClSVi7VrZ-Ta_x9LVtiO2kARYKSiTq_5nv2D7Ct8hKZGQ?e=8Txxhf”, sep = “, header = TRUE)

qualidade_ar <- read.table(file = "https://drive.google.com/file/d/1jBgjSrg9Ef60kIEvpb7C5yccOz3MoET6/view?usp=drive_link", sep = "\t", header = TRUE)

3.2.2 Lendo dados de um arquivo csv em seu computador

Ao ler o arquivo do computador, fique atento ao endereço onde esse arquivo se encontra, ou seja, a pasta dele.
Existem diversas formas de encontrar esse caminho no seu computador. Uma delas é utilizando o navegador do RStudio, aba “Files” (normalmente, no quadrante inferior esquerdo do RStudio) e encontrar o arquivo desejado. Feito isso, clique na engrenagem e em “Copy Folder Path for Clipboard” e cole esse caminho no argumento “file” da função read.table.

Atenção! Caso esteja utilizando o Windows e copie o endereço do Windows Explorer ou de um navegador, é necessário atentar para as barras. No Windows as barras são invertidas e no R elas devem ser normais, como em um navegador da internet.

DICA!

Você pode utilizar a interface gráfica do RStudio para carregar o arquivo desejado. Acesse o ambiente “File” que, normalmente, fica no canto inferior direito, encontre o seu arquivo e clique sobre ele com o botão esquerdo do mouse. Irá surgir uma caixa com “Import Dataset…”.

Utilizando o navegado do RStudio encontre o seu arquivo.
Utilizando o navegado do RStudio encontre o seu arquivo.

Clique sobre “Import Dataset” e irá surgir a caixa de diálago (abaixo).

Importação do seu arquivo. Observe o caminho da pasta no seu computador onde se encontra o arquivo (1); o cabeçalho e como os dados estão separados (2); e o comando utilizado para a importação de dados (3).
Importação do seu arquivo. Observe o caminho da pasta no seu computador onde se encontra o arquivo (1); o cabeçalho e como os dados estão separados (2); e o comando utilizado para a importação de dados (3).

Observe você tem o caminho da pasta no seu computador onde se encontra o arquivo (1); o cabeçalho e como os dados estão separados (2); e o comando utilizado para a importação de dados (3).

No exemplo acima, as coluna não foram reconhecidas. Nesse caso, altere o campo “Delimeter” para “Semicolon” (ponto e vírgula) e as colunas passarão a ser reconhecidas. Após isso importe o arquivo.

Recomendo que você copie o código de importação e inclua no código que você está elaborando para tornar o processo mais ágil, evitando ter que abrir essa caixa toda vez que for importar o arquivo.

Outro ponto de atenção é quanto ao caminho. Algumas vezes no código apresentado em (3) o caminho surge sem o “~/” inicial - inclua esses caracteres caso o código não funicione. Em (1) o caminho aparece completo, é dessa forma que deve ser chamado no seu comando.

# Lendo o mesmo arquivo no computador - neste caso, utilizei o endereço da internet para baixar o arquivo
library(readr)
qualidade_ar  <- read_delim("~/Adriano/Trabalho/R/dados/airquality.csv", 
    delim = ";", escape_double = FALSE, trim_ws = TRUE)
## Rows: 153 Columns: 6
## ── Column specification ────────────────────────────────────────────────────────
## Delimiter: ";"
## dbl (6): Ozone, Solar.R, Wind, Temp, Month, Day
## 
## ℹ Use `spec()` to retrieve the full column specification for this data.
## ℹ Specify the column types or set `show_col_types = FALSE` to quiet this message.

3.2.3 Lendo dados de uma planilha Excel

O procedimento é similar ao da leitura de um arquivo .csv, o que muda é o pacote e a função. Observe o exemplo.

# Carregando o pacote
library(readxl)

# Aleitura do arquivo Excel deve utilizar uma outra função, a read_excel

qualidade_ar <- read_excel("~/Adriano/Trabalho/R/dados/airquality.xlsx")

# O comando acima pode ser incrementando incluindo-se o nome da planilha do arquivo Excel, caso exista mais de uma. Neste caso, utilize o comando:

qualidade_ar <- read_excel("~/Adriano/Trabalho/R/dados/airquality.xlsx", sheet = "airquality")

3.2.4 Lendo dados da área de trabalho (clipboard)

Também é possível ler uma tabela de um arquivo Word ou Excel. Para isso basta copiar a tabela (Ctrl + C) e depois chamar o comando:
tabela <- read.table(file = “clipboard”, sep = “, header=TRUE)

Veja o passo-a-passo:

  1. Selecione e copie os dados (no Word ou Excel) que deseja importar para o R (Ctrl + C).

  2. Execute o seguinte código abaixo para importar os dados copiados:
    tabela <- read.table(file = “clipboard”, sep = “, header=TRUE)

Quando copiamos os dados eles ficam armazenados no clipboard (uma memória) do nosso computador, então o R le esses dados em forma de tabela e os coloca na variável desejadas, no caso, “tabela”.

3.3 Salvando os dados

Para salvar os dados em um arquivo no seu computador é possível utilizar os comandos write.table ou write.csv2.

write.table(qualidade_ar, file = “C:/Users/ADRIANO LAURO/OneDrive/Documentos/Adriano/Trabalho/R/Dados/qualidade_ar2.csv”, sep = “;”)

Para ver documentação sobre write.table, clique no link.

O pacote writexl possui a função write_xlsx2 utilizada para salvar data-frames em formato planilha Excel, conforme apresentado no exemplo abaixo. Não esqueça de realizar a instalação e o carregamento do pacote antes de tentar utilizar a função.

# Instalando e carregando o pacote
# install.packages("writexl")
library(writexl)

# Salvando em .csv
write.table(qualidade_ar, file = "C:/Users/ADRIANO LAURO/OneDrive/Documentos/Adriano/Trabalho/R/dados/qualidade_ar2.csv", sep = ";")    

# Salvando em .txt
write.table(qualidade_ar, file = "C:/Users/ADRIANO LAURO/OneDrive/Documentos/Adriano/Trabalho/R/dados/qualidade_ar2.txt", sep = ";")   

# Salvando em .xlsx
write_xlsx(qualidade_ar, "C:/Users/ADRIANO LAURO/OneDrive/Documentos/Adriano/Trabalho/R/dados/qualidade_ar2")

4 Manipulando dados - nativo e dplyr

Existem duas formas de manipulação de dados, a nativa, com comandos básicos do R e a biblioteca dplyr, que faz parte de um conjunto maior de pacotes chamados tydverse (incluí entre outros o ggplot e dplyr).

O dplyr é uma biblioteca muito utilizada que facilita a manipulação dos dados de tabelas. Seus comando tem semelhanças com comandos SQL e com funcionalidades do Excel, o que facilita o entendimento.
A forma de utilização é intuitiva e muitos usuários têm maior facilidade para a compreensão dos seus códigos.

4.1 Bases de dados do R

Para a condução das atividades serão utilizadas as bases de dados do já existentes no R. Para saber quais são essas bases digite “data()” no console.
Ao instalar o pacote tydverse serão incluídas outras bases de dados à esse conjunto.

# Instale e carregue o pacote dplyr
library(dplyr)
# Conhecendo as bases de dados do R
data()
# A apresentação dos dados foi omitida para não poluir o documento
# Digite esse comando para verificar a variedade de bases disponíveis

Utilizaremos a “storms” por possuir diferentes tipos de dados.
Para visualizar essa base de dados utilize os comandos:

4.1.1 Comandos básicos para visualização dos dados

storms - os primeiros registros (linhas - também chamadas de casos ou observações)

# Digite storms e os dados serão apresentados no console
storms

head(storms, 2) - as 2 primeiras linhas

# Comando apresenta as 2 primeiras linhas
head(storms, 2)
## # A tibble: 2 × 13
##   name   year month   day  hour   lat  long status       category  wind pressure
##   <chr> <dbl> <dbl> <int> <dbl> <dbl> <dbl> <fct>           <dbl> <int>    <int>
## 1 Amy    1975     6    27     0  27.5   -79 tropical de…       NA    25     1013
## 2 Amy    1975     6    27     6  28.5   -79 tropical de…       NA    25     1013
## # ℹ 2 more variables: tropicalstorm_force_diameter <int>,
## #   hurricane_force_diameter <int>

tail(storms,2) - visualizara as 6 últimas linhas

# Comando apresenta as 2 últimas linhas
tail(storms, 2)
## # A tibble: 2 × 13
##   name    year month   day  hour   lat  long status      category  wind pressure
##   <chr>  <dbl> <dbl> <int> <dbl> <dbl> <dbl> <fct>          <dbl> <int>    <int>
## 1 Nicole  2022    11    11    12  33.2 -84.6 tropical d…       NA    25      999
## 2 Nicole  2022    11    11    18  35.4 -83.8 other low         NA    25     1000
## # ℹ 2 more variables: tropicalstorm_force_diameter <int>,
## #   hurricane_force_diameter <int>

dim(storms) - as dimensões da tabela (linhas e colunas)

# Comando apresenta o tamanho da base
dim(storms)
## [1] 19537    13

colnames(storms) - visualizará os nomes das colunas

# Comando apresenta o nome das colunas da base
colnames(storms)
##  [1] "name"                         "year"                        
##  [3] "month"                        "day"                         
##  [5] "hour"                         "lat"                         
##  [7] "long"                         "status"                      
##  [9] "category"                     "wind"                        
## [11] "pressure"                     "tropicalstorm_force_diameter"
## [13] "hurricane_force_diameter"
# Comando apresenta o nome das colunas e os seus tipos de dados
glimpse(storms)
## Rows: 19,537
## Columns: 13
## $ name                         <chr> "Amy", "Amy", "Amy", "Amy", "Amy", "Amy",…
## $ year                         <dbl> 1975, 1975, 1975, 1975, 1975, 1975, 1975,…
## $ month                        <dbl> 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,…
## $ day                          <int> 27, 27, 27, 27, 28, 28, 28, 28, 29, 29, 2…
## $ hour                         <dbl> 0, 6, 12, 18, 0, 6, 12, 18, 0, 6, 12, 18,…
## $ lat                          <dbl> 27.5, 28.5, 29.5, 30.5, 31.5, 32.4, 33.3,…
## $ long                         <dbl> -79.0, -79.0, -79.0, -79.0, -78.8, -78.7,…
## $ status                       <fct> tropical depression, tropical depression,…
## $ category                     <dbl> NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, N…
## $ wind                         <int> 25, 25, 25, 25, 25, 25, 25, 30, 35, 40, 4…
## $ pressure                     <int> 1013, 1013, 1013, 1013, 1012, 1012, 1011,…
## $ tropicalstorm_force_diameter <int> NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, N…
## $ hurricane_force_diameter     <int> NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, N…

4.2 Manipulando dados com comandos nativos

O R permite a manipulação e seleção de linhas e colunas na forma nativa, mas a maioria das operações podem ser realizadas por meio dos comandos do pacote dplyr.

Para melhor entendimento, vamos utilizar o data.frame “df” que contém os dados abaixo. Para você criar esse data.frame copie o código abaixo.

df <- data.frame(NOME = c("VENDEDOR 1", "VENDEDOR 2","VENDEDOR 3","VENDEDOR 4","VENDEDOR 5","VENDEDOR 6","VENDEDOR 7"), 
                 Salario_Base = c(1800, 2500, 2500, 3000,3500, 4000, 5000), 
                 Vendas = c(20000,30000,25000,15000,27000,30000,NA))
NOME Salario_Base Vendas
VENDEDOR 1 1800 20000
VENDEDOR 2 2500 30000
VENDEDOR 3 2500 25000
VENDEDOR 4 3000 15000
VENDEDOR 5 3500 27000
VENDEDOR 6 4000 30000
VENDEDOR 7 5000 NA


4.2.1 Acessando os dados

Chamando todo o df:

df[,] # não se preenche o local das linhas e colunas, chama-se todas as linhas ou colunas.
##         NOME Salario_Base Vendas
## 1 VENDEDOR 1         1800  20000
## 2 VENDEDOR 2         2500  30000
## 3 VENDEDOR 3         2500  25000
## 4 VENDEDOR 4         3000  15000
## 5 VENDEDOR 5         3500  27000
## 6 VENDEDOR 6         4000  30000
## 7 VENDEDOR 7         5000     NA

Chamada a linha 2:

df[2,] # preenche-se o espaço das linhas com o número do registro que se quer
##         NOME Salario_Base Vendas
## 2 VENDEDOR 2         2500  30000

Chamada a linhaS 2, 3 e 4:

df[c(2,3,4),] # utiliza-se a função c() contendo os itens ou o intervalo desejado.
##         NOME Salario_Base Vendas
## 2 VENDEDOR 2         2500  30000
## 3 VENDEDOR 3         2500  25000
## 4 VENDEDOR 4         3000  15000
df[c(2:4),] # mesmo resultado do comando acima
##         NOME Salario_Base Vendas
## 2 VENDEDOR 2         2500  30000
## 3 VENDEDOR 3         2500  25000
## 4 VENDEDOR 4         3000  15000

Chamada a coluna 1:

df[,1] # chamando todas as linhas da coluna 1
## [1] "VENDEDOR 1" "VENDEDOR 2" "VENDEDOR 3" "VENDEDOR 4" "VENDEDOR 5"
## [6] "VENDEDOR 6" "VENDEDOR 7"

Chamando a linha 3, coluna 1:

df[3,1] 
## [1] "VENDEDOR 3"

A coluna também pode ser chamada por seu nome:

df$NOME # chamando todas as linhas da coluna cujo nome é "NOME".
## [1] "VENDEDOR 1" "VENDEDOR 2" "VENDEDOR 3" "VENDEDOR 4" "VENDEDOR 5"
## [6] "VENDEDOR 6" "VENDEDOR 7"

Chamando a linha 3 da coluna “NOME”:

df$NOME[3] 
## [1] "VENDEDOR 3"

Chamando as linhas 3, 4 e 5 da coluna “NOME”:

df$NOME[c(3:5)] 
## [1] "VENDEDOR 3" "VENDEDOR 4" "VENDEDOR 5"

Chamando colunas 1 e 2 e todas suas linhas:

df[,c(1,2)] 
##         NOME Salario_Base
## 1 VENDEDOR 1         1800
## 2 VENDEDOR 2         2500
## 3 VENDEDOR 3         2500
## 4 VENDEDOR 4         3000
## 5 VENDEDOR 5         3500
## 6 VENDEDOR 6         4000
## 7 VENDEDOR 7         5000

Chamando colunas 1 e 3, linhas 5:

df[5,c(1,3)] 
##         NOME Vendas
## 5 VENDEDOR 5  27000

4.2.2 Condicional nos comandos básicos

É possível utilizar condições para definição de um subconjunto do data.frame.
Veja o exemplo:
Chamando todas as linhas cujo valor da coluna 2 (salario_base) é menor do que 2900:

df[df$Salario_Base < 2900,]
##         NOME Salario_Base Vendas
## 1 VENDEDOR 1         1800  20000
## 2 VENDEDOR 2         2500  30000
## 3 VENDEDOR 3         2500  25000

No caso acima, a condição de comparação da coluna é colocada na posição da linha.
Outra forma de escrever o mesmo comando:

df[df[,2] < 2900,]
##         NOME Salario_Base Vendas
## 1 VENDEDOR 1         1800  20000
## 2 VENDEDOR 2         2500  30000
## 3 VENDEDOR 3         2500  25000

É possível combinar condições de diversas colunas:

df[df$Salario_Base < 2900 & df$Vendas > 25000,]
##         NOME Salario_Base Vendas
## 2 VENDEDOR 2         2500  30000

É possível chamar dados tipo texto:

df[df$NOME == "VENDEDOR 4",]
##         NOME Salario_Base Vendas
## 4 VENDEDOR 4         3000  15000

4.2.3 Criando linhas

Para se criar uma linha devemos atribuir os valores para cada coluna dessa nova linha:
Veja o exemplo:

df[8,] <- c("Vendedor 8", 1000, 10000) # cuidado

4.2.4 Atualização de dados

A atualização de dados existentes pode ser feita atribuindo-se o novo valor à posição referenciadas.
Exemplo - atualizando o salário base do vendedor 8:

df[8,2] <- 1920
df[8,]
##         NOME Salario_Base Vendas
## 8 Vendedor 8         1920  10000

Ou:

df$Salario_Base[8] <- 1920
df[8,]
##         NOME Salario_Base Vendas
## 8 Vendedor 8         1920  10000

4.2.5 Criando colunas

df$Perc_comissao <- 5 # todas as linhas dessa nova coluna receberão o valor 5
colnames(df)
## [1] "NOME"          "Salario_Base"  "Vendas"        "Perc_comissao"

É possível criar colunas com valores compostos das demais colunas.
Criaremos uma coluna “Salario” cujo valor é salario_base + (Vendas * Perc_comissao/100).
Veja o exemplo:

# Para fazer essa operação temos que transformar os dados das colunas 2 e 3 que eram de "chr" para numérico. Isso é feito com os comandos abaixo.
df[,2] <- as.numeric((df[,2]))
df[,3] <- as.numeric((df[,3]))

# Agora criamos a nova coluna
df$Salario <- df$Salario_Base + df$Vendas*df$Perc_comissao/100

4.2.6 Unindo linhas - rbind

O comando rbind é utilizado para unir linhas de bases de tabelas distintas. Para sua utilização é fundamental que a quantidade de colunas seja a mesma.
Vamos supor que tenhamos uma outra tabela com mais três vendedores que foram adicionados ao grupo de colaboradores e queremos unir essas tabelas.

Veja essa tabela:

##          NOME Salario_Base Vendas Perc_comissao Salario
## 1  VENDEDOR 8         1800  18000             5    2700
## 2  VENDEDOR 9         2500  20000             5    3500
## 3 VENDEDOR 10         2500  19000             5    3450

O comando para unir as linhas (as tabelas) é rbind(tabela, tabela_nova).
Veja o exemplo.

Veja essa tabela:

rbind(df,df2)
##           NOME Salario_Base Vendas Perc_comissao Salario
## 1   VENDEDOR 1         1800  20000             5    2800
## 2   VENDEDOR 2         2500  30000             5    4000
## 3   VENDEDOR 3         2500  25000             5    3750
## 4   VENDEDOR 4         3000  15000             5    3750
## 5   VENDEDOR 5         3500  27000             5    4850
## 6   VENDEDOR 6         4000  30000             5    5500
## 7   VENDEDOR 7         5000     NA             5      NA
## 8   Vendedor 8         1920  10000             5    2420
## 9   VENDEDOR 8         1800  18000             5    2700
## 10  VENDEDOR 9         2500  20000             5    3500
## 11 VENDEDOR 10         2500  19000             5    3450

4.2.7 Unindo colunas - cbind

O comando cbind() é similar ao rbind(), no entanto ele une as colunas.
Nesse caso é necessário que as colunas tenham a mesma quantidade de linhas.
Vamos supor que queremos adicionar uma coluna com o percentual da comissão dos vendedores, com percentual de 5%.

Veja essa coluna.

# Como o df tem 8 linhas, tenho que criar uma coluna com 8 repetições de 0.05
Percentual_comissao <- rep(0.05,8)

A sintaxe do comando é cbind(tabela, coluna_nova), ou cbind(coluna, coluna_nova).

Veja o exemplo:

cbind(df, Percentual_comissao)
##         NOME Salario_Base Vendas Perc_comissao Salario Percentual_comissao
## 1 VENDEDOR 1         1800  20000             5    2800                0.05
## 2 VENDEDOR 2         2500  30000             5    4000                0.05
## 3 VENDEDOR 3         2500  25000             5    3750                0.05
## 4 VENDEDOR 4         3000  15000             5    3750                0.05
## 5 VENDEDOR 5         3500  27000             5    4850                0.05
## 6 VENDEDOR 6         4000  30000             5    5500                0.05
## 7 VENDEDOR 7         5000     NA             5      NA                0.05
## 8 Vendedor 8         1920  10000             5    2420                0.05

4.2.8 Tratando dados NA

Muitas vezes as bases de dados possuem registros que não possuem dados em determinada coluna. A falta desses dados pode gerar erros em operações e análises estatísticas, por isso é importante saber trata-los.

Existe uma série de comandos para realizar a identificação e tratamento dos NA, “Not Available” (não disponível).

na.omit - remove elementos ‘NA’ do vetor. Repare que no comando abaixo o registro 7 será eliminado.

# Comando remove a linha 7 df porque possui um valor 'NA'
na.omit(df)
##         NOME Salario_Base Vendas Perc_comissao Salario
## 1 VENDEDOR 1         1800  20000             5    2800
## 2 VENDEDOR 2         2500  30000             5    4000
## 3 VENDEDOR 3         2500  25000             5    3750
## 4 VENDEDOR 4         3000  15000             5    3750
## 5 VENDEDOR 5         3500  27000             5    4850
## 6 VENDEDOR 6         4000  30000             5    5500
## 8 Vendedor 8         1920  10000             5    2420

Caso você queira salvar o df sem esse valor, utilize o comando abaixo.

# Comando remove a linha 7 df porque possui um valor 'NA' e carrega em df1
df1 <- na.omit(df)

is.na - retorna um vetor lógico indicando quais os elementos não ‘NA’. Normalmente, esse comando é utilizado em condicionais para identificação e/ou alteração de dados.

is.na(df)
##    NOME Salario_Base Vendas Perc_comissao Salario
## 1 FALSE        FALSE  FALSE         FALSE   FALSE
## 2 FALSE        FALSE  FALSE         FALSE   FALSE
## 3 FALSE        FALSE  FALSE         FALSE   FALSE
## 4 FALSE        FALSE  FALSE         FALSE   FALSE
## 5 FALSE        FALSE  FALSE         FALSE   FALSE
## 6 FALSE        FALSE  FALSE         FALSE   FALSE
## 7 FALSE        FALSE   TRUE         FALSE    TRUE
## 8 FALSE        FALSE  FALSE         FALSE   FALSE

Para substituir um valor ‘NA’ por outro, utilize o comando abaixo. Observe a linha 7.

df[is.na(df)] <- 0
df
##         NOME Salario_Base Vendas Perc_comissao Salario
## 1 VENDEDOR 1         1800  20000             5    2800
## 2 VENDEDOR 2         2500  30000             5    4000
## 3 VENDEDOR 3         2500  25000             5    3750
## 4 VENDEDOR 4         3000  15000             5    3750
## 5 VENDEDOR 5         3500  27000             5    4850
## 6 VENDEDOR 6         4000  30000             5    5500
## 7 VENDEDOR 7         5000      0             5       0
## 8 Vendedor 8         1920  10000             5    2420

4.3 Manipulando dados com o dplyr

O pacote dplyr é um pacote que facilita a manipulação de dados das tabelas.

4.3.1 Carregando o pacote dplyr e outros correlatos

Carregando as bibliotecas necessárias “dplyr”. Portando a instale e depois carregue.
install.packages(“dplyr”)
library(dplyr)

As bibliotecas abaixo são necessárias para o carregamento dos dados:
install.packages(“readr”)
install.packages(“reshape2”)
install.packages(“readxl”)
library(readr)
library(reshape2)
library(readxl)

Por fim, a biblioteca “stringr” será necessária para manipulação de textos.
install.packages(“stringr”)
library(stringr)

# Depois de instalar, carregue a biblioteca
library(dplyr)
# Outras bibliotecas são utilizadas em conjunto para a manipulação de dados
# Sugiro que carregue todas 
library(stringr)   
library(readr)    
library(reshape2)     
library(readxl)

4.3.2 Comandos do dplyr

O símbolo “%>%”, chamados de pipe (pronuncia-se paipe) conduz a operação para o comando subsequente

Agora vamos exercitar cada um desses comandos. Para isso, vamos salvar essa base de dados em uma variável. Esse é o procedimento normal quando trabalhamos com cados carregados de uma planilha ou base de dados.

4.3.3 Manipulando dados com dplyr

Utilizaremos a tibble storms, mas os comandos também funcionam para data.frames.

Conhecendo nossa base de dados.

glimpse(storms) # nomes das colunas
## Rows: 19,537
## Columns: 13
## $ name                         <chr> "Amy", "Amy", "Amy", "Amy", "Amy", "Amy",…
## $ year                         <dbl> 1975, 1975, 1975, 1975, 1975, 1975, 1975,…
## $ month                        <dbl> 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,…
## $ day                          <int> 27, 27, 27, 27, 28, 28, 28, 28, 29, 29, 2…
## $ hour                         <dbl> 0, 6, 12, 18, 0, 6, 12, 18, 0, 6, 12, 18,…
## $ lat                          <dbl> 27.5, 28.5, 29.5, 30.5, 31.5, 32.4, 33.3,…
## $ long                         <dbl> -79.0, -79.0, -79.0, -79.0, -78.8, -78.7,…
## $ status                       <fct> tropical depression, tropical depression,…
## $ category                     <dbl> NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, N…
## $ wind                         <int> 25, 25, 25, 25, 25, 25, 25, 30, 35, 40, 4…
## $ pressure                     <int> 1013, 1013, 1013, 1013, 1012, 1012, 1011,…
## $ tropicalstorm_force_diameter <int> NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, N…
## $ hurricane_force_diameter     <int> NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, N…

Além do nome das colunas e quantidade de linhas, esse comando apresenta os tipos de dados de cada coluna.

4.3.4 Select

Para escolher as colunas (variáveis) com que trabalharei, utilizo o select.

# Este comando retorna todas as linhas dessas duas colunas
storms %>% 
  select(name, year) 
## # A tibble: 19,537 × 2
##    name   year
##    <chr> <dbl>
##  1 Amy    1975
##  2 Amy    1975
##  3 Amy    1975
##  4 Amy    1975
##  5 Amy    1975
##  6 Amy    1975
##  7 Amy    1975
##  8 Amy    1975
##  9 Amy    1975
## 10 Amy    1975
## # ℹ 19,527 more rows
# Retorna apenas as 5 primeiras linhas
storms %>% 
  select(name, year) %>% 
  head(5) 
## # A tibble: 5 × 2
##   name   year
##   <chr> <dbl>
## 1 Amy    1975
## 2 Amy    1975
## 3 Amy    1975
## 4 Amy    1975
## 5 Amy    1975

É possível renomear as colunas com o select. Observe que o nome das colunas da variável não mudou, o que mudou foi o nome das colunas selecionadas e retornadas.

# seleciona as 6 últimas linhas da tabela e renomeia como "nome" e "ano"
storms %>% 
  select(nome = name, ano = year) %>% 
  tail(10)
## # A tibble: 10 × 2
##    nome     ano
##    <chr>  <dbl>
##  1 Nicole  2022
##  2 Nicole  2022
##  3 Nicole  2022
##  4 Nicole  2022
##  5 Nicole  2022
##  6 Nicole  2022
##  7 Nicole  2022
##  8 Nicole  2022
##  9 Nicole  2022
## 10 Nicole  2022

É possível criar uma nova tabela a partir da seleção realizada.
Veja o exemplo:

nova_tabela <- storms %>% 
  select(nome = name, ano = year) %>%
  tail(15) 

# Esta nova variável, chamada "nova_tabela" vai conter apenas as 2 colunas (renomeadas) e 6 útlimas linhas selecionadas (tail)
print(nova_tabela)
## # A tibble: 15 × 2
##    nome     ano
##    <chr>  <dbl>
##  1 Nicole  2022
##  2 Nicole  2022
##  3 Nicole  2022
##  4 Nicole  2022
##  5 Nicole  2022
##  6 Nicole  2022
##  7 Nicole  2022
##  8 Nicole  2022
##  9 Nicole  2022
## 10 Nicole  2022
## 11 Nicole  2022
## 12 Nicole  2022
## 13 Nicole  2022
## 14 Nicole  2022
## 15 Nicole  2022

É possível excluir uma coluna, ao invés de selecionar.
Veja o exemplo:

# Vai retornar as 12 colunas da tabela (exceto a coluna "name"), 6 últimas linhas (tail)
storms %>% 
  select(-name) %>% 
  tail(5) 
## # A tibble: 5 × 12
##    year month   day  hour   lat  long status             category  wind pressure
##   <dbl> <dbl> <int> <dbl> <dbl> <dbl> <fct>                 <dbl> <int>    <int>
## 1  2022    11    10    19  29.2 -83   tropical storm           NA    40      989
## 2  2022    11    11     0  30.1 -84   tropical storm           NA    35      992
## 3  2022    11    11     6  31.2 -84.6 tropical depressi…       NA    30      996
## 4  2022    11    11    12  33.2 -84.6 tropical depressi…       NA    25      999
## 5  2022    11    11    18  35.4 -83.8 other low                NA    25     1000
## # ℹ 2 more variables: tropicalstorm_force_diameter <int>,
## #   hurricane_force_diameter <int>

Vendo as dimensões do retorno do comando anterior.
Veja o exemplo:

storms %>% 
  select(-name) %>% 
  tail() %>% 
  dim()
## [1]  6 12

É possível retirar várias colunas, para isso utilize a expressão “-c(coluna, coluna, coluna,…)”.
Veja o exemplo.

storms %>% 
  select(-c(lat, long, status, wind, tropicalstorm_force_diameter)) %>% 
  tail
## # A tibble: 6 × 8
##   name    year month   day  hour category pressure hurricane_force_diameter
##   <chr>  <dbl> <dbl> <int> <dbl>    <dbl>    <int>                    <int>
## 1 Nicole  2022    11    10    18       NA      989                        0
## 2 Nicole  2022    11    10    19       NA      989                        0
## 3 Nicole  2022    11    11     0       NA      992                        0
## 4 Nicole  2022    11    11     6       NA      996                        0
## 5 Nicole  2022    11    11    12       NA      999                        0
## 6 Nicole  2022    11    11    18       NA     1000                        0
# Mesmo comando com outra forma de escrever, gerando o mesmo resultado
storms %>% 
  select(-lat, -long, -status, -wind, -tropicalstorm_force_diameter) %>% 
  tail
## # A tibble: 6 × 8
##   name    year month   day  hour category pressure hurricane_force_diameter
##   <chr>  <dbl> <dbl> <int> <dbl>    <dbl>    <int>                    <int>
## 1 Nicole  2022    11    10    18       NA      989                        0
## 2 Nicole  2022    11    10    19       NA      989                        0
## 3 Nicole  2022    11    11     0       NA      992                        0
## 4 Nicole  2022    11    11     6       NA      996                        0
## 5 Nicole  2022    11    11    12       NA      999                        0
## 6 Nicole  2022    11    11    18       NA     1000                        0
storms %>% 
  select(-c(lat, long, status, wind, tropicalstorm_force_diameter)) %>% 
  tail %>% 
  dim
## [1] 6 8

4.3.4.1 Selecionando as colunas numéricas

É possível selecionar colunas com características desejadas como, por exemplo, aquelas que possuem somente dados numérios.

Veja os exemplos:

# Retorna todas as colunas que possuem dados numéricos.
storms %>% 
  select_if(is.numeric) %>% 
  tail
## # A tibble: 6 × 11
##    year month   day  hour   lat  long category  wind pressure
##   <dbl> <dbl> <int> <dbl> <dbl> <dbl>    <dbl> <int>    <int>
## 1  2022    11    10    18  29   -82.8       NA    40      989
## 2  2022    11    10    19  29.2 -83         NA    40      989
## 3  2022    11    11     0  30.1 -84         NA    35      992
## 4  2022    11    11     6  31.2 -84.6       NA    30      996
## 5  2022    11    11    12  33.2 -84.6       NA    25      999
## 6  2022    11    11    18  35.4 -83.8       NA    25     1000
## # ℹ 2 more variables: tropicalstorm_force_diameter <int>,
## #   hurricane_force_diameter <int>

4.3.4.2 selecionar apenas as colunas cujo nome começa com uma letra ou texto

É possível selecionar colunas cujo nome comece ou contenha “algumas letras”

# Retorna as colunas que começam com a letra "l".
storms %>% 
  select(starts_with("l")) %>% 
  tail
## # A tibble: 6 × 2
##     lat  long
##   <dbl> <dbl>
## 1  29   -82.8
## 2  29.2 -83  
## 3  30.1 -84  
## 4  31.2 -84.6
## 5  33.2 -84.6
## 6  35.4 -83.8

4.3.4.3 utilizando funções distinct, max, min com select

O comando select pode ser associado com a função distinct. A função “distinct” retorna as linhas únicas de uma determinada coluna.
Veja o exemplo:

# O comando irá apresentar o nome das tempestades registradas
storms %>% 
  select(name) %>% 
  distinct
## # A tibble: 260 × 1
##    name    
##    <chr>   
##  1 Amy     
##  2 Blanche 
##  3 Caroline
##  4 Doris   
##  5 Eloise  
##  6 Faye    
##  7 Gladys  
##  8 Hallie  
##  9 Belle   
## 10 Dottie  
## # ℹ 250 more rows
# O comando irá apresentar o status das tempestades registradas
storms %>% 
  select(status) %>% 
  distinct
## # A tibble: 9 × 1
##   status                
##   <fct>                 
## 1 tropical depression   
## 2 tropical storm        
## 3 extratropical         
## 4 hurricane             
## 5 subtropical storm     
## 6 subtropical depression
## 7 disturbance           
## 8 other low             
## 9 tropical wave
# O comando irá apresentar o minimo da coluna wind
storms %>% 
  select(wind) %>% 
  min
## [1] 10
# O comando irá apresentar o máximo da coluna wind
storms %>% 
  select(wind) %>% 
  max
## [1] 165

4.3.5 arrange

Este comando classifica a tabela de acordo de forma crescente da coluna selecionada.
Veja o exemplo:

# Classificando em ordem crescente
storms %>%
  arrange(wind) %>%
  select(name, wind) %>%
  distinct %>%
  head
## # A tibble: 6 × 2
##   name      wind
##   <chr>    <int>
## 1 Bonnie      10
## 2 Charley     10
## 3 AL031987    10
## 4 Arlene      10
## 5 Bob         10
## 6 Alberto     10
# Classificando em ordem decrescente
storms %>%
  arrange(desc(wind)) %>%
  select(name, wind) %>%
  distinct %>%
  head
## # A tibble: 6 × 2
##   name     wind
##   <chr>   <int>
## 1 Allen     165
## 2 Gilbert   160
## 3 Wilma     160
## 4 Dorian    160
## 5 Allen     155
## 6 Gilbert   155

4.3.6 filter

Esta função filtra AS LINHAS em função do valor da coluna. Ele é similar ao filtro utilizado no Excel. 

# Filtra todas as LINHAS cujo valor na coluna year é maior do que 2015
# Neste caso, o comando retorna as 13 colunas e 1868 linhas com o filtro "year > 2015"
storms %>% 
  filter(year > 2015)
## # A tibble: 4,193 × 13
##    name   year month   day  hour   lat  long status      category  wind pressure
##    <chr> <dbl> <dbl> <int> <dbl> <dbl> <dbl> <fct>          <dbl> <int>    <int>
##  1 Alex   2016     1     7     0  26.6 -75.3 extratropi…       NA    40     1010
##  2 Alex   2016     1     7     6  27.6 -74.7 extratropi…       NA    45     1003
##  3 Alex   2016     1     7    12  28.7 -73.8 extratropi…       NA    50      997
##  4 Alex   2016     1     7    18  30   -72.5 extratropi…       NA    55      987
##  5 Alex   2016     1     8     0  31.4 -70.6 extratropi…       NA    55      986
##  6 Alex   2016     1     8     6  32.4 -68.8 extratropi…       NA    55      986
##  7 Alex   2016     1     8    12  33   -67.1 extratropi…       NA    45      991
##  8 Alex   2016     1     8    18  33.5 -65   extratropi…       NA    45      991
##  9 Alex   2016     1     9     0  34   -62.9 extratropi…       NA    45      991
## 10 Alex   2016     1     9     6  34.5 -60.5 extratropi…       NA    50      991
## # ℹ 4,183 more rows
## # ℹ 2 more variables: tropicalstorm_force_diameter <int>,
## #   hurricane_force_diameter <int>

É possível utilizar diversos filtros em um único comando. Para isso, separe os filtros com vírgulas. Veja o exemplo:

# Filtra todas as LINHAS cujos valores nas colunas year é igual a 2015, wind é maior do que 50, e pressure menor ou igual a 1000.
# Neste caso, o comando reotrna as 13 colunas e 61 linhas.
storms %>% filter(year == 2015, wind > 50, pressure <= 1000)
## # A tibble: 66 × 13
##    name   year month   day  hour   lat  long status      category  wind pressure
##    <chr> <dbl> <dbl> <int> <dbl> <dbl> <dbl> <fct>          <dbl> <int>    <int>
##  1 Danny  2015     8    20     0  11.7 -42.5 tropical s…       NA    55     1000
##  2 Danny  2015     8    20     6  11.9 -43.5 tropical s…       NA    60      998
##  3 Danny  2015     8    20    12  12.3 -44.4 hurricane          1    65      995
##  4 Danny  2015     8    20    18  12.8 -45.3 hurricane          1    75      990
##  5 Danny  2015     8    21     0  13.2 -46.2 hurricane          2    85      981
##  6 Danny  2015     8    21     6  13.5 -47   hurricane          2    95      973
##  7 Danny  2015     8    21    12  13.8 -47.8 hurricane          3   110      960
##  8 Danny  2015     8    21    18  14.3 -48.6 hurricane          3   105      966
##  9 Danny  2015     8    22     0  14.7 -49.4 hurricane          2    95      973
## 10 Danny  2015     8    22     6  15   -50.3 hurricane          2    85      980
## # ℹ 56 more rows
## # ℹ 2 more variables: tropicalstorm_force_diameter <int>,
## #   hurricane_force_diameter <int>

Utilize os seguintes operadores para comparação:
==, !=, >, >=, <, <=

É possível compor o comando filter com o select e todos os outros.
Veja o exemplo:

# Utiliza o filtro do exemplo anterior com o comando select
# Neste caso, como o filtro é aplicado em colunas que não estão no select deve vir antes, caso contrário ocorrerá um erro: o filtro não encontrará a coluna, pois ela não foi selecionada.
storms %>% 
   filter(year == 2015, wind > 50, pressure <= 1000) %>% 
   select(name, year, month)
## # A tibble: 66 × 3
##    name   year month
##    <chr> <dbl> <dbl>
##  1 Danny  2015     8
##  2 Danny  2015     8
##  3 Danny  2015     8
##  4 Danny  2015     8
##  5 Danny  2015     8
##  6 Danny  2015     8
##  7 Danny  2015     8
##  8 Danny  2015     8
##  9 Danny  2015     8
## 10 Danny  2015     8
## # ℹ 56 more rows

Observe que as colunas selecionadas podem ser diferentes das que se aplica o filtro.

4.3.6.1 Filtro contendo intervalo de valores

Podemos utilizar a mesma coluna mais de uma vez para definir um intervalo de interesse.
Veja o exemplo:

# A coluna wind com valores maiores que 50 e menores que 70
storms %>% 
  filter(wind > 50, wind < 60)
## # A tibble: 1,106 × 13
##    name      year month   day  hour   lat  long status   category  wind pressure
##    <chr>    <dbl> <dbl> <int> <dbl> <dbl> <dbl> <fct>       <dbl> <int>    <int>
##  1 Amy       1975     6    30     6  35.6 -70.8 tropica…       NA    55      998
##  2 Amy       1975     7     3     0  37.7 -62.8 tropica…       NA    55      986
##  3 Amy       1975     7     3     6  38.2 -61.2 tropica…       NA    55      986
##  4 Amy       1975     7     3    12  39.3 -59.6 tropica…       NA    55      986
##  5 Caroline  1975     8    31    18  24.8 -98   tropica…       NA    55      993
##  6 Doris     1975     8    30     0  35.3 -48.9 tropica…       NA    55      997
##  7 Doris     1975     8    30     6  35.3 -48.5 tropica…       NA    55      997
##  8 Doris     1975     8    30    12  35.3 -48   tropica…       NA    55      997
##  9 Doris     1975     8    30    18  35   -47.1 tropica…       NA    55      997
## 10 Eloise    1975     9    16    12  19.4 -67.5 tropica…       NA    55     1002
## # ℹ 1,096 more rows
## # ℹ 2 more variables: tropicalstorm_force_diameter <int>,
## #   hurricane_force_diameter <int>

4.3.6.2 Filtro sobre texto

Quando a coluna tem valores de texto, devemos utilizar esses valores entre aspas.
Veja os exemplos:

# A coluna status cujos valores são de "tropical storm"
storms %>% 
  filter(status != "tropical storm")
## # A tibble: 12,707 × 13
##    name     year month   day  hour   lat  long status    category  wind pressure
##    <chr>   <dbl> <dbl> <int> <dbl> <dbl> <dbl> <fct>        <dbl> <int>    <int>
##  1 Amy      1975     6    27     0  27.5 -79   tropical…       NA    25     1013
##  2 Amy      1975     6    27     6  28.5 -79   tropical…       NA    25     1013
##  3 Amy      1975     6    27    12  29.5 -79   tropical…       NA    25     1013
##  4 Amy      1975     6    27    18  30.5 -79   tropical…       NA    25     1013
##  5 Amy      1975     6    28     0  31.5 -78.8 tropical…       NA    25     1012
##  6 Amy      1975     6    28     6  32.4 -78.7 tropical…       NA    25     1012
##  7 Amy      1975     6    28    12  33.3 -78   tropical…       NA    25     1011
##  8 Amy      1975     6    28    18  34   -77   tropical…       NA    30     1006
##  9 Amy      1975     7     4    12  47   -48   extratro…       NA    45      995
## 10 Blanche  1975     7    24     0  26   -68.4 tropical…       NA    20     1014
## # ℹ 12,697 more rows
## # ℹ 2 more variables: tropicalstorm_force_diameter <int>,
## #   hurricane_force_diameter <int>
# A coluna status cujos valores são de "tropical storm"
storms %>% 
  filter(status != "tropical storm", status != "hurricane")
## # A tibble: 7,904 × 13
##    name     year month   day  hour   lat  long status    category  wind pressure
##    <chr>   <dbl> <dbl> <int> <dbl> <dbl> <dbl> <fct>        <dbl> <int>    <int>
##  1 Amy      1975     6    27     0  27.5 -79   tropical…       NA    25     1013
##  2 Amy      1975     6    27     6  28.5 -79   tropical…       NA    25     1013
##  3 Amy      1975     6    27    12  29.5 -79   tropical…       NA    25     1013
##  4 Amy      1975     6    27    18  30.5 -79   tropical…       NA    25     1013
##  5 Amy      1975     6    28     0  31.5 -78.8 tropical…       NA    25     1012
##  6 Amy      1975     6    28     6  32.4 -78.7 tropical…       NA    25     1012
##  7 Amy      1975     6    28    12  33.3 -78   tropical…       NA    25     1011
##  8 Amy      1975     6    28    18  34   -77   tropical…       NA    30     1006
##  9 Amy      1975     7     4    12  47   -48   extratro…       NA    45      995
## 10 Blanche  1975     7    24     0  26   -68.4 tropical…       NA    20     1014
## # ℹ 7,894 more rows
## # ℹ 2 more variables: tropicalstorm_force_diameter <int>,
## #   hurricane_force_diameter <int>

Também é possível criar filtros a partir do fragmento de uma expressão ou palavra.Para isso, é necessário utilizar a função string_detect Veja o exemplo:

# A coluna status cujos valores contém o fragamento de palavra "trop"
storms %>% 
  filter(str_detect(status, "trop"))
## # A tibble: 13,110 × 13
##    name   year month   day  hour   lat  long status      category  wind pressure
##    <chr> <dbl> <dbl> <int> <dbl> <dbl> <dbl> <fct>          <dbl> <int>    <int>
##  1 Amy    1975     6    27     0  27.5 -79   tropical d…       NA    25     1013
##  2 Amy    1975     6    27     6  28.5 -79   tropical d…       NA    25     1013
##  3 Amy    1975     6    27    12  29.5 -79   tropical d…       NA    25     1013
##  4 Amy    1975     6    27    18  30.5 -79   tropical d…       NA    25     1013
##  5 Amy    1975     6    28     0  31.5 -78.8 tropical d…       NA    25     1012
##  6 Amy    1975     6    28     6  32.4 -78.7 tropical d…       NA    25     1012
##  7 Amy    1975     6    28    12  33.3 -78   tropical d…       NA    25     1011
##  8 Amy    1975     6    28    18  34   -77   tropical d…       NA    30     1006
##  9 Amy    1975     6    29     0  34.4 -75.8 tropical s…       NA    35     1004
## 10 Amy    1975     6    29     6  34   -74.8 tropical s…       NA    40     1002
## # ℹ 13,100 more rows
## # ℹ 2 more variables: tropicalstorm_force_diameter <int>,
## #   hurricane_force_diameter <int>

ATENÇÃO! Este comando é CASE SENSITIVE, ou seja, distingue as letras maiúsculas e minúsculas.
Veja o exemplo:

# O mesmo comando anterio com o fragmento "Trop" com o "T" maiúsculo, retorna zero linhas.
storms %>% 
  filter(str_detect(status, "Trop"))
## # A tibble: 0 × 13
## # ℹ 13 variables: name <chr>, year <dbl>, month <dbl>, day <int>, hour <dbl>,
## #   lat <dbl>, long <dbl>, status <fct>, category <dbl>, wind <int>,
## #   pressure <int>, tropicalstorm_force_diameter <int>,
## #   hurricane_force_diameter <int>

4.3.6.3 Exemplo combinando select e filter

Podemos combinar os diversos filtros para obter os resultados desejados.
Veja o exemplo:

# Utiliza o filtro do exemplo anterior com o comando select
# Neste caso, como o filtro é aplicado em colunas que não estão no select deve vir antes, caso contrário ocorrerá um erro: o filtro não encontrará a coluna, pois ela não foi selecionada.
storms %>% 
   filter(year == 2015, wind > 50, wind < 1000, str_detect(status, "trop") ) %>% 
   select(name, year, month, starts_with("l"))
## # A tibble: 16 × 5
##    name     year month   lat  long
##    <chr>   <dbl> <dbl> <dbl> <dbl>
##  1 Danny    2015     8  11.7 -42.5
##  2 Danny    2015     8  11.9 -43.5
##  3 Danny    2015     8  15.6 -54  
##  4 Fred     2015     8  14   -20.7
##  5 Fred     2015     9  17.8 -25.7
##  6 Joaquin  2015     9  26   -70.8
##  7 Joaquin  2015     9  25.8 -71.3
##  8 Joaquin  2015    10  41   -47.5
##  9 Joaquin  2015    10  41.5 -43.3
## 10 Kate     2015    11  28   -76.2
## 11 Kate     2015    11  29.5 -75.4
## 12 Kate     2015    11  31.2 -74  
## 13 Kate     2015    11  38.9 -55  
## 14 Kate     2015    11  40   -52  
## 15 Kate     2015    11  41.3 -50.4
## 16 Kate     2015    11  41.9 -49.9

4.3.7 mutate

Este comando alterar colunas existentes ou cria novas colunas que são funções das demais.

Vamos começar com um comando simples, multiplicando o valor da coluna “wind” multiplicando ela por 100.
Veja o exemplo:

# O comando abaixo cria uma 14ª coluna na pesquisa - não muda a variável "storms".
# Apresentadas somente as 6 primeiras linhas - comando head
storms %>%
  mutate(vento = wind * 100) %>%
  head(2)
## # A tibble: 2 × 14
##   name   year month   day  hour   lat  long status       category  wind pressure
##   <chr> <dbl> <dbl> <int> <dbl> <dbl> <dbl> <fct>           <dbl> <int>    <int>
## 1 Amy    1975     6    27     0  27.5   -79 tropical de…       NA    25     1013
## 2 Amy    1975     6    27     6  28.5   -79 tropical de…       NA    25     1013
## # ℹ 3 more variables: tropicalstorm_force_diameter <int>,
## #   hurricane_force_diameter <int>, vento <dbl>

Para uma melhor visualização, foram selecionadas apenas 4 colunas:

storms %>%
  mutate(vento = wind * 100) %>%
  select(name, year, wind, vento) %>%
  head(2)
## # A tibble: 2 × 4
##   name   year  wind vento
##   <chr> <dbl> <int> <dbl>
## 1 Amy    1975    25  2500
## 2 Amy    1975    25  2500

Para incluirmos um nome composto na nova coluna, é necessário incluir a aspas para definição desse nome.
No entanto, recomenda-se evitar espaços nos nomes das variáveis. Caso seja necessário incluir um nome composto, una-os com “-” ou “_”: vento_x_100, ou vento-x-100.

storms %>%
  mutate("vento x 100" = wind * 100) %>%
  select(name, year, wind, "vento x 100") %>%
  head(2)
## # A tibble: 2 × 4
##   name   year  wind `vento x 100`
##   <chr> <dbl> <int>         <dbl>
## 1 Amy    1975    25          2500
## 2 Amy    1975    25          2500

4.3.7.1 Alterando um dado específico

Para aleterar um dado específico, é necessário fazer uma seleção e/ou filtro nos dados para evitar alteração indiscriminada na tabela.
Para melhor compreensão dessa operação, em um comando selciono e apresento o dados, e na outra altero o dado.

# Na tempestade Amy vou alterar o dado lat - veja o dado
storms %>%
  select(name, hour, wind, lat) %>%
  filter(name == "Amy",
         hour == 0,
         lat == 27.5)
## # A tibble: 1 × 4
##   name   hour  wind   lat
##   <chr> <dbl> <int> <dbl>
## 1 Amy       0    25  27.5
# Comando para alterar lat para o valor de 30 com mutate
storms %>%
  select(name, hour, wind, lat) %>%
  filter(name == "Amy",
         hour == 0,
         lat == 27.5) %>%
  mutate(lat = 30)
## # A tibble: 1 × 4
##   name   hour  wind   lat
##   <chr> <dbl> <int> <dbl>
## 1 Amy       0    25    30
# Comando para alterar o nome de Amy para AMY com mutate 
storms %>%
  select(name, hour, wind, lat) %>%
  filter(name == "Amy",
         hour == 0,
         lat == 27.5) %>%
  mutate(name = "AAMMYY")
## # A tibble: 1 × 4
##   name    hour  wind   lat
##   <chr>  <dbl> <int> <dbl>
## 1 AAMMYY     0    25  27.5

Atenção! - caso você queira realizar alterações em lote,várias ao mesmo tempo, basta reduzir as restrições do filtro.

# Comando para alterar o nome de Amy para AAMMYY com mutate
storms %>%
  select(name, hour, wind, lat) %>%
  filter(name == "Amy") %>%
  mutate(name = "AAMMYY") %>%
  head(3)
## # A tibble: 3 × 4
##   name    hour  wind   lat
##   <chr>  <dbl> <int> <dbl>
## 1 AAMMYY     0    25  27.5
## 2 AAMMYY     6    25  28.5
## 3 AAMMYY    12    25  29.5

Neste exemplo foram o nome foi alterado nos 31 registros existentes, mas apresentei somente o 3 primeiros para não poluir o documento.

4.3.7.2 Transforndo número em character e vice-versa

Utilize a função as.character para realizar essa transformação.
Utilize a função as.numeric para transformar caracter em número.
Veja os exemplo:

# É criada uma coluna com nome "posicao" e com o formato "chr" 
# em uma nova variável chamada 'stm'
stm <- storms %>% 
  mutate(posicao = as.character(lat)) 

stm %>%
  select(name, lat, posicao) %>%
  head(2)
## # A tibble: 2 × 3
##   name    lat posicao
##   <chr> <dbl> <chr>  
## 1 Amy    27.5 27.5   
## 2 Amy    28.5 28.5
# Transformando a coluna posição de stm em numérico
stm %>% 
  mutate(posicao = as.numeric(posicao)) %>%
  select(name, lat, posicao) %>%
  head(2)
## # A tibble: 2 × 3
##   name    lat posicao
##   <chr> <dbl>   <dbl>
## 1 Amy    27.5    27.5
## 2 Amy    28.5    28.5

Podemos concatenar informações de diversas colunas.

# É criada uma coluna com nome "posicao" e com o formato "chr"
storms %>% 
  mutate(posicao = paste(lat, "-", long)) %>%
  select(name, lat, long, posicao) %>%
  head(2)
## # A tibble: 2 × 4
##   name    lat  long posicao   
##   <chr> <dbl> <dbl> <chr>     
## 1 Amy    27.5   -79 27.5 - -79
## 2 Amy    28.5   -79 28.5 - -79

Podemos criar uma coluna extraindo o primeiro nome de outra coluna.

# É criada uma coluna "com nome "posicao" e com o formato "nome_status" com o primeiro nome da coluna "status"
storms %>% 
  mutate(nome_status = stringr::word(status, 1))%>%
  select(status, nome_status) %>%
  head(2)
## # A tibble: 2 × 2
##   status              nome_status
##   <fct>               <chr>      
## 1 tropical depression tropical   
## 2 tropical depression tropical

4.3.7.3 Trabalhando com datas (em construção)

Utilizae a função lubridate para transformar datas.
Vamos criar uma nova coluna concatenando ano-mês-dia das colunas pré-existentes.
Podemos fazer isso de 2 formas, com a função Date ou utilizando o pacote lubridate.

Para descobrir o formato padrão de datas que seu computador está utilizando, utilize a função Sys.Date().

Veja os exemplos:

# Veirifique o formato de data de seu computador.
Sys.Date()
## [1] "2026-01-20"

Concatene as colunas existentes utilizando a função as.Date().

# Concatenando as coluna existentes com os comandos paste e as.Date 

storms_atualizado <- storms %>%
  mutate(data_completa = as.Date(paste(year, month, day, sep = "-"))) %>%
  select(name, year, month, day, data_completa) %>%
  head(2)
# Utilizando o pacote lubridate
library(lubridate)
## 
## Anexando pacote: 'lubridate'
## Os seguintes objetos são mascarados por 'package:base':
## 
##     date, intersect, setdiff, union
# Criando a coluna 'data_completa'
storms %>%
  mutate(data_completa = make_date(year, month, day)) %>% 
  select(name, year, month, day, data_completa) %>%
  head(2)
## # A tibble: 2 × 5
##   name   year month   day data_completa
##   <chr> <dbl> <dbl> <int> <date>       
## 1 Amy    1975     6    27 1975-06-27   
## 2 Amy    1975     6    27 1975-06-27

4.3.7.4 Criar varias colunas simultaneamente

O comando mutate comporta a criação de várias colunas simultaneamente.
Veja o exemplo:

storms %>% 
  mutate(nome_status = stringr::word(status, 1), posicao = paste(lat, " - ", long), categoria = as.numeric(category))%>%
  select(status, nome_status, lat, long, posicao, category, categoria) %>%
  head
## # A tibble: 6 × 7
##   status              nome_status   lat  long posicao        category categoria
##   <fct>               <chr>       <dbl> <dbl> <chr>             <dbl>     <dbl>
## 1 tropical depression tropical     27.5 -79   27.5  -  -79         NA        NA
## 2 tropical depression tropical     28.5 -79   28.5  -  -79         NA        NA
## 3 tropical depression tropical     29.5 -79   29.5  -  -79         NA        NA
## 4 tropical depression tropical     30.5 -79   30.5  -  -79         NA        NA
## 5 tropical depression tropical     31.5 -78.8 31.5  -  -78.8       NA        NA
## 6 tropical depression tropical     32.4 -78.7 32.4  -  -78.7       NA        NA

4.3.8 group_by

Este comando organiza por grupos - as funções são aplicadas nos grupos e é muito utilizado para elaboração de análises e gráficos. Sua utilidade maior ocorre quando é associado com outros comandos, em especial o summarise.
Aplicado sozinho, ele não retorna no console os seus resultados, por isso não serão apresentados exemplos.

4.3.9 summarise

O comando summarise possibilita a aplicação de funções no cálculo dos valores que retornam de uma consulta. Por isso, normalmente são utilizados com o comando group_by.
Este comando é muito utilizado para análises e confecção de gráficos, como veremos adiante.
Veja os exemplos:

# Nome das tempestades com a média dos valores de wind para cada nome
storms %>%
  group_by(name) %>%
  summarise(mean(wind))
## # A tibble: 260 × 2
##    name     `mean(wind)`
##    <chr>           <dbl>
##  1 AL011993         29.5
##  2 AL012000         25  
##  3 AL021992         29  
##  4 AL021994         24.2
##  5 AL021999         28.8
##  6 AL022000         29.2
##  7 AL022001         25  
##  8 AL022003         30  
##  9 AL022006         31.5
## 10 AL031987         21.2
## # ℹ 250 more rows
# Nome das tempestades com a média dos valores de wind para cada nome
storms %>%
  group_by(name) %>%
  summarise(sd(wind))
## # A tibble: 260 × 2
##    name     `sd(wind)`
##    <chr>         <dbl>
##  1 AL011993       4.16
##  2 AL012000       0   
##  3 AL021992       2.24
##  4 AL021994       5.85
##  5 AL021999       2.5 
##  6 AL022000       1.95
##  7 AL022001       0   
##  8 AL022003       0   
##  9 AL022006       6.58
## 10 AL031987       8.71
## # ℹ 250 more rows
# Nome das tempestades com diversos valores calculados de wind. O "n()" realiza a contagem.
storms %>%
  group_by(name) %>%
  summarise(n(), mean(wind), median(wind), sd(wind), min(wind), max(wind))
## # A tibble: 260 × 7
##    name     `n()` `mean(wind)` `median(wind)` `sd(wind)` `min(wind)` `max(wind)`
##    <chr>    <int>        <dbl>          <dbl>      <dbl>       <int>       <int>
##  1 AL011993    11         29.5             30       4.16          25          35
##  2 AL012000     4         25               25       0             25          25
##  3 AL021992     5         29               30       2.24          25          30
##  4 AL021994     6         24.2             25       5.85          15          30
##  5 AL021999     4         28.8             30       2.5           25          30
##  6 AL022000    12         29.2             30       1.95          25          30
##  7 AL022001     5         25               25       0             25          25
##  8 AL022003     4         30               30       0             30          30
##  9 AL022006    13         31.5             30       6.58          25          45
## 10 AL031987    32         21.2             20       8.71          10          40
## # ℹ 250 more rows
# Status das tempestades com diversos valores calculados de wind. O "n()" realiza a contagem.
storms %>%
  group_by(status) %>%
  summarise(n(), mean(wind), median(wind), sd(wind), min(wind), max(wind))
## # A tibble: 9 × 7
##   status    `n()` `mean(wind)` `median(wind)` `sd(wind)` `min(wind)` `max(wind)`
##   <fct>     <int>        <dbl>          <dbl>      <dbl>       <int>       <int>
## 1 disturba…   171         30.0             30       6.50          20          50
## 2 extratro…  2151         41.5             40      13.5           10         105
## 3 hurricane  4803         86.6             80      20.7           65         165
## 4 other low  1453         25.6             25       6.81          10          80
## 5 subtropi…   151         26.7             30       4.79          10          30
## 6 subtropi…   298         44.4             45       7.89          35          60
## 7 tropical…  3569         27.5             30       3.71          10          30
## 8 tropical…  6830         45.7             45       8.29          35          70
## 9 tropical…   111         28.6             30       4.59          20          40
# Status das tempestades com diversos valores calculados de wind. O "n()" realiza a contagem.
storms %>%
  group_by(status) %>%
  summarise(n(), mean(pressure), median(pressure), sd(pressure), min(pressure), max(pressure))
## # A tibble: 9 × 7
##   status                `n()` `mean(pressure)` `median(pressure)` `sd(pressure)`
##   <fct>                 <int>            <dbl>              <dbl>          <dbl>
## 1 disturbance             171            1009.               1009           3.96
## 2 extratropical          2151             993.                995          14.3 
## 3 hurricane              4803             969.                973          18.7 
## 4 other low              1453            1009.               1009           5.26
## 5 subtropical depressi…   151            1008.               1007           3.45
## 6 subtropical storm       298             998.                998           7.24
## 7 tropical depression    3569            1008.               1008           3.87
## 8 tropical storm         6830             999.               1000           6.92
## 9 tropical wave           111            1009.               1009           1.84
## # ℹ 2 more variables: `min(pressure)` <int>, `max(pressure)` <int>
storms %>%
  filter(lat > 11, lat < 12,  long > -30, long < -25) %>%
  group_by(status) %>%
  summarise(Qtde = n(), media_pressao = mean(pressure), mediana_pressao = median(pressure), dp_pressao = sd(pressure), pressao_min = min(pressure), pressao_max = max(pressure))
## # A tibble: 2 × 7
##   status   Qtde media_pressao mediana_pressao dp_pressao pressao_min pressao_max
##   <fct>   <int>         <dbl>           <int>      <dbl>       <int>       <int>
## 1 tropic…    13         1009.            1008       1.80        1008        1013
## 2 tropic…    15         1002.            1003       4.72         990        1006

5 Gráficos

Existem muitas funções gráficas no R e duas funções muito conhecidas, a função plot e algumas derivadas, como por exemplo a função hist, que utiliza padrões de configuração muito semelhantes; e a função ggplot2 que é muito utilizadas com as funções do dplyr. Para alguns casos a função plot é mais simples e direta. No entanto, conforme aumentamos a complexidade dos dados a serem analisados ou exigimos uma formatação aprimorada, a função ggplot tende a ser melhor.

Existem outras alternativas, mas nos ateremos à essas duas.

Utilizaremos a base de dados disponível no RStudio, dplyr, “storms”, cujas colunas são name, year, month, day, hour, lat, long, status, category, wind, pressure, tropicalstorm_force_diameter, hurricane_force_diameter.

Veja os principais dados:

name Amy Amy
year 1975 1975
month 6 6
day 27 27
hour 0 6
lat 27.5 28.5
long -79 -79
status tropical depression tropical depression
category NA NA
wind 25 25
pressure 1013 1013
tropicalstorm_force_diameter NA NA
hurricane_force_diameter NA NA

No item seguinte abordarei a função plot e em seguida a ggplot. Em ambos os casos serão apresentadas as configurações para se produzir gráficos avançados.

5.1 Função plot e sua configuração

Vamos iniciar com um gráfico bastante simples e acrescentar configurações conforme evoluimos o exemplo. Mas atenção! Algumas configurações são úteis em vários tipos de gráficos, mas outras específicas para um tipo específico.

5.1.1 Scaterplot - gráfico de pontos

x <- 1:10 # atribuo uma sequencia de 1 a 10 ao vetor x
y <- x    # faço o mesmo para y, igualando ao x

plot(x,y)

Conforme queremos personalizar o gráfico, acrescentamos alguns parâmetros.

plot(x, y,
     main = "Título principal",
     sub = "Título secundário",
     xlab = "Nome do eixo x",
     ylab = "Nome do eixo y")

Podemos delimitar os eixos com xlim e ylim. Cuidado! Temos que delimitar o minimo e máximo para cada eixo em um vetor.

plot(x, y,
     main = "Título principal",
     sub = "Título secundário",
     xlab = "Nome do eixo x",
     ylab = "Nome do eixo y",
     xlim = c(1,6),
     ylim = c(3,7))

Para alterar a forma dos pontos utilizamos o pch. Você pode utilizar o *help(“points”)“* ou ?points para pedir uma ajuda ao R.
Com esse argumento você pode também alterar o tipo de ponto.
pch - pode variar de 1 a 25 (cada número representa um tipo). Também pode utilizar ao invés do número uma string, tipo”k”.

Símbolos pch
Símbolos pch
par(mfrow=c(1,2))

plot(x, y,
     sub = "pch = simbolo",
     pch = 16)

plot(x, y,
     sub = "pch = 16",
     pch = "k")

col - altera a cor do ponto.
bg - preenche a cor dos símbolos pch entre 21 e 25.
cex - um vetor numérico para alterar o tamanho do caracter (ou símbolo).
lwd - largura da linha para desenhar símbolos.
Como são muitos argumentos, sugiro que utilize o help(“points”) para ter uma melhor compreensão.

plot(x, y,
     main = "Título principal",
     sub = "Título secundário",
     xlab = "Nome do eixo x",
     ylab = "Nome do eixo y",
     pch = 25,             # tipo de símbolo
     col = "orchid",
     bg = "green",
     cex = 2,
     lwd = 3)

5.1.2 Editando as cores

Podemos aleterar as cores conforme nossas necessidades. O comando colors() permite identificar as 657 cores disponíveis. Aqui, vou apresentar somente as 6 primeiras.

head(colors())
## [1] "white"         "aliceblue"     "antiquewhite"  "antiquewhite1"
## [5] "antiquewhite2" "antiquewhite3"

Incluindo as cores no gráfico.

plot(x, y,
     main = "Título principal",
     sub = "Título secundário",
     xlab = "Nome do eixo x",
     ylab = "Nome do eixo y",
     col = "blue")

data(storms)

plot(storms$pressure, storms$wind,
     xlab = "Pressao", ylab= "Vento",   # Nome dos eixos
     main = "Gráfico de pontos",    # t?tulo do grafico
     xlim = c(870,1025), ylim = c(0,200),  # dimens?o dos eixos
     type = "p",                    # tipo de graficos
     pch = 1,                       # tipo de pontos
     cex = 0.5,                      # tamanho dos pontos
     col = "red",                    # cor dos pontos
     bty = "n",                      # tira bordas do grafico
     axes = FALSE,                       # elimina eixos
) +
  abline(h= mean(storms$wind), col = "red")  + # cria uma llinha horizontal em 0
  abline(v =mean(storms$pressure), col = "blue", lwd = 2, lty = 2)
## integer(0)
# Editando eixos side  o lado 1 para x, 2 para y, 3 para superior.....
axis(side = 1, at=seq(850,1025,25), labels=seq(850,1025,25), cex.axis=0.5)
axis(side = 2, at=seq(0,200,25), labels=seq(0,200,25), cex.axis=0.5)

OUtro

# 1. Preparação: Criar uma paleta de cores baseada na pressão para dar efeito visual
# Cores mais quentes (vermelho) para pressões baixas (tempestades fortes)
cor_ponto <- colorRampPalette(c("red", "orange", "green"))(100)
cores_mapeadas <- cor_ponto[as.numeric(cut(storms$pressure, breaks = 100))]

# 2. Ajustar parâmetros gráficos (margens e fundo)
par(mar = c(5, 5, 4, 2), bg = "white")

# 3. Criar o gráfico de dispersão
plot(storms$wind, storms$pressure,
     pch = 16,                       # Tipo de ponto (círculo preenchido)
     col = adjustcolor(cores_mapeadas, alpha.f = 0.2), # Transparência para lidar com sobreposição
     cex = 0.8,                      # Tamanho dos pontos
     main = "Correlação: Pressão Central vs. Velocidade do Vento",
     xlab = "Velocidade do Vento (nós)",
     ylab = "Pressão Central (mbar)",
     cex.axis = 0.8,                 # Reduz o tamanha dos números dos eixos
     las = 1,                        # Eixo Y na horizontal
     frame.plot = FALSE)             # Remove a caixa completa do gráfico

# 4. Adicionar grade para facilitar a leitura técnica
grid(col = "lightgray", lty = "dotted")

# 5. Adicionar legenda para as cores
legend("topright", 
       legend = c("Alta Pressão (Fraco)", "Média Pressão", "Baixa Pressão (Forte)"),
       col = c("green", "orange", "red"),
       pch = c(16, 16, 16),
       lty = c(NA, NA, NA),
       lwd = c(NA, NA, NA),
       bty = "n",
       cex = 0.8)

5.1.3 Histograma

5.1.3.1 Como o histograma é produzido (se fosse feito manualmente)

Calcular manualmente um histograma como o R faz exige transformar dados brutos em uma

tabela de frequências agrupadas. O processo segue cinco etapas lógicas: 

1. Organização e Amplitude 

Primeiro, ordene seus dados do menor para o maior para identificar os extremos. 

  • Valor Mínimo e Máximo: Identifique o menor e o maior valor (ex: na base storms, o vento mínimo e máximo).

  • Amplitude Total: 𝑅=𝑋𝑚𝑎𝑥−𝑋𝑚𝑖𝑛

2. Definição do Número de Classes

O R utiliza algoritmos automáticos (como a Regra de Sturges) para decidir em quantas barras dividir os dados. 

  • Fórmula de Sturges:

    𝑘=1+3,3⋅log10(𝑛)

    , onde 𝑛 é o número total de observações.

  • Arredondamento: O resultado deve ser arredondado para o número inteiro mais próximo. 

3. Cálculo da Amplitude da Classe ℎ

Para que todas as barras tenham a mesma largura (como é o padrão no R), divida a Amplitude Total pelo número de classes:

ℎ=𝑅/𝑘

  • Dica: Arredonde ℎ para cima para garantir que o último intervalo cubra o valor máximo dos dados. 

4. Construção dos Intervalos (Bins) 

Determine os limites de cada barra: 

  • Primeira Classe: Começa no valor mínimo. O limite superior será 𝑀í𝑛𝑖𝑚𝑜+ℎ

  • Classes Seguintes: O limite inferior de uma classe é o limite superior da anterior.

  • Nota: Por padrão, o R usa intervalos fechados à direita (ex: ]10,20] ), o que significa que o valor 20 entra na barra, mas o 10 pertence à anterior. 

Exemplo:

Para calcular manualmente o histograma da coluna

wind (velocidade do vento em nós) da base storms seguindo o padrão do R (Regra de Sturges), utilizaremos os dados estatísticos reais da base: 

1. Coleta e Organização dos Dados 

  • Total de observações: A base storms possui aproximadamente 11.859 observações.

    • Valor Mínimo: 10 nós.

    • Valor Máximo: 160 nós. 

2. Cálculo da Amplitude Total

𝑅=160−10=150 nós

3. Definição do Número de Classes - O R usa a Regra de Sturges por padrão:
𝑘=1+3,322⋅log10(𝑛)

𝑘=1+3,322⋅log10(11.859)≈1+3,322⋅4,07≈14,5

Arredondamos para 15 classes (barras). 

4. Cálculo da Largura da Classe

ℎ=150/15=10 nós

Cada barra terá uma largura de 10 nós. 

5. Construção dos Intervalos e Frequência 

kable(table(cut(storms$wind, breaks = seq(10, 160, by = 10))))
Var1 Freq
(10,20] 922
(20,30] 4793
(30,40] 3736
(40,50] 3034
(50,60] 2050
(60,70] 1653
(70,80] 1026
(80,90] 762
(90,100] 492
(100,110] 339
(110,120] 320
(120,130] 193
(130,140] 80
(140,150] 52
(150,160] 23

6. Desenho do Gráfico 

  • Eixo X: Marque os pontos 10, 20, 30… até 160.

  • Eixo Y: Representa a contagem (frequência) de cada intervalo.

  • Barras: Desenhe retângulos encostados uns nos outros, onde a altura é a frequência calculada no passo anterior. 

Nota: No caso específico da base storms, a velocidade do vento costuma ser arredondada para múltiplos de 5 ou 10, o que fará com que algumas barras sejam muito mais altas que outras (frequência concentrada em valores como 35, 45, 65 nós). 

5.1.3.2 Utilizando o R para produzir o histograma

Para criar um histograma no R utilizando a função básica hist(), o comando mínimo necessário é hist(dados).

hist(storms$wind)

Abaixo estão os principais parâmetros para configurar e personalizar o gráfico:

1. Estrutura e Intervalos (Bins)
breaks: Controla o número de colunas ou os pontos de corte. Você pode informar um número aproximado de barras (ex: breaks = 10) ou um vetor com os limites exatos (ex: breaks = c(0, 5, 10, 15)). freq: Define o que o eixo Y representa. Se TRUE (padrão), mostra a frequência absoluta (contagem); se FALSE ou prob = TRUE, mostra a densidade.

2. Títulos e Eixos main: define o título principal do gráfico.
xlab e ylab: alteram os nomes dos eixos X e Y, respectivamente.
xlim e ylim: definem os limites numéricos de visualização dos eixos (ex: xlim = c(0, 100)).

3. Estética e Cores col: define a cor de preenchimento das barras (ex: col = “blue” ou col = “tomato”).
border: Define a cor das bordas das colunas.
labels: Se TRUE, exibe os valores exatos (contagens) acima de cada barra.
density e angle: Adicionam hachuras (linhas inclinadas) dentro das barras para sombreamento.

Exemplo:

# 1. Cálculos Estatísticos
vento <- storms$wind
media   <- mean(vento, na.rm = TRUE)
mediana <- median(vento, na.rm = TRUE)

# Cálculo da Moda (valor mais frequente)
tab_vento <- table(vento)
moda <- as.numeric(names(tab_vento)[tab_vento == max(tab_vento)])[1] 

# 2. Configurar o ambiente gráfico
par(mar = c(5, 5, 4, 2)) # Ajusta as margens

# 3. Criar o histograma com detalhes avançados
h <- hist(storms$wind, 
     breaks = 20,                # Define o número de faixas (bins)
     col = "skyblue",            # Cor de preenchimento
     border = "white",           # Cor da borda das colunas
     main = "Distribuição da Velocidade dos Ventos", 
     xlab = "Vento (nós)",       # Rótulo do eixo X
     ylab = "Frequência",        # Rótulo do eixo Y
     las = 1,                    # Rotaciona números do eixo Y para horizontal
     cex.main = 1.5,             # Aumenta o tamanho do título
     cex.axis = 0.8,             # Diminui o tamanho dos números dos eixos
     font.lab = 2,               # Coloca os rótulos dos eixos em negrito
     ylim = c(0, 5000))          # Ajusta o limite do eixo Y para o texto caber

# 4. Adicionar uma linha vertical indicando a média
abline(v = media,   col = "red",       lwd = 2, lty = 2) # Média (Tracejada)
abline(v = mediana, col = "blue",      lwd = 2, lty = 4) # Mediana (Ponto e traço)
abline(v = moda,    col = "darkgreen", lwd = 2, lty = 1) # Moda (Contínua)

# 5. Adicionar grade horizontal de fundo
grid(nx = NA, ny = NULL, col = "gray", lty = "dotted")

# 6. Adicionar uma legenda explicativa
legend("topright", 
       legend = c(paste("Média:", round(media, 1)), 
                  paste("Mediana:", mediana), 
                  paste("Moda:", moda)),
       col = c("red", "blue", "darkgreen"),
       lty = c(2,2,2),
       lwd = 2,
       bty = "n",
       cex = 0.8)

Outro

# 1. Cálculos Estatísticos
vento <- storms$wind
media   <- mean(vento, na.rm = TRUE)
mediana <- median(vento, na.rm = TRUE)

# Cálculo da Moda (valor mais frequente)
tab_vento <- table(vento)
moda <- as.numeric(names(tab_vento)[tab_vento == max(tab_vento)])[1] 

# 2. Configurações de layout
par(mar = c(5, 5, 4, 2))

# 3. Criar o Histograma de Densidade
hist(vento, 
     prob = TRUE, 
     breaks = 25, 
     col = "#E6E6FA", # Lavender
     border = "white",
     main = "Distribuição de Ventos: Média, Mediana e Moda",
     xlab = "Vento (nós)", 
     ylab = "Densidade (Proporção)",
     las = 1, 
     ylim = c(0, 0.04))

# 4. Adicionar a Curva de Densidade
lines(density(vento), col = "darkorchid", lwd = 3)

# 5. Adicionar Linhas Verticais para as Medidas de Tendência Central
abline(v = media,   col = "red",       lwd = 2, lty = 2) # Média (Tracejada)
abline(v = mediana, col = "blue",      lwd = 2, lty = 4) # Mediana (Ponto e traço)
abline(v = moda,    col = "darkgreen", lwd = 2, lty = 1) # Moda (Contínua)

# 6. Adicionar Legenda Detalhada
legend("topright", 
       legend = c("Densidade", 
                  paste("Média:", round(media, 1)), 
                  paste("Mediana:", mediana), 
                  paste("Moda:", moda)),
       col = c("darkorchid", "red", "blue", "darkgreen"),
       lty = c(1, 2, 4, 1),
       lwd = 2,
       bty = "n",
       cex = 0.9)

# 7. Adicionar o "Rug Plot" para ver a concentração real dos dados
rug(vento, col = "gray40")

Detalhes técnicos desta visualização:

  1. prob = TRUE: Esta é a configuração chave. Ela muda o eixo Y de “Contagem” (1000, 2000…) para “Densidade” (0.01, 0.02…), permitindo comparar a frequência relativa.

  2. lines(density(...)): Agora a linha de densidade se encaixa perfeitamente sobre as barras, o que não acontece no gráfico de frequência absoluta.

  3. rug(): Adicionei pequenas marcas no eixo X que representam cada ponto de dado individual, excelente para identificar outliers ou lacunas nos dados de vento.

  4. Ajuste de ylim: Como os valores de densidade são decimais pequenos, definimos o limite superior (ex: 0.035) para garantir que o título e a legenda não fiquem em cima das barras.

5.1.4 Boxplot

# 1. Cálculos Estatísticos
vento <- storms$wind
media   <- mean(vento, na.rm = TRUE)
mediana <- median(vento, na.rm = TRUE)

# 2. Configurações de layout
par(mar = c(5, 5, 4, 2))

# 3. Criar o Boxplot
b <- boxplot(vento, 
        horizontal = TRUE,           # Gráfico na horizontal para facilitar leitura
        col = "#E6E6FA",             # Lavender (mesmo padrão do histograma)
        border = "black",            # Cor das linhas da caixa
        main = "Boxplot da Velocidade dos Ventos",
        xlab = "Vento (nós)",
        notch = TRUE,                # Adiciona um entalhe na mediana (intervalo de confiança)
        outline = TRUE,              # Exibe os outliers (pontos pretos)
        frame = FALSE)               # Remove o quadro externo

# 4. Adicionar Linhas Verticais para Média, Mediana e Moda
# (As linhas cruzam o gráfico para facilitar a comparação visual)
abline(v = media,   col = "red",       lwd = 2, lty = 2) # Média
abline(v = mediana, col = "blue",      lwd = 2, lty = 4) # Mediana
# Nota: A moda no boxplot coincide com a linha da maior concentração de dados

# 5. Adicionar Grade Vertical
grid(nx = NULL, ny = NA, col = "lightgray", lty = "dotted")

# 6. Adicionar Legenda Detalhada
legend("topright", 
       legend = c(paste("Média:", round(media, 1)), 
                  paste("Mediana:", mediana),
                  "Outliers (Pontos)"),
       col = c("red", "blue", "black"),
       lty = c(2, 4, NA),
       pch = c(NA, NA, 1),           # Símbolo do ponto para outliers
       lwd = c(2, 2, NA),
       bty = "n",
       cex = 0.9)

# 7. Adicionar rótulos numéricos nos quartis (opcional)
stats <- boxplot.stats(vento)$stats
text(x = stats, y = 1.3, labels = stats, col = "darkblue", font = 2, cex = 0.8)

Boxplot por categoria

# 1. Preparação: Garantir que 'category' seja um fator ordenado
# Isso evita que o gráfico exiba as categorias fora de ordem (ex: 1, 10, 2)
storms$category <- as.factor(storms$category)

# 2. Configurações de layout e margens
par(mar = c(5, 5, 4, 2))

# 3. Criar o Boxplot comparativo
boxplot(wind ~ category, 
        data = storms,
        main = "Intensidade do Vento por Categoria de Tempestade",
        xlab = "Categoria da Tempestade",
        ylab = "Vento (nós)",
        col = terrain.colors(length(unique(storms$category))), # Cores graduais
        border = "black",
        las = 1)                 # Números do eixo Y na horizontal

# 4. Adicionar grade horizontal para facilitar a leitura dos níveis de vento
grid(nx = NA, ny = NULL, col = "gray", lty = "dotted")

Detalhes técnicos desta visualização:

  • wind ~ category: Esta fórmula diz ao R: “Analise a variável numérica wind dividida pelos grupos da variável categórica category”.

  • terrain.colors(): Utilizei uma paleta que gera um degradê de cores, o que ajuda a enfatizar visualmente a progressão da gravidade das categorias.

  • Outliers por Categoria: Note que em cada categoria existem pontos (outliers). Isso mostra que, embora uma tempestade seja classificada como “Categoria 1”, ela pode ter picos de vento que fogem da média daquela classe específica.

  • Ajuste de Eixos: Se houver categorias com nomes longos, você pode usar las = 2 no comando boxplot para girar os nomes das categorias no eixo X.

5.1.5 Gráfico violino

Para criar um gráfico de violino é necessário utilizar o pacote vioplot, pois o R nativo não possui uma função violin() pré-instalada.

O gráfico de violino combina as vantagens do boxplot com um histograma espelhado (densidade), sendo ideal para visualizar a “massa” dos dados de vento da base storms.

# 1. Instalar e carregar o pacote necessário
if(!require(vioplot)) install.packages("vioplot")
## Carregando pacotes exigidos: vioplot
## Warning: pacote 'vioplot' foi compilado no R versão 4.4.3
## Carregando pacotes exigidos: sm
## Warning: pacote 'sm' foi compilado no R versão 4.4.3
## Package 'sm', version 2.2-6.0: type help(sm) for summary information
## Carregando pacotes exigidos: zoo
## Warning: pacote 'zoo' foi compilado no R versão 4.4.3
## 
## Anexando pacote: 'zoo'
## Os seguintes objetos são mascarados por 'package:base':
## 
##     as.Date, as.Date.numeric
library(vioplot)

# 2. Configurar o ambiente gráfico
par(mar = c(5, 5, 4, 2), bg = "#F9F9F9")

# 3. Criar o gráfico de violino detalhado
vioplot(storms$wind, 
        names = "Velocidade do Vento",
        col = "lightblue",          # Cor do corpo do violino
        border = "steelblue",       # Cor da borda
        rectCol = "darkblue",       # Cor do boxplot interno
        lineCol = "red",            # Cor das linhas internas
        colMed = "white",           # Cor do ponto da mediana
        areaEqual = FALSE,          # Mantém a escala de densidade original
        main = "Distribuição de Ventos (Gráfico de Violino)",
        ylab = "Vento (nós)",
        las = 1)

# 4. Adicionar Linha da Média (Customização Extra)
media_wind <- mean(storms$wind, na.rm = TRUE)
abline(h = media_wind, col = "red", lty = 2, lwd = 2)

# 5. Adicionar anotação de texto para a Média
text(x = 1.3, y = media_wind + 5, 
     labels = paste("Média:", round(media_wind, 1)), 
     col = "red", font = 2)

# 6. Adicionar grade para facilitar a leitura técnica
grid(nx = NA, ny = NULL, col = "gray", lty = "dotted")

# 7. Legenda explicativa
legend("topright", 
       legend = c("Mediana (Ponto Branco)", "Média (Linha Tracejada)", "IQR (Retângulo Azul)"),
       col = c("darkblue", "red", "darkblue"),
       lty = c(NA, 2, 1),
       pch = c(16, NA, NA),
       bty = "n", 
       cex = 0.8)

Detalhes técnicos desta visualização:

  • Corpo do Violino: A largura do “violino” representa a densidade de probabilidade. Onde o gráfico é mais largo, há mais registros daquela velocidade de vento na base storms.

  • Boxplot Interno: O vioplot desenha automaticamente um boxplot simplificado dentro do violino (o retângulo azul escuro representa o Intervalo Interquartil).

  • colMed = "white": Destaca a mediana como um ponto branco central, facilitando a localização rápida do centro dos dados.

  • rectCol e lineCol: Permitem separar visualmente as partes do gráfico, tornando-o profissional e pronto para apresentações acadêmicas ou relatórios de 2026.

  • Vantagem sobre o Boxplot: Enquanto o boxplot esconde a distribuição (se é bimodal ou unimodal), o violino mostra claramente que a maioria das tempestades em storms se concentra em velocidades baixas (perto de 30-50 nós).

Gráfico de Violino por categoria

# 1. Carregar pacote
if(!require(vioplot)) install.packages("vioplot")
library(vioplot)

# 2. Preparação: Converter status para fator para garantir a organização
storms$status <- as.factor(storms$status)

# 3. Ajustar margens (Aumentamos a margem inferior 'mar[1]' para os nomes caberem)
par(mar = c(10, 5, 4, 2)) 

# 4. Criar o gráfico de violino por Status
vioplot(wind ~ status, 
        data = storms,
        col = rainbow(length(levels(storms$status)), s = 0.5), # Cores distintas para cada status
        border = "darkgray",
        rectCol = "black",        # Boxplot interno em preto
        colMed = "white",         # Mediana em destaque branco
        main = "Variabilidade do Vento por Status da Tempestade",
        ylab = "Vento (nós)",
        xlab = "",                 # Removemos o rótulo do eixo X para não sobrepor
        las = 2,                   # Rotaciona os nomes do Status em 90 graus
        cex.names = 0.8)           # Ajusta tamanho da fonte dos nomes

# 5. Adicionar grade horizontal de referência
grid(nx = NA, ny = NULL, col = "gray", lty = "dotted")

# 6. Adicionar título ao eixo X manualmente (posicionado abaixo dos nomes rotacionados)
mtext("Status da Tempestade", side = 1, line = 8, font = 2)

# 7. Adicionar legenda informativa
legend("topright", 
       legend = c("Mediana", "Distribuição (Densidade)", "Quartis (Boxplot)"),
       pch = c(16, NA, 15), 
       col = c("white", "gray", "black"),
       bty = "n", 
       cex = 0.8)

Detalhes técnicos desta visualização:

  1. Assimetria (Symmetry): Observe como as categorias mais baixas (0 e 1) têm violinos “gordos” na base, indicando que a maioria das tempestades nessas classes fica no limite inferior de velocidade.

  2. Multimodalidade: Se um violino tiver dois “ombros” largos, isso sugere que existem dois grupos distintos de intensidades dentro da mesma categoria.

  3. Comparação de Medianas: O ponto amarelo permite comparar rapidamente se o salto de velocidade entre a Categoria 3 e 4 é maior do que entre a 1 e 2.

  4. Cores (Terrain Colors): A paleta facilita a visualização da progressão: tempestades mais fracas em tons de verde/marrom e as mais fortes (categorias 4 e 5) em tons mais claros/amarelados.

Este formato é ideal para relatórios técnicos em 2026, pois apresenta a estatística descritiva (boxplot interno) e a distribuição probabilística (curva de densidade externa) simultaneamente.

5.1.6 Gráfico de pizza

Gráficos de pizza são recomendados quando existem poucas categorias, caso contrário ele pode se tornar de difícil interpretação. Quando existem muitas categorias recomenda-se a utilização do gráfico de barras, conforme próximo exemplo.

Para criar o gráfico de pizza temos que colocar os nomes e valores em colunas e para isso utiliza-se a função table como auxiliar. Veja o exemplo:

# Funcao table organiza os dados, contando quantos registros de status
# existem para cada tipo de status. Ela é útil quando o tipo de dado
# da coluna é um "factor"

# 1. Preparação dos dados: contar frequências
status_freq <- table(storms$category)
kable(status_freq)
Var1 Freq
1 2548
2 993
3 593
4 553
5 116 
# 2. Criar porcentagens para exibir no gráfico
porcentagens <- round(100 * status_freq / sum(status_freq), 1)
labels_custom <- paste(names(status_freq), "-", porcentagens, "%")

# 3. Definir uma paleta de cores variada
cores <- rainbow(length(status_freq), s = 0.6, v = 0.9)

# 4. Ajustar margens para garantir que a legenda caiba
par(mar = c(1, 1, 3, 1))

# 5. Criar o gráfico de pizza
pie(status_freq, 
    labels = NA,               # Remove labels automáticos para usar legenda externa
    main = "Proporção de Status das Tempestades", 
    col = cores, 
    border = "white",          # Bordas brancas entre fatias para melhor contraste
    clockwise = TRUE,          # Organiza no sentido horário
    init.angle = 90)           # Inicia o desenho no topo (12 horas)

# 6. Adicionar uma legenda detalhada ao lado
legend("bottom", 
       legend = labels_custom, 
       fill = cores, 
       title = "Categorias de Status",
       cex = 0.7,              # Reduz o tamanho da fonte da legenda
       ncol = 2,               # Organiza em 2 colunas para economizar espaço
       bty = "n")              # Remove a caixa ao redor da legenda

Detalhes técnicos desta visualização:

  • table(storms$status): Consolida as categorias para o cálculo das fatias.

  • labels = NA: Omitimos os rótulos diretamente nas fatias porque muitos nomes se sobreporiam. Em vez disso, calculamos as porcentagens manualmente.

  • rainbow(): Gera uma gama de cores distintas para cada um dos diferentes status presentes na base.

  • init.angle = 90: Alinha o início da primeira fatia ao topo do círculo, o que é um padrão estético comum.

  • legend(): Adicionamos a legenda na parte inferior (bottom) com duas colunas (ncol = 2) para garantir que todas as categorias (como “hurricane”, “tropical storm”, etc.) fiquem visíveis sem poluir o gráfico.

5.1.7 Gráfico de barras

Também é construído de forma semelhante ao de pizza, onde são necessários os valores para cada situação.

# 1. Preparação dos dados: contar frequências da coluna 'status'
status_freq <- table(storms$status)

# 2. Ordenar as barras da maior para a menor (opcional, para melhor visualização)
status_freq <- status_freq[order(status_freq, decreasing = TRUE)]

# 3. Definir uma paleta de cores personalizada
cores <- terrain.colors(length(status_freq))

# 4. Ajustar as margens do gráfico para que os nomes longos caibam no eixo X
# mar = c(bottom, left, top, right)
par(mar = c(9, 5, 4, 2)) 

# 5. Criar o gráfico com a função plot (ou barplot para maior controle)
bp <- barplot(status_freq,
        main = "Distribuição de Status das Tempestades (Base storms)", # Título
        #sub = "Fonte: NOAA Dataset",          # Subtítulo 
        ylab = "Frequência Absoluta",          # Título eixo Y
        cex.axis = 0.7,                        # Reduz tamanho dos números do eixo
        col = cores,                           # Cores das barras
        border = "darkgray",                   # Cor da borda
        las = 2,                               # Rotacionar texto eixo X (vertical)
        cex.names = 0.8,                       # Tamanho da fonte dos nomes
        ylim = c(0, max(status_freq) * 1.2))  # Aumentar topo para caber os números

# 6. Adicionar grade horizontal para facilitar a leitura
grid(nx = NA, ny = NULL, col = "gray", lty = "dotted")

# 7. Adicionar os valores exatos acima de cada barra
text(x = bp, 
     y = status_freq, 
     label = status_freq, 
     pos = 3, 
     cex = 0.7, 
     col = "darkblue", 
     font = 2)

# 8. Resetar as configurações de margem padrão (boa prática)
# dev.off() ou par(mar = c(5, 4, 4, 2) + 0.1)

Detalhes técnicos desta visualização:

table(storms$status): Transforma os dados brutos em uma tabela de contagem necessária para o gráfico.

par(mar = …): Aumenta o espaço inferior (bottom) para evitar que os nomes das categorias (que são longos em storms) sejam cortados.

las = 2: Gira as etiquetas do eixo X em 90 graus, tornando-as legíveis.

ylim: Definimos o limite do eixo Y um pouco acima da maior barra para garantir que o texto dos números (text) não fique cortado no topo.

pos = 3: Posiciona o texto exatamente “acima” das coordenadas Y fornecidas.

grid(): Adiciona linhas de referência que tornam o gráfico mais técnico e fácil de interpretar.

5.1.8 Criando curvas

Utilize a função curve para produzir gráficos com curvas matemáticas conhecidas. Veja o exemplo:

# FUNÇÃO CURVE

curve(x^2, col = "blue")
curve(x^3, col = "green", add = T)
curve(x^4, col = "red", add = T)

5.1.9 Organizando os seus gráficos

A função X11() abre um novo canvas para você publicar seus gráficos enquanto a função dev.off() desliga esse canvas. Por sua vez, a função par() você organiza seus gráficos.

# Edita as margens do gráfico
par(mar= c(10,10,3,3))

# Organiza vários gráficos em um só canva.
par(mfrow=c(2,2)) # um canvas com 4 gráficos, 2 linhas e 2 colunas

5.2 Função ggplot2

Para trabalharmos gráficos com o ggplot é necessária a instalação da library(ggplot2). Não esqueça de verificar se ela está intalada e, se não tiver, instale.

A função ggplot utiliza uma estrutura em camadas que permite ir agregando “funcionalidades”.
A sua função básica é a ggplot() é a funçã base.

A função aes() define o espaço onde serão plotadas as informações.
Algumas características o aes são:
- x - posição no eixo x;
- y - posição no eixo y;
- shape - tipo dos marcadores (pontos, quadrados, cruzes, etc);fill - “cor de dentro” do objeto;
- color - cor do contorno dos objetos internos do gráfico (barras,…); - alpha - nível de transparência dos objetos;
- size - tamanho dos objetos.

A função geom() possui uma infinidade de funcionalidades. Destado agumas mais relevantes:
- geom_abline() – Linhas de referência: horizontal, vertical e diagonal
- geom_bar() – Gráficos de barra
- geom_boxplot() – Cria um boxplot
- geom_density() – Estimativa de densidade kernel
- geom_density_2d() – Estimativa de densidade kernel 2d apresentando os resultados com contorno
- geom_dotplot() – Gráfico de pontos
- geom_label() – Texto
- geom_map() – Polígonos de um mapa de referência
- geom_path() – Conectar observações
- geom_point() – Pontos

Outras funcionalidades:
- geom_bin2d() – Mapa de calor das contagens de bin 2d
- geom_blank() – Plot em branco
- geom_contour() – 2D contornos de uma superfície 3d
- geom_count() – Conta pontos sobrepostos
- geom_crossbar() – Intervalos verticais: linhas, barras transversais e barras de erro
- geom_errorbarh() – Barras de erro horizontais
- geom_freqpoly() – Histogramas e polígonos de frequência
- geom_hex() – Mapa de calor hexagonal de contagens de bin 2d
- geom_jitter() – Pontos agitados
- geom_polygon() – Polígonos
- geom_qq_line() – Um gráfico quantil-quantil
- geom_quantile() – Regressão quantílica
- geom_raster() – Retângulos
- geom_ribbon() – Fitas e gráficos de área
- geom_rug() – Parcelas de tapete nas margens
- geom_segment() – Segmentos de linhas e curvas
- geom_smooth() – Meios condicionais suavizados
- geom_spoke() – Segmentos de linha parametrizados por localização, direção e distância
- geom_violin() – Trama de violino

Alguns temas para dar estilo aos seus gráficos:
- theme_classic()
- theme_bw()
- theme_grey()   - theme_gray()
- theme_linedraw()
- theme_light()
- theme_minimal()   - theme_classic()
- theme_dark()

5.2.1 Aplicando a função ggplot2

Serão apresentadas as funções paulatinamente:

Função ggplot():

# Cria um espaço para os gráficos e associa os dados
ggplot(storms)

O sinal de **_ + _** no final da linha agrega às funções subsequentes, formando um comando único.

Funão aes():
A função aes tem seu nome derivado de “aesthetics”, que significa “estético” em Português.
Nela é especificado o canvas onde serão plotados os gráficos, assim como seus eixos e características.

ggplot(storms) +
  aes(year, wind)

5.2.2 Tipos de gráficos - funções geom:

geom_point()

ggplot(storms) +
  aes(year, wind) +
  geom_point()

Para configurarmos o gráfico, podemos incluir informações nas funções:
Alterando as cores e o tamanho dos pontos.

ggplot(storms) +
  aes(year, wind, color = category, size = wind) +
  geom_point()

Repetindo o mesmo gráfico, com alteração de eixo y:

ggplot(storms) +
  aes(year, pressure, color = category, size = wind) +
  geom_point()+
  geom_smooth(method = "lm")
## Warning: Using `size` aesthetic for lines was deprecated in ggplot2 3.4.0.
## ℹ Please use `linewidth` instead.
## This warning is displayed once every 8 hours.
## Call `lifecycle::last_lifecycle_warnings()` to see where this warning was
## generated.
## `geom_smooth()` using formula = 'y ~ x'
## Warning: The following aesthetics were dropped during statistical transformation: size.
## ℹ This can happen when ggplot fails to infer the correct grouping structure in
##   the data.
## ℹ Did you forget to specify a `group` aesthetic or to convert a numerical
##   variable into a factor?

Entendendo como agregar funcionalidades:

ggplot(storms) +
    geom_col(aes(year,mean(wind), color = year)) 

ggplot(storms) +
    geom_bar(aes(pressure, color = year)) 
## Warning: The following aesthetics were dropped during statistical transformation:
## colour.
## ℹ This can happen when ggplot fails to infer the correct grouping structure in
##   the data.
## ℹ Did you forget to specify a `group` aesthetic or to convert a numerical
##   variable into a factor?

ggplot(storms) +
    geom_histogram(aes(wind), bins = 15)

ggplot(storms) +
  geom_histogram(aes(wind), bins = 15) +
  theme_classic()

Um boxplot do vento (wind) por status da tempestade.
É necessário juntar uma seleção do dplyr onde é realizado o agrupamento por status e depois desenhar o gráfico com o ggplot.
Observe que:
- no dplyr as funções se conectam com %>% , enquanto no
- ggplot as funções se concectam com o _ + _.

storms %>%
  select(status, wind) %>%
  group_by(status) %>%
  ggplot() +
    geom_boxplot(aes(status, wind, color = status)) 

storms %>%
  select(year, status, wind) %>%
  group_by(year, status) %>%
  summarise(media_vento = mean(wind)) %>%
    ggplot() +
      geom_line(aes(year, media_vento, color = status)) 
## `summarise()` has grouped output by 'year'. You can override using the
## `.groups` argument.

5.2.2.1 Configurando títulos e legendas

A função labs é utilizada para configurar títulos e legenda.
Veja os exemplos.

storms %>% 
  group_by(status, category) %>%
  count(category) %>% #Este comando retorna a quantidade de ocorrencias por categoria em uma tabela cujos nomes são category e n
ggplot() +
  geom_col(
    aes(status,n, fill = category)) +
    labs(legend = TRUE,
       title = "Aula de ggplot",
       subtitle = "Quantidade de tempestates por status",
       x = "Status da tempestade",
       y = "Número de ocorrência por status e categoria",
       caption = "Fonte: base storms do dplyr") +
       coord_flip() # Inverte os eixos do gráfico
## Ignoring unknown labels:
## • legend : "TRUE"

5.2.2.2 Facet

A facet_wrap e a facet_grid permitem a subdivisão das áreas de plotagem em diversos gráficos, conforme o tema de interesse.
Vejam os exemplos dos histogramas de ventos (wind) no decorrer dos anos anteriores a 2021.

storms %>%
  filter(year > 2012) %>%
ggplot() +
  geom_histogram(aes(wind), bins = 15) +
  facet_wrap(~ year)

Perceba a diferença entre o facet_grid e o facet_wrap.

storms %>%
  filter(year > 2012) %>%
ggplot() +
  geom_histogram(aes(wind), bins = 10) +
  facet_grid(~ year)

6 Estatística

Estatística Descritiva é o ramo da estatística que envolve a organização, o resumo e a representação dos dados.

Estatística Inferencial é o ramo da estatística que envolve o uso de uma amostra para chegar a conclusões sobre a população e tem como ferramenta básica a probabilidade.

6.1 Probabilidade

6.2 Estatística Descritiva

6.2.1 Medidas de posição

Média Mediana Moda

6.2.2 Medidas de dispersão

Desvio Padrão Variância Erro padrão

6.2.3 Distribuição de frequência

6.2.3.1 Histograma – gráfico da distribuição de frequência

6.2.3.2 Assimetria

A avaliação de assimetria quantifica o grau de desvio de um conjunto de dados em relação a uma distribuição simétrica. Ela é essencial para entender a forma da distribuição e identificar onde os dados estão concentrados.

A assimetria de um conjunto de números é o terceiro momento central dividido pelo segundo momento central elevado à potência de três meios.
As principais utilidades dessa análise incluem:

identificação de Tendências e Padrões: permite descobrir nuances e padrões ocultos que medidas de centro (como média) sozinhas não revelariam.
Seleção de Modelos Estatísticos: ajuda a escolher o modelo probabilístico mais adequado para descrever o comportamento dos dados observados.
Diagnóstico da Forma da Curva: permite antecipar o formato de um histograma e suas caudas (esquerda ou direita) sem a necessidade imediata de construí-lo graficamente.
Detecção de Valores Extremos (Outliers): ajuda a identificar a influência de valores muito altos ou baixos que podem distorcer a média e comprometer testes estatísticos ou modelos de previsão.
Verificação de Normalidade: é um passo crucial para verificar se os dados se aproximam de uma distribuição normal, onde a assimetria deve ser próxima de zero.

Tipos de Assimetria
Simétrica: Média, mediana e moda coincidem no centro.
Positiva (à direita): a cauda é mais longa para o lado direito; a média é maior que a mediana e a moda.
Negativa (à esquerda): a cauda é mais longa para o lado esquerdo; a média é menor que a moda.

Avaliação Numérica (Coeficiente de Assimetria)

O R não possui uma função de assimetria nativa no pacote base, por isso é comum utilizar os pacotes moments ou e1071.

Para exemplificar, utilizaremos a base de dados airquaity - data(airquality).

install.packages(“moments”)
library(moments)
skewness(meus_dados)

Quando skewness:
= 0: distribuição simétrica (como a distribuição normal).
> 0 (Positiva) - cauda à direita. A maioria dos dados está concentrada à esquerda (valores baixos).
< 0 (Negativa) - cauda à esquerda. A maioria dos dados está concentrada à direita (valores altos).

data(airquality)
library(moments)
skewness(airquality$Wind) # >0, leve assimetria positiva
## [1] 0.3443985
skewness(airquality$Temp) # <0, leve assimetria negativa
## [1] -0.3741696

Avaliação Visual
Gráficos são essenciais para confirmar se a assimetria calculada faz sentido fisicamente.

Com Histograma

par(mfrow=c(1,2)) # Cria um canvas com 1 linha e 2 colunas
hist(na.omit(airquality$Ozone), 
     breaks = 5,
     main = "Ozonio",
     xlab = "Ozonio",
     ylab = "Frequência",
     col = blues9)
hist(na.omit(airquality$Solar.R), 
     main = "Temp", 
     xlab = "Temperatura",
     ylab = "Frequência",
     col = "red")

Com Boxplot

boxplot(meus_dados).

Se a linha da mediana estiver mais próxima da parte inferior da caixa e o “bigode” superior for mais longo, há assimetria positiva.

par(mfrow=c(1,2)) # Cria um canvas com 1 linha e 2 colunas

boxplot(na.omit(airquality$Ozone), 
     main = "Ozonio",
     ylab = "Ozonio",
     sub = "Assimetria a direita (positiva)",
     col = blues9)

boxplot(na.omit(airquality$Solar.R), 
     main = "Solar.R",
     ylab = "Solar.R",
     sub = "Assimetria a esquerda (negativa)",
     col = "red")

Sintetizando

library(sn)
## Warning: pacote 'sn' foi compilado no R versão 4.4.3
## Carregando pacotes exigidos: stats4
## 
## Anexando pacote: 'sn'
## O seguinte objeto é mascarado por 'package:lubridate':
## 
##     dst
## O seguinte objeto é mascarado por 'package:stats':
## 
##     sd
par(mfrow=c(1,3)) # Cria um canvas com 1 linha e 3 colunas

curve(dbeta(x,10,3), 
      from = 0, to = 1, 
      col = "darkred", lwd = 2,
      main = "Curva com Assimetria Negativa",
      sub = "Assimetrica a esquerda \n skewness < 0 \n Media < Mediana < Moda",
      ylab = "Densidade")

curve(dnorm(x, mean =0 , sd = 1), 
      from = -3, to = 3, 
      col = "black", lwd = 2,
      main = "Curva de Densidade Normal",
       sub = "Simetrica \n skewness = 0",
      ylab = "Densidade")

curve(dlnorm(x, meanlog = 0, sdlog = 0.8), 
      from = 0, to = 10, 
      col = "blue", lwd = 2,
      main = "Assimetria Positiva",
      sub = "Assimetrica a direita \n skewness > 0 \n Media > Mediana > Moda",
      ylab = "Densidade")

Testes Estatísticos

Para verificar se a assimetria é estatisticamente significativa, você pode usar o Teste de D’Agostino disponível no pacote moments.

Se o p-valor < 0,05, a distribuição é considerada significativamente assimétrica.

agostino.test(na.omit(airquality$Ozone))
## 
##  D'Agostino skewness test
## 
## data:  na.omit(airquality$Ozone)
## skew = 1.2257, z = 4.6564, p-value = 0.000003219
## alternative hypothesis: data have a skewness
agostino.test(na.omit(airquality$Solar.R))
## 
##  D'Agostino skewness test
## 
## data:  na.omit(airquality$Solar.R)
## skew = -0.42363, z = -2.10903, p-value = 0.03494
## alternative hypothesis: data have a skewness

6.2.3.3 Curtose – achatamento

6.2.3.4 Forma da curva normal

6.3