OBRADA PODATAKA

# OBRADA PODATAKA
## Predavanje 5: Manipulacija i prilagodba podataka (data.table)
### Luka Sikic, PhD
### Fakultet hrvatskih studija | <a href="https://github.com/BrbanMiro/Obrada-podataka">OP</a>

---

# Pregled predavanja

1. [Set-up](#prologue)

2. [Uvod](#intro)

3. [data.table osnove](#basics)

4. [Manipulacija redovima: DT[i, ]](#i)

5. [Manipulacija kolonama: DT[, j]](#j)

6. [Grupiranje: DT[, , by]](#by)

7. [Ključevi](#keys)

8. [Spajanje podataka](#merge)

9. [Preoblikovanje](#reshape)

10. [data.table + tidyverse](#tidyverse)

10. [Sažetak](#summary)

---
class: inverse, center, middle
name: prologue

# Set-up

<html><div style='float:left'></div><hr color='#EB811B' size=1px width=796px></html>
(Postavke za rad sa data.table paketom!)
---

# Checklist

Ove pakete ćemo koristit u predavanju:
- Već instalirani: **dplyr**, **ggplot2**, **nycflights13**
- Novi: **data.table**, **tidyfast**, **dtplyr**, **microbenchmark**

Ovaj kod će instalirati (ako je potrebno) i učitati sve potrebne pakete za predavanje.

```r
if (!require(pacman)) install.packages('pacman', repos = 'https://cran.rstudio.com')
```

```
## Warning: package 'pacman' was built under R version 4.0.3
```

```r
pacman::p_load(dplyr, data.table, dtplyr, tidyfast, microbenchmark, ggplot2, nycflights13)
options(dplyr.summarise.inform = FALSE) ## Isključi dplyr group_by poruke 
```

---
class: inverse, center, middle
name: intro

# Uvod

<html><div style='float:left'></div><hr color='#EB811B' size=1px width=796px></html>
(Osnova za korištenje data.table paketa!)

---

# Zašto uopće data.table?

**tidyverse** je sjajan način za manipulaciju podatcima. Također, može se koristiti za rad sa Big Data podatcima  (SQL databases, Spark, etc.)

Zašto je potrebna druga sintaksa za manipulaciju podatcima?

Nekoliko je razloga za  **data.table**:

1. Koncizna sintaksa
2. Nevjerojatna brznia
3. Memorijska efikasnost
4. Mnoštvo mogućnosti (+ stabilnost)
5. Nema zavisnosti (o drugim paketima, instalacijama, etc.)

Prije detalja, pogledajte nekoliko primjera...

---

# Zašto uopće data.table? (dalje)

### 1) Konciznost

Ova dva koda postižu istu stvar:

```r
# library(dplyr) ## Učitano
# data(starwars, package = "dplyr") ## Uvezi podatke u GEnvir
starwars %>% 
  filter(species=="Human") %>% 
  group_by(homeworld) %>% 
  summarise(mean_height=mean(height)) 
```
vs
```r
# library(data.table) ## Učitano
starwars_dt = as.data.table(starwars)
starwars_dt[species=="Human", mean(height), by=homeworld]
```

---
name:fast

# Zašto uopće data.table? (dalje)

### 2) Brzina

```r
collapse_dplyr = function() {
  storms %>%
    group_by(name, year, month, day) %>% 
    summarize(wind = mean(wind), pressure = mean(pressure), category = dplyr::first(category))
  }
storms_dt = as.data.table(storms)
collapse_dt = function() {
  storms_dt[, .(wind = mean(wind), pressure = mean(pressure), category = first(category)),
            by = .(name, year, month, day)]
  }
microbenchmark(collapse_dplyr(), collapse_dt(), times = 10)
```

```
## Unit: milliseconds
##              expr      min       lq      mean    median       uq      max neval
##  collapse_dplyr() 121.4271 136.5441 147.48845 143.75100 153.2597 190.6388    10
##     collapse_dt()   2.3583   2.6939   3.82609   2.83105   3.3484   8.7030    10
```
]

---

# Zašto uopće data.table? (dalje)

### 3) Efikasnost

Mjerenje i usporedba memorijske efikasnosti je relativno komplicirana [stvar](https://stackoverflow.com/a/61376971). Za detalje [pogledajte](https://jangorecki.gitlab.io/r-talks/2019-06-18_Poznan_why-data.table/why-data.table.pdf) (nakon 12-og slide) data.table funkcionalnosti.

### 4) Mogućnosti i 5) Nezavisnost

Ova dva čimbenika idu zajedno jer su povezani sa stabilnošću koda. Nezavisnost se ondosi na  [na](http://www.tinyverse.org/):

```r
tools::package_dependencies("data.table", recursive = TRUE)[[1]]
```
```
## [1] "methods"
```

```r
tools::package_dependencies("dplyr", recursive = TRUE)[[1]]
```
```
##  [1] "ellipsis"   "assertthat" "glue"       "magrittr"   "methods"    "pkgconfig" 
##  [7] "R6"         "Rcpp"       "rlang"      "tibble"     "tidyselect" "utils"     
## [13] "BH"         "plogr"      "tools"      "cli"        "crayon"     "fansi"     
## [19] "lifecycle"  "pillar"     "vctrs"      "purrr"      "grDevices"  "utf8"      
## [25] "digest"  
```

---

# Prije nastavka...

Cilj ovog predavanja *nije* pokazati da je data.table superiorniji pristup od tidyverse. (Niti  vice versa.)

Ljudi imaju različite stavove i to je u redu...

Cilj je prikazati još jedan alat kojim se može manipulirati velikim (i malim) skupovima podataka na efikasan način u programskom jeziku R...

- Poznavanje oba pristupa će vam povećati efikasnost i napraviti od vas boljeg R korisnika/istraživača/podatkovnog znanstvenika/etc.

Aspekt komplementarnosti ćemo obraditi na kraju predavanja.

---

# data.table osnove
<html><div style='float:left'></div><hr color='#EB811B' size=1px width=796px></html>
(Snalaženje u sintaksi paketa!)
---

# data.table objekt

Već smo vidjeli da `tidyerse` omogućava specifičnu i unaprijeđenu varijantu `data.frame`-a u formi `tibble` .

Jednako vrijedi i za `data.table` . Sintaksa `data.table` zapravo funkcionira samo na objektima koji su prvo pretvoreni u `data.table`(slično kao `tibble`), a specijalna interna struktura `data.table` objekta je glavni razlog za iznimnu brzinu. (Više pogledajte [ovdje](https://rdatatable.gitlab.io/data.table/articles/datatable-intro.html#what-is-datatable-1a) i [ovdje](https://twitter.com/matloff/status/1131372631372918784).)

`data.table` možete naraviti na nekoliko načina:
- `fread('mydata.csv')` učitava `CSV` u `R` kao `data.table` (+ extremno brzo).<sup>1</sup>
- `data.table(x = 1:10)` stvara novi `data.table` ni iz čega
- `as.data.table(df)` pretvara postojeći `data.frame` (dalje: `df`) u `data.table`.
- `setDT(df)` pretvara postojeći `df` u `data.table` *prema referenci*; i.e. nije potrebno pripisivanje novom objektu (*reasign*)

---

# Što znači "pretvaranje prema referenci"?

Upravo je to ono što čini data.table tako izvrsnim: modifikacije se, u slučaju gdje je to moguće, izvode *prema referenci*.

Što to znači?

Bez da ulazimo u detalje, kratko objašnjenje se odnosi na to da R ima dva načina za izmjenu i pripisivanje objekata.
1. **Copy-on-modify:** Stvara kopiju podataka. Implicira dodate računalne resurse.<sup>*</sup>
2. **Modify-in-place:** Ne stvara kopiju nego direktno utječe na memoriju.

.footnote[<sup>*</sup> Valja spomenuti da je važno  napraviti distinkciju između <i>shallow</i> i <i>deep copies</i>.]

data.table "modificira prema referenci" jer mjenja objekte na **modify-in-place** način. Upravo to povećava efikasnost i smanjuje memorijsku zahtjevnost!

P.S.Dodatno pogledajte ako vas ovo zanima: (a) [Semantičke reference](https://rdatatable.gitlab.io/data.table/articles/datatable-reference-semantics.html) za data.table vignette-u, (b) [Names and Values](https://adv-r.hadley.nz/names-values.html) poglavlja *Advanced R* (Hadley Wickham), (c) Izvrstan i protočan [blog post](https://tysonbarrett.com//jekyll/update/2019/07/12/datatable/).

---

# data.table sintaksa

Svi data.table objekti imaju istu osnovnu sintaksu:

.center[
.large2[DT[<span style='color: #66C2A5;'>i</span>, <span style='color: #FC8D62;'>j</span>, <span style='color: #8DA0CB;'>by</span>]]
]

![:col_row <span style='color: #66C2A5;'>Po kojim redovima?</span>, <span style='color: #FC8D62;'>Što učiniti?</span>, <span style='color: #8DA0CB;'>Grupiranje prema...</span>]

.center[dplyr "ekvivalenti":]
![:col_list <span style='color: #66C2A5;'>filter(); slice(); arrange()</span>, <span style='color: #FC8D62;'>select(); mutate()</span>, <span style='color: #8DA0CB;'>group_by()</span>]

tidyverse izvršava operacije korok po korak, a data.table izvršava sve u jednom koraku.
- Na taj je nacin moguće izvršiti kompleksnu naredbu kao jednu fluidnu misao.
- Ulančavanje pitem pipe operatora je također moguće.

---

# Brzi primjer

Detalji sljede nakon kratkog data.table primjera.

Ovo je brza paralelna usporedba sa dplyr jer će to motivirati dljnji tok predavanja. Na osnovi *stawars* podataka postavimo pitanje:
> Koja je prosječna visina ljudi po spolu?

```r
data(starwars, package = "dplyr")
starwars %>%
  filter(species=="Human") %>%
  group_by(gender) %>%
  summarise(mean(height, na.rm=T))
```

]

```r
starwars_dt = as.data.table(starwars)
starwars_dt[
  species=="Human", 
  mean(height, na.rm=T), 
  by = gender]
```
]

---

# Brzi primjer

Detalji sljede nakon kratkog data.table primjera.

Brza paralelna usporedba sa dplyr jer će to motivirati predavanje. Na stawars podatcima postavimo pitanje:
> Koja je prosječna visina ljudi po spolu?
.pull-left[
### dplyr

```r
data(starwars, package = "dplyr")
starwars %>%
* filter(species=="Human") %>%
  group_by(gender) %>%
  summarise(mean(height, na.rm=T))
```

]

```r
starwars_dt = as.data.table(starwars)
starwars_dt[
* species=="Human", ## i
  mean(height, na.rm=T), 
  by = gender]
```
]

---

# Brzi primjer

Detalji sljede nakon kratkog data.table primjera.

Brza paralelna usporedba sa dplyr jer će to motivirati predavanje. Na stawars podatcima postavimo pitanje:
> Koja je prosječna visina ljudi po spolu?
.pull-left[
### dplyr

```r
data(starwars, package = "dplyr")
starwars %>%
  filter(species=="Human") %>% 
  group_by(gender) %>%
* summarise(mean(height, na.rm=T))
```

]

```r
starwars_dt = as.data.table(starwars)
starwars_dt[
  species=="Human",
* mean(height, na.rm=T),  ## j
  by = gender]
```
]

---

# Brzi primjer

Detalji sljede nakon kratkog data.table primjera.

Brza paralelna usporedba sa dplyr jer će to motivirati predavanje. Na stawars podatcima postavimo pitanje:
> Koja je prosječna visina ljudi po spolu?
.pull-left[
### dplyr

```r
data(starwars, package = "dplyr")
starwars %>%
  filter(species=="Human") %>% 
* group_by(gender) %>%
  summarise(mean(height, na.rm=T)) 
```

]

```r
starwars_dt = as.data.table(starwars)
starwars_dt[
  species=="Human",
  mean(height, na.rm=T),  
* by = gender] ## by
```
]

---

# Brzi primjer

Detalji sljede nakon kratkog data.table primjera.

Brza paralelna usporedba sa dplyr jer će to motivirati predavanje. Na stawars podatcima postavimo pitanje:
> Koja je prosječna visina ljudi po spolu?
.pull-left[
### dplyr

```r
data(starwars, package = "dplyr")
starwars %>%
  filter(species=="Human") %>%
  group_by(gender) %>%
  summarise(mean(height, na.rm=T))
```

```
## # A tibble: 2 x 2
##   gender    `mean(height, na.rm = T)`
##   <chr>                         <dbl>
## 1 feminine                       160.
## 2 masculine                      182.
```

]

```r
starwars_dt = as.data.table(starwars)
starwars_dt[
  species=="Human", 
  mean(height, na.rm=T), 
  by = gender]
```

```
##       gender       V1
## 1: masculine 182.3478
## 2:  feminine 160.2500
```
]

---
class: inverse, center, middle
name: i

# Manipulacija redovima: DT[i, ]
<html><div style='float:left'></div><hr color='#EB811B' size=1px width=796px></html>
(Smjer prema dolje!)
---

# Indeksiranje po redovima (filter)

Indeksiranje po redovima je jednostavno u `data.table`. Sve radi očekivano ako imate iskustvo sa `dplyr`.

- `DT[x == "string", ]`: Izdvoji redove x koji su jednaki "string"-u.

- `DT[y > 5, ]`: Izdvoji redove u kojima je varijabla y veća od 5.

- `DT[1:10, ]`: Izdvoji prvih 10 redova.

Mnogostruki uvjeti su također dozvoljeni:

- `DT[x=="string" & y>5, ]`: Izdvoji redove gdje je x  "string" **I** y je veći od 5.

Primijetite da ne trebamo zareze kada indeksiramo po `i` (i.e. niti `j` niti `by` funkcijske argumente).
- `DT[x=="string"]` je isto kao `DT[x=="string", ]`
- `DT[1:10]` je isto kao `DT[1:10, ]`
- etc.

---

# Indeksiranje po redovima (filter) (*dalje*)

Ovdje je prethodni primjer indeksiranja na *starwars* `data.table` podatcima (objektu).

```r
starwars_dt[height>190 & species=='Human']
```

```
##                   name height mass hair_color skin_color eye_color birth_year
## 1:         Darth Vader    202  136       none      white    yellow       41.9
## 2:        Qui-Gon Jinn    193   89      brown       fair      blue       92.0
## 3:               Dooku    193   80      white       fair     brown      102.0
## 4: Bail Prestor Organa    191   NA      black        tan     brown       67.0
##     sex    gender homeworld species
## 1: male masculine  Tatooine   Human
## 2: male masculine      <NA>   Human
## 3: male masculine   Serenno   Human
## 4: male masculine  Alderaan   Human
##                                                                        films
## 1: The Empire Strikes Back,Revenge of the Sith,Return of the Jedi,A New Hope
## 2:                                                        The Phantom Menace
## 3:                                  Attack of the Clones,Revenge of the Sith
## 4:                                  Attack of the Clones,Revenge of the Sith
##            vehicles       starships
## 1:                  TIE Advanced x1
## 2:  Tribubble bongo                
## 3: Flitknot speeder                
## 4:
```

---

# Posloži po redovima (arrange)

```r
starwars_dt[order(birth_year)]  ## (privremeno) sortiraj od najmlađeg prema najstarijem
starwars_dt[order(-birth_year)] ## (privremeno) sortiraj od najstarijeg prema najmlađem
```

`data.table` također sadrži optimiziranu `setorder()` funkciju uz slaganje *prema referenci* (*by reference*).

```r
setorder(starwars_dt, birth_year, na.last = TRUE)
starwars_dt[1:5, name:birth_year] ## Prikaži samo dio podataka
```

```
##                     name height mass hair_color skin_color eye_color birth_year
## 1: Wicket Systri Warrick     88   20      brown      brown     brown          8
## 2:                 IG-88    200  140       none      metal       red         15
## 3:        Luke Skywalker    172   77      blond       fair      blue         19
## 4:           Leia Organa    150   49      brown      light     brown         19
## 5:        Wedge Antilles    170   77      brown       fair     hazel         21
```

---
class: inverse, center, middle
name: j

# Manipulacija kolonama: DT[, j]
<html><div style='float:left'></div><hr color='#EB811B' size=1px width=796px></html>
(Smjer desno!)
---

# j: jedno pravilo za sve

Prisjetimo se nekih `dplyr` funkcija:

- `select()`
- `mutate()`
- `summarise()`
- `count()`

`data.table` prepoznaje sve pobrojane funkcije... 
>"*Učini nešto sa ovom varijablom u mojem podatkovnom skupu!*"
... i omogućava da se sve napravi na jednom mjestu: u `j` slot-u.

--
Ipak, potrebno je par sintaktičkih hack-ova vezanih uz način kako pripisujemo varijable u podatkovnom skupu.
- Neki će smatrati ovo odbojnim (ili barem, čudnim) kada se prvi put susretnu sa` data.table`.
- Zapravo se ne radi ni o čemu posebno kompleksnom, a za uzvrat daje *mnoštvo* funkcionalnosti.

---

# Modifikacija kolona sa :=

Za dodavanje, brisanje, mijenjanje u data.table se koristi **`:=`** operator.
- Riječ je o  *walrus* operatoru. [Pogledaj](https://psmag.com/environment/how-do-you-take-down-two-tons-of-blubber-and-tusks)!

Na primjer,

- `DT[, xsq := x^2]`: Napravi novu kolonu (`xsq`) od postojeće (`x`).
- `DT[, x := as.character(x)]`: Promijeni postojeću kolonu.

**Važno:** `:=` je *modifikacija prema referenci*, i.e. "na mjestu". Zbog toga nije potrebno pripisivati promjene novom objektu.

Zbog toga također promjene na objektu nisu vidljive ukoliko to eksplicitno ne tražimo od R.

```r
DT = data.table(x = 1:2)
# DT[, xsq := x^2] ## Promjena na mjestu bez prikaza
DT[, x_sq := x^2][] ## Dodaj [] za prikaz razultata
```

```
##    x x_sq
## 1: 1    1
## 2: 2    4
```

---

# Modifikacija kolona sa := (dalje)

*Modifikacija prema referenci* ima važne implikacije za manipulaciju podatcima. Razmislite što se događa ako kopiramo `data.table` i nakon toga izbrišemo kolonu.

```r
DT_copy = DT
DT_copy[, x_sq := NULL]
```

Očito, "x_sq" je izbrisan iz `DT_copy` objekta. ...ali što se dogodilo sa originalnim `DT` objektom?

```r
DT
```

```
##    x
## 1: 1
## 2: 2
```

---

# Modifikacija kolona sa := (dalje)

Također izbrisano...baš kao što modifikacija prema referenci nalaže. Kako bismo izbjegli ovakvo "ponašanje", moguće je koristiti [`data.table::copy()`](https://rdatatable.gitlab.io/data.table/reference/copy.html) funkciju. Probajte izvšiti sljedeću naredbu:

```r
DT[, x_sq := x^2]     
DT_copy = copy(DT)  
DT_copy[, x_sq := NULL]
DT ## x_sq je još uvijek tu!
```

---

# Modifikacija kolona sa := (dalje)

### Pod-pripisivanje prema referenci

Fantastična funkcionalnost `:=` je `data.table` [sub-assign by reference](https://rdatatable.gitlab.io/data.table/articles/datatable-reference-semantics.html#ref-i-j) funkcionalnost. Za primjer razmotrimo jedan (lažni) skup podataka.

```r
DT2 = data.table(a = -2:2, b = LETTERS[1:5])
```

Zamislite da želimo locirati redove gdje je "a" negativan i zamijeniti pripadajuću "b" ćeliju sa NA.

- U `dplyr` je potrebno napraviti `...mutate(b = ifelse(a < 0, NA, b))`.
--

- U `data.table`, jednstavno specificirajte redove (`i`) i onda pod-pripišite (`j`) direktno.

```r
DT2[a < 0, b := NA][] ## Dodajte [] za prikaz na eranu
```

```
##     a    b
## 1: -2 <NA>
## 2: -1 <NA>
## 3:  0    C
## 4:  1    D
## 5:  2    E
```

---

# Modifikacija kolona sa := (dalje)

Dvije su mogućnosti za manipulaciju više kolna odjednom.

1. LHS `:=` RHS forma: `DT[, c("var1", "var2") := .(val1, val2)]`

2. Funkcionalna forma: `DT[, ':=' (var1=val1, var2=val2)]`

Osobno preporučam funkcionalnu formu pa ćemo to koristiti dalje. E.g.

```r
DT[, ':=' (y = 3:4, y_name = c("three", "four"))]
DT ## Drugi način za print pored []
```

```
##    x x_sq y y_name
## 1: 1    1 3  three
## 2: 2    4 4   four
```

Dinamičko pripisivanje zavisnih kolona u jednom koraku (kao kod `dplyr::mutate`) ne funkcionira.

```r
DT[, ':=' (z = 5:6, z_sq = z^2)][]
```

```
## Error in eval(jsub, SDenv, parent.frame()): object 'z' not found
```

---

# Dodatak: Ulančavanje data.table operacija

Zadnji primjer je ne pokazuje da nije moguće raditi ulančane operacije sa data.table!!!

Prirodni `data.table` način je dodavanje sukcesivnih `[]` operatora.

```r
DT[, z := 5:6][, z_sq := z^2][] 
```

```
##    x x_sq y y_name z z_sq
## 1: 1    1 3  three 5   25
## 2: 2    4 4   four 6   36
```

Ako preferirate **magrittr** pipe operator...dodajte prefiks na `.` na svakom koraku:

```r
# library(magrittr) ## Nije potrebno jer je %>% već učitan via dplyr
DT %>%
  .[, xyz := x+y+z] %>%
  .[, xyz_sq := xyz^2] %>%
  .[] 
```

```
##    x x_sq y y_name z z_sq xyz xyz_sq
## 1: 1    1 3  three 5   25   9     81
## 2: 2    4 4   four 6   36  12    144
```

---

# Modifikacija kolona sa := (dalje)

Za brisanje kolone u podatkovnom skupu možete koristiti NULL.

```r
DT[, y_name := NULL]
DT
```

```
##    x x_sq y z z_sq xyz xyz_sq
## 1: 1    1 3 5   25   9     81
## 2: 2    4 4 6   36  12    144
```

---

# Indeksiranje po kolonama (select)

Moguće je koristiti `j` slot za indeksiranje podataka po kolonama. Pogledajmo *starwars* podatke za primjere...

Indeksiraj prema poziciji kolone:

```r
starwars_dt[1:2, c(1:3, 10)]
```

```
##                     name height mass homeworld
## 1: Wicket Systri Warrick     88   20     Endor
## 2:                 IG-88    200  140      <NA>
```

--
...ili po nazivu:

```r
# starwars_dt[, c("name", "height", "mass", "homeworld")] ## također radi
# starwars_dt[, list(name, height, mass, homeworld)] ## i ovo isto
starwars_dt[1:2, .(name, height, mass, homeworld)]
```

```
##                     name height mass homeworld
## 1: Wicket Systri Warrick     88   20     Endor
## 2:                 IG-88    200  140      <NA>
```

---

# Dodatak: Zašto pak .()?

Već smo vidjeli `.()`na par mjesta, e.g prethodni i [ovaj](#fast) slide ako se sjećate!?
- `.()` je samo data.table kratica za `list()`.

Obilato ćemo koristiti `.()` kada krenemo sa indeksiranjem i/ili grupiranjem više varijabli od jednom.

Možete si objasniti da su to sintaktičke osobine `data.table` ali zapravo je riječ o pristupu koristiti ovu eintaksu izmjenično u `data.table`:
- `.(var1, var2, ...)`
- `list(var1, var2, ...)`
- `c("var1", "var2", ...)`

Meni je `.()` sintaksa izvrsna &mdash; manje tipkanja! &mdash; ali svatko kako voli!

Vratimo se indeksiranju kolona...

---

# Indeksiranje po kolonama (select)

Kolone također možete obrisati negacijom. Isprobajte sljedeći kod:

```r
starwars_dt[, !c("name", "height")]
```

### Preimenovanje kolona

Preimenovanje kolona/e prema referenci. Isprobajte sljedeći kod sami:

```r
setnames(starwars_dt, old = c("name", "homeworld"), new = c"(alias", "crib"))[]
## Promijeni nazad, možda će varijable "name" ili "homeworld" trebati za poslje
setnames(starwars_dt, old = c("alias", "crib"), new = c("name", "homeworld"))
```

`setnames()` pruža neke prednosti  u performansama, npr. kada želite dinamički preimenovati kolone pri indeksiranju. Primjerice:

```r
starwars_dt[1:2, .(alias = name, crib = homeworld)]
```

```
##                    alias  crib
## 1: Wicket Systri Warrick Endor
## 2:                 IG-88  <NA>
```

---

# Indeksiranje po kolonama (select)

Također valja napomenuti da `dplyr` gramatika radi i na `data.table` objektima.

Probajte izvšiti sljedeći kod. (Dobiti ćete upozorenje o gubitku efikasnosti.)

```r
starwars_dt[1:5, ] %>% 
  select(crib = homeworld, everything())
```

Vratiti ćemo se još na `dplyr` + `data.table` funkcionalnost na kraju predavanja....

---

# Agregacija

Moguće su i operacije agregiranja na `j`.

```r
starwars_dt[, mean(height, na.rm=T)]
```

```
## [1] 174.358
```

Sjetite se da ne zadržavamo ništa ako ne pripišemo rezultat novom objektu. Za dodavanje nove kolone sa rezultatima originalnom podatkovnom skupu koristite `:=`.

```r
starwars_dt[, mean_height := mean(height, na.rm=T)] %>% ## Dodaj prosječnu visinu kao kolonu
  .[1:5, .(name, height, mean_height)] ## Zadrži sve
```

```
##              name height mean_height
## 1: Luke Skywalker    172     174.358
## 2:          C-3PO    167     174.358
## 3:          R2-D2     96     174.358
## 4:    Darth Vader    202     174.358
## 5:    Leia Organa    150     174.358
```

---
# Agregacija (dalje)

`data.table` također omogućava [specijalne simbole](https://rdatatable.gitlab.io/data.table/reference/special-symbols.html) za uobičajne agregacijske operacije na `j`.

Na primjer, moguće je izbrojati opervacije sa `.N`.

```r
starwars_dt[, .N]
```

```
## [1] 87
```

Naravno, to je poprilično stiliziran primjer jer ćemo dobiti samo ukupni broj redova u podatcima. Kao i druge agregacijske funkcije, `.N` je puno interesantniji kada je primjenjen na grupirane podatke.
- Ovo je uvod u narednu temu...

---
name: by
class: inverse, center, middle

# Grupiranje: DT[, , by]
<html><div style='float:left'></div><hr color='#EB811B' size=1px width=796px></html>
(Jako korisno!)
---

# by

data.table `by` argument funkcinira slično kao `dplyr::group_by` ekvivalent. Isprobajte sljedeće naredbe u vlastitoj R konzoli:

- `starwars_dt[, mean(height, na.rm=T), by = species]`: Kolapsiraj po varijabli.
- `starwars_dt[, .(species_height = mean(height, na.rm=T)), by = species]`: Kao gore ali po nazivu summary varijable.
- `starwars_dt[, mean(mass, na.rm=T), by = height>190]`: Uvjeti također rade.
- `starwars_dt[, species_n := .N, by = species][]`: Dodaj agregiranu kolonu podatcima (ovdje: broj opservacija po grupama).

Za agregaciju po više varijabli možete koristiti `.()` sintaksu.

```r
starwars_dt[, .(mean_height = mean(height, na.rm=T)), by = .(species, homeworld)] %>%
  head(4) ## stane na slide
```

```
##    species homeworld mean_height
## 1:   Human  Tatooine    179.2500
## 2:   Droid  Tatooine    132.0000
## 3:   Droid     Naboo     96.0000
## 4:   Human  Alderaan    176.3333
```

---

# Efikasno indeksiranje sa .SD

Vidjeli smo kao grupirati više varijabli. Što ako želimo *summarise* više varijabli, nevezano uz to kako grupiramo?

Jedno rješenje je ponovno`.()` Raspišite sve:

```r
## isprobajte sami
starwars_dt[, 
            .(mean(height, na.rm=T), mean(mass, na.rm=T), mean(birth_year, na.rm=T)), 
            by = species]
```
--

Ovo može postati zamorno! Zamislite još varijabli...da li stvarno moramo pisati `mean(..., na.rm=T)` za svaku varijablu?

Odgovor je naravno, "ne". data.table ima `.SD` simbol za **s**ubsetting **d**ata. `.SD` može i [mnogo više](https://rdatatable.gitlab.io/data.table/articles/datatable-sd-usage.html) nego što ćemo prikazati, ali ovako bismo to primijenili u trenutnom slučaju...

---