Obsah
1. Tisk naformátovaného a obarveného strukturovaného textu na terminál s využitím knihovny Rich
3. Vestavěné demo, spuštění tohoto dema na různých terminálech
4. Rozšířená a vylepšená funkce print
5. Způsoby importu a volání vylepšené funkce print
6. Logování nabízené knihovnou Rich
7. Tisk všech lokálních proměnných do logů
8. Výstup ve formátu JSON se zvýrazněním syntaxe
9. Tisk všech lokálních proměnných do JSONu
11. Výpis metod objektů funkcí inspect
12. Výpis interních atributů a metod funkcí inspect
13. Otestování možností funkce inspect na instanci standardní třídy Queue
14. Veřejné atributy instance třídy Queue
15. Metody objektu typu Queue s krátkým popiskem
16. Výpis privátních metod a atributů objektu typu Queue
18. Již vydané články o tvorbě GUI a TUI v Pythonu
19. Repositář s demonstračními příklady
1. Tisk naformátovaného a obarveného strukturovaného textu na terminál s využitím knihovny Rich
Již mnohokrát jsme se na stránkách Roota zabývali problematikou tvorby aplikací s plnohodnotným grafickým uživatelským rozhraním, které se konkrétně (resp. v největší míře) týkají článků o grafickém uživatelském rozhraní v Pythonu. Ovšem existuje relativně velké množství aplikací, popř. nástrojů či her, pro které může být vhodnější použít „pouhý“ textový terminál, resp. textovou konzoli. Příkladem mohou být aplikace, k nimž se přistupuje přes SSH, systémové nástroje apod. Takové aplikace dělíme do dvou skupin. Do první skupiny spadají interaktivně či neinteraktivně ovládané aplikace s příkazovým řádkem. Příkladem takových aplikací mohou být správci balíčků (dnf, apt-get, …), které s uživatelem interagují pouze několika otázkami typu Y/N. Dalším příkladem je nástroj fdisk se složitějším systémem menu, z nichž se však položka vybírá svým jménem (a nikoli například pohybem kurzoru).
Obrázek 1: Poměrně velké množství aplikací sice využívá rozšířených možností textových terminálů, ovšem stále se jedná spíše o neinteraktivní nástroje bez celoobrazovkového přístupu k terminálu. Dobrým příkladem takových typů aplikací je příkaz dnf, který může v některých případech zobrazit jednoduchou otázku a „interaktivně“ očekávat odpověď.
A do druhé skupiny aplikací určených pro běh v terminálu můžeme zařadit aplikace s plnohodnotným textovým uživatelským rozhraním neboli TUI (Text User Interface). Takových aplikací dnes existuje celá řada. Zmínit můžeme zejména celoobrazovkové textové editory (pochopitelně včetně Vimu a Emacsu), dále Midnight Commander, nástroj Aptitude, ale i některé hry používající celoobrazovkový textový režim (0verkill, Rogue, Nethack, Angband, DoomRL atd.). Částečně sem spadá i hra Dwarf Fortress, která by mohla běžet v terminálu, ale kvůli přenositelnosti používá vlastní engine založený na zobrazení textů.
Obrázek 2: DoomRL – úvodní ASCII art použitý v této hře je takřka dokonalý.
Textové uživatelské rozhraní je u některých aplikací volitelné. Dobrým příkladem takového typu aplikace je GNU Debugger, který buď pracuje v režimu příkazového řádku, nebo ho lze v případě potřeby přepnout do režimu s celoobrazovkovým textovým uživatelským rozhraním. I o tvorbě těchto aplikací jsme se ve stručnosti již zmínili v souvislosti s balíčky GNU Readline a především prompt_toolkit. Odkazy na tyto články jsou obsahem osmnácté kapitoly.
Obrázek 3: Nástroj GNU Debugger po zobrazení textového uživatelského rozhraní (TUI) ve chvíli, kdy je nastaven breakpoint na vstupní bod (přesněji řečeno na první příkaz) ve funkci main. Na levém okraji se zobrazují jak breakpointy, tak i ukazatel na právě prováděný či krokovaný příkaz.
Obrázek 4: Hra Angband s textovým uživatelským rozhraním ve verzi pro Linux – podrobnější charakteristiky hrdiny.
U obou dvou výše zmíněných typů aplikací je nutné umět do určité míry ovládat terminálový výstup, aby například bylo možné smazat znak/řádek, zvýraznit text změnou jeho stylu, barvy textu, barvy pozadí atd. A u aplikací s plnohodnotným textovým uživatelským rozhraním je pochopitelně nutné terminál ovládat do ještě větší míry, aby bylo možné pracovat s okny, menu, nápovědou a dalšími ovládacími prvky (widgety). Vzhledem k tomu, že se textové terminály vyvíjejí už velmi dlouho (minimálně od roku 1965, kdy vznikl první skutečný počítačový terminál IBM 2741 jako náhrada za dálnopisy) jsou rozdílné i jejich možnosti (vlastnosti) i způsob jejich ovládání (většinou s využitím řídicích kódů, dnes většinou založených na takzvaných escape sekvencích a několika dalších ASCII znacích).
Obrázek 5: Část sálového počítače IBM System/360 Model 40 (rok výroby 1964). V pozadí můžeme vidět jednotky s magnetickými pásky (model IBM 2401), ovládací panel je umístěn přímo za slečnou. A slečna sedí u dálnopisu, tedy přímého předchůdce počítačových terminálů.
Samozřejmě jsme mohli v průběhu předchozích desetiletí vidět snahu o sjednocení ovládání terminálů, která probíhala paralelně s vytvářením databáze obsahující vlastnosti terminálů (terminfo a termcap). Existují také knihovny, které programátora dokážou odizolovat od nízkoúrovňového přístupu k terminálům a jejich řízení s využitím řídicích kódů. Jedná se především o knihovnu curses a jejího následovníka ncurses (viz článek Psaní aplikací pro terminál: jak funguje knihovna ncurses, popř. o utility spouštěné z příkazového řádku (tput, tset, reset atd.).
Obrázek 6: Ovládací prvky vykreslené s využitím knihovny Blessed-contrib (JavaScript).
Zdroj: https://github.com/yaronn/blessed-contrib.
Dnes se budeme zabývat knihovnou Rich, která je určena pro Python. Do jaké kategorie však tato knihovna spadá? Nejedná se v žádném případě o GUI knihovnu, ovšem současně se nejedná ani o knihovnu pro tvorbu plnohodnotného textového uživatelského rozhraní (TUI). Rich „pouze“ vylepšuje výstup naformátovaného textu na moderních terminálech, které (mnohdy) podporují plné barvy (true color), Unicode atd. A právě v této oblasti je Rich velmi dobrým pomocníkem (pravděpodobně nejlepším ve své kategorii).
Obrázek 7: Spuštění debuggeru, inicializace laděné aplikace, nastavení breakpointu a doskok na breakpoint.
2. Instalace knihovny rich
Knihovna Rich je dostupná na PyPi, takže je její instalace přímočará. V případě, že využijeme nástroj pip, resp. pip3, lze provést instalaci (pro právě přihlášeného uživatele) následujícím způsobem:
$ pip3 install --user rich
Collecting rich
Downloading rich-12.6.0-py3-none-any.whl (237 kB)
|████████████████████████████████| 237 kB 1.6 MB/s
Collecting typing-extensions<5.0,>=4.0.0; python_version < "3.9"
Downloading typing_extensions-4.4.0-py3-none-any.whl (26 kB)
Collecting pygments<3.0.0,>=2.6.0
Downloading Pygments-2.13.0-py3-none-any.whl (1.1 MB)
|████████████████████████████████| 1.1 MB 2.5 MB/s
Collecting commonmark<0.10.0,>=0.9.0
Downloading commonmark-0.9.1-py2.py3-none-any.whl (51 kB)
|████████████████████████████████| 51 kB 3.9 MB/s
Installing collected packages: typing-extensions, pygments, commonmark, rich
Successfully installed commonmark-0.9.1 pygments-2.13.0 rich-12.6.0 typing-extensions-4.4.0
$ virtualenv -p python3 venv && source venv/bin/activate && python3 `which pip3` install -r requirements.txt
To, zda je balíček skutečně dostupný přímo z Pythonu, si můžeme ověřit velmi snadno:
$ python3
Python 3.9.3 (default, Sep 22 2022, 23:10:10)
[GCC 9.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import rich
>>> help("rich")
Help on package rich:
NAME
rich - Rich text and beautiful formatting in the terminal.
PACKAGE CONTENTS
__main__
_cell_widths
_emoji_codes
_emoji_replace
_export_format
_extension
_inspect
...
...
...
3. Vestavěné demo, spuštění tohoto dema na různých terminálech
Knihovna rich obsahuje i vestavěné demo, které přímo na ploše terminálu ukáže některé její možnosti. Toto demo lze spustit následovně:
$ python3 -m rich
Na moderním terminálu, který podporuje plné barvy a Unicode, se zobrazí tento obsah:
Obrázek 8: Demo zobrazené na moderním terminálu.
Zdroj: stránky projektu Rich.
Na xtermu se světlým pozadím a podporou jen 88 barev dostaneme tento výstup:
Obrázek 9: Demo zobrazené na xtermu.
Obrázek 10: Demo zobrazené na xtermu.
Naproti tomu xfce4-terminal zobrazí text podobně, jako je tomu na osmém obrázku:
Obrázek 11: Demo zobrazené na xfce4-terminalu.
Obrázek 12: Demo zobrazené na xfce4-terminalu (povšimněte si, že vlajky nejsou v použitém fontu obsaženy).
4. Rozšířená a vylepšená funkce print
Prakticky každý začínající programátor zavolá ve svých prvních programech standardní funkci print:
Help on built-in function print in module builtins:
print(...)
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.
Tato funkce dokáže zobrazit hodnotu jakéhokoli typu, umožňuje přesměrovat výstup do souboru, volit, resp. modifikovat oddělovač záznamů atd. Ovšem její možnosti při výstupu na terminál (který už dávno není pouhým emulátorem dálnopisu) jsou limitovány – vypisované hodnoty jsou vypsány stejnou barvou a totožným typem písma atd. Ostatně se o tom můžeme snadno přesvědčit výpisem hodnot několika typů – seznamu, n-tice, slovníku a dalšího seznamu se „speciálními“ hodnotami:
a_list = [1, 2, 3, 4, 5]
print(a_list)
a_tuple = (1, 2, 3, 4, 5)
print(a_tuple)
a_dict = {'list': a_list, 'tuple': a_tuple, 'nil': None}
print(a_dict)
other_list = [True, False, None]
print(other_list)
Výsledky:
Obrázek 13: Standardní funkce print na xtermu.
Obrázek 14: Standardní funkce print na xfce4-terminalu.
5. Způsoby importu a volání vylepšené funkce print
Knihovna Rich nabízí svoji vlastní variantu funkce print, která dokáže zobrazované hodnoty (kromě dalších „vychytávek“) barevně zvýraznit, takže výsledky budou vypadat přehledněji:
Obrázek 15: Vylepšená funkce print na xtermu.
Obrázek 16: Vylepšená funkce print na xfce4-terminalu.
Tuto funkci lze naimportovat například takto – tím se přepíše vazba na originální funkci print:
from rich import print
a_list = [1, 2, 3, 4, 5]
print(a_list)
a_tuple = (1, 2, 3, 4, 5)
print(a_tuple)
a_dict = {'list': a_list, 'tuple': a_tuple, 'nil': None}
print(a_dict)
other_list = [True, False, None]
print(other_list)
Alternativně je možné provést import stylem, jenž bude vyžadovat její volání společně s uvedením jmenného aliasu balíčku:
import rich
a_list = [1, 2, 3, 4, 5]
rich.print(a_list)
a_tuple = (1, 2, 3, 4, 5)
rich.print(a_tuple)
a_dict = {'list': a_list, 'tuple': a_tuple, 'nil': None}
rich.print(a_dict)
other_list = [True, False, None]
rich.print(other_list)
Nebo můžeme při importu zvolit nový jmenný alias importované funkce print:
from rich import print as rprint
a_list = [1, 2, 3, 4, 5]
rprint(a_list)
a_tuple = (1, 2, 3, 4, 5)
rprint(a_tuple)
a_dict = {'list': a_list, 'tuple': a_tuple, 'nil': None}
rprint(a_dict)
other_list = [True, False, None]
rprint(other_list)
6. Logování nabízené knihovnou Rich
V knihovně Rich nalezneme i další užitečné funkce a třídy. Příkladem může být třída Console, která dokáže na terminál vypsat (opět v přehledné podobě) jakoukoli hodnotu, přičemž formát odpovídá formátu, který očekáváme od logovacích informací (tedy například se použije časové razítko atd.). Ostatně se podívejme na následující demonstrační příklad, který ve funkci perform_computation vypíše „do logu“ obsah hodnoty uložené v lokální proměnné dictionary:
from rich.console import Console
console = Console()
def perform_computation(x, y):
dictionary = {}
dictionary["x"] = x
dictionary["y"] = y
try:
z = x / y
dictionary["result"] = z
dictionary["success"] = True
except Exception as e:
dictionary["success"] = False
dictionary["errors"] = e
console.log(dictionary)
return dictionary
perform_computation(1, 2)
perform_computation(1, 0)
Výsledek bude vypadat následovně (povšimněte si, že se zobrazí jak časové razítko, tak i řádek v kódu, který log vypsal):
Obrázek 17: Výpis na xtermu.
Obrázek 18: Výpis na xfce4-terminalu.
7. Tisk všech lokálních proměnných do logů
Pokud metodě Console.log předáme nepovinný parametr log_locals nastavený na hodnotu True, vypíšou se automaticky i hodnoty lokálních proměnných:
from rich.console import Console
console = Console()
def perform_computation(x, y):
dictionary = {}
dictionary["x"] = x
dictionary["y"] = y
try:
z = x / y
dictionary["result"] = z
dictionary["success"] = True
except Exception as e:
dictionary["success"] = False
dictionary["errors"] = e
console.log(dictionary, log_locals=True)
return dictionary
perform_computation(1, 2)
perform_computation(1, 0)
S výsledkem:
Obrázek 19: Výpis na xtermu.
Obrázek 20: Výpis na xfce4-terminalu.
V dalším příkladu jsou mezi jednotlivá volání funkce perform_computation vloženy pauzy, takže výstup bude odlišný (použijí se dvě časová razítka):
from rich.console import Console
from time import sleep
console = Console()
def perform_computation(x, y):
dictionary = {}
dictionary["x"] = x
dictionary["y"] = y
try:
z = x / y
dictionary["result"] = z
dictionary["success"] = True
except Exception as e:
dictionary["success"] = False
dictionary["errors"] = e
console.log(dictionary, log_locals=True)
return dictionary
perform_computation(1, 2)
sleep(1)
perform_computation(1, 0)
sleep(1)
perform_computation("foo", 0)
S výsledkem:
Obrázek 21: Výpis na xtermu.
Obrázek 22: Výpis na xfce4-terminalu.
8. Výstup ve formátu JSON se zvýrazněním syntaxe
Nepatrnou změnou, konkrétně náhradou volání metody Console.log za metodu Console.print_json, je možné zajistit, že hodnoty budou na terminál vypsány ve formátu JSON, takže jejich další zpracování může být snadnější:
from rich.console import Console
console = Console()
def perform_computation(x, y):
dictionary = {}
dictionary["x"] = x
dictionary["y"] = y
try:
z = x / y
dictionary["result"] = z
dictionary["success"] = True
except Exception as e:
dictionary["success"] = False
dictionary["errors"] = e
console.print_json(data=dictionary)
return dictionary
perform_computation(1, 2)
perform_computation(1, 0)
Povšimněte si, že se v tomto případě nemůže přímo pracovat s hodnotami typu Exception nebo s odvozenými hodnotami, což je poměrně problematický rys knihovny Rich:
Obrázek 23: Výpis na xtermu.
Obrázek 24: Výpis na xfce4-terminalu.
9. Tisk všech lokálních proměnných do JSONu
I u metody Console.proměnných je možné zobrazit obsah lokálních proměnných ve formátu JSON. Použijeme zde trik – předání pojmenovaného parametru data, jehož hodnotou bude výsledek volání locals():
from rich.console import Console
console = Console()
def perform_computation(x, y):
dictionary = {}
dictionary["x"] = x
dictionary["y"] = y
try:
z = x / y
dictionary["result"] = z
dictionary["success"] = True
except Exception as e:
dictionary["success"] = False
dictionary["errors"] = e
console.print_json(data=locals())
return dictionary
perform_computation(1, 2)
perform_computation(1, 0)
Výsledky budou v tomto případě vypadat následovně:
Obrázek 25: Výpis na xtermu.
Obrázek 26: Výpis na xfce4-terminalu.
10. Užitečná funkce inspect
Velmi užitečnou funkcí, kterou v knihovně Rich najdeme, je funkce, která se nazývá inspect. Tato funkce dokáže ve strukturované a snadno čitelné formě zobrazit prakticky jakékoli hodnoty a navíc nabízí i několik přepínačů:
Help on function inspect in rich:
rich.inspect = inspect(obj: Any, *, console: Union[ForwardRef('Console'), NoneType] = None, title: Union[str, NoneType] = None, help: bool = False, methods: bool = False, docs: bool = True, private: bool = False, dunder: bool = False, sort: bool = True, all: bool = False, value: bool = True) -> None
Inspect any Python object.
* inspect(<OBJECT>) to see summarized info.
* inspect(<OBJECT>, methods=True) to see methods.
* inspect(<OBJECT>, help=True) to see full (non-abbreviated) help.
* inspect(<OBJECT>, private=True) to see private attributes (single underscore).
* inspect(<OBJECT>, dunder=True) to see attributes beginning with double underscore.
* inspect(<OBJECT>, all=True) to see all attributes.
Args:
obj (Any): An object to inspect.
title (str, optional): Title to display over inspect result, or None use type. Defaults to None.
help (bool, optional): Show full help text rather than just first paragraph. Defaults to False.
methods (bool, optional): Enable inspection of callables. Defaults to Fa
docs (bool, optional): Also render doc strings. Defaults to True.
private (bool, optional): Show private attributes (beginning with underscore). Defaults to False.
dunder (bool, optional): Show attributes starting with double underscore. Defaults to False.
sort (bool, optional): Sort attributes alphabetically. Defaults to True.
all (bool, optional): Show all attributes. Defaults to False.
value (bool, optional): Pretty print value. Defaults to True.
Vyzkoušejme si například, jaké informace se zobrazí o třídě list:
from rich import inspect inspect(list)
Obrázek 27: Výpis na xtermu.
Obrázek 28: Výpis na xfce4-terminalu.
11. Výpis metod objektů funkcí inspect
Třída list nabízí několik metod, které jsou veřejně dostupné. Funkce inspect dokáže nejenom zobrazit jména těchto metod, ale navíc dokáže i vypsat krátké anotace k těmto metodám. Ostatně se podívejme na následující kód, kde voláme funkci inspect s nepovinným parametrem methods nastaveným na hodnotu True:
from rich import inspect inspect(list, methods=True)
Výsledek vypadá následovně:
Obrázek 29: Výpis všech veřejných metod třídy list.
12. Výpis interních atributů a metod funkcí inspect
V případě, že se funkci inspect předá (samozřejmě kromě zkoumaného objektu) i nepovinný atribut all=True, zobrazí se na terminálu mnohem větší množství informací, a to včetně všech atributů:
from rich import inspect inspect(list, all=True)
V tomto případě budou informace zobrazené na ploše terminálu vypadat takto:
Obrázek 30: Výpis všech atributů a metod třídy list.
13. Otestování možností funkce inspect na instanci standardní třídy Queue
Některé další možnosti poskytované funkcí inspect si ukážeme na demonstračních příkladech, ve kterých se zkonstruuje instance standardní třídy Queue. Samotná funkce print totiž ani vzdáleně nedokáže vypsat informace o tomto objektu tak přehledně, jako to dokáže právě funkce inspect:
from queue import Queue q = Queue() q.put(42) q.put(3.14) q.put(True) q.put(None) print(q) print(q.__dict__)
Výsledky v tomto případě nejsou v žádném případě přehledné:
<queue.Queue object at 0x7f3c8f268430>
{'maxsize': 0, 'queue': deque([42, 3.14, True, None]), 'mutex': <unlocked _thread.lock object at 0x7f3c8f23ba80>, 'not_empty': <Condition(<unlocked _thread.lock object at 0x7f3c8f23ba80>, 0)>, 'not_full': <Condition(<unlocked _thread.lock object at 0x7f3c8f23ba80>, 0)>, 'all_tasks_done': <Condition(<unlocked _thread.lock object at 0x7f3c8f23ba80>, 0)>, 'unfinished_tasks': 4}
14. Veřejné atributy instance třídy Queue
Výše uvedený výpis, který je z pohledu vývojáře dosti nepraktický, lze vylepšit právě funkcí inspect, která se v tom nejjednodušším případě zavolá takto:
from rich import inspect from queue import Queue q = Queue() q.put(42) q.put(3.14) q.put(True) q.put(None) inspect(q)
Výsledkem bude relativně přehledný seznam veřejných atributů o tomto objektu:
Obrázek 31: Zobrazení veřejných atributů o instanci třídy Queue.
15. Metody objektu typu Queue s krátkým popiskem
Pro výpis veřejných metod objektu typu Queue na terminál se použije toto volání funkce inspect:
inspect(q, methods=True)
Podívejme se na úplný zdrojový kód jednoduchého příkladu, který toto volání realizuje:
from rich import inspect from queue import Queue q = Queue() q.put(42) q.put(3.14) q.put(True) q.put(None) inspect(q, methods=True)
Výsledek (zobrazený na xtermu) bude v tomto případě vypadat následovně:
Obrázek 32: Zobrazení veřejných metod o instanci třídy Queue.
16. Výpis privátních metod a atributů objektu typu Queue
Pro výpis veřejných ale i privátních metod je nutné použít, jak již ostatně víme, nepovinný parametr private nastavený na hodnotu True, tedy následovně:
from rich import inspect from queue import Queue q = Queue() q.put(42) q.put(3.14) q.put(True) q.put(None) inspect(q, methods=True, private=True)
Výsledek zobrazený na xtermu se světlým pozadím:
Obrázek 33: Zobrazení veřejných i privátních metod o instanci třídy Queue.
A na závěr si ukažme, jak se vypíšou všechny veřejné i privátní atributy:
from rich import inspect from queue import Queue q = Queue() q.put(42) q.put(3.14) q.put(True) q.put(None) inspect(q, all=True)
Povšimněte si, že výpis je zkrácen – ve skutečnosti v tomto případě zabere dvě výšky terminálu:
Obrázek 34: Zobrazení všech veřejných i privátních metod a atributů instance třídy Queue.
17. Obsah navazujícího článku
Dnes jsme si ve skutečnosti ukázali pouze naprosto základní funkce, které knihovna Rich programátorům nabízí. Ve druhém (a současně i posledním) článku o této knihovně si popíšeme zajímavější příklady, například to, jakým způsobem je možné zobrazit stromové struktury (a to je v praxi velmi důležité), jak se zobrazují tabulky s formátovaným textem, zobrazení dat umístěných do sloupců (tedy opět formátování textu) a v neposlední řadě si ukážeme například postupné zobrazení dokončené činnosti (progress bar).
18. Již vydané články o tvorbě GUI a TUI v Pythonu
Tento článek se zabývá tvorbou aplikací s textovým uživatelským rozhraním v Pythonu. Neškodí si proto připomenout, že právě pro Python existuje poměrně velké množství knihoven určených pro práci s grafickým uživatelským rozhraním i s uživatelským rozhraním textovým. Mnohé z těchto knihoven jsme si již na stránkách Roota popsali, a to v následujících článcích:
- Knihovny pro tvorbu grafického uživatelského rozhraní v Pythonu
https://www.root.cz/clanky/knihovny-pro-tvorbu-grafickeho-uzivatelskeho-rozhrani-v-pythonu/ - Grafické uživatelské rozhraní v Pythonu: knihovna Tkinter
https://www.root.cz/clanky/graficke-uzivatelske-rozhrani-v-pythonu-knihovna-tkinter/ - Grafické uživatelské rozhraní v Pythonu: knihovna Tkinter (2.část)
https://www.root.cz/clanky/graficke-uzivatelske-rozhrani-v-pythonu-knihovna-tkinter-2-cast/ - Grafické uživatelské rozhraní v Pythonu: knihovna Tkinter (3.část)
https://www.root.cz/clanky/graficke-uzivatelske-rozhrani-v-pythonu-knihovna-tkinter-3-cast/ - Grafické uživatelské rozhraní v Pythonu: menu v knihovně Tkinter
https://www.root.cz/clanky/graficke-uzivatelske-rozhrani-v-pythonu-menu-v-knihovne-tkinter/ - Grafické uživatelské rozhraní v Pythonu: kouzla s kreslicí plochou (canvasem)
https://www.root.cz/clanky/graficke-uzivatelske-rozhrani-v-pythonu-kouzla-s-kreslici-plochou-canvasem/ - Grafické uživatelské rozhraní v Pythonu: kouzla s kreslicí plochou (2. část)
https://www.root.cz/clanky/graficke-uzivatelske-rozhrani-v-pythonu-kouzla-s-kreslici-plochou-2-cast/ - Grafické uživatelské rozhraní v Pythonu: kouzla s kreslicí plochou (dokončení)
https://www.root.cz/clanky/graficke-uzivatelske-rozhrani-v-pythonu-kouzla-s-kreslici-plochou-dokonceni/ - Grafické uživatelské rozhraní v Pythonu: další možnosti nabízené widgety Text a ScrolledText
https://www.root.cz/clanky/graficke-uzivatelske-rozhrani-v-pythonu-dalsi-moznosti-nabizene-widgety-text-a-scrolledtext/ - Grafické uživatelské rozhraní v Pythonu: použití dialogových oken v knihovně Tkinter
https://www.root.cz/clanky/graficke-uzivatelske-rozhrani-v-pythonu-pouziti-dialogovych-oken-v-knihovne-tkinter/ - Tvorba grafického uživatelského rozhraní v Pythonu s využitím knihovny appJar
https://www.root.cz/clanky/tvorba-grafickeho-uzivatelskeho-rozhrani-v-pythonu-s-vyuzitim-knihovny-appjar/ - Tvorba grafického uživatelského rozhraní v Pythonu: widgety v knihovně appJar
https://www.root.cz/clanky/tvorba-grafickeho-uzivatelskeho-rozhrani-v-pythonu-widgety-v-knihovne-appjar/ - Tvorba grafického uživatelského rozhraní v Pythonu: dokončení popisu widgetů v knihovně appJar
https://www.root.cz/clanky/tvorba-grafickeho-uzivatelskeho-rozhrani-v-pythonu-dokonceni-popisu-widgetu-v-knihovne-appjar/ - Tvorba GUI v Pythonu: menu, toolbary a widgety pro vstup textu v knihovně appJar
https://www.root.cz/clanky/tvorba-gui-v-pythonu-menu-toolbary-a-widgety-pro-vstup-textu-v-knihovne-appjar/ - Tvorba GUI v Pythonu: widgety pro zobrazení tabulek a stromů v knihovně appJar
https://www.root.cz/clanky/tvorba-gui-v-pythonu-widgety-pro-zobrazeni-tabulek-a-stromu-v-knihovne-appjar/ - Tvorba GUI v Pythonu: widgety pro zobrazení grafických informací nabízené knihovnou appJar
https://www.root.cz/clanky/tvorba-gui-v-pythonu-widgety-pro-zobrazeni-grafickych-informaci-nabizene-knihovnou-appjar/ - Tvorba GUI v Pythonu: použití želví grafiky společně s knihovnou appJar
https://www.root.cz/clanky/tvorba-gui-v-pythonu-pouziti-zelvi-grafiky-spolecne-s-knihovnou-appjar/ - Tvorba grafického uživatelského rozhraní v Pythonu s využitím frameworku PySide
https://www.root.cz/clanky/tvorba-grafickeho-uzivatelskeho-rozhrani-v-pythonu-s-vyuzitim-frameworku-pyside/ - Tvorba GUI v Pythonu s PySide: signály a sloty, správci rozložení komponent
https://www.root.cz/clanky/tvorba-gui-v-pythonu-s-pyside-signaly-a-sloty-spravci-rozlozeni-komponent/ - Tvorba GUI v Pythonu s PySide: další dostupné ovládací prvky
https://www.root.cz/clanky/tvorba-gui-v-pythonu-s-pyside-dalsi-dostupne-ovladaci-prvky/ - Tvorba GUI v Pythonu s PySide: přepínací tlačítka a tvorba hlavních oken aplikací
https://www.root.cz/clanky/tvorba-gui-v-pythonu-s-pyside-prepinaci-tlacitka-a-tvorba-hlavnich-oken-aplikaci/ - Tvorba GUI v Pythonu s PySide: hlavní menu, nástrojový pruh a výběrový seznam
https://www.root.cz/clanky/tvorba-gui-v-pythonu-s-pyside-hlavni-menu-nastrojovy-pruh-a-vyberove-seznam/ - Tvorba GUI v Pythonu s využitím frameworku PySide: rastrová a vektorová grafika
https://www.root.cz/clanky/tvorba-gui-v-pythonu-s-vyuzitim-frameworku-pyside-rastrova-a-vektorova-grafika/ - Tvorba GUI v PySide: grafické operace používající třídu QPainter
https://www.root.cz/clanky/tvorba-gui-v-pyside-graficke-operace-pouzivajici-tridu-qpainter/ - Tvorba GUI v Pythonu s PySide: pokročilejší grafické operace používající třídu QPainter
https://www.root.cz/clanky/tvorba-gui-v-pythonu-s-pyside-pokrocilejsi-graficke-operace-pouzivajici-tridu-qpainter/ - Tvorba GUI v Pythonu s PySide: použití cest při kreslení 2D scén
https://www.root.cz/clanky/tvorba-gui-v-pythonu-s-pyside-pouziti-cest-pri-kresleni-2d-scen/ - GUI v Pythonu s PySide: rastrové operace, vykreslování textů
https://www.root.cz/clanky/gui-v-pythonu-s-pyside-rastrove-operace-vykreslovani-textu/ - Tvorba GUI v Pythonu s využitím frameworku PySide: widgety pro textový vstup
https://www.root.cz/clanky/tvorba-gui-v-pythonu-s-vyuzitim-frameworku-pyside-widgety-pro-textovy-vstup/ - Složitější ovládací prvky ve frameworku PySide: tabulky a stromy
https://www.root.cz/clanky/slozitejsi-ovladaci-prvky-ve-frameworku-pyside-tabulky-a-stromy/ - Další užitečné ovládací prvky nabízené frameworkem PySide
https://www.root.cz/clanky/dalsi-uzitecne-ovladaci-prvky-nabizene-frameworkem-pyside/ - Standardní dialogy v knihovně PySide
https://www.root.cz/clanky/standardni-dialogy-v-nbsp-knihovne-pyside/ - Konfigurace standardních dialogů nabízených knihovnou PySide
https://www.root.cz/clanky/konfigurace-standardnich-dialogu-nabizenych-knihovnou-pyside/ - Nastavení stylů vykreslování widgetů, oken i dialogů v knihovně PySide
https://www.root.cz/clanky/nastaveni-stylu-vykreslovani-widgetu-oken-i-dialogu-v-knihovne-pyside/ - Tvorba GUI v Pythonu: použití kaskádových stylů v PySide
https://www.root.cz/clanky/tvorba-gui-v-pythonu-pouziti-kaskadovych-stylu-v-pyside/ - Práce s vektorovým formátem SVG ve frameworku PySide
https://www.root.cz/clanky/prace-s-vektorovym-formatem-svg-ve-frameworku-pyside/ - Práce s vektorovým formátem SVG ve frameworku PySide (dokončení)
https://www.root.cz/clanky/prace-s-vektorovym-formatem-svg-ve-frameworku-pyside-dokonceni/ - Použití UI souborů s popisem formulářů ve frameworku PySide
https://www.root.cz/clanky/pouziti-ui-souboru-s-popisem-formularu-ve-frameworku-pyside/ - Jazyk QML (Qt Modeling Language) a PySide
https://www.root.cz/clanky/jazyk-qml-qt-modeling-language-a-pyside/ - Jazyk QML (Qt Modeling Language) a PySide 2
https://www.root.cz/clanky/jazyk-qml-qt-modeling-language-a-pyside-2/ - Reakce na události v GUI deklarované v jazyku QML a PySide 2
https://www.root.cz/clanky/reakce-na-udalosti-v-gui-deklarovane-v-jazyku-qml-a-pyside-2/ - Interaktivní tvorba grafického uživatelského rozhraní nástrojem Pygubu
https://www.root.cz/clanky/interaktivni-tvorba-grafickeho-uzivatelskeho-rozhrani-nastrojem-pygubu/ - Interaktivní tvorba grafického uživatelského rozhraní s využitím nástroje Pygubu (2)
https://www.root.cz/clanky/interaktivni-tvorba-grafickeho-uzivatelskeho-rozhrani-s-vyuzitim-nastroje-pygubu-2/ - Interaktivní tvorba grafického uživatelského rozhraní s využitím nástroje Pygubu (dokončení)
https://www.root.cz/clanky/interaktivni-tvorba-grafickeho-uzivatelskeho-rozhrani-s-vyuzitim-nastroje-pygubu-dokonceni/
Na stránkách Roota jsme se zabývali taktéž některými knihovnami (opět určenými primárně pro Python), které je možné použít pro tvorbu aplikací s celoobrazovkovým (či chcete-li celoterminálovým) textovým uživatelským rozhraním. Podporu pro TUI poskytuje především knihovna prompt_toolkit:
- Tvorba aplikací s příkazovým řádkem v Pythonu s knihovnami GNU Readline a prompt_toolkit
https://www.root.cz/clanky/tvorba-aplikaci-s-prikazovym-radkem-v-pythonu-s-vyuzitim-knihoven-gnu-readline-a-prompt-toolkit/ - Tvorba aplikací s textovým uživatelským rozhraním založeným na knihovně prompt_toolkit
https://www.root.cz/clanky/tvorba-aplikaci-s-textovym-uzivatelskym-rozhranim-zalozenym-na-knihovne-prompt-toolkit/ - Tvorba textového rozhraní s knihovnou prompt_toolkit: základní prvky TUI
https://www.root.cz/clanky/tvorba-textoveho-rozhrani-s-knihovnou-prompt-toolkit-zakladni-prvky-tui/ - Tvorba TUI s knihovnou prompt_toolkit: aplikace s celoobrazovkovým rozhraním
https://www.root.cz/clanky/tvorba-tui-s-knihovnou-prompt-toolkit-aplikace-s-celoobrazovkovym-rozhranim/ - Tvorba textového uživatelského rozhraní s knihovnou prompt_toolkit: ovládací prvky (widgety)
https://www.root.cz/clanky/tvorba-textoveho-uzivatelskeho-rozhrani-s-knihovnou-prompt-toolkit-ovladaci-prvky-widgety/
19. Repositář s demonstračními příklady
Zdrojové kódy všech dnes popsaných demonstračních příkladů určených pro Python 3 byly uloženy do Git repositáře dostupného na adrese https://github.com/tisnik/most-popular-python-libs. V případě, že nebudete chtít klonovat celý repositář (ten je ovšem stále velmi malý, dnes má velikost zhruba několik desítek kilobajtů), můžete namísto toho použít odkazy na jednotlivé příklady, které naleznete v následující tabulce:
20. Odkazy na Internetu
- Repositář s knihovnou Rich
https://github.com/Textualize/rich - Knihovna Rich na PyPi
https://pypi.org/project/rich/ - How to Use the Rich Library with Python
https://www.freecodecamp.org/news/use-the-rich-library-in-python/ - Introduction (Rich, Readthedocs)
https://rich.readthedocs.io/en/stable/introduction.html - Awesome Python
https://awesome-python.com/ - Python Awesome
https://pythonawesome.com/about/ - Python Rich Library
https://vegibit.com/python-rich-library/ - Python’s rich library – a tutorial
https://softbranchdevelopers.com/pythons-rich-library-a-tutorial/ - blessed na PyPi
https://pypi.org/project/blessed/ - blessed na GitHubu
https://github.com/jquast/blessed - Blessed documentation!
https://blessed.readthedocs.io/en/latest/ - termbox-go na GitHubu
https://github.com/nsf/termbox-go - termui na GitHubu
https://github.com/gizak/termui - blessed na GitHubu
https://github.com/chjj/blessed - blessed-contrib na GitHubu
https://github.com/yaronn/blessed-contrib - tui-rs na GitHubu
https://github.com/fdehau/tui-rs
