Como tirar raiz quadrada no r

Esta seção trata do tema manipulação de dados. Trata-se de uma tarefa dolorosa e demorada, tomando muitas vezes a maior parte do tempo de uma análise de dados. Apesar de negligenciada pela Estatística, essa etapa é essencial para o sucesso da análise.

The fact that data science exists as a field is a colossal failure of statistics. To me, what I do is what statistics is all about. It is gaining insight from data using modelling and visualization. Data munging and manipulation is hard and statistics has just said that’s not our domain. — Hadley Wickham

Usualmente, cientistas de dados partem de uma base “crua” e a transformam até obter uma base de dados analítica, que, a menos de transformações simples, está preparada para gerar tabelas e gráficos e alimentar modelos.

Figura 7.1: Estamos na etapa de arrumação do ciclo da Ciência de Dados.

Um conceito importante para obtenção de uma base analítica é o data tidying, ou arrumação de dados. Uma base é considerada tidy se

• 1. Cada linha da base representa uma observação.
• 1. Cada coluna da base representa uma variável.

A base de dados analítica é estruturada de tal forma que pode ser colocada diretamente em ambientes de modelagem estatística ou de visualização. Nem sempre uma base de dados analítica está no formato tidy, mas usualmente são necessários poucos passos para migrar de uma para outra. A filosofia tidy é a base do tidyverse.

Os principais pacotes encarregados da tarefa de estruturar os dados são o dplyr e o tidyr. Eles serão o tema desse capítulo. Instale e carregue os pacotes utilizando:

install.packages(c("dplyr", "tidyr")) library(dplyr) library(tidyr)

Mas antes de apresentar as principais funções do dplyr e do tidyr, precisamos falar sobre o conceito de tibbles.

O dplyr é o pacote mais útil para realizar transformação de dados, aliando simplicidade e eficiência de uma forma elegante. Os scripts em R que fazem uso inteligente dos verbos dplyr e as facilidades do operador pipe tendem a ficar mais legíveis e organizados, sem perder velocidade de execução.

As principais funções do dplyr são:

• select() - seleciona colunas
• arrange() - ordena a base
• filter() - filtra linhas
• mutate() - cria/modifica colunas
• group_by() - agrupa a base
• summarise() - sumariza a base

Todas essas funções seguem as mesmas características:

• O input é sempre uma tibble e o output é sempre uma tibble.
• Colocamos a tibble no primeiro argumento e o que queremos fazer nos outros argumentos.
• A utilização é facilitada com o emprego do operador %>%.

As principais vantagens de se usar o dplyr em detrimento das funções do R base são:

• Manipular dados se torna uma tarefa muito mais simples.
• O código fica mais intuitivo de ser escrito e mais simples de ser lido.
• O pacote dplyr utiliza C e C++ por trás da maioria das funções, o que geralmente torna o código mais rápido.
• É possível trabalhar com diferentes fontes de dados, como bases relacionais (SQL) e data.table.

Se você ainda não tiver o dplyr instalado, rode o código abaixo.

install.packages("dplyr") library(dplyr)

Neste capítulo, vamos trabalhar com uma base de filmes do IMDB. Essa base pode ser baixada clicando aqui.

Assim, utilizaremos o objeto imdb para acessar os dados.

imdb <- readr::read_rds("imdb.rds") imdb

Agora, vamos avaliar com mais detalhes as principais funções do pacote dplyr.

Para selecionar colunas, utilizamos a função select().

O primeiro argumento da função é a base de dados e os demais argumentos são os nomes das colunas que você gostaria de selecionar. Repare que você não precisa colocar o nome da coluna entre aspas.

Você também pode selecionar várias colunas.

select(imdb, titulo, ano, orcamento)

O operador : é muito útil para selecionar colunas consecutivas.

O dplyr possui um conjunto de funções auxiliares muito úteis para seleção de colunas. As principais são:

• starts_with(): para colunas que começam com um texto padrão
• ends_with(): para colunas que terminam com um texto padrão
• contains(): para colunas que contêm um texto padrão

Selecionamos a seguir todas as colunas que começam com o texto “ator”.

select(imdb, starts_with("ator"))

Para retirar colunas da base, base acrescentar um - antes da seleção.

select(imdb, -ano, - diretor)

select(imdb, -starts_with("ator"))

Utilize a base imdb nos exercícios a seguir.

1. Teste aplicar a função glimpse() do pacote {dplyr} à base imdb. O que ela faz?

2. Crie uma tabela com apenas as colunas titulo, diretor, e orcamento. Salve em um objeto chamado imdb_simples.

3. Selecione apenas as colunas ator_1, ator_2 e ator_3 usando a função auxiliar contains().

4. Usando a função select() (e suas funções auxiliares), escreva códigos que retornem a base IMDB sem as colunas ator_1, ator_2 e ator_3. Escreva todas as soluções diferentes que você conseguir pensar.

Para ordenar linhas, utilizamos a função arrange(). O primeiro argumento é a base de dados. Os demais argumentos são as colunas pelas quais queremos ordenar as linhas. No exemplo a seguir, ordenamos as linhas da base por ordem crescente de orçamento.

Também podemos ordenar de forma decrescente usando a função desc().

arrange(imdb, desc(orcamento))

E claro, ordenar segundo duas ou mais colunas.

arrange(imdb, desc(ano), desc(orcamento))

Utilize a base imdb nos exercícios a seguir.

1. Ordene os filmes em ordem crescente de ano e decrescente de receita e salve em um objeto chamado filmes_ordenados.

2. Selecione apenas as colunas titulo e orcamento e então ordene de forma decrescente pelo orcamento.

Na grande maioria dos casos, vamos aplicar mais de uma função de manipulação em uma base para obtermos a tabela que desejamos. Poderíamos, por exemplo, querer uma tabela apenas com o título e ano dos filmes, ordenada de forma crescente de lançamento. Para fazer isso, poderíamos aninhar as funções

arrange(select(imdb, titulo, ano), ano)

ou criar um objeto intermediário

tab_titulo_ano <- select(imdb, titulo, ano) arrange(tab_titulo_ano, ano)

Os dois códigos funcionam e levam ao mesmo resultado, mas não são muito bons.

A primeira alternativa é ruim de escrever (já que precisamos escrever primeiro a função que roda por último) e de ler (pois é difícil identificar qual argumento pertence a qual função).

A segunda alternativa também é ruim, pois exige a criação de objetos auxiliares. Se quiséssimos aplicar 10 operações na base, precisaríamos criar 9 objetos intermediários.

A solução para aplicar diversas operações de manipulação em uma base de dados é aplicar o operador pipe: %>%.

imdb %>% select(titulo, ano) %>% arrange(ano)

O que está sendo feito no código com pipe? Da primeira para a segunda linha, estamos aplicando a função select() à base imdb. Da segunda para a terceira, estamos aplicando a função arrange() à base resultante da função select().

O resultado desse código é idêntico às tentativas sem pipe, com a vantagem de termos escrito o código na ordem em que as funções são aplicadas, de termos um código muito mais legível e de não precisarmos utilizar objetos intermediários.

Para filtrar valores de uma coluna da base, utilizamos a função filter().

imdb %>% filter(nota_imdb > 9)

Podemos selecionar apenas as colunas título e nota para visualizarmos as notas:

imdb %>% filter(nota_imdb > 9) %>% select(titulo, nota_imdb)

Podemos estender o filtro para duas ou mais colunas. Para isso, separamos cada operação por uma vírgula.

imdb %>% filter(ano > 2010, nota_imdb > 8.5)

Também podemos fazer operações com as colunas da base dentro da função filter. O código abaixo devolve uma tabela apenas com os filmes que lucraram.

imdb %>% filter(receita - orcamento > 0)

Naturalmente, podemos filtrar colunas categóricas. O exemplo abaixo retorna uma tabela apenas com os filmes com a Angelina Jolie Pitt ou o Brad Pitt no papel principal.

imdb %>% filter(ator_1 %in% c('Angelina Jolie Pitt', "Brad Pitt"))

Para filtrar textos sem correspondência exata, podemos utilizar a função auxiliar str_detect() do pacote {stringr}. Ela serve para verificar se cada string de um vetor contém um determinado padrão de texto.

library(stringr) str_detect( string = c("a", "aa","abc", "bc", "A", NA), pattern = "a" )

Podemos utilizá-la para filtrar apenas os filmes que contêm o gênero ação.

# A coluna gêneros apresenta todos os gêneros dos filmes concatenados imdb$generos[1:6]

# Podemos detectar se o gênero Action aparece na string str_detect( string = imdb$generos[1:6], pattern = "Action" )

# Aplicamos essa lógica dentro da função filter, para a coluna completa imdb %>% filter(str_detect(generos, "Action"))

Utilize a base imdb nos exercícios a seguir.

1. Crie um objeto chamado filmes_pb apenas com filmes preto e branco.

2. Crie um objeto chamado curtos_legais com filmes de 90 minutos ou menos de duração e nota no imdb maior do que 8.5.

3. Retorne tabelas (tibbles) apenas com:

• a. filmes coloridos anteriores a 1950;

• b. filmes do “Woody Allen” ou do “Wes Anderson”;

• c. filmes do “Steven Spielberg” ordenados de forma decrescente por ano, mostrando apenas as colunas titulo e ano;

• d. filmes que tenham “Action” ou “Comedy” entre os seus gêneros;

• e. filmes que tenham “Action” e “Comedy” entre os seus gêneros e tenha nota_imdb maior que 8;

• f. filmes que não possuem informação tanto de receita quanto de orçamento (isto é, possuem NA em ambas as colunas).

Para modificar uma coluna existente ou criar uma nova coluna, utilizamos a função mutate(). O código abaixo divide os valores da coluna duração por 60, mudando a unidade de medida dessa variável de minutos para horas.

imdb %>% mutate(duracao = duracao/60)

Também poderíamos ter criado essa variável em uma nova coluna. Repare que a nova coluna duracao_horas é colocada no final da tabela.

imdb %>% mutate(duracao_horas = duracao/60)

Podemos fazer qualquer operação com uma ou mais colunas. A única regra é que o resultado da operação retorne um vetor com comprimento igual ao número de linhas da base (ou com comprimento 1 para distribuir um mesmo valor em todas as linhas). Você também pode criar/modificar quantas colunas quiser dentro de um mesmo mutate.

imdb %>% mutate(lucro = receita - orcamento, pais = "Estados Unidos") %>% select(titulo, lucro, pais)

Utilize a base imdb nos exercícios a seguir.

1. Crie uma coluna chamada prejuizo (orcamento - receita) e salve a nova tabela em um objeto chamado imdb_prejuizo. Em seguida, filtre apenas os filmes que deram prejuízo e ordene a tabela por ordem crescente de prejuízo.

2. Fazendo apenas uma chamada da função mutate(), crie as seguintes colunas novas na base imdb:

• a. lucro = receita - orcamento

• b. lucro_medio

• c. lucro_relativo = (lucro - lucro_medio)/lucro_medio

• d. houve_lucro = ifelse(lucro > 0, "sim", "não")

3. Crie uma nova coluna que classifique o filme em "recente" (posterior a 2000) e "antigo" (de 2000 para trás).

Sumarização é a técnica de se resumir um conjunto de dados utilizando alguma métrica de interesse. A média, a mediana, a variância, a frequência, a proporção, por exemplo, são tipos de sumarização que trazem diferentes informações sobre uma variável.

Para sumarizar uma coluna da base, utilizamos a função summarize(). O código abaixo resume a coluna orçamento pela sua média.

imdb %>% summarize(media_orcamento = mean(orcamento, na.rm = TRUE))

Repare que a saída da função continua sendo uma tibble.

Podemos calcular diversas sumarizações diferentes em um mesmo summarize. Cada sumarização será uma coluna da nova base.

imdb %>% summarise( media_orcamento = mean(orcamento, na.rm = TRUE), mediana_orcamento = median(orcamento, na.rm = TRUE), variancia_orcamento = var(orcamento, na.rm = TRUE) )

E também sumarizar diversas colunas.

imdb %>% summarize( media_orcamento = mean(orcamento, na.rm = TRUE), media_receita = mean(receita, na.rm = TRUE), media_lucro = mean(receita - orcamento, na.rm = TRUE) )

Muitas vezes queremos sumarizar uma coluna agrupada pelas categorias de uma segunda coluna. Para isso, além do summarize, utilizamos também a função group_by().

O código a seguir calcula a receita média dos filmes para cada categoria da coluna “cor”.

imdb %>% group_by(cor) %>% summarise(receita_media = mean(receita, na.rm = TRUE))

A única alteração que a função group_by() faz na base é a marcação de que a base está agrupada.

Utilize a base imdb nos exercícios a seguir.

1. Calcule a duração média e mediana dos filmes da base.

2. Calcule o lucro médio dos filmes com duração menor que 60 minutos.

3. Apresente na mesma tabela o lucro médio dos filmes com duracao menor que 60 minutos e o lucro médio dos filmes com duracao maior ou igual a 60 minutos.

4. Retorne tabelas (tibbles) apenas com:

• a. a nota IMDB média dos filmes por tipo de classificacao;

• b. a receita média e mediana dos filmes por ano;

• c. apenas o nome dos diretores com mais de 10 filmes.

Podemos juntar duas tabelas a partir de uma (coluna) chave utilizando a função left_join(). Como exempo, vamos inicialmente calcular o lucro médio dos filmes de cada diretor e salvar no objeto tab_lucro_diretor.

tab_lucro_diretor <- imdb %>% group_by(diretor) %>% summarise(lucro_medio = mean(receita - orcamento, na.rm = TRUE)) tab_lucro_diretor

E se quisermos colocar essa informação na base original? Basta usar a função left_join() utilizando a coluna diretor como chave. Observe que a coluna lucro_medio aparece agora no fim da tabela.

imdb_com_lucro_medio <- left_join(imdb, tab_lucro_diretor, by = "diretor") imdb_com_lucro_medio

Na tabela imdb_com_lucro_medio, como na tabela imdb, cada linha continua a representar um filme diferente, mas agora temos também a informação do lucro médio do diretor de cada filme.

A primeira linha, por exemplo, traz as informações do filme Avatar. O valor do lucro_medio nessa linha representa o lucro médio de todos os filmes do James Cameron, que é o diretor de Avatar. Com essa informação, podemos calcular o quanto o lucro do Avatar se afasta do lucro médio do James Cameron.

imdb_com_lucro_medio %>% mutate( lucro = receita - orcamento, lucro_relativo = (lucro - lucro_medio)/lucro_medio, lucro_relativo = scales::percent(lucro_relativo) ) %>% select(titulo, diretor, lucro, lucro_medio, lucro_relativo)

Observamos então que o Avatar obteve um lucro aproximadamente 169% maior que a média dos filmes do James Cameron.

Além da função left_join(), também são muito utilizadas as funções right_join() e full_join().

• right_join(): retorna todas as linhas da base y e todas as colunas das bases x e y. Linhas de y sem correspondentes em x receberão NA na nova base.

• full_join(): retorna todas as linhas e colunas de xe y. Valores sem correspondência entre as bases receberão NA na nova base.

A figura a seguir esquematiza as operações dessas funções:

1. Utilize a base imdb para resolver os itens a seguir.

a. Salve em um novo objeto uma tabela com a nota média dos filmes de cada diretor. Essa tabela deve conter duas colunas (diretor e nota_imdb_media) e cada linha deve ser um diretor diferente.

b. Use o left_join() para trazer a coluna nota_imdb_media da tabela do item anterior para a tabela imdb original.

A versão 1.0 do pacote dplyr foi oficialmente lançada em junho de 2020 e contou com diversas novidades. Vamos falar das principais mudanças:

• A nova função across(), que facilita aplicar uma mesma operação em várias colunas.

• A repaginada função rowwise(), para fazer operações por linha.

• Novas funcionalidades das funções select() e rename() e a nova função relocate().

Para trabalhar essas funções, vamos utilizar a base casas do pacote dados. Para instalar esse pacote, rode os códigos abaixo:

install.packages("remotes") remotes::install_github("cienciadedatos/dados")

Para trazer os dados para o nosso environment, podemos rodar:

A base casas possui dados de venda de casas na cidade de Ames, nos Estados Unidos. São 2930 linhas e 77 colunas, sendo que cada linha corresponde a uma casa vendida e cada coluna a uma característica da casa ou da venda. Essa versão é uma tradução da base original, que pode ser encontrada no pacote AmesHousing:

install.packages("AmesHousing") data(ames_raw, package = "AmesHousing")

A função across() substitui a família de verbos _all(), _if e _at(). A ideia é facilitar a aplicação de uma operação a diversas colunas da base. Para sumarizar a base para mais de uma variável, antigamente poderíamos fazer:

casas %>% group_by(geral_qualidade) %>% summarise( lote_area_media = mean(lote_area, na.rm = TRUE), venda_valor_medio = mean(venda_valor, na.rm = TRUE) )

Ou então utilizar a função summarise_at():

casas %>% group_by(geral_qualidade) %>% summarise_at( .vars = vars(lote_area, venda_valor), list(mean), na.rm = TRUE )

Com a nova função across(), fazemos:

casas %>% group_by(geral_qualidade) %>% summarise(across( .cols = c(lote_area, venda_valor), .fns = mean, na.rm = TRUE ))

A sintaxe é parecida com a função summarise_at(), mas agora não precisamos mais usar a função vars() e nem usar list(nome_da_funcao)para definir a função aplicada nas colunas.

Usando across(), podemos facilmente aplicar uma função em todas as colunas da nossa base. Abaixo, calculamos o número de valores distintos para todas as variáveis da base casas. O padrão do parâmetro .cols é everything(), que representa “todas as colunas”.

casas %>% summarise(across(.fns = n_distinct))

Para fazer essa mesma operação, antes utilizaríamos a função summarise_all().

