• proměnné (povolená jména, tvorba, výpis, mazání)
• základní datové typy (přehled, testování, konverze)
• chybějící a divné hodnoty
• metadata (atributy)
• operace se základními datovými typy
• faktory
• (datumy)

Proměnná je jméno, ke kterému se přiřadí nějaká oblast v paměti počítače, která obsahuje nějaké hodnoty.

Každá proměnná obsahuje určitou datovou strukturu, např. vektor.

Každý prvek této struktury má určitý typ (např. celé číslo) a nějakou hodnotu (např. číslo 1).

Přiřazením nové hodnoty do proměnné se stará hodnota ztratí.

Jména proměnných musí splňovat určité nároky: jméno

• se může skládat jen z písmen, číslic, teček a podtržítek
• musí začínat písmenem nebo tečkou, za kterou nenásleduje číslice
• nesmí být rezervované slovo

Povolené: a, myNumber nebo my_number
Nepovolené: .2way nejsou povolená.

Rezervovaná slova: if, else, repeat, while, function, for, in, next, break, TRUE, FALSE, NULL, Inf, NaN, NA, NA_integer_, NA_real_, NA_complex_ a NA_character_.

Ve jménech proměnných záleží na velkých a malých písmenech, tj. proměnné a a A jsou dvě různé proměnné.

Jméno proměnné by ideálně mělo být stručné a mělo by výstižně popisovat, jaké hodnoty proměnná obsahuje.

Více slov se historicky oddělovalo tečkami (např. pv.of.bond).

Dnes se doporučuje

• podtržítka (pv_of_bond) nebo
• "Camel Case" (pvOfBond).

Hodnoty se do proměnných přiřazují pomocí "šipky" (klávesová zkratka Alt-).

x <- 1  # x má nyní hodnotu 1
2 -> y  # y má nyní hodnotu 2

Nepoužívejte rovnítko (=):

• v některých kontextech funguje jako synonymum šipky
• v jiných ne

Při přiřazení hodnoty do proměnné se výsledek nevypíše. Pokud jej chcete vypsat, musíte o to R požádat.

x <- "This is some text."  # hodnota se přiřadí, nic se nevypíše
x         # implicitní vypsání hodnoty proměnné x

## [1] "This is some text."

print(x)  # explicitní vypsání hodnoty proměnné x

## [1] "This is some text."

(y <- 2)  # výraz se vyhodnotí a hodnota implicitně vypíše 

## [1] 2

To, co R vypíše do konzoly, se liší od skutečných hodnot proměnných.

R pro různé objekty volá různé funkce print() přizpůsobené těmto objektům a může vypsat více nebo méně informací, než je jich obsaženo v dané proměnné.

Někdy proměnná obsahuje mnoho hodnot – chceme vypsat jen několik prvních / posledních.

x <- matrix(1:1200, ncol = 3)  # vytvoří matici se 400 řádky
head(x)                        # vypíše 6 prvních řádků matice

##      [,1] [,2] [,3]
## [1,]    1  401  801
## [2,]    2  402  802
## [3,]    3  403  803
## [4,]    4  404  804
## [5,]    5  405  805
## [6,]    6  406  806

head(x, n = 3)                 # vypíše 3 první řádky matice

##      [,1] [,2] [,3]
## [1,]    1  401  801
## [2,]    2  402  802
## [3,]    3  403  803

tail(x)                        # vypíše 6 posledních řádků matice

##        [,1] [,2] [,3]
## [395,]  395  795 1195
## [396,]  396  796 1196
## [397,]  397  797 1197
## [398,]  398  798 1198
## [399,]  399  799 1199
## [400,]  400  800 1200

Ke smazání proměnné z aktuálního prostředí slouží funkce rm():

rm(x)  # smaže proměnnou x
rm(x, y, z)  # smaže proměnné x, y a z
rm(list = ls())  # smaže všechny proměnné z aktuálního prostředí

• logical: TRUE a FALSE; (možno zkrátit na T a F, nedělejte to)
• integer – může obsahovat kladná i záporná celá čísla; např. 1L
• double – kladné i záporné reálné číslo; např. 1
• character – řetězec (text); např. "ahoj" nebo 'ahoj'

Reálná čísla jde zadat i pomocí tzv. "vědecké notace":

1.3e3   # 1.3 krát 10 na třetí, tj. 1 300

## [1] 1300

2.7e-5  # 2.7 krát 10 na minus pátou, tj. 0.000027

## [1] 2.7e-05

format(2.7e-5, scientific = FALSE) # výpis "normálně"

## [1] "0.000027"

Funkce is.XXX() vrací logickou hodnotu: TRUE, pokud je proměnná daného typu:

