Introdução ao R
Prof. Vinícius A. Vale (NEDUR-UFPR), Tania M. Alberti (NEDUR-UFPR) e Davi W. Catelan (NEDUR-UFPR)

Introdução ao R

Vinícius A. Vale\(^{\Phi}\), Tania M. Alberti\(^{\Theta}\) e Davi W. Catelan\(^{\Theta}\) Julho, 2022
\(^{\Phi}\)Professor do Departamento de Economia e do Programa de Pós-Graduação em Desenvolvimento Econômico (PPGDE) da Universidade Federal do Paraná (UFPR) e Pesquisador do Núcleo de Estudos em Desenvolvimento Urbano e Regional (NEDUR)
\(^{\Theta}\)Doutorando(a) no Programa de Pós-Graduação em Desenvolvimento Econômico (PPGDE) da Universidade Federal do Paraná (UFPR) e Pesquisador(a) do Núcleo de Estudos em Desenvolvimento Urbano e Regional (NEDUR)

1. Introdução

O curso Introdução ao R tem como objetivo apresentar os elementos básicos do software R e do RStudio, incluindo linguagem, operações básicas, criação de objetos, importação e exportação de dados, manipulação de dados e visualização (gráficos e mapas).

O material do curso é livre e está licenciado com uma Licença CC BY-NC-SA 4.0. Atualizações podem ser consultadas no site do Núcleo de Estudos em Desenvolvimento Urbano e Regional - NEDUR - da Universidade Federal do Paraná (UFPR).

Pré-requisito: Software R e RStudio instalados (links na Seção 2).

Sugestão: Para um melhor aproveitamento do curso, sugere-se realizar a leitura em etapas:

Etapas	Descrição	Seções
1a Etapa - Instalação e Links	Instalação do R e do RStudio e exploração de links úteis	Seções 2 e 3
2a Etapa - Passos Iniciais	Exploração do RStudio	Seções 4, 5 e 6
3a Etapa - Operações e Objetos	Apresentação das principais operações e objetos do R	Seções 7 e 8
4a Etapa - Objetos	Criação de variáveis, vetores e matrizes no R	Seções 9, 10 e 11
5a Etapa - Tabela de Dados	Exploração de tabelas de dados no R	Seção 12
6a Etapa - Dados	Importação, Exportação e Manipulação de dados R	Seções 13, 14 e 15
7a Etapa - Visualização de dados	Criação de gráficos e mapas no R	Seções 16 e 17

Na utilização ou citação de partes do material, referencie da seguinte maneira:

VALE, V. A.; ALBERTI, T. M.; CATELAN, D. W. Introdução ao R. Núcleo de Estudos em Desenvolvimento Urbano e Regional (NEDUR) da Universidade Federal do Paraná (UFPR), Curitiba-PR, 2022. Disponível em: http://nedur.ufpr.br/cursos

Bom curso!

2. Instalando o R e o RStudio

Para participar do curso e replicar os passos abaixo, será necessário instalar o R e o RStudio. Faça o download dos dois programas nos links abaixo:

• R
• RStudio

Instale primeiro o R e depois o RStudio!

Repare que, após a instalação do R e do RStudio, dois aplicativos estarão disponíveis no seu computador. Neste curso introdutório, vamos usar o RStudio, um ambiente de desenvolvimento integrado (IDE - Integrated Development Environment) ao R.

Procure pelo ícone do RStudio:

Alternativamente, você pode usar o RStudio Cloud. Entretanto, as figuras e exemplos abaixo foram elaborados com a versão RStudio Desktop (link para instalação acima).

3. Links úteis

Antes de iniciar de fato o curso no R e RStudio, acesse os links abaixo. Você vai encontrar outros materiais, dicas, exemplos, novidades e muito mais. Esses links serão úteis ao longo do seu processo de aprendizado.

Segure o Ctrl para abrir os links em novas abas:

• RStudio
• RStudio Cheatsheets
• RStudio Education
• RStudio Primers
• R-bloggers
• RPubs
• GitHub

Confira também alguns livros, materiais e blogs disponíveis:

• R for Data Science
• Hands-On Programming with R
• Advanced R
• R: Uma Introdução para economistas
• Ciência de Dados com R – Introdução
• Análise Macro
• Curso-R
• Datacamp

4. Passos iniciais

4.1. R Markdown

Este material foi elaborado no RStudio no formato .Rmd (arquivo R Markdown). O formato .Rmd permite combinar texto e código no mesmo arquivo. Além disso, permite gerar arquivos em html (como esse material), pdf, MS Word, entre outros formatos.

Embora seja um formato interessante para elaborar relatórios e materiais didáticos, neste curso introdutório ao R, não vamos focar na elaboração de documentos nesse formato. Mais informações sobre o R Markdown podem ser obtidas nos links abaixo:

• R Markdown
• R Markdown: The Definitive Guide
• R Markdown Cheat Sheet
• Bookdown
• Markdown

Observação: os códigos (comandos) nos arquivos .Rmd são apresentados dentro dos Code Chunks (retângulos cinzas neste arquivo). Você pode facilmente copiar os códigos e colar no Console do RStudio para replicar e obter os mesmos resultados. Além disso, você pode também copiar e colar os códigos no seu R Script. Veja abaixo mais detalhes!

4.2. Iniciando o RStudio

Para começar o curso, abra o RStudio. Se você está fazendo isso pela primeira vez, algo similar à Figura 1 estará disponível.

Figura 1 - RStudio

Primeiro, abra um novo R Script. Clique em File > New File > R Script (veja Figura 2 abaixo). Alternativamente, você pode usar o atalho Ctrl + Shift + N.

Figura 2 - RStudio

Após abrir o R Script, uma nova janela estará disponível no RStudio (veja Figura 3).

Observe que 4 janelas estarão disponíveis:

1. Source ou R Script (Editor de código) - Espaço onde você pode digitar seus códigos e comentários, incluindo os de leitura dos dados, manipulação e transformação dos dados, estimações, códigos de criação de variáveis, vetores, gráficos e tabelas, etc.
2. Console - Espaço para execução dos códigos.
3. Files, Plots, Packages, Help e Viewer (Output) - Espaço para visualização dos arquivos da pasta “setada”, gráficos construídos, biblioteca de packages (pacotes) instalados e help.
4. Environment - Espaço com os objetos (variáveis, vetores, matrizes, outros) e funções criadas.

Figura 3 - RStudio

Observação: ao longo do curso outros detalhes sobre cada uma das janelas e suas funções serão apresentados. Para uma visão completa do IDE do RStudio, veja a RStudio: IDE :: Cheat Sheet ou acesse rstudio.com.

4.3. R Script

Conforme detalhado acima, o R Script é um arquivo onde você pode digitar seus códigos (comandos). Além disso, você pode incluir comentários usando #.

Por exemplo, você pode inserir um cabeçalho com o nome do curso (e outras informações de seu interesse, como seu nome e data). Copie e cole no seu R Script o texto abaixo:

#Introdução ao R

Repare que o texto irá aparecer em verde (veja Figura 4). Nesse caso, como usamos # antes do texto “Introdução ao R”, o R reconhece essa linha como um comentário e não como um código (comando) executável.

Figura 4 - R Script

Observação: você pode inserir vários comentários para lembrar dos exemplos, funções etc. Lembre-se apenas de usar # antes de cada um deles.

4.4. Diretório de trabalho

Para começar de fato a trabalhar no RStudio, defina o diretório de trabalho. Você pode verificar o diretório de trabalho “setado” com a função getwd(). Digite getwd() no Console:

getwd()

## [1] "C:/Users/vinic/OneDrive/R-VALE/Intro-R"

Observe que o R irá retornar o diretório “setado”. Para definir um diretório de trabalho diferente, podemos usar a função setwd(). Digite o seu caminho, conforme exemplo abaixo.

Você pode copiar facilmente o caminho direto da sua pasta. Lembre-se apenas que o R utiliza a barra invertida / ou duas barras normais \\.

‣ Opção com /:

setwd("C:/Users/vinic/OneDrive/R-VALE/Intro-R")

‣ Opção com \\:

setwd("C:\\Users\\vinic\\OneDrive\\R-VALE\\Intro-R")

Caso tenha dificuldades com a função setwd(), utilize o atalho Ctrl + Shift + H e escolha a pasta desejada. Depois, confira se o caminho foi “setado” corretamente com a função getwd().

Salve esses dois comandos no seu R Script. Você pode adicionar comentários para lembrar do que se trata:

#Definição do diretório de trabalho
setwd("C:/Users/vinic/OneDrive/R-VALE/Intro-R")
 
#Verificação do diretório de trabalho "setado"
getwd()

Após fazer isso, observe que os comentários estarão em verde e as funções setwd() e getwd() em preto (ver Figura 5).

Figura 5 - R Script

Salve seu R Script. Clique em File > Save ou utilize o atalho Ctrl + S.

Observação: você pode facilmente copiar os comandos desse material e colar no Console do seu RStudio e/ou no seu R Script.

4.5. Limpar o Environment

Se você seguiu apenas os passos acima, nenhum objeto (“variável”, vetor ou matriz) foi criado. Entretanto, para começarmos de fato do zero, remova todos os objetos do Environment digitando o comando abaixo no Console:

rm(list = ls())

Para remover um único objeto, você pode utilizar a função rm() com o nome do objeto entre parênteses. Não se preocupe com isso agora, vamos usar e explicar melhor essas duas funções ao longo do curso.

Além disso, caso queira limpar o Console do seu RStudio, aperte Ctrl + L. Repare que as informações iniciais sobre a versão do RStudio irão desaparecer do Console.

Limpe o Console com frequência, o histórico de comandos executados fica disponível na aba History (ao lado da aba Environment).

4.6. Atalhos do RStudio

O RStudio possui vários outros atalhos (Keyboard Shortcut Quick Reference). A tabela abaixo apresenta alguns atalhos úteis:

Atalho	Descrição
Ctrl + L	Limpa o Console
Ctrl + Shift + H	Troca o diretório de trabalho
Ctrl + S	Salva o documento
Ctrl + Enter	Executa a linha selecionada

Para visualizar a lista completa de atalhos, aperte Alt + Shift + K.

Exemplo: para executar uma linha específica do R Script, podemos clicar na linha e apertar Ctrl + Enter. Nesse caso, apenas a linha específica será executada. Faça o teste com a função getwd() do seu R Script e observe o resultado no Console.

5. Packages

Neste curso introdutório, vamos usar alguns packages (pacotes) para manipular dados e gerar gráficos. Para instalar um pacote no R, usamos a função install.packages().

Entre os principais pacotes para Ciência de Dados, podemos citar os pertencentes ao tidyverse. O tidyverse reúne uma coleção de R packages para manipulação, importação e exportação de dados, visualização, entre outras funções.

Você pode ver a lista completa em www.tidyverse.org/packages.

