Hlavní navigace

Programovací jazyk R, Jupyter notebook a Jupytext

2. 2. 2021
Doba čtení: 30 minut

Sdílet

 Autor: R Core Team
Primárním vývojovým prostředím vyvinutým přímo pro jazyk R je RStudio, což ovšem neznamená, že nelze využít i další aplikace. Poměrně často se setkáme s kombinací R + Jupyter notebook. Seznámíme se s užitečným doplňkem nazvaným Jupytext.

Obsah

1. Programovací jazyk R, Jupyter notebook a Jupytext

2. Programovací jazyky podporované Jupyter Notebookem

3. Instalace jazyka R i Jupyter Notebooku

4. Konfigurace a spuštění Jupyter Notebooku

5. Vytvoření nového diáře založeného na jazyku R

6. Instalace knihoven pro R přímo z Jupyter Notebooku

7. Důležité klávesové zkratky

8. Zobrazení dokumentace ke knihovnám, objektům a funkcím

9. Zobrazení matic

10. Datové rámce

11. Zobrazení grafů

12. Grafy vytvořené s využitím knihovny Lattice

13. Grafy vytvořené s využitím knihovny ggplot2

14. Nástroj Jupytext – kooperace mezi Jupyter Notebookem a textovým editorem (IDE)

15. Instalace nástroje Jupytext

16. Nové prvky přidané nástrojem Jupytext

17. Soubor ve formátu Markdown, který je synchronizován s obsahem diáře

18. Repositář s demonstračními příklady i s diáři založenými na jazyku R

19. Další články o nástroji Jupyter

20. Odkazy na Internetu

1. Programovací jazyk R, Jupyter notebook a Jupytext

V základních balíčcích s programovacím jazykem R nalezneme „pouze“ interaktivní smyčku REPL, která umožňuje dialog mezi uživatelem a ekosystémem R. Ovšem v praxi se většinou setkáme s použitím integrovaného vývojového prostředí (jehož nedílnou součástí je ovšem ve většině případů i nějaká forma smyčky REPL). V případě programovacího jazyka R je tímto IDE RStudio, které je volně dostupné a otevřené (což je důležité mj. i v akademické sféře) a pochopitelně je nabízeno i pro Linux. RStudio existuje ve dvou variantách. První varianta se jmenuje RStudio Desktop a jedná se o plnohodnotné desktopové vývojové prostředí. Druhá varianta nese název RStudio Server. Tato varianta, jak již ostatně její název naznačuje, běží na serveru, přičemž na straně klienta je použit WWW prohlížeč, se všemi výhodami a nevýhodami, které toto řešení přináší. V navazujících článcích si použití RStudia, přesněji řečeno jeho (klasické) desktopové varianty, pochopitelně ukážeme.

Obrázek 1: Grafické uživatelské prostředí RStudia.

Dnes se ovšem setkáme s jiným vývojovým prostředím vhodným (mj.) i pro programovací jazyk R. Jedná se o nástroj pojmenovaný Jupyter Notebook, s nímž jsme se již na stránkách Roota několikrát potkali – viz též odkazy na tyto články uvedené v devatenácté kapitole. Jupyter Notebook vznikl z neméně známého a používaného projektu IPython Notebook(s). Toto interaktivní prostředí, které se zobrazuje přímo ve webovém prohlížeči, obsahuje klasickou smyčku REPL (Read–Eval–Print–Loop), což mj. znamená, že se jednotlivé výrazy zapsané uživatelem mohou ihned vyhodnocovat s prakticky okamžitou zpětnou vazbou. Navíc však nástroj Jupyter Notebook dokáže do okna prohlížeče vykreslovat tabulky, grafy či různé obrázky, a to jak s přímým využitím předaných dat (vektory či sekvence čísel), tak i při specifikaci funkce, jejíž průběh se má vykreslit (existují zde ovšem některá omezení, kterými se budu zabývat v navazujících kapitolách). Třešničkou na dortu je podpora pro práci se vzorci psanými v TeXu či LaTeXu, tvorba slajdů, sdílení „živého“ zdrojového kódu atd.

Obrázek 2: Další screenshot z ukázkou grafického uživatelského prostředí RStudia.

Poznámka: existují i další IDE pro R, například R Tools for Visual Studio, Rattle, ESS (založeno na Emacsu), Radiant nebo r4intelliJ, ovšem zdá se, že majorita uživatelů R používá právě RStudio, popř. právě dnes zmiňovanou kombinaci R + Jupyter Notebook.

Obrázek 3: Klasický IPython notebook – jedná se o nástroj, který umožňoval interaktivní ovládání interpretru Pythonu z grafického uživatelského rozhraní, nabízel všechny možnosti konzolového IPythonu a navíc i podporoval práci s grafickými objekty (rastrové obrázky, grafy, diagramy atd.).

2. Programovací jazyky podporované Jupyter Notebookem

Díky architektuře Jupyter Notebooku pro tento projekt vznikla celá řada kernelů, z nichž mnohé podporují další programovací jazyky (i když Python bude pravděpodobně v tomto prostředí stále nejpoužívanějším jazykem). Existují přitom dva primární způsoby, jak lze Jupyter Notebook rozšířit. Může být vytvořen nativní kernel nebo wrapper volaný přímo z Pythonu:

Obrázek 4: Dva primární způsoby, jakými je možné Jupyter rozšířit o další jazyky: nepřímo přes IPython a přímo nativním kernelem.
Zdroj: How IPython and Jupyter Notebook work

Jedná se například o následující jazyky či o jejich varianty:

# Kernel Jazyk
1 Dyalog Jupyter Kernel APL (Dyalog)
2 Coarray-Fortran Fortran 2008/2015
3 IJulia Julia
4 IHaskell ghc >= 7.6
5 IRuby ruby >= 2.3
6 tslab Typescript 3.7.2, JavaScript ESNext
7 IJavascript nodejs >= 0.10
8 ITypeScript Typescript >= 2.0
9 jpCoffeescript coffeescript >= 1.7
10 jp-LiveScript livescript >= 1.5
11 ICSharp C# 4.0+
12 IFSharp F#
13 lgo Go >= 1.8
14 iGalileo Galileo >= 0.1.3
15 gopherlab Go >= 1.6
16 Gophernotes Go >= 1.9
17 IScala Scala
18 IErlang Erlang
19 ITorch Torch 7 (LuaJIT)
20 IElixir Elixir >= 1.5
21 ierl Erlang >= 19, Elixir >= 1.4, LFE 1.2
22 OCaml-Jupyter OCaml >= 4.02
23 IForth Forth
24 peforth Forth
25 IPerl Perl 5
26 Perl6 Perl 6.c
27 IPerl6 Perl 6
28 Jupyter-Perl6 Perl 6.C
29 IPHP PHP >= 5.4
30 Jupyter-PHP PHP >= 7.0.0
31 IOctave Octave
32 IScilab Scilab
33 MATLAB Kernel Matlab
34 Bash bash
35 Z shell zsh >= 5.3
36 PowerShell PowerShell
37 CloJupyter Clojure >= 1.7
38 jupyter-kernel-jsr223 Clojure 1.8
39 Hy Kernel Hy
40 Calysto Hy Hy
41 jp-babel Babel
42 Lua Kernel Lua
43 IPurescript Purescript
44 IPyLua Lua
45 ILua Lua
46 Calysto Scheme Scheme
47 Calysto Processing Processing.js >= 2
48 idl_kernel IDL
49 Mochi Kernel Mochi
50 Lua (used in Splash) Lua
51 Calysto Bash bash
52 IBrainfuck Brainfuck
53 cling C++
54 xeus-cling C++
55 Prolog Prolog
56 SWI-Prolog SWI-Prolog
57 cl-jupyter Common Lisp
58 common-lisp-jupyter Common Lisp
59 IJython Jython 2.7
60 ROOT C++/python
61 Tcl Tcl 8.5
62 J J 805–807 (J901beta)
63 Jython Jython>=2.7.0
64 C C
65 Coconut Coconut
66 Pike Pike >= 7.8
67 jupyter-kotlin Kotlin 1.1-M04 EAP
68 mit-scheme-kernel MIT Scheme 9.2
69 elm-kernel elm
70 SciJava Jupyter Kernel Java + 9 scripting languages
71 BeakerX Groovy, Java, Scala, Clojure, Kotlin, SQL
72 IJava Java 9
73 Guile Guile 2.0.12
74 IRacket Racket >= 6.10
75 EvCxR Jupyter Kernel Rust >= 1.29.2
76 SSH Kernel Bash
77 Emu86 Kernel Intel Assembly Language

Se dvěma „alternativními“ jazyky, jejichž ekosystém byl upraven pro interaktivní prostředí Jupyter Notebooku, jsme se již setkali v následující dvojici článků:

  1. Gophernotes: kombinace interaktivního prostředí Jupyteru s jazykem Go
    https://www.root.cz/clanky/gophernotes-kombinace-interaktivniho-prostredi-jupyteru-s-jazykem-go/
  2. Interpret programovacího jazyka Clojure integrovaný do Jupyter Notebooku
    https://www.root.cz/clanky/interpret-programovaciho-jazyka-clojure-integrovany-do-jupyter-notebooku/

Obrázek 5: Neoficiální logo projektu Gophernotes.

Poznámka: zajímavá, i když asi ne z praktického hlediska, je podpora Brainfucku. Povšimněte si taktéž podpory mnoha překladačů, což je na první pohled neočekávané, protože Jupyter je typickou interaktivní aplikací mířící směrem k interpretrům. Podpora překladačů je tedy relativně složitá a například v případě Go bývá založena na projektu GoMacro, tedy na mechanismu, který překládá jednotlivé příkazy či programové konstrukce a snaží se tak napodobit klasické interpretry. Podobně je tomu i u dalších kompilovaných (překládaných) programovacích jazyků.

Obrázek 6: Logo projektu Clojupyter.

3. Instalace jazyka R i Jupyter Notebooku

Instalace nástrojů programovacího jazyka i celého Jupyter Notebooku tak, aby spolu mohly tyto dvě interně zcela odlišné technologie kooperovat, kupodivu není v praxi příliš složitá. Nejdříve je pochopitelně nutné nainstalovat samotný Jupyter Notebook, což se například na distribucích postavených na RPM provede následovně:

# dnf install python3-notebook

Stejným způsobem se nainstalují i základní nástroje určené pro programovací jazyk R (interpret, nápověda, základní knihovny, testovací data atd.):

# dnf install R

Následně, tedy ve třetím kroku, je nutné nainstalovat kernel používaný pro propojení interpretru jazyka R s Jupyter Notebookem. Tento krok lze provést interaktivně přímo z prostředí R, tedy ze smyčky REPL:

$ R
 
R version 4.0.3 (2020-10-10) -- "Bunny-Wunnies Freak Out"
Copyright (C) 2020 The R Foundation for Statistical Computing
Platform: x86_64-redhat-linux-gnu (64-bit)
 
R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.
 
  Natural language support but running in an English locale
 
R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.
 
Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

Instalace kernelu vyžaduje specifikaci serveru obsahujícího zrcadlené balíčky R:

> install.packages('IRkernel')
 
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]
 ...
 ...
 ...
77: Uruguay [https]
78: (other mirrors)
 
Selection: 1

Instalace byla provedena z prvního nabízeného serveru. Samotný kernel je totiž tak malý, že je prakticky jedno, jak vzdálený server vyberete:

trying URL 'https://cloud.r-project.org/src/contrib/IRkernel_1.1.1.tar.gz'
Content type 'application/x-gzip' length 57656 bytes (56 KB)
==================================================
downloaded 56 KB
 
* installing *source* package ‘IRkernel’ ...
** package ‘IRkernel’ successfully unpacked and MD5 sums checked
** using staged installation
** R
** inst
** byte-compile and prepare package for lazy loading
** help
*** installing help indices
  converting help for package ‘IRkernel’
    finding HTML links ... done
    Comm-class                              html
    CommManager-class                       html
    IRkernel-package                        html
    comm_manager                            html
    installspec                             html
    log                                     html
    main                                    html
** building package indices
** 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 (IRkernel)
Making 'packages.html' ... done
 
The downloaded source packages are in
        ‘/tmp/RtmpVtN3Ct/downloaded_packages’
Updating HTML index of packages in '.Library'
Making 'packages.html' ... done

Nyní je možné prostředí jazyka R opustit, například funkcí q():

q()
 
Save workspace image? [y/n/c]: n
Poznámka: v této chvíli by již mělo být vše připraveno na vytvoření nového diáře v Jupyter Notebooku s podporou jazyka R.

4. Konfigurace a spuštění Jupyter Notebooku

Před prvním spuštěním Jupyter Notebooku je vhodné si nastavit heslo, které se bude zadávat pro přístup (přihlášení) do grafického uživatelského rozhraní:

$ jupyter notebook password
 
Enter password:
Verify password:
[NotebookPasswordApp] Wrote hashed password to /home/ptisnovs/.jupyter/jupyter_notebook_config.json

Dále se již může Jupyter Notebook spustit, a to jednoduše příkazem jupyter notebook:

$ jupyter notebook
 