is.logical(x1)   # je logická
is.integer(x1)   # je celé číslo
is.double(x1)    # je reální číslo
is.numeric(x1)   # je (jakékoli) číslo
is.character(x1) # je řetězec

Funkce typeof() vrací datový typ proměnné jako řetězec:

typeof("Jak se máte?")

## [1] "character"

Do proměnných x1 až x4 vložte po řadě: logickou hodnotu pro pravdu, celočíselnou jedničku, reálnou jedničku a řetězec.

Otestujte, o jaké typy proměnných se jedná.

V některých případech může proměnná obsahovat příznak, že její hodnota chybí nebo je chybná. R k tomu má tři speciální hodnoty:

• chybějící hodnota NA ("not available")
• hodnota není číslo – je chybná NaN ("not a number")
• hodnota je nekonečná Inf (nebo samozřejmě -Inf)

Nekonečná hodnota vznikne např. při dělení nenulového čísla nulou:

1 / 0

## [1] Inf

Chybná hodnota vznikne při různých nepovolených operacích, které však nevedou na nekonečno, např. při dělení nuly nulou:

0 / 0

## [1] NaN

Chybějící hodnoty NA se obvykle používají při zadávání hodnot v konzoli nebo ve skriptu a při ukládání čísel do souboru, aby se označilo, která hodnota chybí.

Funkce vrací logickou hodnotu, TRUE pokud je daná hodnota:

is.na()       # hodnota je NA nebo NaN
is.nan()      # hodnota je NaN
is.finite()   # hodnota je konečná
is.infinite() # hodnota je Inf nebo -Inf

Stejně jako ostatní hodnoty v R, tak i chybějící hodnoty mají svůj typ: NA_real_, NA_real_, NA_character_, …

x1 <- c(1L, NA)[2]   # vezme se druhá hodnota celočíselného vektoru
x2 <- c(1, NA)[2]    # vezme se druhá hodnota reálného vektoru
x1

## [1] NA

x2

## [1] NA

identical(x1, x2)

## [1] FALSE

NULL je speciální objekt (tj. vlastní datový typ) a zároveň rezervované slovo, které R vrací v situaci, kdy nějaká hodnota není definovaná.

K otestování, zda je hodnota objektu NULL slouží funkce is.null().

Když R potřebuje dva základní datové typy, provede jejich automatickou konverzi: převede jednodušší typ na obecnější typ.

Převod probíhá od logických proměnných k celočíselným (TRUE se převede na 1 a FALSE na 0), od celočíselných k reálným a od nich k řetězcům.

# funkce c() spojí hodnoty v závorkách do vektoru
c(TRUE, 1L, 1, "1")

## [1] "TRUE" "1"    "1"    "1"

c(c(TRUE, 1L), 1, "1")

## [1] "1" "1" "1" "1"

Kolik hodnot ve vektoru x je větších než 10?

x <- c(1, 2, 3, 7, 19, 31)  # vytvoří vektor daných čísel
sum(x > 10)

## [1] 2

K manuální konverzi slouží funkce as.XXX():

as.character(TRUE)

## [1] "TRUE"

as.integer(TRUE)

## [1] 1

as.logical(c(-1, 0, 0.1, 1, 2, 5))

## [1]  TRUE FALSE  TRUE  TRUE  TRUE  TRUE

Někdy R neví, jak nějaký objekt převést. Pak je výsledkem hodnota NA a R vydá varování:

x <- c("a", "b", "c", "1")
as.numeric(x)

## Warning: NAs introduced by coercion

## [1] NA NA NA  1

Převeďte

• logickou hodnotu TRUE na celé číslo a na řetězec
• vektor celých čísel \((-1, 0, 1, 2)\) na logický vektor
• vektor řetězců ("ahoj", "222") na reálná čísla

Proměnné v R obsahují kromě vlastních hodnot také metadata (informace o datech). V R se metadata nazývají atributy.

Funkce attributes() vypíše seznam všech atributů dané proměnné.

x <- c(a = 1, b = 2, c = 3)  # vektor s pojmenovanými prvky
x

## a b c 
## 1 2 3

attributes(x)

## $names
## [1] "a" "b" "c"

X <- matrix(1:12, nrow = 3)  # matice má počet řádků a sloupců
X

##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12

attributes(X)

## $dim
## [1] 3 4

Atributy mohou zahrnovat

• třídu objektu
• dimenze proměnných (počet řádků, sloupců a případně dalších rozměrů)
• jména řádků, sloupců, jednotlivých prvků vektorů
• další informace

Hodnotu jednoho atributu je možné získat funkcí attr(); tuto funkci je zároveň možné použít i ke změně hodnoty atributu (ve skutečnosti se volá jiná funkce, syntaxe však vypadá stejně):

