Como calcular a raiz que nao é quadrada rstudio

1. Qual a diferença entre o R e o RStudio?

O R é uma linguagem de programação e um programa que instalamos no nosso computador para interpretar código em linguagem R. O RStudio é um ambiente de desenvolvimento para programação em R, isto é, é um programa que nos ajuda a trabalhar com a linguagem R.

2. Podemos usar o RStudio sem o R? E o R sem o RStudio?

Não podemos usar o RStudio sem o R, pois o programa R é que interpreta os nossos códigos e devolve os resultados. Por outro lado, podemos usar o R sem o RStudio (ou qualquer outro ambiente de desenvolvimento), mas a nossa vida de pessoa programadora se torna muito mais difícil.

3. Precisamos compilar nossos códigos de R?

Não. Um código em R é interpretado linha a linha, isto é, podemos ir rodando nosso código parcialmente, conforme vamos escrevendo.

4. Calcule o número de ouro no R. Dica: o número de ouro é dado pela expressão \(\frac{1 + \sqrt{5}}{2}\).

Também poderia ser resolvido usando a função sqrt() para calcular a raiz quadrada.

5. Por que é preferível escrevermos sempre o nosso código no script e não no Console?

Porque o código é a documentação da nossa análise. Se parte da análise for feita diretamente no Console, parte da documentação será perdida.

1. Qual a diferença entre os códigos abaixo?

# Código 1 33 / 11 # Código 2 divisao <- 33 / 11

O primeiro código calcula a divisão de 33 por 11 e devolve o resultado na tela. O segundo código faz o mesmo cálculo, mas guardo o resultado no objeto divisao, isto é, o resultado não é retornado na tela.

2. Multiplique a sua idade por 12 e salve o resultado em um objeto chamado idade_em_meses. Em seguida, multiplique esse objeto por 30 e salve o resultado em um objeto chamado idade_em_dias.

idade_em_meses <- 31 * 12 idade_em_dias <- idade_em_meses * 30

3. Por que o nome meu-objeto não pode ser utilizado para criar um objeto? O que significa a mensagem de erro resultante?

Porque o sinal - é utilizado pelo R como o operador de subtração. O código acima está sendo interpretado como a subtração dos objetos meu e objeto. Como nenhum dos objetos existe na sessão, é devolvido um erro dizendo que o objeto meu (o primeiro deles) não foi encontrado.

No entanto, mesmo que os objetos existissem, seria retornado um erro. Neste caso, seria um erro de sintaxe, pois o R não sabe como interpretar a atribuição do valor 1 à operação meu - objeto. Veja que a mensagem de erro não é muito intuitiva, pois o R entende que -<- é uma função que esquecemos de definir.

meu <- 1 objeto <- 2 meu-objeto <- 1

1. Guarde em um objeto chamado nome uma string contendo o seu nome completo.

nome <- "William Nilson de Amorim"

2. Guarde em um objeto chamado cidade o nome da cidade onde você mora. Em seguida, guarde em um objeto chamado estado o nome do estado onde você mora. Usando esses objetos, resolva os itens abaixo:

a. Utilize a função nchar() para contar o número de caracteres em cada cada string.

cidade <- "São Paulo" estado <- "SP" nchar(cidade)

b. Interprete o resultado do seguinte código:

A função paste juntou (colou) as duas strings, uma do lado da outra, separando-as por um espaço. O resultado gerado foi uma única string.

c. Interprete o resultado do seguinte código:

paste(cidade, estado, sep = " - ")

O argumento sep da função paste() nos permite escolher qual caracter será utilizado para separar as duas strings. Por padrão será utilizado um espaço em branco " ". No exemplo, foi utilizado um espaço, seguido de um traço, seguido de outro espaço. Sem os espaços o resultado seria:

paste(cidade, estado, sep = "-")

Veja que qualquer caracter ou string pode ser utilizada como separador:

paste(cidade, estado, sep = " #tricolor ")

d. Desafio. Como você reproduziria o mesmo resultado do item (c) sem utilizar o argumento sep?

paste(cidade, "-", estado)

e. Qual a diferença entre as funções paste() e paste0()?

A função paste0() é equivalente à função paste() com o argumento sep = "".

paste(cidade, "-", estado)

paste(cidade, "-", estado, sep = "")

paste0(cidade, "-", estado)

1. Guarde em um objeto a sequência de números de 0 a 5 e resolva os itens abaixo.

a. Use subsetting para fazer o R devolver o primeiro número dessa sequência. Em seguida, faça o R devolver o último número da sequência.

vetor <- 0:5 # Primeiro elemento vetor[1]

# Último elemento vetor[6]

b. Multiplique todos os valores do vetor por -1. Guarde o resultado em um novo objeto chamado vetor_negativo.

vetor_negativo <- vetor * -1 vetor_negativo

2. Crie um vetor com o nome de três frutas, guarde em um objeto chamado frutas e resolva os itens abaixo.

a. Utilize a função length() para verificar o tamanho do vetor.

frutas <- c("banana", "maçã", "mamão") length(frutas)

b. Inspecione a saída de paste("eu gosto de", frutas) e responda se o tamanho do vetor mudou.

paste("eu gosto de", frutas)

O tamanho do vetor não muda. O que aconteceu foi o acréscimo do prefixo “eu gosto de” a cada valor do vetor frutas. Podemos confirmar essa afirmação calculando o comprimento do novo vetor:

length(paste("eu gosto de", frutas))

3. O que é reciclagem? Escreva um código em R que exemplifique esse comportamento.

Reciclagem é a repetição de valores de um vetor para que uma operação com vetores de tamanhos diferentes possa ser realizada. Embora pareça um comportamento estranho, utilizamos a reciclagem o tempo todo dentro do R, muitas vezes sem perceber. No exemplo a seguir, os valores do vetor_menor serão repetidos (reciclados) até os dois vetores terem o mesmo tamanho. Então, o primeiro valor do vetor menor será somado com o promeiro valor do vetor maior, o segundo do menor somado com o segundo do maior e assim por diante.

# Exemplo vetor_menor <- c(1, 3) vetor_maior <- c(1, 2, 3, 4) vetor_menor + vetor_maior

4. O que é coerção? Escreva um código em R que exemplifique esse comportamento.

Coerção é a homogeneização da classe dos valores de um vetor. Se construirmos um vetor com valores de classes diferentes, todos os valores serão reprimidos para a classe mais dominante entre eles. No exemplo abaixo, todos os valores do vetor foram transformados em character, pois character é mais dominante do que as demais classes presentes (numeric e logical).

Considerando apenas as principais classes, temos a seguinte ordem de dominância: character > numeric > integer > logical.

5. Por que a coerção pode ser um problema na hora de importarmos bases de dados para o R?

Porque as colunas podem acabar sendo importadas com uma classe diferente daquela que estamos esperando e nenhum erro ou warning será devolvido. Por exemplo, se uma coluna da base que deveria ser numérica tiver, por algum descuido, qualquer tipo de caracter não numérico (texto), toda a coluna será importada como texto.

O caso mais comum desse problema é gerado pelo separador de decimais. Se não especificarmos corretamente qual é o separador de decimais que estamos utilizando na nossa base de dados na hora da importação, qualquer coluna com valores decimais será importada como texto.

6. Use a função sum() para somar os valores de 1 a 100.

7. Considere o vetor booleano a seguir:

dolar_subiu <- c(TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE)

Este vetor tem informação de uma semana (7 dias, começando no domingo) indicando se o dólar subiu (TRUE) ou não subiu (FALSE) no respectivo dia. Interprete o resultado dos códigos abaixo:

a. length(dolar_subiu)

Devolve o comprimento do vetor dolar_subiu. Podemos interpretar como o número de dias analisados nesse estudo.

b. dolar_subiu[2]

Verifica se o dólar subiu no segundo dia do estudo (segunda-feira).

c. sum(dolar_subiu)

Verifica o número de dias que o dólar subiu (já que na soma, os valores TRUE viram 1 e os valores FALSE viram 0), no caso, 4 dias com alta do dólar.

d. mean(dolar_subiu)

Verifica a proporção de dias em que o dólar subiu (a média de valores 0 e 1 é igual a proporção de valores 1), no caso, cerca de 57% dos dias.

1. O código abaixo vai guardar no objeto segredo um número inteiro entre 0 e 10. Sem olhar qual número foi guardado no objeto, resolva os itens a seguir:

segredo <- round(runif(1, min = 0, max = 10))

a. Teste se o segredo é maior ou igual a 0.

b. Teste se o segredo é menor ou igual a 10.

c. Teste se o segredo é maior que 5.

d. Teste se o segredo é par.

Precisamos verificar se o resto da divisão por 2 é igual a zero.

# Resto da divisão por 2 segredo %% 2

# Guardando o resultado resto <- segredo %% 2 # Teste resto == 0