Entre os pacotes, o ggplot2 é muito utilizado no R para criar gráficos. Para instalar esse pacote, por exemplo, digite install.packages("ggplot2") no Console:

install.packages("ggplot2")

O dplyr, por sua vez, é um pacote muito utilizado para manipular dados. Similarmente, instale o pacote dplyr com a função install.packages():

install.packages("dplyr")

Observação: você pode instalar todos os pacotes da coleção tidyverse com:

install.packages("tidyverse")

Após a instalação, faça a leitura de cada um deles com a função library():

library(ggplot2)

library(dplyr)

Observação: se você instalou o tidyverse, todos os pacotes da coleção tidyverse podem ser lidos com:

library(tidyverse)

Observe que após a leitura dos pacotes, várias mensagens em vermelho irão aprecer no Console. Essas mensagens são apenas avisos (warning message) de leitura do pacote. Como, por exemplo, sobre a versão:

Warning message: package ‘dplyr’ was built under R version 3.6.3

Observação: não é preciso instalar os pacotes toda vez que você fechar e abrir o R. Entretanto, é preciso ler os pacotes que você vai usar com a função library() toda vez que você abrir o R.

6. Ajuda

O R possui uma forma muito fácil de buscar ajuda e obter as principais informações sobre os pacotes e funções. Para tal, você pode usar ? seguido pelo nome do pacote ou função de interesse.

Por exemplo, você pode obter informações sobre a função sum (soma) com ?sum no Console. As informações irão aparecer na aba help do RStudio (veja Figura 6).

?sum

Figura 6 - Help

Similarmente, você pode obter informações sobre o pacote dplyr com:

?dplyr

Para ver exemplos da função sum, você pode usar a função example(). Observe que vários exemplos serão apresentados no Console do RStudio:

example(sum)

## 
## sum> ## Pass a vector to sum, and it will add the elements together.
## sum> sum(1:5)
## [1] 15
## 
## sum> ## Pass several numbers to sum, and it also adds the elements.
## sum> sum(1, 2, 3, 4, 5)
## [1] 15
## 
## sum> ## In fact, you can pass vectors into several arguments, and everything gets added.
## sum> sum(1:2, 3:5)
## [1] 15
## 
## sum> ## If there are missing values, the sum is unknown, i.e., also missing, ....
## sum> sum(1:5, NA)
## [1] NA
## 
## sum> ## ... unless  we exclude missing values explicitly:
## sum> sum(1:5, NA, na.rm = TRUE)
## [1] 15

Caso as dúvidas permaneçam, você pode procurar ajuda no Google. Para obter mais exemplos, tente procurar em inglês. Além disso, você pode procurar ajuda nos links abaixo:

• RStudio Community
• Stack Overflow
• GitHub

7. Operações básicas

O R permite fazer várias operações básicas. Os principais operadores aritméticos e lógicos estão descritos abaixo seguidos de alguns exemplos. Explore cada um deles e utilize o help em caso de dúvidas.

ATENÇÃO! você pode facilmente copiar e colar os comandos abaixo no seu R Script e Console. Entretanto, se preferir, você também pode fazer o download do R Script completo do curso AQUI.

7.1. Operadores aritméticos

A tabela abaixo resume os principais operadores aritméticos usados no R.

Operadores	Descrição
+	Adição
-	Subtração
*	Multiplicação
/	Divisão
^ ou **	Exponencial
%/%	Divisão inteira

Para ver mais detalhes dos operadores aritméticos, utilize o help:

?Arithmetic

Exemplos:

Faça as operações abaixo no Console do seu R, observe os resultados e lembre-se de manter os comandos no seu R Script.

‣ Adição +:

2 + 2 

## [1] 4

‣ Subtração -:

4 - 2 

## [1] 2

‣ Multiplicação *:

3 * 2 

## [1] 6

‣ Divisão /:

4 / 2 

## [1] 2

‣ Exponencial ^ ou **:

4 ^ 2 

## [1] 16

Ou

4 ** 2 

## [1] 16

‣ Divisão inteira %/%:

Repare que o resultado será apenas a parte inteira da divisão:

5 %/% 2

## [1] 2

7.2. Operadores lógicos

A tabela abaixo resume os principais operadores lógicos usados no R.

Operador	Descrição
==	Exatamente igual que
>	Maior que
<	Menor que
>=	Maior ou igual que
<=	Menor ou igual que
!=	“Não igual”
!	“Não”
&	“E”
|	“OU”
isTRUE(x)	Testa se x é “TRUE”
isFALSE(x)	Testa se x é “FALSE”

Para ver mais detalhes dos operadores lógicos, utilize o help:

?Logic

Exemplos:

Similarmente ao que foi feito com os operadores aritméticos, faça as operações abaixo no seu RStudio e observe os resultados.

‣ Igualdade ==:

Se você realizar a operação lógica 5 == 5, o resultado será TRUE (verdadeiro):

5 == 5

## [1] TRUE

Por outro lado, a operação lógica 5 == 4 retornará como resultado FALSE (falso):

5 == 4

## [1] FALSE

O mesmo raciocínio pode ser usado com os outros operadores:

‣ Maior que >:

5 > 4

## [1] TRUE

5 > 6

## [1] FALSE

5 > 5

## [1] FALSE

‣ Maior ou igual que >=:

5 >= 5

## [1] TRUE

‣ Menor que <:

6 < 10

## [1] TRUE

6 < 5

## [1] FALSE

6 < 6

## [1] FALSE

‣ Menor ou igual que <=:

5 <= 5

## [1] TRUE

Observação: exemplos com os demais operadores serão apresentados ao longo do curso.

8. Objetos e classes

Os objetos na linguagem de programação são formas de armazenar dados.

No R base, os principais objetos são atomic vector, matrix, array, list e data frame.

Em síntese, esses objetos podem ser diferenciados pelas suas dimensões e conteúdo. A dimensão varia entre uma (1d), duas (2d) e múltipla (nd). O conteúdo dos objetos, por sua vez, pode ser homogêneo (elementos do mesmo tipo) ou heterogêneo (diferente tipo de elementos).

Objeto	Dimensão	Conteúdo
Atomic vector	1d	homogêneo
Matrix	2d	homogêneo
Array	nd	homogêneo
List	1d	heterogêneo
Data frame	2d	heterogêneo
Fonte: adaptação de Wickham (2015).

Obervação: o R não possui objetos com dimensão 0 ou do tipo escalar. Números individuais ou strings são vetores de tamanho igual a um (WICKHAM, 2015).

E, em geral, o R possui as seguintes classes (tipos de dados):

• Texto (character)
• Numérico (numeric)
• Inteiro (inteiro)
• Complexo (complex)
• Lógico (logic)

Vamos explorar a seguir o processo de criação e manipulação desses objetos. Além disso, vamos explorar as classes dos objetos criados.

9. Variáveis

Nos exemplos com operadores aritméticos, nenhum resultado foi armazenado no Environment do RStudio. Para tal, é necessário definir um objeto.

Lembre-se, o R não possui objetos do tipo escalar. Números individuais são vetores de tamanho igual a um. Portanto, “variável” nesta seção refere-se a um vetor de tamanho igual a um.

Por exemplo, digite o comando abaixo no seu Console:

x <- 5

Repare que o resultado ficará disponível no Environment do RStudio (veja Figura 7).

Figura 7 - Environment

Dessa maneira, você pode utilizar o objeto x e operadores aritméticos para criar outras variáveis (objetos) e realizar outras operações.

Uma variável y, por exemplo, pode ser definida como x mais a unidade:

y <- x + 1

Observe que a variável y também ficará armazenada no Environment. Se quiser ver o seu valor, digite y no Console:

y

## [1] 6

Outras operações também podem ser utilizadas. Crie, por exemplo, a variável z conforme abaixo:

z <- 2 * x 

z

## [1] 10

Observação: para criar objetos, podemos utilizar <- ou =. O resultado de x = 5 e y = x + 1 será o mesmo que anteriormente (x <- 5 e y <- x + 1). Faça o teste:

x = 5

y = x + 1

y

## [1] 6

Por que usar <- e não =? Na lógica da programação em R, usar x <- 5 significa que estamos atribuindo um valor 5 ao objeto x. =, por sua vez, é utilizado para especificar os argumentos de uma função, como veremos no decorrer do curso.

Antes de seguir, utilize a função rm() apresentada no início do material. Remova apenas a variável y do Environment com o seguinte comando:

rm(y)

Observe que as outras “variáveis” (objetos), x e z, continuarão disponíveis.

Agora, remova todos os objetos do Environment:

rm(list = ls())

Nesse último caso, o Environment ficará sem nenhum objeto.

10. Vetores

10.1. Criação de vetores

Além de “variáveis” (vetor de tamanho igual a um), o R permite criar vetores maiores.

Por exemplo, você pode criar um vetor x com os elementos {1, 5, 6} com auxílio da função c():

x <- c(1, 5, 6)

Observe que o vetor estará disponível no seu Environment. Para ver o vetor, digite x no Console:

x

## [1] 1 5 6

Se preferir, utilize a função View(). Nesse caso, uma janela de visualização com o vetor será aberta:

View(x)

Observação: o R é case-sensitive, ou seja, sensível a letras maiúsculas e minúsculas. “View” e “view” são coisas diferentes para o R. Assim como x e X. Fique atento!

Se você usar “view”, o R irá retornar Error in view(x) : could not find function “view”.

Uma vez criado o vetor, podemos verificar a sua classe (tipo) com a função class(). Nesse caso, o R retornará “numeric”, pois trata-se de um objeto numérico.

class(x)

## [1] "numeric"

Entretanto, os vetores não precisam ser numéricos. Podemos criar vetores do tipo texto (“character”). Crie, por exemplo, o vetor y conforme abaixo:

y <- c("NEDUR", "UFPR", "Regional", "Urbana")

y

## [1] "NEDUR"    "UFPR"     "Regional" "Urbana"

Verifique a classe do vetor y com a função class(). Nesse caso, o R retornará “character”:

class(y)

## [1] "character"

Vetores lógicos também podem ser criados no R:

v <- c(TRUE, FALSE, TRUE)

v

## [1]  TRUE FALSE  TRUE

Se usarmos a função class(), o R retornará “logical”:

class(v)

## [1] "logical"

É possível criar vetores heterogêneos com números, texto e lógica. Entretanto, o R converterá automaticamente para o formato “character” (texto). Por exemplo:

g <- c("NEDUR", TRUE, 10)

g

## [1] "NEDUR" "TRUE"  "10"

class(g)

## [1] "character"

Além disso, podemos criar vetores como uma sequência regular de números inteiros com auxílio do operador ::

r <- c(1:5)

r

## [1] 1 2 3 4 5

Vetores também podem ser criados com auxílio da função seq():

q <- seq(2, 4, by = 0.5)

Repare que nesse caso o vetor q será dado por uma sequência regular de 2 a 4 com intervalo de 0.5 dado o argumento by = 0.5:

q

## [1] 2.0 2.5 3.0 3.5 4.0