[I 11:26:39.019 NotebookApp] Writing notebook server cookie secret to /run/user/1000/jupyter/notebook_cookie_secret
[W 11:26:39.615 NotebookApp] WARNING: The notebook server is listening on all IP addresses and not using encryption. This is not recommended.
[I 11:26:39.629 NotebookApp] Serving notebooks from local directory: /home/ptisnovs
[I 11:26:39.629 NotebookApp] 0 active kernels
[I 11:26:39.629 NotebookApp] The Jupyter Notebook is running at:
[I 11:26:39.629 NotebookApp] http://[all ip addresses on your system]:8888/
[I 11:26:39.629 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[I 11:26:39.983 NotebookApp] 302 GET /tree (::1) 1.91ms
Poznámka: v případě, že heslo není nastaveno, zobrazí se v logu i adresa s tokenem, kterou lze přímo přenést do webového prohlížeče.

Pokud se zobrazí i řádky zvýrazněné kurzivou, znamená to, že server Jupyter Notebooku bude přístupný i ostatním počítačům na síti. Toto chování (někdy ho vyžadujeme, pro první pokusy však ne) lze v případě potřeby zakázat editací souboru ~/.jupyter/jupyter_notebo­ok_config.json, konkrétně úpravou řádku s klíčem „ip“:

{
  "NotebookApp": {
    "password": "sha1:neco-tay-je",
    "ip": "localhost"
  }
}

Nové spuštění již nebude výše zvýrazněné varování psát:

$ jupyter notebook
 
[I 11:26:39.019 NotebookApp] Writing notebook server cookie secret to /run/user/1000/jupyter/notebook_cookie_secret
[I 11:26:39.629 NotebookApp] Serving notebooks from local directory: /home/ptisnovs
[I 11:26:39.629 NotebookApp] 0 active kernels
[I 11:26:39.629 NotebookApp] The Jupyter Notebook is running at:
[I 11:26:39.629 NotebookApp] http://localhost:8888/
[I 11:26:39.629 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[I 11:26:39.983 NotebookApp] 302 GET /tree (::1) 1.91ms

Obrázek 7: Přihlašovací obrazovka do grafického uživatelského rozhraní Jupyter Notebooku.

5. Vytvoření nového diáře založeného na jazyku R

Po přihlášení do Jupyter Notebooku by se měl zobrazit obsah výchozího adresáře s jednotlivými diáři (ty zatím pochopitelně neexistují):

Obrázek 8: Výchozí zobrazení adresáře s diáři po přihlášení do Jupyter Notebooku.

Pro vytvoření nového diáře, do něhož je možné zapisovat skripty (resp. přesněji řečeno příkazy) programovacího jazyka R je nutné zvolit příslušný kernel v kontextovém menu skrytém pod tlačítkem New. Pokud kroky popsané v předchozích kapitolách proběhly korektně, měl by se v tomto menu nacházet kernel jazyka Python i kernel jazyka R:

Obrázek 9: Kontextové menu s výběrem dostupných kernelů. Měl by se zde nabízet i kernel programovacího jazyka R.

Jakmile je otevřen nový tab s diářem, je možné začít do buněk zapisovat příkazy jazyka R a stiskem klávesové zkratky Shift+Enter je spustit:

Obrázek 10: Po zápisu příkazu či výrazu jazyka R a stisku klávesové zkratky Shift+Enter se příkaz spustí a vypíše se jeho výsledek (někdy formátovaný – viz další text).

6. Instalace knihoven pro R přímo z Jupyter Notebooku

V mnoha skriptech psaných v programovacím jazyku R se používají další nestandardní (externí) knihovny, které je zapotřebí před jejich použitím nainstalovat. Typickým příkladem takové knihovny je knihovna ggplot2. Tu (ale i další knihovny) můžeme nainstalovat přímo z prostředí Jupyter Notebooku tak, jak je to ukázáno na sérii screenshotů:

Obrázek 11: Začátek instalace knihovny ggplot2.

Pozor je ovšem nutné dát na to, že prostředí Jupyter Notebooku a kernelu běží asynchronně, takže samotná instalace (která trvá několik minut – překládají se nativní části atd.) je ve skutečnosti prováděna na pozadí. To poznáme z ikonky zobrazené u názvu kernelu:

Obrázek 12: Černá tečka vedle názvu kernelu značí, že se provádí operace na pozadí.

Poznámka: můžete se také podívat do logu Jupyter Notebooku, v němž se jednotlivé kroky instalace pochopitelně taktéž vypisují.

Dokončení instalace poznáme změnou ikony a výpisem posledních řádků produkovaných instalačním skriptem. Opět viz následující screenshoty:

Obrázek 13: Dokončení práce instalačního skriptu.

Obrázek 14: Prázdná tečka vedle názvu kernelu značí, že kernel je připraven provádět další operace.

7. Důležité klávesové zkratky

Pro rychlou práci s Jupyter Notebookem je vhodné se naučit základní klávesové zkratky podporované tímto webovým prostředím. Tyto zkratky (a některé „magické příkazy“) naleznete například na adrese https://d1jnx9ba8s6j9r.clou­dfront.net/blog/wp-content/uploads/2018/10/Ju­pyter_Notebook_CheatSheet_E­dureka.png, ovšem jednodušší je zobrazit si nápovědu dostupnou přímo v rámci GUI Jupyter Notebooku:

Obrázek 15: Menu s příkazy nápovědy.

Z nápovědy s tabulkou klávesových zkratek je patrné, že se rozpoznávají dva režimy, v nichž se diář může nacházet – příkazový režim a editační režim. Příkazový režim se zapíná klávesou Esc. Pokud například potřebujete vložit novou buňku nad (above) aktivní buňku, použije se klávesová zkratka Esc, A (což značí stisk klávesy Esc a poté stisk klávesy A, nikoli stisk obou kláves současně):

Obrázek 16: Základní klávesové zkratky Jupyter Notebooku.

8. Zobrazení dokumentace ke knihovnám, objektům a funkcím

Vzhledem k tomu, že nápovědu k jazyku R i ke všem knihovnám (a jejich funkcím) je možné zobrazit přes libovolný HTML prohlížeč a samotný Jupyter Notebook používá pro své uživatelské rozhraní taktéž HTML prohlížeč, můžeme očekávat, že bude plně podporováno zobrazení plnohodnotné nápovědy přímo v prostředí Notebooku. Ostatně si to můžeme velmi snadno vyzkoušet, například pouhým zápisem příkazu help():

Obrázek 17: Po zápisu příkazu help() se v dolní části okna prohlížeče zobrazí příslušná nápověda.

Poznámka: nápovědu lze kdykoli skrýt tlačítkem x.

Zatímco nápověda je zobrazena mimo vlastní diář s buňkami, příklady použití jsou zobrazeny poněkud odlišným způsobem ukázaným na dalším screenshotu:

Obrázek 18: Zobrazení příkladů použití funkce sort().

9. Zobrazení matic

V případě, že je výsledkem nějakého výpočtu (přesněji řečeno výrazu) matice, bude její obsah zobrazen v takové podobě, jakou můžete vidět na následujícím screenshotu:

Obrázek 19: Zobrazení matic o rozměrech 1×12, 3×4 a 4×3 buňky.

Z předchozích článků již víme, že sloupce a řádky matice je možné pojmenovat. I tato vlastnost je Jupyter Notebookem plně podporována:

Obrázek 20: Zobrazení matic s pojmenovanými řádky a sloupci.

Poznámka: nepoužívejte však funkci print(), která výše ukázané automatické formátování nepodporuje (což může být výhoda i nevýhoda).

10. Datové rámce

Prostředí Jupyter Notebooku podporuje i zobrazení datových rámců, a to nejenom v čistě textové podobě (výsledek příkazu print()), tak i podobě naformátovaného HTML:

Obrázek 21: Zobrazení datového rámce s implicitně pojmenovanými sloupci.

Obrázek 22: Zobrazení datového rámce s explicitně (uživatelem) pojmenovanými sloupci.

Obrázek 23: Převod matice s pojmenovanými řádky a sloupci na datový rámec.

11. Zobrazení grafů

Jupyter Notebook dokáže přímo v prostředí diáře zobrazit i grafy, a to jak grafy vykreslované knihovnou ggplot2, tak i knihovnou Lattice, popř. i dalšími podobně koncipovanými knihovnami určenými pro použití v programovacím jazyku R. Některé ukázky si uvedeme v navazujících kapitolách, ovšem pouze ve stručnosti, protože touto problematikou jsme se již v seriálu o jazyku R zabývali:

  1. Základy tvorby grafů v programovacím jazyku R
    https://www.root.cz/clanky/zaklady-tvorby-grafu-v-programovacim-jazyku-r/
  2. Základy tvorby grafů v programovacím jazyku R: typy grafů v knihovně lattice
    https://www.root.cz/clanky/zaklady-tvorby-grafu-v-programovacim-jazyku-r-typy-grafu-v-knihovne-lattice/
  3. Základy tvorby grafů v programovacím jazyku R: knihovna lattice (dokončení)
    https://www.root.cz/clanky/zaklady-tvorby-grafu-v-programovacim-jazyku-r-knihovna-lattice-dokonceni/
  4. Tvorba grafů v jazyce R s využitím knihovny ggplot2
    https://www.root.cz/clanky/tvorba-grafu-v-jazyce-r-s-vyuzitim-knihovny-ggplot2/
  5. Tvorba grafů v jazyce R s využitím knihovny ggplot2 (II)
    https://www.root.cz/clanky/tvorba-grafu-v-jazyce-r-s-vyuzitim-knihovny-ggplot2-ii/

12. Grafy vytvořené s využitím knihovny Lattice

Příklady použití knihovny Lattice jsem si vypůjčil z předchozích částí tohoto seriálu, takže jen stručně:

Obrázek 24: Nápověda dodávaná ke knihovně Lattice.

Obrázek 25: Graf s regresními přímkami.

Obrázek 26: Více grafů zobrazených do dlaždic.

Obrázek 27: Graf s barevně zvýrazněnými konturami.

Obrázek 28: Kontury (vrstevnice) na grafu.

13. Grafy vytvořené s využitím knihovny ggplot2

Použít lze pochopitelně i knihovnu ggplot2, která je dnes pravděpodobně populárnější než výše zmíněná knihovna Lattice:

Obrázek 29: Načtení knihovny ggplot2 a zobrazení její nápovědy.

Obrázek 30: Graf typu x-y.

Obrázek 31: Vykreslení vypočteného modelu.

Obrázek 32: Vykreslení průběhu funkce sinus.

14. Nástroj Jupytext – kooperace mezi Jupyter Notebookem a textovým editorem (IDE)

Diáře jsou interně ukládány ve formátu založeném na JSONu, což znamená mj. i snadnou serializaci a deserializaci v různých externích nástrojích. Současně je ovšem tento formát spíše nevhodný pro ruční editaci, špatně jsou v něm viditelné provedené změny (git diff …) atd. Z tohoto i některých dalších důvodů by bylo vhodné, aby byly diáře snadno editovatelné v externím editoru či IDE. A právě tuto možnost do Jupyter Notebooku přidává nástroj nazvaný Jupytext, který umožňuje, aby byl diář paralelně ukládán jak v nativním formátu, tak i ve vybraném editovatelném formátu, typicky v Markdownu. Jedná se o nástroj velmi snadno použitelný a především umožňující oboustrannou komunikaci mezi Jupyter Notebookem a textovým editorem – změny provedené v textovém editoru se projeví při opětovném načtení diáře a naopak.

15. Instalace nástroje Jupytext

Nástroj Jupytext nainstalujeme zcela stejným způsobem, jako další balíčky či knihovny určené pro ekosystém programovacího jazyka Python:

$ pip install --user jupytext --upgrade

Průběh instalace, která by na běžném počítači měla trvat pouze několik sekund:

Collecting jupytext
  Downloading https://files.pythonhosted.org/packages/b3/81/cf79ed5948a499507e2653a499d5a87f429e1d9da6a6f14c9d7f30b5828d/jupytext-1.9.1-py3-none-any.whl (287kB)
     |████████████████████████████████| 296kB 7.5MB/s
Collecting pyyaml
  Downloading https://files.pythonhosted.org/packages/70/96/c7245e551b1cb496bfb95840ace55ca60f20d3d8e33d70faf8c78a976899/PyYAML-5.4.1-cp38-cp38-manylinux1_x86_64.whl (662kB)
     |████████████████████████████████| 665kB 11.4MB/s
Collecting markdown-it-py~=0.6.0
  Downloading https://files.pythonhosted.org/packages/36/54/4e983048843a5adb6baf58412ab5c4272a412b5fb837fad7e2093576564e/markdown_it_py-0.6.1-py3-none-any.whl (81kB)
     |████████████████████████████████| 81kB 14.8MB/s
Collecting toml
  Downloading https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl
Requirement already satisfied, skipping upgrade: nbformat>=4.0.0 in /usr/lib/python3.8/site-packages (from jupytext) (5.0.4)
Collecting mdit-py-plugins~=0.2.1
  Downloading https://files.pythonhosted.org/packages/9d/df/16e87ebd0bb9d946d3b2d39c1171398f7f71eef5d9ca85adb94131b8c7b5/mdit_py_plugins-0.2.4-py3-none-any.whl
Requirement already satisfied, skipping upgrade: attrs<21,>=19 in /usr/lib/python3.8/site-packages (from markdown-it-py~=0.6.0->jupytext) (19.3.0)
Installing collected packages: pyyaml, mdit-py-plugins, markdown-it-py, toml, jupytext
Successfully installed jupytext-1.9.1 markdown-it-py-0.6.1 mdit-py-plugins-0.2.4 pyyaml-5.4.1 toml-0.10.2

Dále je zapotřebí vytvořit konfigurační soubor (pokud už neexistuje) a provést v něm jednu úpravu:

$ jupyter notebook --generate-config
$ vim .jupyter/jupyter_notebook_config.py

Do konfiguračního souboru .jupyter/jupyter_notebook_config.py je nutné přidat tento řádek:

c.NotebookApp.contents_manager_class = "jupytext.TextFileContentsManager"

16. Nové prvky přidané nástrojem Jupytext

Po instalaci nástroje Jupytext se v menu File objeví nové položky. První se týká nových formátů diářů nabízejících kombinaci zdrojového kódu a značkovacího jazyka:

Obrázek 33: Možnosti otevření diáře založeného na textovém formátu (nové menu).

Užitečnější je ovšem další volba, která nám umožňuje automaticky spárovat dva soubory – jeden s klasickým diářem (koncovka .ipynb) a druhý ve formátu Markdown, R Markdown atd.:

Obrázek 34: Možnosti nastavení Jupytextu – které soubory se mají synchronizovat (resp. spárovat).

V případě, že je párování povoleno, bude se vytvářet dvojice souborů, přičemž v Jupyter Notebooku lze otevřít jakýkoli z nich:

Obrázek 35: Povšimněte si, že nyní existuje jeden diář ve dvou podobách – jako soubor .ipynb a taktéž jako soubor .md. Otevřít je možné kterýkoli z nich.

17. Soubor ve formátu Markdown, který je synchronizován s obsahem diáře

Diář, jehož obsah je vystaven na adrese https://tisnik.github.io/jupyter-notebook-examples/Jupyter_notebook_a_pro­gramovac%C3%AD_jazyk_R.html, vypadá po převedení do formátu Markdown následovně (jedná se o plně editovatelný soubor, který po svém načtení do diáře reflektuje všechny provedené změny):

---
jupyter:
  jupytext:
    formats: ipynb,md
    text_representation:
      extension: .md
      format_name: markdown
      format_version: '1.2'
      jupytext_version: 1.9.1
  kernelspec:
    display_name: R
    language: R
    name: ir
---
 
# Jupyter notebook a programovací jazyk R
 
 
## Otestování základní funkcionality kernelu jazyka R
 
```R
print("Hello world!")
```
 
```R
"Hello world!"
```
 
## Zobrazení nápovědy
 
```R
help(sort)
```
 
### Zobrazení příkladu použití
 
```R
example(sort)
```
 
## Práce s vektory
 
 
Se základními konstruktory vektorů jsme se již v tomto seriálu seznámili, takže si nyní pouze připomeňme, že existuje hned několik způsobů konstrukce nového vektoru. V případě, že má vektor obsahovat jen jedinou hodnotu, je vytvoření takového vektoru jednoduché a přímočaré, protože vlastní zápis hodnoty (typicky čísla) již představuje skalární hodnotu, která se však chová jako vektor (má délku rovnou jedné, může se používat v operacích, kde se očekávají vektory atd.):
 
```R
42
```
 
O tom, jakého typu je takový skalár nebo vektor, se můžeme přesvědčit zavoláním funkce class:
 
```R
class(42)
```
 
Vektor s obecnými prvky se vytvoří konstruktorem nazvaným `c`, což je funkce, které se předají hodnoty jednotlivých prvků:
 
```R
a <- c(1,2,3,4)
```
 
```R
class(a)
```
 
Prvky samozřejmě nemusí být pouze celými čísly, ale například i hodnotami s plovoucí řádovou čárkou:
 
```R
b <- c(1.2, 2.3, 3.4)
class(b)
```
 
Nakonec si vyzkoušíme vytvoření vektoru obsahujícího pravdivostní hodnoty `TRUE` a `FALSE`:
 
```R
l <- c(TRUE, FALSE, TRUE)
class(l)
```
 
Sekvence hodnot:
 
```R
data <- 1:12
```
 
```R
data
```
 
Porovnání dvou vektorů (druhý vektor s jediným prvkem je rozšířen na velikost prvního vektoru):
 
```R
data < 6
```
Poznámka: ve skutečnosti je vypsána jen část celého diáře, což ovšem pro ukázku možností dostačuje.

18. Repositář s demonstračními příklady i s diáři založenými na jazyku R

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. Zdrojové kódy příkladů byly získány exportem z Jupyter Notebooku a obsahují pouze zdrojový text z buněk jazyka R (nikoli z buněk s komentáři v Markdownu):

# Demonstrační příklad Stručný popis demonstračního příkladu Cesta
1 Install_packages_R.r instalace balíčků přímo z Jupyter Notebooku https://github.com/tisnik/r-examples/blob/master/15-jupyter-notebook/Install_packages_R.r
2 Jupyter_notebook_a_progra­movací_jazyk_R.r základní konstrukce jazyka R, tvorba grafů https://github.com/tisnik/r-examples/blob/master/15-jupyter-notebook/Jupyter_notebook_a_pro­gramovací_jazyk_R.r
3 R a knihovna Lattice.r programovací jazyk R a knihovna Lattice https://github.com/tisnik/r-examples/blob/master/15-jupyter-notebook/R a knihovna Lattice.r

Důležitější jsou však samotné diáře (notebooky) vytvořené pro účely dnešního článku. Ty jsou dostupné na adresách:

Root obecny

# Diář Stručný popis diáře Cesta
1 Install_packages_R.ipynb instalace balíčků přímo z Jupyter Notebooku https://github.com/tisnik/jupyter-notebook-examples/blob/master/R/In­stall_packages_R.ipynb
2 Jupyter_notebook_a_progra­movací_jazyk_R.ipynb základní konstrukce jazyka R, tvorba grafů https://github.com/tisnik/jupyter-notebook-examples/blob/master/R/Ju­pyter_notebook_a_programo­vac%C3%AD_jazyk_R.ipynb
3 R a knihovna Lattice.ipynb programovací jazyk R a knihovna Lattice https://github.com/tisnik/jupyter-notebook-examples/blob/master/R/R%20a%20kni­hovna%20Lattice.ipynb

V případě, že se diáře v prostředí GitHubu správně nezobrazí (což je častý problém), můžete si prohlédnou jejich neinteraktivní (vyrendrované) verze, které jsou dostupné na adresách:

# Vykreslený obsah diáře Stručný popis diáře Cesta
1 Install_packages_R.html instalace balíčků přímo z Jupyter Notebooku https://tisnik.github.io/jupyter-notebook-examples/Install_packages_R.html
2 Jupyter_notebook_a_progra­movac%C3%AD_jazyk_R.html základní konstrukce jazyka R, tvorba grafů https://tisnik.github.io/jupyter-notebook-examples/Jupyter_notebook_a_pro­gramovac%C3%AD_jazyk_R.html
3 R%20a%20knihovna%20Lattice.html programovací jazyk R a knihovna Lattice https://tisnik.github.io/jupyter-notebook-examples/R%20a%20knihovna%20Lat­tice.html

19. Další články o nástroji Jupyter

Jak jsme si již řekli v předchozím textu, s nástrojem Jupyter Notebook jsme se již několikrát seznámili, a to především v následujících článcích:

  1. Gophernotes: kombinace interaktivního prostředí Jupyteru s jazykem Go
    https://www.root.cz/clanky/gophernotes-kombinace-interaktivniho-prostredi-jupyteru-s-jazykem-go/
  2. Jupyter Notebook – nástroj pro programátory, výzkumníky i lektory
    https://www.root.cz/clanky/jupyter-notebook-nastroj-pro-programatory-vyzkumniky-i-lektory/
  3. Tvorba grafů v Jupyter Notebooku s využitím knihovny Matplotlib
    https://www.root.cz/clanky/tvorba-grafu-v-jupyter-notebooku-s-vyuzitim-knihovny-matplotlib/
  4. Tvorba grafů v Jupyter Notebooku s využitím knihovny Matplotlib (dokončení)
    https://www.root.cz/clanky/tvorba-grafu-v-jupyter-notebooku-s-vyuzitim-knihovny-matplotlib-dokonceni/
  5. Jupyter Notebook – operace s rastrovými obrázky a UML diagramy, literate programming
    https://www.root.cz/clanky/jupyter-notebook-operace-s-rastrovymi-obrazky-a-uml-diagramy-literate-programming/
  6. Interpret programovacího jazyka Clojure integrovaný do Jupyter Notebooku
    https://www.root.cz/clanky/interpret-programovaciho-jazyka-clojure-integrovany-do-jupyter-notebooku/

20. Odkazy na Internetu

  1. Using the R programming language in Jupyter Notebook
    https://docs.anaconda.com/a­naconda/navigator/tutorial­s/r-lang/
  2. Using R on Jupyter Notebook
    https://dzone.com/articles/using-r-on-jupyternbspnotebook
  3. JupyterLab – Installing R Kernel
    https://www.tutorialspoin­t.com/jupyter/jupyterlab_in­stalling_r_kernel.htm
  4. How to Install R in Jupyter with IRKernel in 3 Steps?
    https://medium.com/@kyleake/how-to-install-r-in-jupyter-with-irkernel-in-3-steps-917519326e41
  5. Jupyter and data science in Fedora
    https://fedoramagazine.org/jupyter-and-data-science-in-fedora/
  6. Jupyter Notebook Keyboard Shortcuts
    https://media.cheatography­.com/storage/thumb/weidade­yue_jupyter-notebook.750.jpg?last=1462914889
  7. Jupyter Notebook Cheat Sheet
    https://d1jnx9ba8s6j9r.clou­dfront.net/blog/wp-content/uploads/2018/10/Ju­pyter_Notebook_CheatSheet_E­dureka.png
  8. Jupyter And R Markdown: Notebooks With R
    https://www.r-bloggers.com/2016/11/jupyter-and-r-markdown-notebooks-with-r/
  9. Jupyter And R Markdown: Notebooks With R
    https://www.datacamp.com/com­munity/blog/jupyter-notebook-r
  10. Jupyter notebooks as Markdown documents
    https://pythonawesome.com/jupyter-notebooks-as-markdown-documents/
  11. R Tutorial
    https://www.tutorialspoin­t.com/r/index.htm
  12. A Tutorial on Using Functions in R!
    https://www.datacamp.com/com­munity/tutorials/functions-in-r-a-tutorial
  13. R Functions
    https://www.datamentor.io/r-programming/function/
  14. A Tutorial on Loops in R – Usage and Alternatives
    https://www.datacamp.com/com­munity/tutorials/tutorial-on-loops-in-r
  15. Anonymous Functions in R – Part 1
    https://coolbutuseless.git­hub.io/2019/03/13/anonymous-functions-in-r-part-1/
  16. Anonymous Functions in R – Part 2
    https://coolbutuseless.git­hub.io/2019/03/13/anonymous-functions-in-r-part-2/
  17. Scoping and Closures in R
    https://www.pluralsight.com/gu­ides/scoping-and-closures-in-r
  18. Tools for Computing on the Language
    https://www.rdocumentation­.org/packages/pryr/version­s/0.1.4
  19. Difference between double-precision data type and numeric data type
    https://stackoverflow.com/qu­estions/50255318/differen­ce-between-double-precision-data-type-and-numeric-data-type
  20. R Data Types
    https://www.w3schools.in/r/data-types/
  21. What is the difference between mode and class in R?
    https://stackoverflow.com/qu­estions/35445112/what-is-the-difference-between-mode-and-class-in-r
  22. switch: Select One of a List of Alternatives
    https://rdrr.io/r/base/switch.html
  23. R switch() Function
    https://www.datamentor.io/r-programming/switch-function/
  24. Using ggplot in Python: Visualizing Data With plotnine
    https://realpython.com/ggplot-python/
  25. A Grammar of Graphics for Python
    https://plotnine.readthedoc­s.io/en/stable/
  26. Plotnine gallery
    https://plotnine.readthedoc­s.io/en/latest/gallery.html
  27. plotnine 0.7.1 na PyPi
    https://pypi.org/project/plotnine/
  28. plotnine-examples 0.0.4 na PyPi
    https://pypi.org/project/plotnine-examples/
  29. plotnine examples repository
    https://github.com/has2k1/plotnine-examples
  30. Data visualization in R: cheat sheet
    https://github.com/rstudi­o/cheatsheets/blob/master/da­ta-visualization-2.1.pdf
  31. The R Project for Statistical Computing
    https://www.r-project.org/
  32. An Introduction to R
    https://cran.r-project.org/doc/manuals/r-release/R-intro.pdf
  33. R (programming language)
    https://en.wikipedia.org/wi­ki/R_(programming_language)
  34. The R Programming Language
    https://www.tiobe.com/tiobe-index/r/
  35. R Graphics Second Edition
    https://www.stat.auckland­.ac.nz/~paul/RG2e/
  36. ggplot2 – Introduction
    https://www.tutorialspoin­t.com/ggplot2/ggplot2_intro­duction.htm
  37. ggplot2: Elegant Graphics for Data Analysis
    https://ggplot2-book.org/index.html
  38. Create Elegant Data Visualisations Using the Grammar of Graphics
    https://www.rdocumentation­.org/packages/ggplot2/ver­sions/3.3.2
  39. Grid
    https://www.stat.auckland­.ac.nz/~paul/grid/grid.html
  40. Interactive Course: Data Visualization with lattice in R
    https://www.datacamp.com/courses/data-visualization-in-r-with-lattice
  41. Lattice: trellis graphics for R
    https://lattice.r-forge.r-project.org/
  42. Lattice: Multivariate Data Visualization with R
    http://lmdvr.r-forge.r-project.org/figures/figures.html
  43. Getting Started with Lattice Graphics
    https://lattice.r-forge.r-project.org/Vignettes/src/lattice-intro/lattice-intro.pdf
  44. Using lattice’s xyplot()
    https://homerhanumat.github­.io/tigerstats/xyplot.html
  45. ggplot2 Tutorial
    https://www.tutorialspoin­t.com/ggplot2/index.htm
  46. Lattice Package in R with Functions and Graphs
    https://techvidvan.com/tu­torials/lattice-package-in-r/
  47. The R Graph Gallery
    https://www.r-graph-gallery.com/index.html
  48. Lattice Graphs
    https://www.statmethods.net/ad­vgraphs/trellis.html
  49. ggplot2 (Graph gallery)
    https://www.r-graph-gallery.com/ggplot2-package.html
  50. R Markdown
    https://rmarkdown.rstudio.com/
  51. R Markdown: The Definitive Guide
    https://bookdown.org/yihui/rmarkdown/
  52. R Markdown Cheat Sheet
    https://rstudio.com/wp-content/uploads/2016/03/rmarkdown-cheatsheet-2.0.pdf
  53. Introduction to R Markdown
    https://rmarkdown.rstudio­.com/articles_intro.html
  54. R Cheat Sheets
    https://blog.sergiouri.be/2016/07/r-cheat-sheets.html
  55. R Cheat Sheet
    https://s3.amazonaws.com/quandl-static-content/Documents/Quandl±+R+Che­at+Sheet.pdf
  56. Base R Cheat Sheet
    https://rstudio.com/wp-content/uploads/2016/06/r-cheat-sheet.pdf
  57. PYPL PopularitY of Programming Language
    https://pypl.github.io/PYPL.html
  58. Tiobe index
    https://www.tiobe.com/tiobe-index/
  59. Stack Overflow: Most Loved, Dreaded & Wanted Programming Languages In 2020
    https://fossbytes.com/stack-overflow-most-loved-dreaded-wanted-programming-languages-in-2020/
  60. How to Install and Use R on Ubuntu
    https://itsfoss.com/install-r-ubuntu/
  61. R programming for beginners – Why you should use R
    https://www.youtube.com/wat­ch?v=9kYUGMg_14s
  62. GOTO 2012 • The R Language The Good The Bad & The Ugly
    https://www.youtube.com/wat­ch?v=6S9r_YbqHy8
  63. Intro to Data Visualization with R & ggplot2
    https://www.youtube.com/wat­ch?v=49fADBfcDD4
  64. Plotting with ggplot2: Part 1
    https://www.youtube.com/wat­ch?v=HeqHMM4ziXA
  65. Plotting with ggplot2: Part 2
    https://www.youtube.com/wat­ch?v=n8kYa9vu1l8
  66. R vs Python – What should I learn in 2020? | R and Python Comparison
    https://www.youtube.com/wat­ch?v=eRP_J2yLjSU
  67. R Programming 101
    https://www.youtube.com/c/rpro­gramming101
  68. Seriál Tvorba grafů pomocí programu „R“
    https://www.root.cz/serialy/tvorba-grafu-pomoci-programu-r/
  69. Tvorba grafů pomocí programu „R“: úvod
    https://www.root.cz/clanky/tvorba-grafu-pomoci-programu-r-1/
  70. Tvorba grafů pomocí programu „R“: pokročilé funkce
    https://www.root.cz/clanky/tvorba-grafu-pomoci-programu-r-pokrocile-funkce/
  71. Tvorba grafů pomocí programu „R“: vkládání textu, čeština
    https://www.root.cz/clanky/grafy-pomoci-programu-r-vkladani-textu-cestina/
  72. Cesta erka: Krok nultý – instalace & nastavení – prostředí, projekty, package
    https://www.jla-data.net/r4su/r4su-environment-setup/
  73. Cesta erka: Krok první – operace a struktury – proměnné, rovnítka a dolary
    https://www.jla-data.net/r4su/r4su-data-structures/
  74. Cesta erka: Krok druhý – načtení externích dat – csvčka, excely a databáze
    https://www.jla-data.net/r4su/r4su-read-data/
  75. Cesta erka: Krok třetí – manipulace s daty – dplyr, slovesa a pajpy
    https://www.jla-data.net/r4su/r4su-manipulate-data/
  76. Cesta erka: Krok čtvrtý – podání výsledků – ggplot, geomy a estetiky
    https://www.jla-data.net/r4su/r4su-report-results/
  77. Cesta erka: Krok pátý – case study – případ piva v Praze
    https://www.jla-data.net/r4su/r4su-case-study-beer/
  78. 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/
  79. Is R Programming SURGING in Popularity in 2020?
    https://www.youtube.com/watch?v=Duwn-vImyXE
  80. Graphics, ggplot2
    http://r4stats.com/examples/graphics-ggplot2/
  81. A Practice Data Set
    https://r4stats.wordpress­.com/examples/mydata/
  82. Shiny – galerie projektů
    https://shiny.rstudio.com/gallery/
  83. Seriál Programovací jazyk Julia
    https://www.root.cz/seria­ly/programovaci-jazyk-julia/
  84. Julia (front page)
    http://julialang.org/
  85. Julia – repositář na GitHubu
    https://github.com/JuliaLang/julia
  86. Julia (programming language)
    https://en.wikipedia.org/wi­ki/Julia_%28programming_lan­guage%29
  87. IJulia
    https://github.com/JuliaLan­g/IJulia.jl
  88. Introducing Julia
    https://en.wikibooks.org/wi­ki/Introducing_Julia
  89. Julia: the REPL
    https://en.wikibooks.org/wi­ki/Introducing_Julia/The_REPL
  90. Introducing Julia/Metaprogramming
    https://en.wikibooks.org/wi­ki/Introducing_Julia/Meta­programming
  91. Month of Julia
    https://github.com/DataWo­okie/MonthOfJulia
  92. Learn X in Y minutes (where X=Julia)
    https://learnxinyminutes.com/doc­s/julia/
  93. New Julia language seeks to be the C for scientists
    http://www.infoworld.com/ar­ticle/2616709/application-development/new-julia-language-seeks-to-be-the-c-for-scientists.html
  94. Julia: A Fast Dynamic Language for Technical Computing
    http://karpinski.org/publi­cations/2012/julia-a-fast-dynamic-language
  95. The LLVM Compiler Infrastructure
    http://llvm.org/
  96. Julia: benchmarks
    http://julialang.org/benchmarks/
  97. R Vector
    https://www.datamentor.io/r-programming/vector/
  98. .R File Extension
    https://fileinfo.com/extension/r
  99. Lineární regrese
    https://cs.wikipedia.org/wi­ki/Line%C3%A1rn%C3%AD_regre­se
  100. lm (funkce)
    https://www.rdocumentation­.org/packages/stats/versi­ons/3.6.2/topics/lm
  101. quit (funkce)
    https://www.rdocumentation­.org/packages/base/version­s/3.6.2/topics/quit
  102. c (funkce)
    https://www.rdocumentation­.org/packages/base/version­s/3.6.2/topics/c
  103. help (funkce)
    https://www.rdocumentation­.org/packages/utils/versi­ons/3.6.2/topics/help
  104. Shiny: Introduction to interactive documents
    https://shiny.rstudio.com/ar­ticles/interactive-docs.html
  105. R Release History 1997–2013
    http://timelyportfolio.git­hub.io/rCharts_timeline_r/
  106. R: atomic vectors
    https://renenyffenegger.ch/no­tes/development/languages/R/da­ta-structures/vector/
  107. 11 Best R Programming IDE and editors
    https://www.dunebook.com/best-r-programming-ide/
  108. CRAN – The Comprehensive R Archive Network
    https://cran.r-project.org/
  109. R – Arrays
    https://www.tutorialspoin­t.com/r/r_arrays.htm
  110. Array vs Matrix in R Programming
    https://www.geeksforgeeks.org/array-vs-matrix-in-r-programming/?ref=rp
  111. Online R Language IDE
    https://www.jdoodle.com/execute-r-online/
  112. Execute R Online (R v3.4.1)
    https://www.tutorialspoin­t.com/execute_r_online.php
  113. Snippets: Run any R code you like. There are over twelve thousand R packages preloaded
    https://rdrr.io/snippets/
  114. R Package Documentation
    https://rdrr.io/
  115. Data Reshaping in R – Popular Functions to Organise Data
    https://techvidvan.com/tutorials/data-reshaping-in-r/
  116. What is an R Data Frame?
    https://magoosh.com/data-science/what-is-an-r-data-frame/
  117. What's a data frame?
    https://campus.datacamp.com/cou­rses/free-introduction-to-r/chapter-5-data-frames?ex=1
  118. data.frame
    https://www.rdocumentation­.org/packages/base/version­s/3.6.2/topics/data.frame
  119. as.data.frame
    https://www.rdocumentation­.org/packages/base/version­s/3.6.2/topics/as.data.fra­me
  120. table
    https://www.rdocumentation­.org/packages/base/version­s/3.6.2/topics/table
  121. Python Pandas – DataFrame
    https://www.tutorialspoin­t.com/python_pandas/python_pan­das_dataframe.htm
  122. The Pandas DataFrame: Make Working With Data Delightful
    https://realpython.com/pandas-dataframe/
  123. Python | Pandas DataFrame
    https://www.geeksforgeeks.org/python-pandas-dataframe/
  124. R – Factors
    https://www.tutorialspoin­t.com/r/r_factors.htm
  125. R – Scatterplots
    https://www.tutorialspoin­t.com/r/r_scatterplots.htm
  126. Quick guide to line types (lty) in R
    https://www.benjaminbell.co­.uk/2018/02/quick-guide-to-line-types-lty-in-r.html
  127. Lattice C (Wikipedia)
    https://en.wikipedia.org/wi­ki/Lattice_C
  128. Lorenz Attractor in R
    https://www.sixhat.net/lorenz-attractor-in-r.html
  129. Small multiple
    https://en.wikipedia.org/wi­ki/Small_multiple
  130. Category:Infographics (infografika)
    https://en.wikipedia.org/wi­ki/Category:Infographics
  131. Trellis plots (pro Python)
    https://subscription.packtpub­.com/book/big_data_and_bu­siness_intelligence/9781784390150/4/ch04l­vl1sec41/trellis-plots
  132. Trellis (architecture)
    https://en.wikipedia.org/wi­ki/Trellis_(architecture)
  133. Izobara (meteorologie)
    https://cs.wikipedia.org/wi­ki/Izobara_(meteorologie)
  134. How to Create a Lattice Plot in R
    https://www.dummies.com/pro­gramming/r/how-to-create-a-lattice-plot-in-r/
  135. Density estimation
    https://en.wikipedia.org/wi­ki/Density_estimation
  136. Sedm smrtelných statistických hříchů
    http://dfens-cz.com/sedm-smrtelnych-statistickych-hrichu/
  137. Spurious correlations
    https://tylervigen.com/spurious-correlations
  138. R programming
    https://www.slideshare.net/shan­tanupatil104/r-programming-44637606
  139. R language tutorial
    https://www.slideshare.net/ChiuYW/r-language-tutorial
  140. An Interactive Introduction To R (Programming Language For Statistics)
    https://www.slideshare.net/da­taspora/an-interactive-introduction-to-r-programming-language-for-statistics
  141. A Pamphlet against R
    https://panicz.github.io/pamphlet/
  142. Notebook interface
    https://en.wikipedia.org/wi­ki/Notebook_interface
  143. Jypyter: open source, interactive data science and scientific computing across over 40 programming languages
    https://jupyter.org/
  144. nbviewer: a simple way to share Jupyter Notebooks
    https://nbviewer.jupyter.org/
  145. Video streaming in the Jupyter Notebook
    https://towardsdatascience.com/video-streaming-in-the-jupyter-notebook-635bc5809e85
  146. How IPython and Jupyter Notebook work
    https://jupyter.readthedoc­s.io/en/latest/architectu­re/how_jupyter_ipython_wor­k.html
  147. Jupyter kernels
    https://github.com/jupyter/ju­pyter/wiki/Jupyter-kernels
  148. PNG is Not GIF
    https://www.root.cz/clanky/png-is-not-gif/
  149. Anatomie grafického formátu PNG
    https://www.root.cz/clanky/anatomie-grafickeho-formatu-png/
  150. PNG – bity, byty, chunky
    https://www.root.cz/clanky/png-bity-byty-chunky/
  151. Řádkové filtry v PNG
    https://www.root.cz/clanky/radkove-filtry-v-png/
  152. Nepovinné chunky v PNG a kontrola pomocí CRC
    https://www.root.cz/clanky/nepovinne-chunky-v-png-a-kontrola-pomoci-crc/

Autor článku

Pavel Tišnovský vystudoval VUT FIT a v současné době pracuje ve společnosti Red Hat, kde vyvíjí nástroje pro OpenShift.io.