# Equivalentemente poderíamos fazer segredo %% 2 == 0

e. Teste se segredo * 5 é maior que a sua idade.

f. Desafio. Escreva um teste para descobrir o valor do segredo.

Vamos descobrir a posição do segredo no vetor 0:10.

numeros_possiveis <- 0:10 numeros_possiveis

segredo == numeros_possiveis

No código acima, para cada valor de numero_possiveis, foi testado se esse valor é igual ao segredo. Em caso afirmativo, um TRUE é devolvido. Veja que há apenas um TRUE no vetor resultante. Essa é posição do nosso segredo dentro do vetor numeros_possiveis.

Podemos usar esse vetor de TRUE/FALSE para recuperar o valor do segredo fazendo subsetting.

# Eis o valor do segredo numeros_possiveis[segredo == numeros_possiveis]

No código acima, foi retornado apenas o número associado ao valor TRUE dado pelo teste segredo == numeros_possiveis.

2. Escreva um código em R que devolva apenas os valores maiores ou iguais a 10 do vetor abaixo:

vetor <- c(4, 8, 15, 16, 23, 42) # Resposta vetor[vetor >= 10]

3. Use o vetor numeros abaixo para responder as questões seguintes.

a. Escreva um código que devolva apenas valores positivos do vetor numeros.

b. Escreva um código que devolta apenas os valores pares do vetor numeros.

# Resto da divisão por 2 numeros %% 2

# Quais números são pares? numeros %% 2 == 0

# Usando para filtrar o vetor numeros[numeros %% 2 == 0]

c. Filtre o vetor para que retorne apenas aqueles valores que, quando elevados a 2, são menores do que 4.

# Quadrado dos valores do vetor numeros^2

# Aqueles menores que 4 numeros^2 < 4

# Usando para filtrar numeros[numeros^2 < 4]

1. Quais as diferenças entre NaN, NULL, NA e Inf? Digite expressões que retornem cada um desses valores.

• O NaN representa uma indefinição matemática. Todo NaN é um NA, mas o contrário não é verdade.

• O NA representa o nosso desconhecimento acerca de um valor. Esse valor existe, mas nós não o conhecemos. Na Estatística, ele é conhecido como valor omisso ou valor faltante.

• O NULL é um valor especial para o R, isto é, ao contrário do NA, ele não tem um significado prático para a análise de dados, mas sim computacional. Ele representa a ausência de um vetor e é útil na construção da lógica de programação de alguns códigos.

mtcars$coluna_que_nao_existe

• O Inf representa um número muito grande (que o computador não consegue representar) ou um limite matemático.

2. Escreva um código que conte o número de NAs do vetor b.

b <- c(1, 0, NA, NA, NA, NA, 7, NA, NA, NA, NA, NA, 2, NA, NA, 10, 1, 1, NA)

1. Quais códigos abaixo retornam um vetor com a coluna mpg do data frame mtcars?

a. mtcars$mpg

Retorna!

b. mtcars[ , 3]

Não retorna. A coluna mpg é a primeira coluna do data frame. A coluna que esse código retornou foi a disp.

c. mtcars("mpg")

A sintaxe desse código não é válida pois () não são utilizados para fazer subsetting, mas sim para definir os argumentos de uma função (e mtcars não é uma função).

d. mtcars[ , "mpg"]

“Retorna!”

e. mtcars.mpg

Essa sintaxe não é válida no R. Ele está procurando por um objeto chamado mtcars.mpg, que não existe.

f. mtcars[ , 1]

Retorna!

g. mtcars[1, 1]

Esse código retorna apenas o primeiro valor da coluna mpg.

Não retorna. Essa sintaxe não é válida para selecionar colunas de um data frame. O correto seria nome_do_data_frame$nome_da_coluna.

2. Para que serve a função str(). Dê um exemplo do seu uso.

Serve para espiarmos a estrutura de um data frame, como número de linhas, colunas, classes das colunas e exemplo de valores em cada uma delas.

3. Para que serve a função names(). Dê um exemplo do seu uso.

Serve para observamos os nomes das colunas de um data frame. O valor retornado é um vetor de strings.

4. Use o data frame airquality para responder às questões abaixo:

a. Quantas colunas airquality tem?

b. Quantas linhas airquality tem?

c. O que a função head() retorna?

Retorna as 6 primeiras linhas do data frame.

d. Quais são os nomes das colunas?

e. Qual é a classe da coluna Ozone?

# Também podemos ver apenas a coluna Ozone class(airquality$Ozone)

5. Desafio. Calculando desvio-padrão no R. Use o data frame airquality para responder às questões abaixo:

a. Tire a média da coluna Ozone e guarde em um objeto.

media_ozone <- mean(airquality$Ozone, na.rm = TRUE)

b. Guarde em um objeto o vetor correspondente à coluna Ozone subtraída da sua própria média (calculada em no item a).

ozone_centralizado <- airquality$Ozone - media_ozone

c. Eleve o vetor calculado em (b) ao quadrado. Salve o resultado em um novo objeto.

ozone_centr_quadrado <- ozone_centralizado ^ 2

d. Tire a média do vetor calculado em (c) e salve o resultado em um objeto chamado variancia. Em seguida, calcule a raiz quadrada desse valor e salve em um objeto chamado desvio_padrao.

variancia <- mean(ozone_centr_quadrado, na.rm = TRUE) desvio_padrao <- sqrt(variancia)

e. Compare o valor de desvio_padrao com sd(airquality$Ozone, na.rm=TRUE) e pesquise por que os valores não são iguais. Dica: veja a documentação da função sd().

sd(airquality$Ozone, na.rm = TRUE)

Os valores não são iguais, pois na nossa conta, ao calcularmos a média no item (d), dividimos a soma de quadrados por n (tamanho da amostra, no caso, 116), enquanto na função sd() a divisão é por n - 1 (115). A divisão por n - 1, na Estatística, representa o estimador não viesado para a variância/desvio-padrão de uma quantidade. Na prática, ambas podem ser utilizadas como medidas de variabilidade, mas em contextos inferenciais o valor dividido por n - 1 é preferível.

Para chegarmos no mesmo resultado, poderíamos fazer:

# Número de valores sem NA n <- length(na.omit(airquality$Ozone)) variancia <- sum(ozone_centr_quadrado, na.rm = TRUE) / (n - 1) desvio_padrao <- sqrt(variancia) desvio_padrao

6. Use o data frame airquality para responder às questões abaixo.

a. Conte quantos NAs tem na coluna Solar.R.

sum(is.na(airquality$Solar.R))

b. Filtre a tabela airqualitycom apenas linhas em que Solar.R é NA.

tab <- airquality[is.na(airquality$Solar.R),] # Imprimindo apenas as primeiras linhas para facilitar a leitura head(tab)

c. Filtre a tabela airquality com apenas linhas em que Solar.R não é NA.

tab <- airquality[!is.na(airquality$Solar.R),] # Imprimindo apenas as primeiras linhas para facilitar a leitura head(tab)

d. Filtre a tabela airquality com apenas linhas em que Solar.R não é NA e Month é igual a 5.

tab <- airquality[!is.na(airquality$Solar.R) & airquality$Month == 5,] # Imprimindo apenas as primeiras linhas para facilitar a leitura head(tab)

1. Qual dos códigos abaixo devolverá um erro se for avaliado?

a. 3 * 5 + 10

Sem erro.

b. function <- 10

Retorna erro pois function é um nome reservado no R. Não podemos utilizá-lo para nomear outros objetos.

c. mean(1, 10)

Não retorna erro, mas o 10 não é considerado na média. O código correto seria mean(c(1, 10)).

d. (soma <- sum(1, 1))

Não retorna erro. Cercar o código com parênteses força a saída a sempre ser apresentada no Console, além de ser gravada dentro do objeto.

2. Crie uma função que receba um número e retorne o quadrado deste número.

quadrado <- function(x) { x ^ 2 } quadrado(2)

3. Crie uma função que receba 2 números e devolva a raiz quadrada da soma desses números.

raiz_da_soma <- function(a, b) { sqrt(a + b) } raiz_da_soma(2, 2)

4. Crie uma função que receba dois valores (numéricos) e devolva o maior deles.

retornar_maior <- function(x, y) { vetor <- c(x, y) filtro <- c(x > y, x <= y) vetor[filtro] } retornar_maior(10, 20)

*Também poderíamos resolver usando a função max().

retornar_maior <- function(x, y) { max(x, y) } retornar_maior(10, 20)

5. Use a função runif() para criar uma função que retorne um número aleatório inteiro entre 0 e 10 (0 e 10 inclusive). Caso você não conheça a função runif(), rode help(runif) para ler a sua documentação.

sortear_numero <- function() { numero <- runif(1, min = 0, max = 10) numero_inteiro <- round(numero) return(numero_inteiro) } sortear_numero()