Você pode mudar os parâmetros dos argumentos dentro da função. Teste os três próximos exemplos e observe os resultados:

seq(1, 9, by = 2)

## [1] 1 3 5 7 9

seq(1, 10, by = 1)

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

seq(1, 9, by = pi)

## [1] 1.000000 4.141593 7.283185

Observação: lembre-se que pi = 3.141593. Faça o teste, digite pi no Console do RStudio:

pi

## [1] 3.141593

Além dos exemplos acima, podemos criar sequências regulares dentro de um intervalo. Nesse caso, especifique o tamanho do vetor com a função length().

Teste as opções abaixo e observe os resultados:

seq(0, 1, length = 1)

## [1] 0

seq(0, 1, length = 2)

## [1] 0 1

seq(0, 1, length = 3)

## [1] 0.0 0.5 1.0

seq(0, 1, length = 4)

## [1] 0.0000000 0.3333333 0.6666667 1.0000000

seq(0, 1, length = 5)

## [1] 0.00 0.25 0.50 0.75 1.00

Vetores também podem ser criados com auxílio da função rep():

w <- rep(5, times = 3)

Repare que, nesse caso, o vetor w será um vetor com o número 5 repetido 3 vezes:

w

## [1] 5 5 5

Observação: A função replicate(5, 3) irá gerar um resultado diferente. Faça o teste e tire suas dúvidas sobre os argumentos de cada uma das funções. Para tal, digite ?rep e depois ?replicate no Console do RStudio.

replicate(5, 3)

## [1] 3 3 3 3 3

A função rep() também pode ser usada com texto:

e <- rep("NEDUR", times = 3)

e

## [1] "NEDUR" "NEDUR" "NEDUR"

Mude os parâmetros e observe o novo padrão gerado:

rep(1:2, times = 3)

## [1] 1 2 1 2 1 2

rep(1:2, each = 3)

## [1] 1 1 1 2 2 2

Antes de continuar, remova todos os objetos do Environment:

rm(list = ls())

10.2. Indexação de vetores

Após a criação de vetores, é possível selecionar um elemento específico (ou elementos) considerando a posição ou valor.

Crie um vetor g com os elementos {1, 5, NEDUR, 2, 6}:

g <- c(1, 5, "NEDUR", 2, 6)

Considerando o vetor g, podemos verificar o elemento contido na posição 3 com a seguinte notação:

g[3]

## [1] "NEDUR"

Similarmente, podemos verificar os elementos contidos entre as posições 2 e 4 com:

g[2:4]

## [1] "5"     "NEDUR" "2"

Para verificar os elementos de g, exceto o elemento contido na posição 3, usamos:

g[-3]

## [1] "1" "5" "2" "6"

Similarmente, podemos verificar os elementos de g exceto aqueles contidos entre as posições 2 e 4 com:

g[-(2:4)]

## [1] "1" "6"

Os elementos de um vetor também podem ser verificados com auxílio da função c(). Por exemplo, os elementos contidos nas posições 1 e 5 podem ser obtidos com:

g[c(1, 5)]

## [1] "1" "6"

Essa última forma de indexação é útil para criar outros vetores. Com a indexação abaixo, por exemplo, podemos criar um novo vetor n com apenas os elementos 1 e 5 do vetor g:

n <- g[c(1, 5)]

n

## [1] "1" "6"

Observação: como exercício, faça o teste com as demais formas de indexação. Crie outros vetores e explore os resultados.

Além da seleção por posição, podemos selecionar elementos de um vetor baseado em valores. Crie o vetor v com os elementos {1, 2, 2, 4, 5}:

v <- c(1, 2, 2, 4, 5)

Para selecionar os elementos iguais a 2, podemos usar:

v[v == 2]

## [1] 2 2

Para selecionar os elementos menores que 4, podemos usar:

v[v < 4]

## [1] 1 2 2

Para selecionar os elementos que pertencem ao conjunto {1, 2}, por sua vez, podemos usar:

v[v %in% c(1, 2)]

## [1] 1 2 2

Antes de continuar, remova todos os objetos do Environment:

rm(list = ls())

10.3. Operações com vetores

Assim como foi feito com as variáveis (vetores de tamanho igual a um), é possível realizar operações aritméticas e lógicas com os vetores. Para tal, defina um vetor k com os seguintes elementos {2, 4, 6, 8, 10}:

k <- c(2, 4, 6, 8, 10)

k

## [1]  2  4  6  8 10

Multiplicar o vetor k por 2 significa multiplicar cada um dos seus elementos por 2:

k * 2

## [1]  4  8 12 16 20

Similarmente, dividir o vetor k por 2 significa dividir cada um dos seus elementos por 2:

k / 2

## [1] 1 2 3 4 5

Faça o teste com K + 1 e K - 1:

k + 1

## [1]  3  5  7  9 11

k - 1

## [1] 1 3 5 7 9

Além das operações acima, podemos realizar operações com mais de um vetor, como somar dois vetores. Para tal, defina um vetor s conforme abaixo:

s <- c(1, 2, 3, 4, 5)

Em seguida, crie um novo vetor b que seja dado pela soma de k e s. Observe que o resultado será a soma elemento a elemento dos dois vetores.

b <- k + s

b

## [1]  3  6  9 12 15

Além das operações aritméticas, operações lógicas também podem ser realizadas com os vetores. Considerando o vetor b criado acima, podemos verificar quais elementos são maiores ou iguais a 9 com:

b >= 9

## [1] FALSE FALSE  TRUE  TRUE  TRUE

Repare que o resultado encontrado foi TRUE (verdadeiro) para os elementos maiores ou iguais a 9 e FALSE (falso) caso contrário. Ou seja, a operação reporta um resultado lógico.

Se o interesse for reportar os valores maiores ou iguais a 9, podemos utilizar a operação abaixo. Nesse caso, como mostrado anteriormente, o R irá retornar os valores que são TRUE (verdadeiros) para a condição especificada, ou seja, {9, 12, 15}.

b[b >= 9]

## [1]  9 12 15

Se o interesse for encontrar a posição desses valores maiores ou iguais a 9, você pode utilizar a função which(). Nesse caso, o resultado será “3 4 5”, ou seja, os elementos maiores ou iguais a 9 são aqueles nas posições 3, 4 e 5.

which(b >= 9)

## [1] 3 4 5

10.4. Funções com vetores

Diversas funções matemáticas e estatísticas podem ser aplicadas aos vetores numéricos, como soma, média, valor máximo, mínimo, quantis, entre outras.

A tabela abaixo apresenta algumas dessas funções:

Função	Descrição
sum()	Retorna a soma do vetor
mean()	Retorna a média do vetor
sd()	Retorna o desvio padrão do vetor
median()	Retorna a mediana do vetor
var()	Retorna a variância do vetor
min()	Retorna o valor mínimo do vetor
max()	Retorna o valor máximo do vetor
range()	Retorna o valor mínimo e o máximo do vetor
summary()	Retorna um sumário do vetor
quantile()	Retorna os quantis do vetor
cor()	Retorna a correlação entre dois vetores

Para facilitar a visualização, limpe o seu Environment:

rm(list = ls())

Após limpar o Environment, defina um vetor x com os elementos {2, 4, 6, 8, 10}:

x <- c(2, 4, 6, 8, 10)

Teste algumas das operações listadas acima:

‣ Soma:

A função sum() retorna a soma do vetor:

sum(x)

## [1] 30

‣ Média:

A função mean() retorna a média do vetor:

mean(x)

## [1] 6

‣ Mínimo e Máximo:

A função range() retorna o maior e o menor valor do vetor:

range(x)

## [1]  2 10

Observação: Se quiser ver apenas o mínimo ou o máximo, use as funções min(x) e max(x), respectivamente.

‣ Sumário:

A função summary() retorna um sumário do vetor, incluindo mínimo, 1^o quantil, mediana, média, 3^o quantil e máximo.

summary(x)

##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##       2       4       6       6       8      10

10.5. Outras funções

A tabela abaixo apresenta outras funções que podem ser usadas com os vetores:

Função	Descrição
sort()	Retorna o vetor em ordem crescente ou decrescente
rev()	Retorna o reverso do vetor
table()	Retorna a contagem dos valores
unique()	Retorna os valores únicos
order()	Retorna a ordem dos elementos do vetor
length()	Retorna o tamanho do vetor
cumsum()	Retorna um vetor que é a soma cumulativa do vetor objeto
is.na()	Retorna um vetor lógico com TRUE para valor ausente (NA)
paste()	Concatena vetores

Para ver alguns exemplos, crie um vetor g com os seguintes elementos {5, 2, 2, 1, 10}:

g <- c(5, 2, 2, 1, 10)

A função sort(), por exemplo, retorna o vetor g em ordem crescente.

sort(g)

## [1]  1  2  2  5 10

Observe que a ordem crescente é o default (parâmetro padrão) da função sort(). Para retornar o vetor em ordem decrescente, especifique decreasing = TRUE dentro da função:

sort(g, decreasing = TRUE)

## [1] 10  5  2  2  1

Observação: para ver detalhes dos argumentos da função e seus parâmetros, utilize o help:

?sort

A função table() retorna a contagem dos valores do vetor:

table(g)

## g
##  1  2  5 10 
##  1  2  1  1

A função unique() retorna apenas os valores únicos do vetor. Observe que o valor “2” irá aparecer apenas uma vez no caso do vetor g:

unique(g)

## [1]  5  2  1 10

Observação: Se você criar um vetor com a função unique(g), apenas os valores únicos de g serão considerados. Nesse caso, o novo vetor terá um elemento a menos visto que o número “2” aparece duas vezes em g. Faça o teste:

w <- unique(g)

w

## [1]  5  2  1 10

A função order() retorna a posição de cada elemento do vetor em ordem crescente:

order(g)

## [1] 4 2 3 1 5

A função length() retorna o tamanho do vetor:

length(g)

## [1] 5

A função cumsum() retorna a soma cumulativa dos elementos do vetor:

cumsum(g)

## [1]  5  7  9 10 20

A função is.na() retorna TRUE para valores ausentes do vetor e FALSE caso contrário. No caso do vetor g, não temos nenhum valor ausente:

is.na(g)

## [1] FALSE FALSE FALSE FALSE FALSE

Observação: A função is.na() é muito utilizada em manipulação de dados. Certamente você irá usar essa função quando estiver manipulando dados econômicos, socioeconômicos, etc.

Para observar os resultados com a função paste(), crie os 3 vetores abaixo:

dia <- c(01, 14, 30)

mes <- c("jan", "mai", "dez")

ano <- c(1980, 1990, 2020)

Se você usar a função paste() apenas com o vetor dia, o R irá retornar os elementos do vetor em formato de texto:

paste(dia)

## [1] "1"  "14" "30"

Observação: nesse caso, a função paste() é similar a função as.character():

as.character(dia)

## [1] "1"  "14" "30"

