ex_data_transformation.qmd

---
title: "Exercícios: Transformação de dados"
subtitle: "Introdução à ciência de dados"
author: "Daniel Brito dos Santos"
format: 
  revealjs:
    incremental: true
---

# 4.2.5 Exercícios sobre linhas

## 1. Encontre todos os voos que 

a. Tiveram um atraso de chegada de duas ou mais horas

. . .

```r
flights |> 
  filter(arr_delay > 120)
```

---

b. Voaram para Houston (IAH ou HOU)

. . .

```r
flights |> filter(dest == "IAH" | dest == "HOU")
```


---

c. Foram operados pela United, American ou Delta

. . .

```r
flights |> 
  filter(carrier %in% c("UA", "AA", "DL"))
```

---

d. Partiu no verão (julho, agosto e setembro)

. . .

```r
flights |> 
  filter(month %in% c(7, 8, 9))
```

---


e. Chegou com mais de duas horas de atraso, mas não saiu atrasado

. . .

```r
flights |> 
  filter(arr_delay > 120, dep_delay <= 0)
```

---

f. Atrasaram-se em pelo menos uma hora, mas compensaram mais de 30 minutos de voo

. . .

```r
flights |>
  mutate(gain = dep_delay - arr_delay) |>
  filter(dep_delay >= 60, gain > 30)
```

---

## 2. Ordene o dataset `flights` para encontrar os voos com os maiores atrasos de partida. Encontre os voos que partiram mais cedo pela manhã.

. . . 

```r
flights |> 
  arrange(desc(dep_delay), dep_time)
```

. . .

```r
flights |> 
  arrange(desc(dep_delay))
```

```r
flights |> 
  arrange(dep_time)
```

## 3. Ordene o dataset `flights` para encontrar os voos mais rápidos (dica: é um cálculo)

- Rapidez aqui seria velocidade, não necessáriamente duração, quase todo mundo pegou essa, muito bom!

. . .

```r
flights |> 
  mutate(speed = distance / air_time * 60) |> 
  arrange(desc(speed))
```

## 4. Houve pelo menos um voo em cada dia do ano 2013?

. . .

```r
flights |> 
  distinct(day, month) |> 
  summarize(n = n() == 365)
```

. . .

```r
flights |> 
  distinct(day, month)
```


## 5. Quais voos viajaram a maior distância? Quais viajaram as distâncias mais curtas?

. . .

```r
flights |> 
  arrange(distance)
```

. . .

```r
flights |> 
  distinct(desc(distance))
```


## 6. Faz diferença a ordem que você usa `filter()` e `arrange()` se for usar os dois? Por que ou por que não? Considere os resultados e o trabalho que as funções vão ter que fazer.


# 4.3.5 Exercícios sobre colunas

## 1. Compare `air_time` com `arr_time - dep_time`.

### O que você espera ver? O que você viu? O que precisa fazer para consertar? 

---

- Tá comparando HHMM com minutos
- Vamos transformar em minutos depois das 00:00
- Alguém se arrisca a transformar 245 em 165?
- Podemos usar divisão inteira!
- 245 %/% 100 = 2
- 245 %% 100 = 45
- 2*60 + 45 = 165

---

```r
flights |>
  mutate(
    arr_time_min = 60*(arr_time %/% 100) + (arr_time %% 100),
    dep_time_min = 60*(dep_time %/% 100) + (dep_time %% 100),
    calc_air_time = arr_time_min - dep_time_min, 
    diff = air_time - calc_air_time,
    .keep = "used"
    )
```


<!-- ```{r}
flights |> 
  mutate(arr_dep_time = arr_time - dep_time, dif = arr_dep_time - air_time) |> 
  select (air_time, arr_dep_time, dif) |> 
  arrange(desc(dif)) 
```
- Esperamos que o tempo no ar do voo seja igual a diferença entre a hora que ele saiu para a hora que ele chegou. -->

## 2. Compare `dep_time`, `sched_dep_time` e `dep_delay`. Como você espera que esses três números se relacionem? 

## 4. O que acontece se você incluir um nome de variável múltiplas vezes em uma chamada `select()`?

## 5. O que a função `any_of()` faz? Como ela pode ser útil com o seguinte vetor?
```r
variables <- c("year", "month", "day", "dep_delay", "arr_delay")
```

. . .

```r
flights |>
  select(any_of(variables))
# A tibble: 336,776 × 5
    year month   day dep_delay arr_delay
   <int> <int> <int>     <dbl>     <dbl>
#>  1  2013     1     1         2        11
#>  2  2013     1     1         4        20
#>  3  2013     1     1         2        33
#>  4  2013     1     1        -1       -18
#>  5  2013     1     1        -6       -25
#>  6  2013     1     1        -4        12
#>  7  2013     1     1        -5        19
#>  8  2013     1     1        -3       -14
#>  9  2013     1     1        -3        -8
#> 10  2013     1     1        -2         8
#> # … with 336,766 more rows
#> # ℹ Use `print(n = ...)` to see more rows
```


