Apostila curso R

Prévia do material em texto

Minicurso de introdução ao R
Semana acadêmica da economia
Marcelo Gelati e Gabriela Corá
16 e 18 de outubro de 2017
Contents
1 Introdução ao R 2
1.1 Como o R funciona . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Criando objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 Funções e operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.5 Pacotes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 Aprofundando o R 6
2.1 Estruturas de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.1 Vetores atômicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.2 Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1.3 Atributos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.1.4 Fatores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.1.5 Matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.1.6 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.7 Data frames . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2 Subsetting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2.1 Vetores atômicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.2.2 Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2.3 Matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2.4 Data frames . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2.5 Preservação e simplificação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2.6 Subset e assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.3 Subsetting com o pacote dplyr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.3.1 Gramática: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.4 Gráficos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.4.1 Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.4.2 Funções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.4.3 Parâmetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.4.4 Bibliotecas Gráficas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1
Figure 1: Objetos e funções
1 Introdução ao R
1.1 Como o R funciona
O R é uma linguagem de programação que funciona, basicamente, através de objetos, operadores e funções
(que elas mesmo são objetos). Os objetos possuem um nome e podem ser dados, variáveis, funções, resultados,
entre outros. Você pode realizar operações com esses objetos através de operadores ou de funções, sendo que
estas necessitam de argumentos para retornar um resultado. A figura 1 resume isto:
1.2 Criando objetos
Para criar um objeto, é preciso usar o operador assign <-. O operador também pode ser usado de maneira
invertida ->. Por exemplo, se queremos atribuir o valor 10 a um objeto n, devemos fazer o seguinte:
> n <- 10
A operação realizada acima deve ser lida da seguinte maneira: “n recebe 10”. Para verificarmos o que está
armazenado no objeto, basta digitar seu nome e apertar enter:
> n
[1] 10
É importante ressaltar que o R é case-sensitive, isto é, sensível a maiúsculas e minúsculas. Isto significa que
um objeto N é diferente do objeto n por nós criado. Veja:
> N <- 20
> N
[1] 20
Todo objeto criado no R deve começar com uma letra (a-z ou A-Z). Os caracteres seguintes podem ser letras,
números (0-9), underlines (_) e/ou pontos (.).
Podemos atribuir operações matemáticas a um objeto:
> soma <- 22 + 5
> soma
[1] 27
2
Mas note que podemos realizar a mesma operação sem ter que criar o objeto! Neste caso, o resultado será
mostrado no console.
> 22 + 5
[1] 27
1.3 Funções e operadores
Como mencionado acima, as funções precisam de argumentos para que possam ser rodadas. Por exemplo, a
função is.atomic() requer apenas um argumento: o objeto a ser testado. Caso você queira ler mais detalhes
sobre alguma função, basta acessar a documentação do R. Para fazer isso, deve-se utilizar uma interrogação ?
antes da função:
> ?is.atomic
A documentação de operadores (como o +, por exemplo) não pode ser acessada através de ?. Neste caso,
deve-se utilizar a função help:
> help("+")
Uma breve lista dos operadores mais básicos está no cartão de referência. Por este motivo não falaremos
sobre os operadores.
Quanto às funções, trabalharemos apenas com três: rep(), seq() e sample().
A função rep() serve para criar um vetor com elementos repetidos. Três de seus argumentos são:
• x: um vetor
• times: um inteiro m que fará com que o vetor seja repetido m vezes
• each: um inteiro m que fará com que cada elemento do vetor x seja repetido m vezes
Mostrando alguns exemplos:
> rep(1:3, times = 2)
[1] 1 2 3 1 2 3
> rep(1:3, each = 2)
[1] 1 1 2 2 3 3
> rep(1:3, times = c(1, 2, 3))
[1] 1 2 2 3 3 3
Note que se botarmos um vetor para o argumento times e não um inteiro, os valores do vetor x foram
repetidos tantas vezes quanto os valores do vetor de times dizem. Em nosso exemplo, o valor 1 foi repetido
uma vez, o valor 2 foi repetido duas vezes e o valor 3 foi repetido três vezes.
A função seq() serve para criarmos uma sequência de números. Alguns de seus argumentos são:
• from: um inteiro m que denota o valor inicial
• to: um inteiro m que denota o valor máximo
• by: um inteiro m que dá o aumento da sequência
Mais alguns exemplos:
> seq(from = 2, to = 3, by = 0.1)
[1] 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 3.0
> seq(from = 4, to = 2, by = -1)
[1] 4 3 2
> seq(from = 1, to = 2, by = 0.3)
[1] 1.0 1.3 1.6 1.9
3
A função sample() serve para gerarmos amostras aleatórias. Seus argumentos são:
• x: um vetor
• size: tamanho da amostra
• replace: um valor lógico que indica se a amostra deve ter reposição
• prob: um vetor que contém a probabilidade de cada cair cada valor incluso no vetor x
Exemplos:
> sample(c("mexerica", "amora", "cereja"), size = 10, replace = TRUE)
[1] "amora" "cereja" "mexerica" "amora" "mexerica" "cereja"
[7] "cereja" "cereja" "amora" "mexerica"
> sample(1:6, size = 6, replace = FALSE)
[1] 3 2 6 4 1 5
> sample(0:1, size = 15, replace = TRUE, prob = c(0.3, 0.7))
[1] 1 1 0 1 1 1 1 0 0 1 0 1 1 0 1
1.4 Scripts
Um script é basicamente um arquivo de texto que contém praticamente os mesmos comandos que você usaria
no console do R. Se você estiver usando o RStudio, é possível criar um novo script utilizando o atalho Ctrl
+ Shift + N ou clicando embaixo de File, no canto superior esquerdo, no ícone da folha de papel com um
símbolo de mais +.
Não há nenhum mistério no script. Como comentado logo acima, ele é basicamente um arquivo de texto. Ele
servirá, basicamente, para você anotar comentários, lembrar de pacotes que utilizou em um trabalho, guardar
funções importantes ou qualquer outra coisa que você queira salvar.
Na linguagem do R, se o texto for precedido de uma cerquilha # ele será interpretado como um comentário
e não será executado. Por exemplo, suponha que queiramos criar um script para nos lembrar como criar
objetos e realizar operaçõesentre eles:
####### CRIANDO OBJETOS
# Neste script, mostraremos como criar um objeto
# Para criar qualquer objeto, precisamos utilizar o operador assign
x <- 2
# Acima estamos criando o objeto x e estamos atribuindo a ele o valor 2
# Vamos criar agora o objeto y com o valor 3
y <- 3
# Agora, vamos realizar uma série de operações com os objetos
x + y
x*y
x - y
y - x
Se você estiver utilizando o RStudio, há duas maneiras de rodar o script: clicando em Run no canto superior
direito da janela do script ou utilizando o atalho Ctrl + Enter. Ao clicar em Run, apenas a linha selecionada
será rodada. Para rodar o script por inteiro selecione todo o arquivo e rode.
4
1.5 Pacotes
Todas funções que aqui utilizamos são do pacote base do R. É possível que aquilo que você deseja fazer não
tenha sido implementado no R. No entanto, por ele ser open source e contar com uma comunidade gigantesca,
é muito possível que alguém já tenha criado um pacote que resolva seu problema.
Para instalar um pacote é preciso utilizar a função install.packages(). É preciso que o nome do pacote
esteja entre aspas. Após o pacote ter sido instalado em seu computador é preciso rodá-lo no R. Para isso,
pode-se usar tanto a função require() como a função library(). Diferentemente da função de instalação,
estas últimas não requerem que o nome do pacote esteja entre aspas. Para você usar um pacote é preciso
rodá-lo toda vez que você inicia uma nova sessão do R.
Abaixo listamos alguns pacotes:
• installr: verifica se existe alguma atualização para o R e a instala
• ggplot2: gráficos mais elegantes
• googlesheets: importar dados das planilhas Google
• gdata: importar arquivos .xls e .xlsx; requer perl para rodar
• XLConnect: importar arquivos .xls e .xlsx; requer Java para rodar
5
2 Aprofundando o R
2.1 Estruturas de dados
Podemos separar as estruturas de objetos no R pela sua composição ou pela dimensão. A composição pode
ser homogênea (apenas um tipo no objeto) ou heterogênea (vários tipos diferentes no objeto). A dimensão
pode variar de 1 a n dimensões.
Dim/Comp Homogêneo Heterogêneo
1 dimensão Vetor atômico Lista
2 dimensões Matriz Data frame
n dimensões Array
Uma função extremamente útil para verificar a estrutura de um objeto é str(), que fornece uma breve
descrição sobre o objeto. Outra função de resumo de objetos é a summary().
Todas cinco estruturas listadas acima possuem atributos. De todos atributos possíveis, há dois que são
intrínsecos a qualquer estrutra: o tipo (type) e o comprimento (length).
2.1.1 Vetores atômicos
Para criarmos um vetor atômico utilizamos a função c().
> n <- c(1, 2, 3)
Note que os vetores atômicos são planos, isto é, criar um vetor atômico dentro de outro não traz nenhuma
diferença ao resultado final.
> x <- c(1, 2, 3, 4)
> y <- c(1, 2, c(3, 4))
> identical(x, y)
[1] TRUE
Como comentado acima, as estruturas de dados possuem um atributo intrínseco chamado tipo. Trabalharemos
aqui com quatro tipos diferentes: logical, integer, double e character.
Para criarmos um vetor do tipo lógico (logical), devemos utilizar os valores TRUE e FALSE. T e F também são
reconhecidos pelo R. Para criar um vetor de inteiros (integer) devemos utilizar o sufixo L. Para criar um
vetor de reais (double) basta criar um vetor com números. Para criar um vetor caractérico (char) devemos
botar as palavras entre aspas:
> logic <- c(T, F, TRUE, FALSE)
> integer <- c(1L, 2L, 3L)
> double <- c(2, 8, 9, 3)
> charac <- c("maria", "joao")
>
> logic
> integer
> double
> charac
[1] TRUE FALSE TRUE FALSE
[1] 1 2 3
[1] 2 8 9 3
[1] "maria" "joao"
6
Para verificarmos o tipo de um objeto, utilizamos a função typeof():
> typeof(logic)
[1] "logical"
> typeof(integer)
[1] "integer"
> typeof(double)
[1] "double"
> typeof(charac)
[1] "character"
Se quiseremos testar o tipo de um objeto, utilizamos as funções is.character(), is.double(),
is.logical(), entre outras.
> is.logical(logic)
[1] TRUE
> is.character(charac)
[1] TRUE
• Nota: is.numeric() é um teste geral que identifica se um vetor tem números, assim ele responderá
como TRUE para vetores do tipo “double” e do tipo “integer”. Da mesma forma, a função as.numeric
não força as variáveis para o tipo “double” automaticamente, utilize para tal as.double.
> is.numeric(charac)
[1] FALSE
> is.numeric(double)
[1] TRUE
O que acontece se criarmos um vetor com dois tipos diferentes em sua composição?
> b <- c("piscina", 1, 0, FALSE)
> typeof(b)
[1] "character"
O vetor atômico b assumiu o tipo caractérico porque existe algo no R chamado de regra de flexibilização.
Esta regra atesta que em uma estrutura homogênea apenas um tipo será suportado.
A ordem de flexibilidade dos tipos, do menos para o mais flexível, é a seguinte:
• logical
• integer
• double
• character
Assim, sempre que houver mais de um tipo diferente no mesmo vetor atômico, todos valores assumirão o tipo
mais flexível.
É possível forçar um vetor a assumir um tipo específico através das funções as.character(), as.double(),
as.integer() e as.logical(). Veja a tabela abaixo para entender o que acontece na coerção forçada:
as.logical as.numeric
Lógico permanece igual FALSE = 0, TRUE = 1
Numérico 0 = FALSE, outros números = 1 permanece igual
Caractérico NA, se o texto não for lógico NA, se o texto não for um número
7
as.character
Lógico fica em formato textual
Numérico fica em formato textual
Caractérico permanece igual
2.1.2 Listas
As listas, diferentemente dos vetores, são heterogêneas. Isto significa que suportam mais de um tipo em sua
composição. Veja:
> ls1 <- list(1:4, c(1, 5), c("massa", "pizza", "macarrao"), c(T, F, F))
> str(ls)
function (name, pos = -1L, envir = as.environment(pos), all.names = FALSE,
pattern, sorted = TRUE)
Outro aspecto que diferencia as listas de vetores atômicos é que as listas são recursivas. Isso significa que é
possível criar uma lista dentro de outra lista.
> ls2 <- list(1, 2, 3, 4)
> ls2
[[1]]
[1] 1
[[2]]
[1] 2
[[3]]
[1] 3
[[4]]
[1] 4
>
> ls3 <- list(list(1, 2), 3, 4)
> ls3
[[1]]
[[1]][[1]]
[1] 1
[[1]][[2]]
[1] 2
[[2]]
[1] 3
[[3]]
[1] 4
É possível retirar todos os objetos de dentro de uma lista usando a função unlist(). Ao fazer isso, o vetor
atômico resultante obedecerá as regras de flexibilização.
> ls1
[[1]]
[1] 1 2 3 4
8
[[2]]
[1] 1 5
[[3]]
[1] "massa" "pizza" "macarrao"
[[4]]
[1] TRUE FALSE FALSE
> unl <- unlist(ls1)
> str(unl)
chr [1:12] "1" "2" "3" "4" "1" "5" "massa" "pizza" "macarrao" "TRUE" ...
2.1.3 Atributos
Como falamos no início do capítulo, há dois atributos intrínsecos em qualquer objeto: o tipo e o comprimento.
Para verificarmos o tipo de um objeto utilizamos a função typeof(). Para verificarmos o comprimento de
um objeto utilizamos a função length().
Vamos falar do de um novo atributo agora: nomes (names). Podemos nomear os elementos de um vetor de
duas maneiras - na hora de criar o vetor ou por atribuição.
> d <- c(a = 1, b = 2, c = 3)
> d
a b c
1 2 3
>
> e <- c(1, 2, 3)
> names(e) <- c("a", "b", "c")
> e
a b c
1 2 3
Podemos verificar os atributos que um objeto contém com a função attributes(). Esta função retornará
todos atributos adicionais que um objeto tem.
> attributes(d)
$names
[1] "a" "b" "c"
>
> b
[1] "piscina" "1" "0" "FALSE"
> attributes(b)
NULL
O atributo dimensão (dim) refere-se às dimensões do objeto. Como estamos tratando apenas de estruturas
unidimensionais, este atributo não está presente.
> dim(d)
NULL
Para eliminar os nomes de um objeto, basta utilizar a função unname() ou atribuir o valor NULL aos nomes
do objeto.
> d <- unname(d)
> d
[1] 1 2 3
9
>
> names(e) <- NULL
> e
[1] 1 2 3
2.1.4 Fatores
Os fatores são casos especiais de vetores atômicos por conterem um atributo restrito a eles, os léveis.
> fac <- factor(1:6)
> fac[1] 1 2 3 4 5 6
Levels: 1 2 3 4 5 6
> attributes(fac)
$levels
[1] "1" "2" "3" "4" "5" "6"
$class
[1] "factor"
Os fatores são úteis para tratarmos de dados categóricos por causa da função table().
> frutas <- sample(c("kiwi", "amora", "ameixa", "morango"), size = 1000,
+ replace = TRUE, prob = c(0.2, 0.3, 0.15, 0.35))
> fac_frutas <- factor(frutas)
> table(fac_frutas)
fac_frutas
ameixa amora kiwi morango
162 281 217 340
Não é possível inserir nenhum valor que não esteja nos léveis do fator. Ao tentar fazer isso, um valor NA será
introduzido no lugar.
> fac
[1] 1 2 3 4 5 6
Levels: 1 2 3 4 5 6
> fac[1] <- "mexerica"
Warning in `[<-.factor`(`*tmp*`, 1, value = "mexerica"): invalid factor
level, NA generated
> fac
[1] <NA> 2 3 4 5 6
Levels: 1 2 3 4 5 6
2.1.5 Matrizes
Para criar uma matriz utilizamos a função matrix(). Seus argumentos são:
• x: os valores dentro da matriz
• ncol: o número de colunas
• nrow: o número de linhas
• byrow: um valor lógico; define se os valores vão ser organizados por linhas
> mat1 <- matrix(1:6, ncol = 2, nrow = 3, byrow = FALSE)
> mat1
10
[,1] [,2]
[1,] 1 4
[2,] 2 5
[3,] 3 6
>
> mat2 <- matrix(1:6, ncol = 2, nrow = 3, byrow = TRUE)
> mat2
[,1] [,2]
[1,] 1 2
[2,] 3 4
[3,] 5 6
A função length() retornará todos os valores dentro da matriz. Se você quiser ver as dimensões, use a função
dim().
> length(mat1)
[1] 6
> dim(mat1)
[1] 3 2
É possível criar uma matriz através das funções cbind() e rbind(). A primeira unirá vetores através de
colunas, já a segunda unirá através de linhas.
> a <- c(1, 2, 3)
> b <- c(4, 5, 6)
>
> cbind(a, b)
a b
[1,] 1 4
[2,] 2 5
[3,] 3 6
> rbind(a, b)
[,1] [,2] [,3]
a 1 2 3
b 4 5 6
2.1.6 Arrays
Arrays são versões de matrizes generalizadas para n dimensões (sendo n maior que 2). Não nos estenderemos
nesta parte, resumindo-a a um exemplo.
> arr <- array(1:24, dim = c(4, 3, 2))
> arr
, , 1
[,1] [,2] [,3]
[1,] 1 5 9
[2,] 2 6 10
[3,] 3 7 11
[4,] 4 8 12
, , 2
[,1] [,2] [,3]
[1,] 13 17 21
11
[2,] 14 18 22
[3,] 15 19 23
[4,] 16 20 24
2.1.7 Data frames
Data frames são muito parecidos com matrizes. Como são heterogêneos, cada coluna pode suportar um tipo
diferente.
> dat <- data.frame(numeros = c(1, 5, 6),
+ frutas = c("mirtilo", "banana", "laranja"),
+ logicos = c(T, F, F))
> dat
numeros frutas logicos
1 1 mirtilo TRUE
2 5 banana FALSE
3 6 laranja FALSE
> str(dat)
'data.frame': 3 obs. of 3 variables:
$ numeros: num 1 5 6
$ frutas : Factor w/ 3 levels "banana","laranja",..: 3 1 2
$ logicos: logi TRUE FALSE FALSE
Note que a coluna frutas foi criada como sendo um fator. Para suprimir este comportamento, basta usar o
argumento stringAsFactors = FALSE
> dat2 <- data.frame(numeros = c(1, 5, 6),
+ frutas = c("mirtilo", "banana", "laranja"),
+ logicos = c(T, F, F),
+ stringsAsFactors = FALSE)
> dat2
numeros frutas logicos
1 1 mirtilo TRUE
2 5 banana FALSE
3 6 laranja FALSE
> str(dat2)
'data.frame': 3 obs. of 3 variables:
$ numeros: num 1 5 6
$ frutas : chr "mirtilo" "banana" "laranja"
$ logicos: logi TRUE FALSE FALSE
Se você usar typeof() em um data frame o R lhe retornará list. Isso acontece porque data frames são listas
em duas dimensões. Para verificar o tipo de uma coluna especifica, use o cifrão $ e o nome da coluna depois
do objeto.
> typeof(dat)
[1] "list"
> typeof(dat$numeros)
[1] "double"
2.2 Subsetting
Subsetting é o ato de retirar de um objeto apenas as partes que lhe interessam. Imagine que você tem um data
frame com 23 colunas, mas que você precisa apenas da quinta para realizar sua análise. Com o subsetting é
12
possível retirar apenas esta quinta coluna, sem precisar ter que trazer todo o conjunto de dados novamente.
Começaremos a falar de subsetting em vetores atômicos, que são a estrutura mais simples, para depois
generalizarmos para as outras dimensões.
2.2.1 Vetores atômicos
Vamos criar um vetor atômico x:
> x <- c(2.1, 4.2, 5.3, 8.4)
> x
[1] 2.1 4.2 5.3 8.4
A casa decimal que tem em cada valor do vetor corresponde a sua posição dentro do vetor. Caso você queira
retirar o segundo valor do vetor, basta usar o operador [] depois do vetor.
> x[2]
[1] 4.2
É possível fazer subsetting com vetores atômicos para retirar mais de um valor.
> x[c(1, 3)]
[1] 2.1 5.3
>
> # Note que a ordem que você especifica o subsetting importa.
>
> x[c(3, 1)]
[1] 5.3 2.1
É possível também pedir valores repetidos e não-inteiros.
> x[c(2, 2)]
[1] 4.2 4.2
> x[c(2.1, 2.9)]
[1] 4.2 4.2
Se colocarmos um sinal negativo - antes do vetor dentro do subsetting, aqueles valores serão omitidos.
> x[-c(3, 4)]
[1] 2.1 4.2
O subsetting pode ser feito também com valores lógicos ou condições.
> x[c(T, F, T, F)]
[1] 2.1 5.3
>
> # A reciclagem ocorre para o subsetting. O subset acima é equivalente ao de baixo.
>
> x[c(T, F)]
[1] 2.1 5.3
>
> x[x >= 5]
[1] 5.3 8.4
É possível fazer o subset por nome caso o vetor tenha nomes.
> y <- c(a = 1, b = 2, c = 3)
> y["a"]
13
a
1
2.2.2 Listas
O subset de listas é extremamente parecido com o de vetores atômicos. Além do subset através dos colchetes
simples [], é possível realizar o subset através dos colchetes duplos [[]]. O resultado no final será diferente
devido à simplificação ou preservação do objeto. Discutiremos este assunto logo em seguida. No entanto,
verifique a diferença dos resultados.
> ls <- list(1:5, c(T, F, T), c("pera", "melão", "melancia"))
> ls
[[1]]
[1] 1 2 3 4 5
[[2]]
[1] TRUE FALSE TRUE
[[3]]
[1] "pera" "melão" "melancia"
> ls[2]
[[1]]
[1] TRUE FALSE TRUE
> ls[[2]]
[1] TRUE FALSE TRUE
> str(ls[2])
List of 1
$ : logi [1:3] TRUE FALSE TRUE
> str(ls[[2]])
logi [1:3] TRUE FALSE TRUE
2.2.3 Matrizes
As matrizes possuem duas dimensões. Isto significa que o operador de subset [] necessitará de dois argumentos:
um para o número de linhas a serem retiradas e outro para o número de colunas. Veja:
> mat <- matrix(1:9, ncol = 3)
> mat
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
Vamos retirar a primeira e a terceira linha junto com a segunda e a terceira coluna.
> mat[c(1, 3), c(2, 3)]
[,1] [,2]
[1,] 4 7
[2,] 6 9
14
>
> # Não especificar um dos argumentos é o mesmo que pedir para que todas as colunas sejam retiradas
>
> mat[c(1, 3), ]
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 3 6 9
2.2.4 Data frames
O subset de data frames é igual ao subsetting de matrizes (2 dimensões) ou ao subsetting de listas (hetero-
geneidade). É possível realizar tanto de um modo como de outro.
> dat <- data.frame(a = 1:10, b = letters[1:10], c = LETTERS[1:10])
> dat
a b c
1 1 a A
2 2 b B
3 3 c C
4 4 d D
5 5 e E
6 6 f F
7 7 g G
8 8 h H
9 9 i I
10 10 j J
Vamos fazer o subset primeiro como se fosse uma lista.
> dat[1]
a
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
10 10
Agora como se fosse uma matriz.
> dat[ , 1]
[1] 1 2 3 4 5 6 7 8 9 10
Note que os resultados foram diferentes. Isto é a preservação e a simplificação, respectivamente.
Uma outra maneira interessante de realizar subsets em data frames é através de condições lógicas. Veja a
construção abaixo passo a passo.
> # Queremos que o nosso data frame seja retornado apenas com as linhas que tenham valor
> # maior ou igual a 5 na coluna a.
> # Primeiro fazemos a condição.
>
15
> dat[ , 1] >= 5
[1] FALSE FALSE FALSE FALSE TRUE TRUE TRUE TRUE TRUE TRUE
>
> # Note que isto retornou um vetor lógico. Coloquemos a condição acima dentro
> # de um subsetting.
>
> dat[dat[ , 1] >= 5, ]
a b c
5 5 e E
6 6 f F
7 7 g G
8 8 h H
9 9 i I
10 10 j J
>
> # Assim, retiramos as linhas que não queríamos. Isto acontece, pois o
> # subset acima é equivalente ao subset abaixo.
>
> dat[c(F, F, F, F, T, T, T, T, T, T), ]
a b c
5 5 e E
6 6 f F
7 7 g G
8 8 h H
9 9 i I
10 10 j J
>
> # Que significa que não queremos as cinco primeiraslinhas.
2.2.5 Preservação e simplificação
Imagine as estruturas de dados como vagões de trens com cargas em seus interiores. Fazendo uma analogia, a
preservação irá retirar o vagão com a carga dentro na hora de fazer o subsetting. A simplificação retirará
apenas a carga.
Abaixo temos uma tabela com um resumo dos operadores de subsetting para realizar a simplificação ou a
preservação.
Estrutura de dados Simplificação Preservação
Vetor atômico x[[ ]] x[ ]
Lista x[[ ]] ou x$ x[ ]
Fator x[ , drop = T] x[ ]
Matriz x[ , 1] x[ , 1, drop = F]
Data frame x[ , 1], x[[1]] ou x$ x[ , 1, drop = F] ou x[1]
Vamos realizar exemplos de simplificação agora.
2.2.5.1 Vetores atômicos
Se um vetor atômico possuir nome, a simplificação retornará os valores sem seu nome.
16
> y
a b c
1 2 3
> y[[1]]
[1] 1
2.2.5.2 Listas
As listas perderão sua estrutura de lista.
> ls
[[1]]
[1] 1 2 3 4 5
[[2]]
[1] TRUE FALSE TRUE
[[3]]
[1] "pera" "melão" "melancia"
> ls[[1]]
[1] 1 2 3 4 5
> is.list(ls[[1]])
[1] FALSE
2.2.5.3 Fatores
O fator perderá léveis que não aparecem no subset.
> fac
[1] <NA> 2 3 4 5 6
Levels: 1 2 3 4 5 6
> fac[2, drop = T]
[1] 2
Levels: 2
2.2.5.4 Matrizes
As matrizes perderão sua estrutura bidimensional.
> mat
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
> mat[ , 1]
[1] 1 2 3
> is.matrix(mat[ , 1])
[1] FALSE
2.2.5.5 Data frames
Os data frames perderão sua estrutura bidimensional.
17
> dat
a b c
1 1 a A
2 2 b B
3 3 c C
4 4 d D
5 5 e E
6 6 f F
7 7 g G
8 8 h H
9 9 i I
10 10 j J
> dat$a
[1] 1 2 3 4 5 6 7 8 9 10
> is.atomic(dat$a)
[1] TRUE
2.2.6 Subset e assignment
Como você já deve ter realizado, é possível realizar o subsetting em conjunto com o assignment caso você
queira mudar um valor de um vetor, por exemplo,
> x
[1] 2.1 4.2 5.3 8.4
> x[2] <- 23
> x
[1] 2.1 23.0 5.3 8.4
2.3 Subsetting com o pacote dplyr
Outra forma de fazer subset em dados é utilizar pacotes do R, garantindo maior agilidade (em especial para
dados grandes). Um desses pacotes é o dplyr, que permite manipulação rápida e intuitiva de data.frames. O
uso desse pacote nos permite filtrar, reordenar, colapsar e manejar de maneira mais eficaz o conteúdo de
nossos dados. Aqui, apresentaremos algumas das funcionalidades, mas você pode encontrar um resumo de
todas as funcionalidades neste link.
2.3.1 Gramática:
As funções “chave” do pacote dplyr são:
• select: retorna um subset com as colunas de um data frame
• filter: filtra as linhas de um data frame baseada em condições lógicas específicas - como um filtro no
excel.
• arrange: reordena as linhas de um data frame ex: arrange(mtcars, desc(disp))
• rename: renomeia as variáveis de um data frame
• mutate: adiciona novas variáveis ou transforma as existentes
• summarise / summarize: gera estatísticas resumidas acerca dos dados
• %>%: o operador “pipe” é usado para conectar funções múltiplas juntas.
Para instalar o pacote, basta utilizar o comando
> #install.packages("dplyr")
> require(dplyr)
18
Loading required package: dplyr
Attaching package: 'dplyr'
The following objects are masked from 'package:stats':
filter, lag
The following objects are masked from 'package:base':
intersect, setdiff, setequal, union
É provável que apareça alguns avisos enquanto o pacote o carregado porque há funções no pacote dplyr que
tem o mesmo nome de funções de outros pacotes. Por enquanto você pode ignorar tais avisos. Caso contrário,
utilize suppressMessages(require(dplyr)).
a. Select
A função select() pode ser utilizada para selecionar colunas de um data frame que você quer. Ela é muito
útil pois geralmente uma base de dados possui um vasto número de variáveis, mas para a análises específicas
você precisará só de algumas delas. Assim, a função select permite que você selecione apenas aquelas que
precisa:
> names(mtcars)
[1] "mpg" "cyl" "disp" "hp" "drat" "wt" "qsec" "vs" "am" "gear"
[11] "carb"
> select(mtcars,mpg,cyl,disp)
mpg cyl disp
Mazda RX4 21.0 6 160.0
Mazda RX4 Wag 21.0 6 160.0
Datsun 710 22.8 4 108.0
Hornet 4 Drive 21.4 6 258.0
Hornet Sportabout 18.7 8 360.0
Valiant 18.1 6 225.0
Duster 360 14.3 8 360.0
Merc 240D 24.4 4 146.7
Merc 230 22.8 4 140.8
Merc 280 19.2 6 167.6
Merc 280C 17.8 6 167.6
Merc 450SE 16.4 8 275.8
Merc 450SL 17.3 8 275.8
Merc 450SLC 15.2 8 275.8
Cadillac Fleetwood 10.4 8 472.0
Lincoln Continental 10.4 8 460.0
Chrysler Imperial 14.7 8 440.0
Fiat 128 32.4 4 78.7
Honda Civic 30.4 4 75.7
Toyota Corolla 33.9 4 71.1
Toyota Corona 21.5 4 120.1
Dodge Challenger 15.5 8 318.0
AMC Javelin 15.2 8 304.0
Camaro Z28 13.3 8 350.0
Pontiac Firebird 19.2 8 400.0
Fiat X1-9 27.3 4 79.0
Porsche 914-2 26.0 4 120.3
Lotus Europa 30.4 4 95.1
Ford Pantera L 15.8 8 351.0
19
Ferrari Dino 19.7 6 145.0
Maserati Bora 15.0 8 301.0
Volvo 142E 21.4 4 121.0
> #ou você pode utilizar ":" para especificar o intervalo de nomes de variáveis que você deseja.
> select(mtcars, mpg:disp)
mpg cyl disp
Mazda RX4 21.0 6 160.0
Mazda RX4 Wag 21.0 6 160.0
Datsun 710 22.8 4 108.0
Hornet 4 Drive 21.4 6 258.0
Hornet Sportabout 18.7 8 360.0
Valiant 18.1 6 225.0
Duster 360 14.3 8 360.0
Merc 240D 24.4 4 146.7
Merc 230 22.8 4 140.8
Merc 280 19.2 6 167.6
Merc 280C 17.8 6 167.6
Merc 450SE 16.4 8 275.8
Merc 450SL 17.3 8 275.8
Merc 450SLC 15.2 8 275.8
Cadillac Fleetwood 10.4 8 472.0
Lincoln Continental 10.4 8 460.0
Chrysler Imperial 14.7 8 440.0
Fiat 128 32.4 4 78.7
Honda Civic 30.4 4 75.7
Toyota Corolla 33.9 4 71.1
Toyota Corona 21.5 4 120.1
Dodge Challenger 15.5 8 318.0
AMC Javelin 15.2 8 304.0
Camaro Z28 13.3 8 350.0
Pontiac Firebird 19.2 8 400.0
Fiat X1-9 27.3 4 79.0
Porsche 914-2 26.0 4 120.3
Lotus Europa 30.4 4 95.1
Ford Pantera L 15.8 8 351.0
Ferrari Dino 19.7 6 145.0
Maserati Bora 15.0 8 301.0
Volvo 142E 21.4 4 121.0
Da mesma forma você pode omitir nomes de variáveis utilizando a função select() usando o sinal negativo,
tal como demonstrado abaixo:
> select(mtcars,-(mpg:disp))
hp drat wt qsec vs am gear carb
Mazda RX4 110 3.90 2.620 16.46 0 1 4 4
Mazda RX4 Wag 110 3.90 2.875 17.02 0 1 4 4
Datsun 710 93 3.85 2.320 18.61 1 1 4 1
Hornet 4 Drive 110 3.08 3.215 19.44 1 0 3 1
Hornet Sportabout 175 3.15 3.440 17.02 0 0 3 2
Valiant 105 2.76 3.460 20.22 1 0 3 1
Duster 360 245 3.21 3.570 15.84 0 0 3 4
Merc 240D 62 3.69 3.190 20.00 1 0 4 2
Merc 230 95 3.92 3.150 22.90 1 0 4 2
Merc 280 123 3.92 3.440 18.30 1 0 4 4
20
Merc 280C 123 3.92 3.440 18.90 1 0 4 4
Merc 450SE 180 3.07 4.070 17.40 0 0 3 3
Merc 450SL 180 3.07 3.730 17.60 0 0 3 3
Merc 450SLC 180 3.07 3.780 18.00 0 0 3 3
Cadillac Fleetwood 205 2.93 5.250 17.98 0 0 3 4
Lincoln Continental 215 3.00 5.424 17.82 0 0 3 4
Chrysler Imperial 230 3.23 5.345 17.42 0 0 3 4
Fiat 128 66 4.08 2.200 19.47 1 1 4 1
Honda Civic 52 4.93 1.615 18.52 1 1 4 2
Toyota Corolla 65 4.22 1.835 19.90 1 1 4 1
Toyota Corona 97 3.70 2.465 20.01 1 0 3 1
Dodge Challenger 150 2.76 3.520 16.87 0 0 3 2
AMC Javelin 150 3.15 3.435 17.30 0 0 3 2
Camaro Z28 245 3.73 3.840 15.41 0 0 3 4
Pontiac Firebird 175 3.08 3.845 17.05 0 0 3 2
Fiat X1-9 66 4.08 1.935 18.90 1 1 4 1
Porsche 914-2 91 4.43 2.140 16.70 0 1 5 2
Lotus Europa 113 3.77 1.513 16.90 1 1 5 2
Ford Pantera L 264 4.22 3.170 14.50 0 1 5 4
Ferrari Dino 175 3.62 2.770 15.50 0 1 5 6
Maserati Bora 335 3.54 3.570 14.60 0 1 5 8
Volvo 142E 109 4.11 2.780 18.60 1 1 4 2
A função select também permite uma sintaxe especial para selecionar linhas que começam ou terminam com
letras, números ou caracteres específicos.
> x = select(mtcars, ends_with("b"))
>
> #ou
>
> y= select (mtcars, starts_with("d"))
b. Filter
A função filter()é utilizada para extrair determinadas linhas de um data frame baseados em uma condição
lógica. Essa função é similar ao subset() existente no R, porém um pouco mais rápida.
> disp_160= filter(mtcars, disp > 160)
>
> # para extrairmais de uma conteúdo ao mesmo tempo utilize a função & para dois eventos conjuntos ou o símbolo "||" para selecionar um ou outro evento.
c. Arrange
A função arrange()é utilizada para reordenar linhas de um data frame de acordo com uma das variáveis.
Você pode ordenar pela variável data, para obter uma ordem crescente de observações mais novas ou uma
ordem decrescente. Para ordenar basta utilizar a função como descrita abaixo:
> arrange(mtcars, desc(disp))
mpg cyl disp hp drat wt qsec vs am gear carb
1 10.4 8 472.0 205 2.93 5.250 17.98 0 0 3 4
2 10.4 8 460.0 215 3.00 5.424 17.82 0 0 3 4
3 14.7 8 440.0 230 3.23 5.345 17.42 0 0 3 4
4 19.2 8 400.0 175 3.08 3.845 17.05 0 0 3 2
5 18.7 8 360.0 175 3.15 3.440 17.02 0 0 3 2
6 14.3 8 360.0 245 3.21 3.570 15.84 0 0 3 4
7 15.8 8 351.0 264 4.22 3.170 14.50 0 1 5 4
8 13.3 8 350.0 245 3.73 3.840 15.41 0 0 3 4
21
9 15.5 8 318.0 150 2.76 3.520 16.87 0 0 3 2
10 15.2 8 304.0 150 3.15 3.435 17.30 0 0 3 2
11 15.0 8 301.0 335 3.54 3.570 14.60 0 1 5 8
12 16.4 8 275.8 180 3.07 4.070 17.40 0 0 3 3
13 17.3 8 275.8 180 3.07 3.730 17.60 0 0 3 3
14 15.2 8 275.8 180 3.07 3.780 18.00 0 0 3 3
15 21.4 6 258.0 110 3.08 3.215 19.44 1 0 3 1
16 18.1 6 225.0 105 2.76 3.460 20.22 1 0 3 1
17 19.2 6 167.6 123 3.92 3.440 18.30 1 0 4 4
18 17.8 6 167.6 123 3.92 3.440 18.90 1 0 4 4
19 21.0 6 160.0 110 3.90 2.620 16.46 0 1 4 4
20 21.0 6 160.0 110 3.90 2.875 17.02 0 1 4 4
21 24.4 4 146.7 62 3.69 3.190 20.00 1 0 4 2
22 19.7 6 145.0 175 3.62 2.770 15.50 0 1 5 6
23 22.8 4 140.8 95 3.92 3.150 22.90 1 0 4 2
24 21.4 4 121.0 109 4.11 2.780 18.60 1 1 4 2
25 26.0 4 120.3 91 4.43 2.140 16.70 0 1 5 2
26 21.5 4 120.1 97 3.70 2.465 20.01 1 0 3 1
27 22.8 4 108.0 93 3.85 2.320 18.61 1 1 4 1
28 30.4 4 95.1 113 3.77 1.513 16.90 1 1 5 2
29 27.3 4 79.0 66 4.08 1.935 18.90 1 1 4 1
30 32.4 4 78.7 66 4.08 2.200 19.47 1 1 4 1
31 30.4 4 75.7 52 4.93 1.615 18.52 1 1 4 2
32 33.9 4 71.1 65 4.22 1.835 19.90 1 1 4 1
> #or
> arrange(mtcars,disp)
mpg cyl disp hp drat wt qsec vs am gear carb
1 33.9 4 71.1 65 4.22 1.835 19.90 1 1 4 1
2 30.4 4 75.7 52 4.93 1.615 18.52 1 1 4 2
3 32.4 4 78.7 66 4.08 2.200 19.47 1 1 4 1
4 27.3 4 79.0 66 4.08 1.935 18.90 1 1 4 1
5 30.4 4 95.1 113 3.77 1.513 16.90 1 1 5 2
6 22.8 4 108.0 93 3.85 2.320 18.61 1 1 4 1
7 21.5 4 120.1 97 3.70 2.465 20.01 1 0 3 1
8 26.0 4 120.3 91 4.43 2.140 16.70 0 1 5 2
9 21.4 4 121.0 109 4.11 2.780 18.60 1 1 4 2
10 22.8 4 140.8 95 3.92 3.150 22.90 1 0 4 2
11 19.7 6 145.0 175 3.62 2.770 15.50 0 1 5 6
12 24.4 4 146.7 62 3.69 3.190 20.00 1 0 4 2
13 21.0 6 160.0 110 3.90 2.620 16.46 0 1 4 4
14 21.0 6 160.0 110 3.90 2.875 17.02 0 1 4 4
15 19.2 6 167.6 123 3.92 3.440 18.30 1 0 4 4
16 17.8 6 167.6 123 3.92 3.440 18.90 1 0 4 4
17 18.1 6 225.0 105 2.76 3.460 20.22 1 0 3 1
18 21.4 6 258.0 110 3.08 3.215 19.44 1 0 3 1
19 16.4 8 275.8 180 3.07 4.070 17.40 0 0 3 3
20 17.3 8 275.8 180 3.07 3.730 17.60 0 0 3 3
21 15.2 8 275.8 180 3.07 3.780 18.00 0 0 3 3
22 15.0 8 301.0 335 3.54 3.570 14.60 0 1 5 8
23 15.2 8 304.0 150 3.15 3.435 17.30 0 0 3 2
24 15.5 8 318.0 150 2.76 3.520 16.87 0 0 3 2
25 13.3 8 350.0 245 3.73 3.840 15.41 0 0 3 4
26 15.8 8 351.0 264 4.22 3.170 14.50 0 1 5 4
22
27 18.7 8 360.0 175 3.15 3.440 17.02 0 0 3 2
28 14.3 8 360.0 245 3.21 3.570 15.84 0 0 3 4
29 19.2 8 400.0 175 3.08 3.845 17.05 0 0 3 2
30 14.7 8 440.0 230 3.23 5.345 17.42 0 0 3 4
31 10.4 8 460.0 215 3.00 5.424 17.82 0 0 3 4
32 10.4 8 472.0 205 2.93 5.250 17.98 0 0 3 4
d. Rename
Renomear as variáveis de um data frame no R pode ser difícil, por isso a função rename()deste pacote auxilia
muito no processo. A sintaxe dentro da função rename() é o novo nome a esquerda do sinal de igual (“=”) e
o nome antigo é direita, como exemplificado abaixo.
> new_mtcars= rename(mtcars, meters_per_gallon = mpg)
e. Mutate
A função mutate() existe para transformar as variáveis de um data frame. Frequentemente você quer criar
variáveis derivadas das existentes e a função mutate()proporciona justamente isso. Por exemplo, se você
deseja criar uma nova variável de mpg que subtraia da variável mpg a sua média (para poder olhar se o mpg -
metros por galão- de um carro é maior ou menos que a média), utiliza-se:
> new = mutate(mtcars, new_mpg= mpg - mean(mpg, na.rm= TRUE))
Há também a função transmute que faz a mesma coisa que mutate porém retirando todas as demais variáveis
não transformadas.
> transmute(mtcars, new_mpg= mpg - mean(mpg, na.rm= TRUE))
new_mpg
1 0.909375
2 0.909375
3 2.709375
4 1.309375
5 -1.390625
6 -1.990625
7 -5.790625
8 4.309375
9 2.709375
10 -0.890625
11 -2.290625
12 -3.690625
13 -2.790625
14 -4.890625
15 -9.690625
16 -9.690625
17 -5.390625
18 12.309375
19 10.309375
20 13.809375
21 1.409375
22 -4.590625
23 -4.890625
24 -6.790625
25 -0.890625
26 7.209375
27 5.909375
28 10.309375
23
29 -4.290625
30 -0.390625
31 -5.090625
32 1.309375
g. Group_by
A função group_by() é usada para gerar estatísticas resumo de um data frame a partir da definição de uma
variável. Por exemplo, se você quiser agrupar por “am” (se o carro é automático ou não) e por “v/s” (se o
carro possui um motor em V ou em linha reta):
> by_vs_am <- group_by(mtcars, vs, am)
> by_vs <- summarise(by_vs_am, n = n())
> by_vs
# A tibble: 4 x 3
# Groups: vs [?]
vs am n
<dbl> <dbl> <int>
1 0 0 12
2 0 1 6
3 1 0 7
4 1 1 7
>
> #Você por utilizar group_by para expressões, um atalho para mutate/rename
>
> group_by(mtcars, vsam = vs + am)
# A tibble: 32 x 12
# Groups: vsam [3]
mpg cyl disp hp drat wt qsec vs am gear carb vsam
<dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
1 21.0 6 160.0 110 3.90 2.620 16.46 0 1 4 4 1
2 21.0 6 160.0 110 3.90 2.875 17.02 0 1 4 4 1
3 22.8 4 108.0 93 3.85 2.320 18.61 1 1 4 1 2
4 21.4 6 258.0 110 3.08 3.215 19.44 1 0 3 1 1
5 18.7 8 360.0 175 3.15 3.440 17.02 0 0 3 2 0
6 18.1 6 225.0 105 2.76 3.460 20.22 1 0 3 1 1
7 14.3 8 360.0 245 3.21 3.570 15.84 0 0 3 4 0
8 24.4 4 146.7 62 3.69 3.190 20.00 1 0 4 2 1
9 22.8 4 140.8 95 3.92 3.150 22.90 1 0 4 2 1
10 19.2 6 167.6 123 3.92 3.440 18.30 1 0 4 4 1
# ... with 22 more rows
h. %>%
O operador de pipeline %>% permite conectar distintas operações, tornando-as mais simples de entender.
Assim, pode utilizar a seguinte sintaxe:
> #first(x) %>% second %>% third
>
> #ao invés de
>
> #third(second(first(x)))
Assim, para o exercícios anterior, é possível fazer:
> by_vs_am = group_by(mtcars, vs, am) %>%
+ summarise(n = n())
24
> by_vs_am
# A tibble: 4 x 3
# Groups: vs [?]
vs am n
<dbl> <dbl> <int>
1 0 0 12
2 0 1 6
3 1 0 7
4 1 1 7
Desse modo, não é preciso criar um conjunto de novas variáveis temporárias, como a by_vs criada no exercício
da seção group_by.
2.4 Gráficos
É possível criar muitos gráficos e customizá-los de muitas maneiras através do R. Você pode verificar as
demonstrações que o R tem de gráficos através de demo(graphics) ou demo(persp).
2.4.1 Layout
No RStudio os gráficos são apresentados na tela no canto inferior direito. Toda vez que você cria um gráfico,
uma nova janela é criada. Veja:
> x <- 1:5
> plot(x)
1 2 3 4 5
1
2
3
4
5
Index
x
25
No entanto, isso pode ser modificado através de layout(). Esta função, em conjunto com matrizes, permite
que você altere a disposição dos gráficos na tela. Se você tiver a seguinte matriz:
> matriz <- matrix(1:2, nrow = 1)
> matriz
[,1] [,2]
[1,] 1 2
E colocá-la dentro da função layout(), a disposição de gráficos será repartida na metade:
> layout(matriz)
> plot(x)
> plot(x)
1 2 3 4 5
1
2
3
4
5
Index
x
1 2 3 4 5
1
2
3
4
5
Index
x
Você pode criar disposições à maneira que quiser. Vamos criar uma disposição extremamente bizarra para
exemplificar.
> a <- c(1, 2, 0, 0)
> b <- c(1, 2, 0, 4)
> c <- c(0, 2, 3, 4)
> d <- c(0, 2, 3, 0)
>
> matriz2 <- rbind(a, b, c, d)
> matriz2
[,1][,2] [,3] [,4]
a 1 2 0 0
b 1 2 0 4
c 0 2 3 4
26
d 0 2 3 0
> layout(matriz2)
> plot(x)
> plot(x)
> plot(x)
> plot(x)
1 2 3 4 5
1
2
3
4
5
Index
x
1 2 3 4 5
1
2
3
4
5
Index
x
1 2 3 4 5
1
2
3
4
5
Index
x
1 2 3 4 5
1
2
3
4
5
Index
x
27
É possível verificar a disposição que você fez através da função layout.show().
> layout(matriz2)
> layout.show(4)
1
2
3
4
Para resetar à disposição original, basta usar layout(1).
2.4.2 Funções
As funções relacionadas à gráficos podem ser dividas em duas categorias: funções de alto e de baixo nível.
2.4.2.1 Funções de alto nível
Estas funções referem-se à criação de gráficos do zero. Funções como plot(), pie(), barplot(), entre outras,
são funções de alto nível.
2.4.2.2 Funções de baixo nível
São as funções que adicionam elementos em um gráfico já criado. Alguns exemplos são abline(), rect() e
points(). Alguns outros exemplos podem ser encontrados no cartão de referência.
2.4.3 Parâmetros
Os parâmetros são os argumentos que você usa para colocar as especificações nos gráficos. Uma lista completa
pode ser visualizada através de help(par).
28
Você pode definir os parâmetros de duas maneiras: definir os parâmetros globais previamente, ou definir nos
argumentos de um gráfico. Para definir previamente, deve-se usar a função par() com os argumentos que
você quer. Por exemplo, suponha que você queira transformar o fundo em azul claro:
> par(bg = "lightblue")
> plot(x)
1 2 3 4 5
1
2
3
4
5
Index
x
A partir de agora, todas gráficos que você criar terão fundo azul claro. Para resetar para os parâmetros
originais, basta usar dev.off()
> dev.off()
null device
1
29
A outra maneira comentada é utilizar os parâmetros na hora de criar a função.
> plot(x, main = "Gráfico exemplo", xlab = "Indexador", ylab = "Pontos de 1 a 5",
+ bty = "l", cex = 2)
1 2 3 4 5
1
2
3
4
5
Gráfico exemplo
Indexador
Po
n
to
s 
de
 1
 a
 5