Entretanto, se você especificar mais de um vetor na função, o R irá transformar em texto e concatenar os vetores. Por exemplo, crie um vetor data com a função paste() e os três vetores acima (dia, mes e ano) e observe o resultado:

data <- paste(dia, mes, ano)

data

## [1] "1 jan 1980"  "14 mai 1990" "30 dez 2020"

Antes de continuar, remova todos os objetos do Environment:

rm(list = ls())

11. Matrizes

11.1. Criação de matrizes

As matrizes representam um tipo de objeto muito utilizado em programação e manipulação de dados. Para criar matrizes no R, podemos usar a função matrix().

Para conhecer os argumentos da função, use o Help:

?matrix

Uma matriz V 10 x 10 (10 linhas e 10 colunas) com todos os elementos iguais a 1, por exemplo, pode ser criada da seguinte maneira:

V <- matrix(1, ncol = 10, nrow = 10)

Para ver a matriz criada, digite no Console ou clique 2 vezes no objeto no Environment (nesse último caso, uma nova janela será aberta):

V

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

Assim como foi feito com os vetores, é possível combinar a função matrix() com outras funções do R. Por exemplo, para criar uma matriz C 10 x 10 (com 10 linhas e 10 colunas) em que seus elementos sejam dados por uma sequência de 1 a 100, podemos usar a função seq() no argumento data:

C <- matrix(data = seq(1, 100), ncol = 10, nrow = 10)

Repare que, nesse caso, a matriz será preenchida com uma sequência de 1 a 100 pelas colunas:

C

##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]    1   11   21   31   41   51   61   71   81    91
##  [2,]    2   12   22   32   42   52   62   72   82    92
##  [3,]    3   13   23   33   43   53   63   73   83    93
##  [4,]    4   14   24   34   44   54   64   74   84    94
##  [5,]    5   15   25   35   45   55   65   75   85    95
##  [6,]    6   16   26   36   46   56   66   76   86    96
##  [7,]    7   17   27   37   47   57   67   77   87    97
##  [8,]    8   18   28   38   48   58   68   78   88    98
##  [9,]    9   19   29   39   49   59   69   79   89    99
## [10,]   10   20   30   40   50   60   70   80   90   100

Observação: não é necessário escrever “data =” na função. Repare que o resultado do código abaixo será exatamente o mesmo:

C <- matrix(seq(1, 100), ncol = 10, nrow = 10)

C

##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]    1   11   21   31   41   51   61   71   81    91
##  [2,]    2   12   22   32   42   52   62   72   82    92
##  [3,]    3   13   23   33   43   53   63   73   83    93
##  [4,]    4   14   24   34   44   54   64   74   84    94
##  [5,]    5   15   25   35   45   55   65   75   85    95
##  [6,]    6   16   26   36   46   56   66   76   86    96
##  [7,]    7   17   27   37   47   57   67   77   87    97
##  [8,]    8   18   28   38   48   58   68   78   88    98
##  [9,]    9   19   29   39   49   59   69   79   89    99
## [10,]   10   20   30   40   50   60   70   80   90   100

O preenchimento pelas colunas é o default (parâmetro padrão). Se quiser especificar o preenchimento pelas linhas, adicione byrow = TRUE:

L <- matrix(seq(1, 100), ncol = 10, nrow = 10, byrow = TRUE)

Digite L no Console e compare o resultado com o obtido na matriz C:

L

##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]    1    2    3    4    5    6    7    8    9    10
##  [2,]   11   12   13   14   15   16   17   18   19    20
##  [3,]   21   22   23   24   25   26   27   28   29    30
##  [4,]   31   32   33   34   35   36   37   38   39    40
##  [5,]   41   42   43   44   45   46   47   48   49    50
##  [6,]   51   52   53   54   55   56   57   58   59    60
##  [7,]   61   62   63   64   65   66   67   68   69    70
##  [8,]   71   72   73   74   75   76   77   78   79    80
##  [9,]   81   82   83   84   85   86   87   88   89    90
## [10,]   91   92   93   94   95   96   97   98   99   100

Matrizes também podem ser criadas a partir da combinação de vetores. Considere, por exemplo, os vetores c1 e c2:

c1 <- c(-1, 4)
c2 <- c(3, 2)

c1

## [1] -1  4

c2

## [1] 3 2

Com auxílio da função cbind(), podemos combinar os dois vetores da seguinte forma:

X <- cbind(c1, c2)

Repare que a função cbind() combina o vetores pelas colunas. Ou seja, nesse caso, as colunas da matrix X serão dadas pelos vetores c1 e c2:

X

##      c1 c2
## [1,] -1  3
## [2,]  4  2

Alternativamente, podemos criar a matriz X em apenas um passo com auxílio da função c():

X <- cbind(c(-1, 4), c(3, 2))

X

##      [,1] [,2]
## [1,]   -1    3
## [2,]    4    2

Ou

X <- matrix(c(-1, 4, 3, 2), nrow = 2, ncol = 2)

X

##      [,1] [,2]
## [1,]   -1    3
## [2,]    4    2

Observação: tente também usar a função rbind() e compare os resultados. A função rbind() combina os vetores pelas linhas:

X <- rbind(c1, c2)

X

##    [,1] [,2]
## c1   -1    4
## c2    3    2

Além dos exemplos acima, como os vetores, as matrizes também podem armazenar dados no formato de texto. O código abaixo, por exemplo, irá criar uma matriz N 5 x 5 com os textos “NEDUR” e “UFPR”.

Repare que, se usarmos a função sample(), o preenchimento será feito com uma amostra aleatória. Ou seja, toda vez que você executar o comando uma matriz diferente será gerada (o seu resultado não será necessariamente igual ao apresentado abaixo).

N <- matrix(
  sample(c("NEDUR", "UFPR"), 25, replace = TRUE),
  ncol = 5, nrow = 5)

N 

##      [,1]    [,2]    [,3]    [,4]    [,5]   
## [1,] "UFPR"  "UFPR"  "UFPR"  "NEDUR" "NEDUR"
## [2,] "UFPR"  "NEDUR" "NEDUR" "NEDUR" "NEDUR"
## [3,] "UFPR"  "NEDUR" "NEDUR" "NEDUR" "UFPR" 
## [4,] "NEDUR" "UFPR"  "UFPR"  "UFPR"  "UFPR" 
## [5,] "NEDUR" "NEDUR" "UFPR"  "UFPR"  "NEDUR"

Observação: para verificar os argumentos da função sample(), use o help:

?sample

11.2. Indexação de matrizes

As matrizes podem ser manipuladas de forma similar aos vetores. As indexações são feitas utilizando a mesma lógica.

Considere a matriz C criada acima:

C

##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]    1   11   21   31   41   51   61   71   81    91
##  [2,]    2   12   22   32   42   52   62   72   82    92
##  [3,]    3   13   23   33   43   53   63   73   83    93
##  [4,]    4   14   24   34   44   54   64   74   84    94
##  [5,]    5   15   25   35   45   55   65   75   85    95
##  [6,]    6   16   26   36   46   56   66   76   86    96
##  [7,]    7   17   27   37   47   57   67   77   87    97
##  [8,]    8   18   28   38   48   58   68   78   88    98
##  [9,]    9   19   29   39   49   59   69   79   89    99
## [10,]   10   20   30   40   50   60   70   80   90   100

Para selecionar o elemento da primeira linha da segunda coluna, por exemplo, a seguinte indexação pode ser usada:

C[1, 2] 

## [1] 11

A terceira linha da matriz C, por sua vez, pode ser selecionada com:

C[3, ] 

##  [1]  3 13 23 33 43 53 63 73 83 93

As linhas 2 a 4 com:

C[2:4, ] 

##      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
## [1,]    2   12   22   32   42   52   62   72   82    92
## [2,]    3   13   23   33   43   53   63   73   83    93
## [3,]    4   14   24   34   44   54   64   74   84    94

Para selecionar apenas a primeira coluna da matriz C, a seguinte indexação pode ser usada:

C[, 1] 

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

E para selecionar apenas as colunas 1 a 3:

C[, 1:3] 

##       [,1] [,2] [,3]
##  [1,]    1   11   21
##  [2,]    2   12   22
##  [3,]    3   13   23
##  [4,]    4   14   24
##  [5,]    5   15   25
##  [6,]    6   16   26
##  [7,]    7   17   27
##  [8,]    8   18   28
##  [9,]    9   19   29
## [10,]   10   20   30

Para não selecionar elementos específicos, a mesma lógica pode ser aplicada com o uso do sinal de subtração -. Por exemplo, para não selecionar apenas a primeira linha e a primeira coluna de C, a seguinte indexação pode ser usada:

C[-1, -1] 

##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9]
##  [1,]   12   22   32   42   52   62   72   82   92
##  [2,]   13   23   33   43   53   63   73   83   93
##  [3,]   14   24   34   44   54   64   74   84   94
##  [4,]   15   25   35   45   55   65   75   85   95
##  [5,]   16   26   36   46   56   66   76   86   96
##  [6,]   17   27   37   47   57   67   77   87   97
##  [7,]   18   28   38   48   58   68   78   88   98
##  [8,]   19   29   39   49   59   69   79   89   99
##  [9,]   20   30   40   50   60   70   80   90  100

Para não selecionar da segunda a décima coluna de C (ou seja, reportar apenas a primeira coluna):

C[, -c(2:10)] 

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

11.3. Operações com matrizes

Similarmente aos vetores, operações aritméticas e lógicas também são usadas com as matrizes.

Considere novamente a matriz C:

C

##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]    1   11   21   31   41   51   61   71   81    91
##  [2,]    2   12   22   32   42   52   62   72   82    92
##  [3,]    3   13   23   33   43   53   63   73   83    93
##  [4,]    4   14   24   34   44   54   64   74   84    94
##  [5,]    5   15   25   35   45   55   65   75   85    95
##  [6,]    6   16   26   36   46   56   66   76   86    96
##  [7,]    7   17   27   37   47   57   67   77   87    97
##  [8,]    8   18   28   38   48   58   68   78   88    98
##  [9,]    9   19   29   39   49   59   69   79   89    99
## [10,]   10   20   30   40   50   60   70   80   90   100

Multiplicar a matriz C por 10, por exemplo, significa multiplicar cada elemento da matriz por 10:

C * 10

##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]   10  110  210  310  410  510  610  710  810   910
##  [2,]   20  120  220  320  420  520  620  720  820   920
##  [3,]   30  130  230  330  430  530  630  730  830   930
##  [4,]   40  140  240  340  440  540  640  740  840   940
##  [5,]   50  150  250  350  450  550  650  750  850   950
##  [6,]   60  160  260  360  460  560  660  760  860   960
##  [7,]   70  170  270  370  470  570  670  770  870   970
##  [8,]   80  180  280  380  480  580  680  780  880   980
##  [9,]   90  190  290  390  490  590  690  790  890   990
## [10,]  100  200  300  400  500  600  700  800  900  1000