casas %>% summarise_all(.funs = ~n_distinct(.x))

Se quisermos selecionar as colunas a serem modificadas a partir de um teste lógico, utilizamos o ajudante where().

No exemplo abaixo, calculamos o número de valores distintos das colunas de categóricas.

casas %>% summarise(across(where(is.character), n_distinct))

Todas as colunas da base resultante eram colunas com classe character na base casas.

Anteriormente, utilizávamos a função summarise_if().

casas %>% summarise_if(is.character, n_distinct)

Com o across(), podemos combinar os efeitos de um summarise_if() e um summarise_at() em um único summarise(). A seguir, calculamos as áreas médias, garantindo que pegamos apenas variáveis numéricas.

casas %>% summarise(across(where(is.numeric) & contains("_area"), mean, na.rm = TRUE))

Além disso, com a função across(), podemos fazer sumarizações complexas que não seria possível utilizando apenas as funções summarise(), summarise_if() e summarise_at(). No exemplo a seguir, calculamos a média das áreas, o número de NAs de variáveis categóricas e o número de casas para cada tipo de fundação. Tudo em um mesmo summarise()!

casas %>% group_by(fundacao_tipo) %>% summarise( across(where(is.numeric) & contains("area"), mean, na.rm = TRUE), across(where(is.character), ~sum(is.na(.x))), n_obs = n(), ) %>% select(1:4, n_obs)

Embora a nova sintaxe, usando across(), não seja muito diferente do que fazíamos antes, realizar sumarizações complexas não é a única vantagem desse novo framework.

O across() pode ser utilizado em todos os verbos do {dplyr} (com exceção do select() e rename(), já que ele não trás vantagens com relação ao que já podia ser feito) e isso unifica o modo de fazermos essas operações no dplyr. Em vez de termos uma família de funções para cada verbo, temos agora apenas o próprio verbo e a função across().

Vamos ver um exemplo para o mutate() e para o filter().

O código abaixo transforma todas as variáveis que possuem “area” no nome, passando os valores de pés quadrados para metros quadrados.

casas %>% mutate(across( contains("area"), ~ .x / 10.764 ))

Já o código a seguir filtra apenas as casas que possuem varanda aberta, cerca e lareira (o NA nessa base significa que a casa não possui tal característica).

casas %>% filter(across( c(varanda_aberta_area, cerca_qualidade, lareira_qualidade), ~!is.na(.x) ))

Não precisamos do across() na hora de selecionar colunas. A função select() já usa naturalmente o mecanismo de seleção de colunas que o across() proporciona.

casas %>% select(where(is.numeric))

O mesmo vale para o rename(). Se quisermos renomer várias colunas, a partir de uma função, utilizamos o rename_with().

casas %>% rename_with(toupper, contains("venda"))

O {dplyr} possui agora uma função própria para reorganizar colunas: relocate(). Por padrão, ela coloca uma ou mais colunas no começo da base.

casas %>% relocate(venda_valor, venda_tipo)

Podemos usar os argumentos .after e .before para fazer mudanças mais complexas.

O código baixo coloca a coluna venda_ano depois da coluna construcao_ano.

casas %>% relocate(venda_ano, .after = construcao_ano)

O código baixo coloca a coluna venda_ano antes da coluna construcao_ano.

casas %>% relocate(venda_ano, .before = construcao_ano)

Por fim, vamos discutir operações feitas por linha. Tome como exemplo a tabela abaixo. Ela apresenta as notas de alunos em quatro provas.

tab_notas <- tibble( student_id = 1:5, prova1 = sample(0:10, 5), prova2 = sample(0:10, 5), prova3 = sample(0:10, 5), prova4 = sample(0:10, 5) ) tab_notas

Se quisermos gerar uma coluna com a nota média de cada aluno nas quatro provas, não poderíamos usar o mutate() diretamente.

tab_notas %>% mutate(media = mean(c(prova1, prova2, prova3, prova4)))

Neste caso, todas as colunas estão sendo empilhadas e gerando uma única média, passada a todas as linhas da coluna media.

Para fazermos a conta para cada aluno, podemos agrupar por aluno. Agora sim a média é calculada apenas nas notas de cada estudante.

tab_notas %>% group_by(student_id) %>% mutate(media = mean(c(prova1, prova2, prova3, prova4)))

Também podemos nos aproveitar da sintaxe do across() neste caso. Para isso, precisamos substutir a função c() pela função c_across().

tab_notas %>% group_by(student_id) %>% mutate(media = mean(c_across(starts_with("prova"))))

Equivalentemente ao group_by(), neste caso, podemos usar a função rowwise().

tab_notas %>% rowwise(student_id) %>% mutate(media = mean(c_across(starts_with("prova"))))

Ela é muito útil quando queremos fazer operação por linhas, mas não temos uma coluna de identificação. Por padrão, se não indicarmos nenhuma coluna, cada linha será um “grupo”.

tab_notas %>% rowwise() %>% mutate(media = mean(c_across(starts_with("prova"))))

Veja que student_id não é passada para a função rowwise(). Não precisaríamos dessa coluna na base para reproduzir a geração da columa media neste caso.

A base casas abaixo pode ser encontrada a partir do código abaixo:

remotes::install_github("cienciadedatos/dados") dados::casas

1. Reescreva os códigos abaixo utilizando as funções across() e where().

a.

casas %>% group_by(geral_qualidade) %>% summarise( acima_solo_area_media = mean(acima_solo_area, na.rm = TRUE), garagem_area_media = mean(garagem_area, na.rm = TRUE), valor_venda_medio = mean(venda_valor, na.rm = TRUE) )

b.

casas %>% filter_at( vars(porao_qualidade, varanda_fechada_area, cerca_qualidade), ~!is.na(.x) )

c.

casas %>% mutate_if(is.character, ~tidyr::replace_na(.x, replace = "Não possui"))

2. Utilizando a base casas, resolva os itens a seguir.

• a. Usando o case_when() crie um código para categorizar a variável venda_valor da seguinte maneira:

  • barata: $0 a $129.500
    
  • preço mediano: $129.500 a $180.796
  • cara: $ 180.796 a $213.500
  • muito cara: maior que $213.500

• b. Utilize o código feito na letra (a) para agrupar a base casas pela variável venda_valor categorizada e calcular todas as áreas médias para cada uma dessas categorias.

3. Escreva um código que receba a base casas e retorne uma tabela com apenas

• a. as colunas referentes à garagem da casa.

• b. as colunas referentes a variáveis de qualidade.

• c. colunas numéricas que representam áreas da casa e do terreno.

• d. colunas numéricas.

• e. colunas referentes à piscina, porão e o valor de venda.

4. Usando a função rename_with(), troque todos os "_" dos nomes das colunas por um espaço " ".

5. Escreva um código para colocar todas as colunas relativas a venda no começo da base casas.

6. 5. Escreva um código para colocar todas as colunas numéricas da base casas no começo da tabela e todas as colunas categóricas no final.

Dentro do tidyverse, uma base tidy é uma base fácil de se trabalhar, isto é, fácil de se fazer manipulação de dados, fácil de se criar visualizações, fácil de se ajustar modelos e por aí vai.

Na prática, uma base tidy é aquela que se encaixa bem no framework do tidyverse, pois os pacotes como o dplyr e o ggplot2 foram desenvolvidos para funcionar bem com bases tidy. E assim como esses pacotes motivaram o uso de bases tidy, o conceito tidy motiva o surgimento de novos frameworks, como o tidymodels para modelagem.

As duas propriedades mais importantes de uma base tidy são:

• cada coluna é uma variável;

• cada linha é uma observação.

Essa definição proporciona uma maneira consistente de se referir a variáveis (nomes de colunas) e observações (índices das linhas).

O pacote {tidyr} possui funções que nos ajudam a transformar uma base bagunçada em uma base tidy. Ou então, nos ajudam a bagunçar um pouquinho a nossa base quando isso nos ajudar a produzir o resultados que queremos.

Vamos ver aqui algumas de suas principais funções:

• separate() e unite(): para separar variáveis concatenadas em uma única coluna ou uni-las.

• pivot_wider() e pivot_longer(): para pivotar a base.

• nest() e unnest(): para criar list columns.

Como motivação para utilizar esssas funções, vamos utilizar a nossa boa e velha base imdb. Essa base pode ser baixada clicando aqui.

library(dplyr) library(tidyr) library(ggplot2) imdb <- readr::read_rds("imdb.rds")

A função separate() separa duas ou mais variáveis que estão concatenadas em uma mesma coluna. A sintaxe da função está apresentada abaixo.

dados %>% separate( col = coluna_velha, into = c("colunas", "novas"), sep = "separador" )

Como exemplo, vamos transformar a coluna generos da base IMDB em três colunas, cada uma com um dos gêneros do filme. Lembrando que os valores da coluna generos estão no seguinte formato:

imdb %>% pull(generos) %>% head()

Veja que agora, temos 3 colunas de gênero. Filmes com menos de 3 gêneros recebem NA na coluna genero2 e/ou genero3. Os gêneros sobressalentes são descartados, assim como a coluna generos original.

imdb %>% separate( col = generos, into = c("genero1", "genero2", "genero3"), sep = "\\|" )

A função unite() realiza a operação inversa da função separate(). Ela concatena os valores de várias variáveis em uma única coluna. A sintaxe é a seguinte:

dados %>% unite( col = coluna_nova, colunas_para_juntar, sep = "separador" )

Como exemplo, vamos agora transformar as colunas ator1, ator2 e ator3 em uma única coluna atores. Lembrando que essas colunas estão no formato abaixo.

imdb %>% select(starts_with("ator")) %>% head(3)

Veja que agora a coluna atores possui os 3 atores concatenados. Se a ordem das colunas ator1, ator2 e ator3 nos trazia a informação de protagonismo, essa informação passa a ficar implícita nesse novo formato. As 3 colunas originais são removidas da base resultante.

imdb %>% unite( col = "elenco", starts_with("ator"), sep = " - " ) %>% select(elenco)

O conceito de pivotagem no tidyverse se refere a mudança da estrutura da base, geralmente para alcançar o formato tidy.

Geralmente realizamos pivotagem quando nossas linhas não são unidades observacionais ou nossas colunas não são variáveis. Ela é similiar à pivotagem do Excel, mas um pouco mais complexa.

O ato de pivotar resulta em transformar uma base de dados long em wide e vice-versa.

Uma base no formato long possui mais linhas e pode ter menos colunas, enquanto no formato wide poussi menos linhas e pode ter mais colunas

Esses formatos são sempre relativos às colunas que estão sendo pivotadas, sendo que uma base tidy pode estar tanto no formato long quanto wide.

Antigamente, utilizávamos as funções gather() e spread() para fazer as operações de pivotagem.

Agora, no lugar de gather(), utilizamos a função pivot_longer(). Abaixo, transformamos as colunas ator1, ator2 e ator3 em duas colunas: ator_atriz e protagonismo.

imdb %>% pivot_longer( cols = starts_with("ator"), names_to = "protagonismo", values_to = "ator_atriz" ) %>% select(titulo, ator_atriz, protagonismo) %>% head(6)

Se considerarmos que na análise da base IMDB cada observação deve ser um filme, então essa nova base já não mais tidy, pois agora cada filme aparece em três linhas diferentes, uma vez para cada um de seus atores.

Nesse sentido, embora possa parecer que a variável protagonismo estava implícita na base original, ela não é uma variável de fato. Todos filmes têm um ator_1, um ator_2 e um ator_3. Não existe nenhuma informação sobre o filme que podemos tirar da coluna protagonismo, pois ela qualifica apenas os atores, não o filme em si.

A função pivot_wider() faz a operação inversa da pivot_longer(). Se aplicarmos as duas funções em sequência, voltamos para a base original.

imdb %>% pivot_longer( cols = starts_with("ator"), names_to = "ator_protagonismo", values_to = "ator_nome" ) %>% pivot_wider( names_from = "ator_protagonismo", values_from = "ator_nome" ) %>% head(4)

A base imdb não possui nenhuma variável que faça sentido aplicarmos diretamente a função pivot_wider(). Vamos então considerar a seguinte tabela derivada da base imdb:

tab_romance_terror <- imdb %>% filter(ano >= 2010) %>% mutate( genero = case_when( stringr::str_detect(generos, "Romance") ~ "Romance", stringr::str_detect(generos, "Horror") ~ "Horror", TRUE ~ NA_character_ ) ) %>% filter(!is.na(genero)) %>% group_by(ano, genero) %>% summarise(receita_media = mean(receita, na.rm = TRUE))

Essa tabela possui a receita média dos filmes de romance e terror nos anos de 2010 a 2016.

Para apresentar essa tabela em uma reunião, por exemplo, pode ficar ser mais agradável ter os anos nas colunas e não nas linhas. Para isso, basta utilizarmos a função pivot_wider().

# Tabela original tab_romance_terror

# Tabela com os anos nas colunas tab_romance_terror %>% pivot_wider( names_from = ano, values_from = receita_media )

Esse é um caso que bagunçar um pouquinho a tabela nos trouxe um resultado desejado.

Um terceiro conceito de dados tidy é que cada célula da tabela possui um valor. No entanto, quando estamos programando, muitas vezes vale apena abandonar essa definição e guardarmos objetos mais complexos nas células de uma tabela.

Utilizando as chamadas list columns podemos guardar virtualmente qualquer objeto em nossas tibbles, como gráficos, resultados de modelos ou até mesmo outras tabelas.

Uma forma de trabalhar com list columns consiste em utilizarmos as funções

• nest(): para criar uma list column;

• unnest(): para desfazer uma list column.

A forma mais simples de utilizarmos uma list column é aninhar a nossa base com relação a uma variável.

imdb_nest <- imdb %>% group_by(ano) %>% nest() %>% arrange(ano) head(imdb_nest, 8)

A base imdb_nest possui duas colunas ano e data e uma linha para cada ano. Na coluna data, temos o restante da base imdb, recortada para cada um dos anos.

Abaixo, acessmos os dados do único filme de 1916 (primeira linha da base imdb_nest).

Imagine que queiramos fazer, para cada ano, um gráfico de dispersão da receita contra o orçamento dos filmes lançados no ano.

Com a base no formato de list columns, basta criarmos uma função para gerar o gráfico e utilizarmos a função purrr::map().

Abaixo, construímos a função fazer_grafico_dispersao(), que será aplicada a cada uma das bases contidas na coluna data da base imdb_nest. Os gráficos, respectivamos a cada ano, são salvos na coluna grafico.

fazer_grafico_dispersao <- function(tab) { tab %>% ggplot(aes(x = orcamento, y = receita)) + geom_point() } imdb_graficos <- imdb_nest %>% mutate( grafico = purrr::map(data, fazer_grafico_dispersao) ) head(imdb_graficos, 6)

Para acessar cada um dos gráficos, basta rodar o código abaixo.

# Pegando o gráfico referente ao ano de 2000 imdb_graficos$grafico[[74]]

Ou, escolhendo diretamente pelo ano

imdb_graficos %>% filter(ano == 2000) %>% pull(grafico)

A função unnest() remove a estrutura de list column. Fazendo a operação abaixo, voltamos para a base imdb original.

imdb_nest %>% unnest(cols = "data")

1. Crie 5 novas colunas de gêneros na base imdb, cada uma com um dos gêneros contidos na coluna generos. Para os filmes com menos de 5 gêneros, substitua os valores NA pela string “inexistente”.

2. Substitua os “????” no código abaixo para criar uma tabela do lucro médio dos filmes ao longo dos anos de 2000 a 2016, com cada ano sendo uma coluna da base.

imdb %>% mutate(lucro = receita - orcamento) %>% filter(ano %in% "????") %>% group_by("????") %>% summarise(lucro_medio = "????") %>% pivot_wider(names_from = "????", values_from = "????")

Para os exercícios 3, 4 e 5, vamos utilize a base pokemon, disponível no pacote basesCursoR.

install.packages("remotes") remotes::install_github("curso-r/basesCursoR")

3. Utilize a função unite() para juntar as duas colunas de tipo em uma única coluna na base pokemon.

4. Utilize a função unite() para juntar as três colunas de cor em uma única coluna na base pokemon. Faça isso sem remover as 3 colunas originais.

5. Utilizando a base pokemon, resolva os itens abaixo:

a. Utilize a função pivot_longer() para criar uma única coluna de tipo na base pokemon.

b. Utilize a base criada no item (a) e escreva um código para descobrir qual o tipo mais frequente na base, independentemente se ele é primário (tipo_1) ou secundário (tipo_2).

6. Escreva uma função que receba uma base qualquer e o nome de uma coluna numérica dessa base e retorne uma figura com um gráfico de dispersão da coluna escolhida contra cada uma das outras variáveis numéricas da base.

Variáveis de texto são muito comuns nos bancos de dados e, geralmente, dão bastante trabalho para serem manipuladas. É muito comum encontrarmos colunas com categorias não padronizadas, como, por exemplo, uma variável Estado com “SP”, “sp”, “Sao Paulo”, “São Paulo” etc, todas indicando o mesmo estado.

O R possui várias funções para manipular textos (ou strings). No entanto, as funções do base não possuem uma interface consistente e cada uma tem a sua forma de passar os parâmetros, dificultando a programação durante a análise.

Pensando nisso, Hadley Wickham deu aquela força para a comunidade R e criou o pacote stringr, que possui uma sintaxe consistente, permitindo a manipulação de textos com muito mais facilidade.

• Sintaxe unificada, o que auxilia na memorização das funções e leitura do código.

• Todas as funções são vetorizadas.

• Construído sobre a biblioteca ICU, implementada em C e C++, uma garantia de resultados mais rápidos.

• As funções de manipulação de texto começam com str_. Caso esqueça o nome de uma função, basta digitar stringr::str_ e apertar TAB para ver quais são as opções.

• O primeiro argumento da função é sempre uma string ou um vetor de strings.

