Obsah
5. Základní funkce pro práci s proměnnými
6. Automatické převody mezi hodnotami různých typů
9. Aritmetické a relační operace s hodnotou NaN
10. Speciální hodnota NA a její varianty
11. Řízení toku programu v jazyce R
12. Podmínky realizované konstrukcí if
15. Programová smyčka typu repeat
16. Programová smyčka typu while
17. Programová smyčka typu for
18. Seznam dnes použitých funkcí
19. Repositář s demonstračními příklady
1. Balíčky
Nejprve si popišme (popř. připomeňme) základní funkce používané pro práci s balíčky. Každý balíček typicky obsahuje sadu funkcí s jejich dokumentací, ovšem mnohdy obsahuje i testovací data, nápovědu k použití těchto testovacích dat a některé balíčky jsou založeny na nativních funkcích překládaných a linkovaných v rámci instalace balíčku.
Pokud je nějaký balíček již nainstalován a je nutné ho použít, lze takový balíček načíst příkazem require:
> require(lattice) Loading required package: lattice
Popř. se použije příkaz library:
> library(lattice)
Při pokusu inicializovat neexistující balíček dojde k chybě:
> library(foobar) Error in library(foobar) : there is no package called ‘foobar’
K balíčku je možné zobrazit dokumentaci zadáním příkazu help, kterému se předá jméno balíčku:
> help(lattice)
V tomto případě s výsledkem:
A_01_Lattice package:lattice R Documentation
Lattice Graphics
Description:
The ‘lattice’ add-on package is an implementation of Trellis
graphics for R. It is a powerful and elegant high-level data
visualization system with an emphasis on multivariate data. It is
designed to meet most typical graphics needs with minimal tuning,
but can also be easily extended to handle most nonstandard
requirements.
Details:
Trellis Graphics, originally developed for S and S-PLUS at the
Bell Labs, is a framework for data visualization developed by R.
A. Becker, W. S. Cleveland, et al, extending ideas presented in
Cleveland's 1993 book _Visualizing Data_. The Lattice API is
based on the original design in S, but extends it in many ways.
The Lattice user interface primarily consists of several
‘high-level’ generic functions (listed below in the “See Also”
section), each designed to create a particular type of display by
Pro zjištění informací o nainstalovaných balíčcích se používá příkaz installed.packages, který vrací tabulku s následujícími informacemi o každém balíčku:
- Package
- LibPath
- Version
- Priority
- Depends
- Imports
- LinkingTo
- Suggests
- Enhances
- OS Type
- License
- Built
Příklad výsledku pro čistě nainstalovaný jazyk R bez dalších doplňujících balíčků:
> installed.packages()
Package LibPath Version Priority
base "base" "/usr/lib64/R/library" "3.6.3" "base"
boot "boot" "/usr/lib64/R/library" "1.3-24" "recommended"
class "class" "/usr/lib64/R/library" "7.3-15" "recommended"
cluster "cluster" "/usr/lib64/R/library" "2.1.0" "recommended"
codetools "codetools" "/usr/lib64/R/library" "0.2-16" "recommended"
compiler "compiler" "/usr/lib64/R/library" "3.6.3" "base"
foreign "foreign" "/usr/lib64/R/library" "0.8-75" "recommended"
graphics "graphics" "/usr/lib64/R/library" "3.6.3" "base"
Depends
base NA
boot "R (>= 3.0.0), graphics, stats"
class "R (>= 3.0.0), stats, utils"
cluster "R (>= 3.3.0)"
codetools "R (>= 2.1)"
compiler NA
datasets NA
foreign "R (>= 3.0.0)"
Imports LinkingTo
base NA NA
boot NA NA
class "MASS" NA
cluster "graphics, grDevices, stats, utils" NA
codetools NA NA
compiler NA NA
datasets NA NA
foreign "methods, utils, stats" NA
Suggests
base "methods"
boot "MASS, survival"
class NA
cluster "MASS, Matrix"
codetools NA
compiler NA
datasets NA
foreign NA
graphics NA
Enhances License
base NA "Part of R 3.6.3"
boot NA "Unlimited"
class NA "GPL-2 | GPL-3"
cluster NA "GPL (>= 2)"
codetools NA "GPL"
compiler NA "Part of R 3.6.3"
datasets NA "Part of R 3.6.3"
foreign NA "GPL (>= 2)"
graphics NA "Part of R 3.6.3"
License_is_FOSS License_restricts_use OS_type MD5sum
base NA NA NA NA
boot NA NA NA NA
class NA NA NA NA
cluster NA NA NA NA
codetools NA NA NA NA
compiler NA NA NA NA
datasets NA NA NA NA
foreign NA NA NA NA
graphics NA NA NA NA
NeedsCompilation Built
base NA "3.6.3"
boot "no" "3.6.3"
class "yes" "3.6.3"
cluster "yes" "3.6.3"
codetools "no" "3.6.3"
compiler NA "3.6.3"
datasets NA "3.6.3"
foreign "yes" "3.6.3"
graphics "yes" "3.6.3"
2. Instalace nového balíčku
Instalaci nového balíčku lze provést příkazem install.packages, kterému se předá jméno požadovaného balíčku. Seznam dostupných balíčků naleznete například na adrese https://cran.r-project.org/web/packages/available_packages_by_name.html:
< install.packages("ggplot2")
Instalační proces ze zpočátku zeptá na volbu umístění serveru se zrcadlem balíčků (ovšem geograficky bližší server nemusí být nutně rychlejší):
Installing package into ‘/usr/lib64/R/library’ (as ‘lib’ is unspecified) --- Please select a CRAN mirror for use in this session --- Secure CRAN mirrors 1: 0-Cloud [https] 2: Australia (Canberra) [https] 3: Australia (Melbourne 1) [https] 4: Australia (Melbourne 2) [https]
Konkrétně v případě balíčku ggplot2 dochází k překladu nativních knihoven s využitím překladače jazyka C++:
...
...
...
** building package indices
** installing vignettes
** testing if installed package can be loaded from temporary location
** testing if installed package can be loaded from final location
** testing if installed package keeps a record of temporary installation path
* DONE (ggplot2)
Making 'packages.html' ... done
The downloaded source packages are in
‘/tmp/RtmpvIdtKQ/downloaded_packages’
Updating HTML index of packages in '.Library'
Making 'packages.html' ... done
Vidíme, že se na konci instalace upravila nápověda dostupná lokálně.
3. Datové typy a proměnné
S některými datovými typy programovacího jazyka R jsme se již seznámili v předchozích částech tohoto seriálu. Připomeňme si tedy, že tento programovací jazyk podporuje práci s následujícími datovými typy:
| # | Datový typ |
|---|---|
| 1 | Vektory |
| 2 | Seznamy |
| 3 | Factory |
| 4 | Pole |
| 5 | Matice |
| 6 | Datové rámce |
Nejjednodušším typem z předchozí šestice jsou vektory, které mohou v limitním případě obsahovat jediný prvek, který by byl v jiných programovacích jazycích považován za skalár. Existuje přitom šest datových typů takzvaných atomických vektorů (může to být matoucí, ale v tomto kontextu se setkáme i s označením „třída vektoru“):
| # | Režim | Typ (třída) atomického vektoru | Příklad |
|---|---|---|---|
| 1 | Logical | Logical | TRUE, FALSE |
| 2 | Numeric | Double | 3.14, 1000, 10000.5 |
| 3 | Numeric | Integer | 42L, 0L |
| 4 | Complex | Complex | 1 + 2i |
| 5 | Character | Character | „Hello“ |
| 6 | Raw | Raw | charToRaw(„Hello“) |
Číslo s plovoucí řádovou čárkou
> x <- 3.14 > is.numeric(x) [1] TRUE > is.integer(x) [1] FALSE > is.double(x) [1] TRUE > is.complex(x) [1] FALSE
Celé číslo
> x <- 1L > is.numeric(x) [1] TRUE > is.integer(x) [1] TRUE > is.double(x) [1] FALSE > is.complex(x) [1] FALSE
Komplexní číslo
> x <- 1+2i > is.numeric(x) [1] TRUE > is.integer(x) [1] FALSE [1] FALSE > is.double(x) [1] FALSE > is.complex(x) [1] TRUE
4. Deklarace proměnných
Proměnné se deklarují (vytváří) přiřazením nové hodnoty (libovolného typu) do proměnné s využitím operátoru ← popř. operátoru =. Při deklaraci proměnných však není nutné datový typ explicitně specifikovat, protože se dynamicky odvodí z hodnoty, která je do proměnné přiřazována. Typ (resp. v řeči jazyka R spíše třídu) proměnné lze zjistit standardní funkcí class, takže si vyzkoušejme několik příkladů:
> x <- 10
> class(x)
[1] "numeric"
> x <- 10L
> class(x)
[1] "integer"
> x <- 1+2i
> class(x)
[1] "complex"
> x <- "Hello world!"
> class(x)
[1] "character"
> x <- charToRaw("Hello")
> class(x)
[1] "raw"
> x <- TRUE
> class(x)
[1] "logical"
Režim uložení libovolné hodnoty se zjistí funkcí nazvanou typeof:
> x <- 10
> typeof(x)
[1] "double"
> x <- 10L
> typeof(x)
[1] "integer"
> x <- 1+2i
> typeof(x)
[1] "complex"
> x <- "Hello world!"
> typeof(x)
[1] "character"
> x <- charToRaw("Hello")
> typeof(x)
[1] "raw"
> x <- TRUE
> typeof(x)
[1] "logical"
Posledním důležitým plnohodnotným datovým typem jsou funkce, kterými se budeme zabývat v samostatné kapitole:
> f <- function() {42}
> f
function() {42}
> f()
[1] 42
> class(f)
[1] "function"
> typeof(f)
[1] "closure"
5. Základní funkce pro práci s proměnnými
Pro práci s proměnnými je k dispozici několik funkcí, které je možné použít pro prakticky libovolné hodnoty:
| # | Funkce | Stručný popis funkce |
|---|---|---|
| 1 | ls() | vrátí vektor se jmény všech viditelných objektů |
| 2 | str(x) | zobrazení objektu v čitelné podobě |
| 3 | head(x) | zobrazení první části obsahu proměnné (vektoru, pole, datového rámce atd.) |
| 4 | tail(x) | zobrazení poslední části obsahu proměnné (vektoru, pole, datového rámce atd.) |
| 5 | class(x) | zobrazení třídy (typu) hodnoty navázané na proměnnou (bylo popsáno ve čtvrté kapitole) |
| 6 | typeof(x) | zobrazení režimu uložení hodnoty navázané na proměnnou (bylo popsáno ve čtvrté kapitole) |
| 7 | rm(x) | odstranění objektů z operační paměti |
Následují příklady použití těchto funkcí:
> v <- 1:100 > head(v) [1] 1 2 3 4 5 6 > tail(v) [1] 95 96 97 98 99 100 > class(v) [1] "integer" > typeof(v) [1] "integer" > str(v) int [1:100] 1 2 3 4 5 6 7 8 9 10 ... > ls() [1] "i" "v" "x"
Specifikace počtu zobrazených prvků ze začátku, resp. konce obsahu proměnné:
> head(v, 10) [1] 1 2 3 4 5 6 7 8 9 10 > tail(v, 10) [1] 91 92 93 94 95 96 97 98 99 100
Použít je však možné i záporné indexy, které určují, kolik prvků od konce/začátku má být z výpisu vynecháno:
> head(v, -10) [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 [26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 [51] 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 [76] 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 > tail(v, -10) [1] 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 [20] 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 [39] 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 [58] 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 [77] 87 88 89 90 91 92 93 94 95 96 97 98 99 100
6. Automatické převody mezi hodnotami různých typů
Typový systém programovacího jazyka R se chová poněkud zvláštním způsobem, což může vést k mnoha „záhadným“ chybám. V některých případech provádí automatickou typovou konverzi tak, aby například byly oba operandy nějakého binárního operátoru kompatibilní. Například:
> 1 == "1" [1] TRUE
V tomto případě je první operand taktéž převeden na řetězec.
U vektorů platí, že všechny jejich prvky musí být stejného typu, takže i zde dochází k automatickým typovým konverzím.
Dvě hodnoty typu double, resp. numeric:
> x <- c(1, 1) > x [1] 1 1 > class(x) [1] "numeric"
Hodnoty různého typu (druhé číslo je v tomto příkladu typu integer):
> x <- c(1, 1L) > x [1] 1 1 > class(x) [1] "numeric"
Dva prvky typu integer:
> x <- c(1L, 1L) > x [1] 1 1 > class(x) [1] "integer"
Jeden z prvků je komplexní číslo:
> x <- c(1, 1+2i) > x [1] 1+0i 1+2i > class(x) [1] "complex"
Jeden z prvků je řetězcem:
> x <- c(1, "1") > x [1] "1" "1" > class(x) [1] "character"
Automatické typové konverze se provádí i při spuštění některých funkcí:
> x <- c(TRUE, FALSE, TRUE, FALSE) > x [1] TRUE FALSE TRUE FALSE > sum(x) [1] 2 > mean(x) [1] 0.5
Ovšem například řetězce se na číselné hodnoty automaticky nepřevádí:
> y <- c("1", "2", "3", "4")
> y
[1] "1" "2" "3" "4"
> class(y)
[1] "character"
> sum(y)
Error in sum(y) : invalid 'type' (character) of argument
7. Explicitní datové konverze
Převod (tedy konverzi) na jiný datový typ lze provést i explicitně, a to s využitím následujících funkcí:
| # | Jméno funkce | Stručný popis funkce |
|---|---|---|
| 1 | as.logical | převod na typ Logical |
| 2 | as.integer | převod na typ Integer |
| 3 | as.double | převod na typ Double |
| 4 | as.character | převod na typ Character |
Opět si ukážeme některé příklady použití:
> x <- c(TRUE, FALSE, TRUE, FALSE) > as.numeric(x) [1] 1 0 1 0 > x [1] TRUE FALSE TRUE FALSE
Převod číselných hodnot uložených v řetězcích je možný:
> as.integer(c("1", "2", "3"))
[1] 1 2 3
> as.complex(c("1+2i"))
[1] 1+2i
Zpětný převod (numerické hodnoty na řetězec):
> as.character(c(1, 2, 3, 4)) [1] "1" "2" "3" "4"
Převod na vektor logických hodnot:
> as.logical(c(0, 1, 2, -1)) [1] FALSE TRUE TRUE TRUE
Pokud nějakou hodnotu konvertovat nelze, což je příklad řetězce „a“ převáděného na celé číslo, bude tato hodnota nahrazena za NA a přitom se vypíše varování:
> as.integer(c("1", "1.5", "a"))
[1] 1 1 NA
Warning message:
NAs introduced by coercion
> as.double(c("1", "1.5", "a"))
[1] 1.0 1.5 NA
Warning message:
NAs introduced by coercion
Některé konverze mohou vést k částečné ztrátě informací; opět se zobrazí varování:
> as.integer(c(1, 2L, 3.14, 5+6i)) [1] 1 2 3 5 Warning message: imaginary parts discarded in coercion
8. Hodnoty Inf, -Inf a NaN
Programovací jazyk R je mj. určen pro zpracování dat získaných z různých zdrojů i pro numerické výpočty. Z tohoto důvodu podporuje jak speciální hodnotu NaN značící „not a number“ (což ale není totéž jako hodnota NA), tak i hodnoty Inf a -Inf reprezentující kladné a záporné nekonečno. S těmito hodnotami lze provádět i aritmetické operace atd.
Typ těchto hodnot je Numeric:
> x <- Inf > class(x) [1] "numeric" > x <- -Inf > class(x) [1] "numeric" > x <- NaN > class(x) [1] "numeric"
Nyní si vyzkoušejme některé aritmetické operace s hodnotou Inf:
> x <- Inf > -x [1] -Inf > x + 0 [1] Inf > x + 10 [1] Inf > x * 0 [1] NaN > x * 10 [1] Inf > x - x [1] NaN > x / x [1] NaN
Základní relační operace pracují s nekonečnem podle předpokladů:
> x <- Inf > x < 0 [1] FALSE > x > 0 [1] TRUE > x == 0 [1] FALSE
Ovšem nikoli již v kombinaci s nějakou aritmetickou operací!:
> x <- Inf > x < x * 2 [1] FALSE > x < x + 1 [1] FALSE
9. Aritmetické a relační operace s hodnotou NaN
Aritmetické operace s hodnotou NaN mají prakticky vždy stejný výsledek – opět NaN, což ostatně odpovídá i normě IEEE 794:
> x <- NaN > -x [1] NaN > x + 0 [1] NaN > x + 10 [1] NaN > x * 0 [1] NaN > x * 10 [1] NaN > x - x [1] NaN > x / x [1] NaN
Speciální chování nalezneme u relačních operátorů, protože v tomto ohledu se jazyk R odlišuje od mnoha jiných jazyků, protože vrací hodnotu NA a nikoli FALSE:
> x <- NaN > x < 0 [1] NA > x > 0 [1] NA > x == 0 [1] NA > x < NaN [1] NA > x > NaN [1] NA > x == NaN [1] NA
Totéž platí i pro kombinaci relačního operátoru s operátorem aritmetickým:
> x <- NaN > x < x * 2 [1] NA > x < x + 1 [1] NA > x > x * 2 [1] NA > x > x + 1 [1] NA
10. Speciální hodnota NA a její varianty
Při zpracování reálných dat se nevyhneme situacím, kdy nějaké údaje zcela chybí. V programovacím jazyku R mohou být takové neexistující údaje reprezentovány speciální hodnotou NA neboli „Not Available“. Tato speciální hodnota může být použita v aritmetických operacích, což mj. naznačuje, že se jedná o koncepční rozdíl oproti NULL či None (spíše se blíží koncepci nil v LISPovských jazycích podporujících „nil punning“:
> NA+NA [1] NA > NA-NA [1] NA > NA+1 [1] NA > NA*2 [1] NA > NA+Inf [1] NA > NA/Inf [1] NA
Výsledky porovnání (relačních operací):
> NA > 42 [1] NA > NA < 42 [1] NA > NA == 42 [1] NA > NA == NA [1] NA > NA != NA [1] NA
Výsledky logických a bitových operací – pozor na to, že zde NA skutečně vystupuje v roli „zde nic není“, což ovlivňuje operaci logického součtu a logického součinu:
> !NA [1] NA > NA | TRUE [1] TRUE > NA & FALSE [1] FALSE > NA ^ 0 [1] 1
> NA_integer_ + 1 [1] NA > NA_real_ * 2.4 [1] NA > NA_character_ [1] NA
11. Řízení toku programu v jazyce R
V programovacím jazyku R pochopitelně nalezneme i konstrukce určené pro řízení toku programu. Prozatím jsme se s nimi nesetkali, a to zejména z toho důvodu, že mnoho skriptů zpracovávajících data se bez těchto relativně nízkoúrovňových konstrukcí bez problému obejde (což ostatně platí i pro další doménově specifické jazyky typu Matlab atd.):
| # | Konstrukce | Stručný popis programové konstrukce |
|---|---|---|
| 1 | if | rozvětvení na základě vyhodnocené podmínky |
| 2 | ifelse | aplikace podmínky na všechny prvky datového typu |
| 3 | switch | rozvětvení na základě numerické hodnoty nebo řetězce |
| 4 | repeat | nekonečná programová smyčka |
| 5 | while | programová smyčka s testem na začátku |
| 6 | for | programová smyčka procházející prvky datového typu |
Jednotlivé konstrukce budou podrobněji popsány v navazujících kapitolách.
12. Podmínky realizované konstrukcí if
V programovacím jazyku R se používá klasická rozhodovací konstrukce (větvení) pojmenovaná if. Tato konstrukce existuje ve dvou variantách – bez větve else a s větví else (což opět koresponduje s většinou ostatních mainstreamových programovacích jazyků):
if (podmínka) větev_true if (podmínka) větev_true else větev_false
Podmínkou je zde myšlen výraz vyhodnocený na TRUE či FALSE; samotné větve mohou taktéž obsahovat jediný výraz, jehož hodnota je vrácena:
> x1 <- if (TRUE) 1 else 2 > x2 <- if (FALSE) 1 else 2 > x1 [1] 1 > x2 [1] 2
Celočíselné hodnoty jsou převáděny na TRUE/FALSE podle běžných zvyklostí (0=FALSE, vše ostatní je TRUE):
> if (1) "yes" else "no" [1] "yes" > if (0) "yes" else "no" [1] "no"
Ovšem pozor na to, že totéž neplatí o celočíselných hodnotách v řetězci:
> if ("1") "yes" else "no"
Error in if ("1") "yes" else "no" :
argument is not interpretable as logical
Z předchozích kapitol již víme, že výsledkem mnoha operací může být hodnota NA. Tu ovšem přímo v podmínce použít nelze:
> if (NA) "yes" else "no" Error in if (NA) "yes" else "no" : missing value where TRUE/FALSE needed
Pokud se v podmínce vyskytne vektor s více prvky (což může být časté), testuje se pouze první prvek tohoto vektoru a navíc se uživateli vypíše varování o provedené operaci:
> if (c(TRUE, FALSE)) "yes" else "no" [1] "yes" Warning message: In if (c(TRUE, FALSE)) "yes" else "no" : the condition has length > 1 and only the first element will be used > if (c(FALSE, FALSE)) "yes" else "no" [1] "no" Warning message: In if (c(FALSE, FALSE)) "yes" else "no" : the condition has length > 1 and only the first element will be used
Toto chování (které může být zbytečně benevolentní) je možné vypnout tímto trikem:
> Sys.setenv("_R_CHECK_LENGTH_1_CONDITION_" = "true")
> if (c(TRUE, FALSE)) "yes" else "no"
Error in if (c(TRUE, FALSE)) "yes" else "no" :
the condition has length > 1
> if (c(FALSE, FALSE)) "yes" else "no"
Error in if (c(FALSE, FALSE)) "yes" else "no" :
the condition has length > 1
Složitější konstrukce s vnořenými konstrukcemi if-else:
grade <- 0
if (grade >= 95) {
"A"
} else if (grade >= 80) {
"B"
} else if (grade >= 70) {
"C"
} else if (grade >= 55) {
"D"
} else {
"E"
}
13. Konstrukce ifelse
V mnoha případech se stane, že potřebujeme zpracovat celý vektor dat na základě nějaké podmínky aplikované na jednotlivé prvky vektoru. Tuto činnost zajišťuje konstrukce ifelse, která je zapisována formou volání funkce, i když se ve skutečnosti o tradiční funkci nejedná. Do ifelse se zapíše podmínka (viz předchozí kapitolu), hodnota či výraz použitý při splnění podmínky a hodnota či výraz použitý při jejím nesplnění:
Vytvoření nového vektoru, který bude obsahovat informaci o tom, zda byl prvek původního vektoru sudý nebo lichý (zdrojový vektor obsahuje hodnoty od 1 do 10 včetně):
> x <- 1:10 > ifelse(x %% 2 == 0, "even", "odd") [1] "odd" "even" "odd" "even" "odd" "even" "odd" "even" "odd" "even"
Použití složitějších výrazů:
> x <- 1:10 > ifelse(x %% 2 == 0, "even", x) [1] "1" "even" "3" "even" "5" "even" "7" "even" "9" "even" > ifelse(x %% 2 == 0, x*10, 1/x) [1] 1.0000000 20.0000000 0.3333333 40.0000000 0.2000000 60.0000000 [7] 0.1428571 80.0000000 0.1111111 100.0000000
14. Konstrukce switch
Vraťme se na chvíli k poněkud složitější konstrukci if-else s několika postupně vyhodnocovanými podmínkami. V takové konstrukci můžeme snadno reagovat na neplatný vstup:
input <- 3
if (input == 0) {
"zero"
} else if (input == 1) {
"one"
} else if (input == 2) {
"two"
} else {
stop("Invalid `input` value")
}
Otestování v praxi:
> input <- 2
>
> if (input == 0) {
+ "zero"
+ } else if (input == 1) {
+ "one"
+ } else if (input == 2) {
+ "two"
+ } else {
+ stop("Invalid `input` value")
+ }
[1] "two"
> input <- 3
>
> if (input == 0) {
+ "zero"
+ } else if (input == 1) {
+ "one"
+ } else if (input == 2) {
+ "two"
+ } else {
+ stop("Invalid `input` value")
+ }
Error: Invalid `input` value
Jedná se ovšem o zbytečně složitý zápis, protože stejného chování můžeme dosáhnout konstrukcí pojmenovanou switch, která se v programovacím jazyku R opět zapisuje tak, jakoby se jednalo o volání funkce. Prvním parametrem je výraz, jehož výsledek určuje, který z dalších parametrů se má vrátit jako výsledek. Pokud je výraz vyhodnocen na celé číslo, vrátí se n-tý parametr (po svém vyhodnocení). Parametry jsou očíslovány od jedničky:
input <- 0
switch(input+1,
"zero",
"one",
"two",
stop("Invalid `input` value")
)
Poněkud odlišného chování dosáhneme tehdy, pokud se použije následující zápis. Ten nám umožní vybírat hodnoty na základě řetězců (klíčů) uvedených před znakem „=“:
command <- "color"
switch(command,
"color" = "red",
"shape" = "square",
"length" = 5)
"red"
command <- "shape"
switch(command,
"color" = "red",
"shape" = "square",
"length" = 5)
"square"
command <- "length"
switch(command,
"color" = "red",
"shape" = "square",
"length" = 5)
5
Při výběru může dojít k vyhodnocení NA tehdy, pokud není řetězec v množině klíčů nalezen:
command <- "foobar"
switch(command,
"color" = "red",
"shape" = "square",
"length" = 5)
Ovšem chybu můžeme nahlásit i explicitně:
command <- "foobar"
switch(command,
"color" = "red",
"shape" = "square",
"length" = 5)
stop("Invalid `input` value"))
Error: Invalid `input` value
15. Programová smyčka typu repeat
Dalším typem řídicích konstrukcí jsou programové smyčky. Nejuniverzálnější a současně i nejjednodušší je smyčka typu repeat. Jedná se o nekonečnou smyčku, jejíž základní podoba vypadá následovně:
repeat print("Diamonds are forever")
[1] "Diamonds are forever"
[1] "Diamonds are forever"
[1] "Diamonds are forever"
...
...
...
Častěji se ovšem setkáme s použitím blokových závorek, což nám umožňuje zápis více výrazů do těla smyčky:
repeat {
print("Diamonds are forever")
}
[1] "Diamonds are forever"
[1] "Diamonds are forever"
[1] "Diamonds are forever"
...
...
...
Explicitně vytvořené počitadlo v nekonečné smyčce:
i <- 0
repeat {
i <- i + 1
print(i)
}
[1] 1
[1] 2
[1] 3
...
...
...
Tuto smyčku (a i další dvě typy programových smyček) je možné ukončit příkazem break známým z dalších programovacích jazyků:
i <- 10
repeat {
print(i)
i <- i - 1
if (i == 0)
break
}
[1] 10
[1] 9
[1] 8
[1] 7
[1] 6
[1] 5
[1] 4
[1] 3
[1] 2
[1] 1
Použít lze i příkaz next, který má stejný význam jako continue známý z céčkové větve programovacích jazyků:
i <- 0
repeat {
i <- i + 1
if (i <= 5)
next
print(i)
if (i >= 10)
break
}
[1] 6
[1] 7
[1] 8
[1] 9
[1] 10
16. Programová smyčka typu while
V jazyku R nalezneme i programovou smyčku typu while, v níž se podmínka (jak bývá zvykem už od dob Algolu) zapisuje před tělo smyčky, protože se taktéž vyhodnocuje před vstupem do smyčky (tedy před začátkem další iterace. Základní forma této smyčky vypadá následovně:
while(podmínka) příkaz
Častěji se však používají blokové závorky:
while(podmínka) {
příkaz
...
...
...
}
Příklad smyčky s explicitně použitým počitadlem:
i <- 10
while (i > 0) {
print(i)
i <- i - 1
}
[1] 10
[1] 9
[1] 8
[1] 7
[1] 6
[1] 5
[1] 4
[1] 3
[1] 2
[1] 1
Nepatrně složitější výpočet:
i <- 1
while (i < 100000) {
print(i)
i <- i * 2
}
[1] 1
[1] 2
[1] 4
[1] 8
[1] 16
[1] 32
[1] 64
[1] 128
[1] 256
[1] 512
[1] 1024
[1] 2048
[1] 4096
[1] 8192
[1] 16384
[1] 32768
[1] 65536
I v této smyčce je možné použít příkaz break:
i <- 1
while (TRUE) {
print(i)
i <- i * 2
if (i > 65536)
break
}
[1] 1
[1] 2
[1] 4
[1] 8
[1] 16
[1] 32
[1] 64
[1] 128
[1] 256
[1] 512
[1] 1024
[1] 2048
[1] 4096
[1] 8192
[1] 16384
[1] 32768
[1] 65536
Použitelný je i příkaz next pro vynechání části těla smyčky:
i <- 1
while (TRUE) {
i <- i * 2
if (i > 65536)
break
if (i < 1000)
next
print(i)
}
[1] 1024
[1] 2048
[1] 4096
[1] 8192
[1] 16384
[1] 32768
[1] 65536
17. Programová smyčka typu for
Posledním typem smyčky programovacího jazyka R je smyčka typu for, která se používá pro průchod prvky vektorů, datových rámců atd. Základní tvar této smyčky vypadá následovně:
for (i in 1:10) {
print(i)
}
[1] 1
[1] 2
[1] 3
[1] 4
[1] 5
[1] 6
[1] 7
[1] 8
[1] 9
[1] 10
Na rozdíl od jiných jazyků je proměnná i (řídicí proměnná smyčky) dostupná i mimo její tělo:
> i [1] 10
Díky tomu, jak jsou v jazyku R konstruovány sekvence, je možné použít i čítač směrem dolů:
for (i in 10:1) {
print(i)
}
[1] 10
[1] 9
[1] 8
[1] 7
[1] 6
[1] 5
[1] 4
[1] 3
[1] 2
[1] 1
I v tomto typu smyčky lze využít příkaz break:
for (i in 1:10) {
print(i)
if (i > 5)
break
}
[1] 1
[1] 2
[1] 3
[1] 4
[1] 5
[1] 6
A taktéž příkaz next:
for (i in 1:10) {
if (i < 5)
next
print(i)
}
[1] 5
[1] 6
[1] 7
[1] 8
[1] 9
[1] 10
Kombinace obou zmíněných příkazů:
for (i in 1:20) {
if (i < 5)
next
else if (i > 10)
break
print(i)
}
[1] 5
[1] 6
[1] 7
[1] 8
[1] 9
[1] 10
Průchod prvky vektoru:
v <- c(1, 2, 5, 10)
for (i in v) {
print(i)
}
[1] 1
[1] 2
[1] 5
[1] 10
Pozor na použití počitadla při průchodu vektorem. Následující příklad sice bude funkční:
v <- c(1, 2, 5, 10)
for (i in 1:length(v)) {
print(i)
}
[1] 1
[1] 2
[1] 3
[1] 4
Ale tento již nikoli, protože se vygenerují pouze indexy 1 a 0 (v tomto pořadí):
v <- c()
for (i in 1:length(v)) {
print(i)
}
[1] 1
[1] 0
18. Seznam dnes použitých funkcí
| # | Funkce | Stručný popis funkce |
|---|---|---|
| 1 | ls() | vektor se jmény všech objektů |
| 2 | str(x) | zobrazení objektu v čitelné podobě |
| 3 | head(x) | zobrazení první části obsahu proměnné (vektoru, pole, datového rámce atd.) |
| 4 | tail(x) | zobrazení poslední části obsahu proměnné (vektoru, pole, datového rámce atd.) |
| 5 | class(x) | zobrazení třídy (typu) hodnoty navázané na proměnnou (bylo popsáno ve třetí kapitole) |
| 6 | typeof(x) | zobrazení režimu uložení hodnoty navázané na proměnnou (bylo popsáno ve třetí kapitole) |
| 7 | rm(x) | odstranění objektů z operační paměti |
| 8 | is.numeric | test na typ parametru funkce |
| 9 | is.integer | test na typ parametru funkce |
| 10 | is.double | test na typ parametru funkce |
| 11 | is.complex | test na typ parametru funkce |
| 12 | as.logical | převod na typ Logical |
| 13 | as.integer | převod na typ Integer |
| 14 | as.double | převod na typ Double |
| 15 | as.character | převod na typ Character |
| 16 | require | načtení zvoleného balíčku |
| 17 | library | načtení zvoleného balíčku |
| 18 | installed.packages | seznam všech nainstalovaných balíčků |
| 19 | install.packages | instalace zvoleného balíčku |
19. Repositář s demonstračními příklady
Zdrojové kódy všech dnes použitých demonstračních příkladů byly uloženy do nového Git repositáře, který je dostupný na adrese https://github.com/tisnik/r-examples V případě, že z nějakého důvodu nebudete chtít klonovat celý repositář (ten je ovšem – alespoň prozatím – velmi malý, dnes má stále jen jednotky kilobajtů), můžete namísto toho použít odkazy na jednotlivé demonstrační příklady, které naleznete v následující tabulce:
20. Odkazy na Internetu
- R Tutorial
https://www.tutorialspoint.com/r/index.htm - Difference between double-precision data type and numeric data type
https://stackoverflow.com/questions/50255318/difference-between-double-precision-data-type-and-numeric-data-type - R Data Types
https://www.w3schools.in/r/data-types/ - What is the difference between mode and class in R?
https://stackoverflow.com/questions/35445112/what-is-the-difference-between-mode-and-class-in-r - switch: Select One of a List of Alternatives
https://rdrr.io/r/base/switch.html - R switch() Function
https://www.datamentor.io/r-programming/switch-function/ - Using ggplot in Python: Visualizing Data With plotnine
https://realpython.com/ggplot-python/ - A Grammar of Graphics for Python
https://plotnine.readthedocs.io/en/stable/ - Plotnine gallery
https://plotnine.readthedocs.io/en/latest/gallery.html - plotnine 0.7.1 na PyPi
https://pypi.org/project/plotnine/ - plotnine-examples 0.0.4 na PyPi
https://pypi.org/project/plotnine-examples/ - plotnine examples repository
https://github.com/has2k1/plotnine-examples - Data visualization in R: cheat sheet
https://github.com/rstudio/cheatsheets/blob/master/data-visualization-2.1.pdf - The R Project for Statistical Computing
https://www.r-project.org/ - An Introduction to R
https://cran.r-project.org/doc/manuals/r-release/R-intro.pdf - R (programming language)
https://en.wikipedia.org/wiki/R_(programming_language) - The R Programming Language
https://www.tiobe.com/tiobe-index/r/ - R Graphics Second Edition
https://www.stat.auckland.ac.nz/~paul/RG2e/ - ggplot2 – Introduction
https://www.tutorialspoint.com/ggplot2/ggplot2_introduction.htm - ggplot2: Elegant Graphics for Data Analysis
https://ggplot2-book.org/index.html - Create Elegant Data Visualisations Using the Grammar of Graphics
https://www.rdocumentation.org/packages/ggplot2/versions/3.3.2 - Grid
https://www.stat.auckland.ac.nz/~paul/grid/grid.html - Interactive Course: Data Visualization with lattice in R
https://www.datacamp.com/courses/data-visualization-in-r-with-lattice - Lattice: trellis graphics for R
https://lattice.r-forge.r-project.org/ - Lattice: Multivariate Data Visualization with R
http://lmdvr.r-forge.r-project.org/figures/figures.html - Getting Started with Lattice Graphics
https://lattice.r-forge.r-project.org/Vignettes/src/lattice-intro/lattice-intro.pdf - Using lattice’s xyplot()
https://homerhanumat.github.io/tigerstats/xyplot.html - ggplot2 Tutorial
https://www.tutorialspoint.com/ggplot2/index.htm - Lattice Package in R with Functions and Graphs
https://techvidvan.com/tutorials/lattice-package-in-r/ - The R Graph Gallery
https://www.r-graph-gallery.com/index.html - Lattice Graphs
https://www.statmethods.net/advgraphs/trellis.html - ggplot2 (Graph gallery)
https://www.r-graph-gallery.com/ggplot2-package.html - R Markdown
https://rmarkdown.rstudio.com/ - R Markdown: The Definitive Guide
https://bookdown.org/yihui/rmarkdown/ - R Markdown Cheat Sheet
https://rstudio.com/wp-content/uploads/2016/03/rmarkdown-cheatsheet-2.0.pdf - Introduction to R Markdown
https://rmarkdown.rstudio.com/articles_intro.html - R Cheat Sheets
https://blog.sergiouri.be/2016/07/r-cheat-sheets.html - R Cheat Sheet
https://s3.amazonaws.com/quandl-static-content/Documents/Quandl±+R+Cheat+Sheet.pdf - Base R Cheat Sheet
https://rstudio.com/wp-content/uploads/2016/06/r-cheat-sheet.pdf - PYPL PopularitY of Programming Language
https://pypl.github.io/PYPL.html - Tiobe index
https://www.tiobe.com/tiobe-index/ - Stack Overflow: Most Loved, Dreaded & Wanted Programming Languages In 2020
https://fossbytes.com/stack-overflow-most-loved-dreaded-wanted-programming-languages-in-2020/ - How to Install and Use R on Ubuntu
https://itsfoss.com/install-r-ubuntu/ - R programming for beginners – Why you should use R
https://www.youtube.com/watch?v=9kYUGMg_14s - GOTO 2012 • The R Language The Good The Bad & The Ugly
https://www.youtube.com/watch?v=6S9r_YbqHy8 - Intro to Data Visualization with R & ggplot2
https://www.youtube.com/watch?v=49fADBfcDD4 - Plotting with ggplot2: Part 1
https://www.youtube.com/watch?v=HeqHMM4ziXA - Plotting with ggplot2: Part 2
https://www.youtube.com/watch?v=n8kYa9vu1l8 - R vs Python – What should I learn in 2020? | R and Python Comparison
https://www.youtube.com/watch?v=eRP_J2yLjSU - R Programming 101
https://www.youtube.com/c/rprogramming101 - Seriál Tvorba grafů pomocí programu „R“
https://www.root.cz/serialy/tvorba-grafu-pomoci-programu-r/ - Tvorba grafů pomocí programu „R“: úvod
https://www.root.cz/clanky/tvorba-grafu-pomoci-programu-r-1/ - Tvorba grafů pomocí programu „R“: pokročilé funkce
https://www.root.cz/clanky/tvorba-grafu-pomoci-programu-r-pokrocile-funkce/ - Tvorba grafů pomocí programu „R“: vkládání textu, čeština
https://www.root.cz/clanky/grafy-pomoci-programu-r-vkladani-textu-cestina/ - Cesta erka: Krok nultý – instalace & nastavení – prostředí, projekty, package
https://www.jla-data.net/r4su/r4su-environment-setup/ - Cesta erka: Krok první – operace a struktury – proměnné, rovnítka a dolary
https://www.jla-data.net/r4su/r4su-data-structures/ - Cesta erka: Krok druhý – načtení externích dat – csvčka, excely a databáze
https://www.jla-data.net/r4su/r4su-read-data/ - Cesta erka: Krok třetí – manipulace s daty – dplyr, slovesa a pajpy
https://www.jla-data.net/r4su/r4su-manipulate-data/ - Cesta erka: Krok čtvrtý – podání výsledků – ggplot, geomy a estetiky
https://www.jla-data.net/r4su/r4su-report-results/ - Cesta erka: Krok pátý – case study – případ piva v Praze
https://www.jla-data.net/r4su/r4su-case-study-beer/ - V indexu popularity programovacích jazyků TIOBE překvapilo R, Go, Perl, Scratch a Rust
https://www.root.cz/zpravicky/v-indexu-popularity-programovacich-jazyku-tiobe-prekvapilo-r-go-perl-scratch-a-rust/ - Is R Programming SURGING in Popularity in 2020?
https://www.youtube.com/watch?v=Duwn-vImyXE - Using the R programming language in Jupyter Notebook
https://docs.anaconda.com/anaconda/navigator/tutorials/r-lang/ - Using R on Jupyter Notebook
https://dzone.com/articles/using-r-on-jupyternbspnotebook - Graphics, ggplot2
http://r4stats.com/examples/graphics-ggplot2/ - A Practice Data Set
https://r4stats.wordpress.com/examples/mydata/ - Shiny – galerie projektů
https://shiny.rstudio.com/gallery/ - Seriál Programovací jazyk Julia
https://www.root.cz/serialy/programovaci-jazyk-julia/ - Julia (front page)
http://julialang.org/ - Julia – repositář na GitHubu
https://github.com/JuliaLang/julia - Julia (programming language)
https://en.wikipedia.org/wiki/Julia_%28programming_language%29 - IJulia
https://github.com/JuliaLang/IJulia.jl - Introducing Julia
https://en.wikibooks.org/wiki/Introducing_Julia - Julia: the REPL
https://en.wikibooks.org/wiki/Introducing_Julia/The_REPL - Introducing Julia/Metaprogramming
https://en.wikibooks.org/wiki/Introducing_Julia/Metaprogramming - Month of Julia
https://github.com/DataWookie/MonthOfJulia - Learn X in Y minutes (where X=Julia)
https://learnxinyminutes.com/docs/julia/ - New Julia language seeks to be the C for scientists
http://www.infoworld.com/article/2616709/application-development/new-julia-language-seeks-to-be-the-c-for-scientists.html - Julia: A Fast Dynamic Language for Technical Computing
http://karpinski.org/publications/2012/julia-a-fast-dynamic-language - The LLVM Compiler Infrastructure
http://llvm.org/ - Julia: benchmarks
http://julialang.org/benchmarks/ - R Vector
https://www.datamentor.io/r-programming/vector/ - .R File Extension
https://fileinfo.com/extension/r - Lineární regrese
https://cs.wikipedia.org/wiki/Line%C3%A1rn%C3%AD_regrese - lm (funkce)
https://www.rdocumentation.org/packages/stats/versions/3.6.2/topics/lm - quit (funkce)
https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/quit - c (funkce)
https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/c - help (funkce)
https://www.rdocumentation.org/packages/utils/versions/3.6.2/topics/help - Shiny: Introduction to interactive documents
https://shiny.rstudio.com/articles/interactive-docs.html - R Release History 1997–2013
http://timelyportfolio.github.io/rCharts_timeline_r/ - R: atomic vectors
https://renenyffenegger.ch/notes/development/languages/R/data-structures/vector/ - 11 Best R Programming IDE and editors
https://www.dunebook.com/best-r-programming-ide/ - CRAN – The Comprehensive R Archive Network
https://cran.r-project.org/ - R – Arrays
https://www.tutorialspoint.com/r/r_arrays.htm - Array vs Matrix in R Programming
https://www.geeksforgeeks.org/array-vs-matrix-in-r-programming/?ref=rp - Online R Language IDE
https://www.jdoodle.com/execute-r-online/ - Execute R Online (R v3.4.1)
https://www.tutorialspoint.com/execute_r_online.php - Snippets: Run any R code you like. There are over twelve thousand R packages preloaded
https://rdrr.io/snippets/ - R Package Documentation
https://rdrr.io/ - Data Reshaping in R – Popular Functions to Organise Data
https://techvidvan.com/tutorials/data-reshaping-in-r/ - What is an R Data Frame?
https://magoosh.com/data-science/what-is-an-r-data-frame/ - What's a data frame?
https://campus.datacamp.com/courses/free-introduction-to-r/chapter-5-data-frames?ex=1 - data.frame
https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/data.frame - as.data.frame
https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/as.data.frame - table
https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/table - Python Pandas – DataFrame
https://www.tutorialspoint.com/python_pandas/python_pandas_dataframe.htm - The Pandas DataFrame: Make Working With Data Delightful
https://realpython.com/pandas-dataframe/ - Python | Pandas DataFrame
https://www.geeksforgeeks.org/python-pandas-dataframe/ - R – Factors
https://www.tutorialspoint.com/r/r_factors.htm - R – Scatterplots
https://www.tutorialspoint.com/r/r_scatterplots.htm - Quick guide to line types (lty) in R
https://www.benjaminbell.co.uk/2018/02/quick-guide-to-line-types-lty-in-r.html - Lattice C (Wikipedia)
https://en.wikipedia.org/wiki/Lattice_C - Lorenz Attractor in R
https://www.sixhat.net/lorenz-attractor-in-r.html - Small multiple
https://en.wikipedia.org/wiki/Small_multiple - Category:Infographics (infografika)
https://en.wikipedia.org/wiki/Category:Infographics - Trellis plots (pro Python)
https://subscription.packtpub.com/book/big_data_and_business_intelligence/9781784390150/4/ch04lvl1sec41/trellis-plots - Trellis (architecture)
https://en.wikipedia.org/wiki/Trellis_(architecture) - Izobara (meteorologie)
https://cs.wikipedia.org/wiki/Izobara_(meteorologie) - How to Create a Lattice Plot in R
https://www.dummies.com/programming/r/how-to-create-a-lattice-plot-in-r/ - Density estimation
https://en.wikipedia.org/wiki/Density_estimation - Sedm smrtelných statistických hříchů
http://dfens-cz.com/sedm-smrtelnych-statistickych-hrichu/ - Spurious correlations
https://tylervigen.com/spurious-correlations - R programming
https://www.slideshare.net/shantanupatil104/r-programming-44637606 - R language tutorial
https://www.slideshare.net/ChiuYW/r-language-tutorial - An Interactive Introduction To R (Programming Language For Statistics)
https://www.slideshare.net/dataspora/an-interactive-introduction-to-r-programming-language-for-statistics - A Pamphlet against R
https://panicz.github.io/pamphlet/ - Notebook interface
https://en.wikipedia.org/wiki/Notebook_interface - Jypyter: open source, interactive data science and scientific computing across over 40 programming languages
https://jupyter.org/ - nbviewer: a simple way to share Jupyter Notebooks
https://nbviewer.jupyter.org/ - Video streaming in the Jupyter Notebook
https://towardsdatascience.com/video-streaming-in-the-jupyter-notebook-635bc5809e85 - How IPython and Jupyter Notebook work
https://jupyter.readthedocs.io/en/latest/architecture/how_jupyter_ipython_work.html - Jupyter kernels
https://github.com/jupyter/jupyter/wiki/Jupyter-kernels - PNG is Not GIF
https://www.root.cz/clanky/png-is-not-gif/ - Anatomie grafického formátu PNG
https://www.root.cz/clanky/anatomie-grafickeho-formatu-png/ - PNG – bity, byty, chunky
https://www.root.cz/clanky/png-bity-byty-chunky/ - Řádkové filtry v PNG
https://www.root.cz/clanky/radkove-filtry-v-png/ - Nepovinné chunky v PNG a kontrola pomocí CRC
https://www.root.cz/clanky/nepovinne-chunky-v-png-a-kontrola-pomoci-crc/