Similarmente, dividir C por 10 significa dividir cada elemento por 10:

C / 10

##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]  0.1  1.1  2.1  3.1  4.1  5.1  6.1  7.1  8.1   9.1
##  [2,]  0.2  1.2  2.2  3.2  4.2  5.2  6.2  7.2  8.2   9.2
##  [3,]  0.3  1.3  2.3  3.3  4.3  5.3  6.3  7.3  8.3   9.3
##  [4,]  0.4  1.4  2.4  3.4  4.4  5.4  6.4  7.4  8.4   9.4
##  [5,]  0.5  1.5  2.5  3.5  4.5  5.5  6.5  7.5  8.5   9.5
##  [6,]  0.6  1.6  2.6  3.6  4.6  5.6  6.6  7.6  8.6   9.6
##  [7,]  0.7  1.7  2.7  3.7  4.7  5.7  6.7  7.7  8.7   9.7
##  [8,]  0.8  1.8  2.8  3.8  4.8  5.8  6.8  7.8  8.8   9.8
##  [9,]  0.9  1.9  2.9  3.9  4.9  5.9  6.9  7.9  8.9   9.9
## [10,]  1.0  2.0  3.0  4.0  5.0  6.0  7.0  8.0  9.0  10.0

Faça o teste também com C + 10 e C - 10:

C + 10

##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]   11   21   31   41   51   61   71   81   91   101
##  [2,]   12   22   32   42   52   62   72   82   92   102
##  [3,]   13   23   33   43   53   63   73   83   93   103
##  [4,]   14   24   34   44   54   64   74   84   94   104
##  [5,]   15   25   35   45   55   65   75   85   95   105
##  [6,]   16   26   36   46   56   66   76   86   96   106
##  [7,]   17   27   37   47   57   67   77   87   97   107
##  [8,]   18   28   38   48   58   68   78   88   98   108
##  [9,]   19   29   39   49   59   69   79   89   99   109
## [10,]   20   30   40   50   60   70   80   90  100   110

C - 10

##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]   -9    1   11   21   31   41   51   61   71    81
##  [2,]   -8    2   12   22   32   42   52   62   72    82
##  [3,]   -7    3   13   23   33   43   53   63   73    83
##  [4,]   -6    4   14   24   34   44   54   64   74    84
##  [5,]   -5    5   15   25   35   45   55   65   75    85
##  [6,]   -4    6   16   26   36   46   56   66   76    86
##  [7,]   -3    7   17   27   37   47   57   67   77    87
##  [8,]   -2    8   18   28   38   48   58   68   78    88
##  [9,]   -1    9   19   29   39   49   59   69   79    89
## [10,]    0   10   20   30   40   50   60   70   80    90

Além disso, operações lógicas também podem ser usadas com as matrizes. O resultado será TRUE (verdadeiro) ou FALSE (falso), conforme condição utilizada:

C >= 50

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

Para reportar os elementos da matriz baseado em uma condição específica, o seguinte código pode ser usado:

C[C >= 50]

##  [1]  50  51  52  53  54  55  56  57  58  59  60  61  62  63  64  65  66  67  68
## [20]  69  70  71  72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87
## [39]  88  89  90  91  92  93  94  95  96  97  98  99 100

11.4. Outras funções

As funções matemáticas e estatísticas também podem ser usadas com as matrizes. As funções sum(), mean(), sd() e range() irão retornar a soma, média, desvio padrão, mínimo e máximo da matriz, respectivamente. Veja os exemplos abaixo com a matriz C:

sum(C)

## [1] 5050

mean(C)

## [1] 50.5

sd(C)

## [1] 29.01149

range(C)

## [1]   1 100

Além das funções acima, outras também estão disponíveis no R:

Função	Descrição
t()	Retorna a matriz transposta
diag(n)	Cria uma matriz identidade n x n
det()	Calcula o determinante da matriz
diag()	Retorna os elementos da diagonal principal
dim()	Retorna a dimensão da matriz
ncol()	Retorna o número de colunas da matriz
nrow()	Retorna o número de linhas da matriz
rowSums()	Retorna a soma das linhas da matriz
rowMeans()	Retorna a média das linhas da matriz
colSums()	Retorna a soma das colunas da matriz
colMeans()	Retorna a média das colunas da matriz
summary()	Retorna o sumário de cada coluna da matriz

A matriz transposta de C pode ser obtida com:

t(C)

##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]    1    2    3    4    5    6    7    8    9    10
##  [2,]   11   12   13   14   15   16   17   18   19    20
##  [3,]   21   22   23   24   25   26   27   28   29    30
##  [4,]   31   32   33   34   35   36   37   38   39    40
##  [5,]   41   42   43   44   45   46   47   48   49    50
##  [6,]   51   52   53   54   55   56   57   58   59    60
##  [7,]   61   62   63   64   65   66   67   68   69    70
##  [8,]   71   72   73   74   75   76   77   78   79    80
##  [9,]   81   82   83   84   85   86   87   88   89    90
## [10,]   91   92   93   94   95   96   97   98   99   100

A soma das linhas pode ser obtida com a função rowSums(). Lembre-se que o R diferencia letras maiúsculas e minúsculas. Logo, se você tentar usar “rowsums()”, a seguinte menssagem irá aparecer no Console:

Error in rowsums(C) : could not find function “rowsums”.

Utilize a função conforme abaixo:

rowSums(C)

##  [1] 460 470 480 490 500 510 520 530 540 550

Para obter a média das linhas, utilize a função rowMeans():

rowMeans(C)

##  [1] 46 47 48 49 50 51 52 53 54 55

Similarmente, podemos encontrar a soma e média das colunas com:

colSums(C)

##  [1]  55 155 255 355 455 555 655 755 855 955

colMeans(C)

##  [1]  5.5 15.5 25.5 35.5 45.5 55.5 65.5 75.5 85.5 95.5

A função summary() com uma matriz irá retornar o sumário de cada uma das colunas:

summary(C)

##        V1              V2              V3              V4       
##  Min.   : 1.00   Min.   :11.00   Min.   :21.00   Min.   :31.00  
##  1st Qu.: 3.25   1st Qu.:13.25   1st Qu.:23.25   1st Qu.:33.25  
##  Median : 5.50   Median :15.50   Median :25.50   Median :35.50  
##  Mean   : 5.50   Mean   :15.50   Mean   :25.50   Mean   :35.50  
##  3rd Qu.: 7.75   3rd Qu.:17.75   3rd Qu.:27.75   3rd Qu.:37.75  
##  Max.   :10.00   Max.   :20.00   Max.   :30.00   Max.   :40.00  
##        V5              V6              V7              V8       
##  Min.   :41.00   Min.   :51.00   Min.   :61.00   Min.   :71.00  
##  1st Qu.:43.25   1st Qu.:53.25   1st Qu.:63.25   1st Qu.:73.25  
##  Median :45.50   Median :55.50   Median :65.50   Median :75.50  
##  Mean   :45.50   Mean   :55.50   Mean   :65.50   Mean   :75.50  
##  3rd Qu.:47.75   3rd Qu.:57.75   3rd Qu.:67.75   3rd Qu.:77.75  
##  Max.   :50.00   Max.   :60.00   Max.   :70.00   Max.   :80.00  
##        V9             V10        
##  Min.   :81.00   Min.   : 91.00  
##  1st Qu.:83.25   1st Qu.: 93.25  
##  Median :85.50   Median : 95.50  
##  Mean   :85.50   Mean   : 95.50  
##  3rd Qu.:87.75   3rd Qu.: 97.75  
##  Max.   :90.00   Max.   :100.00

Antes de continuar, remova todos os objetos do Environment:

rm(list = ls())

Operações matemáticas como soma, subtração, divisão e multiplicação entre matrizes também podem ser realizadas no R. Para tal, crie duas matrizes:

Uma matriz X:

X <- cbind(c(-1, 4), c(3, 2))

X

##      [,1] [,2]
## [1,]   -1    3
## [2,]    4    2

E uma matriz Y:

Y <- cbind(c(1, 3), c(2, 4))

Y

##      [,1] [,2]
## [1,]    1    2
## [2,]    3    4

A soma das duas matrizes é dada por:

X + Y

##      [,1] [,2]
## [1,]    0    5
## [2,]    7    6

A subtração por:

X - Y

##      [,1] [,2]
## [1,]   -2    1
## [2,]    1   -2

A divisão por:

X / Y

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

E a multiplicação por:

X %*% Y

##      [,1] [,2]
## [1,]    8   10
## [2,]   10   16

ATENÇÃO! se você usar apenas *, o resultado será diferente. Nesse caso, o R faz o produto dos elementos:

X * Y

##      [,1] [,2]
## [1,]   -1    6
## [2,]   12    8

Para criar uma matriz identidade I 2 x 2, a seguinte função pode ser utilizada:

I <- diag(2)

I

##      [,1] [,2]
## [1,]    1    0
## [2,]    0    1

A inversa de uma matriz, por sua vez, pode ser obtida com a função solve():

solve(Y)

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

Antes de avançar, remova novamente todos os objetos do Environment:

rm(list = ls())

12. Data frames e tibbles

12.1. Definição

Data frame é um objeto muito semelhante às matrizes. Em síntese, uma data frame consiste em uma tabela de dados capaz de armazenar diferentes classes de dados nas suas colunas.

Para ver um exemplo de data frame, podemos usar os dados do livro Introdução à Econometria: uma abordagem moderna de autoria de Jeffrey M. Wooldridge.

Para tal, instale o pacote wooldridge com a função install.packages():

install.packages("wooldridge")

Após a instalação do pacote, faça leitura do mesmo com a função library():

library(wooldridge)

O pacote wooldridge contém vários dados. Como exemplo, faça leitura da base de dados wage1 com a função data():

data("wage1")

Observe que a base de dados estará disponível no Environment do seu RStudio. Entretanto, para observar a estrutura dos dados use a função str():

str(wage1)