Inicialmente, o stringr era um wrapper de funções do base. Depois disso, surgiu um novo pacote stringi, com sintaxe similar ao stringr, mas funcionando como wrapper da biblioteca ICU. Wickham gostou tanto do pacote stringi que decidiu reescrever o stringr como um wrapper do stringi.

Veja essa página para detalhes.

Todas as funções do stringr começam com o prefixo str_. Isso ajuda na hora de encontrar a função que você está procurando. No RStudio, digite str_ e aperte TAB para visualizar a lista de funções com esse prefixo. Você pode verificar o que cada função faz até encontrar a que atende às suas necessidades.

Na próxima seção, vamos apresentar as funções mais simples do {stringr}. Em seguida, vamos falar um pouco de expressões regulares (regex) e então veremos funções mais avançadas do pacote, que utilizam regex para identificar padrões.

Antes de mais nada, instale e carregue o pacote stringr.

install.packages("stringr")

A seguir, apresentamos as funções mais simples do {stringr}, que não utilizam o conceito de expressões regulares.

A função mais simples do stringr() é a função str_length(). Esta função recebe como argumento um vetor de strings e retorna o número de caracteres de cada string. Repare que o espaço " " é considerado um caractere.

str_length("São Paulo") ## [1] 9 str_length(c("São Paulo", "Rio de Janeiro", "Rio Grande do Norte", "Acre")) ## [1] 9 14 19 4

Note que str_length() é diferente de length(). O primeiro retorna o número de caracteres e o segundo retorna o comprimento do objeto. Isso fica mais claro no seguinte exemplo:

s <- c("São Paulo", "Rio de Janeiro", "Rio Grande do Norte", "Acre") str_length(s) ## [1] 9 14 19 4 length(s) ## [1] 4

A função str_length() retornou um vetor com o número de caracteres de cada elemento do vetor s, enquanto length() retornou o comprimento do vetor s.

Essas funções servem para modificar a caixa das letras. Veja alguns exemplos:

s <- "Somos a curso-r" str_to_lower(s) ## [1] "somos a curso-r" str_to_upper(s) ## [1] "SOMOS A CURSO-R" str_to_title(s) ## [1] "Somos A Curso-R"

É muito comum encontrar textos que vêm com espaços a mais, principalmente de dados provenientes de formulários em que cada usuário escreve da forma que prefere. Isso é um problema pois cria categorias diferentes para valores que deveriam ser iguais. Espaços antes e após o texto são especialmente chatos, pois pode ser difícil detectá-los.

s <- c("M", "F", "F", " M", " F ", "M") as.factor(s) ## [1] M F F M F M ## Levels: F M F M

A função str_trim() ajuda removendo os espaços excedentes antes e depois da string.

string_aparada <- str_trim(s) as.factor(string_aparada) ## [1] M F F M F M ## Levels: F M

Não é raro você precisar obter uma parte fixa de uma string, como, por exemplo, manipular textos da forma:

s <- c("01-Feminino", "02-Masculino", "03-Indefinido")

Você pode querer apenas a parte final da string. Neste caso, pode usar a função str_sub().

# pegar do quarto até o último caractere str_sub(s, start = 4) ## [1] "Feminino" "Masculino" "Indefinido"

Também é possível obter apenas os números.

# pegar apenas os dois primeiros caracteres str_sub(s, end = 2) ## [1] "01" "02" "03"

Em outros casos você precisa obter os últimos 2 caracteres.

s <- c("Feminino-01", "Masculino-02", "Indefinido-03") str_sub(s, end = -4) ## [1] "Feminino" "Masculino" "Indefinido" str_sub(s, start = -2) ## [1] "01" "02" "03"

É possível usar os argumentos start e end conjuntamente.

s <- c("__SP__", "__MG__", "__RJ__") str_sub(s, 3, 4) ## [1] "SP" "MG" "RJ"

Análoga à função paste0() do R base, concatena strings em uma única string.

string1 <- "O valor p é: " string2 <- 0.03 str_c(string1, string2) ## [1] "O valor p é: 0.03"

Além disso, essa função:

• Pode misturar objetos com strings definidas diretamente na função.

string1 <- "Brigadeiro" string2 <- "bom" string3 <- "melhor" str_c(string1, " é a prova de que não existe nada tão ", string2, " que não possa ficar ", string3, ".") ## [1] "Brigadeiro é a prova de que não existe nada tão bom que não possa ficar melhor."

string1 <- c("Brigadeiro", "A política brasileira") string2 <- c("bom", "ruim") string3 <- c("melhor", "pior") str_c(string1, " é a prova de que não existe nada tão ", string2, " que não possa ficar ", string3, ".") ## [1] "Brigadeiro é a prova de que não existe nada tão bom que não possa ficar melhor." ## [2] "A política brasileira é a prova de que não existe nada tão ruim que não possa ficar pior."

Essas são as funções mais simples do pacote stringr e não exigem nenhum conhecimento de expressões regulares. Note que nenhuma delas possui o parâmetro pattern. Você verá como especificar esse parâmetro nas próximas seções.

Trabalhar com textos exige um certo conhecimento de expressões regulares. As expressões regulares — ou simplesmente regex — permitem identificar conjuntos de caracteres, palavras e outros padrões por meio de uma sintaxe concisa.

O stringr utiliza regex da forma descrita neste documento. A própria definição de regex do R é um ótimo manual.

Vamos estudar expressões regulares por meio de exemplos e da função str_detect(). Ela retorna TRUE se uma string atende a uma expressão regular e FALSE caso contrário. Por exemplo:

str_detect("sao paulo", pattern = "paulo$") ## [1] TRUE str_detect("sao paulo sp", pattern = "paulo$") ## [1] FALSE

A regex/pattern “paulo$” indica que o texto deve ser terminado em “paulo”. Existem diversos caracteres auxiliares que vão auxiliar na manipulação dos textos, assim como o “$”.

Importante: o valor passado para o argumento pattern de qualquer função do pacote stringr será entendido como uma regex.

A tabela abaixo mostra a aplicação de cinco regex em seis strings distintas.

• ‘^ban’ reconhece apenas o que começa exatamente com “ban”.

• ‘b ?an’ reconhece tudo que tenha “ban”, com ou sem espaço entre o “b” e o “a”.

• ‘ban’ reconhece tudo que tenha “ban”, apenas minúsculo.

• BAN’ reconhece tudo que tenha “BAN”, apenas maiúsculo.

• ‘ban$’ reconhece apenas o que termina exatamente em “ban”

Os caracteres +, * e {x,y} indicam quantas vezes um padrão se repete:

• ey+ significa e e depois y “uma vez ou mais”. Por exemplo, reconhece hey, heyy, a eyyy, mas não reconhece e, y nem yy.

• ey* significa “nenhuma vez ou mais”. Por exemplo, reconhece hey, heyy, a eyyy e e, mas não reconhece y nem yy.

• ey{3} significa “exatamente três vezes”. Por exemplo, reconhece eyyy e eyyyy, mas não reconhece eyy.

• ey{1,3} significa “entre uma e três vezes”.

Para aplicar um quantificador a um conjunto de caracteres, use parênteses. Por exemplo, (ey )+ reconhece ey ey.

Colocando caracteres dentro de [], reconhecemos quaisquer caracteres desse conjunto. Alguns exemplos práticos:

• [Cc]asa para reconhecer “casa” em maiúsculo ou minúsculo.

• [0-9] para reconhecer somente números. O mesmo vale para letras [a-z], [A-Z], [a-zA-Z] etc.

• O símbolo ^ dentro do colchete significa negação. Por exemplo, [^0-9] significa pegar tudo o que não é número.

• O símbolo . fora do colchete indica “qualquer caractere”, mas dentro do colchete é apenas ponto.

• Use [[:space:]]+ para reconhecer espaços e [[:punct:]]+ para reconhecer pontuações.

• Use abjutils::rm_accent() para retirar os acentos de um texto.

• Use | para opções. Por exemplo, desfavor|desprov reconhece tanto “desfavorável” quanto “desprovido”.

• O código \n pula linha, \f é final da página, \t é tab. Use \ para transformar caracteres especiais em literais.

A lista de possibilidades com expressões regulares é extensa. Um bom lugar para testar o funcionamento das regex é o regex101.

Agora que já vimos as funções básicas do stringr e aprendemos um pouco de regex, vamos às funções mais avançadas. Basicamente, essas funções buscarão patterns em um vetor de strings e farão alguma coisa quando encontrá-lo.

Como já vimos na seção sobre regex, a função mais simples que possui o argumento pattern= é a str_detect().

Retorna TRUE se a regex é compatível com a string e FALSE caso contrário.

library(stringr) str_detect("sao paulo", pattern = "paulo$") ## [1] TRUE str_detect("sao paulo sp", pattern = "paulo$") ## [1] FALSE

Substituem um padrão (ou todos) encontrado por um outro padrão.

Substituindo apenas a primeira ocorrência:

cidades <- c("S. José do Rio Preto", "São Paulo", "S. José dos Campos", "São Roque", "S. S. da Grama") str_replace(cidades, "S[.]", "São") ## [1] "São José do Rio Preto" "São Paulo" "São José dos Campos" ## [4] "São Roque" "São S. da Grama"

Veja que no exemplo anterior precisamos colocar o . entre colchetes. Se não tivéssemos colocado, ele seria interpretado como uma regex e o padrão procurado seria “S” seguido de qualquer caracter:

cidades <- c("S. José do Rio Preto", "São Paulo", "S. José dos Campos", "São Roque", "S. S. da Grama") str_replace(cidades, "S.", "São") ## [1] "São José do Rio Preto" "Sãoo Paulo" "São José dos Campos" ## [4] "Sãoo Roque" "São S. da Grama"

Nesses casos, podemos usar a função fixed() para indicar que o padrão procurado não é uma regex:

cidades <- c("S. José do Rio Preto", "São Paulo", "S. José dos Campos", "São Roque", "S. S. da Grama") str_replace(cidades, fixed("S."), "São") ## [1] "São José do Rio Preto" "São Paulo" "São José dos Campos" ## [4] "São Roque" "São S. da Grama"

A função str_replace() substitui apenas a primeira ocorrência encontrada. No exemplo anterior, apenas o primeiro “S.” era substituído por “São”. Se quisermos substituir todas as ocorrências de um padrão dentro de uma string, utilizamos a função str_replace_all().

No exemplo abaixo, substituímos todas as ocorrências de . e - por um espaço.

cpf <- c("303.030.111-33", "102-177-011-20", "987.220.199.00") str_replace_all(cpf, "[.-]", " ") ## [1] "303 030 111 33" "102 177 011 20" "987 220 199 00"

Essas funções separam uma string em várias de acordo com um separador.

texto <- 'Durante um longo período de tempo o "R" foi escrito "P" como no alfabeto cirílico. O seu nome no alfabeto fenício era "rech". Seu significado era o de uma cabeça, representada pela adaptação do hieróglifo egípcio de uma cabeça. Transformou-se no "rô" dos gregos. Os romanos modificaram o rô acrescentando um pequeno traço para diferenciá-lo do no nosso P.' str_split(texto, fixed('.')) ## [[1]] ## [1] "Durante um longo período de tempo o \"R\" foi escrito \"P\" como no alfabeto cirílico" ## [2] " O seu nome no alfabeto fenício era \"rech\"" ## [3] " Seu significado era o de uma cabeça, representada pela adaptação do hieróglifo egípcio de uma cabeça" ## [4] " Transformou-se no \"rô\" dos gregos" ## [5] " Os romanos modificaram o rô acrescentando um pequeno traço para diferenciá-lo do no nosso P" ## [6] ""

O str_split_fixed faz o mesmo que str_split(), mas separa apenas n vezes.

str_split_fixed(texto, fixed('.'), 3) ## [,1] ## [1,] "Durante um longo período de tempo o \"R\" foi escrito \"P\" como no alfabeto cirílico" ## [,2] ## [1,] " O seu nome no alfabeto fenício era \"rech\"" ## [,3] ## [1,] " Seu significado era o de uma cabeça, representada pela adaptação do hieróglifo egípcio de uma cabeça. Transformou-se no \"rô\" dos gregos. Os romanos modificaram o rô acrescentando um pequeno traço para diferenciá-lo do no nosso P."

1. O CPF é um número de 11 dígitos, por exemplo: 54491651884. No entanto para facilitar a visualização costumamos mostrá-lo com separadores a cada 3 casas: 544.916.518-84. Crie uma função que transforma um número de 11 dígitos em uma string com as separações, como um CPF.

2. Transforme o vetor de strings abaixo em "01 - Alto" "02 - Médio" "03 - Baixo".

s <- c('Alto', 'Médio', 'Baixo')

3. Crie uma regex que capture múltiplas versões da palavra ‘casa’. Ela deve funcionar com as palavras ‘Casa’, ‘CASA’, ‘CaSa’, ‘CAsa’. Teste-a usando a função str_detect().

s <- c('Casa', 'CASA', 'CaSa', 'CAsa')

4. Imagine que a seguinte string é a parte final de uma URL.

• /ac/rio-branco/xpto-xyz-1-0-1fds2396-5

Transforme-a em “AC - Rio Branco” utilizando funções do pacote {stringr}.

url <- c('/ac/rio-branco/xpto-xyz-1-0-1fds2396-5')

5. Crie uma função que retorna TRUE quando a string é um palíndromo e FALSO caso não seja.

6. De acordo com as regras da língua portuguesa, antes de “p” ou “b” devemos usar a letra “m”. Em outras palavras, com outras consoantes, usamos a letra “N”. Suponha que você tem o seguinte texto com erros gramaticais:

texto <- 'Nós chamamos os bonbeiros quando começou o incêmdio.'

Crie uma função para corrigi-lo.

7. Considere o seguinte texto

txt <- "A função mais importante para leitura de dados no `lubridate` é a `ymd`. Essa função serve para ler qualquer data de uma `string` no formato `YYYY-MM-DD`. Essa função é útil pois funciona com qualquer separador entre os elementos da data e também porque temos uma função para cada formato (`mdy`, `dmy`, `dym`, `myd`, `ydm`)."

Extraia todas as combinações da função ymd, sem repetições.

8. Considere as frases abaixo

s <- c( 'O produto é muito bom.', 'O produto não é bom.', 'O produto não é muito bom.', 'O produto não é ruim.', 'O produto não é não bom.' )

Crie uma regra para identificar se o texto refere-se a um feedback positivo ou negativo sobre o produto (considere “não bom = ruim” e “não ruim = bom”). Retorne um vetor lógico que vale TRUE se o feedback é positivo e FALSE caso contrário.

Trabalhar com datas no R era uma chateação. As funções do R base são, em grande parte, contraintuitivas e podem mudar de acordo com o tipo do objeto que você está usando (data, hora, data/hora). Além disso, características como fusos horários, anos bissextos, horários de verão, entre outras, podem não estar bem especificadas ou nem mesmo sendo levadas em conta.

O pacote {lubridate}, criado por Garrett Grolemund e Hadley Wickham, surgiu para lidar com esses problemas, fazendo o trabalho com datas ser muito mais fácil.

Antes de começar a usar, você precisa instalar e carregar o pacote.

install.packages("lubridate") library(lubridate)

Nesta seção, falaremos sobre:

• transformar e extrair datas;
• algumas funções úteis para trabalhar com datas;
• trabalhar com fusos horários; e
• operações aritméticas com datas.

Datas no R são tratadas como um tipo especial de objeto, com classe date. Há várias formas de criar objetos dessa classe com o pacote {lubridate}:

data_string <- "21-10-2015" class(data_string) ## [1] "character" data_date <- date(data_string) class(data_date) ## [1] "Date" data_date ## [1] "0021-10-20" data_as_date <- as_date(data_string) ## Warning: All formats failed to parse. No formats found. class(data_as_date) ## [1] "Date" data_as_date ## [1] NA data_mdy <- dmy(data_string) class(data_mdy) ## [1] "Date" data_mdy ## [1] "2015-10-21"

Veja que as funções date() e as_date() converteram a string para data, mas não devolveram o valor esperado. A função dmy() resolve esse problema estabelecendo explicitamente a ordem dia-mês-ano. Existem funções para todas as ordens possíveis: dmy(), mdy(), myd(), ymd(), ydm() etc.

As funções date() e as_date() assumem que a ordem segue o padrão da língua inglesa: ano-mês-dia (ymd).

date("2015-10-21") ## [1] "2015-10-21" as_date("2015-10-21") ## [1] "2015-10-21"

Uma grande facilidade que essas funções trazem é poder criar objetos com classe date a partir de números e strings em diversos formatos.

dmy(21102015) ## [1] "2015-10-21" dmy("21102015") ## [1] "2015-10-21" dmy("21/10/2015") ## [1] "2015-10-21" dmy("21.10.2015") ## [1] "2015-10-21"

Se além da data você precisar especificar o horário, basta usar as funções do tipo ymd_h(), ymd_hm(), ymd_hms(), sendo que também há uma função para cada formato de dia-mês-ano.

ymd_hms(20151021165411) ## [1] "2015-10-21 16:54:11 UTC"

No R base, utilizamos a função as.Date() para transformar uma string em data:

data_base <- as.Date("2015-10-21") class(data_base) ## [1] "Date" data_base ## [1] "2015-10-21"

Repare que a função date() do R base retorna a data e horário no momento da execução:

base::date() ## [1] "Thu Mar 10 13:10:15 2022"

O lubridate traz diversas funções para extrair os componentes de um objeto da classe date.

• second() - extrai os segundos.
• minute() - extrai os minutos.
• hour() - extrai a hora.
• wday() - extrai o dia da semana.
• mday() - extrai o dia do mês.
• month() - extrai o mês.
• year() - extrai o ano.

