Programovací jazyk R, Jupyter notebook a Jupytext

2. 2. 2021

Doba čtení: 30 minut

Líbí se vám článek?
Podpořte redakci

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ů:

Gophernotes: kombinace interaktivního prostředí Jupyteru s jazykem Go
https://www.root.cz/clanky/gophernotes-kombinace-interaktivniho-prostredi-jupyteru-s-jazykem-go/
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_notebook_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.cloudfront.net/blog/wp-content/uploads/2018/10/Jupyter_Notebook_CheatSheet_Edureka.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:

Základy tvorby grafů v programovacím jazyku R
https://www.root.cz/clanky/zaklady-tvorby-grafu-v-programovacim-jazyku-r/
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/
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/
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/
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_programovac%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_programovací_jazyk_R.r	základní konstrukce jazyka R, tvorba grafů	https://github.com/tisnik/r-examples/blob/master/15-jupyter-notebook/Jupyter_notebook_a_programovací_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:

#	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/Install_packages_R.ipynb
2	Jupyter_notebook_a_programovací_jazyk_R.ipynb	základní konstrukce jazyka R, tvorba grafů	https://github.com/tisnik/jupyter-notebook-examples/blob/master/R/Jupyter_notebook_a_programovac%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%20knihovna%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_programovac%C3%AD_jazyk_R.html	základní konstrukce jazyka R, tvorba grafů	https://tisnik.github.io/jupyter-notebook-examples/Jupyter_notebook_a_programovac%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%20Lattice.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:

Gophernotes: kombinace interaktivního prostředí Jupyteru s jazykem Go
https://www.root.cz/clanky/gophernotes-kombinace-interaktivniho-prostredi-jupyteru-s-jazykem-go/
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/
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/
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/
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/
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

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
JupyterLab – Installing R Kernel
https://www.tutorialspoint.com/jupyter/jupyterlab_installing_r_kernel.htm
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
Jupyter and data science in Fedora
https://fedoramagazine.org/jupyter-and-data-science-in-fedora/
Jupyter Notebook Keyboard Shortcuts
https://media.cheatography.com/storage/thumb/weidadeyue_jupyter-notebook.750.jpg?last=1462914889
Jupyter Notebook Cheat Sheet
https://d1jnx9ba8s6j9r.cloudfront.net/blog/wp-content/uploads/2018/10/Jupyter_Notebook_CheatSheet_Edureka.png
Jupyter And R Markdown: Notebooks With R
https://www.r-bloggers.com/2016/11/jupyter-and-r-markdown-notebooks-with-r/
Jupyter And R Markdown: Notebooks With R
https://www.datacamp.com/community/blog/jupyter-notebook-r
Jupyter notebooks as Markdown documents
https://pythonawesome.com/jupyter-notebooks-as-markdown-documents/
R Tutorial
https://www.tutorialspoint.com/r/index.htm
A Tutorial on Using Functions in R!
https://www.datacamp.com/community/tutorials/functions-in-r-a-tutorial
R Functions
https://www.datamentor.io/r-programming/function/
A Tutorial on Loops in R – Usage and Alternatives
https://www.datacamp.com/community/tutorials/tutorial-on-loops-in-r
Anonymous Functions in R – Part 1
https://coolbutuseless.github.io/2019/03/13/anonymous-functions-in-r-part-1/
Anonymous Functions in R – Part 2
https://coolbutuseless.github.io/2019/03/13/anonymous-functions-in-r-part-2/
Scoping and Closures in R
https://www.pluralsight.com/guides/scoping-and-closures-in-r
Tools for Computing on the Language
https://www.rdocumentation.org/packages/pryr/versions/0.1.4
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
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/

Seriál: Programovací jazyk R

Podrobnější popis vlastností programovacího jazyka R
Funkce v programovacím jazyku R
Programovací jazyk R, Jupyter notebook a Jupytext

Přečtěte si všechny díly seriálu Programovací jazyk R nebo sledujte jeho RSS

Vstoupit do diskuse (12 názorů)

Pavel Tišnovský

Vystudoval VUT FIT a v současné době pracuje na projektech vytvářených v jazycích Python a Go.

jupytext je koncepcne org-mode babel podobny, ale postaveny na markdown syntaxi, je oproti org-mode jednodussi, coz usnadnuje podporu napric editory. Org-mode ma mozna zbytecne moc featur, coz komplikuje vznik alternativnich implementaci.

bez přezdívky

Sdílet

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

Podrobnější popis vlastností programovacího jazyka R

Funkce v programovacím jazyku R