## 'data.frame':    526 obs. of  24 variables:
##  $ wage    : num  3.1 3.24 3 6 5.3 ...
##  $ educ    : int  11 12 11 8 12 16 18 12 12 17 ...
##  $ exper   : int  2 22 2 44 7 9 15 5 26 22 ...
##  $ tenure  : int  0 2 0 28 2 8 7 3 4 21 ...
##  $ nonwhite: int  0 0 0 0 0 0 0 0 0 0 ...
##  $ female  : int  1 1 0 0 0 0 0 1 1 0 ...
##  $ married : int  0 1 0 1 1 1 0 0 0 1 ...
##  $ numdep  : int  2 3 2 0 1 0 0 0 2 0 ...
##  $ smsa    : int  1 1 0 1 0 1 1 1 1 1 ...
##  $ northcen: int  0 0 0 0 0 0 0 0 0 0 ...
##  $ south   : int  0 0 0 0 0 0 0 0 0 0 ...
##  $ west    : int  1 1 1 1 1 1 1 1 1 1 ...
##  $ construc: int  0 0 0 0 0 0 0 0 0 0 ...
##  $ ndurman : int  0 0 0 0 0 0 0 0 0 0 ...
##  $ trcommpu: int  0 0 0 0 0 0 0 0 0 0 ...
##  $ trade   : int  0 0 1 0 0 0 1 0 1 0 ...
##  $ services: int  0 1 0 0 0 0 0 0 0 0 ...
##  $ profserv: int  0 0 0 0 0 1 0 0 0 0 ...
##  $ profocc : int  0 0 0 0 0 1 1 1 1 1 ...
##  $ clerocc : int  0 0 0 1 0 0 0 0 0 0 ...
##  $ servocc : int  0 1 0 0 0 0 0 0 0 0 ...
##  $ lwage   : num  1.13 1.18 1.1 1.79 1.67 ...
##  $ expersq : int  4 484 4 1936 49 81 225 25 676 484 ...
##  $ tenursq : int  0 4 0 784 4 64 49 9 16 441 ...
##  - attr(*, "time.stamp")= chr "25 Jun 2011 23:03"

Com a função str(), a estrutura da base de dados wage1 será impressa no Console e a base ficará disponível no Environment. Observe que a base de dados conta com 24 variáveis e 526 observações.

Entretanto, antes de explorar a base de dados, verifique a classe do objeto com a função class(). No caso, a função retornará “data.frame”:

class(wage1)

## [1] "data.frame"

Para ver uma descrição da base de dados, como formato e variáveis disponíveis, use o help:

?wage1

Além disso, use a função View() para explorar a data frame com os dados:

View(wage1)

Observação: duas funções novas foram apresentadas durante a leitura dos dados acima. Para ver os argumentos e os detalhes de cada uma delas, use o help:

?data

?str

Além do objeto data frame, o R conta com o objeto do tipo tibble. O tibble é muito semelhante a data frame, entretanto, uma forma mais moderna. As duas principais diferenças consistem na forma de impressão e indexação.

Para ver a diferença em termos de impressão, você pode testar digitar no Console um objeto no formato data frame e depois no formato tibble.

Por exemplo, se você digitar wage1 - um objeto no formato data.frame - no Console do seu RStudio, um grande volume de informações será impresso. Faça o teste:

wage1

Entretanto, se você converter a base de dados em tibble, a impressão no Console irá incluir o tipo de cada coluna e irá apresentar apenas as dez primeiras linhas e as colunas que cabem na tela.

Para transformar a data frame wage1 em tibble, use o pacote tibble da família tidyverse. Para tal, instale o pacote com a função install.packages():

install.packages("tibble")

Observação: se você já instalou o pacote tidyverse, você pode apenas fazer a leitura do pacote tibble com a função library().

Após a instalação do pacote, faça a sua leitura com a função library():

library(tibble)

Para transformar a base de dados wage1 em tibble, use a função as_tibble(). Entretanto, especifique outro nome para não substituir o objeto original (por exemplo: wage1tib):

wage1tib <- as_tibble(wage1)

Confira a classe do objeto com a função class:

class(wage1tib)

## [1] "tbl_df"     "tbl"        "data.frame"

Além disso, use a função View() para explorar a tibble com os dados e observar que a base de dados é idêntica:

View(wage1tib)

Por fim, digite wage1tib - um objeto no formato tibble - no Console e compare com o resultado anterior:

wage1tib

## # A tibble: 526 x 24
##     wage  educ exper tenure nonwhite female married numdep  smsa northcen south
##    <dbl> <int> <int>  <int>    <int>  <int>   <int>  <int> <int>    <int> <int>
##  1  3.10    11     2      0        0      1       0      2     1        0     0
##  2  3.24    12    22      2        0      1       1      3     1        0     0
##  3  3       11     2      0        0      0       0      2     0        0     0
##  4  6        8    44     28        0      0       1      0     1        0     0
##  5  5.30    12     7      2        0      0       1      1     0        0     0
##  6  8.75    16     9      8        0      0       1      0     1        0     0
##  7 11.2     18    15      7        0      0       0      0     1        0     0
##  8  5       12     5      3        0      1       0      0     1        0     0
##  9  3.60    12    26      4        0      1       0      2     1        0     0
## 10 18.2     17    22     21        0      0       1      0     1        0     0
## # ... with 516 more rows, and 13 more variables: west <int>, construc <int>,
## #   ndurman <int>, trcommpu <int>, trade <int>, services <int>, profserv <int>,
## #   profocc <int>, clerocc <int>, servocc <int>, lwage <dbl>, expersq <int>,
## #   tenursq <int>

12.2. Manipulando data frames

A manipulação de data frames é muito similar ao que foi feito com as matrizes.

Por exemplo, para selecionar a segunda linha da terceira coluna da data frame wage1, podemos usar:

wage1[2, 3]

## [1] 22

Para selecionar somente as colunas “wage” e “educ” pelo nome, podemos usar:

wage1[, c("wage", "educ")]

Podemos selecionar uma variável também com auxílio do $. Por exemplo, para selecionar apenas a variável educ da data frame, podemos usar a seguinte sintaxe:

wage1$educ

Algumas funções, exploradas anteriormente, funcionam similarmente com o objeto data frame:

Função	Descrição
ncol	Retorna o número de colunas da data frame
nrow()	Retorna o número de linhas da data frame
rowSums()	Retorna a soma das linhas da data frame
rowMeans()	Retorna a média das linhas da data frame
colSums()	Retorna a soma das colunas da data frame
colMeans()	Retorna a média das colunas da data frame
summary()	Retorna o sumário de cada coluna da data frame

Lembre-se apenas que algumas colunas da data frame podem ser não numéricas.

Outras três funções são muito usadas quando estamos trabalhando com tabelas de dados grandes: subset(), head() e tail().

A função subset() cria um subconjunto baseado em um critério:

subset(wage1, wage > 10)

A função head() mostra as seis primeiras observações:

head(wage1)

E a tail() mostra as seis últimas observações:

tail(wage1)

Utilize o help para conhecer os argumentos e os detalhes dessas três funções:

?subset

?head

?tail

12.3. Transformando variáveis

Além das operações acima, as variáveis de uma tabela de dados podem ser transformadas com auxílio dos operadores aritméticos e lógicos, funções matemáticas, etc.

Por exemplo, podemos criar uma nova variável wage2x que seja 2 vezes a variável wage:

wage1$wage2x <- wage1$wage * 2

Observe que a nova variável wage2x estará disponível na base de dados wage1 como uma nova coluna (última coluna da tabela):

View(wage1)

Você pode utilizar outras operações para transformar as variáveis. Pratique o que você aprendeu nas seções anteriores!

Antes de avançar, remova todos os objetos do Environment:

rm(list = ls())

13. Importação de dados

Para importar dados para o R, podemos utilizar diferentes pacotes e funções. A escolha depende do formato dos dados. Entre os principais formatos, trabalhamos, geralmente, com arquivos em CSV, XLS, XLSX, TXT, TSV, RData, RDS, DTA, entre outros.

Entre os principais pacotes para lidar com esses formatos, podemos citar:

• readr - Read Rectangular Text Data
• data.table - Extension of data.frame
• readxl - Read Excel Files
• xlsx - Read, Write, Format Excel
• openxlsx - Read, Write and Edit xlsx Files

Além disso, o próprio R base possui algumas funções para fazer a leitura dos principais formatos.

Observação: Alguns pacotes possuem funções com o mesmo nome. Entretanto, seus argumentos são geralmente diferentes. Para evitar problemas, faça a leitura apenas dos pacotes que você irá usar e tire suas dúvidas com help. Alguns exemplos serão apresentados abaixo.

13.1. Arquivos CSV

O pacote readr é muito utilizado para ler dados no formato CSV. Para uma visão completa do pacote, veja a Data Import :: Cheat Sheet ou acesse readr.tidyverse.org.

Para instalar o pacote readr, utilize a função install.packages():

install.packages("readr")

Após a instalação do pacote, faça sua leitura com a função library():

library(readr)

Como exemplo, vamos usar a Base de Dados do Comércio Exterior Brasileiro (Comex Stat) disponibilizados pelo Governo Federal (Ministério da Economia) em www.gov.br.

Nos exemplos abaixo, vamos usar a base de dados de Exportações detalhada por NCM para o ano 2019.

Observação: os dados também estão disponíveis AQUI em zip. Extraia os dados na sua pasta “setada”!

O arquivo CSV disponibilizado no Comex Stat utiliza separador ponto e vírgula (;) e apresenta o seguinte detalhamento:

• Ano
• Mês
• Código NCM
• Código da unidade estatística
• Código de país de destino/origem do produto
• Código da UF de origem/destino do produto
• Código da via de transporte
• Código da URF de embarque/desembarque
• Quantidade estatística
• Quilograma líquido
• Valor dólar FOB (US$)

Para importar os dados para o R, podemos usar a função read_csv2 do pacote readr. Para tal, especifique um objeto dexp (dados de exportações) da seguinte forma:

dexp <- read_csv2("EXP_2019.csv")

Observe que o objeto dexp estará disponível no Environment. No caso, os dados contam com 1416883 observações e 11 variáveis.

ATENÇÃO! Vamos trabalhar com essa base de dados na Seção 14 - Manipulação de dados. Portanto, mantenha ela no seu Environment.

Observação: Para verificar os argumentos da função read_csv2() use o help:

?read_csv2

O pacote readr também conta com a função read_csv(). A principal diferença entre as duas funções consiste no separador usado. A função read_csv2() utiliza CSV com separador ponto e vírgula (;) enquanto a função read_csv() utiliza CSV com separador vírgula (,). Confira sempre o separador da sua base de dados antes de usar.

No caso da base de dados do Comex Stat, conforme detalhado acima, os arquivos CSV utilizam o separador ponto e vírgula (;) como padrão.

13.2. Arquivos XLS e XLSX

Assim como o caso do CSV, existem diversos pacotes no R para ler os dados XLS e XLSX, como o readxl, xlsx e openxls.

Como exemplo, faça o download do arquivo EXP2019_ComexStat AQUI.

ATENÇÃO! Após fazer o download, salve o arquivo XLSX na sua pasta “setada”.

Para instalar o pacote readxl, utilize a função install.packages():

install.packages("readxl")

Após a instalação do pacote, faça sua leitura com a função library():

library(readxl)

Para importar os dados para o R, podemos usar a função read_excel. Para tal, especifique um objeto dados com:

dados <- read_excel("EXP2019_ComexStat.xlsx")

Observe que o objeto dados estará disponível no Environment. No caso, os dados contam com 28 observações e 3 variáveis.

Observação: Outros pacotes e funções podem ser usados. Por exemplo:

‣ Pacote xlsx:

install.packages("xlsx")

library(xlsx)

Para ler os dados com o pacote xlsx, use a função read.xlsx():

dados <- read.xlsx(file = "EXP2019_ComexStat.xlsx", sheetName = "2019")