bday <- ymd_hms("1989-07-29 030142") bday ## [1] "1989-07-29 03:01:42 UTC" second(bday) ## [1] 42 day(bday) ## [1] 29 month(bday) ## [1] 7 year(bday) ## [1] 1989 wday(bday) ## [1] 7 wday(bday, label = TRUE) ## [1] Sat ## Levels: Sun < Mon < Tue < Wed < Thu < Fri < Sat

Você também pode usar essas funções para atribuir esses componentes a uma data:

data <- dmy("01/04/1991") data ## [1] "1991-04-01" hour(data) <- 20 data ## [1] "1991-04-01 20:00:00 UTC"

Também existem funções para extrair a data no instante da execução.

# Data e horário do dia em que essa página foi editada pela última vez. today() ## [1] "2022-03-10" now() ## [1] "2022-03-10 13:10:15 -03"

Uma característica inerente das datas é o fuso horário. Se você estiver trabalhando com datas de eventos no Brasil e na Escócia, por exemplo, é preciso verificar se os valores seguem o mesmo fuso horário. Além disso, quando a data exata de um evento for relevante, você pode precisar converter horários para outros fusos para comunicar seus resultados em outros países.

Para fazer essas coisas, o lubridate fornece as funções with_tz() e force_tz(). Veja um exemplo de como usá-las.

estreia_GoT <- ymd_hms("2017-07-16 22:00:00", tz = "America/Sao_Paulo") estreia_GoT ## [1] "2017-07-16 22:00:00 -03" # Devolve qual seria a data em outro fuso with_tz(estreia_GoT, tzone = "GMT") ## [1] "2017-07-17 01:00:00 GMT" with_tz(estreia_GoT, tzone = "US/Alaska") ## [1] "2017-07-16 17:00:00 AKDT" # Altera o fuso sem mudar a hora force_tz(estreia_GoT, tzone = "GMT") ## [1] "2017-07-16 22:00:00 GMT"

Nos exercícios a seguir, vamos utilizar a base lakers (do pacote lubridate), que contém estatísticas jogo a jogo do Los Angeles Lakers na temporada 2008-2009.

lakers %>% as_tibble() ## # A tibble: 34,624 × 13 ## date opponent game_type time period etype team player result points type ## <int> <chr> <chr> <chr> <int> <chr> <chr> <chr> <chr> <int> <chr> ## 1 2.01e7 POR home 12:00 1 jump… OFF "" "" 0 "" ## 2 2.01e7 POR home 11:39 1 shot LAL "Pau … "miss… 0 "hoo… ## 3 2.01e7 POR home 11:37 1 rebo… LAL "Vlad… "" 0 "off" ## 4 2.01e7 POR home 11:25 1 shot LAL "Dere… "miss… 0 "lay… ## 5 2.01e7 POR home 11:23 1 rebo… LAL "Pau … "" 0 "off" ## 6 2.01e7 POR home 11:22 1 shot LAL "Pau … "made" 2 "hoo… ## 7 2.01e7 POR home 11:22 1 foul POR "Greg… "" 0 "sho… ## 8 2.01e7 POR home 11:22 1 free… LAL "Pau … "made" 1 "" ## 9 2.01e7 POR home 11:00 1 foul LAL "Vlad… "" 0 "per… ## 10 2.01e7 POR home 10:53 1 shot POR "LaMa… "made" 2 "jum… ## # … with 34,614 more rows, and 2 more variables: x <int>, y <int>

1. Repare que a coluna date no data.frame é um vetor de inteiros. Transforme essa coluna em um vetor de valores com classe date.

2. Crie uma coluna que junte as informações de data e tempo de jogo (colunas date e time) em objetos da classe date.

3. Crie as colunas dia, mês e ano com as respectivas informações sobre a data do jogo.

4. Em média, quanto tempo o Lakers demora para arremessar a primeira bola no primeiro período?

Dica: arremessos são representados pela categoria shot da coluna etype.

5. Em média, quanto tempo demora para sair a primeira cesta de três pontos? Considere toda a base, e cestas de ambos os times.

6. Construa boxplots do tempo entre pontos consecultivos para cada períodos. Considere toda a base de dados e apenas pontos do Lakers.

7. Qual foi o dia e mês do jogo que o Lakers demorou mais tempo para fazer uma cesta? Quanto tempo foi?

Se você já utilizava o R antes do surgimento do tidyverse, provavelmente já escreveu a expressão stringsAsFactors = F quando importava dados usando as funções read.csv ou read.table. É muito frustrante quando uma coluna de strings é lida como um fator, pois fatores não podem ser manipulados do mesmo jeito que manipulamos vetores de strings.

Felizmente, depois de aprender a usar o readr você não terá mais esse problema, pois as funções do pacote não leem colunas de caracteres como fatores por padrão. Mas isso não significa que fatores são inúteis. Eles representam uma forma muito prática de lidar com variáveis categorizadas, tanto para fins de modelagem quanto para fins de visualização.

Grande parte da frustração associada ao uso de fatores no R existe por conta da falta de algumas ferramentas úteis no pacote base. Para resolver esse problema, Hadley Wickham ajudou a comunidade R (de novo) desenvolvendo o pacote forcats(for categorial variables), que implementa algumas dessas ferramentas.

As principais funções do forcats servem para alterar a ordem e modificar os níveis de um fator. Para exemplificar a utilidade dessas funções, nesta seção vamos utilizá-las em situações corriqueiras.

Se você não tem o pacote {forcats}, instalado rode o código abaixo antes de utilizá-lo:

install.packages("forcats")

Nos exemplos a seguir, utilizarmos os seguintes pacotes:

library(forcats) library(ggplot2) library(dplyr)

Como vimos na Seção 3.13.2, fatores são uma classe de objetos no R criada para representar as variáveis categóricas numericamente.

Eles são necessários pois muitas vezes precisamos representar variáveis categóricas como números. Quando estamos fazendo um gráfico, por exemplo, só podemos mapear variáveis numéricas em seus eixos, pois o plano cartesiano é formado por duas retas de números reais.

O que fazemos então quando plotamos uma variável categórica? Nós a transformamos em fatores.

Mas como a manipulação de fatores é diferente da manipulação de números e strings (graças aos famosos levels), tarefas que parecem simples, como ordenar as barras de um gráfico de barras, acabam se tornando grandes desafios quando não sabemos lidar com essa classe de valores.

Nos exemplos a seguir, vamos utilizar a base starwars (do pacote {dplyr}) para aprendermos a fazer as principais operações com fatores utilizando o pacote {forcats}.

Vamos trabalhar primeiro com a coluna sex, que diz qual é o sexo de cada personagem. As possibilidades são:

starwars %>% pull(sex) %>% unique() ## [1] "male" "none" "female" "hermaphroditic" ## [5] NA

Veja que se transformarmos a coluna em fator, esses serão os levels da variável, não importa se o sub-conjunto que estivermos observando possua ou não todas as categorias.

starwars %>% mutate(sex = as.factor(sex)) %>% pull(sex) %>% head() ## [1] male none none male female male ## Levels: female hermaphroditic male none

Vamos criar um objeto com os 16 primeiros valores da coluna sex já transformados em fator.

fator_sex <- starwars %>% pull(sex) %>% as.factor() %>% head(16) fator_sex ## [1] male none none male female ## [6] male female none male male ## [11] male male male male male ## [16] hermaphroditic ## Levels: female hermaphroditic male none

Para mudar os níveis de um fator, podemos utilizar a função lvls_revalue(). Veja que, ao mudarmos os níveis de um fator, o label de cada valor também muda. Os novos valores precisam ser passados conforme a ordem dos níveis antigos.

lvls_revalue( fator_sex, new_levels = c("Fêmea", "Hermafrodita", "Macho", "Nenhum") ) ## [1] Macho Nenhum Nenhum Macho Fêmea ## [6] Macho Fêmea Nenhum Macho Macho ## [11] Macho Macho Macho Macho Macho ## [16] Hermafrodita ## Levels: Fêmea Hermafrodita Macho Nenhum

Essa função é uma boa alternativa para mudar o nome das categorias de uma variável antes de construir um gráfico.

starwars %>% filter(!is.na(sex)) %>% count(sex) %>% mutate( sex = lvls_revalue(sex, c("Fêmea", "Hermafrodita", "Macho", "Nenhum")) ) %>% ggplot() + geom_col(aes(x = sex, y = n))

Como as colunas no gráfico respeitam a ordem dos níveis do fator, não importa a ordem que as linhas aparecem na tabela, o gráfico sempre será gerado com as colunas na mesma ordem. Assim, se quiséssemos alterar a ordem das barras do gráfico anterior, precisaríamos mudar a ordem dos níveis do fator sex.

Para mudar a ordem dos níveis de um fator, podemos utilizar a função lvls_reorder(). Basta passarmos qual a nova ordem dos fatores, com relação à ordem anterior. No exemplo abaixo definimos que, na nova ordem,

• a primeira posição terá o nível que estava na terceira posição na ordem antiga;

• a segunda posição terá o nível que estava na primeira posição na ordem antiga;

• a terceira posição terá o nível que estava na quarta posição na ordem antiga;

• a quarta posição terá o nível que estava na segunda posição na ordem antiga.

lvls_reorder(fator_sex, c(3, 1, 4, 2)) ## [1] male none none male female ## [6] male female none male male ## [11] male male male male male ## [16] hermaphroditic ## Levels: male female none hermaphroditic

Assim, poderíamos usar essa nova ordem para ordenar as colunas do nosso gráfico.

starwars %>% filter(!is.na(sex)) %>% count(sex) %>% mutate( sex = lvls_revalue(sex, c("Fêmea", "Hermafrodita", "Macho", "Nenhum")), sex = lvls_reorder(sex, c(3, 1, 4, 2)) ) %>% ggplot() + geom_col(aes(x = sex, y = n))

Repare que precisamos passar a nova ordem na mão, o que pode deixar de funcionar se a nossa base mudar (recebermos mais linhas ou fizermos um filtro anteriormente).

Anterior ao mutate() temos a seguinte tabela:

starwars %>% filter(!is.na(sex)) %>% count(sex) ## # A tibble: 4 × 2 ## sex n ## <chr> <int> ## 1 female 16 ## 2 hermaphroditic 1 ## 3 male 60 ## 4 none 6

O que queremos é que os níveis da coluna sex sejam ordenados segundo os valores da coluna n, isto é, quem tiver o maior valor de n deve ser o primeiro nível, o segundo maior valor de n seja o segundo nível e assim por diante.

Podemos melhorar esse código utilizando a função fct_reorder(). Com ela, em vez de definirmos na mão a ordem dos níveis do fator, podemos ordená-lo segundo valores de uma segunda variável.

starwars %>% filter(!is.na(sex)) %>% count(sex) %>% mutate( sex = lvls_revalue(sex, c("Fêmea", "Hermafrodita", "Macho", "Nenhum")), sex = fct_reorder(sex, n) ) %>% ggplot() + geom_col(aes(x = sex, y = n))

É quase o que queríamos! O problema é que os níveis estão sendo ordenados de forma crescente e gostaríamos de ordenar na ordem decrescente. Para isso, basta utilizarmos o parâmetro .desc.

starwars %>% filter(!is.na(sex)) %>% count(sex) %>% mutate( sex = lvls_revalue(sex, c("Fêmea", "Hermafrodita", "Macho", "Nenhum")), sex = fct_reorder(sex, n, .desc = TRUE) ) %>% ggplot() + geom_col(aes(x = sex, y = n))

Agora sim! Com esse código, as colunas estarão sendo ordenadas pela frequência, independentemente dos valores de n e sex que chegarem no mutate().

Se olharmos a documentação da função fct_reorder() vamos descobrir que esse exemplo é apenas um caso particular de como podemos utilizá-la. No contexto geral, ela ordena os níveis de um fator segundo uma função dos valores de uma segunda variável.

Se em vez de construirmos um gráfico de barras da frequência da variável sex, construíssemos boxplots da altura para cada sexo diferente, teríamos o gráfico a seguir.

starwars %>% filter(!is.na(sex)) %>% ggplot() + geom_boxplot(aes(x = sex, y = height)) ## Warning: Removed 5 rows containing non-finite values (stat_boxplot).

No exemplo abaixo, utilizamos .fun = median, o que significa que, para cada nível da variável sex, vamos calcular a mediana da variável height e ordenaremos os níveis de sex conforme a ordem dessas medianas. Assim, o primeiro nível será o sexo com menor altura mediana, o segundo nível será o sexo com a segunda menor algura media e assim por diante. Se quiséssemos ordenar de forma decrescente, bastaria utilizar o argumento .desc = TRUE.

starwars %>% filter(!is.na(sex)) %>% mutate( sex = lvls_revalue(sex, c("Fêmea", "Hermafrodita", "Macho", "Nenhum")), sex = fct_reorder(sex, height, .fun = median, na.rm = TRUE) ) %>% ggplot() + geom_boxplot(aes(x = sex, y = height)) ## Warning: Removed 5 rows containing non-finite values (stat_boxplot).

starwars %>% filter(!is.na(sex)) %>% mutate( sex = lvls_revalue(sex, c("Fêmea", "Hermafrodita", "Macho", "Nenhum")), sex = fct_reorder(sex, height, .fun = max, na.rm = TRUE) ) %>% ggplot() + geom_boxplot(aes(x = sex, y = height)) ## Warning: Removed 5 rows containing non-finite values (stat_boxplot).

Imagine que queremos fazer um gráfico de barras com a frequência de personagens por espécie.

starwars %>% ggplot(aes(x = species)) + geom_bar()

O gráfico resultante é horrível, pois temos muitas espécies diferentes. Uma solução seria agrupar as espécies menos frequentes, criando uma nova categoria (outras, por exemplo).

Para isso, podemos usar a função fct_lump(). Vamos fazer isso primeiro com o vetor de espécies.

fator_especies <- as.factor(starwars$species) fator_especies ## [1] Human Droid Droid Human Human ## [6] Human Human Droid Human Human ## [11] Human Human Wookiee Human Rodian ## [16] Hutt Human Human Yoda's species Human ## [21] Human Droid Trandoshan Human Human ## [26] Mon Calamari Human Human Ewok Sullustan ## [31] Human Neimodian Human Gungan Gungan ## [36] Gungan <NA> Toydarian Dug <NA> ## [41] Human Zabrak Twi'lek Twi'lek Vulptereen ## [46] Xexto Toong Human Cerean Nautolan ## [51] Zabrak Tholothian Iktotchi Quermian Kel Dor ## [56] Chagrian Human Human Human Geonosian ## [61] Mirialan Mirialan Human Human Human ## [66] Human Clawdite Besalisk Kaminoan Kaminoan ## [71] Human Aleena Droid Skakoan Muun ## [76] Togruta Kaleesh Wookiee Human <NA> ## [81] Pau'an Human Human Human Droid ## [86] <NA> Human ## 37 Levels: Aleena Besalisk Cerean Chagrian Clawdite Droid Dug ... Zabrak

Temos 37 espécies diferentes na base. Podemos deixar apenas as 3 mais frequentes da seguinte forma:

fct_lump(fator_especies, n = 3) ## [1] Human Droid Droid Human Human Human Human Droid Human Human ## [11] Human Human Other Human Other Other Human Human Other Human ## [21] Human Droid Other Human Human Other Human Human Other Other ## [31] Human Other Human Gungan Gungan Gungan <NA> Other Other <NA> ## [41] Human Other Other Other Other Other Other Human Other Other ## [51] Other Other Other Other Other Other Human Human Human Other ## [61] Other Other Human Human Human Human Other Other Other Other ## [71] Human Other Droid Other Other Other Other Other Human <NA> ## [81] Other Human Human Human Droid <NA> Human ## Levels: Droid Gungan Human Other

O fator resultante possui 4 níveis: Droid, Gungan, Human e Other. Os 3 primeiros níveis são os mais frequentes, enquanto o nível Other foi atribuído a todos os outros 34 níveis que existiam anteriormente.

Poderíamos definir o nome do nível Others usando o argumento other_level.

fct_lump(fator_especies, n = 3, other_level = "Outras espécies") ## [1] Human Droid Droid Human ## [5] Human Human Human Droid ## [9] Human Human Human Human ## [13] Outras espécies Human Outras espécies Outras espécies ## [17] Human Human Outras espécies Human ## [21] Human Droid Outras espécies Human ## [25] Human Outras espécies Human Human ## [29] Outras espécies Outras espécies Human Outras espécies ## [33] Human Gungan Gungan Gungan ## [37] <NA> Outras espécies Outras espécies <NA> ## [41] Human Outras espécies Outras espécies Outras espécies ## [45] Outras espécies Outras espécies Outras espécies Human ## [49] Outras espécies Outras espécies Outras espécies Outras espécies ## [53] Outras espécies Outras espécies Outras espécies Outras espécies ## [57] Human Human Human Outras espécies ## [61] Outras espécies Outras espécies Human Human ## [65] Human Human Outras espécies Outras espécies ## [69] Outras espécies Outras espécies Human Outras espécies ## [73] Droid Outras espécies Outras espécies Outras espécies ## [77] Outras espécies Outras espécies Human <NA> ## [81] Outras espécies Human Human Human ## [85] Droid <NA> Human ## Levels: Droid Gungan Human Outras espécies

Também podemos transformar em Outras os níveis cuja frequência relativa é menor que um determinado limite, por exemplo, 2%. No exemplo abaixo, apenas espécies que representam mais de 2% dos personagem na base são mantidas. As demais foram transformadas em Outras.

