075-lubridate.Rmd

```{r, include=FALSE}
knitr::opts_chunk$set(
  fig.align = "center",
  cache = TRUE,
  collapse = TRUE
)
```

## O pacote lubridate

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](https://github.com/garrettgman) e [Hadley Wickham](https://github.com/hadley), 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.

```{r, eval = FALSE}
install.packages("lubridate")
library(lubridate)
```

```{r, include=FALSE}
library(lubridate)
library(magrittr)
library(tibble)
library(dplyr)

# https://github.com/tidyverse/lubridate/issues/928
if (grepl("darwin", R.version$os))
  Sys.setenv("TZDIR" = "/Library/Frameworks/R.framework/Resources/share/zoneinfo/")
```

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.

### A classe `date`

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}`:

```{r}
data_string <- "21-10-2015"
class(data_string)

data_date <- date(data_string)
class(data_date)
data_date

data_as_date <- as_date(data_string)
class(data_as_date)
data_as_date

data_mdy <- dmy(data_string)
class(data_mdy)
data_mdy
```

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

```{r}
date("2015-10-21")
as_date("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.

```{r}
dmy(21102015)
dmy("21102015")
dmy("21/10/2015")
dmy("21.10.2015")
```

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.

```{r}
ymd_hms(20151021165411)
```

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

```{r}
data_base <- as.Date("2015-10-21")
class(data_base)
data_base
```

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

```{r}
base::date()
```

### Funções úteis

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.


```{r}
bday <- ymd_hms("1989-07-29 030142")
bday

second(bday)
day(bday)
month(bday)
year(bday)

wday(bday)
wday(bday, label = TRUE)
```

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

```{r}
data <- dmy("01/04/1991")
data

hour(data) <- 20
data
```

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

```{r}
# Data e horário do dia em que essa página foi editada pela última vez.
today() 
now()
```

### Fusos horários

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.

```{r}
estreia_GoT <- ymd_hms("2017-07-16 22:00:00", tz = "America/Sao_Paulo")
estreia_GoT

# Devolve qual seria a data em outro fuso

with_tz(estreia_GoT, tzone = "GMT")
with_tz(estreia_GoT, tzone = "US/Alaska")  

# Altera o fuso sem mudar a hora

force_tz(estreia_GoT, tzone = "GMT")
```

### Operações com datas

O pacote `lubridate` possui ainda funções para calcular intervalos e fazer operações aritméticas com datas.

#### Intervalos {-}

Intervalos podem ser salvos em objetos com classe `interval`.

```{r}
inicio <- dmy("01-04-1991")
evento <- dmy("31-10-1993")

sobrev <- interval(inicio, evento)
sobrev
class(sobrev)
```

Você pode verificar se dois intervalos tem intersecção com a função `int_overlaps()`.

```{r}
# Outra forma de definir um intervalo: o operador %--%
intervalo_1 <- dmy("01-02-2003") %--% dmy("02-03-2005")  

intervalo_2 <- dmy("04-05-2004") %--% dmy("12-03-2012")  

int_overlaps(intervalo_1, intervalo_2)
```

#### Aritmética com datas

Veja alguns exemplos de operações aritméticas que você pode fazer utilizando funções do `lubridate`:

```{r}
# Somando datas

data <- dmy("31/01/2000")

data + ddays(1)
data + dyears(1)

# A operação abaixo retornaria uma data inválida
# por isso obtemos NA
data + months(1)  

# Criando datas recorrentes

reuniao <- dmy("18-03-2017")
reunioes <- reuniao + weeks(0:10)
reunioes

# Duração de um intervalo 

intervalo <-dmy("01-03-2003") %--% dmy("31-03-2003") 

intervalo / ddays(1)               # Número de dias
intervalo / dminutes(1)            # Número de minutos

as.period(intervalo)
```

Para mais informações sobre o`lubridate`, visite o [vignette do pacote](https://cran.r-project.org/web/packages/lubridate/vignettes/lubridate.html).

### Exercícios

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](http://www.nba.com/lakers/) na temporada 2008-2009.

```{r}
lakers %>% as_tibble()
```


**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?