6. Rode help(sample) para descobrir o que a função sample() faz. Em seguida:

a. Use a função sample() para escrever uma função que devolva uma linha aleatória de um data frame.

sortear_linha <- function(data_frame) { num_linhas <- nrow(data_frame) linha_sorteada <- sample(1:num_linhas, 1) data_frame[linha_sorteada, ] } sortear_linha(mtcars)

b. Generalize a função para retornar um número qualquer de linhas, que poderá ser escolhido por quem for usá-la.

sortear_linha <- function(data_frame, n) { num_linhas <- nrow(data_frame) linha_sorteada <- sample(1:num_linhas, n) data_frame[linha_sorteada, ] } sortear_linha(mtcars, 10)

1. Por que o código abaixo retorna erro? Arrume o código para retornar o valor TRUE.

x <- 4 if(x = 4) { TRUE }

**Porque a expressão dentro do if deve retornar um valor lógico (TRUE ou FALSE) e o código x = 4 é uma atribuição (equivalente a x <- 4). O correto seria utilizar == em vez de =.*

x <- 4 if(x == 4) { TRUE }

2. Usando if e else, escreva um código que retorne a string "número" caso um valor x seja da classe numeric ou integer; a string "palavra" caso seja da classe character; e NA caso contrário.

x <- 10 if (class(x) == "numeric" | class(x) == "integer") { "número" } else if (class(x) == "character") { "palavra" } else { NA }

Uma solução mais simples seria utilizar as funções is.numeric() e is.character().

x <- "qualquer texto" if (is.numeric(x)) { "número" } else if (is.character(x)) { "palavra" } else { NA }

3. Usando apenas for e a função length(), construa uma função que calcule a média de um vetor numérico qualquer. Construa uma condição para a função retornar NULL caso o vetor não seja numérico.

minha_media <- function(vetor) { soma <- 0 for (i in 1:length(vetor)) { soma <- soma + vetor[i] } media <- soma / length(vetor) return(media) } minha_media(c(1, 2))

4. Utilize o vetor a para resolver as questões a seguir:

a <- c(10, 3, 5, -1, 3, -4, 8, 9, -10)

a. Utilize o for para imprimir as médias acumuladas do vetor a, isto é, primeiro vamos imprimir 10, depois a média entre 10 e 3, depois a média entre 10, 3 e 5 e assim por diante.

soma <- 0 for(i in 1:length(a)) { soma <- soma + a[i] print(soma / i) }

b. Adapte o laço que você fez no item anterior para ignorar os valores negativos, isto é, em caso de valor negativo, o laço não deve calcular a média e não imprimir nada.

soma <- 0 divisor <- 0 for(i in 1:length(a)) { if (a[i] >= 0) { soma <- soma + a[i] divisor <- divisor + 1 print(soma / divisor) } }

1. Qual a diferença entre as funções read_csv() e read_csv2()?

A função read_csv() lê arquivos CSV separados por vírgula (padrão norte-americano). A função read_csv2() lê arquivos CSV separados por ponto-e-vírgula (padrão brasileiro, já que usamos a vírgula como separador de decimais).

2. Leia o arquivo imdb.csv utilizando a função read_delim().

library(readr) read_delim("imdb.csv", delim = ",")

3. Escreva a base mtcars em um arquivo mtcars.csv que não contenha o nome das colunas.

write_csv(mtcars, "mtcars.csv", col_names = FALSE)

4. Use a função write_rds() para salvar em arquivos

a) Um número.

numero <- 29 write_rds(numero, "numero.rds")

b) Um vetor de strings.

estados <- c("SP", "RN", "AC", "MG") write_rds(estados, "estados.rds")

c) Uma lista com valores númericos, textuais e lógicos.

lista <- list(numero = 1, texto = c("M", "F", "F"), logico = FALSE) write_rds(lista, "lista.rds")

d) As 3 primeiras colunas da base mtcars.

write_rds(mtcars[,1:3], "mtcars_3_colunas.rds")

5. Utilize a função read_rds() para importar de volta para o R os arquivos criados no exercício 4.

read_rds("numero.rds") read_rds("estados.rds") read_rds("lista.rds") read_rds("mtcars_3_colunas.rds")

1. Reescreva a expressão abaixo utilizando o %>%.

round(mean(sum(1:10)/3), digits = 1) 1:10 %>% sum %>% divide_by(3) %>% round(digits = 1)

2. Reescreva o código abaixo utilizando o %>%.

# Setamos a semente que gera números aleatórios para deixar o resultado reprodutível set.seed(137) x <- rnorm(100) x.pos <- x[x>0] media <- mean(x.pos) saida <- round(media, 2) saida

set.seed(137) rnorm(100) %>% magrittr::extract(. > 0) %>% mean %>% round(digits = 2)

3. Sem rodar, diga qual a saída do código abaixo. Consulte o help das funções caso precise.

2 %>% add(2) %>% c(6, NA) %>% mean(na.rm = T) %>% equals(5)

• Primeiro, somamos 2 com 2, gerando o valor 4.
• Então colocamos esse valor em um vetor com os valores 6 e NA.
• Em seguida, tiramos a média desse vetor, desconsiderando o NA, obtendo o valor 5.
• Por fim, testemos se o valor é igual a 5, obtendo o valor TRUE.

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?

A função glimpse() traz um resumo da base, contendo o número de linhas, colunas, o nome e tipo das colunas e as primeiras observações de cada coluna.

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

imdb_simples <- select(imdb, titulo, diretor, orcamento) imdb_simples

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

select(imdb, contains("ator"))

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.

select(imdb, -starts_with("ator")) select(imdb, -ator_1, -ator_2, -ator_3) select(imdb, -(ator_1:ator_3)) select(imdb, titulo:likes_facebook) select(imdb, -contains("ator"))

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

filmes_ordenados <- arrange(imdb, ano, desc(receita))

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

# Aninhando as funções arrange(select(imdb, titulo, orcamento), desc(orcamento)) # Criando objeto intermediário imdb_aux <- select(imdb, titulo, orcamento) arrange(imdb_aux, desc(orcamento)) # Pipe s2 imdb %>% select(titulo, orcamento) %>% arrange(desc(orcamento))

Utilize a base imdb nos exercícios a seguir.

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

# Vendo categorias da variável cor unique(imdb$cor)

# Filtrando imdb %>% filter(cor == "Black and White")

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.

curtos_legais <- imdb %>% filter(duracao <= 90, nota_imdb > 8.5)

3. Retorne tabelas (tibbles) apenas com:

a. filmes coloridos anteriores a 1950;

imdb %>% filter(cor == "Color", ano < 1950)

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

imdb %>% filter(diretor == "Woody Allen" | diretor == "Wes Anderson")

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

imdb %>% filter(diretor == "Steven Spielberg") %>% arrange(desc(ano)) %>% select(titulo, ano)

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

library(stringr) # Solução 1 imdb %>% filter(str_detect(generos, "Action") | str_detect(generos, "Comedy"))

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

imdb %>% filter(str_detect(generos, "Action"), str_detect(generos, "Comedy"))

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

imdb %>% filter(is.na(orcamento), is.na(receita))

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.

imdb_prejuizo <- imdb %>% mutate(prejuizo = orcamento - receita) imdb_prejuizo %>% filter(prejuizo > 0) %>% arrange(prejuizo)

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")

imdb %>% mutate( lucro = receita - orcamento, lucro_medio = mean(lucro, na.rm = TRUE), lucro_relativo = (lucro - lucro_medio) / lucro_medio, 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).

imdb %>% mutate(antigo_ou_recente = ifelse(ano > 2000, "recente", "antigo"))

Utilize a base imdb nos exercícios a seguir.

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

imdb %>% summarise( duracao_media = mean(duracao, na.rm = TRUE), duracao_mediana = median(duracao, na.rm = TRUE) )

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

imdb %>% filter(duracao < 60) %>% mutate(lucro = receita - orcamento) %>% summarise(lucro_medio = mean(lucro, na.rm = TRUE))

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.

imdb %>% mutate( lucro = receita - orcamento, duracao_cat = ifelse(duracao < 60, "menor 60 min", "60 ou mais min") ) %>% filter(!is.na(lucro)) %>% group_by(duracao_cat) %>% summarise( lucro_medio = mean(lucro, na.rm = TRUE) )

4. Retorne tabelas (tibbles) apenas com:

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

imdb %>% group_by(classificacao) %>% summarise(nota_media = mean(nota_imdb, na.rm = TRUE))

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

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

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

imdb %>% filter(!is.na(diretor)) %>% group_by(diretor) %>% summarise(num_filmes = n()) %>% filter(num_filmes > 10) %>% select(diretor)

Também podemos usar a função count().