fct_lump(fator_especies, p = 0.02, other_level = "Outras") ## [1] Human Droid Droid Human Human Human Human Droid ## [9] Human Human Human Human Wookiee Human Outras Outras ## [17] Human Human Outras Human Human Droid Outras Human ## [25] Human Outras Human Human Outras Outras Human Outras ## [33] Human Gungan Gungan Gungan <NA> Outras Outras <NA> ## [41] Human Zabrak Twi'lek Twi'lek Outras Outras Outras Human ## [49] Outras Outras Zabrak Outras Outras Outras Outras Outras ## [57] Human Human Human Outras Mirialan Mirialan Human Human ## [65] Human Human Outras Outras Kaminoan Kaminoan Human Outras ## [73] Droid Outras Outras Outras Outras Wookiee Human <NA> ## [81] Outras Human Human Human Droid <NA> Human ## 9 Levels: Droid Gungan Human Kaminoan Mirialan Twi'lek Wookiee ... Outras

Com isso, já conseguimos fazer um gráfico de barras mais agradável.

starwars %>% filter(!is.na(species)) %>% mutate(species = fct_lump(species, n = 2)) %>% ggplot(aes(x = species)) + geom_bar()

starwars %>% filter(!is.na(species)) %>% mutate( species = fct_lump(species, p = 0.02), species = fct_infreq(species) # Ordena pela frequência de cada nível ) %>% ggplot(aes(x = species)) + geom_bar()

Também é possível colapsar níveis criando manualmente os grupos. Para isso, utilizamos a função fct_collapse(). No exemplo a seguir, reclassificamos os níveis da variável eye_color. Os níveis não listados são reclassificados como "outros".

fator_cor_olhos <- as.factor(starwars$eye_color) fct_collapse( fator_cor_olhos, preto = "black", castanho = c("brown", "hazel"), azul_verde = c("blue", "green"), exotico = c("pink", "red", "white"), colorido = c("red, blue", "green, yellow"), other_level = "outros" ) ## Warning: Unknown levels in `f`: green ## [1] azul_verde outros exotico outros castanho azul_verde ## [7] azul_verde exotico castanho outros azul_verde azul_verde ## [13] azul_verde castanho preto outros castanho azul_verde ## [19] castanho outros castanho exotico exotico castanho ## [25] azul_verde outros azul_verde castanho castanho preto ## [31] azul_verde exotico azul_verde outros outros outros ## [37] azul_verde outros outros castanho castanho outros ## [43] exotico castanho outros preto outros castanho ## [49] outros preto castanho azul_verde outros outros ## [55] preto azul_verde castanho castanho azul_verde outros ## [61] azul_verde azul_verde castanho castanho castanho castanho ## [67] outros outros preto preto azul_verde outros ## [73] colorido outros outros preto colorido azul_verde ## [79] castanho exotico preto outros castanho castanho ## [85] preto outros castanho ## Levels: preto azul_verde castanho colorido exotico outros

A seguir, listamos outras funções úteis do pacote {forcats}, apresentando exemplos simples de como usá-las.

fator <- factor(c("a", "b", "a", "c", "c", "a")) fator ## [1] a b a c c a ## Levels: a b c

Junta dois fatores (e seus níveis).

fator2 <- factor(c("d", "e")) fct_c(fator, fator2) ## [1] a b a c c a d e ## Levels: a b c d e

Devolve a frequência dos níveis de um vetor.

fct_count(fator) ## # A tibble: 3 × 2 ## f n ## <fct> <int> ## 1 a 3 ## 2 b 1 ## 3 c 2

Acrescenta níveis a um fator

fct_expand(fator, c("d", "e")) ## [1] a b a c c a ## Levels: a b c d e

Inverte os níveis de um fator.

fct_rev(fator) ## [1] a b a c c a ## Levels: c b a

A base casas nos exercícios abaixo está no pacote dados:

remotes::install_github("cienciadedatos/dados")

1. Qual a diferença nos fatores criados com os códigos abaixo?

fator1 <- as.factor(c("c", "a", "z", "B")) fator2 <- forcats::as_factor(c("c", "a", "z", "B"))

2. Ordene os níveis do fator frutas conforme a sua preferência, isto é, as que você mais gosta primeiro e as que você menos gosta por último.

frutas <- as.factor(c("maçã", "banana", "mamão", "laranja", "melancia"))

3. Com base no vetor series, resolva os itens a seguir.

series <- as.factor(c("Game of Thrones", "How I Met your Mother", "Friends", "Lost", "The Office", "Breaking Bad"))

• a. Ordene os níveis do vetor series conforme a sua preferência, isto é, as que você mais gosta primeiro e as que você menos gosta por último.

• b. Junte ao vetor series o vetor novas_series a seguir, reordenando os níveis para manter a sua ordem de preferência.

novas_series <- as.factor(c("The Boys", "Stranger Things", "Queen's Gambit"))

• c. Renomeie o níveis do vetor criado no item (b) para os nomes em Português das séries. Mantenha o mesmo nome caso não haja tradução.

4. Ordene as categorias do eixo y do gráfico abaixo para que os pontos no eixo x fique em ordem crescente.

library(dplyr) library(ggplot2) mtcars %>% tibble::rownames_to_column("modelo") %>% ggplot(aes(x = mpg, y = modelo)) + geom_point()

5. Utilize a base dados::casas para fazer um gráfico de barras mostrando as vizinhanças (coluna vizinhanca) com casas mais caras (segundo a coluna venda_valor). O gráfico deve conter as 9 vizinhanças mais frequentes e as demais devem ser agrupadas em uma categoria chamada Outras vizinhanças.

Agora que já temos em mãos as ferramentas para importar, arrumar, transformar e sumarizar os nossos dados, podemos dar um passo adiante no ciclo da Ciência de Dados: a construção de visualizações.

Visualizar os dados é uma etapa importantíssima da análise estatística, pois é a partir dela que criamos boa parte da intuição necessária para escolher o teste ou modelo mais adequado para o nosso problema. Muitas vezes, um problema de análise de dados pode ser resolvido apenas com visualizações. Além disso, elas são o principal combustível da etapa de Comunicação da análise.

Visualizações podem ser uma simples medida resumo (frequência, média, variância, mínimo, máximo etc), um conjunto dessas medidas organizadas em uma tabela, ou a representação (de uma parte) dos dados em um gráfico. Neste capítulo, mostraremos como construir gráficos e tabelas bem formatadas dentro do R. Começaremos com a construção de gráficos e, em seguida, falaremos sobre a formatação de tabelas11.

Mas, antes de mais nada, o que é um gráfico estatístico?

A construção de gráficos no R foi revolucionada com a criação do pacote ggplot2, fruto da tese de doutorado do Hadley Wickham. Essa revolução teve base na filosofia que Hadley adotou para responder a pergunta “O que é um gráfico estatístico?”.

Em 2005, o estatístico norte-americano Leland Wilkinson publicou o livro The Grammar of graphics (A gramática dos gráficos, em português), uma fonte de princípios fundamentais para a construção de gráficos estatísticos. No livro, ele defende que um gráfico é o mapeamento dos dados em atributos estéticos (posição, cor, forma, tamanho) de formas geométricas (pontos, linhas, barras, caixas).

A partir dessa definição, Hadley escreveu A Layered Grammar of Graphics (Uma gramática em camada dos gráficos), acrescentando que os elementos de um gráfico (dados, sistema de coordenadas, rótulos, anotações, entre outros) são as suas camadas e que a construção de um gráfico se dá pela sobreposição dessas camadas.

Essa é a essência do ggplot2: construir um gráfico camada por camada.

Além de uma filosofia bem fundamentada, o ggplot2 ainda traz outras vantagens em relação aos gráficos do R base:

• gráficos naturalmente mais bonitos;
• fácil personalização (mais simples deixar o gráfico do jeito que você quer);
• a estrutura padronizada das funções deixa o aprendizado mais intuitivo;
• a diferença no código entre tipos diferentes de gráficos é muito pequena.

Para discutir os principais aspectos da construção de gráficos com o ggplot2, vamos continuar utilizando a base de filmes do IMDB. Você pode baixá-la clicando aqui.

Na próxima seção, vamos conhecer as principais funções do ggplot2 e começar a construir nossos primeiros gráficos. Não se esqueça de instalar e carregar o pacote antes de rodar os exemplos.

install.packages("ggplot2") library(ggplot2)

No ggplot2, os gráficos são construídos camada por camada, sendo a primeira delas dada pela função ggplot() (repare que não tem o “2”). Essa função recebe um data frame e cria a camada base do gráfico, o nosso canvas, onde acrescentaremos todos os outros elementos (camadas).

Se rodarmos apenas a função ggplot(), obteremos um painel em branco.

imdb <- readr::read_rds("assets/data/imdb.rds") ggplot(data = imdb)

Apesar de termos passado os dados para a função, precisamos especificar como as observações serão mapeadas nos aspectos visuais do gráfico e quais formas geométricas serão utilizadas para isso.

O código abaixo constrói um gráfico de dispersão entre as variáveis orcamento e receita.

ggplot(imdb) + geom_point(mapping = aes(x = orcamento, y = receita))

Observe que:

• a primeira camada é dada pela função ggplot() e recebe a nossa base imdb;
• a segunda camada é dada pela função geom_point(), especificando a forma geométrica utilizada no mapeamento das observações (pontos);
• as camadas são unidas com um +;
• o mapeamento na função geom_point() recebe a função aes(), responsável por descrever como as variáveis serão mapeadas nos aspectos visuais dos pontos (a forma geométrica escolhida);
• neste caso, os aspectos visuais mapeados são a posição do ponto no eixo x e a posição do ponto no eixo y;
• o Warning nos avisa sobre a exclusão das observações que possuem NA na variável receita e/ou orcamento;
• todas essas funções são do pacote {ggplot2}.

A combinação da função ggplot() e de uma ou mais funções geom_() definirá o tipo de gráfico gerado.

O primeiro argumento de qualquer função geom é o mapping. Esse argumento serve para mapear os dados nos atributos estéticos da forma geométrica escolhida. Ele sempre receberá a função aes(), cujos argumentos vão sempre depender da forma geométrica que estamos utilizando. No caso de um gráfico de dispersão, precisamos definir a posição dos pontos nos eixos x e y. No exemplo, a posição do ponto no eixo x foi dada pela coluna orcamento e a posição do ponto no eixo y pela coluna receita.

Atenção! As camadas dos gráficos são empilhadas utilizando-se o sinal +. Como a estrutura é muito parecida com a do pipe, é comum trocarmos o + por um %>% no meio do código, resultando em erro.

Podemos acrescentar uma terceira camada ao gráfico, desenhando a reta y = x para visualizarmos os filmes que não se pagaram.

ggplot(imdb) + geom_point(mapping = aes(x = orcamento, y = receita)) + geom_abline(intercept = 0, slope = 1, color = "red")

Os pontos abaixo da reta representam os filmes com orçamento maior que a receita, isto é, aqueles que deram prejuízo.

A reta x = y foi acrescentada ao gráfico pela função geom_abline(). Esse geom pode ser utilizado para desenhar qualquer reta do tipo y = a + b * x, sendo a o intercepto (intercept) da reta e b o seu coeficiente angular (slope).

Neste caso, como não estamos mapeando colunas da base a essa reta (isto é, essa reta não depende dos dados), não precisamos utilizar o argumento mapping da função geom_abline(), tampouco a função aes().

Para ver como um ggplot realmente é construído por camadas, veja o que acontece quando colocamos a camada da reta antes da camada dos pontos:

ggplot(imdb) + geom_abline(intercept = 0, slope = 1, color = "red") + geom_point(mapping = aes(x = orcamento, y = receita))

Além da posição nos eixos x e y, podemos mapear a cor dos pontos a uma variável.

library(dplyr, warn.conflicts = FALSE) imdb %>% mutate(lucro = receita - orcamento) %>% ggplot() + geom_point(aes(x = orcamento, y = receita, color = lucro))

O gráfico acima tem a cor dos pontos definida pelo valor da variável lucro. Como a coluna lucro é numérica, um degradê é criado para a cor dos pontos. O azul é a cor padrão nesses casos (veremos mais adiante como escolher a cor).

Veja que criamos a coluna lucro utilizando a função mutate() antes de iniciarmos a construção do gráfico. O fluxo base %>% manipulação %>% ggplot é muito comum no dia-a-dia.

Lembre-se: por trás de um grande gráfico sempre existe uma grande tabela.

Poderíamos também classificar os filmes entre aqueles que lucraram ou não. Neste caso, como a coluna lucrou é textual, uma cor é atribuída a cada categoria.

imdb %>% mutate( lucro = receita - orcamento, lucro = ifelse(lucro <= 0, "Não", "Sim") ) %>% filter(!is.na(lucro)) %>% ggplot() + geom_point(mapping = aes(x = orcamento, y = receita, color = lucro))

Um erro comum na hora de definir atributos estéticos de um gráfico é definir valores para atributos estéticos dentro da função aes(). Repare o que acontece quando tentamos definir diretamente a cor dos pontos dentro dessa função.

ggplot(imdb) + geom_point(aes(x = orcamento, y = receita, color = "blue"))

Estranho, não? O que aconteceu foi o seguinte: a função aes() espera uma coluna para ser mapeada a cada atributo, então o valor blue é tratado como uma nova variável/coluna que tem essa string para todas as observações. Assim, todos pontos têm a mesma cor (vermelha, padrão do ggplot) pois pertencem todos à essa “categoria blue”.

No caso, o que gostaríamos é de ter pintado todos os pontos de azul. A forma certa de fazer isso é colocando o atributo color= fora da função aes():

ggplot(imdb) + geom_point(aes(x = orcamento, y = receita), color = "blue")

Utilizamos o geom_line para fazer gráficos de linhas. Assim como nos gráficos de pontos, precisamos definir as posições x e y. O gráfico abaixo representa a evolução da nota média dos filmes ao longo dos anos.

imdb %>% group_by(ano) %>% summarise(nota_media = mean(nota_imdb, na.rm = TRUE)) %>% ggplot() + geom_line(aes(x = ano, y = nota_media))

Gráficos de linha são muito utilizados para representar séries temporais, isto é, observações medidas repetidamente em intervalos equidistantes12 de tempo. O gráfico anterior apresenta a série da nota IMDB média ao longo dos anos.

Podemos colocar pontos e retas no mesmo gráfico. Basta acrescentar os dois geoms. O gráfico abaixo mostra a nota média anual dos filmes do Robert De Niro.

imdb %>% filter(ator_1 == "Robert De Niro") %>% group_by(ano) %>% summarise(nota_media = mean(nota_imdb, na.rm = TRUE)) %>% ggplot() + geom_line(aes(x = ano, y = nota_media)) + geom_point(aes(x = ano, y = nota_media))

Quando precisamos usar o mesmo aes() em vários geoms, podemos defini-lo dentro da função ggplot(). Esse aes() será então distribuído para todo geom do gráfico. O código anterior pode ser reescrito da seguinte forma:

imdb %>% filter(ator_1 == "Robert De Niro") %>% group_by(ano) %>% summarise(nota_media = mean(nota_imdb, na.rm = TRUE)) %>% ggplot(aes(x = ano, y = nota_media)) + geom_line() + geom_point()

Se algum geom necessitar de um atributo que os outros não precisam, esse atributo pode ser especificado normalmente dentro dele. Abaixo, utilizamos o geom_label para colocar as notas médias no gráfico. Além do x e y, o geom_label também precisa do texto que será escrito no gráfico.

imdb %>% filter(ator_1 == "Robert De Niro") %>% group_by(ano) %>% summarise(nota_media = mean(nota_imdb, na.rm = TRUE)) %>% mutate(nota_media = round(nota_media, 1)) %>% ggplot(aes(x = ano, y = nota_media)) + geom_line() + geom_label(aes(label = nota_media))

Para construir gráficos de barras, utilizamos o geom_col. A seguir, construímos um gráfico de barras do número de filmes dos 10 diretores que mais aparecem na nossa base do IMDB.

imdb %>% count(diretor) %>% top_n(10, n) %>% ggplot() + geom_col(aes(x = diretor, y = n))

Gráficos de barras também precisam dos atributos x e y, sendo que o atributo y representará a altura de cada barra.

No gráfico anterior, vemos que o NA é considerado uma “categoria” de diretor e entra no gráfico. Podemos retirar os NAs dessa coluna previamente utilizando a função filter().

A seguir, além de retirar os NAs, atribuímos a coluna diretor à cor das colunas. Repare que, nesse caso, não utilizamos o atributo color e sim fill. A regra é a seguinte: o atributo color colore objetos sem área (pontos, linhas, contornos), o atributo fill preenche objetos com cor (barras, áreas, polígonos em geral).

imdb %>% count(diretor) %>% filter(!is.na(diretor)) %>% top_n(10, n) %>% ggplot() + geom_col( aes(x = diretor, y = n, fill = diretor), show.legend = FALSE )

Para consertar as labels do eixo x, a melhor prática é invertermos os eixos do gráfico, construindo barras horizontais.

imdb %>% count(diretor) %>% filter(!is.na(diretor)) %>% top_n(10, n) %>% ggplot() + geom_col( aes(y = diretor, x = n, fill = diretor), show.legend = FALSE )

Para ordenar as colunas, precisamos mudar a ordem dos níveis do fator diretor. Para isso, utilizamos a função fct_reorder() do pacote forcats. A nova ordem será estabelecida pela coluna n (quantidade de filmes).

Fatores dentro do R são números inteiros (1, 2, 3, …) que possuem uma representação textual (Ver Seção 7.6). Variáveis categóricas são transformadas em fatores pelo ggplot pois todo eixo cartesiano é numérico. Assim, os textos de uma variável categórica são, internamente, números inteiros.

Por padrão, os inteiros são atribuídos a cada categoria de uma variável pela ordem alfabética (repare na ordem dos diretores nos gráficos anteriores). Assim, se transformássemos o vetor c("banana", "uva", "melancia") em um fator, a atribuição de inteiros seria: “banana” vira 1, “melancia” vira 2 e “uva” vira 3. Embora sejam inteiros internamente, sempre que chamássemos esse novo vetor, ainda sim veríamos os textos “banana”, “uva” e “melancia”.

imdb %>% count(diretor) %>% filter(!is.na(diretor)) %>% top_n(10, n) %>% mutate(diretor = forcats::fct_reorder(diretor, n)) %>% ggplot() + geom_col( aes(y = diretor, x = n, fill = diretor), show.legend = FALSE )

Por fim, podemos colocar uma label com o número de filmes de cada diretor dentro de cada barra.

imdb %>% count(diretor) %>% filter(!is.na(diretor)) %>% top_n(10, n) %>% mutate(diretor = forcats::fct_reorder(diretor, n)) %>% ggplot() + geom_col(aes(x = diretor, y = n, fill = diretor), show.legend = FALSE) + geom_label(aes(x = diretor, y = n/2, label = n)) + coord_flip()

Para construir histogramas, usamos o geom_histogram. Esse geom só precisa do atributo x (o eixo y é construído automaticamente). Histogramas são úteis para avaliarmos a distribuição de uma variável.

A seguir, construímos o histograma do lucro dos filmes do diretor Steven Spielberg. O primeiro warning nos diz que o eixo x foi dividido em 30 intervalos para a construção do histograma.

imdb %>% filter(diretor == "Steven Spielberg") %>% mutate(lucro = receita - orcamento) %>% ggplot() + geom_histogram(aes(x = lucro))

Para definir o tamanho de cada intervalo, podemos utilizar o argumento bindwidth.

imdb %>% filter(diretor == "Steven Spielberg") %>% mutate(lucro = receita - orcamento) %>% ggplot() + geom_histogram( aes(x = lucro), binwidth = 100000000, color = "white" )

Boxplots também são úteis para estudarmos a distribuição de uma variável, principalmente quando queremos comparar várias distribuições.

Para construir um boxplot no ggplot, utilizamos a função geom_boxplot. Ele precisa dos atributos x e y, sendo que ao atributo x devemos mapear uma variável categórica.

A seguir, construímos boxplots do lucro dos filmes dos diretores que fizeram mais de 15 filmes.

imdb %>% filter(!is.na(diretor)) %>% group_by(diretor) %>% filter(n() >= 15) %>% mutate(lucro = receita - orcamento) %>% ggplot() + geom_boxplot(aes(x = diretor, y = lucro))

Também podemos reordenar a ordem dos boxplots utilizando a função forcats::fct_reorder. Neste caso, os diretores são ordenados pela mediana do lucro13.

imdb %>% filter(!is.na(diretor)) %>% group_by(diretor) %>% filter(n() >= 15) %>% ungroup() %>% mutate( lucro = receita - orcamento, diretor = forcats::fct_reorder(diretor, lucro, na.rm = TRUE) ) %>% ggplot() + geom_boxplot(aes(x = diretor, y = lucro))

Os títulos e labels do gráfico também são considerados camadas e são criados ou modificados pela função labs(). O exemplo a seguir coloca um título e um subtítulo no gráfico, além de modificar os labels do eixo x e y e da legenda.

imdb %>% mutate(lucro = receita - orcamento) %>% ggplot() + geom_point(mapping = aes(x = orcamento, y = receita, color = lucro)) + labs( x = "Orçamento ($)", y = "Receita ($)", color = "Lucro ($)", title = "Gráfico de dispersão", subtitle = "Receita vs Orçamento" )

O pacote {ggplot2} possui uma família de funções scale_ para modificarmos propriedades referentes às escalas do gráfico. Como podemos ter escalas de números, categorias, cores, datas, entre outras, temos uma função específica para cada tipo de escala.

Considere o gráfico a seguir.

imdb %>% group_by(ano) %>% summarise(nota_media = mean(nota_imdb, na.rm = TRUE)) %>% ggplot() + geom_line(aes(x = ano, y = nota_media))

Vamos redefinir as quebras dos eixos x e y.

imdb %>% group_by(ano) %>% summarise(nota_media = mean(nota_imdb, na.rm = TRUE)) %>% ggplot() + geom_line(aes(x = ano, y = nota_media)) + scale_x_continuous(breaks = seq(1916, 2016, 10)) + scale_y_continuous(breaks = seq(0, 10, 2))

Como as escalas dos eixos x e y são numéricas, utilizamos nesse caso as funções scale_x_continuous() e scale_y_continuous(). Veja que, mesmo definindo as quebras entre 0 e 10, o limite do eixo y não é alterado. Para alterá-lo, usamos a função coord_cartesian().

imdb %>% group_by(ano) %>% summarise(nota_media = mean(nota_imdb, na.rm = TRUE)) %>% ggplot() + geom_line(aes(x = ano, y = nota_media)) + scale_x_continuous(breaks = seq(1916, 2016, 10)) + scale_y_continuous(breaks = seq(0, 10, 2)) + coord_cartesian(ylim = c(0, 10))

Para mudarmos as escalas de cores, usamos as funções do tipo: scale_color_ e scale_fill_.

Para escolher manualmente as cores de um gráfico, utilize as funções scale_color_manual() e scale_fill_manual(). A seguir substituímos as cores padrão do gráfico por um outro conjunto de cores.

imdb %>% count(diretor) %>% filter(!is.na(diretor)) %>% top_n(5, n) %>% ggplot() + geom_col( aes(x = diretor, y = n, fill = diretor), show.legend = FALSE ) + coord_flip() + scale_fill_manual(values = c("red", "blue", "green", "pink", "purple", "black"))

Também podemos usar códigos hexadecimais.

imdb %>% count(diretor) %>% filter(!is.na(diretor)) %>% top_n(5, n) %>% ggplot() + geom_col( aes(x = diretor, y = n, fill = diretor), show.legend = FALSE ) + coord_flip() + scale_fill_manual( values = c("#ff4500", "#268b07", "#ff7400", "#0befff", "#a4bdba", "#b1f91a") )

Para trocar as cores de um gradiente, utilize as funções scale_color_gradient() e scale_fill_gradient().

imdb %>% mutate(lucro = receita - orcamento) %>% ggplot() + geom_point(aes(x = orcamento, y = receita, color = lucro)) + scale_color_gradient(low = "red", high = "green")

Para trocar o nome das categorias de uma legenda de cores, utilize as funções scale_color_discrete() e scale_fill_discrete().

imdb %>% filter(!is.na(cor)) %>% group_by(ano, cor) %>% summarise(num_filmes = n()) %>% ggplot() + geom_line(aes(x = ano, y = num_filmes, color = cor)) + scale_color_discrete(labels = c("Preto e branco", "Colorido"))

Os gráficos que vimos até agora usam o tema padrão do ggplot2. Existem outros temas prontos para utilizarmos presentes na família de funções theme_.

imdb %>% ggplot() + geom_point(mapping = aes(x = orcamento, y = receita)) + theme_minimal()

imdb %>% ggplot() + geom_point(mapping = aes(x = orcamento, y = receita)) + theme_bw()

imdb %>% ggplot() + geom_point(mapping = aes(x = orcamento, y = receita)) + theme_classic()

imdb %>% ggplot() + geom_point(mapping = aes(x = orcamento, y = receita)) + theme_dark()

Você também pode criar o seu próprio tema utilizando a função theme(). Nesse caso, para trocar os elementos estéticos do gráfico precisamos usar as funções element_text() para textos, element_line() para linhas, element_rect() para áreas e element_blank() para remover elementos.

No exemplo a seguir, fizemos as seguintes modificações no tema padrão:

• Alinhamos o título no centro do gráfico.
• Alinhamos o subtítulo no centro do gráfico.
• Pintamos o título dos eixos de roxo.
• Preenchemos o fundo do gráfico de preto.
• Removemos o grid do gráfico.

imdb %>% ggplot() + geom_point(mapping = aes(x = orcamento, y = receita), color = "white") + labs(title = "Gráfico de dispersão", subtitle = "Receita vs Orçamento") + theme( plot.title = element_text(hjust = 0.5), plot.subtitle = element_text(hjust = 0.5), axis.title = element_text(color = "purple"), panel.background = element_rect(fill = "black"), panel.grid = element_blank() )

No ggplot2, temos várias formas de juntar gráficos. Vamos apresentar a seguir as principais.

Como vimos anteriormente, podemos acrescentar vários geoms em um mesmo gráfico, apenas adicionando novas camadas. No código a seguir, construímos o gráfico de dispersão da receita pelo orçamento dos filmes, acrescentando também uma reta de tendência linear aos pontos.

ggplot(imdb, aes(x = orcamento, y = receita)) + geom_point() + geom_smooth(se = FALSE, method = "lm")

Uma funcionalidade muito útil do ggplot2 é a possibilidade de usar facets para replicar um gráfico para cada categoria de uma variável.

imdb %>% filter(classificacao %in% c("Livre", "A partir de 13 anos")) %>% ggplot() + geom_point(aes(x = orcamento, y = nota_imdb)) + facet_wrap(~classificacao, nrow = 2)

Repare que usamos uma fórmula para dizer à função qual variável vamos utilizar para quebrar o gráfico. Podemos especificar se queremos os gráficos lado a lado ou um embaixo do outro pelos argumentos nrow= e ncol=.

imdb %>% filter(classificacao %in% c("Livre", "A partir de 13 anos")) %>% ggplot() + geom_point(aes(x = orcamento, y = nota_imdb)) + facet_wrap(~classificacao, ncol = 2)

Diversos outros pacotes trazem ferramentas super úteis para trabalharmos com o ggplot2. Um deles é o pacote {patchwork}. Após carregá-lo, podemos juntar dois gráficos em uma mesma figura com um simples +.

# Instale antes de carregar # install.packages("patchwork") library(patchwork) p1 <- imdb %>% filter(diretor == "Steven Spielberg") %>% group_by(ano) %>% summarise(nota_media = mean(nota_imdb, na.rm = TRUE)) %>% ggplot() + geom_line(aes(x = ano, y = nota_media)) p2 <- imdb %>% mutate(lucro = receita - orcamento) %>% filter(diretor == "Steven Spielberg") %>% ggplot() + geom_histogram( aes(x = lucro), fill = "lightblue", color = "darkblue", binwidth = 100000000 ) p1 + p2

1. O que acontece quando rodamos o código ggplot(data = mtcars)?

2. O que tem de errado no código abaixo? Por que os pontos não ficaram azuis?

ggplot(data = mpg) + geom_point(mapping = aes(x = displ, y = hwy, color = "blue"))

3. Mapeie uma variável contínua para a cor, o tamanho e a forma de um gráfico de pontos. Como esses atributos estéticos se comportam diferente para variáveis categóricas vs contínuas?

4. Utilizando o mtcars, faça um gráfico de dispersão de mpg por qsec.

5. Utilizando o mtcars, o que acontece se você fizer um gráfico de dispersão de vs por mpg? Por que o gráfico não é útil?

Para resolver os exercícios a seguir, utilize a base imdb.

6. Crie um gráfico de dispersão da nota do imdb pelo orçamento.

7. Faça um gráfico de linhas do orçamento médio dos filmes ao longo dos anos.

8. Transforme o gráfico do exercício anterior em um gráfico de barras.

9. Descubra quais são os 5 atores que mais aparecem na coluna ator_1 e faça um boxplot do lucro dos filmes desses atores.

10. Com base no código abaixo, resolva os itens a seguir.

diretores <- c( "Steven Spielberg", "Quentin Tarantino", "Christopher Nolan", "Martin Scorsese" ) imdb %>% filter(diretor %in% diretores) %>% group_by(ano, diretor) %>% summarise(nota_media = mean(nota_imdb, na.rm = TRUE)) %>% ggplot(aes(x = ano, y = nota_media)) + geom_point() + geom_line() + facet_wrap(vars(diretor))

• a. Analisando o gráfico gerado, descreva o que a função facet_wrap() faz.

• .b Utilize os argumentos nrow e ncol da função facet_wrap() para colocar os quatro gráficos em uma única coluna.

11. Resovla os itens a seguir para fazer um gráfico de barras da frequência de filmes com nota maior que 8 ao longo dos anos.

• a. Crie uma nova coluna na base IMDB indicando se a nota de um filme é maior que 8 ou não.

• b. b. Utilizando a coluna criada em (a) crie uma tabela com o número anual de filmes com nota maior 8.

• c. Utilize a tabela criada em (b) para fazer um gráfico de barras do número de filmes com nota maior que 8 ao longo dos anos.

O site ggplot2 extensions tem uma galeria com diversos pacotes que deixam o ggplot2 bem mais poderoso, indo de novos geoms até animações.

A seguir, listamos algumas das mais famosas.

O gghighlight é uma extensões do {ggplot2} que serve para realçar partes de um gráfico feito com ggplot.

A seguir, mostramos como utilizar essa extensão para realçar gráficos de pontos e linhas.

Muitas vezes temos um gráfico de dispersão em que queremos realçar alguns pontos de acordo com alguma característica. Por exemplo, abaixo estamos realçando os pontos que possuem carat > 4, além disso colocamos uma label em cada um.

diamonds %>% ggplot(aes(x = carat, y = price)) + geom_point() + gghighlight::gghighlight(carat > 4, label_key = carat)

Também é possível configurar a cor dos pontos que serão realçados e dos que não serão, bem como o estilo das labels.

diamonds %>% ggplot(aes(x = carat, y = price)) + geom_point(color = "red") + gghighlight::gghighlight( carat > 4, label_key = carat, unhighlighted_params = list(colour = "black"), label_params = list(size = 10, fill = "grey") )

Com o {gghighlight} também é possível realçar linhas em um gráfico que possui varias linhas. Isso é interessante quando você quer ver como uma série temporal se compara com relação à um conjunto de outras séries.

No gráfico a seguir mostramos o número de downloads de cada um dos pacotes do tidyverse no ano de 2019. Uma das séries se destaca por mudar de padrão no meio do ano. Usamos o {gghighlight} para destacá-la no gráfico.

tab <- cranlogs::cran_downloads( packages = tidyverse::tidyverse_deps()$package, from = "2019-01-01", to = "2019-12-31" ) tab %>% ggplot(aes(x = date, y = count, group = package)) + geom_line() + gghighlight::gghighlight(max(count) > 100000, label_key = package)

Para mais informações sobre o {gghighlight}, recomendamos a leitura da excelente documentação oficial.

A extensão {ggridges} é uma ótima alternativa para histogramas e boxplots, quando queremos comparar a distribuição de uma variável A em vários níveis de uma variável B.

Primeiro, instale o pacote.

install.packages("ggridges")

No gráfico abaixo, comparamos a distribuição da receita dos filmes em cada um dos anos de 2005 a 2016. Para isso, utilizamos o novo geom_density_ridges(), disponibilizado pelo pacote {ggridges}.

library(ggridges) imdb %>% filter(ano > 2005) %>% mutate(ano = as.factor(ano)) %>% ggplot(aes(y = ano, x = receita, fill = ano)) + geom_density_ridges(na.rm = TRUE, show.legend = FALSE)

Você pode baixar a base IMDB utilizada clicando aqui.

Depois de fazer toda a nossa análise dentro do R, não é justamente na hora de mostrá-la ao mundo que vamos abandonar as vantagens de estarmos dentro de uma linguagem de programação.

Com a ajuda do R Markdown, uma interface de anotações que combina texto livre com códigos em R, podemos construir relatórios não só reprodutíveis, mas elegantemente bem formatados, sem sair do R!

Figura 9.1: Ilustração por Allison Horst.

Além do próprio {rmarkdown}, existem diversos pacotes que podem ser utilizados para ampliar os produtos que elaboramos com R Markdown. Podemos criar/escrever:

Antes de mais nada, vamos instalar os pacotes {rmarkdown} e {knitr}. O primeiro reúne todas as funcionalidades para juntar nossos textos narrativos e códigos de R. O segundo vai fazer a magia de transformar nossos simples arquivos de texto em arquivos HTML, PDF e Word (.doc) bonitões.

install.packages(c("rmarkdown", "knitr"))

Nas seções a seguir, vamos mostrar como começar a utilizar o R Markdown para criar esses documentos. Não se esqueça de conferir (e deixar por perto) as folhas de cola sobre R Markdown:

• rmarkdown cheatsheet

  • Guia de referência do rmarkdown

Se você é uma pessoa que utiliza R, sabe das possibilidades de utilizar R Markdown (e os pacotes que expandem mais ainda as possibilidades) e gostaria de começar a utilizá-lo, é importante conhecer o Markdown. Por quê? O R Markdown tem como base a linguagem de marcação Markdown.

Os arquivos markdown podem ser abertos por qualquer software que suporte este formato aberto. Além disso, independente da plataforma de trabalho, pode-se migrar para um arquivo de texto sem perder a formatação. O Markdown também é usado em outros lugares, como no GitHub e no Fórum da Curso-R.

Uma referência interessante para ter sempre em mãos é a Folha de cola (Cheatsheet) do Markdown.

Nas seções seguintes, descreveremos como podemos marcar os nossos textos e códigos usando markdown, e você poderá usar isso tanto em arquivos .Rmd, quanto em outros lugares que também utilizam essa marcação (como no Fórum da Curso-R!).

Para destacar um texto em negrito, coloque ** ou __ ao redor do texto.

Por exemplo:

Para destacar um texto em itálico, coloque * ou _ ao redor do texto.

Por exemplo:

Para riscar/tachar um texto, coloque ~~ ao redor do texto.

Por exemplo:

Esse é um texto com uma palavra riscada/tachada.

Os títulos funcionam como uma hierarquia, e para criar um título é necessário colocar um # no início da linha. Então um # marca um título, ## marca um sub-título, e assim sucessivamente. Veja os exemplos:

# Título 1 ## Título 2 ### Título 3

Você pode fazer uma lista ordenada usando somente números. Você pode repetir o número quantas vezes quiser:

Como é escrito no código:

1. Maçã

1. Banana

1. Uva

Como aparece no relatório:

Você pode fazer uma lista não ordenada escrevendo com hífens ou asteriscos, como a seguir:

* Maçã

* Banana

* Uva

- Maçã

- Banana

- Uva

O resultado será:

Você também pode adicionar sub-itens na lista indicando a hierarquia através da identação no Markdown (dica: utilize a tecla tab do teclado):

Você pode adicionar equações utilizando LaTeX. Você pode saber mais na página do Overleaf sobre expressões matemáticas. Além disso, existem geradores de equações online que ajudam a escrevâ-las em LaTeX, HTML, entre outras linguagens de marcação.

É possível centralizar a equação envolvendo o código com $$. Veja o exemplo abaixo:

Também é possível adicionar a equação na mesma linha que o texto, envolvendo o código com $. Veja o exemplo abaixo:

É possível marcar textos para que fiquem formatados como códigos, usando a crase: `

Mas atenção: o texto será formatado como código, porém não será executado!

Também é possível delimitar um trecho maior de código, utilizando três crases.

Exemplo:

Como é escrito no código:

``` library(dados) mean(pinguins$massa_corporal, na.rm = TRUE) ```

Como aparece no relatório:

Você pode incluir uma imagem utilizando esta estrutura:

.

Não se esqueça: a descrição da imagem é importante para acessibilidade do conteúdo através de leitores de tela!



As tabelas em Markdown têm uma estrutura definida, como mostra o exemplo abaixo.

É possível usar ferramentas online para gerar tabelas em Markdown, como por exemplo o Tables Generator.

Em Markdown:

Resultado:

Nesta seção, aprendemos que o Markdown é uma linguagem de marcação, usada para marcar textos. Podemos usar o Markdown para formatar textos e adicionar elementos no nossos relatórios.

Porém existem elementos (como código, imagens, tabelas, entre outros) que podemos também adiconar nos relatórios utilizando R. É isso que veremos na seção seguinte!

1. Leia a primeira página o guia de referência do RMarkdown

2. Liste abaixo outros lugares que utilizam o Markdown como base (Dica: outras linguagens de programação, fóruns, aplicativos de mensagem, etc)

3. Qual é o output se você criar uma lista ordenada começando no 2? Por exemplo:

4. O que são os sabores de Markdown (Markdown flavor)?

5. Experimente o pandoc no site de demonstração da ferramenta.

O R Markdown é a junção da linguagem Markdown com o poder de códigos em R. A mágica acontece em arquivos do tipo .Rmd, onde é possível adicionar textos, códigos, resultados de códigos e muito mais!

Falamos que mágica acontece em arquivos do tipo .Rmd, porém, como podemos criar esses arquivos? Primeiramente, no menu superior, clique em File > New File > R Markdown, ou utilize os botões da interface gráfica, como mostrado na imagem a seguir:

Figura 9.1: Captura de tela da IDE RStudio

Uma janela será aberta, chamada New R Markdown. Neste momento, iremos focar na seção inicial (Document). Nessa janela, é possível informar o título do relatório, o nome das pessoas autoras, e o formato em que deseja criar o relatório (sendo HTML, PDF ou Word). Caso queira gerar um PDF, será necessário instalar o LaTeX (saiba como no capítulo sobre instalações adicionais).

Para facilitar o aprendizado, recomendamos que escolha a opção HTML, sendo que é possível alterar todos esses campos posteriormente. Para que o arquivo seja criado, é necessário clicar no botão OK.

Figura 6.1: Captura de tela da IDE RStudio

Quando criamos um novo arquivo .Rmd (como descrito na seção anterior), o arquivo vem com alguns conteúdos para nos ajudar a organizar corretamente.

O arquivo .Rmd possui a seguinte estrutura, ilustrada pela figura a seguir:

• 1. YAML - Uma seção de metadados, que apresenta códigos YAML. Essa seção apresenta informações que serão usadas para gerar o arquivo final, como por exemplo: título do relatório, autoria, data, formato gerado, etc. É necessário cuidado ao editar essa seção, pois coisas simples como indentação incorreta, fechamento incorreto de textos, etc, podem resultar em um erro ao gerar seu relatório. Essa seção deve estar sempre ao início do documento, e é delimitado por três traços no começo e no final: ---.
• 1. Chunks - Nos campos de código (também chamados de chunks) podemos adicionar códigos em R (ou em algumas outras linguagens). Os chunks são delimitados por três crases, e a linguagem deve ser especificada entre chaves. Caso queira adicionar chunks com código em Python, é necessário ter o pacote {reticulate} instalado. Exemplo de um chunk que apresenta código em R:

• 1. Markdown - Textos marcados com Markdown podem ser adicionados ao longo do relatório, fora das demarcações do YAMl e dos Chunks. Caso queira saber mais sobre como marcar textos com Markdown, é possível ler mais na seção anterior deste capítulo.

Figura 9.2: Captura de tela da IDE RStudio

Nesta seção, utilizaremos como exemplos alguns códigos envolvendo a base de dados de pinguins. A versão original deste dataset (em Inglês) está disponível no pacote palmerpenguins, e a versão traduzida para Português está disponível no pacote dados.

Figura 9.3: Conheça os Pinguins do dataset PalmerPenguins! Ilustração por Allison Horst.

Caso não tenha o pacote dados instalado, é possível instalar com o seguinte código:

install.packages("remotes") remotes::install_github("cienciadedatos/dados")

Agora carregue os pacotes necessários:

library(dados) # Pacote com bases de dados em Português library(magrittr) # Pacote para utilizar o Pipe %>%

Ao analisar dados, escrevemos códigos que calculam estatísticas descritivas, geram gráficos e tabelas, entre outros. Para adicionar esses resultados nos relatórios, não é muito prático adicionar manualmente o resultado final (copiando e colando, por exemplo), pois em caso de alguma mudança na base de dados, será necessário gerar novamente estes resultados e adicioná-los novamente!

Com o RMarkdown, podemos adicionar códigos nos nossos relatórios que geram os resultados, assim a cada vez que compilarmos o relatório, os códigos que geram estes resultados serão executados, e o relatório terá sempre os resultados atualizados.

Caso você queira que o código seja executado como código R, existem duas possibilidades:

• chunks de código ou campos de código ( chunks em Inglês), quando o código é executado em um campo de código em R.

• código em linha (ou ‘inline code’ em Inglês), quando o resultado aparece junto ao texto;

É possível adicionar campos de código utilizando a seguinte sintaxe:

```{r} codigo em R aqui ```

Um exemplo de campo de código é o campo abaixo, onde é possível executar o código e visualizar o resultado.

Exemplo:

```{r} # calcula a média media_massa_g <- mean(pinguins$massa_corporal, na.rm = TRUE) # converte de gramas para kilogramas media_massa_kg_completo <- media_massa_g / 1000 # arredonda o valor para ter uma casa decimal media_massa_kg <- round(media_massa_kg_completo, 1) # exibe o resultado media_massa_kg ```

Resultado:

# calcula a média media_massa_g <- mean(pinguins$massa_corporal, na.rm = TRUE) # converte de gramas para kilogramas media_massa_kg_completo <- media_massa_g / 1000 # arredonda o valor para ter uma casa decimal media_massa_kg <- round(media_massa_kg_completo, 1) # exibe o resultado media_massa_kg

Veja que no resultado obtivemos o código em R e também o resultado deste código. Dependendo do público alvo do relatório, não queremos mostrar códigos. É possível escondê-los (e fazer muito mais!) alterando as opções de chunks (ou chunk options em Inglês). Veremos mais sobre isso posteriormente!

Para que um resultado de código apareça ao longo do texto, é possivel usar a seguinte estrutura: `r ` .

Exemplo:

A média da massa corporal dos pinguins é `r media_massa_kg` kg.

Resultado:

A média da massa corporal dos pinguins é 4.2 kg.

Na seção anterior (sobre Markdown), mostramos como é possóvel adicionar uma imagem em um relatório utilizando Markdown.

Porém, quando utilizamos arquivos RMarkdown também podemos adicionar imagens usando código em R, com a função include_graphics do pacote knitr.

Usando o knitr é possível personalizar de forma mais intuitiva como a imagem aparecerá no arquivo final: você pode adicionar uma imagem utilizando como primeiro argumento a url da imagem ou o caminho onde ela está no projeto. Além disso, com as opções de chunks (ou chunk options em Inglês), poderemos personalizar diversos atributos da imagem, como: legenda, tamanho, alinhamento, entre outros.

Veja o exemplo abaixo:

knitr::include_graphics("https://sg.cdnki.com/como-tirar-raiz-quadrada-no-r---aHR0cHM6Ly9saXZyby5jdXJzby1yLmNvbS9hc3NldHMvaW1nL3JlbGF0b3Jpb3MvZGFkb3MtaGV4LnBuZw==.webp")

Na seção anterior (sobre Markdown), foi apresentado como adicionar uma tabela utilizando Markdown.

Porém quando utilizamos arquivos R Markdown também é possível adicionar tabelas que resultam de códigos em R.

Existem algumas funções diferentes para fazer isso. Para apresentar alguns exemplos, primeiramente vamos salvar uma versão da base pinguins:

media_massa <- pinguins %>% # usamos a base de pinguins # agrupamos por especie e ilhas dplyr::group_by(especie, ilha) %>% # calculamos a média da massa corporal dplyr::summarise(media_massa = mean(massa_corporal, na.rm = TRUE)) %>% # criamos uma nova coluna, com a massa em kg, e arredondada com 2 casas decimais dplyr::mutate(media_massa_kg = round(media_massa / 1000, 2)) %>% # removemos a coluna da massa em gramas dplyr::select(-media_massa) # Apresentamos o resultado da tabela: media_massa

Acima, a tabela é apresentada como ela é escrita no console do R. Porém essa forma não é elegante de ser apresentada em um relatório! Podemos utilizar funções de diferentes pacotes para que as tabelas fiquem formatadas de uma forma mais atraente:

• Utilizando o pacote knitr: função kable()

media_massa %>% knitr::kable()

• Utilizando o pacote DT: função datatable()

media_massa %>% DT::datatable()

Os exemplos anteriores são as formas mais simples de apresentar as tabelas, porém cada pacote possibilita diferentes personalizações (por exemplo, alterar o nome das colunas, etc). Existem outros pacotes que permitem adicionar tabela nos relatórios em RMarkdown, como por exemplo:

• gt

• reactable

• flextable

• kableExtra

A versão mais recente do RStudio possui uma ferramenta de edição de Markdown visual, que disponibiliza botões para editar o texto com Markdown.

Veja mais neste post no blog da RStudio, e também a animação disponível neste post:

Figura 9.4: Demonstração do RStudio versão 1.4

1. Leia o guia de referência do RMarkdown até o final.

2. Qual o propósito do YAML do documento?

3. Quais são as opções e resultados do parâmetro results=?

```{r results='markup'} knitr::kable(head(cars)) ```

Programação funcional (PF) é um paradigma de programação com o qual a maior parte das pessoas que estudam estatística não está familiarizada. Essa técnica costuma ser ignorada na maioria dos tutoriais de R por não estar diretamente envolvida com manipulação e visualização de dados, mas isso não quer dizer que ela não tenha suas vantagens.

Usando programação funcional podemos criar códigos mais concisos e pipeáveis, características que por tabela também tornam mais simples o processo de encontrar erros. Além disso, códigos funcionais geralmente são paralelizáveis, permitindo que tratemos problemas muito grandes com poucas modificações.

Apesar de o R base já ter funções que podem ser consideradas elementos de PF, a implementação destas não é tão elegante e, portanto, este tutorial abordará somente a implementação de PF realizada pelo pacote purrr.

Para instalar e carregar o purrr, rode o código a seguir. Nas próximas seções deste tutorial, assumiremos que você têm esse pacote instalado e carregado.

install.packages("purrr") library(purrr)

A primeira família de funções do purrr que veremos também é a mais útil e extensível. As funções map() são quase como substitutas para laços for, elas abstraem a iteração em apenas uma linha. Veja esse exemplo de laço usando for:

soma_um <- function(x) { x + 1 } obj <- 10:15 for (i in seq_along(obj)) { obj[i] <- soma_um(obj[i]) } obj

O que de fato estamos tentando fazer com o laço acima? Temos um vetor (obj) e queremos aplicar uma função (soma_um()) em cada elemento dele. A função map() remove a necessidade de declaramos um objeto iterador auxiliar (i) e simplesmente aplica a função desejada em cada elemento do objeto dado.

soma_um <- function(x) { x + 1 } obj <- 10:15 obj <- map(obj, soma_um) obj

Como você deve ter percebido, o resultado da execução acima não é exatamente igual ao que tivemos com o laço. Isso acontece porque a map() tenta ser extremamente genérica, retornando por padrão uma lista com um elemento para cada saída.

Se quisermos “achatar” o resultado, devemos informar qual será o seu tipo. Isso é super simples e pode ser feito com as irmãs da map(): map_chr() (para strings), map_dbl() (para números reais), map_int() (para números inteiros) e map_lgl() (para booleanos).

obj <- 10:15 map_dbl(obj, soma_um)

O purrr também nos fornece outra ferramenta interessante para achatar listas: a família flatten(). No fundo, map_chr() é quase um atalho para map() %>% flatten_chr()!

Algo bastante útil da família map() é a possibilidade de passar argumentos fixos para a função que será aplicada. A primeira forma de fazer isso envolve fórmulas:

soma_n <- function(x, n = 1) { x + n } obj <- 10:15 map_dbl(obj, ~soma_n(.x, 2))

Como vemos no exemplo acima, para utilizar fórmulas precisamos colocar um til (~) antes da função que será chamada. Feito isso, podemos utilizar o placeholder .x para indicar onde deve ser colocado cada elemento de obj.

A outra forma de passar argumentos para a função é através das reticências da map(). Desta maneira precisamos apenas dar o nome do argumento e seu valor logo após a função soma_n().

soma_n <- function(x, n = 1) { x + n } obj <- 10:15 map_dbl(obj, soma_n, n = 2)

Usando fórmulas temos uma maior flexibilidade (podemos, por exemplo, declarar funções anônimas como ~.x+2), enquanto com as reticências temos maior legibilidade.

Agora que já exploramos os básicos da família map() podemos partir para iterações um pouco mais complexas. Observe o laço a seguir:

soma_ambos <- function(x, y) { x + y } obj_1 <- 10:15 obj_2 <- 20:25 for (i in seq_along(obj_1)) { obj_1[i] <- soma_ambos(obj_1[i], obj_2[i]) } obj_1

Com a função map2() podemos reproduzir o laço acima em apenas uma linha. Ela abstrai a iteração em paralelo, aplica a função em cada par de elementos das entradas e, assim como sua prima map(), pode achatar o objeto retornado com os sufixos _chr, _dbl, _int e _lgl.

O termo “paralelo” neste capítulos se refere a laços em mais de uma estrutura e não a paralelização de computações em mais de uma unidade de processamento.

soma_ambos <- function(x, y) { x + y } obj_1 <- 10:15 obj_2 <- 20:25 obj_1 <- map2_dbl(obj_1, obj_2, soma_ambos) obj_1

Como o pacote purrr é extremamente consistente, a map2() também funciona com reticências e fórmulas. Poderíamos, por exemplo, transformar soma_ambos() em uma função anônima:

obj_1 <- 10:15 obj_2 <- 20:25 map2_dbl(obj_1, obj_2, ~.x+.y)

Desta vez também temos acesso ao placeholder .y para indicar onde os elementos de do segundo vetor devem ir.

Para não precisar oferecer uma função para cada número de argumentos, o pacote purrr fornece a pmap(). Para essa função devemos passar uma lista em que cada elemento é um dos objetos a ser iterado:

soma_varios <- function(x, y, z) { x + y + z } obj_1 <- 10:15 obj_2 <- 20:25 obj_3 <- 30:35 obj_1 <- pmap_dbl(list(obj_1, obj_2, obj_3), soma_varios) obj_1

Com a pmap() infelizmente não podemos usar fórmulas. Se quisermos usar uma função anônima com ela, precisamos declará-la a função no seu corpo:

obj_1 <- 10:15 obj_2 <- 20:25 obj_3 <- 30:35 pmap_dbl(list(obj_1, obj_2, obj_3), function(x, y, z) { x + y + z })

A última função que veremos nessa seção é a imap(). No fundo ela é um atalho para map2(x, names(x), ...) quando x tem nomes e para map2(x, seq_along(x), ...) caso contrário:

obj <- 10:15 imap_dbl(obj, ~.x+.y)

Como podemos observar, agora .y é o placeholder para o índice atual (equivalente ao i no laço com for). Naturalmente, assim como toda a família map(), a imap() também funciona com os sufixos de achatamento.

Agora que já vimos como substituir iterações de nível básico e de nível intermediário com a família map(), podemos passar para os tipos mais obscuros de laços. Cada item desta seção será mais denso do que os das passadas, por isso encorajamos todos os leitores para que também leiam a documentação de cada função aqui abordada.

Imagine que precisamos aplicar uma função somente em alguns elementos de um vetor. Com um laço isso é uma tarefa fácil, mas com as funções da família map() apresentadas até agora isso seria extremamente difícil. Veja o trecho de código a seguir por exemplo:

dobra <- function(x) { x*2 } obj <- 10:15 for (i in seq_along(obj)) { if (obj[i] %% 2 == 1) { obj[i] <- dobra(obj[i]) } else { obj[i] <- obj[i] } } obj

No exemplo acima, aplicamos a função dobra() apenas nos elementos ímpares do vetor obj. Com o pacote purrr temos duas maneiras de fazer isso: com map_if() ou map_at().

A primeira dessas funções aplica a função dada apenas quando um predicado é TRUE. Esse predicado pode ser uma função ou uma fórmula (que serão aplicadas em cada elemento da entrada e devem retornar TRUE ou FALSE). Infelizmente a map_if() não funciona com sufixos, então devemos achatar o resultado:

eh_impar <- function(x) { x%%2 == 1 } dobra <- function(x) { x*2 } obj <- 10:15 map_if(obj, eh_impar, dobra) %>% flatten_dbl()

Com fórmulas poderíamos eliminar completamente a necessidade de funções declaradas:

obj <- 10:15 map_if(obj, ~.x%%2 == 1, ~.x*2) %>% flatten_dbl()

A segunda dessas funções é a irmã gêmea de map_if() e funciona de forma muito semelhante. Para map_at() devemos passar um vetor de nomes ou índices onde a função deve ser aplicada:

obj <- 10:15 map_at(obj, c(2, 4, 6), ~.x*2) %>% flatten_dbl()

Duas funções menos utilizadas da família map() são map_dfc() e map_dfr(), que equivalem a um map() seguido de um dplyr::bind_cols() ou de um dplyr::bind_rows() respectivamente.

A maior utilidade dessas funções é quando temos uma tabela espalhada em muitos arquivos. Se elas estiverem divididas por grupos de colunas, podemos usar algo como map_dfc(arquivos, readr::read_csv) e se elas estiverem divididas por grupos de linhas, map_dfr(arquivos, readr::read_csv)

Outro membro obscuro da família map() é a invoke_map(). Na verdade essa função pode ser considerada um membro da família invoke(), mas vamos ver que as semelhanças são muitas. Primeiramente, vamos demonstrar o que faz a invoke() sozinha:

soma_ambos <- function(x, y) { x + y } invoke(soma_ambos, list(x = 10, y = 15))

É fácil de ver que essa função recebe uma função e uma lista de argumentos para usar em uma chamada desta. Agora generalizando esta lógica temos invoke_map(), que chama uma mesma função com uma lista de listas de argumentos ou uma lista de funções com uma lista de argumentos. A família invoke() também aceita os sufixos como veremos a seguir:

soma_ambos <- function(x, y) { x + y } soma_um <- function(x) { x + 1 } soma_dois <- function(x) { x + 2 } invoke_map_dbl(soma_ambos, list(list(x = 10, y = 15), list(x = 20, y = 25)))

invoke_map_dbl(list(soma_um, soma_dois), list(x = 10))

Outras funções simbólicas de programação funcional além da map() são reduce e accumulate, que aplicam transformações em valores acumulados. Observe o laço a seguir:

soma_ambos <- function(x, y) { x + y } obj <- 10:15 for (i in 2:length(obj)) { obj[i] <- soma_ambos(obj[i-1], obj[i]) } obj

Essa soma cumulativa é bastante simples, mas não é difícil imaginar uma situação em que um programador desavisado confunde um índice com o outro e o bug acaba passando desapercebido. Para evitar esse tipo de situação, podemos utilizar accumulate() (tanto com uma função quanto com uma fórmula):

soma_ambos <- function(x, y) { x + y } obj <- 10:15 accumulate(obj, soma_ambos)

Obs.: Nesse caso, os placeholders têm significados ligeiramente diferentes. Aqui, .x é o valor acumulado e .y é o valor “atual” do objeto sendo iterado.

Se não quisermos o valor acumulado em cada passo da iteração, podemos usar reduce():

obj <- 10:15 reduce(obj, ~.x+.y)

Para a nossa comodidade, essas duas funções também têm variedades paralelas (accumulate2() e reduce2()), assim como variedades invertidas accumulate_right() e reduce_right()).