ATENÇÃO: O pacote xlsx pode apresentar problemas com o Java. Se esse for o caso, tente instalar a última versão do Java ou use outro pacote.

‣ Pacote openxlsx:

install.packages("openxlsx")

library(openxlsx)

Para ler os dados com o pacote openxlsx, podemos usar a função read.xlsx(). Observe que o nome da função é o mesmo que no exemplo acima (com o pacote xlsx), entretanto, os argumentos são diferentes (no pacote xlsx usamos “file” e “sheetName” e aqui “xlsxFile” e “sheet”):

dados <- read.xlsx(xlsxFile = "EXP2019_ComexStat.xlsx", sheet = "2019")

ATENÇÃO! Se você tiver feito a leitura dos dois pacotes, provavelmente um erro como Error in read.xlsx() : unused argument () foi reportado. Isso ocorre justamente pelo fato de os dois pacotes usarem o mesmo nome de função com argumentos diferentes. Nesse caso, você pode especificar o pacote exato com o seu nome seguido de duplo dois pontos antes da função:

dados <- xlsx::read.xlsx(file = "EXP2019_ComexStat.xlsx", sheetName = "2019")

dados <- openxlsx::read.xlsx(xlsxFile = "EXP2019_ComexStat.xlsx", sheet = "2019")

Antes de avançar, remova todos objetos do Environment, EXCETO o objeto dexp. Para remover todos objetos exceto dexp, use o seguinte comando:

rm(list = ls()[!ls() %in% c("dexp")])

14. Manipulação de dados

Conforme destacado acima, a base de dados de exportações conta com muitas observações e variáveis. Vamos usar os pacotes dplyr e tidyr para manipular os dados, como selecionar, criar e renomear variáveis, filtrar observações, entre outras.

Para instalar os pacotes dplyr e tidyr (se você não fez isso anteriormente), utilize a função install.packages():

install.packages("dplyr")

install.packages("tidyr")

Observação: Se você já instalou o pacote tidyverse ou o dplyr e o tidyr no início, você pode apenas fazer a leitura dos pacotes com a função library().

Após a instalação dos pacotes, faça a leitura deles com a função library():

library(dplyr)

library(tidyr)

Para iniciar, abra a base de dados dexp importada na seção anterior e observe os nomes das colunas (variáveis).

Alternativamente, confira os nomes das colunas com a função names():

names(dexp)

##  [1] "CO_ANO"     "CO_MES"     "CO_NCM"     "CO_UNID"    "CO_PAIS"   
##  [6] "SG_UF_NCM"  "CO_VIA"     "CO_URF"     "QT_ESTAT"   "KG_LIQUIDO"
## [11] "VL_FOB"

ATENÇÃO! Se você não tiver feito a leitura da base de dados, volte na seção 13.1.

Com dexp disponível no Environment, podemos manipular a base de dados com algumas funções básicas dos dois pacotes.

Antes:

• Para uma visão completa do pacote dplyr veja a Data Transformation with dplyr :: Cheat Sheet ou acesse dplyr.tidyverse.org.

• Para uma visão completa do pacote tidyr veja a Data Import :: Cheat Sheet ou acesse tidyr.tidyverse.org.

Após explorar as principais informações dos pacotes, podemos usar eles para:

‣ Selecionar variáveis:

Para selecionar apenas algumas variáveis, podemos utilizar a função select() do pacote dplyr.

Por exemplo, um novo objeto dexp_mod pode ser especificado a partir da seleção de algumas variáveis da base original, como Ano (“CO_ANO”), Mês (“CO_MES”), UF (“SG_UF_NCM”) e Valor FOB (“VL_FOB”):

dexp_mod <- select(dexp, c("CO_ANO", "CO_MES", "SG_UF_NCM", "VL_FOB"))

Observe que a nova base de dados estará disponível no Environment com apenas as 4 variáveis especificadas no código acima.

‣ Renomear variáveis:

Para renomear as variáveis, podemos usar a função rename().

Por exemplo, para renomear “CO_ANO” como “ano”, “CO_MES” como “mes”, “SG_UF_NCM” como “uf” e “VL_FOB” como “exp” na base de dados dexp_mod, o seguinte código pode ser usado:

dexp_mod <- rename(
  dexp_mod,
  ano = CO_ANO,
  mes = CO_MES,
  uf  = SG_UF_NCM,
  exp = VL_FOB
  )

Observe que a nova base de dados no código acima tem o mesmo nome que a anterior. Portanto, o R substitui a base de dados. Se você abrir o objeto dexp_mod, as variáveis estarão com os novos nomes.

‣ Modificar dados:

Para criar uma nova variável, podemos utilizar a função mutate().

Por exemplo, podemos criar uma variável que seja o log do valor das exportações com o seguinte código:

dexp_mod <- mutate(dexp_mod, log_exp = log(exp))

Observe que uma nova coluna com os dados em log estará disponível na base de dados.

Além disso, podemos transformar o valor US$ FOB das exportações em bilhões com a divisão:

dexp_mod <- mutate(dexp_mod, exp = exp / 1000000000)

‣ Agrupar e Agregar dados:

Para agrupar a base de dados, podemos utilizar as funções group_by() e summarise() do pacote dplyr.

Primeiro, especificamos os grupos de interesse (ano e uf, por exemplo):

dexp_mod <- group_by(dexp_mod, ano, uf)

Repare que nenhuma alteração foi feita na base de dados. Apenas especificamos o agrupamento de interesse dos dados.

Os dados serão agregados com a função summarise() e funções matemáticas.

Por exemplo, depois de especificar o agrupamento, podemos utilizar a função summarise() para sumarizar os dados com base na função soma, sum().

Com o comando abaixo, as exportações (exp) serão somadas preservando o agrupamento especificado acima:

dexp_mod <- summarise(dexp_mod, exp = sum(exp))

Observe que o número de linhas diminui. Agora, temos as exportações por UF e ano e não mais por mês. Ou seja, os dados foram agregados somando as exportações por mês.

Além disso, observe também que a variável log_exp não estará mais disponível uma vez que não especificamos ela em nenhuma das duas funções - group_by() e summarise().

‣ Filtrar observações:

Para filtrar as observações, podemos usar a função filter().

Por exemplo, para filtrar apenas as exportações do Paraná (PR), o operador lógico == (“exatamente igual que”) pode ser usado. Especifique uma nova base de dados dexp_pr com o seguinte comando:

dexp_pr <- filter(dexp_mod, uf == "PR")

Observe que a base de dados dexp_pr contará apenas com as exportações do Paraná em 2019.

Além das funções acima, o pacote dplyr possui um operador “pipe” que facilita a manipulação e transformação dos dados:

‣ Operações com pipes (%>%):

Todas as operações acima podem ser realizadas em um único passo com auxílio do “pipe”. O pipe, ou como usado no código %>%, é um operador utilizado para facilitar a execução dos comandos. Basicamente, ele usa o valor resultante da expressão anterior (lado esquerdo) como primeiro argumento da função do lado direito.

Por exemplo:

Com os pipes %>%, lemos o código abaixo da seguinte maneira:

1. Crie um objeto dexp_mod2 que seja igual a dexp
2. Com o resultado de 1, selecione as variáveis “CO_ANO”, “CO_MES”, “SG_UF_NCM” e “VL_FOB”
3. Com o resultado de 2, renomeie “CO_ANO” como ano, “CO_MES” como mes, “SG_UF_NCM” como uf e “VL_FOB” como exp
4. Com a base de dados resultante de 3, crie uma nova variável log_exp que seja o log de exp
5. Com a base de dados resultante de 4, divida o valor de exp por 1 bilhão
6. Com a base de dados resultante de 5, agrupe os dados em ano e uf
7. Com o resultado de 6, agregue os dados somando as exportações com base no agrupamento especificado em 6

dexp_mod2 <- dexp %>% select("CO_ANO", "CO_MES", "SG_UF_NCM", "VL_FOB") %>%
  rename(ano = CO_ANO,
         mes = CO_MES,
         uf  = SG_UF_NCM,
         exp = VL_FOB) %>%
  mutate(log_exp = log(exp)) %>%
  mutate(exp = exp / 1000000000) %>% 
  group_by(ano, uf) %>%
  summarise(exp = sum(exp))

Observe que o resultado, dexp_mod2, é exatamente igual ao obtido anteriormente em dexp_mod. Ou seja, o “pipe” facilita o processo de transformação dos dados.

Para a base do Paraná, podemos acrescentar a função filter:

dexp_pr2 <- dexp %>% select("CO_ANO", "CO_MES", "SG_UF_NCM", "VL_FOB") %>%
  rename(ano = CO_ANO,
         mes = CO_MES,
         uf  = SG_UF_NCM,
         exp = VL_FOB) %>%
  mutate(exp = exp / 1000000000) %>% 
  group_by(ano, uf) %>%
  summarise(exp = sum(exp)) %>% 
  filter(uf == "PR")

Observe que dexp_pr2 é exatamente igual a dexp_pr.

Observação: O operador “pipe” %>% pode ser acrescentado com Ctrl + Shift + M.

15. Exportação de dados

Para exportar dados do R, podemos utilizar diferentes pacotes e funções. A escolha do pacote nesse caso também depende do formato dos dados.

Entre os principais pacotes, podemos citar o readr, xlsx e openxlsx.

15.1. Dados em CSV

Para exportar a base de dados dexp_mod, podemos usar, por exemplo, a função write_csv() do pacote readr:

library(readr)

write_csv(dexp_mod, "Exp_UF_2019v.csv")

Observe que a base de dados foi salva na sua pasta “setada”. Se você abrir o arquivo CSV, irá observar que os dados estão separados por vírgula. A função write_csv() utiliza vírgula (,) como separador padrão.

Para mudar o separador para ponto e vírgula (;), podemos usar a função write_csv2():

write_csv2(dexp_mod, "Exp_UF_2019pv.csv")

Ou usar a função write_delim() especificado o separador desejado no argumento “delim”:

write_delim(dexp_mod, "Exp_UF_2019.csv", delim = ";")

Observação: Lembre-se, você pode tirar suas dúvidas sobre as funções no Help:

?write_csv

?write_csv2

?write_delim

15.2. Dados em XLS e XLSX

Podemos também exportar os dados no formato XLS ou XLSX. Os pacotes openxlsx e xlsx, usados para importar os dados, podem ser usados nesse caso.

O pacote xlsx pode aprensentar problemas com o Java. Portanto, tente usar o openxlsx primeiro:

library(openxlsx)

write.xlsx(dexp_mod, file = "Exp_UF_2019.xlsx", sheetName = "2019")

Similarmente, com pacote xlsx:

library(xlsx)

write.xlsx(dexp_mod, file = "Exp_UF_2019.xlsx", sheetName = "2019")

Observação: Outros pacotes também estão disponíveis, como o writexl e WriteXLS. Você pode procurar informações sobre eles no CRAN Packages.