imdb %>% filter(!is.na(diretor)) %>% count(diretor, name = "num_filmes") %>% filter(num_filmes > 10) %>% select(diretor)

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.

nota_diretores <- imdb %>% group_by(diretor) %>% summarise(nota_imdb_media = mean(nota_imdb)) nota_diretores

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

imdb %>% left_join(nota_diretores, by = "diretor") %>% select(nota_imdb_media, everything())

library(stringr) library(dplyr) library(glue)

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.

# Sem regex formata_CPF <- function(num) { if(str_count(num) != 11) { stop("Número inválido!") } # Concatemos cada parte do número, interpolando # com os pontos e o traço. s <- str_c( str_sub(num, start = 1, end = 3), ".", str_sub(num, start = 4, end = 6), ".", str_sub(num, start = 7, end = 9), "-", str_sub(num, start = 10, end = 11) ) } # Com regex formata_CPF <- function(num) { if(str_count(num) != 11) { stop("Número inválido!") } str_replace( string = num, pattern = "([0-9]{3})([0-9]{3})([0-9]{3})", replacement = "\\1.\\2.\\3-" ) }

A função str_replace() faz o seguinte:

• O pattern= procurará um padrão de 9 números:
  • O primeiro ([0-9]{3}) pega os três primeiros números.
  • O segundo ([0-9]{3}) pega os três próximos números (quarto ao sexto).
  • O terceiro ([0-9]{3}) pega os três números seguintes (sétimo ao nono).
• O replacement= substituirá esses 9 números pela string formada por:
  • \\1, a expressão dada pelo primeiro parêntese do pattern=, isto é, os três primeiros números.
  • ., o primeiro ponto.
  • \\2, a expressão dada pelo segundo parêntese do pattern=, isto é, os três próximos números (quarto ao sexto).
  • ., o segundo ponto.
  • \\3, a expressão dada pelo terceiro parêntese do pattern=, isto é, os três números seguintes (sétimo ao nono).
  • -, o traço.

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

s <- c('Alto', 'Médio', 'Baixo') # Usando str_c() str_c("0", 1:length(s), " - ", s, sep = "") ## [1] "01 - Alto" "02 - Médio" "03 - Baixo" # Usando o pacote glue glue("0{1:length(s)} - {s}") ## 01 - Alto ## 02 - Médio ## 03 - Baixo

Para mais informações sobre o pacote glue, confira este post.

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') str_detect(s, "[CcAaSsAa]") ## [1] TRUE TRUE TRUE TRUE str_detect(s, "[Cc][Aa][Ss][Aa]") ## [1] TRUE TRUE TRUE TRUE

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 a função str_split().

url <- c('/ac/rio-branco/xpto-xyz-1-0-1fds2396-5') UF <- url %>% str_split("[/]", simplify = TRUE) %>% .[1,2] %>% str_to_upper() cidade <- url %>% str_split("[/]", simplify = TRUE) %>% .[1,3] %>% str_replace("-", " ") %>% str_to_title() str_c(UF, " - ", cidade) ## [1] "AC - Rio Branco"

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

# Solução 1: usando a função rev() para inverter uma string fragmentada testa_palindromo <- function(s) { s %>% str_split("", simplify = T) %>% rev %>% str_c(collapse = "") %>% str_detect(s) } testa_palindromo("ana") ## [1] TRUE testa_palindromo("bananas") ## [1] FALSE testa_palindromo("socorrammesubinoonibusemmarrocos") ## [1] TRUE # Solução 2: usando a função str_reverse() do pacote stringi, # que já inverte a string diretamente. testa_palindromo <- function(s) { s %>% stringi::stri_reverse() %>% str_detect(s) } testa_palindromo("ana") ## [1] TRUE testa_palindromo("bananas") ## [1] FALSE testa_palindromo("socorrammesubinoonibusemmarrocos") ## [1] TRUE

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:

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

Crie uma função para corrigi-lo.

# Função que funciona para o exemplo corrige_mn <- function(s) { s %>% str_replace("nb", "mb") %>% str_replace("md", "nd") } corrige_mn(s) ## [1] "Nós chamamos os bombeiros quando começou o incêndio." # Função que funciona no caso geral corrige_mn <- function(s) { s %>% str_replace_all("m([^aeioubp[[:space:]]+])", "n\\1") %>% str_replace_all("n([pb])", "m\\1") } corrige_mn(s) ## [1] "Nós chamamos os bombeiros quando começou o incêndio."

O padrão [^aeioubp[[:space:]]+] significa “tudo menos vogais, b, p ou espaços”. O \\1 devolve o padrão encontrado pelo primeiro parêntese do argumento patern=.

7. Considere o seguinte texto

s <- "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 (`ymd`, `mdy`, `dmy`, `dym`, `myd`, `ydm`)."

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

str_extract_all(s, "[ymd]{3}") %>% unlist() %>% unique ## [1] "ymd" "mdy" "dmy" "dym" "myd" "ydm"

8. Considere as frases abaixo