Por fim, veremos algumas funções do purrr que não têm exatamente a ver com laços, mas que acabam sendo bastante úteis quando usando as funções que vimos até agora. Elas não serão apresentadas em nenhuma ordem específica, este é apenas um apanhado de funções sortidas que achamos úteis enquanto programando com o purrr.

Se quisermos filtrar elementos de um vetor ou lista, podemos usar as funções keep() e discard(). Elas funcionam com fórmulas e podem ser extremamente úteis em situações que dplyr::select() e magrittr::extract() não conseguem cobrir:

obj <- list(10:15, 20:25, c(30:34, NA)) keep(obj, ~any(is.na(.x)))

discard(obj, ~!any(is.na(.x)))

No exemplo acima descartamos todos os vetores da lista que não têm pelo menos um elemento omisso (NA).

Uma outra família do pacote purrr é a is(). Com essa série de funções podemos fazer verificações extremamente estritas em objetos dos mais variados tipos. Seguem alguns poucos exemplos:

walk() e modify() são pequenas alterações da família map() que vêm a calhar em diversas situações. A primeira destas funciona exatamente igual à map() mas não devolve resultado, apenas efeitos colaterais; a segunda, não muda a estrutura do objeto sendo iterado, ela substitui os próprios elementos da entrada.

A maior utilidade de walk é quando precisamos salvar múltiplas tabelas. Para fazer isso, podemos usar algo como walk(tabelas, readr::write_csv).