attr(x, "names")

## [1] "a" "b" "c"

attr(x, "names") <- c("Ahoj", "Bum", "Cak")
attr(x, "names")

## [1] "Ahoj" "Bum"  "Cak"

x

## Ahoj  Bum  Cak 
##    1    2    3

Dotaz na neexistující atribut vrátí hodnotu NULL:

attr(x, "bum")

## NULL

Atribut zrušíte tak, že do něj přiřadíte hodnotu NULL.

attr(x, "names") <- NULL
x

## [1] 1 2 3

Vytvořte vektor v tří čísel, která budou pojmenovaná "A", "B" a "C".

Změňte pomocí funkce tolower() názvy prvků vektoru na malá písmena.

Základní aritmetické operace jsou

• sčítání (+)
• odčítání (-)
• násobení (*)
• dělení (/)
• umocňování (^)
• celočíselné dělení %/%
• zbytek po dělení %%

Operátory mají normální prioritu:

1 + 2 * 3  # 7, nikoli 9

## [1] 7

Ke změně pořadí vyhodnocování výrazů slouží závorky:

(1 + 2) * 3  # 9, nikoli 7

## [1] 9

Ke srovnání aritmetických hodnot slouží následující operátory:

• rovná se (==)
• liší se (!=)
• větší (<)
• větší rovno (<=)
• menší (>)
• menší rovno (>=)

Funguje po vektorech, vrací logické hodnoty:

c(1L, 2L, 3L) == c(3L, 2L, 1L)

## [1] FALSE  TRUE FALSE

Srovnat stejnost nebo různost dvou reálných čísel pomocí operátorů == a != nejde:

x1 <- 0.5 - 0.3
x2 <- 0.3 - 0.1
x1 == x2                           # na většině počítačů FALSE

## [1] FALSE

Ke srovnání dvou reálných čísel slouží následující fráze:

identical(all.equal(x1, x2), TRUE) # TRUE everywhere

## [1] TRUE

Srovnejte pomocí == a idiomu pro reálná čísla, zda jsou následující hodnoty stejné:

• 1L a (3L - 2L)
• 1L a 1
• 1 a (3 - 2)
• (0.5 - 0.3) a (0.3 - 0.1)

Základní logické operace zahrnují logický součin ("a zároveň", &), logický součet ("nebo", |) a negaci ("opak", !). Kromě toho samozřejmě fungují i závorky.

Všimněte si, že !(V1 & V2) \(=\) !V1 | !V2 a !(V1 | V2) \(=\) !V1 & !V2.

Logický součin a součet existují v R ve dvou formách: jednoduché a "zkratující":

• jednoduchá: &, |
• zkratující: &&, ||

Jednoduchá forma se používá při vyhodnocování operátorů na logických vektorech:

 c(TRUE, FALSE) & c(TRUE,TRUE)

## [1]  TRUE FALSE

Zkratující forma se používá v podmínkách. Zastaví vyhodnocování výrazu ve chvíli, kdy je výsledek jednoznačně známý:

FALSE && !(TRUE || FALSE) # vyhodnocování skončí hned prvním FALSE

## [1] FALSE

c(TRUE, FALSE) && c(TRUE, TRUE)

## [1] TRUE

Vektorová funkce all() vrátí TRUE, pokud jsou všechny prvky vektoru TRUE; jinak vrátí FALSE. (= logický součin přes všechny prvky vektoru)

Vektorová funkce any() vrátí TRUE, pokud je aspoň jedna hodnota TRUE; jinak vrátí FALSE. (= logický součet přes všechny prvky vektoru)

Funkce all.equal() vrací TRUE, pokud jsou všechny prvky dvou vektorů "téměř stejné"; jinak vrací rozdíl

Funkce identical() vrací TRUE, pokud jsou dva objekty naprosto stejné.

Vytvořte logické vektory a zjistěte, jaký výsledek pro ně vrátí funkce all() a any():

• (T, T, T)
• (F, F, F)
• (T, F, T)

Zjistěte, co pro následující dvojice vektorů vrátí funkce all.equal():

• (1, 1) a (1, 1)
• (1, 1) a (1, 2)
• (1, 1) a (1, 1, 2)

Faktory slouží k uchovávání kategoriálních proměnných:

• ordinálních (pořadí je definované)
  kvalita služby: "velmi špatná", "špatná", "průměrná", "dobrá", "výborná"
• neordinálních (pořadí není definované)
  pohlaví: "žena" nebo "muž"

Je možné je kódovat jako celá čísla:

• muž = 0, žena = 1
• nejhorší kvalita služby = 0, druhá nejhorší 1 atd