s <- c( 'O produto é bom.', 'O produto não é bom.', 'O produto não é muito bom.', 'O produto é muito bom', 'O produto não é ruim.', 'O produto não é 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 for positivo e FALSE caso contrário.

feedback <- function(s) { s %>% str_replace("não bom", "ruim") %>% str_replace("não ruim", "bom") %>% str_replace("muito ", "") %>% str_detect("(.*) produto é bom|(.*) não é ruim") } feedback(s) ## [1] TRUE FALSE FALSE TRUE TRUE FALSE TRUE

library(dplyr) library(lubridate) library(ggplot2) lakers <- tibble::as_tibble(lakers)

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

lakers %>% mutate(date = ymd(date)) ## # A tibble: 34,624 × 13 ## date opponent game_type time period etype team player result points ## <date> <chr> <chr> <chr> <int> <chr> <chr> <chr> <chr> <int> ## 1 2008-10-28 POR home 12:00 1 jump … OFF "" "" 0 ## 2 2008-10-28 POR home 11:39 1 shot LAL "Pau G… "miss… 0 ## 3 2008-10-28 POR home 11:37 1 rebou… LAL "Vladi… "" 0 ## 4 2008-10-28 POR home 11:25 1 shot LAL "Derek… "miss… 0 ## 5 2008-10-28 POR home 11:23 1 rebou… LAL "Pau G… "" 0 ## 6 2008-10-28 POR home 11:22 1 shot LAL "Pau G… "made" 2 ## 7 2008-10-28 POR home 11:22 1 foul POR "Greg … "" 0 ## 8 2008-10-28 POR home 11:22 1 free … LAL "Pau G… "made" 1 ## 9 2008-10-28 POR home 11:00 1 foul LAL "Vladi… "" 0 ## 10 2008-10-28 POR home 10:53 1 shot POR "LaMar… "made" 2 ## # … with 34,614 more rows, and 3 more variables: type <chr>, x <int>, y <int>

Repare que as_date() não funciona neste caso.

lakers %>% mutate(date = as_date(date)) ## # A tibble: 34,624 × 13 ## date opponent game_type time period etype team player result points ## <date> <chr> <chr> <chr> <int> <chr> <chr> <chr> <chr> <int> ## 1 56949-12-27 POR home 12:00 1 jump … OFF "" "" 0 ## 2 56949-12-27 POR home 11:39 1 shot LAL "Pau G… "miss… 0 ## 3 56949-12-27 POR home 11:37 1 rebou… LAL "Vladi… "" 0 ## 4 56949-12-27 POR home 11:25 1 shot LAL "Derek… "miss… 0 ## 5 56949-12-27 POR home 11:23 1 rebou… LAL "Pau G… "" 0 ## 6 56949-12-27 POR home 11:22 1 shot LAL "Pau G… "made" 2 ## 7 56949-12-27 POR home 11:22 1 foul POR "Greg … "" 0 ## 8 56949-12-27 POR home 11:22 1 free … LAL "Pau G… "made" 1 ## 9 56949-12-27 POR home 11:00 1 foul LAL "Vladi… "" 0 ## 10 56949-12-27 POR home 10:53 1 shot POR "LaMar… "made" 2 ## # … with 34,614 more rows, and 3 more variables: type <chr>, x <int>, y <int>

Para entender porque a função devolveu um dia do ano 56949, rode os códigos abaixo.

as_date(0) ## [1] "1970-01-01" as_date(-3:3) ## [1] "1969-12-29" "1969-12-30" "1969-12-31" "1970-01-01" "1970-01-02" ## [6] "1970-01-03" "1970-01-04" as_date(20081027:20081029) ## [1] "56949-12-26" "56949-12-27" "56949-12-28"

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

lakers %>% mutate(date_time = paste0(date, " 00:", time) %>% ymd_hms) %>% select(date_time) ## # A tibble: 34,624 × 1 ## date_time ## <dttm> ## 1 2008-10-28 00:12:00 ## 2 2008-10-28 00:11:39 ## 3 2008-10-28 00:11:37 ## 4 2008-10-28 00:11:25 ## 5 2008-10-28 00:11:23 ## 6 2008-10-28 00:11:22 ## 7 2008-10-28 00:11:22 ## 8 2008-10-28 00:11:22 ## 9 2008-10-28 00:11:00 ## 10 2008-10-28 00:10:53 ## # … with 34,614 more rows

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

lakers %>% mutate( date = ymd(date), dia = day(date), mes = month(date), ano = year(date) ) %>% select(date, dia, mes, ano) ## # A tibble: 34,624 × 4 ## date dia mes ano ## <date> <int> <dbl> <dbl> ## 1 2008-10-28 28 10 2008 ## 2 2008-10-28 28 10 2008 ## 3 2008-10-28 28 10 2008 ## 4 2008-10-28 28 10 2008 ## 5 2008-10-28 28 10 2008 ## 6 2008-10-28 28 10 2008 ## 7 2008-10-28 28 10 2008 ## 8 2008-10-28 28 10 2008 ## 9 2008-10-28 28 10 2008 ## 10 2008-10-28 28 10 2008 ## # … with 34,614 more rows

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

Dicas: arremessos são representados pela categoria shot da coluna etype e cada período tem 12 minutos.

lakers %>% dplyr::filter(etype == "shot", period == 1, team == "LAL") %>% dplyr::mutate( time = hms(paste0("00:", time)), cronometro = 12*60 - minute(time)*60 - second(time) ) %>% dplyr::group_by(date) %>% dplyr::filter(cronometro == min(cronometro)) %>% dplyr::ungroup() %>% dplyr::summarise(media = mean(cronometro)) ## # A tibble: 1 × 1 ## media ## <dbl> ## 1 29.6

O que foi feito:

• Primeiro filtramos a base para arremessos, etype == "shot", do primeiro período, period ==, que fossem do Lakers, team == "LAL".

• Em seguida, mudamos a classe da coluna time, de character para period, e criamos a coluna cronometro, que contém o tempo passado (em segundos) até o instante do evento.

• Então agrupamos a base pelo dia e a filtramos apenas para o primeiro evento de cada dia, isto é, o evento que tem o menor valor na coluna cronometro. Assim, a coluna cronometro da base resultante terá o tempo do primeiro arremesso de cada jogo.

• Por fim, desagrupamos a base e calculamos a média da coluna cronometro.

5. Em média, quanto tempo demora para sair a primeira cesta de três pontos em cada um dos quatro períodos? Considere toda a base, e cestas de ambos os times.

lakers %>% dplyr::filter(etype == "shot", period %in% 1:4, points == "3") %>% dplyr::mutate(time = hms(paste0("00:", time)), cronometro = 12*60 - minute(time)*60 - second(time)) %>% dplyr::group_by(date, period) %>% dplyr::filter(cronometro == min(cronometro)) %>% dplyr::ungroup() %>% dplyr::group_by(period) %>% dplyr::summarise(media = mean(cronometro)) ## # A tibble: 4 × 2 ## period media ## <int> <dbl> ## 1 1 202. ## 2 2 219. ## 3 3 203. ## 4 4 192.

A resolução desse exercício é análoga ao anterior, só mudamos o filtro inicial e o agrupamento. Se você ficou com dúvidas, consulte o passo a passo na resolução do exercício 4.

Repare que não precisarímos filtrar por etype == "shot", já que o único evento que gera 3 pontos é a cesta de 3 pontos.

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

lakers %>% filter(points > 0, team == "LAL") %>% dplyr::mutate( time = hms(paste0("00:", time)), tempo_segundos = 60 * minute(time) + second(time), dif = tempo_segundos - lead(tempo_segundos), period = as.character(period) ) %>% filter(dif >= 0) %>% ggplot(aes(x = period, y = dif)) + geom_boxplot()

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

cesta_demorada <- lakers %>% filter(points > 0, team == "LAL", period == 1) %>% dplyr::mutate( time = hms(paste0("00:", time)), time = 60 * minute(time) + second(time), date = ymd(date), dia = day(date), mes = month(date), ) %>% group_by(date) %>% filter(time == max(time)) %>% ungroup() %>% slice_min(time) cesta_demorada %>% select(date, opponent, dia, mes) ## # A tibble: 1 × 4 ## date opponent dia mes ## <date> <chr> <int> <dbl> ## 1 2009-04-12 MEM 12 4 tempo_seg <- 12*60 - cesta_demorada$time seconds_to_period(tempo_seg) ## [1] "2M 37S"

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

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"))

A função do R base as.factor() ordena os níveis do fator em ordem alfabética. A função as_factor() do pacote forcats ordena os níveis do fator na ordem que eles aparecem no vetor.

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")) frutas ## [1] maçã banana mamão laranja melancia ## Levels: banana laranja maçã mamão melancia # preferência do Willy lvls_reorder(frutas, c(4, 5, 1, 3, 2)) ## [1] maçã banana mamão laranja melancia ## Levels: mamão melancia banana maçã laranja

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.

levels(series) ## [1] "Breaking Bad" "Friends" "Game of Thrones" ## [4] "How I Met your Mother" "Lost" "The Office" # preferência do Willy series <- lvls_reorder(series, c(6, 5, 1, 3, 2, 4))

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("Stranger Things", "The Boys", "Queen's Gambit")) series <- series %>% fct_c(novas_series) levels(series) ## [1] "The Office" "Lost" "Breaking Bad" ## [4] "Game of Thrones" "Friends" "How I Met your Mother" ## [7] "Queen's Gambit" "Stranger Things" "The Boys" series <- lvls_reorder(series, c(1:7, 9, 8)) levels(series) ## [1] "The Office" "Lost" "Breaking Bad" ## [4] "Game of Thrones" "Friends" "How I Met your Mother" ## [7] "Queen's Gambit" "The Boys" "Stranger Things"

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.

series %>% fct_recode( "A Guerra dos Tronos" = "Game of Thrones", "Como Eu Conheci Sua Mãe" = "How I Met your Mother", "A Química do Mal" = "Breaking Bad", "O Gambito da Rainha" = "Queen's Gambit" ) ## [1] A Guerra dos Tronos Como Eu Conheci Sua Mãe Friends ## [4] Lost The Office A Química do Mal ## [7] Stranger Things The Boys O Gambito da Rainha ## 9 Levels: The Office Lost A Química do Mal A Guerra dos Tronos ... Stranger Things

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

mtcars %>% tibble::rownames_to_column("modelo") %>% mutate(modelo = fct_reorder(modelo, mpg)) %>% 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.

dados::casas %>% mutate(vizinhanca = fct_lump_n(vizinhanca, 9, other_level = "Outras vizinhanças")) %>% group_by(vizinhanca) %>% summarise(venda_valor = mean(venda_valor, na.rm = TRUE)) %>% mutate(vizinhanca = fct_reorder(vizinhanca, venda_valor)) %>% ggplot(aes(x = venda_valor, y = vizinhanca)) + geom_col()

library(dplyr) library(purrr) library(ggplot2)

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

map(mtcars, mean) ## $mpg ## [1] 20.09062 ## ## $cyl ## [1] 6.1875 ## ## $disp ## [1] 230.7219 ## ## $hp ## [1] 146.6875 ## ## $drat ## [1] 3.596563 ## ## $wt ## [1] 3.21725 ## ## $qsec ## [1] 17.84875 ## ## $vs ## [1] 0.4375 ## ## $am ## [1] 0.40625 ## ## $gear ## [1] 3.6875 ## ## $carb ## [1] 2.8125

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.

testar_vogal <- function(x) { if(x %in% c("a", "e", "i", "o", "u")) { return(TRUE) } else { return(FALSE) } } # retornando uma lista map(letters, testar_vogal) ## [[1]] ## [1] TRUE ## ## [[2]] ## [1] FALSE ## ## [[3]] ## [1] FALSE ## ## [[4]] ## [1] FALSE ## ## [[5]] ## [1] TRUE ## ## [[6]] ## [1] FALSE ## ## [[7]] ## [1] FALSE ## ## [[8]] ## [1] FALSE ## ## [[9]] ## [1] TRUE ## ## [[10]] ## [1] FALSE ## ## [[11]] ## [1] FALSE ## ## [[12]] ## [1] FALSE ## ## [[13]] ## [1] FALSE ## ## [[14]] ## [1] FALSE ## ## [[15]] ## [1] TRUE ## ## [[16]] ## [1] FALSE ## ## [[17]] ## [1] FALSE ## ## [[18]] ## [1] FALSE ## ## [[19]] ## [1] FALSE ## ## [[20]] ## [1] FALSE ## ## [[21]] ## [1] TRUE ## ## [[22]] ## [1] FALSE ## ## [[23]] ## [1] FALSE ## ## [[24]] ## [1] FALSE ## ## [[25]] ## [1] FALSE ## ## [[26]] ## [1] FALSE # retornando um vetor (2 soluções equivalentes) map(letters, testar_vogal) %>% flatten_lgl() ## [1] TRUE FALSE FALSE FALSE TRUE FALSE FALSE FALSE TRUE FALSE FALSE FALSE ## [13] FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE TRUE FALSE FALSE FALSE ## [25] FALSE FALSE map_lgl(letters, testar_vogal) ## [1] TRUE FALSE FALSE FALSE TRUE FALSE FALSE FALSE TRUE FALSE FALSE FALSE ## [13] FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE TRUE FALSE FALSE FALSE ## [25] FALSE 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.