Um caso de uso interessante da modify() é ao lado do sufixo _if(), combinação que nos permite iterar nas colunas de uma tabela e aplicar transformações de tipo apenas quando um predicado for verdade (geralmente de queremos transformar as colunas de fator para caractere).

Quando precisarmos lidar com listas complexas e profundas, o purrr nos fornece duas funções extremamente úteis: transpose() e pluck(). A primeira transpõe uma lista, enquanto a segunda é capaz de acessar elementos profundos de uma lista sem a necessidade de colchetes.

obj <- list(list(a = 1, b = 2, c = 3), list(a = 4, b = 5, c = 6)) str(obj)

Obs.: Se você estiver com muitos problemas com listas profundas, dê uma olhada nas funções relacionadas a depth() pois elas podem ser muito úteis.

Se quisermos pré-preencher os argumentos de uma função (seja para usá-la em uma pipeline ou com alguma função do próprio purrr), temos partial(). Ela funciona nos moldes da família invoke() e pode ser bastante útil para tornar suas pipelines mais enxutas:

soma_varios <- function(x, y, z) { x + y + z } nova_soma <- partial(soma_varios, x = 1, y = 2) nova_soma(3)

Não é incomum executarmos uma função e recebermos um erro de volta. Isso pode ser lidado com facilidade em um laço com um condicional, mas essa tarefa já é mais complexa quando se trata de programação funcional. Para isso, no purrr temos algumas funções que embrulham uma função e, quando esta retornar um erro, o silenciam e retornam um valor padrão em seu lugar.