Ale není to dobrý nápad.

Proč nekódovat faktory jako celá čísla:

1. je obtížné pamatovat si, co která hodnota znamená
2. R nebude vědět, jak s takovými proměnnými zacházet a bude je považovat za kardinální veličiny
3. je těžké hlídat, že proměnná obsahuje jen povolené úrovně

Faktory řeší všechny tyto problémy:

• jednotlivým hodnotám dávají "nálepky", které ukazují na jejich význam
• říkají R, že se jedná o kategoriální proměnnou
• R zná platné úrovně faktorů, tj. může hlídat, zda je zadaná úroveň platná

Faktory se tvoří pomocí funkce factor():

factor(c("žena", "muž", "muž", "žena"))

## [1] žena muž  muž  žena
## Levels: muž žena

Bezpečnější je vyjmenovat explicitně i platné úrovně:

factor(c("male", "female", "female", "male", "female", "beaver"),
       levels = c("female", "male", "asexual"),
       labels = c("žena", "muž", "asexulní"))

## [1] muž  žena žena muž  žena <NA>
## Levels: žena muž asexulní

Implicitně jsou faktory ne-ordinální. Ordinální vytvoříme:

quality <- factor(c("poor", "satisfactory", "excelent"),
                  levels = c("poor", "satisfactory", "excelent"),
                  ordered = TRUE)
quality

## [1] poor         satisfactory excelent    
## Levels: poor < satisfactory < excelent

quality[1] < quality[3]  # quality[i] je i-tý prvek vektoru

## [1] TRUE

Funkce is.ordered() vrací logickou hodnotu TRUE, pokud je faktor ordinální.

Pokud opravdu dobře nevíte, co děláte, používejte raději ne-ordinální faktory.

Ordinální faktory se ve formulích (tj. např. v ekonometrické analýze) chovají jinak, než byste možná čekali, viz

• https://stat.ethz.ch/pipermail/r-help/2008-January/150930.html
• https://cran.r-project.org/doc/manuals/R-intro.pdf, oddíl 11.1.1

Hodnoty úrovní můžete získat pomocí funkce levels(); jejich počet pomocí funkce nlevels(). Funkce levels() umožňuje i měnit hodnoty úrovní faktoru:

f <- factor(c("female", "male", "female"))
f

## [1] female male   female
## Levels: female male

levels(f) <- c("a", "b", "c")
f

## [1] a b a
## Levels: a b c

Do proměnné study ulože typ studia jako faktor:

• data jsou dána vektorem ("B", "B", "M", "D", "M", "B", "X")
• známé úrovně jsou "B", "M" a "D", ale
• budou uložené jako "Bc", "Mgr" a "PhD"

Napište kód, který spočítá počet neplatných hodnot ve study.

Někdy chceme rozdělit spojitou škálu do diskrétních hodnot:

grades <- c(1.05, 3.31, 2.57, 1.75, 2.15)  # studijní průměry
students <- cut(grades, breaks = c(0, 1.2, 2.5, Inf), right = TRUE)
students

## [1] (0,1.2]   (2.5,Inf] (2.5,Inf] (1.2,2.5] (1.2,2.5]
## Levels: (0,1.2] (1.2,2.5] (2.5,Inf]

levels(students) <- c("excelent", "normal", "rest")
students

## [1] excelent rest     rest     normal   normal  
## Levels: excelent normal rest

Změnu názvů úrovní je možné nastavit přímo ve funkci cut() parametrem labels. Detaily funkce viz dokumentace.

Vložte do vektoru v 1 000 náhodných čísel \(v \sim N(0, 1)\):

v <- rnorm(1000)

Rozdělte pomocí funkce cut() čísla na

• "common" – v intervalu \([-1, 1]\)
• "suspicious" – v intervalu \([-2, -1) \cup (1, 2]\)
• "extreme" – v intervalu \((-\infty, -2) \cup (2, \infty)\)

Hint: pomůže funkce abs().

Faktory jsou užitečné, ale i zrádné. Technicky je vektor celých čísel plus pojmenované úrovně:

unclass(factor(c("žena", "muž", "muž", "žena")))

## [1] 2 1 1 2
## attr(,"levels")
## [1] "muž"  "žena"

Automatická konverzi může být zavádějící – na celá čísla vezme číslo úrovně:

# vektor typů vašich letadel Boeing
f <- factor(c("747", "737", "777", "747"))
f

## [1] 747 737 777 747
## Levels: 737 747 777

as.integer(f)  # ouha! dostanete čísla úrovní!

## [1] 2 1 3 2

as.integer(as.character(f))  # je potřebná dvojí konverze!

## [1] 747 737 777 747

viz lecture notes