operacao <- function(x) { if (x %% 2 == 0) { return(x / 2) } else { return(x * 2) } } operacao(2) ## [1] 1 operacao(3) ## [1] 6 map_dbl(1:100, operacao) ## [1] 2 1 6 2 10 3 14 4 18 5 22 6 26 7 30 8 34 9 ## [19] 38 10 42 11 46 12 50 13 54 14 58 15 62 16 66 17 70 18 ## [37] 74 19 78 20 82 21 86 22 90 23 94 24 98 25 102 26 106 27 ## [55] 110 28 114 29 118 30 122 31 126 32 130 33 134 34 138 35 142 36 ## [73] 146 37 150 38 154 39 158 40 162 41 166 42 170 43 174 44 178 45 ## [91] 182 46 186 47 190 48 194 49 198 50

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()).

imdb <- readr::read_rds("imdb.rds") # gerando uma lista de gráficos fazer_grafico <- function(tab, ano_) { tab %>% filter(ano == ano_) %>% ggplot(aes(x = orcamento, y = receita)) + geom_point() } anos <- unique(imdb$ano) graficos <- map(anos, fazer_grafico, tab = imdb) # gerando uma coluna na tabela imdb fazer_grafico2 <- function(tab) { tab %>% ggplot(aes(x = orcamento, y = receita)) + geom_point() } imdb_com_graficos <- imdb %>% group_by(ano) %>% tidyr::nest() %>% mutate( grafico = map(data, fazer_grafico2) )

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.

imdb <- readr::read_rds("imdb.rds") salvar_base <- function(tab, ano_) { tab %>% filter(ano == ano_) %>% readr::write_rds(file = paste0("teste/imdb_", ano_, ".rds")) } anos <- imdb %>% filter(!is.na(ano)) %>% pull(ano) walk(anos, salvar_base, tab = imdb)

library(dplyr) library(ggplot2)

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.

tabela_qualquer <- tibble::tibble( x = c(1, 2, 3, NA, 6), y = c("a", "b", NA, "d", "e") ) filtrar_na <- function(tab, coluna) { tab %>% filter(!is.na({{coluna}})) } filtrar_na(tabela_qualquer, x) ## # A tibble: 4 × 2 ## x y ## <dbl> <chr> ## 1 1 a ## 2 2 b ## 3 3 <NA> ## 4 6 e filtrar_na(tabela_qualquer, y) ## # A tibble: 4 × 2 ## x y ## <dbl> <chr> ## 1 1 a ## 2 2 b ## 3 NA d ## 4 6 e # string como argumento filtrar_na <- function(tab, coluna) { tab %>% filter(!is.na(.data[[coluna]])) } filtrar_na(tabela_qualquer, "x") ## # A tibble: 4 × 2 ## x y ## <dbl> <chr> ## 1 1 a ## 2 2 b ## 3 3 <NA> ## 4 6 e filtrar_na(tabela_qualquer, "y") ## # A tibble: 4 × 2 ## x y ## <dbl> <chr> ## 1 1 a ## 2 2 b ## 3 NA d ## 4 6 e

2. Escreva uma função que recebe uma tibble e uma coluna e faz um gráfico de barras da frequência dessa coluna.

criar_grafico <- function(tab, coluna) { tab %>% count({{coluna}}) %>% ggplot(aes(x = {{coluna}}, y = n)) + geom_col() } criar_grafico(mtcars, cyl)

# string como argumento criar_grafico <- function(tab, coluna) { tab %>% count(.data[[coluna]]) %>% ggplot(aes(x = .data[[coluna]], y = n)) + geom_col() } criar_grafico(mtcars, "cyl")

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.

fazer_grafico_disp <- function(tab, col1, col2) { tab %>% ggplot(aes(x = {{col1}}, y = {{col2}})) + geom_point() } fazer_grafico_disp(mtcars, mpg, wt)

# string como argumento fazer_grafico_disp <- function(tab, col1, col2) { tab %>% ggplot(aes(x = .data[[col1]], y = .data[[col2]])) + geom_point() } fazer_grafico_disp(mtcars, "mpg", "wt")

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.

calcular_media <- function(tab, col_grupo, col_num) { tab %>% group_by({{col_grupo}}) %>% summarise(media = mean({{col_num}}, na.rm = TRUE)) } calcular_media(mtcars, cyl, mpg) ## # A tibble: 3 × 2 ## cyl media ## <dbl> <dbl> ## 1 4 26.7 ## 2 6 19.7 ## 3 8 15.1 # string como argumento calcular_media <- function(tab, col_grupo, col_num) { tab %>% group_by(.data[[col_grupo]]) %>% summarise(media = mean(.data[[col_num]], na.rm = TRUE)) } calcular_media(mtcars, "cyl", "mpg") ## # A tibble: 3 × 2 ## cyl media ## <dbl> <dbl> ## 1 4 26.7 ## 2 6 19.7 ## 3 8 15.1

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.

Os softwares descritos anteriormente são suficientes para realizar as tarefas básicas em R. Porém, principalmente quando tratamos de relatórios com R, alguns softwares adicionais podem ser necessários em casos específicos! A seguir citamos alguns destes softwares, em quais casos eles são necessários e/ou úteis, e instruções sobre como instalá-los.

O LaTeX é um software para renderização de documentos PDF e também uma linguagem de programação. É bastante usada na academia para produção de artigos científicos.

No R, o LaTeX aparece quando queremos gerar relatórios e apresentações em PDF, a partir de um documento RMarkdown. Na prática, o RMarkdown é transformado para LaTeX através do software Pandoc1, que por sua vez é processado para gerar o PDF. Portanto, para gerar um relatório em PDF através do RMarkdown, precisamos ter alguma ferramenta de LaTeX instalada.

A recomendação das pessoas que desenvolvem o RMarkdown é a utilização do tinytex, uma distribuição leve do LaTeX.

install.packages('tinytex') tinytex::install_tinytex() # instalar o TinyTeX

Caso você encontre algum problema para instalar o TinyTex, também é possível instalar outros editores de LaTex. A seguir estão apresentadas algumas opções!

Uma distribuição de LaTeX que apresenta versão para Windows é o MiKTeX.

1. Para instalá-lo, primeiramente faça o download do arquivo .exe através deste link, escolhendo a versão de instalação para Windows.

2. Abra o arquivo baixado. Uma janela irá abrir, e a primeira etapa de instalação é a “Copying Conditions”. Nesta etapa você deve selecionar a opção “I accept the MiKTeX copying conditions” e clicar em “Avançar”.

1. A próxima etapa da instalação, chamada de “Installation Scope”, você deve escolher em qual usuário o software deve ser instalado. Selecione a primeira opção (“Install MiKTeX only for me.”) para que o MiKTeX seja instalado apenas no seu usuário atual no computador. Essa é a opção recomendada. Então clique em ”Avançar”.

1. Na etapa “Installation Directory”, escolha o diretório em que o MiKTeX será instalado. Caso tenha dúvidas sobre isso, não altere nada e utilize o caminho padrão de instalação. Então clique em “Avançar”.

1. Na etapa “Settings”, utilize as configurações padrão e clique em “Avançar”.

1. Na etapa “Review”, são apresentadas as configurações escolhidas anteriormente. Clique em Start para que a instalação seja começada.

1. O processo de instalação será realizado, e pode demorar alguns minutos. Duas barras verdes aparecerão para demonstrar a porcentagem da instalação já realizada. Quando essa etapa terminar, as barras ficarão cinzas e o você deverá clicar no botão Start.

1. Na etapa “Update Check”, aparecerá a opção de buscar por atualizações. Mantenha o botão “Check for updates now” selecionado, e clique no botão Start.

1. A próxima janela mostrará uma mensagem dizendo que a instalação foi completa. Clique no botão Close para fechar essa janela.

1. Abra o MiKTeX console através do menu Iniciar do Windows. No menu lateral, escolha a opção “Updates”. Clique em “Check for updates”, e o MiKTeX buscará informações sobre as possíveis atualizações necessárias. Então clique em “Update now”, para que as atualizações sejam baixadas e instaladas. Essa etapa também pode demorar um pouco!