quietly() retorna uma lista com resultado, saída, mensagem e alertas, safely() retorna uma lista com resultado e erro (um destes sempre é NULL), e possibly() silencia o erro e retorna um valor dado pelo usuário.

soma_um <- function(x) { x + 1 } s_soma_um <- safely(soma_um, 0) obj <- c(10, 11, "a", 13, 14, 15) s_soma_um(obj)

A base imdb nos exercícios abaixo pode ser baixada clicando aqui.

1. Utilize a função map() para calcular a média de cada coluna da base mtcars.

2. Use a função map() para testar se cada elemento do vetor letters é uma vogal ou não. Dica: você precisará criar uma função para testar se é uma letra é vogal. Faça o resultado ser (a) uma lista de TRUE/FALSE e (b) um vetor de TRUE/FALSE.

3 Faça uma função que divida um número por 2 se ele for par ou multiplique ele por 2 caso seja ímpar. Utilize uma função map para aplicar essa função ao vetor 1:100. O resultado do código deve ser um vetor numérico.

4. Use a função map() para criar gráficos de dispersão da receita vs orçamento para os filmes da base imdb. Os filmes de cada ano deverão compor um gráfico diferente. Faça o resultado ser (a) uma lista de gráficos e (b) uma nova coluna na base imdb (utilizando a função tidyr::nest()).

5. Utilize a função walk para salvar cada ano da base imdb em um arquivo .rds diferente, isto é, o arquivo imdb_2001.rds, por exemplo, deve conter apenas filmes do ano de 2001.

Neste capítulo, abordaremos alguns assuntos avançados, porém muito úteis no dia-a-dia de quem faz Ciência de Dados no R.

Se o {tidyverse} é o conjunto mais incrível de pacotes, faz sentido querermos criar nossos pacotes e fazer nossas análises usando seus princípios. Funções cujo primeiro argumento é um data frame e operações “pipeáveis” são apenas o começo.

Uma das características mais marcantes do {tidyverse} é a possibilidade de trabalhar com colunas como se elas fossem objetos comuns, criados fora da função. Basta pensar na mutate(): como ela sabe que mpg é uma coluna da tabela e não um objeto externo com o mesmo nome?

Existe uma ferramenta especial (e exclusiva ao R!) que nos permite fazer esse tipo de mágica: a non-standard evaluation (NSE) ou, em português, a avaliação não-padrão. Usamos NSE desde a primeira vez que escrevemos o comando library(), mas o seu funcionamento ainda é um mistério para a maioria.

Para criar funções flexíveis e enxutas como as do {tidyverse}, é necessário entender o básico da NSE e de como trabalhar com alguns operadores desse novo mundo.

Non-standard evaluation é uma propriedade do R que permite capturar o seu código sem avaliá-lo. Isso mesmo: o R deixa de ser uma caixa para a qual nós enviamos comandos a serem executados e passa a ter a capacidade de interpretar e trabalhar os próprios comandos. Genericamente isso se chama metaprogramação.

# O objeto 'dplyr' simplesmente não existe... dplyr

# Por que então esse comando funciona? library(dplyr)

Na chamada library() acima, a palavra “dplyr” não se refere a nenhum objeto! O R consegue ler o código que nós escrevemos e agir em cima dessa informação. Apesar de ser comum para nós, outras linguagens são incapazes de fazer isso por causa da forma com que elas tratam seus argumentos.

O R tem o que chamamos de avaliação tardia (delayed evaluation), ou seja, uma expressão só é avaliada quando ela é necessária e não logo que ela é criada. No R, print(1 + 2) é diferente de print(3), mas nas outras linguagens isso não é o caso!

A faceta da NSE que nos interessa no momento é a chamada tidy evaluation, ou tidy eval, a avaliação não-padrão utilizada pelas funções do {tidyverse} e outros pacotes feitos para trabalhar com o mesmo paradigma.

• O mundo sem tidy eval é extremamente verborrágico, pois a tabela precisa ser especificada toda vez que nos referirmos a uma coluna:

starwars[starwars$homeworld == "Naboo" & starwars$species == "Human", ]

• Para não precisar do $, a nossa única saída é criar objetos com as colunas:

homeworld <- starwars$homeworld; species <- starwars$species starwars[homeworld == "Naboo" & species == "Human", ]

• O {tidyverse} permite criar um “mini ambiente” em que as colunas da tabela estão disponíveis como se fossem objetos declarados explicitamente:

filter(starwars, homeworld == "Naboo", species == "Human")

O problema de capturar o código sem avaliá-lo é que fica difícil avaliar algo antes que ele seja capturado.

# O código 'birth_year' é capturado starwars %>% filter(is.na(birth_year)) %>% nrow()

# O objetivo é filtrar uma coluna especificada pelo usuário filter_na <- function(df, col) { filter(df, is.na(col)) } # A função captura o código 'col' starwars %>% filter_na(col = birth_year) %>% nrow()

O operador que vai resolver nosso problema é o {{ }} (lê-se curly curly), que permite interpolar o código, ou seja, avaliá-lo antes da captura.

# O objetivo é filtrar uma coluna especificada pelo usuário filter_na <- function(df, col) { filter(df, is.na( {{col}} )) } # Agora a função captura o código 'birth_year' starwars %>% filter_na(col = birth_year) %>% nrow()

Essa sintaxe vem da interpolação de strings:

col <- "birth_year" stringr::str_glue("Interpolando '{col}'!")

Para passar múltiplos argumentos nem é necessário usar o curly-curly já que a reticência já possui as capacidades de tidy eval:

# O objetivo é permitir vários cálculos summarise_by <- function(df, ..., by) { df %>% group_by( {{by}} ) %>% summarise(...) } starwars %>% summarise_by( media = mean(height, na.rm = TRUE), maximo = max(height, na.rm = TRUE), by = gender )

Note como não houve necessidade de interpolar media e maximo: a summarise() não tentou criar uma coluna chamada ....

E se quisermos passar strings para as funções do {tidyverse}? Se pedirmos o nome de uma coluna para um usuário, a resposta virá como string.

# O objetivo é dar um nome para a média summarise_mean <- function(df, nome, col) { summarise(df, nome = mean(col, na.rm = TRUE)) } # É criada uma coluna 'nome' sem valor ('col' não existe) summarise_mean(starwars, "media", "height")

Quando o “lado esquerdo” (antes de um igual) de uma expressão com tidy eval é uma string (ou se tornará uma quando avaliado), precisamos apenas usar o operador := (lê-se walrus, “morsa”):

# O objetivo é dar um nome para a média summarise_mean <- function(df, nome, col) { summarise(df, {{nome}} := mean(col, na.rm = TRUE)) } # É criada uma coluna 'media' sem valor ('col' não existe) summarise_mean(starwars, "media", "height")

Quando uma string (ou algo que se tornará uma quando avaliado) está no “lado direito” (depois de um igual ou quando não há igual) de uma expressão com tidy eval, precisamos apenas usar o pronome .data:

# O objetivo é dar um nome para a média summarise_mean <- function(df, nome, col) { summarise(df, {{nome}} := mean(.data[[col]], na.rm = TRUE)) } # É criada uma coluna 'media' com a média de 'height' summarise_mean(starwars, "media", "height")

É como se estivéssemos chamando df[["height"]], mas, como df não faria sentido dentro da expressão, usamos .data.

1. Escreva uma função que recebe uma tibble e uma coluna qualquer e devolve uma tibble sem as linhas contendo NA na coluna especificada.

2. Escreva uma função que recebe uma tibble e uma coluna e faz um gráfico de barras da frequência dessa coluna.

3. Escreva uma função que recebe uma tibble e o nome de duas colunas numéricas e faz um gráfico de dispersão dessas colunas.

4. Escreva uma função que recebe uma tibble, o nome de uma coluna categótica e o nome de uma coluna numérica e devolva uma tabela com a média da coluna numérica para cada categoria da coluna categórica.

Nesta seção, abordaremos como instalar o R e o RStudio no Linux e no Windows. Também discutiremos sobre a instalação de pacotes no R.

A instalação padrão do R é feita a partir do CRAN, uma rede de servidores espalhada pelo mundo que armazena versões idênticas e atualizadas de códigos e documentações para o R.

Sempre que for instalar algo do CRAN, utilize o servidor (mirror) mais próximo de você.

Para instalar o R no Windows, siga os seguintes passos:

1. Acesse o CRAN: https://www.r-project.org/

2. No menu à esquerda, encontre a opção Download e clique em CRAN.

3. Escolha a opção de servidor (mirror) mais próxima de você.

4. Clique em Download R for Windows.

5. Clique na opção base.

6. Na nova página, clique em Download R x.x.x for Windows, sendo x.x.x o número da versão que será baixada. Se você teve algum problema com o download, tente escolher outro servidor no passo 3.

7. Feito o download, clique duas vezes no arquivo baixado e siga as instruções para instalação.

Na etapa de escolher a pasta de destino da instalação, se você escolher um local que não esteja dentro da sua pasta de usuário, você precisará de acesso de administrador. Se escolher uma pasta dentro da sua pasta de usuário, não precisará.

Como a instalação no Linux depende da distribuição utilizada e, em geral, pessoas que utilizam Linux são mais experientes, vamos informar apenas as coordenadas até as instruções/arquivos. Se você tiver alguma dificuldade durante o processo, por favor envie a sua dúvida para a nossa comunidade. Faremos o possível para ajudar.

1. Acesse o CRAN: https://cran.r-project.org/

2. No menu à esquerda, encontre a opção Download e clique em CRAN.

3. Escolha a opção de servidor (mirror) mais próxima de você.

4. Clique em Download R for Linux.

5. Clique no link referente à distribuição que você utiliza.

6. Siga as instruções contidas na página para instalar o R. Se você teve algum problema com o download, tente escolher outro servidor no passo 3.

Para instalar o R no MacOS, siga os seguintes passos:

1. Acesse o CRAN: https://www.r-project.org/

2. No menu à esquerda, encontre a opção Download e clique em CRAN.

3. Escolha a opção de servidor (mirror) mais próxima de você.

4. Na nova página, clique em Download R for (Mac) OS X.

5. Clique na versão do R que você quer baixar (geralmente queremos baixar a mais recente). O objetivo aqui é baixar um arquivo do tipo “R-x.x.x.pkg”, sendo x.x.x o número da versão que vamos instalar. Se você teve algum problema com o download, tente escolher outro servidor no passo 3.

6. Feito o download, clique duas vezes no arquivo baixado e siga as instruções para instalação.

Agora vamos instalar a versão open source do RStudio, a IDE que utilizaremos para escrever e executar códigos em R.

Para instalar o RStudio no Windows, siga os seguintes passos:

• Se você tiver acesso de administrador, baixe a versão referente ao seu sistema operacional que está na lista de All Installers.

• Se você não tiver acesso de administrador, baixe a versão referente ao seu sistema operacional que está na lista de Zip/Tarballs.

1. Clique duas vezes no arquivo que você baixou da página do RStudio e siga as instruções de instalação.

1. Descompacte o arquivo baixado no passo anterior. Geralmente isso pode ser feito clicando no arquivo compactado com o botão direito do mouse e clicando na opção descompactar ou extrair.

2. Após a descompactação ter sido finalizada, você terá uma pasta chamada: RStudio-x.x.x, em que x.x.x é o número da versão baixada. Abra essa pasta e entre na subpasta com nome bin.

3. Procure pelo arquivo chamado rstudio e clique duas vezes. Isso abrirá o RStudio. Recomendamos fixar o programa na barra de tarefas para não precisar repetir essa etapa sempre que for abrir o programa.

Observação: se você excluir a pasta que extraímos, o RStudio irá parar de funcionar.