# Načtení balíčku tidyverse (tidyverse je vlastně sada více balíčků)
library(tidyverse)

Orientace v R Studiu
- Konzole
- Vytvoření nového skriptu
- Environment/History/Connections
- Files/Plots/Packages/Help/Viewer
Vytvoření nového projektu: File – New Project
Nastavení vzhledu: `Tools – Global Options – Appearance
Změna klávesových zkratek: Tools – Modify Keyboard Shortcuts

1 R jako kalkulačka

R lze využít jako kalkulačku. Podobné symboly pro matematické operace využívá i Excel.

# Sčítání
5 + 50 
#> [1] 55

# Odčítání
5 - 5
#> [1] 0

# Násobení
3 * 5
#> [1] 15

# Dělení
(5 + 5) / 2 
#> [1] 5

# Umocňování
2^10
#> [1] 1024

# Odmocňování
sqrt(9)
#> [1] 3
9^(1/2)
#> [1] 3
8^(1/3)
#> [1] 2

# Celočíselné dělení
16 %/% 6
#> [1] 2

# Zbytek po celočíselném dělení
16 %% 6
#> [1] 4

2 Klávesové zkrakty

Psaní symbolů na české klávesnici skrze pravý alt:

R Alt + X = hashtag # (používá se pro uvození komentářů ve skriptu)
R Alt + F = hranaté závorky [] (používají se pro výběr prvků – subsetting)
R Alt + B = složené závorky {} (používají se při vytváření funkcí)
R Alt + čárka = menší než <
R Alt + tečka= větší net >
R Alt + ů = znak dolaru $
R Alt + C = znak & (používá se jako logický operátor a zároveň)
R Alt + W = svislice | (používá se jako logický operátor anebo)
R Alt + Š, poté jakýkoli znak = stříška ^
R Alt + Ý, potéjakýkoli znak = zpětný apostrof `` (používá se pro odkazování na nestandardní názvy)

Alternativa - přepnutí na anglickou klávesnici, kde jsou tyty symboly dostupnější.

2.1 Modifikovatelné klávesové zkratky RStudia

Alt + Shift + K pro seznam klávesových zkratek RStudia
Ctrl + Enter pro spuštění aktuálního kódu na označeném řádku
Ctrl + Alt + P znovu spustí kód, který byl spuštěn naposledy
Ctrl + Alt + R spustí všechen kód
Alt + - vloží assigment operátor <- pro tvorbu objektů
Alt + L zabalí aktuální blok kód
Alt + Shift + L rozbalí aktuální blok kód
Alt + O zabalí všechen kód
Alt + Shift + O rozbalí všechen kód
Ctrl + Shift + R vloží nový nadpis
Ctrl + Shift + M vloží pipe operátor %>% (nověji |>)

3 Objekty

3.1 Tvorba objektů

Objekt reprezentují hodnoty (např. “0” nebo “Jablko”) nebo jiné objekty. Např. dataset je objekt obsahující jiné objekty, tj. jednotlivé proměnné.

Nové objekty lze vytvářet pomocí <- ve formě: object_name <- value

Při pojmenování objektů doporučuji používat tzv. snake_case: nepužívat velká písmena a jednotlivá slova/výrazy oddělovat pomocí underscore

i_use_snake_case
otherPeopleUseCamelCase
some.people.use.periods
And_aFew.People_RENOUNCEconvention

# Přidělit objektu x hodnotu 42
x <- 42 

# vyvolat/prozkoumat objekt lze jenoduše napsáním jeho jména
x
#> [1] 42

r_rocks <- 666

# Proč tento kód nefunguje? Je R "case sensitive"?
r_rock
#> Error in eval(expr, envir, enclos): object 'r_rock' not found

R_rocks
#> Error in eval(expr, envir, enclos): object 'R_rocks' not found

# Jde to i naopak?
33 -> y
y
#> [1] 33

Vytvořte proměnnou my_age s hodnotou vašeho věku v letech
Vyvolejte tuto proměnnou
Vytvořte proměnnou year se současným rokem
Odečtěte my_age od year a vytvořte proměnnou birth_year
Vyvolejte proměnnou birth_year

# Změňte hodnotu my_numeric na vaše oblíbené číslo
my_numeric <- 17
my_numeric
#> [1] 17

# Změňte hodnotu my_character např. na jméno vaší oblíbené kapely
my_character <- c("Iron Maiden")
my_character
#> [1] "Iron Maiden"

# Změňte hodnotu my_logical na FALSE
my_logical <- TRUE
my_logical
#> [1] TRUE

# Vyvolejte proměnné my_numeric, my_character i my_logical

# Aplikujte funkci typeof() na objekty my_numeric, my_character i my_logical

Jednou z nejpoužívanějších funkcí je funkce c() (combine, concatenate), která umožňuje sloučit více prvků dohromady čili vytvářet vektory o délce větší než 1.

x <- c(8, 5, 9, 10, 16)
x
#> [1]  8  5  9 10 16

4 Vektory

4.1 Vlastnosti vektorů

Existují dva základní typy vektorů. Atomické vektory (atomic vectors) a listy (lists). Nejdůležitějšími atomickými vektory jsou vektory logické (logical), celá čísla (integer) a reálná čísla (double). Hlavní rozdíl mezi atomickými vektory a listy je ten, že atomické vektory jsou homogenní (všechny prvky jsou stejného typu, např. pouze celá čísla). O atomických vektorech lze uvyžovat jako o jednotlivých proměnných.

Každý vektor má dvě hlavní vlastnosti:

typ, který lze určit pomocí funkce typeof();
a délku, kterou lze určit pomocí funkce lenght()

# letters ja zabudovaný vektor typu character se základními písmeny abecedy
letters
#>  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
#> [20] "t" "u" "v" "w" "x" "y" "z"

typeof(letters)
#> [1] "character"

1:10
#>  [1]  1  2  3  4  5  6  7  8  9 10

typeof(1:10)
#> [1] "integer"

typeof(c(TRUE, FALSE, TRUE))
#> [1] "logical"

x <- list("a", "b", 1:10)
length(x)
#> [1] 3

typeof(x)
#> [1] "list"

length(1:10)
#> [1] 10

length(letters)
#> [1] 26

typeof(c(TRUE, FALSE, 1, 5))
#> [1] "double"

c(TRUE, FALSE, 1, 5)
#> [1] 1 0 1 5

Vektory také mohou obsahovat různá metadata ve formě tzv. atributů. Tyto atributy využívají tzv. augmentované vektory, jimiž jsou například:

Faktory, jejichž základem jsou vektory typu integer;
Data a data-plus-časy, jejichž základem jsou vektory typu double;
data frames a tibbles, jejichž základem jsou listy.

4.2 Základní typy atomických vektorů

Vektory typu logical jsou nejjednodušším typem atomických vektorů, protože mohou nabývat pouze tří možných hodnot: TRUE, FALSE a NA, tj. pravda, nepravda a NA jako chybající hodnota (not available)

c(TRUE, TRUE, FALSE, NA)
#> [1]  TRUE  TRUE FALSE    NA

Mezi numerické vektory (numeric) se řadí vektory typu integer a double čili celá čísla a reálná čísla. Defaultně R vytváří vektory typu double, abychom vytvořili vektor typu integer, musíme za číslo doplnit písmeno L. Také při generování sekvence číšel pomocí dvojtečky je výstupem vektor typu integer.

typeof(1)
#> [1] "double"

typeof(1L)
#> [1] "integer"

typeof(1:10)
#> [1] "integer"

Obvykle není potřeba mezi integers a doubles rozlišovat, ale je třeba mít na paměti, že doubles jsou pouze aproximace. Protože paměť počítače není nekonečná, pamatuje si jen určitý počet desetinnýh míst, a proto se R nemusí někdy chovat tak, jak bychom očekávali.

x <- sqrt(2) ^ 2
x
#> [1] 2

x - 2
#> [1] 4.440892e-16

x == 2
#> [1] FALSE

# Funkce near počítá s nějakou (velmi malou) tolerancí
near(x, 2)
#> [1] TRUE

Vektory typu character jsou nejkomplexnější, protože mohou zahrnovat jakékoli znaky (řetězce znaků) a počet těchto znaků je téměř neomezený.

x <- "This is a reasonably long string."
x
#> [1] "This is a reasonably long string."

4.3 Konverze mezi typy vektorů

Existují dva způsoby, jak kovertovat jeden typ vektoru v jiný: explicitně a implicitně.

Explicitní konverze znamená, že použijeme použijeme přímo funkce k tomu určené, např. as.logical(), as.integer(), as.double() nebo as.character()

as.integer(c(TRUE, FALSE, TRUE))
#> [1] 1 0 1

as.character(c(1, 2, 3, 4))
#> [1] "1" "2" "3" "4"

as.logical(c(0, 1, 0, 1))
#> [1] FALSE  TRUE FALSE  TRUE

as.double(c("0.1", "1.5", "3.6"))
#> [1] 0.1 1.5 3.6

Implicitní konverze znamená, že použijeme vektor ve specifickém kontextu, který očekává určitý typ vektoru

x <- sample(1:20, 100, replace = TRUE)
x # číselný vektor
#>   [1]  8  1  7 12 17 20 14 15 20  9 17  8 11  3  2 18 20 18  5  8  9  3  9 19  9
#>  [26]  9  4 17  4  5 16  6 17 14  4  2  4  4  7 16 12 11  4  5  6  9 14  7 19 10
#>  [51]  6  6 20 12  5  3 14 17 19 17  4 13 11 13 20 13 14  2 12 10 12 15  2 19  2
#>  [76]  3 10  5  1 10 16 11 17  5 13  9  7  1  1 18 14  3  5  4  8 11 16  4  9 20

y <- x > 10
y # logický vektor TRUE/FALSE 
#>   [1] FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE FALSE  TRUE FALSE
#>  [13]  TRUE FALSE FALSE  TRUE  TRUE  TRUE FALSE FALSE FALSE FALSE FALSE  TRUE
#>  [25] FALSE FALSE FALSE  TRUE FALSE FALSE  TRUE FALSE  TRUE  TRUE FALSE FALSE
#>  [37] FALSE FALSE FALSE  TRUE  TRUE  TRUE FALSE FALSE FALSE FALSE  TRUE FALSE
#>  [49]  TRUE FALSE FALSE FALSE  TRUE  TRUE FALSE FALSE  TRUE  TRUE  TRUE  TRUE
#>  [61] FALSE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE FALSE  TRUE FALSE  TRUE  TRUE
#>  [73] FALSE  TRUE FALSE FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE FALSE
#>  [85]  TRUE FALSE FALSE FALSE FALSE  TRUE  TRUE FALSE FALSE FALSE FALSE  TRUE
#>  [97]  TRUE FALSE FALSE  TRUE
# prvky, pro které podmínka platí – TRUE
# prvky, pro které podmínka neplatí – TRUE

# Implicitní konverze TRUE na 1 a FALSE na 0 při použití funkcí sum() a mean()
sum(y)
#> [1] 46

mean(y)
#> [1] 0.46

Při tvorbě vektorů s více prvky pomocí funkce c() má vždy přednost složitější typ, protože převod jednoduššího typu vektoru na složitější je možný, ale naopak to často není možné (nedávalo by např. smysl převádět věty na celá čísla).

c(TRUE, 0L)
#> [1] 1 0

typeof(c(TRUE, 0L))
#> [1] "integer"

c(TRUE, 0L, 2.5)
#> [1] 1.0 0.0 2.5

typeof(c(TRUE, 0L, 2.5))
#> [1] "double"

c(TRUE, 0L, 2.5, "one")
#> [1] "TRUE" "0"    "2.5"  "one"

typeof(c(TRUE, 0L, 2.5, "one"))
#> [1] "character"

4.4 Ověření typu vektoru

Často potřebujeme vektory nějak transformovat, sumarizovat apod., ale operace, kterou chceme provést, závisí na typu vektoru. Prvním ze způsobů, jak ověřit typ vektoru, je funkce typeof(), která vrací typ vektoru.

typeof(c(TRUE, FALSE))
#> [1] "logical"

Druhým způsobem jsou testovací funkce, které vracejí hodnoty TRUE nebo FALSE, podle toho, zda je testovaný vektor daného typu.

is_logical(c(TRUE, FALSE))
#> [1] TRUE

is_logical(c(0, 1))
#> [1] FALSE


is_integer(c(1L, 2L))
#> [1] TRUE

is_integer(c(1, 2))
#> [1] FALSE


is_double(c(1.2, 2.4))
#> [1] TRUE

is_double(c(1L, 2L))
#> [1] FALSE


is_numeric(c(1.2, 2.4))
#> Warning: Deprecated
#> [1] TRUE

is_numeric(c(1L, 2L))
#> Warning: Deprecated
#> [1] TRUE


is_character(c("1", "2"))
#> [1] TRUE

is_character(c(1, 2))
#> [1] FALSE


is_atomic(c(1, 2))
#> [1] TRUE

is_atomic(list(1, c(1, 2)))
#> [1] FALSE


is_list(c(1, 2))
#> [1] FALSE

is_list(list(1, c(1, 2)))
#> [1] TRUE


is_vector(c(1, 2))
#> [1] TRUE

is_vector(NULL)
#> [1] FALSE

4.5 Recyklace prvků vektoru

Každé zřejmě uhádne, co se stane, když sečteme (vynásobíme, odečteme apod.) vektory stejné délky

c(1, 2, 3) + c(4, 5, 6)
#> [1] 5 7 9

c(1, 2, 3) * c(4, 5, 6)
#> [1]  4 10 18

c(1, 2, 3) / c(4, 5, 6)
#> [1] 0.25 0.40 0.50

Co když ale vektory nemají stejnou délku? Kromě implicitní konverze typů vektorů si R také implicitně vynutí stejnou délku vektorů. Tomu se říká recyklace, protože prvky kratšího vektoru (toho s méně prvky) jsou opakovány, dokud jeho délka neodpovídá délce vektoru s více prvky.

# Tyto operace jsou tedy ekvivaletní
c(1, 2, 3) + 10
#> [1] 11 12 13

c(1, 2, 3) + c(10, 10, 10)
#> [1] 11 12 13


1:10 + 1:2
#>  [1]  2  4  4  6  6  8  8 10 10 12

c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) + c(1, 2, 1, 2, 1, 2, 1, 2, 1, 2)
#>  [1]  2  4  4  6  6  8  8 10 10 12


1:10 + 1:3
#> Warning in 1:10 + 1:3: longer object length is not a multiple of shorter object
#> length
#>  [1]  2  4  6  5  7  9  8 10 12 11


c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) + c(1, 2, 3, 1, 2, 3, 1, 2, 3, 1)
#>  [1]  2  4  6  5  7  9  8 10 12 11

4.6 Pojmenování prvků vektoru

Prvky jakéhokoli typu vektoru lze pojmenovat, a to už při jeho vytváření. Jména jsou jedním z možných atributů vektoru.

x <- c(x = 1, y = 2, z = 4)
x
#> x y z 
#> 1 2 4

names(x)
#> [1] "x" "y" "z"

attributes(x)
#> $names
#> [1] "x" "y" "z"

Jména prvků lze doplnit i poté, co byl vektor vytvořen.

x <- c(1, 2, 4)
x
#> [1] 1 2 4

# Jeden z možných způsobů
names(x)
#> NULL

names(x) <- c("x", "y", "z")
x
#> x y z 
#> 1 2 4

names(x)
#> [1] "x" "y" "z"

# Další z možných způsobů
x <- c(1, 2, 4)
x <- set_names(x, c("x", "y", "z"))
x
#> x y z 
#> 1 2 4

4.7 Výběr prvků vektoru (subsetting)

Existují tři hlavní způsoby, jak vybrat prvky jednoho vektoru pomocí jiného vektoru. Všechny z nich ale používají hranaté závorky.

Zaprvé, pomocí jiného, celočíselného vektoru.

x <- c("one", "two", "three", "four", "five")
x
#> [1] "one"   "two"   "three" "four"  "five"

x[c(3, 2, 5)]
#> [1] "three" "two"   "five"

# Opakováním čísel/pozic můžete vytvořit delší vektor, než byl vektor vstupní
x[c(1, 1, 1, 5, 5, 5, 2)]
#> [1] "one"  "one"  "one"  "five" "five" "five" "two"

# Záporné hodnoty vedou k vyřazení prvků na daných pozicích
x[c(-1, -3, -5)]
#> [1] "two"  "four"

x[-c(1, 3, 5)] # snadnější zápis
#> [1] "two"  "four"

# Ale nejde mísit dohromady kladné a záporné hodnoty
x[c(1, -1)]
#> Error in x[c(1, -1)]: only 0's may be mixed with negative subscripts

Zadruhé, pomocí logického vektoru, kdy jsou zachovány všechny prvky, kterým koresponduje hodnota TRUE. To je nejužitečnější s využitím srovnávacích funkcí a logických operátorů, jako jsou:

< znamená menší než;
> znamená větší než;
<= znamená menší nebo rovno;
>= znamená větší nebo rovno;
== znamená rovno;
!= znamená nerovno;
& znamená a zároveň (jsou obě podmínky splněny?);
| znamená anebo (je aspoň jedna z podmínek splněna?).

x <- c(10, 3, NA, 5, 8, 1, NA)
x
#> [1] 10  3 NA  5  8  1 NA

x[c(TRUE, TRUE, FALSE, FALSE, FALSE)]
#> [1] 10  3  1 NA

x[c(TRUE, FALSE)] # Opět dochází k recyklaci, takže je vybrán každý lichý prvek
#> [1] 10 NA  8 NA

# Všechny hodnoty vyšší než 5 (ponechá i missing values)
x[x > 5]
#> [1] 10 NA  8 NA

# Všechny hodnoty dělitelné dvěmi (opět ponechá i missing values)
x[x %% 2 == 0]
#> [1] 10 NA  8 NA

K ověření toho, zda je nějaký prvek missing value, je nutné použít funkci is.na() (tím se eRka ptáme je prvek chybějící?), nikoli x[x == NA] (tím bychom se eRka ptali. jestli má prvek určitou hodnotu, ale neřekli bychom mu jakou, takže výsledkem by byl jen vektor NA).

# Toto nefunguje, jak bychom asi očekávali
x[x == NA]
#> [1] NA NA NA NA NA NA NA

# Jak tedy vybrat všechny nechybějící prvky?
is.na(x) # funkce is.na() vrací TRUE, když je prvek NA (missing value)
#> [1] FALSE FALSE  TRUE FALSE FALSE FALSE  TRUE

!is.na(x) # pomocí výkřičníku můžeme negovat
#> [1]  TRUE  TRUE FALSE  TRUE  TRUE  TRUE FALSE

x[!is.na(x)] # výběr všech non-missing values
#> [1] 10  3  5  8  1

Zatřetí, pokud jsou prvky vektoru pojmanovány, můžeme k výběru prvků použít jiný vektor typu character.

x <- c(abc = 1, def = 2, xyz = 5)

x[c("xyz", "def")]
#> xyz def 
#>   5   2

x[c("xyz", "xyz", "xyz")]
#> xyz xyz xyz 
#>   5   5   5

Kromě hranatých závorek je možné použít i dvojité hranaté závorky. Použití [[ vždy vybere pouze jediný prvek vektoru (kdybychom se pokoušeli vybrat více prvků, vyústí to v chybové hlášení) a také vždy vymaže jméno prvku.

4.7.1 Cvičení

Co nám řekne mean(is.na(x)) o vektoru x?
Co se stane, když subsetujeme pomocí číselného vektoru, jehož hodnoty jsou větší než délka původního vektoru?
Co se stane, když prvek s daným jménem neexistuje?
Jaký je rozdíl v chování [ a [[, když subsetujeme neexistující prvky?
Vyzkoušejte si všechny logické operátory.

x <- c(1, 2, 3, NA)
is.na(x)
#> [1] FALSE FALSE FALSE  TRUE

mean(is.na(x))
#> [1] 0.25

mean(!is.na(x))
#> [1] 0.75

x <- c(a = 10, b = 20)
x[1:5]
#>    a    b <NA> <NA> <NA> 
#>   10   20   NA   NA   NA

x[c("a", "b", "c", "d", "e")]
#>    a    b <NA> <NA> <NA> 
#>   10   20   NA   NA   NA

x[3]
#> <NA> 
#>   NA

x[[3]]
#> Error in x[[3]]: subscript out of bounds

# Na tomto vektoru si vyzkoušejte různé logické operátory
set.seed(123)
x <- sample(1:20, size = 100, replace = TRUE)

5 Listy (rekurzivní vektory, lists)

Listy jsou komlexnější než atomické vektory, protože mohou obsahovat jiné listy nebo atomické vektory. Jsou tak ideální pro tvorbu hierarchických datových struktur.

x <- list(1, c(2, 3), c("A", "B", "C"))
x
#> [[1]]
#> [1] 1
#> 
#> [[2]]
#> [1] 2 3
#> 
#> [[3]]
#> [1] "A" "B" "C"

Velmi užitečná je funkce str(), protože zobrazuje strukturu listu.

str(x)
#> List of 3
#>  $ : num 1
#>  $ : num [1:2] 2 3
#>  $ : chr [1:3] "A" "B" "C"

x_named <- list(a = 1, b = 2, c = 3)
str(x_named)
#> List of 3
#>  $ a: num 1
#>  $ b: num 2
#>  $ c: num 3

Jak bylo naznačeno. Na rozdíl od atomických vektorů mohou listy obsahovat směs různých typů objektů. Dokonce i jiné listy.

y <- list("a", 1L, 1.5, TRUE)
str(y)
#> List of 4
#>  $ : chr "a"
#>  $ : int 1
#>  $ : num 1.5
#>  $ : logi TRUE

z <- list(list(1, 2), list(3, 4))
str(z)
#> List of 2
#>  $ :List of 2
#>   ..$ : num 1
#>   ..$ : num 2
#>  $ :List of 2
#>   ..$ : num 3
#>   ..$ : num 4

5.1 Subsetting listu

Existují tři způsoby, jak subsetovat list (vybrat prvky listu). Jejich použití si můžeme ukázat na listu à

a <- list(
  a = 1:3, 
  b = "a string", 
  c = pi, 
  d = list(-1, -5)
  ) 

str(a)
#> List of 4
#>  $ a: int [1:3] 1 2 3
#>  $ b: chr "a string"
#>  $ c: num 3.14
#>  $ d:List of 2
#>   ..$ : num -1
#>   ..$ : num -5

Pomocí [ vytvoříme list s vybranými prvky. Zachováváme tedy list jako typ outputu. Je to, jako bychom z původního listu “vyházeli” prvky, které nepotřebujeme.

a[1:2]
#> $a
#> [1] 1 2 3
#> 
#> $b
#> [1] "a string"

a[4]
#> $d
#> $d[[1]]
#> [1] -1
#> 
#> $d[[2]]
#> [1] -5

str(a[1:2])
#> List of 2
#>  $ a: int [1:3] 1 2 3
#>  $ b: chr "a string"

str(a[4])
#> List of 1
#>  $ d:List of 2
#>   ..$ : num -1
#>   ..$ : num -5

Pomocí [[ jakoby “vyřízneme” prvek listu a odstraníme přitom jednu úroveň hierarchie.

str(a[[1]])
#>  int [1:3] 1 2 3

a[[1]]
#> [1] 1 2 3

Pokud mají prvky listu jména, můžeme subseting provést takto:

# Výběr více prvků
a[c("a", "b")]
#> $a
#> [1] 1 2 3
#> 
#> $b
#> [1] "a string"

# Vyříznutí jednoho prvku
a[["b"]]
#> [1] "a string"

a$b
#> [1] "a string"

6 Faktory

Faktory (factors) jsou určeny k reprezentaci kategorických proměnných, tj. proměnných, které mohou nabývat jen několika jedinečných hodnot. Zjednodušeně řečeno, faktory jsou eRkovské označení pro kategorické proměnné. Jejich základem je vektor typu integer, ale jsou “augmentovaný” o aribut levels, který definuje úrovně a jejich pořadí.

temps <- c("cold", "hot", "hot", "warm", "cold", "cold", "warm")
factor(temps)
#> [1] cold hot  hot  warm cold cold warm
#> Levels: cold hot warm

Defaultní je pořadí podle abecedy. Ale pomocí argumentu levels jej můžeme změnit

temps_fct <- factor(temps, 
                    levels = c("cold", "warm", "hot"))
temps_fct
#> [1] cold hot  hot  warm cold cold warm
#> Levels: cold warm hot

Často jsou jednotlivé kategorie nejprve kódovány numericky a jejich labely doplněny pomocí argumentu labels.

temps <- c(1, 3, 3, 2, 1, 1, 2)
temps
#> [1] 1 3 3 2 1 1 2

temps_fct <- factor(temps,
                    levels = c(1, 2, 3),
                    labels = c("cold", "warm", "hot"))
temps_fct
#> [1] cold hot  hot  warm cold cold warm
#> Levels: cold warm hot

7 Matice (matrix)

Matice (matrix) je v eRku také atomický vektor, protože může zahrnovat pouze prvky stejného typu (např. jen reálná čísla), ale opět jde o “agumentovaný” atomický vektor, protože má dvě dimenze: řádky a sloupce. Je tedy dvoudimenzionální.

Takto lze v eRku pomocí funkce matrix() vytvořit matici. Argument byrow specifikuje, zda chceme matici plnit po řádcích. Argumenty nrow a ncol specifikují, kolik řádků nebo sloupců má matice mít. Stačí vyplnit jen jeden z nich, protože pokud máme např. 12 prvků a mají se rozdělit do tří řádků, je jasné, že sloupce musejí být čtyři.

# Nejprve vytvoříme atomický vektor
x <- 1:12 
x
#>  [1]  1  2  3  4  5  6  7  8  9 10 11 12

matrix(x, byrow = TRUE, nrow = 3)
#>      [,1] [,2] [,3] [,4]
#> [1,]    1    2    3    4
#> [2,]    5    6    7    8
#> [3,]    9   10   11   12

matrix(x, byrow = FALSE, nrow = 3)
#>      [,1] [,2] [,3] [,4]
#> [1,]    1    4    7   10
#> [2,]    2    5    8   11
#> [3,]    3    6    9   12

matrix(x, byrow = FALSE, ncol = 2)
#>      [,1] [,2]
#> [1,]    1    7
#> [2,]    2    8
#> [3,]    3    9
#> [4,]    4   10
#> [5,]    5   11
#> [6,]    6   12

7.1 Pojmenování řádků a sloupců matice

Jednotlivé prvky matice pojmenovat nelze, ale můžeme pojmenovat její řádky a sloupce, buďto rovnou při jejím vytváření (pomocí argumentu dimnames, což musí být list obsahující dva atomické vektory odpovídající délky), nebo dodatečně pomocí funkce dimnames(), resp. colnames() a rownames()

# Již při vytváření
m <- matrix(x, byrow = FALSE, nrow = 3,
            dimnames = list(
              c("row1", "row2", "row3"), # vektor s labely pro řádky matice
              c("col1", "col2", "col3", "col4") # vektor s labely pro sloupce matice
              )
            )
m
#>      col1 col2 col3 col4
#> row1    1    4    7   10
#> row2    2    5    8   11
#> row3    3    6    9   12

# Dodatečně
m <- matrix(x, byrow = FALSE, nrow = 3)
m
#>      [,1] [,2] [,3] [,4]
#> [1,]    1    4    7   10
#> [2,]    2    5    8   11
#> [3,]    3    6    9   12

dimnames(m) <- list(c("row1", "row2", "row3"), # vektor s labely pro řádky matice
                    c("col1", "col2", "col3", "col4")) # vektor s labely pro sloupce matice
m
#>      col1 col2 col3 col4
#> row1    1    4    7   10
#> row2    2    5    8   11
#> row3    3    6    9   12

m <- matrix(x, byrow = FALSE, nrow = 3)
rownames(m) <- c("row1", "row2", "row3")
colnames(m) <- c("col1", "col2", "col3", "col4")
m
#>      col1 col2 col3 col4
#> row1    1    4    7   10
#> row2    2    5    8   11
#> row3    3    6    9   12

7.2 Výběr řádků a sloupců matice

Protože matice je vlastně atomický vektor, můžeme selektovat její prvky podobně jako u jiných atomických vektorů pomocí hranatých závorek. Ale protože má dvě dimenze, rozlišujeme výběr řádků a sloupců. Nejlepší je ukázat si to názorně.

m[1, 2] # Výběr hodnot z prvního řádku a druhého sloupce
#> [1] 4

m[c(1,2), c(1,2)] # Výběr hodnot z prvních dvou řádků a sloupců
#>      col1 col2
#> row1    1    4
#> row2    2    5

m[ , 3] # Výběr všech řádků třetího sloupce
#> row1 row2 row3 
#>    7    8    9

K výběru také můžeme poutíž logické vektory nebo textové vektory (má-li matice pojmenované řádky/sloupce)

m[c(TRUE, FALSE, FALSE), c(FALSE, FALSE, TRUE, TRUE)]
#> col3 col4 
#>    7   10

m["row2", c("col3", "col4")]
#> col3 col4 
#>    8   11

Anebo jinou matici logických hodnot se shodnými dimenzemi.

m_logical <- matrix(
  c(TRUE, FALSE, FALSE, TRUE,
    FALSE, TRUE, TRUE, FALSE,
    TRUE, FALSE, FALSE, TRUE),
  byrow = TRUE, nrow = 3)
m_logical
#>       [,1]  [,2]  [,3]  [,4]
#> [1,]  TRUE FALSE FALSE  TRUE
#> [2,] FALSE  TRUE  TRUE FALSE
#> [3,]  TRUE FALSE FALSE  TRUE

m[m_logical]
#> [1]  1  3  5  8 10 12

7.3 Filmy Q. Tarantina: Procvičování

Budeme se zabývat počtem “cursing words” v několika filmech Q. Tarantina.

# Názvy filmů
movies <- c("Django Unchained", "Inglorious Basterds", "Jackie Brown",
            "Kill Bill: Vol. 1", "Kill Bill: Vol. 2", "Pulp Fiction", 
            "Reservoir Dogs")
# Počty slov
profanities <- c(262, 58, 368, 57, 69, 469, 421)
profanities
#> [1] 262  58 368  57  69 469 421

Pojmenujte prvky vektoru profanities vektorem movies
Vyberte několika možnými způsoby počty “cursing words” pro filmy Inglorious Basterds a Pulp Fiction

Zaznamenáme si, kolikrát v jednotlivých filmech zazněla slova “hell” a “goddamn”

hell <-  c(10, 4, 10, 3, 1, 2, 12)
goddamn <-  c(28, 8, 27, 7, 5, 28, 10)

Nejprve prkvy obou vektorů opět pojmenujte podle filmů.
Poté vytvořte nový vektor spirituality jako součet obou vektorů.
Pomocí funkce sum() vypočtěte, kolikrát celkově zazněla slova hell/goddamn.
Vhodným logických operátorem zjistěte, ve kterých filmech vícekrát zaznělo slovo “hell” než “goddamn”
Ve kterých filmech zaznělo více než 100 cursing words?

Doplníme si údaje o počtu zachycených úmrtí.

deaths <- c(47, 48, 4, 63, 11, 7, 10)
names(deaths) <- movies
deaths
#>    Django Unchained Inglorious Basterds        Jackie Brown   Kill Bill: Vol. 1 
#>                  47                  48                   4                  63 
#>   Kill Bill: Vol. 2        Pulp Fiction      Reservoir Dogs 
#>                  11                   7                  10

Vytvořte matici, kde na řádcích budou jednotlivé filmy a ve sloupcích údaje o počtu profanities a deaths. Náležitě také pojmenujte řádky a sloupce matice.
Zkuste na matici aplikovat funkce colSums(), colMeans(), rowSums() a rowMeans(). Co tyto funkce počítají?
Pomocí funkce cbind() přidejte do matice vektor year s roky premiéry filmů jako nový sloupec:

year <- c(2012, 2009, 1997, 2003, 2004, 1994, 1992)

Pomocí funkce rbind() přidejte do matice vektor The Hateful Eight s údaji o novém filmu:

`The Hateful Eight` <- c(107, 20, 2015)

Pomocí číselných indexů:
- Vyberte celý poslední řádek matice, který jste právě přidali.
- vyberte rok premiéry The Hateful Eight.
- Vyberte sloupec s počty úmrtí.
Pomocí textových vektorů vyberte počet profanities v Pulp Fiction.
Pomocí logického vektoru vyberte všechny řádky s filmy, které měly premiéru po roce 2000
Vyberte sloupec deaths jakýmkoli způsobem a vhodnou funkcí zjistěne průměrný počet úmrtí na jeden film.
Jaký je Tarantino index (tj. počet mrtvých na počet nadávek) pro Inglorious Basterds? Vyberte z matice nejprve jeden a poté druhý příslušný prvek a poté je vydělte.

8 Dataframe

Dataframe je matice tak, jak ji chápeme při analýze dat. Dataframe je uspořádán do sloupců a řádků, přičemž řádky odpovídají pozorováním/případům a sloupce proměnným. Technicky je dataframe typ listu, protože může obsahovat různé typy vektorů, ale je omezen tím, že jeho prvky (sloupce) musejí mít stejnou délku.

Balíčky v R obsahují i různé dataframy

data() # Přehled zabudovaných datasetů
data(USArrests) # Vyvolání zabudovaného datasetu
View(USArrests) # Prohlížení v RStudiu

K orientaci v dataframu slouží několik funkcí (tyto funkce lze použít i pro jiné typy vektorů):

head() - ukáže několik prvních řádků;
tail()- ukáže několik posledních řádků;
str - struktura dat; podobně glimpse() z balíčku dplyr

head(USArrests)
#>            Murder Assault UrbanPop Rape
#> Alabama      13.2     236       58 21.2
#> Alaska       10.0     263       48 44.5
#> Arizona       8.1     294       80 31.0
#> Arkansas      8.8     190       50 19.5
#> California    9.0     276       91 40.6
#> Colorado      7.9     204       78 38.7

head(USArrests, n = 10)
#>             Murder Assault UrbanPop Rape
#> Alabama       13.2     236       58 21.2
#> Alaska        10.0     263       48 44.5
#> Arizona        8.1     294       80 31.0
#> Arkansas       8.8     190       50 19.5
#> California     9.0     276       91 40.6
#> Colorado       7.9     204       78 38.7
#> Connecticut    3.3     110       77 11.1
#> Delaware       5.9     238       72 15.8
#> Florida       15.4     335       80 31.9
#> Georgia       17.4     211       60 25.8


tail(USArrests)
#>               Murder Assault UrbanPop Rape
#> Vermont          2.2      48       32 11.2
#> Virginia         8.5     156       63 20.7
#> Washington       4.0     145       73 26.2
#> West Virginia    5.7      81       39  9.3
#> Wisconsin        2.6      53       66 10.8
#> Wyoming          6.8     161       60 15.6

tail(USArrests, n = 15)
#>                Murder Assault UrbanPop Rape
#> Oklahoma          6.6     151       68 20.0
#> Oregon            4.9     159       67 29.3
#> Pennsylvania      6.3     106       72 14.9
#> Rhode Island      3.4     174       87  8.3
#> South Carolina   14.4     279       48 22.5
#> South Dakota      3.8      86       45 12.8
#> Tennessee        13.2     188       59 26.9
#> Texas            12.7     201       80 25.5
#> Utah              3.2     120       80 22.9
#> Vermont           2.2      48       32 11.2
#> Virginia          8.5     156       63 20.7
#> Washington        4.0     145       73 26.2
#> West Virginia     5.7      81       39  9.3
#> Wisconsin         2.6      53       66 10.8
#> Wyoming           6.8     161       60 15.6


str(USArrests)
#> 'data.frame':    50 obs. of  4 variables:
#>  $ Murder  : num  13.2 10 8.1 8.8 9 7.9 3.3 5.9 15.4 17.4 ...
#>  $ Assault : int  236 263 294 190 276 204 110 238 335 211 ...
#>  $ UrbanPop: int  58 48 80 50 91 78 77 72 80 60 ...
#>  $ Rape    : num  21.2 44.5 31 19.5 40.6 38.7 11.1 15.8 31.9 25.8 ...

glimpse(USArrests)
#> Rows: 50
#> Columns: 4
#> $ Murder   <dbl> 13.2, 10.0, 8.1, 8.8, 9.0, 7.9, 3.3, 5.9, 15.4, 17.4, 5.3, 2.…
#> $ Assault  <int> 236, 263, 294, 190, 276, 204, 110, 238, 335, 211, 46, 120, 24…
#> $ UrbanPop <int> 58, 48, 80, 50, 91, 78, 77, 72, 80, 60, 83, 54, 83, 65, 57, 6…
#> $ Rape     <dbl> 21.2, 44.5, 31.0, 19.5, 40.6, 38.7, 11.1, 15.8, 31.9, 25.8, 2…

I když to děláme spíš výjimečně, dataframe lze vytvoři přímo v eRku pomocí funkce data.frame()

planets <- data.frame(
  name = c("Mercury", "Venus", "Earth", "Mars", 
           "Jupiter", "Saturn", "Uranus", "Neptune"),
  type = c("Terrestrial", "Terrestrial", "Terrestrial","Terrestrial", 
           "Gas giant", "Gas giant", "Gas giant", "Gas giant"),
  diameter = c(0.382, 0.949, 1, 0.532, 11.209, 9.449, 4.007, 3.883),
  rotation = c(58.64, -243.02, 1, 1.03, 0.41, 0.43, -0.72, 0.67),
  rings = c(FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE)
)
planets
#>      name        type diameter rotation rings
#> 1 Mercury Terrestrial    0.382    58.64 FALSE
#> 2   Venus Terrestrial    0.949  -243.02 FALSE
#> 3   Earth Terrestrial    1.000     1.00 FALSE
#> 4    Mars Terrestrial    0.532     1.03 FALSE
#> 5 Jupiter   Gas giant   11.209     0.41  TRUE
#> 6  Saturn   Gas giant    9.449     0.43  TRUE
#> 7  Uranus   Gas giant    4.007    -0.72  TRUE
#> 8 Neptune   Gas giant    3.883     0.67  TRUE

8.1 Výběr prvků dataframu

Výběr prvků dataframu je velmi podobný tomu u matic.

# První až třetí řádek, první sloupec
planets[1:3, 1]
#> [1] "Mercury" "Venus"   "Earth"

# První a třetí sloupec
planets[, c(1, 3)]
#>      name diameter
#> 1 Mercury    0.382
#> 2   Venus    0.949
#> 3   Earth    1.000
#> 4    Mars    0.532
#> 5 Jupiter   11.209
#> 6  Saturn    9.449
#> 7  Uranus    4.007
#> 8 Neptune    3.883

# Jde to i bez čárky, protože sloupce jsou považovány za základní
# stavební prvky dataframu
planets[c(1, 3)] 
#>      name diameter
#> 1 Mercury    0.382
#> 2   Venus    0.949
#> 3   Earth    1.000
#> 4    Mars    0.532
#> 5 Jupiter   11.209
#> 6  Saturn    9.449
#> 7  Uranus    4.007
#> 8 Neptune    3.883

length(planets) # Proto i délka odpovídá počtu sloupců
#> [1] 5

# První až třet řádek, sloupec "name"
planets[1:3,"name"]
#> [1] "Mercury" "Venus"   "Earth"

Sloupce můžeme z dataframu “vyříznout” podobně jako u listů.

planets[["name"]]
#> [1] "Mercury" "Venus"   "Earth"   "Mars"    "Jupiter" "Saturn"  "Uranus" 
#> [8] "Neptune"

planets$name
#> [1] "Mercury" "Venus"   "Earth"   "Mars"    "Jupiter" "Saturn"  "Uranus" 
#> [8] "Neptune"

planets$diameter
#> [1]  0.382  0.949  1.000  0.532 11.209  9.449  4.007  3.883

8.2 Řazení a filtrování

K seřezaní řádků podle hodnot některého ze sloupců můžeme funkci order(). Výstupem této funkce je pořadí hodnot podle daného vektoru nebo vektorů

planets$diameter
#> [1]  0.382  0.949  1.000  0.532 11.209  9.449  4.007  3.883

order(planets$diameter) # Defaultně vzestupně
#> [1] 1 4 2 3 8 7 6 5

order(planets$diameter, decreasing = TRUE) # Takto sestupně
#> [1] 5 6 7 8 3 2 4 1

# Vektor, který je výstupem funkce order(), můžeme využít k seřazení řádků
planets[order(planets$diameter, decreasing = FALSE), ]
#>      name        type diameter rotation rings
#> 1 Mercury Terrestrial    0.382    58.64 FALSE
#> 4    Mars Terrestrial    0.532     1.03 FALSE
#> 2   Venus Terrestrial    0.949  -243.02 FALSE
#> 3   Earth Terrestrial    1.000     1.00 FALSE
#> 8 Neptune   Gas giant    3.883     0.67  TRUE
#> 7  Uranus   Gas giant    4.007    -0.72  TRUE
#> 6  Saturn   Gas giant    9.449     0.43  TRUE
#> 5 Jupiter   Gas giant   11.209     0.41  TRUE

planets[order(planets$diameter, decreasing = TRUE), ]
#>      name        type diameter rotation rings
#> 5 Jupiter   Gas giant   11.209     0.41  TRUE
#> 6  Saturn   Gas giant    9.449     0.43  TRUE
#> 7  Uranus   Gas giant    4.007    -0.72  TRUE
#> 8 Neptune   Gas giant    3.883     0.67  TRUE
#> 3   Earth Terrestrial    1.000     1.00 FALSE
#> 2   Venus Terrestrial    0.949  -243.02 FALSE
#> 4    Mars Terrestrial    0.532     1.03 FALSE
#> 1 Mercury Terrestrial    0.382    58.64 FALSE

# Co dělá tato funkce?
sort(planets$diameter)
#> [1]  0.382  0.532  0.949  1.000  3.883  4.007  9.449 11.209

sort(planets$diameter, decreasing = TRUE)
#> [1] 11.209  9.449  4.007  3.883  1.000  0.949  0.532  0.382

K filtrování můžeme použít logické operátory v kombinaci s hranatými závorkami nebo funkcí subset(). Funkce subset() vyřaduje o něco méně psaní, protože vektor/sloupec hledá automaticky v rámci použitého dataframu.

planets$rotation < 0
#> [1] FALSE  TRUE FALSE FALSE FALSE FALSE  TRUE FALSE

# Tyto operace jsou ekvivalentní:
planets[planets$rotation < 0, ]
#>     name        type diameter rotation rings
#> 2  Venus Terrestrial    0.949  -243.02 FALSE
#> 7 Uranus   Gas giant    4.007    -0.72  TRUE

subset(planets, rotation < 0)
#>     name        type diameter rotation rings
#> 2  Venus Terrestrial    0.949  -243.02 FALSE
#> 7 Uranus   Gas giant    4.007    -0.72  TRUE

Brzo se naučíme ještě jednoduší a intuitivnější funkce (z balíčku tidyverse) pro výběr řádků a sloupců.

8.3 Tibbles

Tibbles jsou vlastně upgradované dataframes. Chovájí se trochu jinak než obyčejné dataframes, ale tak, aby nám to ulehčilo práci. Obyčejný dataframe můžeme změnit v tibble pomocí funkce as_tibble() a ověřit si, zda je nějaký objekt tibble, pomocí funkce is_tibble.

head(iris)
#>   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
#> 1          5.1         3.5          1.4         0.2  setosa
#> 2          4.9         3.0          1.4         0.2  setosa
#> 3          4.7         3.2          1.3         0.2  setosa
#> 4          4.6         3.1          1.5         0.2  setosa
#> 5          5.0         3.6          1.4         0.2  setosa
#> 6          5.4         3.9          1.7         0.4  setosa

is_tibble(iris)
#> [1] FALSE

as_tibble(iris)
#> # A tibble: 150 × 5
#>    Sepal.Length Sepal.Width Petal.Length Petal.Width Species
#>           <dbl>       <dbl>        <dbl>       <dbl> <fct>  
#>  1          5.1         3.5          1.4         0.2 setosa 
#>  2          4.9         3            1.4         0.2 setosa 
#>  3          4.7         3.2          1.3         0.2 setosa 
#>  4          4.6         3.1          1.5         0.2 setosa 
#>  5          5           3.6          1.4         0.2 setosa 
#>  6          5.4         3.9          1.7         0.4 setosa 
#>  7          4.6         3.4          1.4         0.3 setosa 
#>  8          5           3.4          1.5         0.2 setosa 
#>  9          4.4         2.9          1.4         0.2 setosa 
#> 10          4.9         3.1          1.5         0.1 setosa 
#> # … with 140 more rows

Vytvořit tibble z jednotlivých vektorů pak lze pomocí funkce tibble(). Tato funkce automaticky recykluje vektory, které mají jen jeden prvek, a umožňuje se rovnou odkazovat na právě vytvořené vektory, jako je to ilustrováno níže.

tibble(
  x = 1:5, 
  y = 1, 
  z = x ^ 2 + y
)
#> # A tibble: 5 × 3
#>       x     y     z
#>   <int> <dbl> <dbl>
#> 1     1     1     2
#> 2     2     1     5
#> 3     3     1    10
#> 4     4     1    17
#> 5     5     1    26

Tibble také umožňuje dát sloupcům nestandardní jména, např. jména nezačínající písmenem nebo zahrnující speciální znaky. Stačí k tomu použít zpětný apostrof (R Alt + ý). Ale není to něco, co bychom si v praxi přáli dělat.

tb <- tibble(
  `:)` = "smile", 
  ` ` = "space",
  `2000` = "number"
)
tb
#> # A tibble: 1 × 3
#>   `:)`  ` `   `2000`
#>   <chr> <chr> <chr> 
#> 1 smile space number

Další způsob, jak vytvořit tibble, nabízí funkce tribble(). S využitím této funkce “plníme” tibble po řádcích, nikoli po sloupcích jako. Jména sloupců uvádíme jako první a dáváme před ně tildu (na české klávesnic R Alt + 1)

tribble(
  ~x, ~y, ~z, # Jména sloupců
  
  "a", 2, 3.6, # první řádek hodnot
  "b", 1, 8.5 # druhý řádek hodnot
)
#> # A tibble: 2 × 3
#>   x         y     z
#>   <chr> <dbl> <dbl>
#> 1 a         2   3.6
#> 2 b         1   8.5

Když si tibble vyvoláme do konzole, na rozdíl od obyčejných dataframes ji nezahltí, protože zobrazí jen prvních deset řádků a tolik sloupců, kolik se jich do konzole vleze. Navíc se u každého sloupce zobrazí jeho typ.

tb <- tibble(
  a = Sys.time() + runif(1e3) * 86400,
  b = as.Date(Sys.time()) + runif(1e3) * 30,
  c = 1:1e3,
  d = runif(1e3),
  e = sample(letters, 1e3, replace = TRUE)
)
tb
#> # A tibble: 1,000 × 5
#>    a                   b              c      d e    
#>    <dttm>              <date>     <int>  <dbl> <chr>
#>  1 2022-09-19 14:13:42 2022-09-30     1 0.153  u    
#>  2 2022-09-19 03:31:15 2022-09-30     2 0.449  k    
#>  3 2022-09-19 19:50:11 2022-10-07     3 0.186  n    
#>  4 2022-09-19 17:01:36 2022-10-15     4 0.427  e    
#>  5 2022-09-19 15:08:52 2022-09-24     5 0.821  k    
#>  6 2022-09-19 13:56:29 2022-10-04     6 0.0504 w    
#>  7 2022-09-19 08:02:34 2022-10-09     7 0.325  e    
#>  8 2022-09-19 11:49:30 2022-09-29     8 0.842  x    
#>  9 2022-09-19 20:06:05 2022-09-20     9 0.0402 v    
#> 10 2022-09-19 13:04:16 2022-10-07    10 0.792  a    
#> # … with 990 more rows

Kdybychom nám toto nevyhovovalo, můžeme pomocí funkce print upřesnit, kolik řádků a sloupců chceme v konzoli zobrazit.

print(tb, n = 20, width = Inf)
#> # A tibble: 1,000 × 5
#>    a                   b              c       d e    
#>    <dttm>              <date>     <int>   <dbl> <chr>
#>  1 2022-09-19 14:13:42 2022-09-30     1 0.153   u    
#>  2 2022-09-19 03:31:15 2022-09-30     2 0.449   k    
#>  3 2022-09-19 19:50:11 2022-10-07     3 0.186   n    
#>  4 2022-09-19 17:01:36 2022-10-15     4 0.427   e    
#>  5 2022-09-19 15:08:52 2022-09-24     5 0.821   k    
#>  6 2022-09-19 13:56:29 2022-10-04     6 0.0504  w    
#>  7 2022-09-19 08:02:34 2022-10-09     7 0.325   e    
#>  8 2022-09-19 11:49:30 2022-09-29     8 0.842   x    
#>  9 2022-09-19 20:06:05 2022-09-20     9 0.0402  v    
#> 10 2022-09-19 13:04:16 2022-10-07    10 0.792   a    
#> 11 2022-09-19 19:15:48 2022-09-18    11 0.962   v    
#> 12 2022-09-19 06:36:28 2022-09-24    12 0.661   b    
#> 13 2022-09-19 16:06:29 2022-10-08    13 0.00872 d    
#> 14 2022-09-19 05:28:10 2022-10-13    14 0.466   f    
#> 15 2022-09-19 13:22:24 2022-10-11    15 0.717   e    
#> 16 2022-09-19 10:39:36 2022-09-22    16 0.0282  s    
#> 17 2022-09-19 05:28:11 2022-09-29    17 0.845   l    
#> 18 2022-09-19 12:39:33 2022-10-11    18 0.746   a    
#> 19 2022-09-19 21:01:32 2022-10-08    19 0.264   j    
#> 20 2022-09-19 20:45:14 2022-10-05    20 0.746   d    
#> # … with 980 more rows

Výběr prvků z tibblu je v podstatě stejný jako výběr prvků z dataframes, protože tibble je “jen” vylepšený dataframe.

df <- tibble(
  x = runif(5),
  y = rnorm(5),
  z = runif(5)
)
df
#> # A tibble: 5 × 3
#>       x      y     z
#>   <dbl>  <dbl> <dbl>
#> 1 0.699  0.665 0.651
#> 2 0.900 -0.565 0.761
#> 3 0.723 -0.962 0.281
#> 4 0.255  0.623 0.984
#> 5 0.309  0.106 0.964

# Výběr jediného prvku pomocí jména
df$x
#> [1] 0.6986846 0.8999534 0.7232587 0.2550500 0.3086717

df[["x"]]
#> [1] 0.6986846 0.8999534 0.7232587 0.2550500 0.3086717

# Výběr prvků pomocí pozice
df[[1]]
#> [1] 0.6986846 0.8999534 0.7232587 0.2550500 0.3086717

df[1]
#> # A tibble: 5 × 1
#>       x
#>   <dbl>
#> 1 0.699
#> 2 0.900
#> 3 0.723
#> 4 0.255
#> 5 0.309

8.3.1 Cvičení

Pomocí které funkce lze ověřit, zda je datový objekt tibble? Zkuste uhádnout název funkce a zkusit ji na dataframu mtcars.
Porovnejte výsledky stejných operací na obyčejném dataframu vs tibblu.

df <- data.frame(
  x = c(1, 2, 3), 
  y = c("a", "b", "c")
)

df$x
#> [1] 1 2 3

df[, "y"]
#> [1] "a" "b" "c"

df[, c("x", "y")]  
#>   x y
#> 1 1 a
#> 2 2 b
#> 3 3 c

  
tb <- tibble(
  x = c(1, 2, 3), 
  y = c("a", "b", "c")
)

tb$x
#> [1] 1 2 3

tb[, "y"]
#> # A tibble: 3 × 1
#>   y    
#>   <chr>
#> 1 a    
#> 2 b    
#> 3 c

tb[, c("x", "y")] 
#> # A tibble: 3 × 2
#>       x y    
#>   <dbl> <chr>
#> 1     1 a    
#> 2     2 b    
#> 3     3 c

9 Co je potřeba si zapamatovat

Jaké jsou základní matematické operátory v R.
Jaké existují základní typy vektorů a jaké jsou mezi nimi rozdíly.
Jak ověřit, jakého typu je určitý vektor.
Jak lze vytvářet atomické vektory, matice a dataframy/listy.
Jak lze pojmenovat prvky různých typů vektoru (při vytváření, dodatečně).
Jak lze subsetovat atomické vektory, matice, listy a dataframy/tibbly.
Jaké jsou základní logické operátory a jak se používají k subsettingu.
Co dělají tzv. testovací funkce (začínající na is_ nebo is.) a jak se používají.
Jak fungují a co dělají funkce: typeof(), is.na(), sum(), mean(), rowSums(), colSums(), rowMeans(), colMeans(), head(), tail(), str(), glimpse(), factor(), subset(), order(), sort().

1 Úvod do R

Karel Rečka

2022-09-18