1. Após instalar as atualizações, o MiKTeX avisará que ele precisa ser fechado. Abra-o novamente. Após este processo, o MiKTex estará pronto para uso.

No linux, a forma mais direta de garantir que temos o LaTeX na máquina com todas as dependências é instalando o texlive-full. No Ubuntu, basta rodar

Importante: o texlive-full é uma forma “bruta” de instalar tudo do LaTeX, e pode ocupar mais do que 5GB do seu disco! Então tome cuidado e procure alternativas, como as descritas neste site.

Uma distribuição de LaTeX que apresenta versão para MacOS é o MikTex. Para instalá-lo, primeiramente faça o download do arquivo .dmg através deste link. Este tutorial apresenta todos os passos de instalação no MacOS, porém abaixo também vamos descrever os passos:

1. Faça o download do arquivo .dmg através deste link, escolhendo a versão de instalação para MacOS.

2. Abra o arquivo baixado. Uma janela irá abrir, e você deve arrastar o ícone “MiKTeX Console” para a pasta “Applications” (como mostrado na animação abaixo, sendo necessário arrastar apenas uma vez).

1. No Launchpad (menu de arquivos instalados), procure o ícone do “MiKTeX Console” e abra-o. Você também pode usar a pesquisa do MacOS (utilizando o atalho Command + Barra de espaço), pesquisando por MiKTeX para abrir o software.

2. Ao abrir pela primeira vez, o MiKTeX solicitará que você selecione uma opção para que a instalação seja completada. Selecione “Finish private setup”, e isso fará com que o MiKTeX esteja disponível apenas no seu usuário do computador. Após selecionar essa opcão, ele terminará a configuração, e aparecerá uma mensagem dizendo que o MiKTex será reiniciado. Espere até que ele reinicie. Ao final, aparecerá uma mensagem dizendo que é necessário fazer atualizações no MiKTeX.

1. No menu lateral, escolha a opção “Updates”. Clique em “Check for updates”, e o MiKTex buscará informações sobre as possíveis atualizações necessárias. Então clique em “Update now”, para que as atualizações sejam baixadas e instaladas.

1. Após instalar e atualizar, o MiKTeX está pronto para uso!

No R, os arquivos do pacote office também são gerados a partir do Pandoc. Por isso, não é necessário instalar nenhum software adicional para gerar os documentos.

No entanto, para abrir documentos do Office, como .pptx e .docx, é necessário ter o Office ou alguma alternativa aberta instalados.

Além disso, por conta das particularidades desses tipos de documentos, muitas vezes é necessário instalar pacotes adicionais, que não vêm com o {rmarkdown}. Abaixo, segue uma lista de pacotes usualmente utilizados nesse contexto:

• {officedown}.
• {officer}, que é uma dependência do {officedown}.
• {flextable}, para geração de tabelas.
• {svglite}, para renderizar gráficos em SVG.

Uma dica adicional: É possível gerar gráficos editáveis nos documentos Office! Dessa forma, você pode gerar o relatório bruto e depois editar manualmente. Para isso, siga o tutorial deste vídeo do YouTube. Referência: link.

O LibreOffice pode ser instalado através deste link, escolhendo o sistema operacional “Windows” e clicando em “Baixar” e executando o arquivo baixado.

No linux, a forma mais fácil de abrir documentos provenientes do Office é utilizando o LibreOffice:

O LibreOffice possui algumas limitações quando comparado ao software da Microsoft. Por exemplo, as tabelas que saem bonitas no Office podem ficar desformatadas no LibreOffice.

o LibreOffice 7.2 não está ainda no aptitude. Se quiser instalar essa versão, é possível baixar o arquivo .deb no site da ferramenta.

O sistema operaciona MacOS disponibiliza o iWork, que é composto pelas ferramentas Numbers, Pages e Keynote. Esses programas possibilitam abrir arquivos provenientes do Office.

Outra opção é a utilização do LibreOffice.

1. Primeiro, faça o download do arquivo .dmg de instalação, através deste link, escolhendo o sistema operacional “MacOS” e clicando em “Baixar”.

2. Após baixar o arquivo, abra-o. Uma janela irá abrir (como na imagem a seguir). Você deve arrastar o ícone “LibreOffice” para a pasta “Applications” (como mostrado na animação abaixo, sendo necessário arrastar apenas uma vez).

1. O LibreOffice será instalado e você poderá utilizá-lo abrindo através do Launchpad (menu de arquivos instalados), ou também utilizando a pesquisa do Mac (utilizando o atalho Command + Barra de espaço), pesquisando por LibreOffice para abrir o software.

O {pagedown} é uma alternativa recente para produzir arquivos em HTML utilizando o paged.js, uma biblioteca em JavaScript que torna um arquivo HTML muito parecido com um PDF. Com a ajuda do Chrome, é possível, inclusive, exportar o arquivo para PDF.

O {pagedown}, portanto, apresenta o melhor de dois mundos: a praticidade da extensão HTML e a portabilidade de arquivos PDF. Dessa forma, é possível gerar documentos PDF com formatos agradáveis sem depender do LaTeX.

No entanto, para gerar documentos PDF, é preciso utilizar um navegador. O navegador recomendado pelo {pagedown} é o Chrome, tanto que o pacote já vem com a função pagedown::chrome_print(), que pode ser utilizada para transformar um arquivo HTML ou RMarkdown em PDF.

Se você já tiver o Chrome instalado na sua máquina, provavelmente tudo funcionará sem problemas. Se não tiver e não quiser instalar, é possível instalar somente o headless Chrome.

No linux, uma alternativa é instalar o projeto Chromium, que é quase que totalmente open source.

Os HTML widgets são formas de ligar bibliotecas do JavaScript com pacotes do R. Isso permite gerar relatórios dinâmicos em HTML diretamente do R. O pacote {htmlwidgets} possui um conjunto de melhores práticas para criação dessas soluções.

No entanto, é comum utilizar HTML widgets em relatórios estáticos. Para isso, o R precisa de uma estratégia para tirar fotos estáticas dos widgets. Isso é realizado através do pacote {webshot}.

Você pode instalar o {webshot} executando o código abaixo:

install.packages("webshot")

Para que o {webshot} funcione, no entanto, também é necessário ter o PhantomJS instalado na máquina. O PhantomJS é basicamente um navegador que roda totalmente no plano de fundo, possibilitando a captura de tela.

Para instalar o PhantomJS, execute o código abaixo:

webshot::install_phantomjs()

Para criar blogs utilizando o pacote {blogdown}, também é necessário instalar o Hugo, programa que renderiza sites estáticos.

Felizmente, essa tarefa é bem tranquila pois o {blogdown} já vem com um helper para isso. Basta executar o código abaixo e reiniciar a sua sessão do R para que o Hugo seja instalado:

Em algumas situações (como por exemplo, no desenvolvimento de pacotes), é solicitada a instalação de ferramentas de desenvolvimento. Essas ferramentas dependem do sistema operacional utilizado.

No caso do desenvolvimento de pacotes, você pode verificar se já possui as ferramentas de desenvolvimento instaladas usando a seguinte função: devtools::has_devel(). Caso a mensagem retornada seja “Your system is ready to build packages!”, significa que você já tem as ferramentas necessárias instaladas.

devtools::has_devel() #> Your system is ready to build packages!

No Linux, caso seja necessário, você também pode instalar o pacote r-base-dev. Por exemplo, no Ubuntu você pode instalá-lo executando o seguinte código no terminal:

O Xcode command line tools é uma ferramenta de desenvolvimento oficial da Apple. Para instalar essa ferramenta, primeiramente é preciso acessar o Terminal. Você pode encontrar o Terminal procurando na lista de programas instalados (Launchpad), ou então na opção de busca (usando o atalho: command + barra de espaço) e escrevendo Terminal.

No terminal, escreva o seguinte código e aperte Enter, o que iniciará a instalação:

Siga as instruções apresentadas para instalar.

Caso a seguinte mensagem apareça, significa que você já tem a ferramenta instalada: error: command line tools are already installed, use "Software Update" to install updates.

Caso queira confirmar que a instalação foi bem sucedida, execute no terminal o código a seguir. Caso a mensagem de retorno seja um caminho (por exemplo: /Library/Developer/CommandLineTools), significa que a instalação foi bem sucedida, e esse é o caminho onde a ferramenta foi instalada.

O Git é um programa para linha de comando que possibilita realizar o controle de versões dos arquivos em um diretório (ou seja, em uma pasta). Para instalar esse sistema de controle de versões distribuído, acesse a página sobre Download do Git, escolha o seu sistema operacional, siga as instruções apresentadas para instalação.

O RStudio é sem dúvidas o mais completo ambiente de desenvolvimento para programação em R. Descubra aqui as funcionalidades do RStudio que nos permitem escrever códigos e analisar resultados de forma muito mais eficiente.