15.3. Salvar objetos do R

Além dos formatos acima, podemos salvar os objetos do R no formato RDS e RData.

Para salvar um único objeto (dexp_mod, por exemplo), o formato RDS pode ser usado. Para tal, podemos usar a função saveRDS():

saveRDS(dexp_mod, file = "Exp_UF_2019.rds")

Observe que o arquivo estará na sua pastada “setada”. Para ler o objeto, você pode usar a função “readRDS()”. Especifique outro nome para não substituir o objeto original:

dexp_mod2 <- readRDS(file = "Exp_UF_2019.rds")

O formato RData, por sua vez, permite salvar um ou mais objetos. Por exemplo, podemos salvar os objetos dexp, dexp_mod e dexp_pr no mesmo arquivo RData com a função save():

save(dexp, dexp_mod, dexp_pr, file = "Exp.RData")

Observe que a base de dados estará disponível na sua pasta “setada”. Para verificar e testar a importação do arquivo, remova todos objetos do Environment e faça a importação com a função load():

rm(list = ls())

load("Exp.RData")

ATENÇÃO! Vamos trabalhar com essa base nas duas próximas seções. Portanto, mantenha ela no seu Environment e deixe o arquivo Exp.RData na sua pasta. Você poderá usar ele como backup.

16. Gráficos

O R também apresenta vários pacotes e ferramentas de visualização.

Para criar gráficos, vamos utilizar o pacote ggplot2. Se você já instalou o pacote no início, apenas faça a leitura dele com a função library():

library(ggplot2)

Observação: Caso não tenha instalado, use a função install.packages():

install.packages("ggplot2")

Para uma visão completa do pacote ggplot veja a Data Visualization with ggplot2 :: Cheat Sheet ou acesse ggplot2.tidyverse.org.

Se você fechou a base de dados, volte na seção 13 e 14. Ou, se você tiver salvado os objetos em RData, importe eles com a função load():

load("Exp.RData")

A criação de um gráfico com o ggplot2 é feita por camada. Por exemplo, podemos criar um gráfico de barras com as exportações por UF da seguinte forma:

• Na primeira camada, definimos a base do gráfico com a função ggplot(). Nessa camada, especificamos a base de dados com data = dexp_mod e as variáveis de interesse com aes(uf, exp);
• Na segunda camada, especificamos a geometria desejada. Escolhemos o gráfico de barras com a função geom_col() e determinamos que as barras sejam preenchidas com a cor azul com fill = "blue".

ggplot(data = dexp_mod, aes(uf, exp)) +
  geom_col (fill = "blue")

Observação: ND significa UF Não Declarada (região não declarada).

Podemos melhorar o gráfico modificando o nome dos eixos, inserindo e centralizando o título e subtítulo. Conforme lógica anterior, isso é feito inserindo novas camadas:

• O nome dos eixos pode ser inserido com as funções xlab() e ylab();
• O título do gráfico pode ser inserido com a função ggtitle();
• O subtítulo do gráfico pode ser inserido com a função labs() e argumento “subtitle”;
• O título e subtítulo podem ser centralizados com a função theme(), argumento “plot.title” e “plot.subtitle”.

ggplot(data = dexp_mod, aes(uf, exp)) +
  geom_col (fill = "blue") +
  xlab("Unidades da Federação") +
  ylab("Valor FOB em bilhões US$") +
  ggtitle("Exportações") +
  labs(subtitle = "2019") +
  theme(plot.title = element_text(hjust = 0.5)) +
  theme(plot.subtitle = element_text(hjust = 0.5))

Observação: Se você quiser usar o fundo branco, adicione theme_minimal() ao seu comando. Faça o teste com:

ggplot(data = dexp_mod, aes(uf, exp)) +
  geom_col (fill = "blue") +
  theme_minimal() +
  xlab("Unidades da Federação") +
  ylab("Valor FOB em bilhões US$") +
  ggtitle("Exportações") +
  labs(subtitle = "2019") +
  theme(plot.title = element_text(hjust = 0.5)) +
  theme(plot.subtitle = element_text(hjust = 0.5))

Dica: Para explorar outros gráficos com o ggplot2 veja:

WICKHAM, H. ggplot2: elegant graphics for data analysis. Springer, 2016.

17. Mapas

O R também permite criar mapas com dados espaciais. Para acessar os shapefiles do IBGE e de outras fontes oficiais, podemos usar o pacote geobr. O pacote apresenta shapefiles para várias unidades espaciais (estados, microrregiões, entre outras).

Para mais detalhes e outros exemplos, acesse geobr.

Infelizmente, o pacote geobr foi removido do CRAN. Portanto, se você tentar instalar o pacote com a função install.packages() o seguinte erro será apresentado no console: “Warning in install.packages: package ‘geobr’ is not available for this version of R”.

Uma alternativa é instalar o pacote diretamente via github. Para tal, instale o pacote devtools com a função install.packages():

install.packages("devtools")

Depois, utilize o seguinte comando para instalar o pacote geobr:

devtools::install_github("ipeaGIT/geobr", subdir = "r-package")

Após a instalação do pacote, faça sua leitura com a função library():

library(geobr)

Além do pacote geobr, certifique-se que o pacote sf também esteja instalado. O pacote é importante para codificar dados vetoriais espaciais. Faça a leitura do pacote:

library(sf)

Observação: Caso o pacote sf não esteja instalado, use o procedimento padrão:

install.packages("sf")

Para manipulação e visualização dos dados, vamos usar outros dois pacotes já conhecidos, o ggplot2 e o dplyr. Faça a leitura dos dois, caso não tenha feito ainda:

library(ggplot2)

library(dplyr)

O objetivo dessa seção é criar um mapa com as exportações por UF. Para tanto, vamos utilizar os dados da Seção 14. Se você limpou seu Environment, importe os objetos em RData com a função load():

load("Exp.RData")

Para fazer o download do shapefile com os estados brasileiros, podemos usar a função read_state() do pacote geobr. Especifique um nome para o objeto, como por exemplo shapeUF:

shapeUF <- read_state()

Após a criação do objeto, consulte seu tipo de classe com a função class():

class(shapeUF)

## [1] "sf"         "data.table" "data.frame"

Observe que se trata de um objeto “sf”. Esse formato inclui atributos e geometrias para trabalhar com os dados espaciais. Abra o objeto shapeUF com a função View() e observe os dados:

View(shapeUF)

O próximo passo consiste em juntar o objeto com os dados de exportação por UF, dexp_mod, e o objeto shapeUF com os atributos e geometrias. Para tal, podemos usar a função left_join() do pacote dplyr.

No nosso exemplo, podemos usar a função para juntar os dois objetos levando em consideração a informação da coluna abbrev_state (Sigla da UF) do objeto shapeUF e da coluna UF do objeto dexp_mod.

Para tal, especificamos um novo objeto expuf com a função e critério de junção:

expuf <- left_join(shapeUF, dexp_mod, by = c("abbrev_state" = "uf"))

Após a junção dos dois objetos, podemos criar o mapa com auxílio do pacote ggplot2.

Para tal, podemos usar a função geom_sf(). A lógica de inserir camadas também é válida para esse caso:

ggplot() +
  geom_sf(data = expuf, aes(fill = exp), color = "white", size = .15) +
  labs(title = "Exportações", subtitle = "2019", caption = "Fonte: Elaboração própria.") +
  scale_fill_distiller(palette = "Reds", name = "Valor FOB Bilhões US$") +
  theme_minimal() +
  theme(plot.title = element_text(hjust = 0.5)) +
  theme(plot.subtitle = element_text(hjust = 0.5))

No mapa anterior, os estados com maiores exportações foram preenchidos com cores mais claras. Para alterar e adotar o inverso, ou seja, quanto maior as exportações mais escuro o preenchimento, podemos acrescentar trans = "reverse" na função scale_fill_distiller():

ggplot() +
  geom_sf(data = expuf, aes(fill = exp), color = "white", size = .15) +
  labs(title = "Exportações", subtitle = "2019", caption = "Fonte: Elaboração própria.") +
  scale_fill_distiller(palette = "Reds", trans = "reverse", name = "Valor FOB Bilhões US$") +
  theme_minimal() +
  theme(plot.title = element_text(hjust = 0.5)) +
  theme(plot.subtitle = element_text(hjust = 0.5))

Observação: Se você quiser retirar as coordenadas, adicione axis.text.x = element_blank(), axis.text.y = element_blank() e panel.grid = element_blank() ao seu comando com a função theme(). Faça o teste:

ggplot() +
  geom_sf(data = expuf, aes(fill = exp), color = "white", size = .15) +
  labs(title = "Exportações", subtitle = "2019", caption = "Fonte: Elaboração própria.") +
  scale_fill_distiller(palette = "Reds", trans = "reverse", name = "Valor FOB Bilhões US$") +
  theme_minimal() +
  theme(plot.title = element_text(hjust = 0.5)) +
  theme(plot.subtitle = element_text(hjust = 0.5)) +
  theme(axis.text.x = element_blank(),
        axis.text.y = element_blank(),
        panel.grid = element_blank())

Dica: Para explorar outros mapas com o geobr veja:

FIGUEIREDO, A. M. R. Mapas em R com geobr. Campo Grande-MS, Brasil: RStudio/Rpubs, 2020.

Referências

FERREIRA, E.; LISBOA, W. Curso Básico de Linguagem R. Escola de Contas Conselheiro Otacílio Silveira - ECOSIL, 2018.

FIGUEIREDO, A. M. R. Mapas em R com geobr. Campo Grande-MS, Brasil: RStudio/Rpubs, 2020.

GROLEMUND, G. Hands-on Programming with R: write your own functions and simulations. O’Reilly Media, Inc., 2014.

LONG, J. D.; TEETOR, P. R cookbook: proven recipes for data analysis, statistics, and graphics. O’Reilly Media, Inc., 2019.

OLIVEIRA, P. F.; GUERRA, S.; McDONNELL, R. Ciência de Dados com R - Introdução. Brasília: Editora IBPAD, 2018.

VERZANI, J. Getting started with RStudio. O’Reilly Media, Inc., 2011.

WICKHAM, H. ggplot2: elegant graphics for data analysis. Springer, 2016.

WICKHAM, H.; GROLEMUND, G. R for Data Science: import, tidy, transform, visualize, and model data. O’Reilly Media, Inc., 2016.

ZUUR, A.; IENO, E. N.; MEESTERS, E. A Beginner’s Guide to R. Springer Science & Business Media, 2009.

Comentários ou Sugestões:

Prof. Vinícius A. Vale
vinicius.a.vale@gmail.com
viniciusvale@ufpr.br

Tania M. Alberti
taniamoreiraalberti@gmail.com

Davi W. Catelan
daviwindercatelan.ecae@gmail.com

Esta obra está licenciada com uma Licença

Creative Commons Atribuição-NãoComercial-CompartilhaIgual 4.0 Internacional