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
8. Zobrazení dokumentace ke knihovnám, objektům a funkcím
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
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.
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.
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
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
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í.
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.
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.
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
```
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/