Ao abrir o RStudio, você verá 4 quadrantes. Observe a figura abaixo.

Esses quadrantes representam o editor, o console, o environment e o output. Eles vêm nesta ordem, mas você pode organizá-los da forma que preferir acessando a seção Pane Layout da opção Global options... no menu Tools.

O editor e o console são os dois principais painéis do RStudio. Passaremos a maior parte do tempo neles.

• Editor/Scripts: é onde escrevemos nossos códigos. Repare que o RStudio colore algumas palavras e símbolos para facilitar a leitura do código.
• Console: é onde rodamos o código e recebemos as saídas. O R vive aqui!

Os demais painéis são auxiliares. O objetivo deles é facilitar pequenas tarefas que fazem parte tanto da programação quanto da análise de dados, como olhar a documentação de funções, analisar os objetos criados em uma sessão do R, procurar e organizar os arquivos que compõem a nossa análise, armazenar e analisar os gráficos criados e muito mais.

• Environment: painel com todos os objetos criados na sessão.
• History: painel com um histórico dos comandos rodados.
• Files: mostra os arquivos no diretório de trabalho. É possível navegar entre diretórios.
• Plots: painel onde os gráficos serão apresentados.
• Packages: apresenta todos os pacotes instalados e carregados.
• Help: janela onde a documentação das funções serão apresentadas.
• Viewer: painel onde relatórios e dashboards serão apresentados.

Conhecer os atalhos do teclado ajuda bastante quando estamos programando no RStudio. Veja os principais:

• CTRL+ENTER: roda a(s) linha(s) selecionada(s) no script. O atalho mais utilizado.
• ALT+-: cria no script um sinal de atribuição (<-). Você o usará o tempo todo.
• CTRL+SHIFT+M: (%>%) operador pipe. Guarde esse atalho, você o usará bastante.
• CTRL+1: altera cursor para o script.
• CTRL+2: altera cursor para o console.
• CTRL+ALT+I: cria um chunk no R Markdown.
• CTRL+SHIFT+K: compila um arquivo no R Markdown.
• ALT+SHIFT+K: janela com todos os atalhos disponíveis.

No MacBook, os atalhos geralmente são os mesmos, substituindo o CTRL por command e o ALT por option.

O RStudio possui funcionalidades para quem trabalha com o programa Git para versionar arquivos.

Além disso, quando você inicia o Git na pasta raiz de um projeto, o RStudio criará uma nova abinha chamada Git, onde você pode confirir os arquivos modificados que estão à espera de um commit.

Para saber mais sobre Git e versionamento de arquivos, leia esse excelente capítulo do Zen do R.

O RStudio tem à disposição algumas folhas de cola, as cheatsheets. Elas trazem um resumão de como utilizar diversos pacotes e até o próprio RStudio.

Para acessá-las, basta clicar no menu Help e então em Cheatsheets.

Outra forma de acessá-las é através do site da RStudio, onde existem muitas opções de cheatsheets, incluindo algumas traduzidas para o Português.

Addins são cápsulas de código R que podem ser executados interativamente a partir do menu Addins.

Eles servem para fazer diversos tipos de tarefas, como identar seu código, ajudar nas tarefas de copiar e colar, insirir códigos no seu script e muito mais.

Os addins são criados pelos pacotes que instalamos, então cada pacote vai nos disponibizar addins que facilitam algum tipo de tarefa.

Veja aqui um exemplo de um addin que formata um código e aqui um addin que filtra uma base.

O pacote {CursoR} da Curso-R, por exemplo, tem um addin que auxilia quem faz nossos cursos a atualizar o material de cada aula.

Snippets são atalhos que podemos criar para gerar pedaços rotineiros de código.

O RStudio já vem com vários snippets criados. Você pode visualizar os snippts existentes ou criar novos acessando Tools > Global Options... > Code > Editting > Snippets > Edit snippets.

No arquivo de texto aberto, basta seguir o padrão dos snippets já existentes para criar novos. Você também pode editar os snippets padrão do RStudio.

Cada snippet terá um nome, que deverá ser utilizado no script para ativar o código guardado por trás.

Basta escrever o nome, apertar a teclar TAB e voilà.

Introduziremos aqui os principais conceitos de programação em R. Indicamos a leitura deste capítulo a quem nunca teve contato com uma linguagem de programação ou a quem gostaria de entender um pouco melhor a estrutura de objetos, funções e classes do R.

Os tópicos discutidos aqui são especialmente importantes para entendermos o que é um data frame, a nossa base de dados dentro do R, e quais operações estão sendo realizadas por trás das cortinas quando estivermos filtrando suas linhas ou modificando suas colunas. Também são importantes para começarmos a criar as nossas próprias funções, o que deixa nossos códigos muito mais organizados, eficientes e compartilháveis.

Na linguagem R é possível fazer bastante coisa à base da tentativa e erro. Além disso, grande parte do conhecimento é escalável, isto é, aprender a utilizar uma função é meio caminho andado para aprender todas as outras funções que operam de forma semelhante2.

No entanto, a intuição não é infalível, e recorrentemente vamos precisar de ajuda para rodar alguma função ou descobrir como fazer alguma tarefa no R. Felizmente, a comunidade R é bem ativa e existem vários lugares para buscar respostas. Nesta seção, vamos apresentar algumas dessas maneiras.

Figura 3.1: Arte por Allison Horst (@allison_horst). Veja nas Referências onde encontrá-la.

No R, há quatro principais entidades para se pedir ajuda:

• Help/documentação do R
• Google
• Stack Overflow
• Coleguinha

A busca por ajuda é feita preferencialmente, mas não necessariamente, na ordem acima.

A documentação do R serve para você aprender a usar uma determinada função. Se você não sabe o que é uma função, não se preocupe. Discutiremos esse tópico nas Seções 3.3 e 3.11.

Você pode acessar a documentação de uma função3 através de dois comandos: ?nome_da_funcao ou help(nome_da_funcao). Por exemplo, para acessar a documentação da função mean, fazemos:

Algumas dicas:

1. Leia a seção Usage para ter noção de como usar a função.
2. Os parâmetros da função estão descritos em Arguments.
3. Os exemplos no final são particularmente úteis.
4. Caso essa função não atenda às suas necessidades, a seção See Also sugere funções relacionadas.

Alguns pacotes possuem tutoriais de uso mais completos. Esses textos são chamados de vignettes e podem ser acessados com a função vignette(package = 'nomeDoPacote'). Por exemplo, vignette(package = 'dplyr').

Há uma comunidade gigantesca de R gerando diariamente uma infinidade de conteúdos e discussões. Não raramente, você irá encontrar discussões sobre o seu problema simplesmente o descrevendo no Google. Pesquisas em inglês aumentam consideravelmente a chance de encontrar uma resposta.

Quando você recebe um erro na tentativa de rodar algum código no R e não sabe o que está errado, uma boa estratégia é pesquisar a mensagem de erro no Google. Essa deve ser sua primeira tentativa para resolver o problema. Repare na imagem abaixo o ‘r’ adicionado na busca. Isso ajuda bastante a encontrar uma solução.

log("5") ## Error in log("5"): non-numeric argument to mathematical function

O Stack Overflow e o Stack Overflow em Português são sites de Pergunta e Resposta amplamente utilizados por todas as linguagens de programação, e o R é uma delas. Nos EUA, chegam até a usar a reputação das pessoas dentro da plataforma como diferencial no currículo!

Provavelmente o Google lhe indicará uma dessas quando você estiver procurando ajuda. E quando todas as fontes possíveis de ajuda falharem, o Stack Overflow lhe dará o espaço para criar sua própria pergunta.

Um ponto importante: como fazer uma boa pergunta no Stack Overflow?

No site, existe um tutorial com uma lista de boas práticas, que se encontra aqui. Resumindo, as principais dicas são

• fazer perguntas concisas;
• fazer perguntas específicas;
• ter mente aberta; e
• ser gentil.

Porém, no caso do R, há outro requisito que vai aumentar muito sua chance de ter uma boa resposta: exemplinho minimal e reprodutível.

• Ser minimal: usar bancos de dados menores e utilizar pedaços de códigos apenas suficientes para apresentar o seu problema. Não precisa de banco de dados de um milhão de linhas e nem colocar o seu código inteiro para descrever a sua dúvida.

• Ser reprodutível: o seu código deve rodar fora da sua máquina. Se você não fornecer uma versão do seu problema que rode (ou que imite seu erro), as pessoas vão logo desistir de te ajudar. Por isso, nunca coloque bancos de dados que só você tem acesso. Use bancos de dados que já vem no R ou disponibilize um exemplo (possivelmente anonimizado) em .csv na web para baixar. E se precisar utilizar funções de algum pacote, especifique os pacotes que você usou.