# 6.
- O resultado do código a seguir de surpreende? 
- Como as funções auxiares (helper functions) de `select()` lidam com esse caso por padrão? 
- Como podemos alterar esse padrão?
```r
select(flights, contains("TIME"))
```

. . . 

```r
#> # A tibble: 336,776 × 6
#>    dep_time sched_dep_time arr_time sched_arr_time air_time time_hour          
#>       <int>          <int>    <int>          <int>    <dbl> <dttm>             
#>  1      517            515      830            819      227 2013-01-01 05:00:00
#>  2      533            529      850            830      227 2013-01-01 05:00:00
#>  3      542            540      923            850      160 2013-01-01 05:00:00
#> # … with 336,766 more rows
#> # ℹ Use `print(n = ...)` to see more rows
```

. . .

```r
select(flights, contains("TIME", ignore.case = FALSE))

# A tibble: 336,776 × 0
# ℹ Use `print(n = ...)` to see more rows
```


# 4.4.6 Exercícios sobre grupos

## 1. Qual operadora tem os piores atrasos? 
- Desafio: você consegue separar os efeitos de aeroportos ruins versus companhias aéreas ruins? Por que/por que não? 

. . .

```r
flights |> 
  group_by(carrier) |> 
  summarise(arr_delay = mean(arr_delay, na.rm = TRUE)) |>
  arrange(desc(arr_delay))
```

- O desafio segue aberto. 
- A abordagem é de alguma forma comparar atraso por rota com o atraso de determinada empresa naquela rota 

## 2. Encontre o voo mais atrasado para cada destino.

. . . 

```r
flights |> 
  group_by(dest) |> 
  slice_max(arr_delay, n = 1)
```

## 3. Como os atrasos variam ao longo do dia? ilustre a resposta com um gráfico. 

```r
flights |>
  mutate(dep_time_min = (60*(arr_time %/% 100) + (arr_time %% 100)) %% 1440) |>
  group_by(dep_time_min) |> 
  summarize(
    mean_delay_per_time = mean(dep_delay, na.rm = TRUE),
    n_flights = n()) |> 
  ggplot(aes(x=dep_time_min, y=mean_delay_per_time, alpha=n_flights)) +
  geom_point()
```
---

```{r}
library(tidyverse)
library(nycflights13)

flights |>
  mutate(dep_time_min = (60*(arr_time %/% 100) + (arr_time %% 100)) %% 1440) |>
  group_by(dep_time_min) |> 
  summarize(
    mean_delay_per_time = mean(dep_delay, na.rm = TRUE),
    n_flights = n()) |> 
  ggplot(aes(x=dep_time_min, y=mean_delay_per_time, alpha=n_flights)) +
  geom_point()
```


## 4. O que acontece se você fornecer um `n` negativo para `slice_min()` e as suas amigas?

## 5. Explique o que `count()` significa em termos dos verbos dplyr que você aprendeu. O que faz o argumento `sort`? 

## 6. Suponha que você tem o seguinte data frame:
```r
df <- tibble(
  x = 1:5,
  y = c("a", "b", "a", "a", "b"),
  z = c("K", "K", "L", "L", "K")
)
```

---

a. O que esse código faz? Rode, analise o resultado e diga o que o `group_by()` faz. 

. . .

```r
df |>
  group_by(y)
```


---

b. O que o código a seguir faz? Execute-o, analise o resultado e descreva o que o ``array()`` faz. Comente também como é diferente do ``group_by()`` na pergunta. 

. . .

```r
df |>
  arrange(y)
```

---

c. O que faz o código a seguir? Execute-o, analise o resultado e descreva o que essa faz pipeline (sequência de pipes).

. . .

```r
df |>
  group_by(y) |>
  summarize(mean_x = mean(x))
```

---

d. O que faz o código a seguir? Execute-o, analise o resultado e descreva o que essa pipeline faz. Depois comente sobre o que a mensagem diz. 

. . .

```r
df |>
  group_by(y, z) |>
  summarize(mean_x = mean(x))
```

---

e. O que faz o código a seguir? Execute-o, analise o resultado e descreva o que essa pipeline faz. Como esse output é diferente do output anterior (questão d)?

. . .

```r
df |>
  group_by(y, z) |>
  summarize(mean_x = mean(x), .groups = "drop")
```

---

f. O que essas pipelines fazem? Execute ambas, analise os resultados e descreva cada uma. Qual é a diferença dos seus resultados? 

. . . 

```r
df |>
  group_by(y, z) |>
  summarize(mean_x = mean(x))

df |>
  group_by(y, z) |>
  mutate(mean_x = mean(x))
```

# Até a próxima