Mendelova univerzita v Brně Provozně ekonomická fakulta
Schopnosti překladačů programovacího jazyka Python Diplomová práce
Vedoucí práce: Ing. Pavel Haluza, Ph.D.
Bc. Ondřej Pala
Brno 2015
Rád bych poděkoval své přítelkyni, rodině a v neposlední řadě i mému vedoucímu práce Ing. Pavelu Haluzovi, Ph.D. za užitečné rady při tvorbě práce.
Čestné prohlášení Prohlašuji, že jsem tuto práci: Srovnání překladačů programovacího jazyka Python vypracoval/a samostatně a veškeré použité prameny a informace jsou uvedeny v seznamu použité literatury. Souhlasím, aby moje práce byla zveřejněna v souladu s § 47b zákona č. 111/1998 Sb., o vysokých školách ve znění pozdějších předpisů, a v souladu s platnou Směrnicí o zveřejňování vysokoškolských závěrečných prací. Jsem si vědom/a, že se na moji práci vztahuje zákon č. 121/2000 Sb., autorský zákon, a že Mendelova univerzita v Brně má právo na uzavření licenční smlouvy a užití této práce jako školního díla podle § 60 odst. 1 Autorského zákona. Dále se zavazuji, že před sepsáním licenční smlouvy o využití díla jinou osobou (subjektem) si vyžádám písemné stanovisko univerzity o tom, že předmětná licenční smlouva není v rozporu s oprávněnými zájmy univerzity, a zavazuji se uhradit případný příspěvek na úhradu nákladů spojených se vznikem díla, a to až do jejich skutečné výše. V Brně dne 20. května 2015
_______________________________
Abstract PALA, Ondřej. Ability of compilers programming language Python. Brno, 2015. Diploma thesis. Mendel university in Brno. Diploma thesis rate ability of selected compilers programming language Python. First path of thesis is focused to programming language Python and principle of working compilers. Second path is focused to creating testing tasks, defining evaluation criterias of compilers and testing compilers without testing tasks. Keywords Compilers, programming language Python, testing tasks, evaluation criteria.
Abstrakt PALA, Ondřej. Schopnosti překladačů programovacího jazyka Python. Brno, 2015. Diplomová práce. Mendelova univerzita v Brně. Diplomová práce hodnotí schopnosti vybraných překladačů programovacího jazyka Python. První část práce je zaměřena na programovací jazyk Python a princip činnosti překladačů. Druhá část je pak zaměřena na vytvoření testovacích úloh, stanovení hodnotících kritérií překladačů a otestování překladačů pomocí testovacích úloh. Klíčová slova Překladače, programovací jazyk Python, testovací úlohy, hodnotící kritéria.
Schopnosti překladačů programovacího jazyka Python
9
Obsah 1 Úvod a cíl práce
17
1.1
Úvod....................................................................................................................................... 17
1.2
Cíl práce................................................................................................................................ 17
2
Přehled literatury
19
3
Programovací jazyk Python
20
3.1
Historie programovacího jazyka Python ................................................................. 20
3.2
Verze programovacího jazyka Python ..................................................................... 20
3.2.1
Python 1.0 ................................................................................................................. 20
3.2.2
Python 2.0 ................................................................................................................. 21
3.2.3
Python 3.0 ................................................................................................................. 21
3.3 4
Vlastnosti programovacího jazyka Python ............................................................. 21
Chyby při vývoji aplikací 4.1
Lexikální chyby ................................................................................................................. 23
4.2
Syntaktické chyby ............................................................................................................ 23
4.2.1 4.3 4.4
Příklady syntaktických chyb při programování v jazyce Python ........ 24
Sémantické chyby............................................................................................................. 26
4.3.1
5
23
Příklady sémantických chyb při programování v jazyce Python ........ 27
Logické chyby .................................................................................................................... 28
Překladače 5.1
29
Druhy překladačů ............................................................................................................. 29
5.1.1
Kompilátor ................................................................................................................ 29
5.1.2
Interpret .................................................................................................................... 29
5.1.3
Hybridní překladače ............................................................................................. 30
5.2
Části překladače ................................................................................................................ 30
5.2.1
Lexikální analyzátor .............................................................................................. 30
5.2.2
Syntaktický analyzátor ......................................................................................... 31
5.2.3
Sémantický analyzátor ......................................................................................... 31
Schopnosti překladačů programovacího jazyka Python
5.2.4
Optimalizátor kódu ................................................................................................ 32
5.2.5
Generátor cílového kódu nebo interpret....................................................... 32
5.3 6
10
Kompatibilita překladačů .............................................................................................. 32
Překladače programovacího jazyka Python 6.1
33
Překladač Pyjamas ........................................................................................................... 33
6.1.1
Hlavní vlastnosti ..................................................................................................... 33
6.1.2
Hlavní výhody .......................................................................................................... 33
6.1.3
Princip činnosti ....................................................................................................... 33
6.2
Překladač Python .............................................................................................................. 34
6.2.1
Hlavní vlastnosti ..................................................................................................... 34
6.2.2
Hlavní výhody .......................................................................................................... 35
6.2.3
Princip činnosti ....................................................................................................... 35
6.3
Překladač Skulpt ............................................................................................................... 35
6.4
Překladač Jython ............................................................................................................... 36
6.4.1
Hlavní vlastnosti ..................................................................................................... 36
6.4.2
Hlavní výhody .......................................................................................................... 36
6.5
Překladač Ironpython ..................................................................................................... 36
6.5.1
Hlavní vlastnosti ..................................................................................................... 36
6.5.2
Hlavní výhody .......................................................................................................... 37
6.6
Překladač Stackless Python .......................................................................................... 37
6.6.1
Hlavní vlastnosti ..................................................................................................... 37
6.6.2
Hlavní výhody .......................................................................................................... 38
6.7
Překladač Shed Skin ........................................................................................................ 38
6.7.1
Hlavní vlastnosti ..................................................................................................... 38
6.7.2
Hlavní výhody .......................................................................................................... 38
6.8
Překladač Py2exe.............................................................................................................. 38
6.8.1
Hlavní vlastnosti ..................................................................................................... 38
6.8.2
Hlavní výhody .......................................................................................................... 39
6.9
Překladač Active Python ................................................................................................ 39
6.9.1
Hlavní vlastnosti ..................................................................................................... 39
6.9.2
Hlavní výhody .......................................................................................................... 40
Schopnosti překladačů programovacího jazyka Python
7
Kritéria pro hodnocení překladačů jazyka Python 7.1
11
41
Obtížnost instalace a odinstalace ............................................................................... 41
7.1.1
Instalace ..................................................................................................................... 41
7.1.2
Odinstalace ............................................................................................................... 41
7.2
Kompatibilita s operačními systémy ........................................................................ 41
7.3
Možnost zpětné vazby k uživateli .............................................................................. 42
7.4 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu ........................................................................................................................................... 42 7.5
7.5.1
Časová složitost překladu ................................................................................... 43
7.5.2
Prostorová složitost překladu ........................................................................... 44
7.6 8
Časová a prostorová složitost překladu .................................................................. 43
Úroveň dokumentace...................................................................................................... 46
Testovací úlohy 8.1
Základní matematické operace ................................................................................... 47
8.1.1 8.2
47
Verze s chybami ...................................................................................................... 47
Práce s cykly ....................................................................................................................... 48
8.2.1
Cyklus for................................................................................................................... 49
8.2.2
Cyklus for – verze s chybami ............................................................................. 49
8.2.3
Cyklus while ............................................................................................................. 50
8.2.4
Cyklus while – verze s chybami ........................................................................ 50
8.3
Práce s řetězci .................................................................................................................... 51
8.3.1
Přístup k znakům řetězce.................................................................................... 51
8.3.2
Přístup k znakům řetězce – verze s chybami .............................................. 51
8.3.3
Formátování výstupu............................................................................................ 52
8.3.4
Formátování výstupu – verze s chybami ...................................................... 53
8.3.5
Funkce pro práci s řetězci ................................................................................... 53
8.3.6
Funkce pro práci s řetězci – verze s chybami .............................................. 54
8.4
Práce s regulárními výrazy ........................................................................................... 54
8.4.1 8.5
Verze s chybami ...................................................................................................... 55
Práce se soubory ............................................................................................................... 56
8.5.1
Čtení ze souborů ..................................................................................................... 56
Schopnosti překladačů programovacího jazyka Python
8.5.2
Čtení ze souborů – verze s chybami ................................................................ 56
8.5.3
Zápis do souboru .................................................................................................... 57
8.5.4
Zápis do souboru – verze s chybami ............................................................... 58
8.6
Práce s XML ......................................................................................................................... 58
8.6.1
Tvorba XML souborů............................................................................................. 58
8.6.2
Tvorba XML souborů – verze s chybami ....................................................... 59
8.6.3
Čtení XML souborů................................................................................................. 60
8.6.4
Čtení XML souborů – verze s chybami ........................................................... 61
8.7
Webové služby ................................................................................................................... 63
8.7.1
Dostupnost HTML stránky .................................................................................. 63
8.7.2
Dostupnost HTML stránky – verze s chybami ............................................. 64
8.7.3
Vrácení dat HTML stránky .................................................................................. 65
8.7.4
Vrácení dat HTML stránky – verze s chybami ............................................. 65
8.8
9
12
Definice tříd ........................................................................................................................ 65
8.8.1
Dědičnost ................................................................................................................... 65
8.8.2
Dědičnost – verze s chybami .............................................................................. 66
8.8.3
Definice třídy a vytvoření instance této třídy.............................................. 68
8.8.4
Definice třídy a vytvoření instance této třídy – verze s chybami ........ 69
Průběh hodnocení překladačů
10 Výsledky
73 75
10.1 Překladač Pyjamas ........................................................................................................... 75 10.1.1
Obtížnost instalace................................................................................................. 75
10.1.2
Obtížnost odinstalace ........................................................................................... 75
10.1.3
Kompatibilita s operačními systémy .............................................................. 76
10.1.4
Možnosti zpětné vazby k uživateli ................................................................... 76
10.1.5 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu ...................................................................................................................................... 76 10.1.6
Časová náročnost překladu ................................................................................ 76
10.1.7
Prostorová náročnost překladu ........................................................................ 77
10.1.8
Úroveň dokumentace ............................................................................................ 78
10.1.9
Hodnocení překladače Pyjamas ........................................................................ 78
Schopnosti překladačů programovacího jazyka Python
13
10.2 Překladač Python ............................................................................................................. 78 10.2.1
Obtížnost instalace ................................................................................................ 78
10.2.2
Obtížnost odinstalace ........................................................................................... 79
10.2.3
Kompatibilita s operačními systémy .............................................................. 79
10.2.4
Možnosti zpětné vazby k uživateli ................................................................... 79
10.2.5 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu ...................................................................................................................................... 81 10.2.6
Časová náročnost překladu ................................................................................ 82
10.2.7
Prostorová náročnost překladu ........................................................................ 83
10.2.8
Úroveň dokumentace............................................................................................ 83
10.2.9
Hodnocení překladače Python .......................................................................... 84
10.3 Překladač Skulpt ............................................................................................................... 84 10.3.1
Obtížnost instalace ................................................................................................ 84
10.3.2
Obtížnost odinstalace ........................................................................................... 84
10.3.3
Kompatibilita s operačními systémy .............................................................. 84
10.3.4
Možnosti zpětné vazby k uživateli ................................................................... 84
10.3.5 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu ...................................................................................................................................... 85 10.3.6
Časová náročnost překladu ................................................................................ 86
10.3.7
Prostorová náročnost překladu ........................................................................ 87
10.3.8
Úroveň dokumentace............................................................................................ 87
10.3.9
Hodnocení překladače Skulpt............................................................................ 87
10.4 Překladač Jython ............................................................................................................... 88 10.4.1
Obtížnost instalace ................................................................................................ 88
10.4.2
Obtížnost odinstalace ........................................................................................... 89
10.4.3
Kompatibilita s operačními systémy .............................................................. 89
10.4.4
Možnosti zpětné vazby k uživateli ................................................................... 89
10.4.5 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu ...................................................................................................................................... 90 10.4.6
Časová náročnost překladu ................................................................................ 90
10.4.7
Prostorová náročnost překladu ........................................................................ 91
10.4.8
Úroveň dokumentace............................................................................................ 91
Schopnosti překladačů programovacího jazyka Python
10.4.9
14
Hodnocení překladače Jython............................................................................ 91
10.5 Překladač Ironpython ..................................................................................................... 92 10.5.1
Obtížnost instalace................................................................................................. 92
10.5.2
Obtížnost odinstalace ........................................................................................... 92
10.5.3
Kompatibilita s operačními systémy .............................................................. 92
10.5.4
Možnosti zpětné vazby k uživateli ................................................................... 92
10.5.5 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu ...................................................................................................................................... 93 10.5.6
Časová náročnost překladu ................................................................................ 94
10.5.7
Prostorová náročnost překladu ........................................................................ 94
10.5.8
Úroveň dokumentace ............................................................................................ 94
10.5.9
Hodnocení překladače Ironpython .................................................................. 95
10.6 Překladač Stackless Python .......................................................................................... 95 10.6.1
Obtížnost instalace................................................................................................. 95
10.6.2
Obtížnost odinstalace ........................................................................................... 95
10.6.3
Kompatibilita s operačními systémy .............................................................. 96
10.6.4
Možnosti zpětné vazby k uživateli ................................................................... 96
10.6.5 Reakce na nalezení chyby v lexikální, syntaktické a sémantické fázi překladu ...................................................................................................................................... 96 10.6.6
Časová náročnost překladu ................................................................................ 97
10.6.7
Prostorová náročnost překladu ........................................................................ 97
10.6.8
Úroveň dokumentace ............................................................................................ 98
10.6.9
Hodnocení překladače Stackless Python ....................................................... 98
10.7 Překladač Shed Skin ........................................................................................................ 98 10.7.1
Obtížnost instalace................................................................................................. 98
10.7.2
Obtížnost odinstalace ........................................................................................... 98
10.7.3
Kompatibilita s operačními systémy .............................................................. 98
10.7.4
Možnosti zpětné vazby k uživateli ................................................................... 99
10.7.5 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu ...................................................................................................................................... 99 10.7.6
Časová náročnost překladu ..............................................................................100
10.7.7
Prostorová náročnost překladu ......................................................................100
Schopnosti překladačů programovacího jazyka Python
15
10.7.8
Úroveň dokumentace.......................................................................................... 101
10.7.9
Hodnocení překladače Shed Skin ................................................................... 101
10.8 Překladač Py2exe ........................................................................................................... 101 10.8.1
Obtížnost instalace .............................................................................................. 101
10.8.2
Obtížnost odinstalace ......................................................................................... 102
10.8.3
Kompatibilita s operačními systémy ............................................................ 102
10.8.4
Možnosti zpětné vazby k uživateli ................................................................. 102
10.8.5 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu .................................................................................................................................... 102 10.8.6
Časová náročnost překladu .............................................................................. 103
10.8.7
Prostorová náročnost překladu ...................................................................... 103
10.8.8
Úroveň dokumentace.......................................................................................... 103
10.8.9
Hodnocení překladače Py2exe ........................................................................ 104
10.9 Překladač Active Python .............................................................................................. 104 10.9.1
Obtížnost instalace .............................................................................................. 104
10.9.2
Obtížnost odinstalace ......................................................................................... 104
10.9.3
Kompatibilita s operačními systémy ............................................................ 105
10.9.4
Možnost zpětné vazby k uživateli .................................................................. 105
10.9.5 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu .................................................................................................................................... 106 10.9.6
Časová náročnost překladu .............................................................................. 106
10.9.7
Prostorová náročnost překladu ...................................................................... 107
10.9.8
Úroveň dokumentace.......................................................................................... 108
10.9.9
Hodnocení překladače Active Python .......................................................... 108
11 Závěr
109
12 Literatura
116
Schopnosti překladačů programovacího jazyka Python
16
Schopnosti překladačů programovacího jazyka Python
17
1 Úvod a cíl práce 1.1 Úvod Existují dva základní přístupy k programování a to strukturovaný a objektově orientovaný. V současné době je právě nejrozšířenějším způsobem objektově orientované programování. Takto orientované jsou např. jazyky C#, Java, C++ a také právě jazyk Python, kterého se tato práce týká. Jazyk Python je tedy, jak už bylo výše řečeno objektově orientovaný, to znamená, že využívá objektů. Každá reálná skutečnost je reprezentována objektem, který zahrnuje atributy (vlastnosti) a metody pro práci s tímto objektem. Procesor počítače nerozumí přímo příkazům jazyka Python, nebo kterýmkoliv jiným příkazům jiného tzv. vyššího programovacího jazyka, ale příkazům ve strojovém kódu. Do tohoto kódu je vyšší programovací jazyk překládán pomocí překladačů (kompilátorů). Ke každému jazyku existuje více různých volně dostupných překladačů a je velmi těžké posoudit, který je lepší. Různé překladače totiž reagují různě např. na syntaktické chyby (tím jsou myšleny informace o konkrétních chybách v syntaxi – např. oznámení, kde se daná chyby nachází, zda ji vůbec překladač detekuje apod.), mají jinak kvalitně zpracovanou dokumentaci a různě obtížně se instalují, odinstalují a konfigurují.
1.2 Cíl práce V současné době patří mezi nejrozšířenější programovací jazyky právě ty, které jsou objektově orientované. Mezi tento druh programovacích jazyků patří i jazyk Python. Tato práce je zaměřena na různé volně dostupné překladače tohoto programovacího jazyka. V první části se budu zabývat programovacím jazykem Python, jeho specifickými vlastnostmi, verzemi apod. Dále bude pojednáno o překladačích obecně. Tím jsou myšleny druhy překladačů a princip jejich činnosti. Druhá část diplomové práce se pak zabývá vybranými překladači programovacího jazyka Python, dále stanovením kritérií pro hodnocení vybraných překladačů tohoto programovacího jazyka, popisu těchto kritérií a vytvoření sady testovacích úloh, zahrnujících základní matematické operace, cykly, práci s řetězci, práci s regulárními výrazy, se soubory, práci s webovými službami a definici tříd, pomocí kterých pak budou vybraného překladače programovacího jazyka Python otestovány. Výsledky tohoto testování budou pak vyhodnoceny a přehledně interpretovány. Tato práce poskytuje detailní podklady pro další následné testování schopností překladačů, včetně testovacích úloh, které mohou k tomuto testování být použity v případě výše uvedeného programovacího jazyka.
Schopnosti překladačů programovacího jazyka Python
18
Cílem této práce je tedy prozkoumat dané překladače jazyka Python z hlediska daných hodnotících kritérií, stanovit způsob jejich hodnocení z hlediska těchto kritérií a provést samotné ohodnocení těchto překladačů.
Schopnosti překladačů programovacího jazyka Python
19
2 Přehled literatury Vzhledem k rychlému a neustálému rozvoji oblasti informačních technologií dochází i k neustálému publikování knih a různých materiálů týkajících se této oblasti. Jinak tomu není ani v případě tématu, kterým se zabývá tato práce. Existuje mnoho různě kvalitních materiálů týkajících se problematiky překladačů a programovacích jazyků. Snad nejznámějším a nejkvalitnějším počinem je kniha Compilers: Principles, Techniques, and Tools (Aho, 2007) od Alfreda V. Aho a kolektivu. V knize je podrobně rozebrána problematika programovacích jazyků a hlavně problematika překladačů, konkrétně tedy jak jednotlivé části překladačů (syntaktický, sémantický analyzátor), tak jednotlivé fáze překladu. V oblasti českých zdrojů je velmi zajímavou studijní oporou materiál Tvorba překladačů (Vavrečková, 2008) pocházející ze Slezské univerzity v Opavě, která se velmi podrobně a srozumitelně zabývá vlastnostmi překladačů, jejich druhy a hlavně jednotlivými fázemi překladu – lexikální, syntaktickou a sémantickou fází překladu. Pokud se zaměříme konkrétně na téma týkající se této práce, tj. na programovací jazyk Python, tak za zmínku stojí zejména kniha Dive Into Python 3(Pilgrim, 2009)od Marka Pilgrima, jejíž český překlad je volně dostupný na webových stránkách. Jedná se o kvalitního průvodce celým tímto programovacím jazykem. Autor přehledně a srozumitelně vysvětluje jednotlivé části jazyka Python od jeho základních prvků, jako jsou deklarace proměnných, základní matematické operace, definice podmínek, cykly, přes náročnější témata jako jsou práce se vstupními soubory a řetězci, až po využívání webových služeb, zpracování XML souborů a problematiku týkající se objektově orientovaného programování. Další neméně kvalitní knihou, zabývající se programovacím jazykem Python je Python 3: výukový kurz (Summerfield, 2010) od Marca Summerfielda, která opět pojednává o všech oblastech jazyka Python, stejně jako kniha předchozí. Pokud se ale zaměříme konkrétně na oblast překladačů jazyka Python, musíme se spokojit pouze s internetovými zdroji. Tyto zdroje se věnují jednotlivým překladačům jazyka Python, ale pouze na úrovni popisu jeho vlastností, nikoliv na úrovni, na které se touto tématikou zabývá tato diplomová práce. Zejména je tím myšleno to, že doposud nikdo jednotlivé překladače programovacího jazyka Python neporovnal podle přesně stanovených kritérií. Jedinými pracemi, které se podobnou problematikou zabývají, jsou diplomové práce Schopnosti překladačů vybraných strukturovaných jazyků (Zerdaloglu, 2012) a Schopnosti překladačů vybraných objektově orientovaných jazyků (Ventruba, 2011). První z těchto prací se, jak už název vypovídá, zabývá srovnáváním překladačů strukturovaných programovacích jazyků, konkrétně tedy jazyka Pascal a jazyka C. Druhá z těchto prací se zabývá srovnáváním překladačů jazyků C++, C# a Java.
Schopnosti překladačů programovacího jazyka Python
20
3 Programovací jazyk Python 3.1 Historie programovacího jazyka Python Počátky jazyka Python jsou datovány do roku 1980. Koncept tohoto programovacího jazyka byl vytvořen již v roce 1980. S tvorbou tohoto jazyka začal pan Guido van Rossum, původem z Holandska, ale až o 9 let později, tj. v roce 1989. Jazyk Python byl vyvíjen jako nástupce programovacího jazyka ABC, konkrétně pro operační systém Amoeba. První verze jazyka Python byla uvedena v lednu roku 1994. Zřejmě nejvýznamnějším milníkem v historii programovacího jazyka Python bylo uvedení jeho druhé verze - Pythonu 2.0. Stalo se tak 16. října roku 2000. Hlavními vlastnostmi této nové verze jazyka byl úplný Garbage collection a podpora unicodu. Poté v roce 2008 přichází na svět třetí verze tohoto jazyka – Python 3.0, která přináší další vylepšení a její hlavní rysy jsou zpětně kompatibilní se staršími verzemi Pythonu 2.6 a Pythonu 2.7 (History of Python, 2015).
Obrázek 1: Původní logo programovacího jazyka Python, zdroj: en.wikipedia.org/wiki/History_of_Python
Obrázek 2: Aktuální logo programovacího jazyka Python, zdroj: www.python.org
3.2 Verze programovacího jazyka Python 3.2.1
Python 1.0
Jak už bylo řečeno výše, první verze jazyka Python – Python 1.0 spatřila světlo světa v lednu roku 1994. Mezi nejvýznamnější znaky této verze Pythonu patřilo: Možnost využití lambda funkcí – lambda Možnost využití datové struktury map pro ukládání dat Možnost snadného filtrování dat pomocí filter
Schopnosti překladačů programovacího jazyka Python
21
Samozřejmě, že Python 1.0 nebyla poslední verze tohoto jazyka, po několika letech byla vydána aktualizace první verze – Python 1.2 a poté i Python 1.4, který přinesl velkou novinku – vestavěnou podporu komplexních čísel (History of Python, 2015).
3.2.2
Python 2.0
Verze jazyka Python Python 2.0 přináší možnost využít dynamických seznamů (polí), tzv. listů. Tvůrci Pythonu se inspirovali u jazyků SETL a Haskell. S další aktualizací Pythonu, tj. s verzí Python 2.1 přichází hlavně změna v licencování. Licence držící práva na jazyk Python byla pojmenována Python Software Foundation a jejím majetkem se staly veškeré kódy, dokumentace a specifikace jazyka Python. Další z aktualizací jazyka Python, tj. verze Python 2.2 se stala důležitým milníkem objektově orientovaného programování v programovacím jazyce Python. Byly totiž sjednoceny Pythonovské datové typy, které jsou napsány v programovacím jazyce C se třídami, které jsou napsány v jazyce Python a tak se programovací jazyk Python stal i objektově orientovaným (History of Python, 2015).
3.2.3
Python 3.0
Python 3.0, někdy také nazývaný jako Python 3000 nebo Py3K, přináší zejména vylepšení nedostatků, které měli předešlé verze. Konkrétně se jedná o fakt, že v předešlých verzích existovalo např. více možností jak řešit jeden konkrétní problém a tuto duplicitu právě Python 3.0 odstraňuje. Tato verze jazyka se snaží, aby každý problém šel řešit jedním konkrétním způsobem. I přes tuto skutečnost ale zůstává programovací jazyk Python více-paradigmatický, tím je myšleno, že podporuje řešení problémů objektovým, strukturovaným a funkcionálním programovacím paradigmatem (History of Python, 2015).
3.3 Vlastnosti programovacího jazyka Python Programovací jazyk Python je interpretovaným jazykem, který je zejména objektově orientovaný, ale jak už bylo výše uvedeno, podporuje i další programovací paradigmata a to strukturované a funkcionální. Jedná se o programovací jazyk kompatibilní se všemi nejznámějšími a nejpoužívanějšími operačními systémy, konkrétně tedy s operačními systémy Windows, Linux a Mac OS. Další velkou předností tohoto jazyka je, že v porovnání s jinými programovacími jazyky je úspornější na kód. Program v jazyce Python je obecně kratší, než programy v jiných programovacích jazycích. Velmi zajímavý je i interaktivní Python shell, který je dodáván společně s oficiálním překladačem tohoto jazyka. Tento shell umožňuje spouštět příkazy jazyka Python přímo v tomto příkazovém řádku. Pro lepší představu uvedu tento příklad: napíšeme-li do interaktivního Pythonovského shellu
Schopnosti překladačů programovacího jazyka Python
22
například přiřazovací příkaz, ve kterém přiřadíme do proměnné a hodnotu 5 (a=5) a poté zadáme do příkazového řádku název proměnné, tj. a, vypíše nám interaktivní příkazový řádek její hodnotu (Python, 2015). Pokud se zaměříme na syntaxi jazyka Python, tak můžeme narazit na několik zajímavých věcí: Není nutné deklarovat proměnné, datový typ proměnné je určen až ve chvíli, kdy je do proměnné přiřazena nějaká hodnota – podle této hodnoty, je pak určen datový typ. Jazyk Python má silnou typovou kontrolu, tato kontrola ale není prováděna při překladu, ale až za běhu daného programu. Při deklaraci funkcí, podmínek if a cyklů for nebo while, využívá Python pro identifikaci bloku kódu, který bude prováděn jak už ve funkci, podmínce nebo v cyklech odsazení. Jednoduše řečeno kód, který je pod definicí např. funkce odsazen, bude prováděn právě v této funkci. Kód funkce tedy končí prvním řádkem kódu, který není odsazený. Velikost odsazení je standardně 4 mezery, odsazení ale nemusí mít vždy tuto velikost, ale je důležité velikost tohoto odsazení dodržovat stejnou v celém kódu. Cyklus while může mít i svůj blok else, který je známý především v souvislosti s podmínkou if. Pokud pak cyklus doběhne bez přerušení, tak je proveden výraz za klíčovým slovem else (Python profesionálně: úvod, 2012). Je možné využívat takzvaných lambda funkcí. Používají se zejména v případech, kdy potřebujeme deklarovat funkci ve funkci, nebo kdy potřebujeme deklarovat nějakou velmi jednoduchou funkci. Příklad takovéto funkce můžete vidět níže, konkrétně se jedná o lambda funkci vracející dvojnásobek zadané hodnoty: d = lambda x: x*2 d(5) Funkci poté předáme jako parametr číslo, která chceme zdvojnásobit (Lambda, filter, reduce and map, 2011). V poslední řadě se musíme zaměřit na asi největší výhodu a přednost programovacího jazyka Python a to na skutečnost, že existuje mnoho překladačů, pro tento jazyk, které umožňují např. generovat spustitelné soubory (exe soubory) ze skriptů jazyka Python, nebo vyvíjet pomocí jazyka Python v Microsoft Visual Studiu. O těchto i dalších překladačích bude pojednáno v dalších částech této práce.
Schopnosti překladačů programovacího jazyka Python
23
4 Chyby při vývoji aplikací Tak jako v každé jiné lidské činnosti, tak i při vývoji aplikací dochází k různým chybám, jelikož člověk není neomylný. Rozlišujeme čtyři základní druhy chyb, které mohou při překladu programu nastat: Lexikální chyby Syntaktické chyby Sémantické chyby Logické chyby O všech těchto chybách bude podrobněji pojednáno níže.
4.1 Lexikální chyby Tento druh chyb bývá odhalen při samotném počátku překladu, jelikož první částí překladu zdrojového kódu je jeho lexikální analýza, kdy je zdrojový kód překládán na posloupnost atomických symbolů, které jednoznačně identifikují každou část zdrojového kódu. Tento druh chyby tedy souvisí s tím, že lexikální analyzátor při překladu nenalezne pro danou část zdrojového kódu atomický symbol. Typicky se může jedna o situaci, kdy je například špatně zadán název datového typu nebo použit špatný symbol pro určitou operaci.
4.2 Syntaktické chyby Jak už název těchto chyb napovídá, k jejich odhalení při překladu programu dochází ve fázi syntaktické analýzy. Při syntaktické analýze je kontrolována syntaktická správnost napsaného kódu (programu). Takovým příkladem základní syntaktické chyby u většiny programovacích jazyků může být zapomenutí středníku, kterým oddělujeme od sebe příkazy. V případě programovacího jazyka Python, kterému je tato práce věnována, se pak může jednat o nevložení konce řádku za daným příkazem, jelikož oddělovačem příkazů v tomto jazyce je právě znak konce řádku, tzn. na každém řádku je uveden pouze jeden příkaz.
Schopnosti překladačů programovacího jazyka Python
24
4.2.1 Příklady syntaktických chyb při programování v jazyce Python
Neuvedení znaku konce řádku za příkazem – při programování v jazyce Python jsou jednotlivé příkazy od sebe oddělovány znakem konce řádku, tzn. na každém řádku se musí nacházet pouze jeden příkaz. Níže je uveden příklad této syntaktické chyby. a = 5 b = 6 Syntakticky správně jsou tyto dva příkazy zapsány takto: a = 5 b = 6
Neodsazení bloku, který má být součástí cyklu nebo funkce (metody) – u většiny programovacích jazyků jsou bloky (příkazy, které jsou součástí cyklů, podmínek nebo metod) uzavírány do složených závorek. U programovacího jazyka Python je tomu jinak. Příkazy, které jsou součástí cyklů, podmínek, případně metod, musí být odsazeny. Podle tohoto odsazení pak překladač jazyka Python pozná, které příkazy jsou součástí nadřazeného cyklu, podmínky nebo metody. Velikost tohoto odsazení musí být v celém programu stejná. Níže je opět uveden příklad této chyby. if a > 5: print a Správně jsou tyto příkazy zapsány zde: If a > 5: print a
Neuvedení dvojtečky za definicí cyklu, podmínky, funkce (metody) a třídy – při definici cyklů, podmínek, funkcí (metod) a tříd je třeba blok, který bude součástí těchto objektů, uvodit dvojtečkou, tzn. že za příkazy, které definují cyklus, podmínku, funkce případně třídu je nutné uvést dvojtečku. Pro lepší pochopení je opět níže uveden příklad této chyby a poté správný zápis. class Auto def __init__(v) self.vaha = v
Schopnosti překladačů programovacího jazyka Python
25
Správně je tento blok příkazů zapsán takto: class Auto: fef __init__(v): self.vaha = v
Neuvedení klíčového slova def před definicí metody (funkce) –každá funkce, případně metoda určité třídy musí být uvozena klíčovým slovem def za kterým musí následovat jména této funkce (metody). Níže uvedený zápis metody je chybný. pozdrav (): print “ahoj“ Správný zápis této metody vypadá takto: def pozdrav(): print “ahoj“
Neuvedení kulatých závorek za jménem funkce (metody) – tak jako u většiny programovacích jazyků, tak i u programovacího jazyka Python, musí být za definicí funkce (metody), tzn. za názvem metody, kterému předchází klíčové slovo def, uvedena dvojice kulatých závorek – (). Příklad této časté syntaktické chyby můžete vidět níže. def pozdrav: print “Ahoj“ Naopak správný zápis této funkce můžete vidět zde: def pozdrav(): print “Ahoj“
Uvedení špatného klíčového slova – nejedná se o nic jiného, než o špatný zápis určitého klíčového slova. Nejčastějšími zdroji těchto chyb jsou „překlepy“. Příklad chyby, která vznikla špatným zapsáním klíčového slova, můžete vidět níže. printl “Ahoj“
Schopnosti překladačů programovacího jazyka Python
26
Správně je tento příkaz zapsán takto: print “Ahoj“
Použití špatného logického operátoru – jedná se zejména o špatné použití operátoru s významem „je rovno“, „je větší nebo rovno“, „je menší nebo rovno“ a „je různo“. Pro lepší názornost jsou všechny tyto chyby uvedeny pod tímto textem. a = 5 if a = 5: print “Ano“ Správně je tento kus kódu zapsán zde: a = 5 if a == 5: print “Ano“
Dále se zaměříme ne operátor „větší nebo rovno“, případně „menší nebo rovno“. U tohoto druhu operátoru záleží na pořadí jednotlivých operátorů. Chyba nastane, když operátor „větší nebo rovno“ zapíšeme takto: a = 5 if a => 5: print "Ok" Správně je tento operátor pak zapsán takto: a = 5 if a >= 5: print "Ok" Obecně se třeba psát operátory v tom pořadí v jakém je vyslovujeme, tj. v případě operátoru „větší nebo rovno“ napřed zapsat znak „je větší“ a až poté znak rovno.
4.3 Sémantické chyby Sémantické chyby nesouvisí nijak se syntaxí, jako chyby předešlé, tj. chyby syntaktické, ale přímo s použitím určitých příkazů programovacího jazyka. Na tyto chyby je programátor upozorněn sémantickým analyzátorem při sémantické fázi překladu zdrojového kódu. Konkrétně se například jedná o chyby kdy se progra-
Schopnosti překladačů programovacího jazyka Python
27
mátor snaží sčítat řetězcovou a číselnou proměnnou nebo přistupovat k položce v poli přes index, kterým není indexována žádná z položek tohoto pole.
4.3.1 Příklady sémantických chyb při programování v jazyce Python
Použití nedefinované proměnné – každá použitá proměnná musí být napřed inicializována, tzn. musí být do ní přiřazena určitá hodnota. Dále je třeba si dávat pozor na to, kde je daná proměnná deklarována. Pokud deklaruji určitou proměnnou ve skriptu, pak se jedná o globální proměnou platnou v celém skriptu. Naopak deklaruji-li proměnnou (klidně i stejného jména, jako onu globální) v určitém cyklu, podmínce případně metodě (funkci), pak je tato proměnná lokální a její platnost spadá do daného bloku kódu, tzn. do daného cyklu, podmínky nebo metody. Příklad této chyby je uveden níže pod tímto textem. def vrat_a(): print a vrat_a() Správně je tato funkce napsána zde: def vrat_a(): a = 4 print a vrat_a()
Neuvedení potřebného počtu parametrů určité funkce – každá funkce má definovaný počet svých parametrů, neuvedením potřebného počtu argumentů skončí překlad takovéhoto programu sémantickou chybou. Jednou takou chybu můžete vidět níže. a = “ahoj“ print len() Správně je tento kousek kódu uveden zde: a = “ahoj“ print len(a)
Přístup na položku v poli přes nesprávný index – v případě, že přistupujeme v poli na položku, jejíž index je větší než počet prvků pole. Děje se tomu tak například ve zdrojovém kódu níže:
Schopnosti překladačů programovacího jazyka Python
28
a = [1,2,3] print (a[4]) Jelikož výše uvedené pole obsahuje tři prvky, správný přístup k prvkům tohoto pole se provede přes index, který nabývá hodnot od nuly do dvou (prvky pole jsou indexovány od nuly). Příklad kódu bez chyby je uveden zde: a = [1, 2, 3] print a[2]
4.4 Logické chyby Tento druh chyby nemusí být vůbec překladačem daného jazyka identifikován, jelikož překladač nedokáže rozpoznat chybu v logice napsaného programu. Jedná se tedy zejména o chyby vznikající ve chvíli, kdy programátor nedostatečně porozumí zadání programu a tato skutečnost pak vede k tomu, že výsledný program, ač je úspěšně překladačem přeložen, nedělá to, co by měl dělat. Tento druh chyby může tedy být eliminován pouze důkladným prostudováním si zadání a pochopením, co má daný program dělat.
Schopnosti překladačů programovacího jazyka Python
29
5 Překladače Překladač je obecně program, který provádí zobrazení zdrojového programu napsaného ve zdrojovém jazyce do cílového programu v cílovém jazyce a to tak, že cílový program má stejný význam jako zdrojový program. Obecně se tedy jedná o zobrazení programu, který je napsán v některém z vyšších programovacích jazyků do strojového kódu (assembleru), tedy to jazyka, kterému rozumí procesor počítače (Vavrečková, 2008).
5.1 Druhy překladačů 5.1.1
Kompilátor
Kompilátor, nebo jinak generační překladač , provádí překlad některého z vyšších programovacích jazyků, jako je Java, C#, C++ apod. do strojového kódu (assembleru, jinak nazývaného jako jazyk symbolických adres). U kompilátorů je tedy požadovaný program přeložen jako jeden celek (ne po částech, tak jako u interpretu). Výhodou tohoto druhu překladače je rychlost přeloženého programu – výsledný spustitelný soubor pracuje ve většině případů velmi rychle, oproti tomu rychlost překladu u překladačů tohoto druhu je menší, než u překladačů druhu interpret. Jednou z větších nevýhod kompilátorů je nepřenositelnost výsledku překladu mezi různými druhy operačních systémů. Mezi nejznámější programovací jazyky využívající kompilovaný překlad jsou Delphi, Pascal, C nebo C++ (Vavrečková, 2008).
Obrázek 3: Princip činnosti kompilátoru, zdroj: www.cs.uaf.edu/~cs631/node4.html
5.1.2
Interpret
Interpret provádí překlad, na rozdíl od kompilátoru, po částech. Po částech interpretuje zdrojový program a vytváří v paměti počítače určitou reprezentaci daného vstupního zdrojového programu. Překlad programu pomocí interpretačního překladače tudíž probíhá rychleji, než u kompilovaného překladu, jelikož jsou po-
Schopnosti překladačů programovacího jazyka Python
30
stupně zpracovávány jednotlivé příkazy zdrojového programu a ty jsou pak interpretovány a provedeny. Určitou nevýhodou je, že při každém spuštění je nutné provádět překlad zdrojového programu znovu, což může být také určitou nevýhodou a důvodem, proč některé vyšší programovací jazyky používají právě kompilační překladače. Pokud bychom měli zmínit hlavní výhodou tohoto druhu překladače, pak je to určitě přenositelnost kódu mezi jednotlivými platformami (Windows, Linux a Mac OS). Nejznámějšími programovacími jazyky, které využívají interpretační překladač je právě Python, dále PHP, Perl, Ruby, JavaScript a samozřejmě také příkazové řádky operačních systémů Windows a Linux (Vavrečková, 2008).
Obrázek 4: Princip činnosti interpretu, zdroj: Vavrečková, 2008
5.1.3
Hybridní překladače
Jedná se o typ překladačů, které můžeme zařadit někam mezi kompilátory a interprety. Jejich princip činnosti spočívá v tom, že jedna část těchto překladačů generuje tzv. mezikód, který není nijak závislý na operačním systému a tento mezikód je pak interpretován druhou částí překladače, která souvisí s operačním systémem, na kterém překlad probíhá. Typickým programovacím jazykem, který využívá tento druh překladačů je jazyk JAVA (mezikód tohoto jazyka se nazývá bytekód) a jazyky využívající technologii .NET (C#, Visual Basic.NET) (Vavrečková, 2008).
5.2 Části překladače 5.2.1
Lexikální analyzátor
Lexikální analyzátor převezme ze svého vstupu zdrojový program (program, které má být překladačem přeložen) a převádí jej do takové podoby, které poté
Schopnosti překladačů programovacího jazyka Python
31
rozumí i ostatní části překladače. Zdrojový program je tedy převeden na posloupnost atomických symbolů (Vavrečková, 2008). Níže je uveden příklad. int i = 15 // vstup
<semicolon> // výstup Vstup (zdrojový program) je postupně převeden na posloupnost atomických symbolů, které identifikují každou část vstupního zdrojového programu. Při lexikální analýze jsou ignorovány bílé znaky a komentáře a není vůbec kontrolováno, zda dané konstrukce mají nějaký smysl. Tato část překladače bývá realizována pomocí stavového automatu (Konstrukce překladače, 2011).
5.2.2
Syntaktický analyzátor
Jedná se o nejdůležitější fázi překladu. Syntaktický analyzátor si bere posloupnosti atomických symbolů, které byly vygenerovány lexikálním analyzátorem a z nich vytváří strukturu překládaného programu - příkazy, bloky příkazů (Vavrečková, 2008). Tyto symboly jsou přiřazovány k sobě a vytváří tak příkazy, které mají být provedeny a při tom kontroluje jejich správnou syntaxi – to zda odpovídají pravidlům, které jsou definovaná v gramatice daného jazyka (Konstrukce překladače, 2011). Tyto pravidla definují, v jakém pořadí se mohou jednotlivé identifikátory objevit v daném příkaze nebo jaké operace jsou přípustné.
5.2.3
Sémantický analyzátor
Při této analýza je vytvořena tabulka symbolů, která obsahuje všechny objekty, které byly při sémantické analýze nalezeny. Obsahuje tedy proměnné, konstanty, funkce, procedury, názvy tříd apod. O každém objektu jsou pak v tabulce uvedeny podrobné informace, jako je např. datový typ, název identifikátoru, adresa v paměti, nebo také zda už byl daný objekt použit apod. Pomocí této tabulky je poté přiřazován význam jednotlivým příkazům a blokům kódu, které byly výstupem syntaktické analýzy. V případě, že je např. prováděna sémantická analýza příkazu, ve kterém jsou sčítány dvě proměnné, je napřed provedena kontrola datového typu obou proměnných – zda je možná danou operaci s těmito datovými typy vykonat a poté je teprve provedena daná operace. Pokud datové typy nesouhlasí, může sémantický analyzátor provést přetypování, ale např. v případě provádění matematických operací s proměnnými číselného a řetězcového datového typu je u mnohých programovacích jazyků zobrazena chyba při sémantické fázi překladu (Vavrečková, 2008).
Schopnosti překladačů programovacího jazyka Python
5.2.4
32
Optimalizátor kódu
Do této fáze překladače obvykle vstupuje kód v tzv. intermediálním tvaru. Jedná se o program, který je svým tvarem už velmi podobný cílovému programu, ale je lépe přizpůsobitelný různé optimalizaci. Obvykle je to tedy program, který je velmi podobný assembleru nebo dynamický seznam obsahující jako položky derivační stromy jednotlivých příkazů. Optimalizátor kódu optimalizuje příkazy tak, že např. kontroluje, zda není třeba do některé z proměnných v cyklu přiřazována ta stejná hodnota vícekrát apod. Jednoduše řečeno, optimalizuje kód tak, aby bylo používáno co nejméně pomocných proměnných (Vavrečková, 2008).
5.2.5
Generátor cílového kódu nebo interpret
Jedná se o poslední část překladače, která generuje výsledný kód v jazyce symbolických adres (assembler), případně v jazyce sestavujícího programu (pak se jedná o interpretační překlad) nebo ve strojovém kódu (např. exe a dll v operačním systému Windows) (Vavrečková, 2008).
5.3 Kompatibilita překladačů V případě, že bychom chtěli vytvořit překladač určitého programovacího jazyka tak, aby byl kompatibilní se třemi základními nejrozšířenějšími operačními systémy na světě – Windows, Linux a MAC OS, velmi záleží na části překladače, která optimalizuje kód a generuje cílový program . Jinými slovy, části překladače jako je lexikální, syntaktický a sémantický analyzátor jsou ve většině případů nezávislé na cílovém operačním systému. Takže v případě, kdy potřebujeme překladače, který vygeneruje cílový program kompatibilní se všemi výše uvedenými operačními systémy, musí být vytvořeny tři různé části pro optimalizaci kódu a generování cílového programu (každá pro jeden druh operačního systému) (Vavrečková, 2008).
Schopnosti překladačů programovacího jazyka Python
33
6 Překladače programovacího jazyka Python V této kapitole se zaměříme na vybrané překladače programovacího jazyka Python, které budou později podrobněji zkoumány a analyzovány z hlediska hodnotících kritérií, které budou popsána dále v této práci.
6.1 Překladač Pyjamas 6.1.1
Hlavní vlastnosti
Pyjamas, nebo někdy také Pyjs, je vývojová platforma, sloužící pro vývoj webových aplikací či webových stránek. Konkrétně webových aplikací nebo webových stránek založených na Javascriptu (What is pyjs?, 2013). Mimo jiné je také požadavkem pro jeho spuštění nainstalovaný oficiální překladač jazyka Python.
6.1.2
Hlavní výhody
Mezi hlavní výhody tohoto překladače patří: Podpora datových typů jazyka Python (List, Dictionary, Tuple, string), které jsou převedeny na objekty Javascriptu mající stejné vlastnosti. Vše může být napsáno čistě a přehledně objektově orientovaným způsobem (v programovacím jazyce Python). Tímto způsobem by bylo obtížné psát kód v čistém Javascriptu (Overview, 2013).
6.1.3 níže.
Princip činnosti
Překladač se skládá z několika hlavních částí, které jsou uvedeny na obrázku
Obrázek 5: schéma činnosti překladače Pyjamas, zdroj: pyjs.org/Overview.html
Schopnosti překladačů programovacího jazyka Python
34
Blíže si popíšeme jednotlivé části tohoto překladače jazyka Python. Knihovny Pyjs – tato část překladače je velmi důležitá, bere si zdrojový kód, který je napsán v programovacím jazyce Python a pomocí syntaktického stromu generuje kód v Javascriptu Knihovny Pyjslib – i když je většina konstrukcí jazyka Python velmi podobná Javascriptu, najdou se určité oblasti, ve kterých se tyto dva programovací jazyky svými konstrukcemi značně liší. Jedná se zejména o oblast datových typů. Například seznamy v Pythonu jsou touto knihovnou převedeny na samostatné objekty a metody pro práci s těmito objekty. Tyto metody implementují přidávání prvků do těchto objektů (dříve seznamů v Pythonu) apod. UI widgety a DOM knihovny – jedná se o knihovny obsahující prvky uživatelského rozhraní, jako jsou různá tlačítka, formuláře apod. Tak, jako všechny ostatní prvky, jsou i prvky uživatelského rozhraní napsány v programovacím jazyce Python a poté jsou přeloženy do Javascriptu. Build – vytváří výsledné HTML, případně Javascriptové soubory (Overview, 2013).
6.2 Překladač Python 6.2.1
Hlavní vlastnosti
Jedná se o volně dostupný, oficiální překladač programovacího jazyka Python. Aktuálně je dostupná nejnovější verze – Python 3.4.3. V případě stažení tohoto překladače nezískáme jen samotný překladač, ale i vývojové prostředí zvané IDLE, pro vývoj aplikací v jazyce Python a v poslední řadě také interaktivní příkazový řádek, pomocí kterého je možné přímo spouštět příkazy tohoto programovacího jazyka (Python, 2015).
Obrázek 6: Interaktivní příkazový řádek
Schopnosti překladačů programovacího jazyka Python
35
Obrázek 7: IDLE - vývojové prostředí jazyka Python
6.2.2
Hlavní výhody
Hlavními výhodami tohoto nejrozšířenějšího překladače jazyka Python jsou: Oficiální překladač jazyka. Součástí balíčku i vývojové prostředí, interaktivní příkazový řádek a možnost instalace Python.exe – umožňuje poté spouštět skripty jazyky Python přímo v příkazovém řádku operačního systému Windows. Pravidelné aktualizace a oprava chyb (Python, 2015).
6.2.3
Princip činnosti
Po stažení a instalaci je možné psát skripty v jazyce Python pomocí vývojového prostředí IDLE, případně přímo v interaktivním příkazovém řádku (shellu), nebo pomocí jakéhokoliv jiného textovém editoru. Po napsání takovéhoto skriptu (s příponou .py) je pak možné tento program spustit přímo v příkazovém řádku operačního systému Windows, nebo ve vývojovém prostředí IDLE(Python, 2015).
6.3 Překladač Skulpt Jedná se o implementaci programovacího jazyka Python v internetovém prohlížeči. Tato implementace (včetně překladače – interpretu) je volně dostupná ke stažení na webových stránkách. Implementace tohoto překladače je podobně jako u překladače Pyjamas založená na Javascriptu. Tohoto překladače je hojně využíváno u online služeb, které poskytují online vývojová prostředí pro interpretaci příkazů jazyka Python. Jednou z takovýchto služeb (využívající překladač Skulpt) je Trinket.io (Skulpt, 2014).
Schopnosti překladačů programovacího jazyka Python
36
Obrázek 8: Online služba využívající překladač Skulpt, zdroj: trinket.io/python
6.4 Překladač Jython 6.4.1
Hlavní vlastnosti
Jedná se o implementaci programovacího jazyka Python, která je spouštěna pomocí platformy Java. Poté je možné (po importování Javy) při programování v jazyce Python využívat i funkcí a objektů z programovacího jazyka Java. Po překladu je z napsaného zdrojového kódu vygenerován soubor s příponou .jar – tzv. Java bytecode (General information, 2014).
6.4.2
Hlavní výhody
Hlavními výhodami překladače Jython jsou: Generování Java bytekódu – v případě, že potřebujeme Java bytekód a programujeme v jazyce Python. Možnost využití metod a tříd jazyku Java při programování v jazyce Python (Why Jython, 2014).
6.5 Překladač Ironpython 6.5.1
Hlavní vlastnosti
Jedná se implementaci programovacího jazyka Python pomocí technologie .NET, kterou vyvinula firma Microsoft. Tato technologie je známa zejména v souvislosti v vývojovým prostředím firmy Microsoft, Visual Studiem. Tento pře-
Schopnosti překladačů programovacího jazyka Python
37
kladač je celý napsán v programovacím jazyce C#. Zasloužil se o to pan Jim Hugunin, který také vytvořil překladač, překládající jazyk Python do Java bytekódu, Jython. Ironpython mohl být napsán pomocí jazyka C#, jelikož mezi tímto jazykem a jazykem Python, je mnoho syntaktických podobností. Překladač je v současnosti neustále vyvíjen a zdokonalován pro firmu Microsoft (Ironpython, 2014).
6.5.2
Hlavní výhody
Hlavními důvody proč tento překladač použít jsou: Možnost použít pro vývoj aplikací v jazyce Python vývojové prostředí Visual Studio Možnost použít skripty v jazyce Python v již vytvořené aplikaci, která je napsána v některém z .NET jazyků. Dojde k přidání vrstvy (s daným skriptem jazyka Python) do aplikačního rámce dané .NET aplikace a pak mohou programátoři ve svých skriptech jazyka Python používat i objekty technologie .NET. Použití reflexe – souvisí s předchozím bodem. Jakmile programátor použije některý z objektů technologie .NET jsou k tomuto objektu získány i všechny jeho příslušné metody se kterými může tento objekt pracovat. Této vlastnosti je využito při tzv. našeptávání, viz. obrázek níže (Ironpython, 2014).
Obrázek 9: Našeptávání při tvorbě zdrojového kódu, zdroj: www.ironpython.net
6.6 Překladač Stackless Python 6.6.1
Hlavní vlastnosti
Jedná se o implementaci programovacího jazyka Python, která používá zásobník, který je podobný zásobníku programovacího jazyka C (Stackless Python,
Schopnosti překladačů programovacího jazyka Python
38
2015). Hlavní způsob použití tohoto druhu překladače programovacího jazyka Python, spočívá v tom, že umožňuje při vývoji aplikací v jazyce Python, použít preemtivní multitasking. Ten je charakterizován tím, že procesor počítače nepředá plnou kontrolu danému procesu, nýbrž mu předá řízení pouze na určitý čas. To je výhodné zejména z hlediska, kdy daný proces havaruje a tak nedojde k zastavení všech dalších procesů. Zjednodušeně řečeno, Stackless Python umožňuje pracovat s microthready a tasklety (Stackless Python, ABC Linux, 2013).
6.6.2
Hlavní výhody
Hlavní výhody tohoto druhu překladače plynou zejména z jeho již výše popsané vlastnosti, tj. z možnosti využití preemtivního multitaskingu.
6.7 Překladač Shed Skin 6.7.1
Hlavní vlastnosti
Jedná se o překladač, který překládá programy napsané v programovacím jazyce Python do kódu, který napsán v jazyce C++. Je nutné si uvědomit, že se jedná o experimentální překladač, jak je podotknuto na oficiálních webových stránkách tohoto překladače. Většina funkcí a metod jazyka Python, jsou tímto překladačem podporovány, to ale neznamená, že podpora je plnohodnotná. Pro příklad, nejsou podporovány metody getattr a hasattr. Překladač Shed Skin tedy ve výsledku generuje kód v jazyce C++, který potřebuje ke své činnosti pouze C++ runtime knihovny (Shed Skin, 2014).
6.7.2
Hlavní výhody
Pokud bychom měli vyzdvihnout určité výhody tohoto druhy překladače programovacího jazyka Python, jedná se zejména o jeho základní funkčnost, tím je myšlena skutečnost, že generuje kód v C++ kódu.
6.8 Překladač Py2exe 6.8.1
Hlavní vlastnosti
Hlavní funkcí tohoto překladače je, že z programu, který je napsán v jazyce Python vytvoří spustitelný soubor – soubor s příponou .exe. Překladač byl původně vyvinut panem Thomasem Hellerem, který se o vývoj v dnešní době už nestará, ale na vývoj pouze přispívá. Překladač Py2exe využívá například BitTorrent apod.
Schopnosti překladačů programovacího jazyka Python
39
Pro svoji činnosti potřebuje tento překladač oficiální překladač jazyka Python (Python: Py2exe, 2014).
6.8.2
Hlavní výhody
Opět je hlavní výhodou tohoto překladače vlastně jeho hlavní funkce, tj. skutečnost, že dokáže z programu napsaného v programovacím jazyce Python, vygenerovat spustitelný soubor, tj. soubor s příponou .exe.
6.9 Překladač Active Python 6.9.1
Hlavní vlastnosti
Jedná se o kompletní balíček, který obsahuje překladač (interpret) programovacího jazyka Python, stejně jako vývojové prostředí Komodo, různé tutoriály a návody, dokumentaci apod. Jedná se tedy o kompletní balíček, který může konkurovat oficiálním nástrojům pro vývoj v jazyce Python. Tento překladač a balíček je zmíněn již dříve. Active Python má několik verzí – bezplatnou, která je určena pro nekomerční vývoj aplikací a placenou, která je určena pro komerční vývoj aplikací a obsahuje kompletní balíček, na rozdíl od bezplatné verze, které neobsahuje všechny části jako verze komerční (ActiveState, 2014).
Obrázek 10: Vývojové prostředí Komodo, doporučované k překladači Active Python, zdroj: www.bitwisemag.com/2/IMG/jpg/python1-komodo.jpg
Schopnosti překladačů programovacího jazyka Python
6.9.2
40
Hlavní výhody
Největší výhodou oproti oficiálnímu balíčku pro vývoj aplikací v programovacím jazyce Python je skutečnost, že vývojové prostředí Iron Pythonu je propracovanější. Co se týče dalších vlastností, ty budou podrobněji zkoumány pomocí hodnotících kritérií.
Schopnosti překladačů programovacího jazyka Python
41
7 Kritéria pro hodnocení překladačů jazyka Python 7.1 Obtížnost instalace a odinstalace 7.1.1
Instalace
Jedná se o základní kritérium, protože než můžeme přistoupit k překladu daných programů v jazyce Python, musíme mít naistalován některý z překladačů. Každý překladač se jinak a různě obtížně instaluje. Většina překladačů, stejně tak jako většina programů bývá instalována pomocí průvodce, který uživatele postupně informuje o jednotlivých krocích instalace a ptá se jej na důležité informace, které potřebuje k úspěšnému provedení instalace – např. kam má daný překladač instalátor nainstalovat apod. Způsob instalace také může záviset na operačním systému, ve které je instalace prováděna. Jak už bylo řečeno, většina zkoumaných překladačů jazyka Python se instaluje pomocí standardního průvodce, ale není tomu tak u všech. Některé je třeba různě konfigurovat a pak obtížnost instalace závisí na dalším zkoumaném kritériu, na úrovni dokumentace.
7.1.2
Odinstalace
Obtížnost odinstalace souvisí s obtížností instalace. Většina překladačů, které jsou instalovány pomocí průvodce, mají i průvodce pro odinstalaci. Další možností, jak nainstalované překladače odebrat z operačního systému, je např. možnost využít Ovládacích panelů v operačních systémech Windows, kde můžeme nainstalované programy odinstalovat v sekci Programy. V případě, že u daného překladače proběhla instalace jiným způsobem, např. konfigurací různých souborů apod., pak obtížnost instalace závisí opět na úrovni dokumentace, kde si může uživatel přečíst, jak odinstalaci provést.
7.2 Kompatibilita s operačními systémy Existují tři nejpoužívanější operační systémy pro osobní počítače – Windows, Linux a Mac OS. U všech zkoumaných překladačů bude vyhodnocena jejich kompatibilita se všemi třemi výše uvedenými druhy operačních systému, tzn. zda je daný překladač dostupný pro dané tři operační systémy. Samotné testování, tím je myšleno vyhodnocení všech dalších kritérií pro hodnocení překladačů u všech překladačů programovacího jazyka Python, bude provedeno pouze v prostředí dvou operačních systémů. Konkrétně tedy v prostředí operačního systému Windows 8.1 a Linux Ubuntu.
Schopnosti překladačů programovacího jazyka Python
42
7.3 Možnost zpětné vazby k uživateli Do této kategorie spadají zejména možnosti, jakými daný překladač poskytuje zpětnou vazbu uživateli. V praxi se tedy jedná zejména o to, jakým způsobem překladač uživatele informuje o následujících skutečnostech: Chybách při překladu – jak identifikuje danou chybu, zda udává i pozici chyby v kódu, případně i nějaký její popis a návrh řešení jak tuto chybu vyřešit. O úspěšném překladu programu. Případně o dalších skutečnostech, které by měl uživatel mít v povědomí.
7.4 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu Reakce na chyby ve všech výše uvedených fázích překladu bude testována pomocí testovacích úloh, které zahrnují všechny základní konstrukce, které jsou nejběžnější pro programovací jazyk Python. Konkrétně se jedná o: Základní matematické operace – sčítání, odčítání, násobení a dělení. Práci s cykly – cyklus while a for. Práci s řetězci – různé funkce pro práci s řetězci, přístup ke konkrétním znakům řetězcových proměnných apod. Práci s regulárními výrazy – nalezení určitých znaků, přístup ke všem nalezeným položkám apod. Práci se soubory – zápis a čtení ze souborů. Práci s XML soubory – čtení a zápis do tohoto druhu souborů. Práci s webovými službami - zpracování HTTP requestů apod. Definici tříd – při objektově orientovaném programování, konkrétně se jedná o zakládání tříd, dědičnost apod. Pro každou z výše uvedených oblastí budou vytvořeny testovací úlohy, které budou ve dvou verzích a to ve verzi, které neobsahují žádnou chybu a dále ve verzi, kde daný zdrojový kód obsahuje chyby. Pomocí takto vytvořených testovacích úloh bude poté vyhodnocena schopnost všech překladačů programovacího jazyka Python reagovat na lexikální, syntaktické a sémantické chyby. Testování proběhne v prostředí dvou operačních systémů – Windows 8.1 a Linux Ubuntu 14.04.
Schopnosti překladačů programovacího jazyka Python
43
7.5 Časová a prostorová složitost překladu 7.5.1
Časová složitost překladu
Časová složitost je definována jako čas, který je potřebný k provedení určité činnosti. V našem případě je to čas, který je potřebný k provedení překladu. Překládány budou testovací úlohy a bude tak zkoumán čas překladu zdrojového kódu v jazyce Python, který je bez chyby a zdrojový kód v jazyce Python, který obsahuje chyby. Tyto skutečnosti budou pak zkoumány u každého z dříve uvedených překladačů programovacího jazyka Python. V prostředí operačního systému Linux Ubuntu, bude časová složitost překladu vyhodnocena pomocí příkazu time, který lze použít v příkazovém řádku operačního systému Linux. Použití je jednoduché, před příkaz u kterého chceme zjistit jeho čas provedení, se pouze uvede příkaz time. Tudíž v našem případě před příkaz, který zajistí překlad dané testovací úlohy, bude uveden příkaz time, který určí časovou složitost překladu. Naopak v prostředí operačního systému Windows 8.1 ekvivalent funkce time jako je u operačního systému Linux, neexistuje. Proto bude použita konzolová aplikace TimeMem, která je spouštěna v příkazovém řádku systému Windows a jako její parametr bude vždy uveden příkaz pro překlad programu v jazyce Python python a za tímto příkazem soubor obsahující program v jazyce Python (Timewindows, 2012). Případně bude časová složitost překladu zkoumána jinými prostředky – pokud to dovolí např. aktuálně používaný překladač, např. jeho vývojové prostředí.
Schopnosti překladačů programovacího jazyka Python
44
Obrázek 11: Konzolová aplikace TimeMem, zobrazující časovou složitost překladu, konzolová aplikace dostupná na: www.code.google.com/p/timewindows/downloads/detail?name=TimeMem-1.0.exe&can=2&q=
7.5.2
Prostorová složitost překladu
Prostorová složitost je definována jako velikost operační paměti, kterou procesor využije při provádění určitého příkazu. V našem případě se tedy bude jednat o velikost paměti, která bude potřebná k provedení překladu testovacích příkladů. Opět analogicky jako u časové složitosti překladu, bude pro zajímavost porovnáván rozdíl mezi prostorovou složitostí překladu programu s chybou a bez chyby. V prostředí operačního systému Linux bude použito aplikace Htop, která je volně stažitelná pro každou distribuci operačního systému Linux. Tato aplikace dokáže monitorovat spuštěné procesy v operačním systému Linux. V operačním systému Linux musíme ale dbát na jeho způsob správy paměti. Abychom dostali opravdu kapacitu operační paměti, kterou potřebuje daný proces ke svému provedení, musíme od sebe odečíst hodnoty RES a SHI, což je resident size, neboli skutečná velikost paměti (ta může ale být ale sdílena mezi různými procesy) a shared memory, což je právě kapacita operační paměti, kterou daný proces sdílí s dalšími procesy (Kolik paměti zabírá konkrétní aplikace?, 2012).
Schopnosti překladačů programovacího jazyka Python
45
Obrázek 12: Htop - zobrazení spuštěných procesů
Naopak v operačním systému Windows 8.1 bude využito Správce úloh, který zobrazuje všechny spuštěné procesy.
Obrázek 13: Správce úloh operačního systému Windows 8.1
Schopnosti překladačů programovacího jazyka Python
46
7.6 Úroveň dokumentace Posledním, ale neméně důležitým kritériem pro ohodnocení zkoumaných překladačů programovacího jazyka Python je úroveň dokumentace. Dokumentace by měla být na takové úrovni, aby poskytla uživateli dostatečné informace ohledně daného překladače. Dokumentace by měla přehledně a srozumitelně informovat uživatele např. o postupu instalace překladače, případně o jeho konfiguraci, dále pak o postupu jak pomocí něj provést překlad, případně jak řešit nějaké nejčastěji se vyskytující problémy. Přehledně a srozumitelně napsaná dokumentace, která zahrnuje všechny informace potřebné pro práci s daným překladačem, velmi usnadní a zrychlí práci s tímto překladačem.
Schopnosti překladačů programovacího jazyka Python
47
8 Testovací úlohy Tato kapitola bude věnována popisu všech testovacích úloh. Podrobně budou zejména popsány verze s chybami. Jednotlivé chyby jsou, pokud je to možné, v uvedeném kódu vyznačeny kurzívou. Všechny tyto testovací úlohy jsou dostupné v příloze této diplomové práce.
8.1 Základní matematické operace Základními matematickými operacemi se rozumí sčítání, odčítání, násobení a dělení. Níže můžete vidět jednoduchý program, který realizuje tyto operace s dvěma číselnými proměnnými. a = 150.0 b = 502.0 print (a + print (a – print (a * print (a /
8.1.1
b) b) b) b)
Verze s chybami
Mezi hlavní chyby, které se mohou vyskytnout v programech pracujících s matematickými operacemi je např. sčítání proměnné která je číselného datového typu a proměnné, která je řetězcového datového typu. Tato situace může při programování v jazyce Python celkem často, jelikož se jedná o programovací jazyk, kde při vytváření proměnné není udáván její datový typ. Datový typ dané proměnné přiřadí až sám Python po jejím naplnění, tj. pokud je do ní pak přiřazeno např. číslo jedná se o číselnou proměnnou. a = 'A' b = 502.0 print (a + print (a – print (a * print (a /
b) b) b) b)
Další z řady velmi častých chyb je dělení nulou. Jak víme už ze základní školy, dělit nulou prostě nelze. a = 150.0 b = 0 print a + b
Schopnosti překladačů programovacího jazyka Python
48
print a - b print a * b print a / b Určitě nesmíme zapomenout na chybu, která se může vyskytnout v jakékoliv oblasti, ale pro jednoduchost byla zařazena do oblasti matematických operací. Jedná se o deklaraci proměnné a nepřeřazení žádné hodnoty do této proměnné. a = b = 502.0 print a + print a print a * print a /
b b b b
Pokud chceme výsledek matematické operace opatřit nějakým popiskem může se snadno stát, že vyprodukujeme tuto chybu – zapomeneme zřetězit řetězec, který má být funkcí print vypsán s danou proměnnou pomocí operátoru zřetězení (+). a = 150.0 b = 502.0 print "vysledek" a + b print a - b print a * b print a / b Poslední, ale velmi zásadní chybou při používání matematických operací je opomenutí některého z matematických operátorů, např. operátoru pro sčítání, jak můžete vidět v kódu níže. a = 150.0 b = 502.0 print a b print a - b print a * b print a / b
8.2 Práce s cykly Cykly jsou důležitou konstrukcí a součástí každého programovacího jazyka. Jinak tomu není ani u programovacího jazyka Python, kterému je věnována tato práce. Programovací jazyk Python zahrnuje dva typy cyklů a to cyklus for a cyklus while.
Schopnosti překladačů programovacího jazyka Python
8.2.1
49
Cyklus for
Následující kód ukazuje bezchybnou konstrukci cyklus for. for i in range(11): print i * 5
8.2.2
Cyklus for – verze s chybami
Základní chybou při využití cyklu for v programovacím jazyce Python je neuvedení číselného parametru funkci range, která udává počet opakování daného cyklu. for i in range(): print i * 5 Další chybou související s funkcí range je, když dáme této funkci jako parametr příliš velké číslo, tj. číslo přesahující hodnotu maxint u jazyka Python. Konkrétně se jedná o číslo v řádech stamilionů. for i in range(200000000): print i * Další chybou související s funkcí range, která definuje počet opakování cyklu, je případ, kdy dáme této funkci jako parametr proměnnou, ale ta nebude číselného typu, ale řetězcového. a = "ahoj" for i in range(a): print i * 5 Předposlední chybou, která se produkována programátory velmi často, je opomenutí dvojtečky za definicí cyklu. for i in range(11) print i * 5 Poslední chybou, je chyba, která je velmi specifická pro programovací jazyk Python. Jedná se o neodsazení příkazu, který má být provádět v daném cyklu. for i in range(11): print i * 5
Schopnosti překladačů programovacího jazyka Python
8.2.3
50
Cyklus while
Bezchybná konstrukce cyklus while v programovacím jazyce Python zahrnuje proměnnou která bude postupně inkrementována a porovnávána s hodnotou, která udává, kolikrát bude příkaz, nebo příkazy v daném cyklus provedeny. Dále pak samozřejmě také odsazení příkazů, které mají být v tomto cyklu prováděny. i = 1 a = 5 while i <= 10: print a * i i = i + 1
8.2.4
Cyklus while – verze s chybami
Základní chybou při práci s cyklem while je nedeklarování proměnné, která bude porovnávána s hodnotou v podmínce cyklu. V příkladu níže se konkrétně jedná o proměnnou i. a = 5 while i <= 10: print a * i i = i + 1 Další velmi častou chybou, související opět s proměnnou, jejíž hodnota je porovnávána v podmínce cyklu, je její neinkrementování v cyklu. i = 1 a = 5 while i <= 10: print a * i Chybou, která může velmi často nastat právě v programovacím jazyce Python, jelikož jak už bylo dříve řečeno, Python nevyžaduje při deklarování proměnných udávat datový typ, je porovnávat v podmínce cyklu proměnnou s řetězcem nebo řetězcovou proměnnou. i=1 a=5 while i <= '10': print a * i i=i+1
Schopnosti překladačů programovacího jazyka Python
51
Při využívání cyklu while musíme v podmínce cyklu velmi často použít operátory porovnání, chyba může nastat při použití operátoru větší (menší) nebo rovno, pokud uvedeme špatné pořadí operátoru rovno a operátoru větší (menší). i = 1 a = 5 while i =< 10: print a * i i = i + 1
8.3 Práce s řetězci 8.3.1
Přístup k znakům řetězce
S řetězcovými proměnnými je v programovacím jazyce Python zacházeno stejně jako ve většině moderních programovacích jazycích, tj. že na řetězec je pohlíženo jako na pole znaků a k tudíž můžeme k jednotlivým znakům řetězce přistupovat přes číselný index. a = "ahoj" b = "120" print a[1] print a[5:] for i in a: print i print a + " " + b
8.3.2
Přístup k znakům řetězce – verze s chybami
Jedním ze základních chyb při přístupu k znakům daného řetězce je když se snažíme vypsat znaky od indexu, který v daném řetězci neexistuje. a = "ahoj" b = "120" print a[1] print a[5:] for i in a: print i print a + " " + b Další velmi podobná chyba je pokud chceme přistoupit k jednomu konkrétnímu znaku řetězcem přes index, který neexistuje. a = "ahoj"
Schopnosti překladačů programovacího jazyka Python
52
b = "120" print a[6] for i in a: print i print a + " " + b Velmi častou chybou je dále případ, kdy se snažíme zřetězovat číselné a řetězcové proměnné. Abychom toho úspěšně dosáhli, musíme danou číselnou proměnnou pomocí funkce str přetypovat na řetězcovou proměnnou. Tak se tomu ale neděje v následujícím příkladu. a = "ahoj" b = 120 print a[2] for i in a: print i print a + " " + B Pokud při přiřazování řetězce do proměnné zapomeneme tento řetězec uzavřít do dvojitých uvozovek, pak se také jedná o jednu z častých chyb. a = "ahoj b = "120" print a[1] for i in a: print i print a + " " + b
8.3.3
Formátování výstupu
Formátováním výstupu je myšlen případ, kdy chceme pomocí funkce print vytisknout na standardní výstup určitý řetězec a ten doplnit dalšími informacemi – hodnotami z dalších proměnných. Níže můžete vidět příklad. jmeno = 'mark' heslo = '123heslo' print "{0}ovo heslo je {1}".format(jmeno, heslo)
Schopnosti překladačů programovacího jazyka Python
8.3.4
53
Formátování výstupu – verze s chybami
Jednou z nejčastějších chyb je neuvedení funkci format potřebný počet parametrů, který se odvíjí od počtu číselných identifikátorů v řetězci, do kterého se budou přidávat hodnoty z proměnných. jmeno = 'mark' heslo = '123heslo' print "{0}ovo heslo je {1}".format(jmeno) Naopak další chybou je také případ, kdy uvedeme do textu číselný identifikátor, který je vyšší jak počet parametrů funkce format (číselné identifikátory jsou číslovány od nuly). jmeno = 'mark' heslo = '123heslo' print "{0}ovo heslo je {2}".format(jmeno, heslo) Poslední velmi častou chybou je pak neoddělení proměnných ve funkci format čárkou. jmeno = 'mark' heslo = '123heslo' print "{0}ovo heslo je {1}".format(jmenoheslo)
8.3.5
Funkce pro práci s řetězci
Pro práci s řetězci existuje mnoho různých funkcí, např. funkce zjišťující délku daného řetězce, funkce převádějící daný řetězec na velká písmena apod. Naším hlavním cílem je ale demonstrovat na testovacích úlohách reakci na chyby a v případě funkcí pro práci s řetězci jsou tyto reakce stejné – překladač reaguje stejným způsobem. Proto bylo pro účely testování vybráno pouze pár základních funkcí – např. již výše zmíněná funkce pro zjištění délky řetězce, převedení řetězce na velké znaky apod. s = "ahoj jak se mas" c = '100' if c in s: print "ano" else: print "ne" v = c.upper() print len(s) print v
Schopnosti překladačů programovacího jazyka Python
8.3.6
54
Funkce pro práci s řetězci – verze s chybami
V programovacím jazyce Python můžu elegantně a jednoduše zjišťovat zda nějaký znak nebo řetězec leží v určitém řetězci a to pomocí funkce in. Pokud ale začnu zjišťovat, zda leží číselná proměnná v řetězcové proměnné, dojde k chybě. s = "ahoj jak se mas" c = 100 if c in s: print "ano" else: print "ne" Chyba také nastane, pokud se snažím aplikovat na číselnou proměnnou jakoukoliv metody pro práci s řetězci. V kódu níže se tak děje s funkcí upper. s = "ahoj jak se mas" c = '100' if c in s: print "ano" else: print "ne" c = 100 v = c.upper() print v
8.4 Práce s regulárními výrazy Regulární výraz je výraz, který pomocí zástupných znaků popisuje určitý řetězec, konkrétně tedy jeho tvar. Této velmi užitečné věci můžeme využít např. při hledání řetězcům (znaků) určitého tvaru např. v textu apod. Pomocí níže uvedeného kódu například můžeme nalézt malá písmena abecedy, která se nachází vždy na první pozici ve slově. import re text = "ahoj jak se mas?" p = re.findall("([a-z])\w+", text) for i in p: print i
Schopnosti překladačů programovacího jazyka Python
8.4.1
55
Verze s chybami
Abychom mohli v programovacím jazyce Python pracovat s regulárními výrazy, je třeba mít importovanou knihovnu re, pro práci s těmito výrazy. Pokud tak neučiníme dojde k chybě, tak jako v níže uvedeném kódu. text = "ahoj jak se mas?" p = re.findall("([a-z])\w+", text) for i in p: print i Další velmi častou chybou, která souvisí s knihovnou re je zapomenutí identifikátoru této knihovny při použití regulárního výrazu. V níže uvedeném příkladu musíme tak učinit před použitím funkce findall, správně je tento kousek kódu tedy zapsán takto – re.findall. import re text = "ahoj jak se mas?" p = findall("([a-z])\w+", text) for i in p: print i Dále je nutné funkci findall poskytnout potřebný počet parametrů – tj. regulární výraz a také řetězec nebo řetězcovou proměnnou ve které má pomocí regulárního výrazu vyhledávat. Pokud tomu tak není, dojde k chybě. import re text = "ahoj jak se mas?" p = re.findall("([a-z])\w+") for i in p: print i Velmi častou chybou, která spíše plyne z nepozornost programátora, je neuzavření řetězce definujícího regulární výraz do uvozovek. import re text = "ahoj jak se mas?" p = re.findall("([a-z])\w+, text) for i in p: print i Poslední chybou, která opět spadá do stejné kategorie, jako chyba výše, je zapomenutí čárky, která odděluje jednotlivé parametry funkce findall, tj. řetězec de-
Schopnosti překladačů programovacího jazyka Python
56
finující regulární výraz a proměnnou, případně řetězec ve kterém má být vyhledávání prováděno. import re text = "ahoj jak se mas?" p = re.findall("([a-z])\w+" text) for i in p: print i
8.5 Práce se soubory Práci se soubory můžeme rozdělit na dvě základní úlohy – čtení ze souboru a zápis (případně přidávání záznamů) do souboru.
8.5.1
Čtení ze souborů
Čtení ze souboru je v jazyce Python, stejně tak jako v mnoho dalších moderních programovacích jazycích velmi jednoduché. Programovací jazyk Python pomocí funkce open otevře daný soubor a pak z něj můžeme např. pomocí funkce readlines načíst do proměnné (typu pole) všechny řádky z daného souboru. f = open('vstup_soubor.txt', 'r') radky = f.readlines() for i in radky: print i f.close()
8.5.2
Čtení ze souborů – verze s chybami
Velmi častou chybou při čtení ze souborů bývá uvedení špatného identifikátoru, který udává způsob, jakým má být daný soubor otevřen. Pro názornost je níže uveden příklad, kde chceme ze souboru číst (používáme funkce readlines), ale soubor se snažíme otevřít pro zápis – funkci open dáváme jako druhý parametr w (write). f = open('vstup_soubor.txt', 'w') radky = f.readlines() for i in radky: print i f.close()
Schopnosti překladačů programovacího jazyka Python
57
Další velmi častou chybou je nepřiřazení výsledku funkce readlines do nějaké proměnné. f = open('vstup_soubor.txt', 'r') f.readlines() for i in radky: print i f.close() Dále je v níže uvedením kódu chyba, která opět souvisí s funkcí readlines, konkrétně se jedná o zapomenutí závorek za touto funkcí. f = open('vstup_soubor.txt', 'r') radky = f.readlines for i in radky: print i f.close() Pokud nastane situace, kdy zapomeneme uzavřít řetězec obsahující vstupní soubor do uvozovek, tak také dojde k chybě. f = open(vstup_soubor.txt, 'r') radky = f.readlines() for i in radky: print i f.close()
8.5.3
Zápis do souboru
Zápis do určitého souboru je opět velmi jednoduchý, stejně tak jako čtení. Stačí otevřít pomocí funkce open určitý soubor pro zápis a poté pomocí funkce write do daného souboru zapsat potřebné informace. f = open('vystup_soubor.txt', 'w+') s = "ahoj jak se mas ? ja se mam dobre" f.write(s) f.close()
Schopnosti překladačů programovacího jazyka Python
8.5.4
58
Zápis do souboru – verze s chybami
Nejčastější chyba, která obecně při práci se soubory může nastat je, že daný soubor, do kterého chceme zapisovat (případně ze kterého chceme číst) neexistuje. f = open('ahoj', 'r+') s = "ahoj jak se mas ? ja se mam dobre" f.write(s) f.close() Pokud zapomeneme uvést funkci write parametr, tj. to co chceme zapsat do daného souboru, pak také samozřejmě dojde k chybě. f = open('ahoj.txt', 'r+') s = "ahoj jak se mas ? ja se mam dobre" f.write() f.close() Chyba také nastane v případě, že se snažíme do textového souboru pomocí funkce write zapsat proměnnou, která je číselného datového typu. V takovém případě dojde chybě. Pokud bychom chtěli této chybě předejít, museli bychom danou proměnnou přetypovat pomocí funkce str, na proměnnou řetězcového datového typu. f = open('vystup_soubor.txt', 'r+') s = 100 f.write(s) f.close()
8.6 Práce s XML XML neboli Extensible Markup Language je značkovací jazyk, který se zejména používá pro přenos dat různých typů. Většina moderních programovacích jazyků práci se soubory tohoto typu podporuje, jinak tomu není ani u jazyka Python (XML, 2015).
8.6.1
Tvorba XML souborů
Tvorba XML souborů je v programovacím jazyce Python stejně tak jako mnoho dalších věcí, velmi jednoduchá. Můžete se o tom přesvědčit v kódu, který je uveden pod tímto textem. Důležité je mít importovanou některou z knihoven, která umožní v jazyce Python pracovat s XML soubory. Napřed je vytvořen kořen struktury pomocí příkazu Element, poté je vytvořen jeho potomek pomocí příkazu SubElement a tomuto potomku jsou vytvořeny a přidány jeho atributy.
Schopnosti překladačů programovacího jazyka Python
import xml.etree.cElementTree as ET koren = ET.Element("koren") potomek = ET.SubElement(koren, "uzel") ET.SubElement(doc, "polozka1", name="pol1").text "hodnota1" ET.SubElement(doc, "polozka2", name="pol2").text "hodnota2" strom = ET.ElementTree(koren) strom.write("vystup.xml")
59
= =
Výsledný XML soubor je pak v následujícím tvaru. <polozka1 name="pol1">some value1 <polozka2 name="pol2">some vlaue2
8.6.2
Tvorba XML souborů – verze s chybami
Pokud neuvedeme název kořenového elementu, tj. nějaký parametr funkci Element, tak samozřejmě dochází k chybě. import xml.etree.cElementTree as ET koren = ET.Element() potomek = ET.SubElement(koren, "uzel") ET.SubElement(doc, "polozka1", name="pol1").text "hodnota1" ET.SubElement(doc, "polozka2", name="pol2").text "hodnota2" strom = ET.ElementTree(koren) strom.write("vystup.xml")
= =
Stejně tak dojde k chybě, pokud funkci ElementTree neposkytneme povinný parametr, kterým je právě kořen XML struktury. Funkce ElementTree pak nemůže vytvořit celkovou stromovou strukturu. import xml.etree.cElementTree as ET koren = ET.Element(“koren“) potomek = ET.SubElement(koren, "uzel") ET.SubElement(doc, "polozka1", name="pol1").text "hodnota1"
=
Schopnosti překladačů programovacího jazyka Python
ET.SubElement(doc, "polozka2", "hodnota2" strom = ET.ElementTree() strom.write("vystup.xml")
60
name="pol2").text
=
Jelikož chceme poté danou XML strukturu zapsat do souboru, pak pokud neuvedeme funkci write potřebný parametr, kterým je název souboru, do kterého má být zapsáno, dojde k chybě. import xml.etree.cElementTree as ET koren = ET.Element("koren") potomek = ET.SubElement(koren, "uzel") ET.SubElement(doc, "polozka1", name="pol1").text "hodnota1" ET.SubElement(doc, "polozka2", name="pol2").text "hodnota2" strom = ET.ElementTree(koren) strom.write()
= =
Nyní se dostáváme k poslední z velmi častých chyb a tou je uvedení špatného názvu funkce. Na příkladu níže můžete tedy vidět, špatně zapsané klíčové slovo Element. import xml.etree.cElementTree as ET koren = ET.lement("koren") potomek = ET.SubElement(koren, "uzel") ET.SubElement(doc, "polozka1", name="pol1").text "hodnota1" ET.SubElement(doc, "polozka2", name="pol2").text "hodnota2" strom = ET.ElementTree(koren) strom.write(koren)
8.6.3
= =
Čtení XML souborů
Stejně jako při vytváření XML souborů, tak i při čtení a zpracovávání těchto souborů, musíme použít knihovny pro to určené. Samotné čtení je pak jednoduché, jak můžete vidět v ukázce kódu níže pod tímto textem. from xml.dom import minidom xml = minidom.parse("vstup.xml") jmeno = xml.getElementsByTagName("name")[0] print(jmeno.firstChild.data) polozky = xml.getElementsByTagName("staff") for p in polozky:
Schopnosti překladačů programovacího jazyka Python
61
cislo = p.getAttribute("id") nick = p.getElementsByTagName("nickname")[0] plat = p.getElementsByTagName("salary")[0] print("id:%s, nickname:%s, salary:%s" % (cislo, nick.firstChild.data, plat.firstChild.data))
8.6.4
Čtení XML souborů – verze s chybami
Zřejmě nejčastější chybou při zpracovávání informací, nebo čtení XML souborů je případ, kdy uvedeme špatný název atributu, ke kterému chceme přistupovat. Děje se tomu tak i ve zdrojovém kódu níže. Místo abychom přistupovali k elementu s jménem staff, přistupujeme k elementu s názvem staffa. from xml.dom import minidom xml = minidom.parse("vstup.xml") jmeno = xml.getElementsByTagName("name")[0] print(jmeno.firstChild.data) polozky = xml.getElementsByTagName("staffa") for p in polozky: cislo = p.getAttribute("id") nick = p.getElementsByTagName("nickname")[0] plat = p.getElementsByTagName("salary")[0] print("id:%s, nickname:%s, salary:%s" % (cislo, nick.firstChild.data, plat.firstChild.data)) Další velmi častou chybou je opomenutí importu potřebných knihoven pro čtení XML souborů. V níže uvedeném příkladu chybí tedy import knihovny xml.dom. xml = minidom.parse("vstup.xml") jmeno = xml.getElementsByTagName("name")[0] print(jmeno.firstChild.data) polozky = xml.getElementsByTagName("staff") for p in polozky: cislo = p.getAttribute("id") nick = p.getElementsByTagName("nickname")[0] plat = p.getElementsByTagName("salary")[0] print("id:%s, nickname:%s, salary:%s" % (cislo, nick.firstChild.data, plat.firstChild.data)) Chybou, která opět souvisí s potřebnou knihovnou pro čtení XML souborů, je zapomeutí identifikátoru knihovny při práci s funkcemi této knihovny. V příkladu níže chybí před funkcí parse identifikátor minidom.
Schopnosti překladačů programovacího jazyka Python
62
from xml.dom import minidom xml =parse("vstup.xml") jmeno = xml.getElementsByTagName("name")[0] print(jmeno.firstChild.data) polozky = xml.getElementsByTagName("staffa") for p in polozky: cislo = p.getAttribute("id") nick = p.getElementsByTagName("nickname")[0] plat = p.getElementsByTagName("salary")[0] print("id:%s, nickname:%s, salary:%s" % (cislo, nick.firstChild.data, plat.firstChild.data)) Pokud zapomeneme uvést jméno XML souboru, ze kterého má být čtení prováděno, tak podobně jako při čtení každého jiného souboru, tak i v této situaci dojde k chybě. Jméno souboru se uvádí jako parametr funkce parse. from xml.dom import minidom xml = minidom.parse() jmeno = xml.getElementsByTagName("name")[0] print(jmeno.firstChild.data) polozky = xml.getElementsByTagName("staffa") for p in polozky: cislo = p.getAttribute("id") nick = p.getElementsByTagName("nickname")[0] plat = p.getElementsByTagName("salary")[0] print("id:%s, nickname:%s, salary:%s" % (cislo, nick.firstChild.data, plat.firstChild.data)) Obdobná chyba nastává, pokud uvedeme do parametru této funkce (funkce parse) neexistující soubor. from xml.dom import minidom xml = minidom.parse("vstupaa.xml") jmeno = xml.getElementsByTagName("name")[0] print(jmeno.firstChild.data) polozky = xml.getElementsByTagName("staffa") for p in polozky: cislo = p.getAttribute("id") nick = p.getElementsByTagName("nickname")[0] plat = p.getElementsByTagName("salary")[0] print("id:%s, nickname:%s, salary:%s" % (cislo, nick.firstChild.data, plat.firstChild.data)) Funkce getElementsByTagName vrací na základě daného parametru všechny dané položky do proměnné, která je poté typu pole. Tudíž pokud budeme přistu-
Schopnosti překladačů programovacího jazyka Python
63
povat v této proměnné na položky pomocí indexu, který je větší jak je samo pole, dojde k chybě. from xml.dom import minidom xml = minidom.parse("vstup.xml") jmeno = xml.getElementsByTagName("name")[10] print(jmeno.firstChild.data) polozky = xml.getElementsByTagName("staffa") for p in polozky: cislo = p.getAttribute("id") nick = p.getElementsByTagName("nickname")[0] plat = p.getElementsByTagName("salary")[0] print("id:%s, nickname:%s, salary:%s" % (cislo, nick.firstChild.data, plat.firstChild.data)) Pokud uvedeme špatný název některé z funkcí, tak také samozřejmě dochází k chybě. Na příkladu níže se tak děje při použití funkce getElementsByTagName. from xml.dom import minidom xml = minidom.parse("vstup.xml") jmeno = xml.getElementsByTagName("name")[0] print(jmeno.firstChild.data) polozky = xml.gtElementsByTagName("staff") for p in polozky: cislo = p.getAttribute("id") nick = p.getElementsByTagName("nickname")[0] plat = p.getElementsByTagName("salary")[0] print("id:%s, nickname:%s, salary:%s" % (cislo, nick.firstChild.data, plat.firstChild.data))
8.7 Webové služby Programovací jazyk Python umožňuje provádět velmi náročné operace v souvislosti s webovými službami. Pro účely testování překladačů v této oblasti tohoto programovacího jazyka si ale vystačíme s jednoduchými příklady, jelikož na těchto jednoduchých příkladech je vidět jak programovací jazyk Python reaguje na chyby.
8.7.1
Dostupnost HTML stránky
Následující ukázka kódu nedělá nic jiného než pomocí zadané url zjistí, zda je webová stránka na dané adrese dostupná nebo ne. Na tomto příkladě si také ukážeme jak se v jak jsou v jazyce Python definovány vyjímky.
Schopnosti překladačů programovacího jazyka Python
64
import urllib2 url = "http://slashdot.org" try: urllib2.urlopen( url) except urllib2.URLError: print "nedostupna" else: print "dostupna"
8.7.2
Dostupnost HTML stránky – verze s chybami
Základní chybou je neuvedení parametru funkci urlopen, která jako parametr vyžaduje url adresu. V příkladu níže je sice u této funkce uveden parametr – proměnná url, ta ale není nikde před tím naplněna. import urllib2 try: urllib2.urlopen(url) except urllib2.URLError: print "nedostupna" else: print “dostupna“ Další z mnoho chyb je neuvedení potřebné knihovny, se kterou bude pracováno. V následujícím kódu za klíčovým slovem import chybí právě název knihovny urllib2, která umožňuje práci s webovými službami. import url = "http://slashdot.org" try: urllib2.urlopen( url) except urllib2.URLError: print "nedostupna" else: print "dostupna" Jak už bylo zmíněno na začátku kapitoly věnované právě webovým službám, tak jsou do těchto úloh zahrnuty i výjimky. Jednou z chyb, která může nastat při práci s nimi, je neuvedení některého z klíčových slov, které jsou potřebné. V následujícím příkladu není např. uvedeno klíčové slovo try. import urllib2 url = "http://slashdot.org" urllib2.urlopen( url)
Schopnosti překladačů programovacího jazyka Python
65
except urllib2.URLError: print "nedostupna" else: print "dostupna"
8.7.3
Vrácení dat HTML stránky
V následujícím příkladu se zaměříme na zpracování dat z webových stránek. Konkrétně programovací jazyk Python umožňuje jednoduše vrátit veškerý obsah dané stránky (včetně HTML tagů). import urllib url = urllib.urlopen("http://www.mendelu.cz/") obsah = url.read() url.close() print obsah
8.7.4
Vrácení dat HTML stránky – verze s chybami
Jednou ze základních chyb, které mohou nastat je, že uvedeme špatnou url. Funkce urlopen se pak snaží na tuto url adresu přistoupit, ale samozřejmě se jí to nepodaří, takže dojde k chybě. import urllib url = urllib.urlopen("http://www.mendelua.cz/") obsah = url.read() url.close() print obsah
8.8 Definice tříd Definici tříd provádíme při objektově orientovaném programování. Blíže je o zvláštnostech programovacího jazyka Python v oblasti objektového programování pojednáno v kapitole 3.3 Vlastnosti programovacího jazyka Python.
8.8.1
Dědičnost
Při dědičnost využíváme toho, že daný potomek má velmi podobné vlastnosti jako jeho předek. V následujícím příkladu můžeme vidět definici třídy Auto, ze které pak dále dětí třída Autobus. Pro jednoduchost znovu uvedu, že metody obsahující klíčové slovo __init__ v programovacím jazyce Python definují konstruktor a metody obsahující klíčové slovo __del__ definují destruktor. class Auto: def __init__(self, jm, ci):
Schopnosti překladačů programovacího jazyka Python
self.jmeno = jm self.cislo = ci
def zobraz_info(self): print self.jmeno print self.cislo def __del__(self): print "Auto zanika" class Autobus(Auto): def __init__(self, jm, ci): Auto.__init__(self, jm, ci) def __del__(self): print "Autobus zanika" auto = Auto("Skoda", 12245) autobus = Autobus("Karosa", 1234) auto.zobraz_info() autobus.zobraz_info() del auto del autobus
8.8.2
Dědičnost – verze s chybami
Základní chybou při využívání dědičnost v jazyce Python, je neuvedení třídy, ze které je děděno. Děje se tomu tak v ukázce kódu níže. Třída Autobus nemá uvedena svého předchůdce, tj. třídu Auto v závorkách za konstruktorem. class Auto: def __init__(self, jm, ci): self.jmeno = jm self.cislo = ci def zobraz_info(self): print self.jmeno print self.cislo def __del__(self): print "Auto zanika" class Autobus():
66
Schopnosti překladačů programovacího jazyka Python
67
def __init__(self, jm, ci): Auto.__init__(self, jm, ci) def __del__(self): print "Autobus zanika" auto = Auto("Skoda", 12245) autobus = Autobus("Karosa", 1234) auto.zobraz_info() autobus.zobraz_info() del auto del autobus Další chybou související s předchůdcem dané třídy, je neuvedení definice této třídy. Jak můžete vidět v kódu níže chybí definice třídy Auto, ze které třída Autobus dědí. class Autobus(Auto): def __init__(self, jm, ci): Auto.__init__(self, jm, ci) def __del__(self): print "Autobus zanika" auto = Auto("Skoda", 12245) autobus = Autobus("Karosa", 1234) auto.zobraz_info() autobus.zobraz_info() del auto del autobus V případě, že dědíme a používáme konstruktor předka, musíme uvést také jeho definici – a stejný počet parametrů. V příkladu níže se tomu tak neděje. class Auto: def __init__(self, jm, ci): self.jmeno = jm self.cislo = ci def zobraz_info(self): print self.jmeno
Schopnosti překladačů programovacího jazyka Python
68
print self.cislo def __del__(self): print "Auto zanika" class Autobus(Auto): def __init__(self): Auto.__init__(self, jm, ci) def __del__(self): print "Autobus zanika" auto = Auto("Skoda", 12245) autobus = Autobus("Karosa", 1234) auto.zobraz_info() autobus.zobraz_info() del auto del autobus
8.8.3
Definice třídy a vytvoření instance této třídy
Definice tříd má svá pravidla a to v každém programovacím jazyce. V jazyce Python musí každá definice třídy začínat klíčovým slovem class a za tímto slovem následuje jméno této třídy, které začíná velkým písmenem. Za tímto názvem je pak uvedena dvojtečka a pod touto definicí jsou definovány jednotlivé metody a atributy této třídy. V případě programovacího jazyka Python nesmíme zapomenout na odsazení definic těchto metod a atributů podle, kterého jazyk Python rozpozná, co je součástí definice dané třídy a co ne. class Auto: def __init__(self, jm, ci): self.jmeno = jm self.cislo = ci def __del__(self): print "Auto zanika" auto = Auto("Opel", 12334) print auto.jmeno print auto.cislo del auto
Schopnosti překladačů programovacího jazyka Python
69
8.8.4 Definice třídy a vytvoření instance této třídy – verze s chybami Jednou ze základních chyb při vytváření instancí dané třídy, je neuvedení správného počtu parametrů danému konstruktoru. V ukázce pod tímto textem můžete vidět, že konstruktor třídy Auto přijímá dva parametry, ale při vytváření instance této třídy konstruktor žádné parametry nedostává. class Auto: def __init__(self, jm, ci): self.jmeno = jm self.cislo = ci def __del__(self): print "Auto zanika" auto = Auto() print auto.jmeno print auto.cislo del auto Další z velmi častých chyb je přístup k atributu, který není v dané třídě děfinován. V následující ukázce zdrojového kódu přistupujeme k atributu jm, který není v dané třídě definován. class Auto: def __init__(self, jm, ci): self.jmeno = jm self.cislo = ci def __del__(self): print "Auto zanika" auto = Auto("Opel", 1235) print auto.jm print auto.cislo del auto Chyba také nastává, pokud při vytváření instance dané třídy uvedeme špatný název dané třídy. V případě naší ukázky se jedná o příkaz auto = auto("Opel", 1235). Třída ale není pojmenována auto, ale Auto.
Schopnosti překladačů programovacího jazyka Python
70
class Auto: def __init__(self, jm, ci): self.jmeno = jm self.cislo = ci def __del__(self): print "Auto zanika" auto = auto("Opel", 1235) print auto.jmeno print auto.cislo del auto Velmi častou chybou při programování v jazyce Python je špatné uvedení klíčového slova __init__, které definuje konstruktor. V případě, že jej totiž uvedeme špatně, pak jazyk Python vytváří instance dané třídy s implicitní, tj. bezparametrickým konstruktorem a v případě, že danému konstruktoru definujeme nějaké parametry, tak vše skončí chybou. Ukázku můžete vidět pod tímto textem. class Auto: def _init__(self, jm, ci): self.jmeno = jm self.cislo = ci def __del__(self): print "Auto zanika" auto = Auto("Opel", 1235) print auto.jmeno print auto.cislo del auto Další specialitou při objektově orientovaném programování v jazyce Python je nutnost každé metodě a i konstruktoru dát jako parametr na první místo klíčové slovo self, které vlastně definuje, že daná metoda, případně konstruktor náleží dané třídě. Ve zdrojovém kódu níže je klíčové slovo selfv definici konstruktoru vynecháno a to způsobuje chybu při překladu. class Auto: def __init__(jm, ci): self.jmeno = jm self.cislo = ci def __del__(self):
Schopnosti překladačů programovacího jazyka Python
71
print "Auto zanika" auto = Auto("Opel", 1235) print auto.jmeno print auto.cislo del auto Další chyba týkající se opět klíčového slova self nastane ve chvíli, kdy při přiřazování hodnot z parametrů konstruktoru do atributů dané třídy nepoužijeme před jménem atributu dané třídy klíčové slovo self. Příklad této chyby můžete vidět níže. class Auto: def __init__(self, jm, ci): jmeno = jm self.cislo = ci def __del__(self): print "Auto zanika" auto = Auto("Opel", 1235) print auto.jmeno print auto.cislo del auto Další chyby, které uvedeme se týkají zejména nepozornost programátorů. První z nich je zapomenutí dvojtečky za definicí třídy, případně definicí metody apod. V příkladu níže, můžete vidět, že za definicí jména třídy není uvedena dvojtečka. class Auto def __init__(self, jm, ci): self.jmeno = jm self.cislo = ci def __del__(self): print "Auto zanika" auto = Auto("Opel", 1235) print auto.jmeno print auto.cislo del auto Pokud zapomeneme při definování jakékoliv třídy klíčové slovo class také samozřejmě dojde k chybě. V příkladu pod tímto textem je toto klíčové slovo zapomenuto před jménem třídy Auto.
Schopnosti překladačů programovacího jazyka Python
Auto: def __init__(self, jm, ci): self.jmeno = jm self.cislo = ci def __del__(self): print "Auto zanika" auto = Auto("Opel", 1235) print auto.jmeno print auto.cislo del auto Dále pokud před definicí jakékoliv metody, případně konstruktoru či destruktoru zapomeneme uvést klíčové slovo def dochází k chybě. V následujícím příkladu není toto klíčové slovo uvedeno před definicí konstruktoru třídy Auto. class Auto: __init__(self, jm, ci): self.jmeno = jm self.cislo = ci def __del__(self): print "Auto zanika" auto = Auto("Opel", 1235) print auto.jmeno print auto.cislo del auto
72
Schopnosti překladačů programovacího jazyka Python
73
9 Průběh hodnocení překladačů Každý z překladačů bude otestován v prostředí dvou operačních systémů – Linux Ubuntu 14 a Windows 8.1, pokud to kompatibilita daného překladače umožní. Testování bude probíhat z hlediska již dříve popsaných hodnotících kritérií. Všechny kritéria kromě obtížnosti instalace a odinstalace, časové a prostorové náročnost překladu, budou hodnoceny nezávisle na operačním systému, jelikož např. úroveň dokumentace je stejná pro jakýkoliv operační systém. V případě že bude hodnocení kritéria probíhat v prostředí dvou operačních systémů, pak bude celková známka za dané kritérium dána průměrem známek tohoto kritéria z prostředí operačního systému Windows a Linux. Hodnocení překladače z hlediska daného kritéria bude probíhat pomocí známek 1 až 5 (jako ve škole). Určitě se teď také ptáte, jak bude pomocí známek 1 až 5 hodnocena časová a prostorová náročnost překladu. Výsledné známkování těchto kritérií proběhne až po změření časových a prostorových náročností všech překladačů, poté z naměřených hodnot budou určeny hranice pro jednotlivé známky, tj. nejnižší naměřený čas a prostor bude odpovídat známce 1 apod. Jelikož bude testování probíhat pomocí několika testovacích úloh z dané oblasti, tak budou výsledné hodnoty vždy pro danou oblast zprůměrovány a výsledná známka pro např. časovou složitost překladu bude opět průměrem všech hodnot z různých oblastí testovacích úloh – opět pro každý operační systém zvlášť. Dále bude každému kritériu přiřazena jeho váha (čím větší váha, tím důležitější je dané kritérium). Váhy jednotlivých kritérií můžete vidět v tabulce níže. Celkové známka daného překladače bude poté dána váženým průměrem všech známek, které získal. V případě, že se bude jednat o kritéria, která jsou závislá na operačním systému, bude hodnota tohoto kritéria dána průměrem vážených průměrů tohoto kritéria u operačního systému Windows 8.1 a Linux Ubuntu. Hodnotící kritérium Obtížnost instalace Obtížnost odinstalace Kompatibilita s operačními systémy Možnosti zpětné vazby k uživateli Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu Časová náročnost překladu Prostorová náročnost překladu Úroveň dokumentace
Váha kritéria 4 4 3 10 10 8 7 6
Schopnosti překladačů programovacího jazyka Python
74
Známky pro ohodnocení časové a prostorové náročnosti překladu byly vypočteny až po ohodnocení těchto kritérií u všech zkoumaných překladačů a to způsobem jaký byl již dříve uveden. Známky pro časovou náročnost překladu nacházející se v jednotlivých intervalech jsou: Známka 1 – 11 až 304 ms Známka 2 – 305 až 598 ms Známka 3 – 599 až 892 ms Známka 4 – 893 až 1186 ms Známka 5 – 1187 až 1480 ms Známky pro prostorovou náročnost překladu nacházející se v jednotlivých intervalech jsou: Známka 1 – 3 až 43 MB Známka 2 – 44 až 84 MB Známka 3 – 85 až 125 MB Známka 4 – 126 až 166 MB Známka 5 – 167 až 207 MB
Schopnosti překladačů programovacího jazyka Python
75
10 Výsledky 10.1
Překladač Pyjamas
10.1.1
Obtížnost instalace
Základním požadavkem pro instalaci (na obou operačních systémech, na kterých probíhalo testování – Windows 8.1 a Linux Ubuntu), nebo spíše konfigurace tohoto překladače, je mít nainstalován oficiální překladač programovacího jazyka Python. Ten je dostupný volně ke stažení na internetových stránkách www.python.org. Samotná instalace tohoto překladače tudíž není realizována pomocí průvodce, ale velmi závisí na úrovni dokumentace, která je dostupná na webových stránkách překladače. Úrovni dokumentace se budeme věnovat samostatně při hodnocení tohoto kritéria. Co se týče celkové obtížnosti instalace, samotná instalace, v tomto případě spíše konfigurace není nijak těžká, spíše je těžší si dané informace jak ji provést na webových stránkách tohoto překladače najít. Informace o instalaci se totiž nenachází přímo na stránkách překladače, ale jsou skryty v GitHubovém repositáři tohoto projektu (překladače). Pokud se tedy zaměříme na samotnou instalaci, ta je pod oběma operačními systémy, na kterých testování překladačů probíhalo stejná. Instalace se skládá z několika kroků: Instalace oficiálního překladače programovacího jazyka Python, dostupného na www.python.org Stažení překladače (knihoven) Pyjamas Extrakce těchto souborů a vytvoření adresáře Pyjamas na disku C, v případě operačního systému Linux Ubuntu vytvoření této složky v kořenovém adresáři
10.1.2
Obtížnost odinstalace
Pokud se zaměříme na obtížnost odinstalace tohoto překladače, tak se nemůžeme opřít o žádné informace z dokumentace. Když budeme vycházet ze znalostí, které jsme získali při instalaci překladače Pyjamas, tak stačí z příslušných složek smazat příslušné soubory (týká se to obou operačních systémů – Windows 8.1 i Linux Ubuntu). Pokud bychom chtěli být korektní, a odinstalaci dokončit úplně, pak musíme také odebrat oficiální překladač jazyka Python. Jeho odinstalaci bude ale věnována samostatná kapitola – při jeho hodnocení.
Schopnosti překladačů programovacího jazyka Python
10.1.3
76
Kompatibilita s operačními systémy
Pokud budeme vycházet z informací, které jsou dostupné přímo na webových stánkách daného překladače – www.pyjs.org, tak se toho moc o této oblasti nedozvíme. Pokud budeme pátrat a opět přejdeme na GitHubový repositář tohoto projektu, můžeme snadno vydedukovat, že jelikož je v tomto repositáři uveden postup pro instalaci na operačních systémech Windows a Linux, pak je překladač Pyjamas také s těmito operačními systémy kompatibilní.
10.1.4
Možnosti zpětné vazby k uživateli
Jelikož tento překladač plně využívá oficiálního překladače programovacího jazyka Python, pak i způsob jakým poskytuje zpětnou vazbu uživateli je stejný jako u tohoto překladače. Více informací o principu činnosti tohoto překladače je uvedeno v dřívějších kapitolách – konkrétně v kapitole věnované zkoumaným překladačům programovacího jazyka Python. Výsledné hodnocení překladače v oblasti tohoto kritéria bude tedy stejné jako u oficiálního překladače programovacího jazyka Python.
10.1.5 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu Jedná se o podobný příklad jako u kritéria možnosti zpětné vazby k uživateli. Jelikož je využíváno oficiálního překladače jazyka Python (dostupného na www.python.org), pak bude hodnocení tohoto kritéria stejné jako u oficiálního překladače Python.
10.1.6
Časová náročnost překladu
Jelikož tento překladač (interpret) využívá oficiálního překladače jazyka Python tak se výsledky moc neliší právě od výsledků tohoto překladače. Nicméně malý rozdíl v nich je. V obou testovaných systémech – Linux Ubuntu a Windows 8.1 bylo dosaženo vyšších hodnot časové náročnosti překladu. Je to způsobeno zejména tím, že po překladu daných zdrojových kódu, překladač Pyjamas generuje z daného kódu Javascript. Zajímavostí je také porovnání časové složitosti mezi těmito dvěma operačními systémy. Hodnoty časové náročnosti překladu u operačního systému jsou značně vyšší. To je nejspíše dáno odlišnou architekturou obou operačních systémů. Níže pod tímto textem jsem uvedeny grafy, které přehledně zobrazují dosažené výsledky.
Schopnosti překladačů programovacího jazyka Python
77
Porovnání časové náročnosti překladu u skriptů bez chyb (ms) 250
208,375
200 150 100 50
36,625
0 Windows 8.1
Linux Ubuntu
Obrázek 14: Překladač Pyjamas - porovnání časové náročnosti překladu u skriptů bez chyb
10.1.7
Prostorová náročnost překladu
Podobně jako je to s časovou náročností u překladače Pyjamas, tak je tomu i s prostorovou složitostí jeho překladu. V prostředí obou operačních systémů bylo dosaženo vyšších výsledků, než v porovnání s oficiálním překladačem programovacího jazyka Python. Je to opět dáno tím, že Pyjamas poté generuje Javascriptový kód, tudíž v porovnání se standardním překladačem Pythonu spotřebuje více operační paměti. Na rozdíl od časové náročnosti překladu zde jsou role obráceny. Prostorová náročnost překladu je vyšší u operačního systému Windows 8.1. Tento rozdíl je dán rozdílnou správou paměti (oproti operačnímu systému Linux Ubuntu). Níže jsou opět uvedeny výsledky ve formě grafů.
29
Porovnání prostorové náročnosti překladu u skriptů bez chyb (MB) 28
28 27 26 25
24,125
24 23 22 Windows 8.1
Linux Ubuntu
Obrázek 15: Překladač Pyjamas - porovnání prostorové náročnosti překladu u skriptů bez chyb
Schopnosti překladačů programovacího jazyka Python
10.1.8
78
Úroveň dokumentace
Posledním kritériem je samotná úroveň dokumentace, o které bylo již při hodnocení několika předešlých kritérií zmíněno. Dokumentace je dostupná na oficiálních stránkách překladače – www.pyjs.org. V dokumentaci jsou sice velmi dobře a přehledně uvedeny jednotlivé příkazy apod., ale chybí u nich nějaké podrobnější informace, který by u nich očekával snad každý programátor, tj. např. nějaké ukázkové použití dané funkce apod. Jak už bylo dříve zmíněno v souvislosti s instalací (konfigurací) tohoto překladače, všechny tyto informace by podle mého názoru měli být uvedeny v dokumentaci a ne někde odděleně v GitHubovém repositáři. Co je pozitivní na dokumentaci, je větší množství obsáhlejší ukázkových příkladů.
10.1.9
Hodnocení překladače Pyjamas
Obtížnost instalace – 3 Obtížnost odinstalace – 2 Kompatibilita s operačními systémy – 3 Možnosti zpětné vazby k uživateli – 2 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu – 2 Časová náročnost překladu – 1 Prostorová náročnost překladu – 1 Úroveň dokumentace – 4
10.2
Překladač Python
10.2.1
Obtížnost instalace
Jedná se o oficiální překladač jazyka Python. Součástí balíčku, který je volně dostupný ke stažení na webových stránkách www.python.org je i vývojové prostředí IDLE. Co se týče samotné instalace tohoto překladače je velmi jednoduchá a srozumitelná. Napřed se zaměříme na instalaci v prostředí operačního systému Windows 8.1. Tam je instalace totiž realizována tzv. průvodcem, který se uživatele postupně ptá na různé informace, které potřebuje znát, např. kam má daný program – v našem případě tento překladač nainstalovat apod. Pokud se přesuneme do prostředí operačního systému Linux Ubuntu, tak tam je instalace ještě snadnější – ve většině linuxových distribucích je totiž překladač (interpret) programovacího jazyka Python již nainstalován. Stejně tak tomu je i v našem případě, tedy v případě operačního systému Linux Ubuntu. Jediné co bylo doinstalováno, bylo vývojové prostředí IDLE a to pomocí Ubuntu Software Center.
Schopnosti překladačů programovacího jazyka Python
10.2.2
79
Obtížnost odinstalace
V prostředí operačního systému Windows 8.1 je odinstalace daného překladače velmi jednoduchá. Součástí nainstalovaného překladače, nebo chcete-li celého balíčku je i odinstalační program, který stačí spustit a překladač Python je odinstalován podobným způsobem, jako byl nainstalován, tj. pomocí tzv. průvodce. Pokud se zaměříme na prostředí druhého operačního systému, tj. systému Linux Ubuntu tak z něj můžeme odebrat maximálně vývojové prostředí IDLE, které bylo doinstalováno a můžeme tak učinit opět pomocí Ubuntu Software Center. Samotný překladač (interpret) programovacího jazyka Python odebrán být nemůže, protože je součástí této linuxové distribuce.
10.2.3
Kompatibilita s operačními systémy
Pokud budeme vycházet z informací, které jsou uvedeny na oficiálních webových stránkách překladače Python, pak snadno zjistíme, že tento překladač je kompatibilní se všemi třemi nejpoužívanějšími operačními systémy, tedy s operačním systémem Windows, Linux a Mac OS.
10.2.4
Možnosti zpětné vazby k uživateli
Pokud se budeme zabývat zpětnou vazbou, kterou poskytuje překladač Python uživateli, dojdeme k následujícímu závěru. Tento překladač totiž poskytuje uživateli zpětnou vazbu v závislosti na typu chyby, kterou zrovna nalezl. Pokud dojde při překladu k lexikální nebo syntaktické chybě, pak je uživateli zobrazeno varování ve formě messageboxu – to vše ovšem pouze za předpokladu, že pro vývoj používáme vývojové prostředí IDLE, které bylo součástí překladače. Po odsouhlasení (stisku tlačítka OK v tomto messageboxu) je zobrazen daný program ve vývojovém prostředí IDLE a kurzor je umístěn na řádek, kde se chyba nachází.
Schopnosti překladačů programovacího jazyka Python
80
Obrázek 16: Překladač Python - zpětná vazba k uživateli při nalezení lexikálních a syntaktických chyb
Pokud naopak dojde k chybě při sémantické fázi překladu, už o této skutečnosti není uživatel informován formou messageboxu, ale normálním výpisem této chyby v příkazovém řádku, nebo v pythonovské konzoli.
Obrázek 17: Překladač Python - zpětná vazba k uživateli při nalezení sémantických chyb
Pokud shrneme zpětnou vazbu, kterou překladač Python poskytuje uživatelům, pak dojdeme k závěru, že informace, které poskytuje o sémantických chybách, jsou na dobré úrovni – poskytuje informace o typu chyby, řádku na kterém se nachází. Naopak v oblasti zpětné vazby ohledně lexikálních a syntaktických chyb bych uvítal více informací, než jen pouhé zvýraznění řádku, kde se daná chyba nachází.
Schopnosti překladačů programovacího jazyka Python
81
10.2.5 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu Pokud se zaměříme obecně na reakci na nalezené chyby, pak překladač Python reaguje na lexikální a syntaktické chyby stejně – pomocí již dříve zmíněného messageboxu a hlášky syntax error. Dalším druhem chyb, na které reaguje, jsou chyby sémantické a na ty, jak už bylo dříve zmíněno, reaguje podrobněji a lépe. Nyní se pojďme podrobněji zaměřit na reakce překladače Python na chyby v daných testovacích úlohách. Překladač Python našel a identifikoval téměř všechny již dříve uvedené chyby (kapitola Testovací úlohy), tak jak bychom očekávali. Nicméně ani tento překladač není bezchybný a při testování bylo zjištěno pár zajímavostí. První chybou - konkrétně sémantickou chybou, kterou překladač Python neidentifikoval je chyba týkající se přístupu k znakům určitého řetězce. Testovací úloha, u které se tomu tak stalo pochází ze sekce Práce s řetězci. Konkrétně se tedy jedná o tento kousek kódu. a = "ahoj" print a[5:] Ve výše uvedeném kousku kódu se snažím vypsat znaky řetězce od indexu 5 až do konce, ale délka daného řetězce je 4. Zajímavostí je, že pokud se budu snažit jen přistoupit na 5. prvek dané proměnné, tak překladač Python už zahlásí chybu. V následujícím textu si přehledně shrneme reakce na nejčastěji se vyskytující chyby: Chyby související se syntaxí – messagebox syntax error Neuvedení potřebného počtu parametrů - TypeError: range expected at least * arguments, got 0, kde * udává počet parametrů, které dané funkce vyžaduje Použití čísla vyššího jak maxint – MemoryError Volání nedefinované proměnné - NameError: name '*' is not defined, kde * udává jméno nedefinované proměnné Přístup k atributu, který nemá daná třída definována - AttributeError: * instance has no attribute '**', kde * označuje jméno třídy a ** daný atribut, který není definován v této třídě Přístup k prvku na nedefinovaném indexu - IndexError: tuple index out of range Přístup číselné proměnné k řetězcovým metodám - AttributeError: 'int' object has no attribute '*‘, kde * je název metody, která byla použita Spojování řetězcové a číselné proměnné - TypeError: cannot concatenate 'str' and 'int' objects Dělení nulou - ZeroDivisionError: float division by zero
Schopnosti překladačů programovacího jazyka Python
10.2.6
82
Časová náročnost překladu
Zaměříme-li se na časovou náročnost překladu, pak můžeme zjistit mnoho zajímavých věcí. Průměrná časová náročnost překladu je pod operačním systémem Windows 8.1 32,25ms. Pokud se zaměříme na testovací úlohy, ve kterých byly schválně uvedeny chyby, v případě, že se jednalo o chyby sémantické, pak průměrná časová náročnost překladu takového skriptu byla 24,25ms a v případě chyb syntaktických, případně lexikální tato hodnota činila 15,87ms. V prostředí operačního systému Linux jsme došli k obdobným výsledkům. Opět nejvyšší hodnotu měla časová náročnost překladu skriptů, které byly bez chyb. Tyto skutečnosti jsou zejména dány tím, že programovací jazyk Python je totiž jazyk interpretovaný. Tudíž pokud je při překladu (interpretaci) nalezena chyba, pak je překlad ukončen a tudíž je jeho časová náročnost menší, než když překladač přeloží celý program. Všechny výsledky jsou přehledně interpretovány v grafech níže. Srovnání časové náročnosti překladu testovacích úloh u Windows 8.1 (ms) 35
32,25
30 25
24,25
20 15,875 15 10 5 0 Sémantické chyby
Lexikální a syntaktické chyby
Bez chyb
Obrázek 18: Překladač Python - srovnání časové náročnosti překladu testovacích úloh v prostředí Windows 8.1
Schopnosti překladačů programovacího jazyka Python
83
Srovnání časové náročnosti překladu (ms) 250 200 150 100 50 0
207
32,25
Windows 8.1
Linux Ubuntu
Obrázek 19: Překladač Python - srovnání časové náročnosti překladu u jednotlivých operačních systémů
10.2.7
Prostorová náročnost překladu
Prostorová složitost překladu nebývá ve dvou testovaných operačních systémech – systému Windows 8.1 a Linux Ubuntu velmi podobných hodnot. Zaměřme se tedy napřed na prostředí operačního systému Windows 8.1. V tomto systému u všech testovaných úloh, ať už se jednalo o verze s chybami nebo bez byla naměřena průměrná prostorová náročnost překladu 21MB. Nyní přejdeme do prostředí druhého z operačních systémů. V systému Linux Ubuntu byly naměřeny velmi podobné hodnoty. Průměrná hodnota prostorové náročnosti překladu v tomto systému je tedy 23MB.
Srovnání prostorové náročnosti překladu (MB) 24 23 23 22 21 21 20 Windows 8.1
Linux Ubuntu
Obrázek 20: Překladač Python - srovnání prostorové náročnosti překladu u jednotlivých operačních systémů
10.2.8
Úroveň dokumentace
Dokumentace k překladači Python je dostupná online na webových stránkách www.python.org/doc. Je velmi přehledná a obsáhlá. Zahrnuje i návody a postupy jak instalovat překladač Python v prostředích operačních systémů Windows, Linux
Schopnosti překladačů programovacího jazyka Python
84
i Mac OS. Také obsahuje různé tutoriály a návody jak začít vyvíjet pomocí programovacího jazyka Python. Celkově hodnotím tuto dokumentaci jako velmi povedenou.
10.2.9
Hodnocení překladače Python
Obtížnost instalace – 1 Obtížnost odinstalace – 1 Kompatibilita s operačními systémy – 1 Možnosti zpětné vazby k uživateli – 2 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu – 1,3 Časová náročnost překladu – 1 Prostorová náročnost překladu – 1 Úroveň dokumentace - 1
10.3
Překladač Skulpt
10.3.1
Obtížnost instalace
Překladač Skuplt je, jak už bylo zmíněno v kapitole, která je věnována podrobnému popisu všech testovaných překladačů dostupný jako online služba. Tudíž nemusí být instalován.
10.3.2
Obtížnost odinstalace
Souvisí s předchozím bodem – obtížností instalace. Jelikož je tento překladač dostupný jako online služba, pak nemusí být v případě nepoužívání nijak odebírán.
10.3.3
Kompatibilita s operačními systémy
Zde opět můžeme nalézt souvislost s předchozími body. Jelikož je překladač Skulpt dostupný online, pak je plně kompatibilní se všemi používanými operačními systémy. Stačí mít spuštěný webový prohlížeč.
10.3.4
Možnosti zpětné vazby k uživateli
I přes skutečnost, že překladač Skulpt je dostupný jako online služba jsou jeho možnosti zpětné vazby k uživateli na velmi dobré úrovni. V porovnáním s předešlými překladači, např. s oficiálním překladačem jazyka Python neinformuje uživatele o nalezených chybách tak podrobně, ale i tak jsou informace o daných chybách postačující. Jednu takovou reakci si můžete prohlédnout na obrázku níže.
Schopnosti překladačů programovacího jazyka Python
85
Obrázek 21: Překladač Skulpt - ukázka zpětné vazby k uživateli
Na obrázku můžete reakci překladače (interpretu) směrem k uživateli vidět v červeném pruhu.
10.3.5 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu Překladač Skulpt vůbec nerozlišuje nějaká druhy chyb při překladu, jak tomu bylo např. u oficiálního překladače Pythonu, který rozlišoval syntaktické (mezi tyto chyby řadil i lexikální) a sémantické chyby. Tento překladač na všechny tyto druhy chyb samozřejmě reaguje, ale nijak nerozlišuje jejich druhy. Zajímavostí je, že opět jako v případě oficiálního překladače jazyka Python nereaguje na stejnou chybu, tj. když chci pomocí funkce print vypsat obsah řetězcové proměnné od pozice, která už v daném řetězci není až do konce. Dále v tomto interpretu jazyka Python nejsou implementovány knihovny urllib2 a urllib, které slouží pro zpracovávání http požadavků – jsou využívány v testovacích úlohách zabývajících se webovými službami. Stejný případ nastal při testování úloh týkajících se XML souborů – tento překladač nemá implementovanou knihovnu xml.etree.cElementTree. Poslední problém nastal ve chvíli, kdy měli být testovány úlohy týkající se čtení a zápisu do souborů. Tyto funkce totiž tento online překladač (interpret) také implementovány nemá. V následujícím textu si opět přehledně shrneme reakce na nejčastěji se vyskytující chyby: Chyby související se syntaxí – ParseError: bad input on line *, kde * je číslo řádku Neuvedení potřebného počtu parametrů - TypeError: *() takes at ** arguments (***) on line ****, kde * je název funkce, ** je počet argumentů, která
Schopnosti překladačů programovacího jazyka Python
86
funkce potřebuje, *** je počet argumentů, které dané funkce dostala a **** je číslo řádku na kterém se daná chyba vyskytuje Použití čísla vyššího jak maxint – dojde k pádu webové aplikace Volání nedefinované proměnné - NameError: name '*' is not defined on line **, kde * udává jméno nedefinované proměnné a ** číslo řádku na kterém se daná chyba vyskytuje Přístup k atributu, který nemá daná třída definována - AttributeError: ‘*‘ object has no atribute ‘**‘ on line ***, kde * je název třídy u jejíž instance se chyba vyskytla, ** je název atributu, který není definován a *** je číslo řádku, kde se daná chyba nachází Přístup k prvku na nedefinovaném indexu - IndexError: tuple index out of range Přístup číselné proměnné k řetězcovým metodám - AttributeError: 'int' object has no attribute '*‘, kde * je název metody, která byla použita Spojování řetězcové a číselné proměnné - TypeError: cannot concatenate 'str' and 'int' objects on line *, kde * je číslo řádku kde daná chyba je Dělení nulou - ZeroDivisionError: interger division or modulo by zero on line *, kde * je číslo řádku, kde se daná chyba vyskytuje
10.3.6
Časová náročnost překladu
Časová náročnost překladu se na rozdíl od předešlých překladačů nemůže nijak lišit v prostředí různých operačních systémů. Proto bude také zkoumána pouze v prostředí jednoho z nich. Jelikož se jedná o online překladač bude tato vlastnost zkoumána jiným způsobem než u předešlých překladačů. Do každé testovací úlohy bude na začátek přidána proměnná start, která ponese v sobě přibližný start skriptu. Za touto definicí bude následovat blok kódu, který má být proveden (původní testovací úloha) a na jejím konci bude pomocí příkazu print vypsán rozdíl aktuálně zjištěného času a proměnné start. Tak získáme přibližný čas překladu (interpretace) daných testovacích úloh. Nicméně takto nemůžeme zjistit časovou náročnost testovacích úloh, které v sobě obsahují chyby. Jelikož programovací jazyk Python je jazykem interpretovaným, takže překladač přestane interpretovat zdrojový kód ve chvíli, kdy narazí na chybu. Tudíž se vůbec nedostane k poslednímu řádku kódu, kde zjišťujeme celkový čas. Z tohoto důvodu může být u tohoto překladače hodnocena pouze jeho časová náročnost překladu u testovacích úloh bez chyb. Pokud se zaměříme na níže uvedených graf, který znázorňuje časovou náročnost překladů jednotlivých typů úloh, můžeme zjistit, že nejvyšších hodnot nabývala časová náročnost překladu u úloh, kde docházelo k práci s cykly. V grafu jsou také u některých typů úloh uvedeny nulové hodnoty. Je tomu tak z toho důvodu, že jak už bylo dříve řečeno, překladač Skulpt nepodporoval práci s knihovnami pro tyto druhy úloh.
Schopnosti překladačů programovacího jazyka Python
87
Srovnání časové náročnosti překladu jednotlivých druhů testovacích úloh (ms) 50 45 40 35 30 25 20 13 15 10 5 0
47
21
19
14 0
0
0
Obrázek 22: Překladač Skulpt - srovnání časové náročnosti překladu jednitlivých typů testovacích úloh
10.3.7
Prostorová náročnost překladu
Prostorová náročnost překladu nemůže být u tohoto překladače objektivně vyhodnocena, jelikož je jedná o online překladač. Proto bude jeho známka za tuto kategorii nabývat hodnoty nula.
10.3.8
Úroveň dokumentace
Posledním hodnotícím kritériem tohoto překladače je jeho úroveň dokumentace. K tomuto překladači není dostupná dokumentace v takové formě, jako je například dostupná dokumentace k dříve hodnoceným překladačům. Jediné informace, které lze o tomto překladači získat můžeme nalézt na jeho webových stránkách – www.skulpt.org. Sice se na těchto stránkách nachází menší množství informací týkajících se např. toho jak tento překladač používat a kde je dostupný, ale podle mého názoru je to nedostačující. Z tohoto důvodu je také úroveň dokumentace tohoto překladače hodnocena nízkou známkou.
10.3.9
Hodnocení překladače Skulpt
Obtížnost instalace – 1 Obtížnost odinstalace – 1 Kompatibilita s operačními systémy – 1 Možnosti zpětné vazby k uživateli – 2 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu – 1,6 Časová náročnost překladu – 1 Prostorová náročnost překladu – nehodnoceno
Schopnosti překladačů programovacího jazyka Python
88
Úroveň dokumentace - 4
10.4
Překladač Jython
10.4.1
Obtížnost instalace
Jelikož se jedná o překladač, který generuje jar soubory, tudíž využívá Java Development Kit, tak je hlavním požadavkem mít tuto sadu nástrojů nainstalovánu. Dalším z požadavků je mít nainstalován opět jako u většiny předešlých překladačů, oficiální překladač programovacího jazyka Python. Toho překladač Jythontotiž využívá. Díky němu je pak možné, jak už bylo zmíněno v kapitole věnované samotným překladačům, využívat v pythonovských skriptech konstrukce programovacího jazyka Java. Poté je třeba nainstalovat samotný překladač Jython. Instalace probíhá velmi uživatelsky přívětivě, konkrétně pomocí průvodce, který sám rozbalí a nainstaluje vše potřebné do vašeho počítače. Tento výše uvedený postup platí pro prostředí operačního systému Windows 8.1. Pro druhý z operačních systémů – Linux Ubuntu tento překladač není dostupný. Nicméně následně vygenerovaný jar soubor, tedy soubor v tzv. JavaByte kódu je spustitelný (kompatibilní) i s operačním systémem Linux Ubuntu (za předpokladu, že je na něm nainstalována Java).
Obrázek 23: Překladač Jython – instalace
Samotný překlad je prováděn pomocí příkazové řádky pomocí příkazu java – jar. Za tento příkaz je poté nutné uvést cestu k souboru jython.jar a cestu k souboru, který obsahuje příslušný pythonovský skript.
Schopnosti překladačů programovacího jazyka Python
10.4.2
89
Obtížnost odinstalace
Ačkoliv je instalace tohoto překladače prováděna pomocí průvodce, tak pokud se zaměříme na odinstalaci, je tomu úplně jinak. V prostředí operačního systému Windows 8.1 je nutné využít ovládacích panelů, kde je možné odebírat všechny aktuálně nainstalované programy. Jelikož pro prostředí systému Linux Ubuntu není tento překladač dostupný, nebudeme se jeho odinstalací v tomto prostředí zabývat.
10.4.3
Kompatibilita s operačními systémy
Co se týče samotného překladače, ten je kompatibilní pouze s jedním z nejpoužívanějších operačních systémů, konkrétně tedy s operačním systémem Windows. Nicméně, jak už bylo dříve zmíněno, výsledný jar soubor je za předpokladu nainstalované Javy na daném počítači, spustitelný i v prostředí dalších operačních systémů.
10.4.4
Možnosti zpětné vazby k uživateli
Možnosti zpětné vazby k uživateli odpovídají dvěma skutečnostem. Tou první je, že pro překlad je opět využíván oficiální překladač programovacího jazyka Python a tou druhou, že překlad probíhá v prostředí příkazové řádky, tudíž nemůže být daná chyba, nalezená při překladu, nijak graficky zvýrazněna apod. I přes tuto skutečnost je ale úroveň zpětné vazby k uživateli dostačující. V případě, že je nalezena chyba, pak je stejně jako u oficiálního překladače Pythonu oznámen druh chyby a i pozice, včetně čísla řádku, na kterém se nachází.
Obrázek 24: Překladač Jython - možnosti zpětné vazby k uživateli
Schopnosti překladačů programovacího jazyka Python
90
10.4.5 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu Překladač Jython, stejně tak jako oficiální překladač jazyka Python (podobnost zde není náhodou – Jython využívá oficiální překladač jazyka Python, on sám pouze překládá do JavaByte kódu a případně umožňuje používat v pythonovských skriptech některé prvky programovacího jazyka Java), rozlišuje synktatické a sémantické chyby. Mezi chyby syntaktické řadí chyby, které se vyskytnou jak v lexikální, tak i v syntaktické fázi překladu. Na tuto chyby reaguje hláškou SyntaxError. Zaměříme – li se na chyby sémantické, tak u nich už rozlišuje jejich typ, který odpovídá typům chyb uvedeným již dříve, při podrobném hodnocení oficiálního překladače programovacího jazyka Python.
10.4.6
Časová náročnost překladu
Pokud se zaměříme na časovou náročnost překladu u překladače Jython, pak si můžeme povšimnout vyšších hodnot tohoto kritéria. To je dáno zejména vlastní činností tohoto překladače – generuje totiž JavaByte kód. To, že je vyšší časová náročnost překladu skriptů bez chyb je opět dáno tím, že v tomto případě, překladač interpretuje celý skript, zatímco v případě skriptu, ve kterém je chyba, překladač interpretuje zdrojový kód pouze do chvíle, než narazí na chybu. Níže uvedený graf tedy interpretuje časovou náročnost překladu pouze v prostředí operačního systému Windows 8.1, jelikož překladač Jython není pro operační systém Linux Ubuntu dostupný. Srovnání časové náročnosti překladu (ms) 3020,0 3000,0 2980,0 2960,0 2940,0 2920,0 2900,0 2880,0 2860,0 2840,0 2820,0 2800,0
3005,0 2986,1
2880,0
Sémantické chyby
Lexikální a syntaktické chyby
Bez chyb
Obrázek 25: Překladač Jython - srovnání časové náročnosti překladu u jednotlivých typů testovacích úloh
Schopnosti překladačů programovacího jazyka Python
10.4.7
91
Prostorová náročnost překladu
U prostorové náročnosti překladu opět platí stejná vlastnost, jako u časové náročnosti překladu a to, že její velikost u překladu skriptů bez chyb je větší, jak u skriptů ve kterých se chyby vyskytují. Pokud se zaměříme na velikost prostorové náročnosti v souvislosti s dalšími překladači, pak zjistíme, že její velikost se příliš neliší, tak jak např. u časové náročnosti překladu. Srovnání prostorové náročnosti překladu (MB) 20,4 20,2 20,0 19,8 19,6 19,4 19,2 19,0 18,8
20,2
19,4
Sémantické chyby
19,5
Lexikální a syntaktické chyby
Bez chyb
Obrázek 26: Překladač Jython - srovnání prostorové náročnosti překladu u jednotlivých typů testovaných úloh
10.4.8
Úroveň dokumentace
Dokumentace je stejně jako ve většině případů dostupná online na webových stránkách překladače Jython. Konkrétně se jedná o webovou stránku www.jython.org. Úroveň dokumentace je velmi dobrá, téměř na stejné úrovni jako např. u překladače Python. Obsahuje velké množství informací, včetně informací o instalaci apod. Jediné, co úroveň dokumentace sráží, je její určitá nepřehlednost.
10.4.9
Hodnocení překladače Jython
Obtížnost instalace – 1 Obtížnost odinstalace – 1 Kompatibilita s operačními systémy – 4 Možnosti zpětné vazby k uživateli – 2 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu – 1,6 Časová náročnost překladu – 5 Prostorová náročnost překladu – 1 Úroveň dokumentace - 2
Schopnosti překladačů programovacího jazyka Python
10.5
Překladač Ironpython
10.5.1
Obtížnost instalace
92
Již dříve bylo řečeno (konkrétně v kapitole věnované všem testovaným překladačům jazyka Python), překladač Ironpython je vlastně takovým doplňkem vývojového prostředí Visual Basic. Jedná se zřejmě o nejznámější vývojové prostředí vyvinuté firmou Microsoft. Jak už je zvykem, opět využívá oficiálního překladače (interpretu) programovacího jazyka Python. Tudíž jedním z požadavků je mít tento interpret nainstalován, dalším požadavkem je mít nainstalováno vývojové prostředí Visual Studio. Poté můžeme přistoupit k samotné instalaci. Ta je velmi jednoduchá. Je realizována pomocí průvodce a uživatel se nemusí o nic starat. Výsledkem instalace je i přidání šablon projektů v jazyce Python do vývojového prostředí Visual Studio. Tento postup platí pouze pro operační systém Windows, pro jiný druh operačního systému tento překladač není dostupný.
10.5.2
Obtížnost odinstalace
Odinstalace už tak jednoduchá není. Bohužel není dostupná možnost odinstalace, která by byla realizována pomocí průvodce jako instalace. V případě, že chceme překladač Ironpython odebrat musíme smazat obsah příslušné složky, která se nachází v místě, kde máme nainstalováno vývojové prostředí Visual Studio. Konkrétně se jedná o obsah složky Microsoft Visual Studio 10.0/Common7/IDE/Extensions/Ironpython. Po provedení této operace už nebude možné vytvářet Ironpython projekty a překladač Ironpython už nebude dostupný na daném počítači.
10.5.3
Kompatibilita s operačními systémy
Jelikož se jedná o doplněk Visual Studia, které je produktem společnosti Microsoft, tak je tento překladač kompatibilní pouze s operačními systémy Windows.
10.5.4
Možnosti zpětné vazby k uživateli
Možnosti zpětné vazby k uživateli jsou na velmi dobré úrovni, jelikož samotný vývoj pythonovských aplikací může díky překladači Ironpython probíhat v prostředí Visual Studia. Prostředí tohoto vývojového nástroje je velmi interaktivní – např. nezobrazuje chyby až při překladu, ale interaktivně upozorňuje uživatele na nalezené chyby již při psaní zdrojového kódu. Velmi dobrý je i nástroj zobrazující obsahy jednotlivých proměnných v případě nalezení chyby (konkrétně tedy chyb v sémantické fázi překladu). Tento nástroj samozřejmě není dostupný pouze v situacích, kdy jsou nalezeny chyby.
Schopnosti překladačů programovacího jazyka Python
93
Celkově tedy hodnotím úroveň možností zpětné vazby překladače Ironpython velmi dobře, zejména tedy z důvodu, že je pro vývoj používáno velmi propracované vývojové prostředí Visual Studio.
10.5.5 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu Tak jako ve většině překladačů programovacího jazyka Python jsou v prostředí nástroje Visual Studio rozlišovány dva druhy chyb. Jedná se o chyby syntaktické (mezi ně počítá toto vývojové prostředí chyby nalezené v lexikální i syntaktické části překladu) a chyby sémantické. Na první skupinu chyb je uživatel upozorňován již před samotným překladem, díky velmi interaktivnímu vývojovému prostředí Visual Studia. V případě, že se pokusí i tak daný zdrojový kód přeložit, je zobrazeno varování zda opravdu chce přeložit a spustit zdrojový kód obsahující chyby. Na druhou skupinu chyb je uživatel upozorněn až při samotném překladu (interpretaci) zdrojového kódu. Ve chvíli, kdy překladač narazí na chybu, je překlad zastaven a uživatel je informován o nalezené chybě. Informován je uživatel prostřednictvím messageboxu, který je spojen s řádkem, kde se příslušná chyba nachází. Na všechny druhy chyb reaguje překladač Ironpython prostřednictvím Visual Studia velmi dobře a podrobně popisuje jednotlivé druhy chyb, včetně jejich umístění. Nyní se zaměřme na jednotlivé reakce na nejčastěji vyskytující se chyby: Chyby související se syntaxí – invalid syntax Neuvedení potřebného počtu parametrů – TypeError, range expected at least * arguments, got **, kde * je počet argumentů, které funkce potřebuje a ** je počet argumentů, které funkce dostala Použití čísla vyššího jak maxint – OverFlowError Volání nedefinované proměnné – NameError, name * is not defined, kde * je jméno proměnné, která není definována Přístup k atributu, který nemá daná třída definována - AttributeError: ‘*‘ object has no atribute ‘**‘ on line ***, kde * je název třídy, u jejíž instance se chyba vyskytla, ** je název atributu, který není definován a *** je číslo řádku, kde se daná chyba nachází Přístup k prvku na nedefinovaném indexu - IndexError: index out of range Přístup číselné proměnné k řetězcovým metodám - AttributeError: 'int' object has no attribute '*‘, kde * je název metody, která byla použita Spojování řetězcové a číselné proměnné - TypeError: cannot concatenate 'str' and 'int' objects Dělení nulou - ZeroDivisionError: interger division or modulo by zero
Schopnosti překladačů programovacího jazyka Python
10.5.6
94
Časová náročnost překladu
Jelikož je tento překladač dostupný pouze pro operační systém Windows uvádím srovnání časových náročností překladu u jednotlivých typů testovacích úloh - úloh s chybami a bez chyb. Jak plyne z grafu pod tímto textem, časová náročnost testovacích úloh bez chyb značně převyšuje časovou náročnosti překladu úloh s chybami. To je dáno, jak už bylo několikrát řečeno tím, že v případě úloh, kde jsou uvedeny chyby, překladač interpretuje zdrojový kód jen do chvíle, než na danou chybu narazí, zatímco pokud máme zdrojový kód bez chyby, tak jej interpretuje celý. To, že časová náročnost překladu testovacích úloh značně převyšuje všechny další testovací úlohy je také dáno tím, že časová náročnost testovacích úloh zabývajících se webovými službami dosahovala hodnot přes 100ms.
Srovnání časové náročnosti překladu (ms) 140,0 120,0 100,0 80,0 60,0 40,0 20,0 0,0
122,0
26,8
24,8
Sémantické chyby
Syntaktické a lexikální chyby
Bez chyb
Obrázek 27: Překladač Ironpython - srovnání časové náročnosti překladu jednotlivých typů testovacích úloh
10.5.7
Prostorová náročnost překladu
Prostorová náročnost překladu je při použití překladače Ironpython zatím nejvyšší ze všech dosud naměřených hodnot. Není to ale způsobeno samotným překladačem, jako spíše tím, že využívá vývojové prostředí Visual Studio, které samo o sobě využívá hodně operační paměti. Průměrná hodnota prostorové náročnosti překladu u tohoto překladače dosáhla přibližně 415 MB.
10.5.8
Úroveň dokumentace
Dokumentace je dostupná online na webových stránkách překladače Ironpython, konkrétně na adrese www.ironpython.net. Její úroveň je dobrá, obsahuje téměř všechny potřebné informace. Jediné informace, které chybí nebo by mohly být spíše lépe a více rozvedeny, jsou informace týkající se instalace, případně odinstalace překladače Ironpython. Ony samotné tyto dvě činnosti nejsou nijak těžké, ale bylo by dobré mít v dokumentaci rozvedeny a dopsány tyto dvě základní činnosti.
Schopnosti překladačů programovacího jazyka Python
10.5.9
95
Hodnocení překladače Ironpython
Obtížnost instalace – 1 Obtížnost odinstalace – 2 Kompatibilita s operačními systémy – 4 Možnosti zpětné vazby k uživateli – 1 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu – 1 Časová náročnost překladu – 1 Prostorová náročnost překladu – 5 Úroveň dokumentace - 2
10.6
Překladač Stackless Python
10.6.1
Obtížnost instalace
Napřed se zaměříme na prostředí operačního systému Windows 8.1. V tomto prostředí je instalace realizována pomocí tzv. průvodce. Instalační soubor lze stáhnout z webových stránek překladače a poté jej stačí pouze spustit a vše potřebné je automaticky provedeno. I když překladač Stackless Python využívá opět oficiálního překladače jazyka Python, není nutné tento překladač mít nainstalován na počítači. V případě, že jej uživatel nemá dostupný na počítači, instalátor překladače Stackless Python to zjistí a sám jej na počítač nainstaluje. Pokud už na daném počítači je dostupný, tak pouze extrahuje potřebné soubory do složky, kde se oficiální překladač jazyka Python nachází. Pokud se přesuneme do prostředí operačního systému Linux Ubuntu, pak si stačí stáhnout daný soubor a jeho obsah extrahovat do adresáře, kde je umístěn Python na vašem počítači s OS Linux. Je tedy nutné mít už nainstalován překladač jazyka Python. Abychom mohli použít některé vlastnosti tohoto překladače, které jiný překladač nemá, např. práci s microthready, kanály, serializaci apod., musíme importovat danou knihovnu pomocí import stackless. Samozřejmě, že můžeme i nadále používat klasické konstrukce programovacího jazyka Python.
10.6.2
Obtížnost odinstalace
V prostředí operačního systému Windows 8.1 je odinstalace velmi podobná instalaci. Můžeme ji realizovat pomocí dostupného programu pro odinstalaci (průvodce, který odinstaluje a odebere všechny součásti, které nainstaloval). V prostředí systému Linux Ubuntu je odinstalace opět velmi podobná vlastní instalaci. Stačí totiž smazat příslušné soubory, které jsme při instalaci extrahovali do adresáře s Pythonem.
Schopnosti překladačů programovacího jazyka Python
10.6.3
96
Kompatibilita s operačními systémy
Jak vyplývá z informací uvedených na webových stránkách tohoto překladače, je dostupný pro všechny tři nejpoužívanější druhy operačních systémů – Windows, Linux a Mac OS. Pro každý tento operační systém je dokonce dostupný v několikátí verzích. Tyto verze odpovídají verzi oficiálního překladače jazyka Python, který je nutné mít také naistalován.
10.6.4
Možnosti zpětné vazby k uživateli
Možnosti zpětné vazby k uživateli plně odpovídají možnostem zpětné vazby k uživateli u oficiálního překladače programovacího jazyka Python (www.python.org). Protože samotnou instalací překladače Stackless Python vlastně přidáme určité knihovny a možnosti jak interpretovat daný kód z těchto knihoven v daném oficiálním překladači jazyka Python.
10.6.5 Reakce na nalezení chyby v lexikální, syntaktické a sémantické fázi překladu Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu bude probíhat, jak už asi správně tušíte, stejně jako u překladače Python – jelikož překladač Staskless Python jej využívá. Opět jsou rozlišovány dva základní druhy chyb – chyby syntaktické (mezi ně překladač řadí chyby nalezené v lexikální a syntaktické fázi překladu) a chyby sémantické. Na chyby syntaktické reaguje překladač hláškou SyntaxError umístěnou v messageboxu, v případě, že překlad (interpretaci) spouštíme z vývojového prostředí IDLE. Pokud tomu tak není a překlad spouštíme z příkazového řádku, pak na daný druh chyb reaguje překladač pouze výpisem chyby – SyntaxError do příkazového řádku. Pokud se zaměříme na sémantické chyby, tak na ty reaguje překladač stejně, ať už překlad spouštíme z vývojového prostředí IDLE nebo z příkazového řádku – je zobrazeno hlášení o chybě formou výpisu dané chyby.
Schopnosti překladačů programovacího jazyka Python
10.6.6
97
Časová náročnost překladu
Z níže uvedeného grafu můžeme snadno zjistit, že se hodnoty časové náročnosti překladu u obou operačních systémů při porovnání s oficiálním překladačem jazyka Python příliš neliší. To je dáno zejména tím, že překladač Stackless Python jej využívá. Časová náročnost překladu by nabývala nižších hodnot v porovnání se všemi ostatními překladači pouze v případě, kdy bychom začali využívat hlavní výhody tohoto druhu překladače, tj. jeho práci s vlákny apod. Jelikož je pro tyto úlohy tento překladač optimalizován, pak by dosáhnul určitě lepší časové náročnosti překladu než ostatní překladače.
Srovnání časové náročnosti překladu testovacích úloh bez chyb (ms) 188,5
200 150 100 50
31,625
0 Windows 8.1
Linux Ubuntu
Obrázdek 28: Překladač Stackless Python - srovnání časové náročnosti překladu testovacích úloh bez chyb u obou operačních systémů
10.6.7
Prostorová náročnost překladu
V případě, že se zaměříme na prostorovou náročnost překladu, opět u ní můžeme nalézt určitou podobnost s většinou překladačů – nejvíce pak s překladačem Python, kterého využívá. Odlišné hodnoty tohoto kritéria v jednotlivých operačních systémech jsou zejména dány odlišnou správou paměti.
Srovnání prostorové náročnosti překladu testovacích úloh bez chyb (MB) 26,5
26
26 25,5
25
25 24,5 Windows 8.1
Linux Ubuntu
Obrázek 29: Překladač Stackless Python - srovnání prostorové náročnosti překladu úloh bez chyb u obou operačních systémů
Schopnosti překladačů programovacího jazyka Python
10.6.8
98
Úroveň dokumentace
Dokumentace je dostupná na www.stackless.com. Ač se to na první pohled nezdá, je dokumentace velmi obsáhlá a plně dostačující. Obsahuje návod k instalaci (včetně odkazů na příslušné soubory) pro všechny tři nejpoužívanější operační systémy. Dále dokumentace zahrnuje i ukázkové příklady a tutoriály, jak začít používat překladač Stackless Python.
10.6.9
Hodnocení překladače Stackless Python
Obtížnost instalace – 1 Obtížnost odinstalace – 1 Kompatibilita s operačními systémy – 1 Možnosti zpětné vazby k uživateli – 2 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu – 1,3 Časová náročnost překladu – 1 Prostorová náročnost překladu – 1 Úroveň dokumentace - 3
10.7
Překladač Shed Skin
10.7.1
Obtížnost instalace
V prostředí Windows 8.1 je instalace velmi jednoduchá. Z webových stránek je nutní stáhnout instalační soubor, která pouze na uživatelem zadané místo rozbalí všechny potřebné soubory. Samotný překlad je pak realizován v příkazovém řádku dávkového souboru systému Windows – init.bat. V tomto dávkovém souboru pak stačí uvést jméno pythonovského skriptu a je proveden jeho překlad. V prostředí systému Linux Ubuntu si uživatel musí stáhnout zazipovaný soubor, který pouze rozbalí do jakéhokoliv adresáře a opět je vše hotovo. Překlad je poté prováděn pomocí příkazu shedskin, za kterým je nutné uvést jméno pythonovského skriptu, který má být interpretován.
10.7.2
Obtížnost odinstalace
Odinstalace je v obou operačních systémech totožná. Je třeba pouze smazat příslušné soubory a tím je veškerá práce hotová.
10.7.3
Kompatibilita s operačními systémy
Překladač Shed Skin je plně kompatibilní se všemi nejpoužívanějšími operačními systémy. Konkrétně tedy se systémy Windows, Linux a Mac OS.
Schopnosti překladačů programovacího jazyka Python
10.7.4
99
Možnosti zpětné vazby k uživateli
Jelikož se jedná o překladač, který je ovládán z příkazové řádky, pak tomu i odpovídají možnosti, jak může tento překladač poskytnout zpětnou vazbu uživatelům. Uživatel je o nalezených chybách informován prostřednictví zprávy, která je vypsána do příkazové řádky. Uživatel se prostřednictvím této informace dozvídá o jakou chybu se jedná a samozřejmostí je i její umístění (číslo řádku).
10.7.5 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu Překladač velmi dobře rozlišuje syntaktické a sémantické chyby, přesně tak jako všechny doposud prozkoumané překladače jazyka Python. Mezi syntaktické chyby pak překladač opět řadí chyby, které nalezl jak v lexikální, tak i syntaktické fázi překladu. Nyní se tedy zaměříme na to, jak překladač reaguje na nejčastěji se vyskytující chyby: Chyby související se syntaxí – SyntakxError: invalid syntax Neuvedení potřebného počtu parametrů – TypeError, range expected at least * arguments, got **, kde * je počet argumentů, které funkce potřebuje a ** je počet argumentů, které funkce dostala Použití čísla vyššího jak maxint – OverFlowError: result has too many items Volání nedefinované proměnné – NameError, name * is not defined, kde * je jméno proměnné, která není definována Přístup k atributu, který nemá daná třída definována - AttributeError: ‘*‘ object has no atribute ‘**‘ on line ***, kde * je název třídy, u jejíž instance se chyba vyskytla, ** je název atributu, který není definován a *** je číslo řádku, kde se daná chyba nachází Přístup k prvku na nedefinovaném indexu - IndexError: index out of range Přístup číselné proměnné k řetězcovým metodám - AttributeError: 'int' object has no attribute '*‘, kde * je název metody, která byla použita Spojování řetězcové a číselné proměnné - TypeError: cannot concatenate 'str' and 'int' objects Dělení nulou - ZeroDivisionError: interger division or modulo by zero
Schopnosti překladačů programovacího jazyka Python
10.7.6
100
Časová náročnost překladu
Časová náročnost překladu pomocí překladače Shed Skin nabývá jedné z nejnižších hodnot, které byly při zkoumání časové náročnosti překladu u testovaných překladačů zjištěny. Děje se tomu tak u obou operačních systémů – Windows 8.1 i Linux Ubuntu. Tuto skutečnost bychom mohli vysvětlit tak, že jako jeden z mála překladačů nevyužívá oficiální překladač jazyka Python. Jednoduše řečeno nepotřebuje ke své činnosti žádné další součásti.
Srovnání časové náročnosti překladu u testovacích úloh bez chyb (ms) 300 195
200 100
30
0 Windows 8.1
Linux Ubuntu
Obrázek 30: Překladač Shed Skin - srovnání prostorové náročnosti překladu úloh bez chyb u obou operačních systémů
10.7.7
Prostorová náročnost překladu
Hodnoty prostorové náročnosti překladu při použití tohoto překladače také nabývají velmi nízkých hodnot. V případě operačního systému Windows 8.1 se jedná o hodnotu 1,2 MB a v případě operačního systému Linux Ubuntu se jedná o hodnotu 6,47 MB. Tyto nízké výsledky souvisí opět se skutečností, že tento druh překladače nepotřebuje ke své činnosti žádné další součásti (např. oficiální překladač jazyka Python).
Srovnání prostorové náročnosti překladu u testovacích úloh bez chyb (MB) 8
6,4
6 4 2
1,2
0 Windows 8.1
Linux Ubuntu
Obrázek 31: Překladač Shed Skin - srovnání prostorové náročnosti překladu úloh bez chyb u obou operačních systémů
Schopnosti překladačů programovacího jazyka Python
10.7.8
101
Úroveň dokumentace
Dokumentace je zpracována velmi stručně, ale nachází se v ní vše, co je pro spuštění, tj. konfiguraci překladače nutné. Je pravda, že by mohla být více, tím je myšleno podrobněji zpracována. Na rozdíl od ostatních doposud prozkoumaných dokumentací, neobsahuje tolik ukázkových příkladů a návodů. Nicméně, jak už bylo řečeno, vše potřebné v ní lze nalézt.
10.7.9
Hodnocení překladače Shed Skin
Obtížnost instalace – 1 Obtížnost odinstalace – 1 Kompatibilita s operačními systémy – 1 Možnosti zpětné vazby k uživateli – 2 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu – 1,6 Časová náročnost překladu – 1 Prostorová náročnost překladu – 1 Úroveň dokumentace - 2
10.8
Překladač Py2exe
10.8.1
Obtížnost instalace
Obtížnost instalace bude stejně jako obtížnost odinstalace zkoumána pouze v prostředí operačního systému Windows 8.1, jelikož pro jiný z operačních systémů není tento překladač dostupný. Pro instalaci je nutné si stáhnout z webových stránek překladače, které jsou dostupné na adrese www.py2exe.org instalátor, který už provede vše potřebné. Pokud se zaměříme na samotné spuštění překladu, tak to je trochu náročnější, ale postup je podrobně popsán v dokumentaci, které se budeme věnovat samostaně. Pro samotný překlad musíme napřed vytvořit tzv. setup.py skript, který obsahuje v sobě cestu k souboru, který bude překladán. Tento skript je tvaru: from distutils.core import setup import py2exe setup(console=[‘nazevSkriptu.py‘]) Poté je třeba tento skript spustit v příkazovém řádku pomocí příkazu: python setup.py install
Schopnosti překladačů programovacího jazyka Python
102
Poté je už možné provést překlad – interpretaci daného skriptu, která je uvedený v tzv. setup skritu – setup.py. Překlad provedeme pomocí příkazu: python setup.py py2exe Pokud chceme daný přeložený skript spustit (nyní se nachází ve formě exe souboru, jelikož tento překladač k této činnosti slouží) musíme pomocí příkazu cd v příkazové řádce přejít do složky dist a v ní už můžeme spustit daný exe soubor. Jeho jméno se shoduje se jménem pythonovského skriptu, který byl překládán.
10.8.2
Obtížnost odinstalace
Obtížnost odinstalace je opět zkoumána pouze v jednom z operačních systémů, konkrétně tedy v prostředí systému Windows 8.1, jelikož pro jiný operační systém není tento překladač dostupný. Pokud chceme tento překladač odebrat musíme využít Ovládacích panelů operačního systému Windows 8.1, kde je možné v sekci Programy daný program odinstalovat.
10.8.3
Kompatibilita s operačními systémy
Informace týkající se kompatibility nejsou nikde na stránkách daného překladače dostupné. Nicméně pokud se podíváme do sekce Downloads, kde jsou dostupné všechny instalátory tohoto překladače, tak snadno zjistíme, že jediným systémem, pro který je tento překladač určen, je operační systém Windows.
10.8.4
Možnosti zpětné vazby k uživateli
Možnosti zpětné vazby k uživateli jsou dané možnostmi příkazové řádky, ve které daný překlad (na exe soubor) probíhá. Reakce na chyby je opět stejná jako v případě většiny zkoumaných překladačů. Uživatel je upozorněn na skutečnost, že došlo k chybě a je informován o jaký druh chyby se jedná a o tom, kde se daná chyba nachází.
10.8.5 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu Pokud překladač Py2exe nalezne chybu v lexikální nebo sémantické fázi překladu pak ji ohlásí jako SyntaxError. Naopak pokud nalezne chybu v sémantické fázi překladu, pak danou chybu označí typem chyby (např. TypeError apod.). O každé chybě tedy překladač Py2exe uvádí její typ a i řádek, kde se daná chyby nachází. Pokud se zaměříme na to, jak tento překladač reaguje, na nejčastěji se vyskytující chyby pak dojdeme na to, že reaguje stejně jako většina zkoumaných překladačů.
Schopnosti překladačů programovacího jazyka Python
10.8.6
103
Časová náročnost překladu
Zkoumání časové náročnosti překladu proběhlo v překladače Py2exe pouze v prostředí operačního systému Windows 8.1, jelikož pro další operační systémy tento překladač není dostupný. Zaměříme – li se na níže uvedený graf, snadno si můžeme ověřit již dříve zjištěné informace a to, že časová náročnost překladu testovacích úloh bez chyb je časově náročnější než překlad testovacích úloh s chybami. Je to dáno, tím že při překladu testovacích úloh bez chyb je interpretován celý zdrojový kód, zatímco u testovacích úloh s uvedenými chybami je zdrojový kód interpretován pouze do chvíle, než překladač narazí na danou chybu. Můžeme si také všimnout, že tak jako u všech předchozích zkoumaných překladačů je časová náročnost překladu testovacích úloh se syntaktickými chybami menší než časová náročnost překladu testovacích úloh se sémantickými chybami. To je dáno tím, že překladač napřed provádí lexikální a syntaktickou analýzu. Až po uskutečnění těchto dvou analýz přichází na řadu analýza sémantická.
Srovnání časové náročnosti překladu u jednotlivých typů úloh (ms) 35 30 25 20 15 10 5 0
30,875 19,375
17,875
Sémantické chyby
Syntaktické a lexikální chyby
Bez chyb
Obrázek 32: Překladač Py2exe - srovnání časové náročnosti překladu u jednotlivých typů úloh v prostředí operačního systému Windows 8.1
10.8.7
Prostorová náročnost překladu
Prostorová náročnost překladu byla opět tak jako časová náročnost překladu zkoumána pouze v prostředí operačního systému Windows 8.1. Pro jiný druh operačního systému totiž není tento překladač dostupný. Průměrná hodnota prostorové náročnost testovacích úloh, jak těch bezchybných, tak těch s chybami se pohybovala okolo 12MB.
10.8.8
Úroveň dokumentace
Pokud budeme na webových stánkách tohoto překladače hledat dokumentaci, pak ji nenalezneme. Na stránkách překladače můžeme nalézt pouze v sekci Tuto-
Schopnosti překladačů programovacího jazyka Python
104
rial informace o tom, jak provést instalaci, konfigurace a samotný překladač, případně spuštění výsledného exe souboru. Další informace, které by se měly v dokumentaci nacházet, chybí.
10.8.9
Hodnocení překladače Py2exe
Obtížnost instalace – 1 Obtížnost odinstalace – 2 Kompatibilita s operačními systémy – 4 Možnosti zpětné vazby k uživateli – 2 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu – 1,6 Časová náročnost překladu – 1 Prostorová náročnost překladu – 1 Úroveň dokumentace - 4
10.9
Překladač Active Python
10.9.1
Obtížnost instalace
V prostředí operačního systému Windows 8.1 je instalace velmi snadná. Stačí si pouze stáhnout instalační soubor z webových stránek www.activestate.com/activepython a spustit jej. Po spuštění je provedena instalace tohoto překladače. Instalace je realizována pomocí tzv. průvodce. Samotné vývojové prostředí Komodo, které je k tomuto překladači doporučováno je nutné stáhnout a nainstalovat zvlášť. Přesuneme – li se do prostředí druhého operačního systému, na kterém probíhá testování v rámci této práce, tedy do prostředí operačního systému Linux Ubuntu, je instalace provedena pomocí příkazové řádky a použití příkazu sudo. Ještě se zaměřme na jednotlivé verze tohoto překladače a vývojového prostředí. Testování probíhalo na bezplatných verzích. Bezplatná verze překladače Active Python je dostupná bez nějakého časového omezení. Naopak u vývojového prostředí Komodo je dostupná bezplatně pouze trial verze na 21 dní.
10.9.2
Obtížnost odinstalace
V prostředí operačního systému Windows 8.1 je nutné použít Ovládacích panelů, kde je možné v sekci Programy odebrat všechny nainstalované součásti systému Windows. Naopak v prostředí systému Linux Ubuntu je nutné použít opět příkazové řádky a opaku příkazu sudo. Konkrétně se jedná tento příkaz: sudo apt-get remove název_aplikace
Schopnosti překladačů programovacího jazyka Python
105
Kde je místo název_aplikace uveden konkrétní název aplikace, kterou chceme odebrat, v našem případě se bude jednat o překladač Active Python.
10.9.3
Kompatibilita s operačními systémy
Zaměříme – li se na webové stránky překladače Active Python a jeho dokumentaci, tak snadno zjistíme, že tento překladač je dostupný pro všechny tři nejpoužívanější operační systémy – Windows, Linux a Mac OS. Překladač Active Python je dokonce dostupný i pro další operační systémy, např. pro operační systém Solaris apod.
10.9.4
Možnost zpětné vazby k uživateli
Jelikož je k překladači Active Python doporučováno vývojové prostředí Komodo, pak tomu odpovídají i možnosti zpětné vazby k uživateli. Ty se tedy odvíjejí od možností, jak dokáže poskytovat zpětnou vazbu uživateli právě toto vývojové prostředí. Možnosti zpětné vazby k uživateli jsou velmi obdobné jako u překladače Ironpython, který využívá vývojové prostředí Visual Studio. Na nalezené chyby reaguje překladač Active Python prostřednictvím vývojového prostředí Komodo velmi dobře a přehledně. Řádek, kde byla nalezena chyba, je červeně podtržen a každá chyba je popsána v dolní části tohoto vývojového prostředí.
Obrázek 33: Překladač Active Python - možnosti zpětné vazby k uživateli prostřednictvím vývojového prostředí Komodo
Schopnosti překladačů programovacího jazyka Python
106
10.9.5 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu Jak taková reakce na nalezené chyby probíhá, už bylo řečeno v části o možnostech zpětné reakce k uživateli. Pokud bychom měli rozlišit jak překladač Active Python reaguje na jednotlivé chyby v různých fázích překladu, pak opět dojdeme k závěru, že překladač rozlišuje dva základní druhy chyb. Jedná se o chyby syntaktické, mezi které zahrnuje ty chyby, které nalezne v lexikální a syntaktické fází překladu. Druhým druhem chyb, které tento překladač rozlišuje, jsou chyby sémantické na které reaguje příslušnou informací, která danou chybu identifikuje. V následujícím textu si můžeme prohlédnout, jak tento překladač reaguje na nejčastěji se vyskytující chyby: Chyby související se syntaxí – SyntakxError: invalid syntax Neuvedení potřebného počtu parametrů – TypeError, range expected at least * arguments, got **, kde * je počet argumentů, které funkce potřebuje a ** je počet argumentů, které funkce dostala Použití čísla vyššího jak maxint – OverFlowError: result has too many items Volání nedefinované proměnné – NameError, name * is not defined, kde * je jméno proměnné, která není definována Přístup k atributu, který nemá daná třída definována - AttributeError: ‘*‘ object has no atribute ‘**‘ on line ***, kde * je název třídy, u jejíž instance se chyba vyskytla, ** je název atributu, který není definován a *** je číslo řádku, kde se daná chyba nachází Přístup k prvku na nedefinovaném indexu - IndexError: index out of range Přístup číselné proměnné k řetězcovým metodám - AttributeError: 'int' object has no attribute '*‘, kde * je název metody, která byla použita Spojování řetězcové a číselné proměnné - TypeError: cannot concatenate 'str' and 'int' objects Dělení nulou - ZeroDivisionError: interger division or modulo by zero
10.9.6
Časová náročnost překladu
Časová náročnost překladu je opět vyšší než u předešlých překladačů, jelikož je využíváno vývojového prostředí Komodo, které využívá větší množství zdrojů daného počítače. Pokud srovnáme v prostředí obou operačních systémů výsledky časové náročnosti překladu testovacích úloh se sémantickými, syntaktickými chybami a bez chyb, pak nejvyšších hodnot časové náročnosti opět dosahují testovací úlohy, které jsou bez chyb. Druhých nejvyšších hodnot dosahují testovací úlohy, které v sobě obsahují sémantické chyby a nejmenších časových náročností překladu dosahují testovací úlohy, které obsahují syntaktické (případně lexikální) chyby. Je to dáno tím, že jak už bylo dříve řečeno, testovací úlohy bez chyb jsou interpretovány celé, zatímco testovací úlohy s chybami jsou interpretovány pouze, dokud překladač (interpret) nenarazí na chybu. Testovací chyby obsahující syntaktické a
Schopnosti překladačů programovacího jazyka Python
107
lexikální chyby dosahují nejmenší časové náročnosti překladu, protože překladač napřed provádí lexikální a syntaktickou analýzu a až poté analýzu sémantickou.
Srovnání časové náročnosti překladu u ubou operačních systémů (ms) 250 200 150 100 50 0
207
81,25
Windows 8.1
Linux Ubuntu
Obrázek 34: Překladač Active Python - srovnání prostorové náročnosti překladu v prostředích operačních systémů Windows 8.1 a Linux Ubuntu
10.9.7
Prostorová náročnost překladu
Pokud srovnáme prostorovou náročnost překladu u obou operačních systémů, konkrétně u systémů Windows 8.1 a Linux Ubuntu, pak můžeme zjistit, že se opět potvrdila skutečnost již dříve zjištěná, že prostorová náročnost překladu je vyšší u operačního systému Linux Ubuntu. Celkově jsou hodnoty prostorové náročnost překladu u překladače Active Python vyšší než u předchozích zkoumaných překladačů – to je dáno tím, že podobně jako např. překladač Ironpython využíval vývojové prostředí Visual Studio, tak překladač Active Python využívá vývojového prostředí Komodo.
Srovnání prostorové náročnosti překladu u obou operačních systémů (MB) 200 150
175 131
100 50 0 Windows 8.1
Linux Ubuntu
Obrázek 35: Překladač Active Python - srovnání prostorové náročnosti překladu v prostředích operačních systémů Windows 8.1 a Linux Ubuntu
Schopnosti překladačů programovacího jazyka Python
10.9.8
108
Úroveň dokumentace
Dokumentace k překladači Active Python je dostupná na webových stránkách daného překladače, konkrétně na adrese doc.activestate.com/activepython/2.7/. Dokumentace je velmi podrobná a obsáhlá. Obsahuje všechny potřebné informace, včetně informací o instalaci na všech kompatibilních platformách. Celkově hodnotím úroveň dokumentace velmi dobře.
10.9.9
Hodnocení překladače Active Python
Obtížnost instalace – 1 Obtížnost odinstalace – 1 Kompatibilita s operačními systémy – 1 Možnosti zpětné vazby k uživateli – 1 Reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu – 1,3 Časová náročnost překladu – 1 Prostorová náročnost překladu – 4 Úroveň dokumentace - 1
Schopnosti překladačů programovacího jazyka Python
109
11 Závěr Ze všech zkoumaných překladačů dopadl podle očekávání nejlépe oficiální překladač programovacího jazyka Python – Python. Tato skutečnost se dala očekávat, jelikož se přece jenom jedná o neustále vyvíjený, opravovaný a nejpoužívanější překladač tohoto programovacího jazyka. Samozřejmě má také své vady, kterým se budu věnovat v tomto textu dále. Velmi dobře dopadly (celková známka do 2) také další překladače jako např. Skulpt, který je dostupný jako online služba, dále pak Ironpython, který umožňuje vývoj aplikací v programovacím jazyce Python pomocí Microsoft Visual Studia. Tento překladač mě osobně nejvíce zaujal, jelikož ve vývojovém prostředí Visual Studio vyvíjím velmi rád. Jeho celková známka by byla nižší, nebýt jeho vysoké prostorové náročnosti při překladu, která se dá vysvětlit především větší pamětí, kterou toto velmi kvalitní a vývojové prostředí spotřebuje. Další překladač, který je velmi podobný překladači Ironpython, překladač Active Python, který je nejvíce používán v prostředí Komodo. Tento překladač mne také velmi zaujal, protože je díky vývojovému prostředí Komodo velmi podobný překladači Ironpython. Naopak nejhůře dopadl překladač Jython, který je jedním z neoficiální překladačů, které neposkytují moc kvalitní podporu. Tím je myšlena skutečnost, že nejsou např. pravidelně aktualizovány a vyvíjeny.
Celkové hodnocení všech překladačů 2,50
2,21
2,08
1,90
2,00 1,50
1,52 1,25
1,90 1,48
1,42
1,46
1,00 0,50 0,00
Obrázek 36: Celkové hodnocení zkoumaných překladačů
Nyní se blíže zaměříme na srovnání všech překladačů z hlediska jednotlivých kritérií. Prvním kritériem pro hodnocení zkoumaných překladačů byla obtížnost instalace, která při neznalosti daného překladače hodně souvisí s úrovní dokumentace, které se budeme věnovat dále v tomto textu. Nejhorší známku ze všech zkoumaných překladačů z hlediska obtížnosti instalace získal překladač Pyjamas. Naopak
Schopnosti překladačů programovacího jazyka Python
110
instalace všech dalších překladačů byla ohodnocena známkou 1. Je to dáno, zejména tím, že byla instalace těchto překladačů realizována pomocí tzv. průvodce, nebo byl postup instalace kvalitně popsán v dokumentaci.
Srovnání překladačů z hlediska obtížnosti instalace 4 3 2 1 0
3 1
1
1
1
1
1
1
1
Obrázek 37: Celkové hodnocení překladačů z hlediska obtížnosti instalace
S instalací úzce souvisí i další hodnocené kritérium a tím byla obtížnost odinstalace. Toto kritérium opět velmi úzce souvisí s úrovní dokumentace, případně je odvoditelné ze způsobu instalace. Pokud je instalace realizována pomocí tzv. průvodce, pak je i samotná odinstalace realizována připraveným odinstalačním programem. Všechny překladače, které získaly při hodnocení tohoto kritéria známku 1 měly odinstalaci realizovanou pomocí odinstalačního programu, případně byl způsob odinstalace velmi dobře popsán v dokumentaci. Naopak překladače, které získaly známku 2, měly způsob odinstalace v dokumentaci popsán velmi stručně, případně se tento postup nenacházel přímo v této dokumentaci a musel být dohledán.
Srovnání překladačů z hlediska obtížnosti odinstalace 2,5 2 1,5 1 0,5 0
2
2 1
1
1
2 1
1
1
Obrázek 38: Celkové hodnocení překladačů z hlediska obtížnosti odinstalace
Schopnosti překladačů programovacího jazyka Python
111
Dalším neméně důležitým kritériem pro ohodnocení zkoumaných překladačů programovacího jazyka Python je kompatibilita s operačními systémy. Pět překladačů (známky 1) je plně kompatibilních se třemi nejpoužívanějšími operačními systémy – Windows, Linux a Mac OS. Mezi těmito překladači se také nachází překladač Skulpt, který dostupný jako online služba, tudíž je ho možné spustit v jakémkoliv operačním systému. Podmínkou je pouze mít dostupné webové připojení. Překladač Pyjamas získal známku 3, což znamená, že je plně kompatibilní pouze se dvěma z nejpoužívanějších operačních systémů, konkrétně s operačním systémem Windows a Linux. Všechny další překladače získaly známku 4, což znamená, že jsou plně kompatibilní pouze s jedním z nejpoužívanějším operačním systémem. Konkrétně tedy s operačním systémem Windows.
Srovnání překladačů z hlediska kompatibility s operačními systémy 5 4 3 2 1 0
4
3 1
1
4
4 1
1
1
Obrázek 39: Srovnání překladačů z hlediska kompatibility s operačními systémy
Schopnosti překladačů programovacího jazyka Python
112
Velmi důležitým kritériem pro hodnocení všech překladačů jsou možnosti zpětné vazby k uživateli. Známku 1 získaly dva překladače Ironpython a Active Python. Jedná se totiž o dva překladače, které využívají velmi propracovaných vývojových prostředí. Překladač Ironpython využívá vývojového prostředí Visual Studio a překladač Active Python využívá prostředí Komodo. Právě tyto skutečnosti způsobily, že uvedené překladače získaly známku 1. Souvisí to s tím, že jak už bylo zmíněno, jsou tato vývojová prostředí velmi propracována a dokážou tak velmi podrobně a plnohodnotně poskytnout uživateli kvalitní zpětnou vazbu.
Srovnání překladačů z hlediska možností zpětné vazby k uživateli 2,5 2 1,5 1 0,5 0
2
2
2
2
2 1
2
2 1
Obrázek 40: Srovnání překladačů z hlediska možností zpětné vazby k uživateli
Dalším z důležitých hodnotících kritérií je reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu. Všechny testované překladače dokázaly reagovat na všechny uvedené chyby v testovacích příkladech a většinou stejně identifikovaly, o jaký typ chyby se jedná. Všechny překladače rozlišují dva druhy chyb – chyby syntaktické a chyby sémantické. Mezi chyby syntaktické řadí vždy chyby, které jsou nalezeny v lexikální a syntaktické fázi překladu. Samozřejmostí je, že chyby nalezené v sémantické fázi překladu jsou identifikovány jako chyby sémantické. V případě, že překladač nalezne chybu, pak je vždy uživateli zobrazena informace ohledně toho, kde se dané chyba nachází a také o jaký typ chyby se jedná. V případě, že se jedná o syntaktickou chybu, je uživatel informován o této skutečnosti pomocí hlášení SyntaxError. Pokud překladač nalezne sémantickou chybu, pak je uživateli zobrazena informace o jakou chybu se jedná – např. TypeError apod. To, že již dříve zmíněné překladače – Ironpython a Active Python získaly známku 1, souvisí zejména s tím, že využívají propracovaných vývojových prostředí, kde je reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu na velmi dobré úrovni.
Schopnosti překladačů programovacího jazyka Python
113
Srovnání překladačů z hlediska reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu 2,5 2 1,5 1 0,5 0
2 1,6
1,3
1,6 1
1,6
1,3
1,6
1,3
Obrázek 41: Srovnání překladačů z hlediska reakce na nalezené chyby v lexikální, syntaktické a sémantické fázi překladu
Časové náročnost překladu je dalším kritériem. Nejvyšších hodnot toto kritérium nabývalo u překladače Jython, tudíž byl také ohodnocen známkou 5. Souvisí to, zejména s tím, že tento překladač generuje z pythonovských skriptů soubory s příponou jar, tj. JavaByte kód. Všechny ostatní překladače získaly známku 1, jelikož hodnota jejich časové náročnost se pohybuje v mezích 11 až 304 ms. Obecně byla časová náročnost překladu všech testovacích úloh u všech testovaných překladačů v těchto mezích. Značné rozdíly jsou pak v časové náročnosti překladu testovacích úloh s chybami a bez chyb. Časová náročnost úloh bez chyb je samozřejmě vyšší, protože překladač (interpret) interpretuje celý zdrojový kód, tudíž mu to zabere více času, než když je ve zdrojovém kódu chyba a překladač interpretuje zdrojový kód pouze do chvíle než na danou chybu narazí.
Srovnání překladačů z hlediska časové náročnosti překladu 6 5 4 3 2 1 0
5 1
1
1
1
1
1
1
1
Obrázek 42: Srovnání překladačů z hlediska časové náročnosti překladu
Schopnosti překladačů programovacího jazyka Python
114
Předposledním kritériem pro hodnocení testovaných překladačů byla prostorová náročnost překladu. U překladače Skulpt tato vlastnost nebyla hodnocena, jelikož je tento překladač dostupný jako online služba. Nejvyšších hodnot, prostorová náročnost překladu nabývala u překladačů Ironpython a Active Python. Tato skutečnost byla dána tím, že tyto překladače byly využívány v souvislosti s vývojovými prostředími a ta sama o sobě měla velké paměťové nároky.
Srovnání překladačů z hlediska prostorové náročnosti překladu 6 5 5 4 4 3 2 1
1
1
1
1
1
1 0 0
Obrázek 43: Srovnání překladačů z hlediska prostorové náročnosti překladu
Schopnosti překladačů programovacího jazyka Python
115
Posledním, ale neméně důležitým kritériem byla úroveň dokumentace. Ta je velmi důležitá jelikož poskytuje velmi podstatné a důležité informace týkající se daného překladače. Dokumentaci na nejlepší úrovni má překladač Python. Což se dalo očekávat, jelikož se jedná o nejrozšířenější a tudíž i nejrozvíjenější překladač programovacího jazyka Python.
Srovnání překladačů z hlediska úrovně dokumentace 5 4 3 2 1 0
4
4 1
2
2
3
4 2
1
Obrázek 44: Srovnání překladačů z hlediska úrovně dokumentace
Schopnosti překladačů programovacího jazyka Python
116
12 Literatura ActiveState [online]. 2014 [cit. 2015-05-01]. Dostupné z: http://www.activestate.com/python AHO, Alfred V. Compilers: principles, techniques. 2nd ed. Boston: Addison Wesley, 2007. ISBN 0-321-48681-1. General information. Jython [online]. 2014 [cit. 2015-04-28]. Dostupné z: https://wiki.python.org/jython/JythonFaq/GeneralInfo#What_is_Jython.3F History of Python. In: Wikipedia: the free encyclopedia [online]. San Francisco (CA): Wikimedia Foundation, 2001- [cit. 2015-03-18]. Dostupné z: http://en.wikipedia.org/wiki/History_of_Python Ironpython. In: Wikipedia: the free encyclopedia [online]. San Francisco (CA): Wikimedia Foundation, 2014 [cit. 2015-05-01]. Dostupné z: http://en.wikipedia.org/wiki/IronPython Konstrukce překladače. Algoritmy.net [online]. 2011 [cit. 2015-04-25]. Dostupné z:http://www.algoritmy.net/article/100/Konstrukce-prekladace Kolik paměti zabírá konkrétní aplikace? 2012. Root.cz [online]. [cit. 2015-0511]. Dostupné z: http://petrkrcmar.blog.root.cz/2012/02/07/kolik-pameti-zabirakonkretni-aplikace/ Lambda, filter, reduce and map. Python Course [online]. 2011 [cit. 2015-03-20]. Dostupné z: http://www.python-course.eu/lambda.php Overview. Pyjs [online]. 2013 [cit. 2015-04-28]. Dostupné z: http://pyjs.org/Overview.html PILGRIM, M. Dive Into Python 3. 1. vyd. New York: Apress, 2009. 360 s. ISBN 978-1-430-22415-0. Python [online]. 2015 [cit. 2015-04-28]. Dostupné z: www.python.org Python. In: Wikipedia: the free encyclopedia [online]. San Francisco (CA): Wikimedia Foundation, 2001- [cit. 2015-03-20]. Dostupné z: http://en.wikipedia.org/wiki/Python_(programming_language) Python profesionálně: úvod. Zdroják.cz [online]. 2012 [cit. 2015-03-20]. Dostupné z: http://www.zdrojak.cz/clanky/python-profesionalne-uvod/
Schopnosti překladačů programovacího jazyka Python
117
Python: Py2exe [online]. 2014 [cit. 2015-05-01]. Dostupné z: http://www.py2exe.org/index.cgi/FrontPage Skulpt [online]. 2014 [cit. 2015-04-28]. Dostupné z: http://www.skulpt.org/ Stackless Python. In: Wikipedia: the free encyclopedia [online]. San Francisco (CA): Wikimedia Foundation, 2015 [cit. 2015-05-01]. Dostupné z: http://en.wikipedia.org/wiki/Stackless_Python Shed Skin. In: Wikipedia: the free encyclopedia [online]. San Francisco (CA): Wikimedia Foundation, 2014 [cit. 2015-05-01]. Dostupné z: http://en.wikipedia.org/wiki/Shed_Skin Stackless python. ABC Linuxu [online]. 2013 [cit. 2015-05-01]. Dostupné z:http://www.abclinuxu.cz/blog/bystroushaak/2013/10/stackless-python SUMMERFIELD, M. Python 3 : výukový kurz. 1. vyd. Brno: Computer Press, 2010. 584 s. ISBN 978-80-251-2737-7. Time-windows. Time-windows, Windows port of Unix time utility [online]. 2012 [cit. 2015-05-01]. Dostupné z: https://code.google.com/p/timewindows/downloads/detail?name=TimeMem-1.0.exe&can=2&q= VAVŘEČKOVÁ, Šárka. Tvorba překladačů: Studijní opora k výuce předmětu Překladače. Opava, 2008. Studijní opora. Slezská univerzita v Opavě. VENTRUBA. Schopnosti překladačů vybraných objektově orientovaných jazyků. Brno, 2011. Diplomová práce. What is pyjs?. Pyjs [online]. 2013 [cit. 2015-04-28]. Dostupné z: http://pyjs.org/About.html Why Jython. Jython [online]. 2014 [cit. 2015-04-28]. Dostupné z: https://wiki.python.org/jython/WhyJython XML. 2015-. Wikipedia: the free encyclopedia [online]. San Francisco (CA): Wikimedia Foundation [cit. 2015-05-12]. Dostupné z: http://en.wikipedia.org/wiki/XML ZERDALOGLU, Stratos. Schopnosti překladačů vybraných strukturovaných jazyků. Brno, 2012. Diplomová práce.