> # Estes parâmetros servem, respectivamente, para criar o título do gráfico,
> # para criar o texto do eixo x, para criar o texto do eixo y, para definir o
> # formato da caixa e para definir o tamanho dos pontos
Uma lista com os parâmetros mais comuns está no cartão de referência.
2.4.4 Bibliotecas Gráficas
Existem inúmeros pacotes gráficos disponíveis para utilização no R, eles auxiliam criando gráficos mais
organizados, coesos e dinâmicos. Os principais pacotes utilizados para a criação de dashboards e relatórios
são:
• Plotly: permite gerar gráficos muito mais intuitivos e de melhor visualização quando comparado aos
gráficos gerados pelo R sem o pacote.
• Dygraphs: O pacote dygraphs é uma interface no R para biblioteca de gráficos JavaScript, “dygraphs”.
Esta biblioteca detém muitas facilidades para construção de gráficos de séries temporais no R.
• Leaflet:É um dos pacotes mais conhecidos de mapas interativos, facilmente integrado ao R.
• Hicharter: HighChart promove uma rica interface do R para gráficos JavaScript. Hightchats é grátis
apenas para uso não comercial).
• GGPlot2: pacote gráfico que permite elabora de gráficos complexos, com linhas de ajustes fnuncionais.
30
2.4.4.1 Plotly
O pacote plotly nos permite gerar gráficos muito mais intuitivos e de melhor visualização quando comparado
aos gráficos gerados pelo R sem o pacote. Abaixo seguem os principais tipos de gráficos e comandos do
pacote:
a. Gráfico de dispersão,scatter.
> library(plotly)
> plot_ly(x= cars$speed, y= cars$dist, type = "scatter", mode = "markers")
b. Text: gráfico de dipersão modo texto, text.
> plot_ly(x = mtcars$wt, y = mtcars$mpg, text = rownames(mtcars),type = "scatter", mode="text")
31
c. Markers+text: gráfico de dipersão misturando as formas de exibição, em pontos e texto.
> #Definindo o tipo de fonte para o texto e tamanho.
> t <- list(
+ family = "sans serif",
+ size = 14,
+ color = toRGB("grey50")
+ )
> #Gráfico inserido o tipo de fonte/tamanho estabelecido acima.
> plot_ly(x = mtcars$wt, y = mtcars$mpg, text = rownames(mtcars), type = "scatter", mode = "markers+text",
+ textfont = t, textposition = "top middle")
d. Boxplot
> plot_ly(y= cars$dist, type = "box")
32
e. Múltiplos boxplots
>
> p<-plot_ly(y = ggplot2::diamonds$price, color = ggplot2::diamonds$cut, type = "box")
>
> # Definição da fonte (tipo e tamanho)
>
> f <- list(
+ family = "sans-serif",
+ size = 12,
+ color = "#000"
+ )
> # Definição da legenda (fonte, cor da caixa, cor da borda da caixa e espessura da borda)
>
> layout(p,legend = list(
+ font = f,
+ bgcolor = "#FFFFFF",
+ bordercolor = "#E2E2E2",
+ borderwidth = 2)
+ )
33
f. Suplot: exibe mais de gráfico de forma conjunta. Podem aparecer em n coluna, ou em n linhas. O
padrão, ao utilizar o comando suplot, é dividir os gráficos em colunas distintas. Para dividí-los em
linhas, utiliza-se o comando nrows= n.Ambos os exemplos são mostrados abaixo:
> p1 <- plot_ly(x = economics$date, y = economics$uempmed, showlegend = F)
> p2 <- plot_ly(x = economics$date, y = economics$unemploy, showlegend = F)
> x<-subplot(p1, p2)
> x
34
g. Anotações: pode-se identificar os pontos desejados em um gráfico. O exemplo abaixo identifica o ponto
máximo:
> m <- mtcars[which.max(mtcars$mpg), ]
> a <- list(
+ x = m$wt,
+ y = m$mpg,
+ text = rownames(m),
+ xref = "x",
+ yref = "y",
+ showarrow = T,
+ arrowhead = 6,
+ ax = 20,
+ ay = -40
+ )
> layout(plot_ly(mtcars, x = mtcars$wt, y = mtcars$mpg, type = "scatter" , mode = "markers"), annotations = a)
35
i. Histograma
> plot_ly(x = rnorm(50), type = "histogram")
• Sobreposição de histogramas
> layout(add_trace(plot_ly(x = rnorm(500), opacity = 0.6, type = "histogram"),
+ x = rnorm(500)+1, opacity = 0.6, type = "histogram"),
+ barmode="overlay")
2.4.4.2 Dygraphs
O pacote dygraphs é uma interface no R para biblioteca de gráficos JavaScript, “dygraphs”. Esta biblioteca
detém muitas facilidades para construção de gráficos de séries temporais no R. São características dessa
biblioteca:
36
1. Gera gráficos automaticamente de objetos de séries temporais XTS (ou qualquer objeto que seja
convertível para xts).
2. Torna os eixos e séries temporais (incluíndo até um segundo eixo de Y) altamente reconfiguráveis.
3. Possui recuros de interatividade riquíssimos, incluíndo zoom e opções de destaque em séries.
4. Mostra barras superiores/inferiores (por exemplo, intervalo de confiança) em torno das séries.
5. Possibilita várias sobreposições de gráficos, incluindo regiões sombreadas, linhas de eventos e ponto de
anotações.
6. É simples de usar, funcional igual aos gráficos convencionais do R.
7. É perfeito para usar conjuntamente com documentos R Markdown e aplicações web Shiny.
Abaixo temos um exemplo de um dygraph criada para um objeto de múltiplas séries temporais
> library(dygraphs)
> lungDeaths <- cbind(mdeaths, fdeaths)
> dygraph(lungDeaths)
37
Com a biblioteca DYGRAPHS podemos fazer as seguintes personalizações:
• Cores
> lungDeaths <- cbind(ldeaths, mdeaths, fdeaths)
> dygraph(lungDeaths, main = "Mortes por câncer de pulmão(UK)") %>%
+ dyOptions(colors = RColorBrewer::brewer.pal(3, "Set2"))
• Gráficos de escada
> lungDeaths <- cbind(mdeaths, fdeaths)
> dygraph(lungDeaths, main = "Mortes por câncer de pulmão (UK)") %>%
+ dyOptions(stepPlot = TRUE)
38
• Gráficos preenchidos
> dygraph(ldeaths, main = "Mortes por câncer de pulmão (UK)") %>%
+ dyOptions(fillGraph = TRUE, fillAlpha = 0.4)
• Gráficos com pontos
> dygraph(ldeaths, main = "Mortes por câncer de pulmão (UK)") %>%
+ dyOptions(drawPoints = TRUE, pointSize = 2)
39
• Opções nos eixos: é possível customizar os eixos através da função dyOptions (para opção global) e da
opção dyAxis.
• valueRange é usadopara definir a variação de um eixo;
• axisLineWidth é usado para especificar pixels de largura ligeiramente maior para as linhas de eixo;
• fillGraph especifica quais os valores de y que devem ser preenchidos verticalmente;
• drawGrid desliga a linha do gráfico dos eixos especificados (no caso abaixo, para o eixo x);
• includeZeroassegura que o eixo y inclui o zero (e não o menor número);
• axisLineColor e gridLineColor mudam a linha do eixo e do gráfico, respectivamente;
• Opções no segundo eixo: se você está plotando multiplas séries, que possuem valores distintos, é possível
adicionar um eixo y secundário. Isso é feito pela opção independentTicks para o eixo y2 e, então,
vinculando uma ou mais séries a esse eixo.
> temperatura <- ts(frequency = 12, start = c(1980, 1),
+ data = c(7.0, 6.9, 9.5, 14.5, 18.2, 21.5,25.2, 26.5, 23.3, 18.3, 13.9, 9.6))
> chuva <- ts(frequency = 12, start = c(1980, 1),
+ data = c(49.9, 71.5, 106.4, 129.2, 144.0, 176.0,135.6, 148.5, 216.4, 194.1, 95.6, 54.4))
> weather <- cbind(chuva, temperatura)
> dygraph(weather) %>% dySeries("chuva", axis = 'y2')
40
• Linhas de eventos: linhas de eventos são maneiras úteis de mostrar pontos e eventos importantes no
meio de uma série temporal. No gráfico abaixo, são mostradas as datas dos primeiros combates na
Coréia e no Vietnã em um gráfico das taxas de aprovação presidencial dos Estados Unidos.
> dygraph(presidents, main = "Taxas de Aprovação presidenciais") %>%
+ dyAxis("y", valueRange = c(0, 100)) %>%
+ dyEvent("1950-6-30", "Coréia", labelLoc = "bottom") %>%
+ dyEvent("1965-2-09", "Vietnã", labelLoc = "bottom")
• Linha de Limite: por exemplo, o limite mínimo de temperatura:
>
> dygraph(nhtemp, main = "Temperatura") %>%
+ dyLimit(as.numeric(nhtemp[29]), color = "red")
41
• Barras: você pode plottar barras de erro simplesmente especificando o menor valor e o maior no nome
do parâmetro dySeries. Por exemplo:
> hw <- HoltWinters(ldeaths)
> p <- predict(hw, n.ahead = 72, prediction.interval = TRUE)
>
> dygraph(p, main = "Mortes por câncer de pulmão (UK)") %>%
+ dySeries(c("lwr", "fit", "upr"), label = "Mortes")
42
Assim, é possível colocar a série atual e a prevista em um mesmo gráfico:
> hw <- HoltWinters(ldeaths)
> p <- predict(hw, n.ahead = 36, prediction.interval = TRUE)
> all <- cbind(ldeaths, p)
>
> dygraph(all, "Mortes por câncer de pulmão (UK)") %>%
+ dySeries("ldeaths", label = "Atual") %>%
+ dySeries(c("p.lwr", "p.fit", "p.upr"), label = "Previsto")
2.4.4.3 Highchart
HighChart promove uma rica interface do R para gráficos JavaScript. Hightchats é grátis apenas para uso
não comercial.
43
• Gráficos de barras
>
> require(highcharter)
> hchart(diamonds$cut, colorByPoint = TRUE, name = "Cut")
• Boxplot
> highchart() %>%
+ hc_add_series_boxplot(x = iris$Sepal.Length, by = iris$Species, name = "length")
Warning: 'hc_add_series_boxplot' is deprecated.
Use 'hcboxplot' instead.
See help("Deprecated")
44
• Densidade
>
> hchart(density(diamonds$price), area = TRUE, color = "#B71C1C", name = "Preço")
• Fatores
> hchart(diamonds$cut, colorByPoint = TRUE)
45
• Decomposição Sazonal de uma série temporal
>
> x <- stl(log(AirPassengers), "per")
>
> hchart(x)
• Autocovariância e Autocorrelação
> x <- acf(diff(economics$unemploy), plot = FALSE)
>
> hchart(x)
46
• Múltiplas Séries Temporais
> x <- cbind(mdeaths, fdeaths)
>
> hchart(x)
• Gráficos com pontos e anotações
>
> highchart(height = 500) %>%
+ hc_title(text = "") %>%
+ hc_add_series_scatter(mtcars$wt, mtcars$mpg,
+ mtcars$drat, mtcars$hp,
+ rownames(mtcars),
+ dataLabels = list(
+ enabled = TRUE,
+ format = "{point.label}"
+ ))
Warning: 'hc_add_series_scatter' is deprecated.
Use 'hc_add_series' instead.
See help("Deprecated")
47
Outros exemplos de temas disponíveis estão neste link
2.4.4.4 Leaflet
É um dos pacotes mais conhecidos de mapas interativos, facilmente integrado ao R.
• Uso básico:
> #install.packages('leaflet')
> require(leaflet)
Warning: package 'leaflet' was built under R version 3.4.2
> m <- leaflet() %>%
+ addTiles() %>%
+ addMarkers(lng=174.768, lat=-36.852, popup="Local de nascimento do R")
> m
48
	Introdução ao R
	Como o R funciona
	Criando objetos
	Funções e operadores
	Scripts
	Pacotes
	Aprofundando o R
	Estruturas de dados
	Vetores atômicos
	Listas
	Atributos
	Fatores
	Matrizes
	Arrays
	Data frames
	Subsetting
	Vetores atômicos
	Listas
	Matrizes
	Data frames
	Preservação e simplificação
	Subset e assignment
	Subsetting com o pacote dplyr
	Gramática:
	Gráficos
	Layout
	Funções
	Parâmetros
	Bibliotecas Gráficas