Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.
1
Univerzita Komenského v Bratislave, Prírodovedecká fakulta
LLiibboorr BBuurriiaann
HHaannaa SSttaannkkoovváá
PPyytthhoon...
2
Univerzita Komenského v Bratislave, Prírodovedecká fakulta
Katedra fyzickej geografie a geoekológie
Katedra kartografie,...
3
Obsah
Úvod.................................................................................................................
4
Úvod
V predkladanej publikácii predstavujeme jazyk Python ako jeden z nástrojov na priestorovú
analýzu pre potreby fyzic...
5
1. Jazyk Python
Python je open sourceový jazyk, ktorý vznikol v roku 1991 a za jeho tvorcu je považovaný
Guido van Rossu...
6
Obrázok 1. Schéma komunikácie prostredia a jadra Python.
Na jednom operačnom systéme môže byť nainštalovaných niekoľko v...
7
Obrázok 3. Ukážka hlavného okna prostredia IDLE
Obrázok 4. Ukážka výpisu Ahoj prostredníctvom interaktívneho módu (vľavo...
8
2.2 Spyder
Ide o sofistikovanejšie open sourceové prostredie, ktoré je podobné mnohým bežne
používaným prostrediam skrip...
9
Obrázok 6. Ukážka hlavného okna prostredia PSPad.
V ľavej časti prostredia nachádzame Správcu projektov, Správcu súborov...
10
Obrázok 7. Ukážka korektne nastaveného spojenia medzi PSPad a jadrom Python.
2.4 ArcGIS 10.x
Ako bolo spomínané už vyšš...
11
prostredníctvom funkcie Load... v kontextovom menu (pravé tlačidlo myši). V pravej časti
okna sa zobrazuje pomoc k prík...
12
Z vyššie uvedeného vyplýva, že interaktívne vývojové prostredie jazyka Python môžeme
používať aj ako jednoduchú kalkula...
13
= 2, y = 2, z = x + y = 4. Avšak, pri opakovanom použití hodnôt (napr. v cykloch)
v počítačovom prostredí sa oplatí tie...
14
Z = "Cau"
print z
"Ahoj"
# v tomto pripade sme nechali vypisat na obrazovku premennu z,
nie Z.
Opätovne, v prípade prir...
15
Tabuľka 3. Ukážka funkcií využívaných na zmenu typu premenných.
funkcia popis príklad
int() prevod na premennú typu int...
16
 n – nový riadok textu
 t – tabulátor
 s – medzera
print "Ahoj ja som Jozef n A ty si kto?"
Ahoj ja som Jozef
A ty s...
17
2. Druhou možnosťou je využiť formátovanie reťazcov a špecifický zápis, ktorý umožní
spájať niekoľko premenných rozličn...
18
meno_6 = f.readline()
meno_7 = f.readline()
meno_8 = f.readline()
# precitanie vzdy jedneho riadka a jeho priradenie pr...
19
# vypocita sucet, rozdiel, sucin a podiel premenych x a y a
vysledok priamo zapise do noveho riadku.
f.close()
# uzatvo...
20
Môžeme si všimnúť, že tieto príkazy nie sú oddelené od posledného kódu zátvorkami.
Jediným oddeľovačom je v tomto prípa...
21
nadváhu a pod 19 za podváhu. Všetky hodnoty medzi tým reprezentujú normálnu hmotnosť.
Postup práce je nasledovný:
1. Pr...
22
Obrázok 11. Ukážka dvoch možností riešenia viacnásobných podmienok (vetvenia). a,–
Každá eventualita je definovaná zvlá...
23
a5 = random.randrange(5,28)
# nahodne generovanie cien akcii piatich firiem
print "1,t cena akcie spolocnosti Prva Uden...
24
V tomto prípade sme sa zoznámili s modulom random, ktorý pod sebou združuje niekoľko
funkcií na generovanie náhodných č...
25
1. Vytvoríme telo cyklu, ktorý sa bude 20-krát opakovať.
2. Definujeme zápis, ktorý bude vždy do nového riadku vypisova...
26
# telo funkcie for, kde horna hranica intervalu je definovana
premennou vyska
print i*"*"
# vypis
Do predošlého skriptu...
27
Obrázok 13. Ukážka štruktúry vnoreného cyklu.
Najprv sa teda vypísali stĺpce v prvom riadku prostredníctvom cyklu s ite...
28
else:
f.write("0 ")
# v pripade, ze cislo riadka nie je totozne s cislom
stlpca zapiseme 0
f.write("n")
f.close()
# uza...
29
# premennej plat priradime hodnotu 560, ktora reprezentuje
nastupny plat
while plat <1020:
# telo cyklu while s podmien...
30
Zoznam ako premenná sa javí ako jeden celok. Čo však v prípade, že chceme zobraziť (alebo
použiť) len vybraný prvok zo ...
31
3.8 Funkcie
Funkcie v programovacom jazyku sú časti kódu, ktoré možno opakovane spúšťať
prostredníctvom ich zavolania. ...
32
print ('Ahoj ' + meno + ', ako sa máš?')
pozdrav('Mirka')
Ahoj Mirka, ako sa mas?
V rámci funkcie môžeme volať akékoľve...
33
jedného z týchto modulov, je nutné najprv modul importovať (aktivovať, vzbudiť). Toto
uskutočníme prostredníctvom príka...
34
from arcpy.sa import *
# import modulu Spatial Analysis – druhý spôsob
# nemusíme písať predponu
outRaster = (Raster(in...
35
V prípade, že chceme v rámci modulu ArcPy využiť nástroj, s ktorým sme ešte nepracovali,
odporúčame nasledujúci postup:...
36
definované v Help súbore. Ak nepovinné parametre nechceme zadať, nemôžeme ich
vynechať, ale musíme namiesto toho uviesť...
37
Na vyššie uvedenom príklade sme si ukázali spôsob spúšťania nástrojov ArcToolbox-u
pomocou knižnice ArcPy. Ak je výsled...
38
nástroja Buffer_analysis(). Keďže parameter vzdialenosti sa zadáva ako textový reťazec aj s
uvedením jednotiek, tento p...
39
reťazcom je písmeno u, ktoré znamená, že sa jedná o reťazec typu Unicode). Takto vytvorený
zoznam môžeme použiť pri ako...
40
# ulozenie vyslednej rastrovej vrstvy vo formate TIF
Vstupná vektorová vrstva sa v tomto prípade volá body.shp a nachád...
41
nastavení váhy (0.1, 0.2, 0.3, 0.4, 0.5). Je teda nutné zostaviť skript, ktorý bude generovať
všetky možnosti nastaveni...
42
import arcpy
from arcpy.sa import *
# import kniznice arcpy a modulu Spatial Analyst
outSpline = Spline("C:/arcpy/body....
43
outSpline = Spline("C:/arcpy/body.shp", "ELEVATION", 5,
"REGULARIZED", 0.1)
outSpline.save("C:/arcpy/raster/dtm")
# int...
44
na hodnotu "NO DATA" a všetky ostatné bunky budú reklasifikované na hodnotu 1. Pre
potreby reklasifikácie využívame nás...
45
outStreamLink.save("C:/arcpy/raster/str_lnk")
# unikatne pomenovavanie segmentov vodnych tokov
outWatershed = Watershed...
46
Riešením tohto problému je vytvorenie skriptu na výpočet základných morfometrických
charakteristík, ktorý bude disponov...
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Python pre Geovedné aplikácie
Upcoming SlideShare
Loading in …5
×

Python pre Geovedné aplikácie

491 views

Published on

Libor Burian, Hana Stanková: Python pre Geovedné aplikácie, Univerzita Komenského v Bratislave, Prírodovedecká fakulta, Bratislava, 2015, ISBN: 978-80-223-3947-6

Published in: Technology
  • Be the first to like this

Python pre Geovedné aplikácie

  1. 1. 1 Univerzita Komenského v Bratislave, Prírodovedecká fakulta LLiibboorr BBuurriiaann HHaannaa SSttaannkkoovváá PPyytthhoonn GGeeoovveeddnnéé aapplliikkáácciiee
  2. 2. 2 Univerzita Komenského v Bratislave, Prírodovedecká fakulta Katedra fyzickej geografie a geoekológie Katedra kartografie, geoinformatiky a DPZ Python pre Geovedné aplikácie autori: Mgr. Libor Burian Mgr. Hana Stanková, PhD. recenzenti: Mgr. Michal Gallay, PhD. Ing. Karel Jedlička, PhD. jazyková úprava: Bc. Martina Lešková © Univerzita Komenského v Bratislave ISBN: 978-80-223-3947-6 Bratislava, 2015
  3. 3. 3 Obsah Úvod................................................................................................................................ 4 1. Jazyk Python ............................................................................................................... 5 2. Prostredia jazyka Python............................................................................................. 5 2.1 IDLE (Python GUI)............................................................................................... 6 2.2 Spyder.................................................................................................................... 8 2.3 PSPad .................................................................................................................... 8 2.4 ArcGIS 10.x ........................................................................................................ 10 3. Základy jazyka Python.............................................................................................. 11 3.1 Základné príkazy jazyka Python ......................................................................... 11 3.2 Premenné............................................................................................................. 12 3.2.1 Priraďovanie hodnôt premenným................................................................. 13 3.2.2 Typy premenných......................................................................................... 14 3.2.3 Zmena typu premenných .............................................................................. 14 3.3 Práca s textovými reťazcami............................................................................... 15 3.4 Práca so súbormi ................................................................................................. 17 3.4.1 Čítanie zo súboru.......................................................................................... 17 3.4.2 Zapisovanie do súboru.................................................................................. 18 3.5 Podmienky........................................................................................................... 19 3.6 Cykly ................................................................................................................... 24 3.6.1 Cykly s definovaným počtom opakovaní..................................................... 24 3.6.2 Cykly s nedefinovaným počtom opakovaní ................................................. 28 3.7 Zoznamy.............................................................................................................. 29 3.8 Funkcie................................................................................................................ 31 3.9 Modulárna štruktúra jazyka Python .................................................................... 32 4. Priestorová analýza prostredníctvom knižnice ArcPy.............................................. 33 4.1 Práca s vektorovými vrstvami............................................................................. 37 4.2 Práca s rastrovými vrstvami................................................................................ 39 4.3 Tvorba nástroja v ArcToolbox............................................................................ 45 5. Priestorová analýza prostredníctvom knižnice NumPy............................................ 52 6. Vykresľovanie grafov prostredníctvom knižnice Matplotlib ................................... 59 7. Zoznam použitej literatúry........................................................................................ 66 8. Zoznam odporúčanej literatúry................................................................................. 66
  4. 4. 4 Úvod V predkladanej publikácii predstavujeme jazyk Python ako jeden z nástrojov na priestorovú analýzu pre potreby fyzickej geografie. Text je určený najmä študentom a pracovníkom s geovedným vzdelaním, ktorí vo svojej bežnej praxi využívajú geografické informačné systémy na úrovni používateľov (tvorba máp, základné priestorové analýzy, tvorba jednoduchých modelov...) a majú snahu postúpiť o krok ďalej. Naopak, text rozhodne nie je odporúčaný začiatočníkom na poli priestorovej analýzy. Pre túto skupinu čitateľov odporúčame najprv siahnuť po iných publikáciách, zameraných na osvojenie si základných znalostí na poli priestorovej analýzy a až následne sa vrátiť k tomuto textu. Text ani v najmenšom nenahrádza plnohodnotné učebnice jazyka Python, určené najmä pre technické smery štúdia. Naopak, ponúka veľmi jednoduché ozrejmenie pojmového aparátu, najmä za pomoci príkladov a poskytuje prehľad o základných nástrojoch, využívaných pre potreby priestorovej analýzy. Text je zostavený na základe filozofie "tak jednoducho, ako sa len dá", preto nám snáď skúsený programátor alebo pokročilý používateľ informačných systémov odpustí nedostatočnú exaktnosť a miestami hrubé zjednodušovanie. V prípade, že čitateľ nadobudne po tomto základnom exkurze dojem, že bol preň jednoduchý, ba priam banálny, odporúčame mu, aby čo najskôr siahol po učebných textoch určených pre mierne pokročilých používateľov, ktoré sú používané najmä na vysokých školách s technickým zameraním. autorský kolektív
  5. 5. 5 1. Jazyk Python Python je open sourceový jazyk, ktorý vznikol v roku 1991 a za jeho tvorcu je považovaný Guido van Rossum. Jeho názov je odvodený od satirickej skupiny Monty Python, nie od hada pytóna, ako je vo všeobecnosti známe. Považuje sa za skriptovací jazyk, teda na rozdiel od programovacích jazykov, akým je napríklad C, nie je možné z neho vytvoriť priamo spustiteľný *.exe súbor. Medzi základnú výhodu tohto jazyka považujeme schopnosť spolupráce na širokom spektre platforiem a implementovanie do bežne používaných geografických informačných systémov, akými sú ArcGIS, GRASS, QGIS a podobne. Funkcionalitu jazyka je možné rozširovať prostredníctvom modulov (akýchsi balíčkov funkcií), vďaka čomu dokáže, napríklad, pracovať s priestorovými informáciami, pohodlne tvoriť grafy, počítať pohyby hviezd a planét na oblohe, kresliť geometrické tvary, komunikovať priamo s operačným systémom alebo komunikovať s externými programami. Práve táto univerzalita z neho urobila veľmi populárny jazyk hlavne v komunite používateľov informačných technológií, ktorí nemajú hlboké znalosti v oblasti programovania, teda stoja na pomedzí medzi vývojárom a používateľom. Jazyk Python je možné nainštalovať do osobného počítača ako: 1. Samostatný jazyk a samostatné prostredie (rozhranie). 2. Ako komplexný balík, ktorý v sebe najčastejšie obsahuje jazyk, prostredie a niekoľko bežne používaných modulov (napr. Anaconda). 3. Ako súčasť niektorých iných prostredí, kde sa jadro a základné prostredie nainštalujú spolu s iným programom alebo skupinou programov (napr. ArcGIS 10.x). Pre potreby tohto textu budeme využívať verziu Python 2.7. Táto verzia je bežne distribuovaná s prostredím ArcGIS 10.2. 2. Prostredia jazyka Python Za prostredie (vývojové prostredie) považujeme obslužnú aplikáciu, ktorá komunikuje so samotným jazykom Python (jadrom jazyka Python). Ide teda o komunikačné rozhranie medzi používateľom a jazykom Python. Ak jazyk Python (jadro Python) považujeme za úradníka, tak prostredie (rozhranie) považujeme za kanceláriu prvého kontaktu, kde zadáme svoju žiadosť vo správnej forme a tá ju následne postúpi úradníkovi, ktorý o nej rozhodne a opätovne prostredníctvom kancelárie prvého kontaktu nám odpovie (Obrázok 1.).
  6. 6. 6 Obrázok 1. Schéma komunikácie prostredia a jadra Python. Na jednom operačnom systéme môže byť nainštalovaných niekoľko verzií jazyka Python a každá verzia môže mať niekoľko prostredí (Obrázok 2.). Obrázok. 2. Ukážka vzťahov medzi prostrediami a jadrami jazyka Python. Na jednom počítači môže byť nainštalovaných niekoľko verzií jadra a každá z nich môže komunikovať s niekoľkými prostrediami. Medzi bežne najpoužívanejšie prostredia patrí Python IDLE, Spyder alebo PSPad. V tomto texte sa zoznámime len s elementárnym ovládaním každého z prostredí. Podrobnejšie štúdium necháme na samotného používateľa. Začínajúcemu používateľovi odporúčame vyskúšať niekoľko prostredí a vybrať si to, s ktorým sa mu pracuje najkomfortnejšie. 2.1 IDLE (Python GUI) Ide o jedno z najintuitívnejších open sourceových prostredí pre Python. Prostredie sa inštaluje spolu s jadrom Python. Stiahnuť ho je najjednoduchšie zo stránky https://www.python.org. V prípade, že má používateľ nainštalovaný ArcGIS 10.0, inštaluje sa toto prostredie spolu s jadrom automaticky vo verzii 2.6. V prípade, že je nainštalovaný ArcGIS 10.2, inštaluje sa verzia jadra 2.7. Ukážku základného okna tohto prostredia (Python Shell) vidíme na Obrázku 3. Prvých desať riadkov nás informuje o základných atribútoch jadra Python. Riadok začínajúci >>> a blikajúci kurzor nás informuje o pripravenosti prostredia. IDLE je interaktívne prostredie, kde je interaktivita zabezpečená možnosťou spustiť nami napísaný riadok skriptu priamo stlačením tlačidla ENTER. Tento druh prostredia je vhodný najmä pre prvotné pokusy s jazykom, pretože je možné spustit vždy len jeden príkaz (prostredie funguje ako interpreter). Nie je možné vytvoriť zdrojový kód dlhý niekoľko riadkov a spustiť ho naraz. Ak chceme využiť práve túto funkciu, je nutné vytvoriť nový Python súbor prostredníctvom ponuky File/New window alebo prostredníctvom klávesovej skratky ctrl + n. Následne sa otvorí nové obdobné okno IDLE, ktoré však nie je interaktívne. Tu možno písať priamo zdrojový kód, ktorý spustíme prostredníctvom Run/Run module alebo klávesou F5. Celé prostredie IDLE sa reštartuje, aby sa vynulovali hodnoty premenných a spustí sa program v hlavnom okne prostredia. Celý postup je ilustrovaný na Obrázku 4., kde sme vytvorili program, ktorý vypíše na obrazovku "Ahoj". Samotné prostredie IDLE sa v dnešnej dobe používa len výnimočne, avšak pre začínajúceho programátora je vhodné.
  7. 7. 7 Obrázok 3. Ukážka hlavného okna prostredia IDLE Obrázok 4. Ukážka výpisu Ahoj prostredníctvom interaktívneho módu (vľavo) a neinteraktívneho módu (vpravo) v prostredí IDLE.
  8. 8. 8 2.2 Spyder Ide o sofistikovanejšie open sourceové prostredie, ktoré je podobné mnohým bežne používaným prostrediam skriptovacích jazykov, ako napríklad R studio alebo Matlab. Prostredie je súčasťou balíčka Anaconda (32 / 64 bit verzia), ktorý ponúka komplexné prostredie Python spolu so 195 najbežnejšie používanými modulmi Python a konzolou IPython, ktorá je alternatívou k vyššie spomínanému IDLE prostrediu. Ukážka základného okna prostredia Spyder sa nachádza na Obrázku 5. Obrázok 5. Ukážka hlavného okna prostredia Spyder. Hlavné okno sa skladá z troch častí. V ľavej časti je umiestnené pole na písanie zdrojového kódu. V pravej hornej časti nachádzame Object inspector (správca objektov), Variable explorer (správca premenných) a File explorer (správca súborov). Prostredníctvom týchto troch nástrojov dokážeme kontrolovať vstupy a výstupy zo skriptu. V pravej dolnej časti nachádzame konzolu IPython, ktorá spúšťa skripty napísané v ľavej časti hlavného okna. Skript po napísaní spustíme tlačidlom F5. Jednou z výhod tohto prostredia je schopnosť odhaľovať chyby v zdrojovom kóde už počas jeho písania. Teda v prípade, že zadáme nekorektný príkaz, prostredie nás na to upozorní s krátkym časovým oneskorením (žltá výstražná ikona). Každý novovytvorený skript je nutné ešte pred spustením uložiť ako samostatný súbor prostredníctvom File/Save, treťou ikonou zľava na hornej lište prostredia alebo klávesovou skratkou ctrl + s. Spyder je sofistikované prostredie určené aj pre pokročilých programátorov, ktoré môže byť pre začínajúceho používateľa trocha mätúce. 2.3 PSPad PSPad nepredstavuje prostredie v klasickom ponímaní. Ide o open sourceový textový editor, ktorý je v mnohých aspektoch podobný poznámkovému bloku (Notepadu) v prostredí MS Windows. Disponuje však pokročilejšími funkciami na editáciu textu (zdrojového kódu) a pohodlnejšiu prácu s ním. Okrem iného je možné ho prepojiť s jadrom Python, ktoré v operačnom systéme stojí samostatne. Ukážku hlavného okna tohto programu nachádzame na Obrázku 6.
  9. 9. 9 Obrázok 6. Ukážka hlavného okna prostredia PSPad. V ľavej časti prostredia nachádzame Správcu projektov, Správcu súborov, Správcu FTP spojení, Správcu obľúbených lokalít a Správcu otvorených súborov. V prípade, že chceme PSPad využívať pre potreby komunikácie s jadrom Python, je nutné spojiť ho s jadrom Python: 1. Otvoríme si menu Nastavenie/Nastavenie zvýrazňovačov. 2. V ľavej časti menu zrušíme označenia všetkých možností okrem možnosti Python. 3. V záložke Externé programy definujeme cestu k jadru Python. Prostredníctvom tlačidla "..." v položke Program definujeme umiestnenie jadra Python. V našom prípade to je C:Python27ArcGIS10.2python.exe 4. Po stlačení tlačidla Otvoriť sa v položke Program automaticky zobrazí nasledovná cesta "C:Python27ArcGIS10.2python.exe" "%File%". 5. Cestu spomínanú v bode 4 upravíme na "C:Python27ArcGIS10.2python.exe" -i "%File%", teda za cestu k jadru jazyka Python pridáme "-i". To zabezpečí, aby sa spúšťané okno s prebiehajúcim programom ihneď nezavrelo, ale ostalo otvorené, aby sme boli schopní prečítať výsledok (Obrázok 7.). 6. Potvrdíme tlačidlom Pridaj a okno zavrieme tlačidlom OK. 7. PSPad reštartujeme. Pre korektné spustenie projektu v novom okne, musí byť nový projekt nastavený ako Python dokument s príponou *.py. Nový Python dokument vytvoríme prostredníctvom Súbor/Nový, čo predstavuje siedmu ikonu zľava na hornej lište a následne výberieme Python z ponuky. Súbor nemusí byť pred spustením programu uložený. Program spúšťame prostredníctvom tlačidla F9. Medzi hlavné výhody prostredia PSPad patrí jednoduchosť, kde mimo základného nastavenia sa prostredie správa ako bežný textový editor so všetkými ponukami editácie textu, ktoré používatelia poznajú z iných textových editorov.
  10. 10. 10 Obrázok 7. Ukážka korektne nastaveného spojenia medzi PSPad a jadrom Python. 2.4 ArcGIS 10.x Ako bolo spomínané už vyššie, jazyk Python sa využíva aj v externých komerčných a open sourceových prostrediach ako alternatíva interaktívnej komunikácie (príkazy sa neklikajú myšou, ale spúšťajú sa prostredníctvom skriptov). Python implementovaný v prostredí ArcGIS 10.x týmto umožňuje ovládať a vyvíjať toto prostredie prostredníctvom programového kódu. Jedným z takýchto prostredí je ArcGIS verzia 10.0 a vyššia, v ktorom sa nachádza špeciálne prostredie určené na prácu s jazykom Python, tzv. Python Window (od verzie ArcGIS 10 nahradilo dovtedajšie Command Line Window). Python Window spustíme ikonou, ktorá je umiestnená na hornej lište hlavného okna ArcGIS. Ukážku okna Python nachádzame na Obrázku 8. Obrázok 8. Ukážka Python Window v prostredí ArcGIS 10.x. Okno je rozdelné na dve časti. V ľavej časti je príkazový riadok, v ktorom zadávame príkazy za znak >>>, podobne ako v prostredí Python IDLE. V tomto prípade ide opätovne o interaktívne prostredie, teda príkaz v každom riadku spúšťame prostredníctvom tlačidla ENTER. Taktiež je možné spúšťať aj viacriadkové príkazy, pričom na nový riadok sa príkaz zadáva prostredníctvom CTRL + ENTER alebo SHIFT + ENTER. Viacriadkové príkazy sa spúšťajú dvojnásobným stlačením ENTER. Zdrojové kódy je možné kopírovať (ctrl + c) a prilepiť (ctrl + v) do konzoly a následne spustiť tlačidlom ENTER, alebo načítať zo súboru
  11. 11. 11 prostredníctvom funkcie Load... v kontextovom menu (pravé tlačidlo myši). V pravej časti okna sa zobrazuje pomoc k príkazom, vrátane syntaxe nástrojov ArcToolbox. V Python Window môžeme používať všetky príkazy jazyka Python, tak ako v ktoromkoľvek interpretačnom rozhraní. Medzi základné výhody tohto prostredia patrí priama komunikácia s prostredím ArcGIS a jednoduchosť. Avšak, v prípade viacriadkových zdrojových kódov je pre prácu s ArcGIS nástrojmi v Python ideálne využívať externé programy pre prácu s textom (napr. Notepad alebo PSPad), ktoré pracujú v neinteraktívnom režime. Nasledujúca kapitola 3. je zameraná na osvojenie si základov jazyka Python. Využívaniu funkcionality prostredia ArcGIS 10.x prostredníctvom jazyka Python sa venujeme až následne v kapitole 4. 3. Základy jazyka Python 3.1 Základné príkazy jazyka Python V tejto časti sa zameriame na základné príkazy využívané v jazyku Python. Medzi tie elementárne, ktoré využíva začínajúci operátor, patrí príkaz print, ktorý slúži na výpis informácií na obrazovku. Je to jeden zo skupiny príkazov, skladajúcich sa z pevnej a premenlivej časti. Pevná časť je samotný príkaz print a premenlivá časť je všetko, čo sa za týmto príkazom nachádza, teda čo sa vypíše na obrazovku po stlačení tlačidla ENTER. print 10 10 # po stlaceni ENTER sa vypiše 10 na obrazovku print "Ahoj" Ahoj # po stlaceni ENTER sa vypiše Ahoj na obrazovku print 2+5 7 # po stlaceni ENTER sa vypise 7 na obrazovku print 2*5 10 # po stlaceni ENTER sa vypise 10 na obrazovku Uviedli sme pár príkladov použitia príkazu print. V prípade, že chceme vypísať čísla, zadávame ich priamo za príkaz print. V prípade, že chceme vypísať text, tak premenlivú časť príkazu print ohraničíme úvodzovkami. V prípade príkazu print, ako aj ostatných príkazov, je možné v premenlivej časti využívať aritmetické operátory. Zoznam bežne používaných aritmetických operátorov spolu s príkladmi ich využitia v jazyku Python nachádzame v tabuľke 1. Ako vidíme na ukážke, znak # na začiatku riadku sa využíva pre zápis komentárov. Tabuľka 1. Ukážka základných aritmetických operátorov v jazyku Python operand popis príklad + sčítanie 2 + 4 = 6 - odčítanie 2 - 4 = -2 * násobenie 2 * 4 = 8 / delenie 2 / 4 = 0.5 % zvyšok z delenia 7 % 2 = 1 ** mocnina 4 ** 2 = 16
  12. 12. 12 Z vyššie uvedeného vyplýva, že interaktívne vývojové prostredie jazyka Python môžeme používať aj ako jednoduchú kalkulačku. V tomto špecifickom prípade nepotrebujeme zadať príkaz print, ale rovno zadáme matematický výraz, stlačíme ENTER a vypíše sa výsledok. >>>2*5 10 >>>2+5 7 >>>7/2 3 >>>7/2.0 3.5 Ak delíme celé čísla, aj výsledok bude zaokrúhlený na celé čísla. Ak potrebujeme dostať výsledok vo forme desatinného čísla, musíme zadať delenec alebo deliteľ ako desatinné číslo. Viac o premenných a práci s nimi sa čitateľ dozvie v nasledujúcej podkapitole 3.2. Okrem aritmetických operátorov využívame aj logické operátory, ktoré sa využívajú najmä na spájanie výrazov. Výsledkom operácie je v tomto prípade hodnota True (platí, je pravda) alebo False (neplatí, nie je pravda). Ich význam plne pochopíme neskôr, avšak pre úplnosť informácie ponúkame ich zoznam v Tabuľke 2, spolu s príkladom ich využitia. Tabuľka 2. Ukážka základných logických operátorov využívaných v jazyku Python. operand popis príklad == rovná sa 2 == 2 True != nerovná sa 3!= 2 True < ľavá časť je menšia ako pravá 2 > 4 False > pravá časť je menšia ako ľavá 1 < 2 True <= ľavá časť je menšia alebo rovná ako pravá 1 >= 1 True >= pravá časť je menšia alebo rovná ako ľavá 5 <= 1 False 10 > 5 True # po stlaceni ENTER sa vypise True na obrazovku 10 == 5 False # po stlaceni ENTER sa vypise False na obrazovku 10 >= 11 False # po stlaceni ENTER sa vypise False na obrazovku 3.2 Premenné Z uhla pohľadu bežného človeka je použitie premennej nadbytočnou operáciou, pretože človek len málokedy uvažuje v hodnotách x, y... V našej mysli teda počítame 2 + 2 = 4, nie x
  13. 13. 13 = 2, y = 2, z = x + y = 4. Avšak, pri opakovanom použití hodnôt (napr. v cykloch) v počítačovom prostredí sa oplatí tieto hodnoty uložiť do pripravených pamäťových miest a ďalej s nimi pracovať práve takouto formou. Premennú môžeme definovať ako pripravené pamäťové miesto, ktoré môže, alebo nemusí mať definovanú veľkosť a je zaplnené najčastejšie číselnou alebo znakovou (textovou) hodnotou. 3.2.1 Priraďovanie hodnôt premenným Priradenie hodnoty premennej je proces uloženia hodnoty do premennej. V niektorých programovacích jazykoch je potrebné premennú najprv vytvoriť (tzv.deklarovať). Výhodou jazyka Python je, že premennú nemusíme dopredu vytvárať (nie je nevyhnutné program informovať o tom, že plánujem využiť premennú), vytvorí sa automaticky pri priradení. Priradenie premennej sa skladá z troch častí (Obrázok 9): 1. názov premennej – Ide o jednoznačný identifikátor premennej, ktorý musí byť jedinečný (neopakovať sa), výstižný (aby ju vedel operátor prečítať) a korektný (nesmie obsahovať diakritiku a iné špeciálne znaky a musí byť odlišný od príkazov jazyka Python, teda premennú nemôžeme, napr. nazvať print). Názov premennej obyčajne tvorí jedno písmeno alebo slovo. V prípade viacslovných premenných nepoužívame medzery, ale oddeľujeme ďalšie slová prvým veľkým písmenom (myVariable) alebo podčiarkovníkom (my_variable). 2. znak priradenia – Premennú takzvane priraďujeme, teda názvu premennej priraďujeme hodnotu. Znakom priraďovania v jazyku Python je "=". 3. hodnota premennej – Hodnota premennej nemusí byť na rozdiel od názvu premennej unikátna a môže nadobúdať niekoľko typov hodnôt (viď. kapitola 3.2.2.). Obrázok 9. Proces priradenia premennej Nasleduje niekoľko ukážok priradenia premenných. x = 10 # premennej x priradi hodnotu 10 (cele cislo) y = 12.2 # premennej y priradi hodnotu 12.2 (realne cislo) z = "Ahoj" # premennej z priradi hodnotu "Ahoj" (znakovy retazec) m = 15*2 # premennej m priradi hodnotu 30 (cele cislo) m = "Teraz som zmazal hodnotu premennej m a nahradil som ju týmto textom" (znakovy retazec) # povodna hodnota premennej bola zmazaná a nahradená textovym retazcom
  14. 14. 14 Z = "Cau" print z "Ahoj" # v tomto pripade sme nechali vypisat na obrazovku premennu z, nie Z. Opätovne, v prípade priradenia znakových reťazcov využívame úvodzovky a pri procese priradenia hodnoty premennej môžeme využívať aritmetické operátory. Taktiež si môžeme všimnúť, že Python rozlišuje veľké a malé písmená, teda premenná z nie je rovná premennej Z. 3.2.2 Typy premenných V praxi sa stretávame so širokým spektrom premenných, my však budeme pracovať najmä s tromi typmi premenných, ktoré môžeme považovať za základné, nielen v jazyku Python. Sú to:  integer – Premenná typu integer môže obsahovať celočíselné hodnoty v ľubovoľnom rozsahu. Rozsah hodnôt je limitovaný len pamäťovým miestom. (napr. 4, 5, 6, -7, -8 ...)  float – Premenná typu float môže obsahovať reálne čísla v ľubovoľnom rozsahu. Rozsah hodnôt je limitovaný len pamäťovým miestom. (napr. 4, 5, 2.1, 3.5, -4.587, - 4568741258.457 ...) V prípade dlhých čísel sa využíva zápis čísla prostredníctvom exponentu (tzv. vedecká anotácia známa napríklad z MS Excel).  string – Premenná typu string môže obsahovať ľubovoľné znaky z tabuľky ASCII (znakový reťazec). Rozsah hodnôt je limitovaný len pamäťovým miestom. Za znak považujeme aj číslo, ktoré sa však v prípade tejto premennej považuje za text, nie číslo ako také. S týmto typom premennej nie je možné uskutočňovať aritmetické operácie. Ako bolo spomínané už vyššie, typ premennej nie je potrebné deklarovať. V praxi to znamená, že na začiatku zdrojového kódu nie je nutné informovať program, že budeme používať premenné x a y, ktoré budú nadobúdať hodnotu reálnych čísel a premennú z, ktorá bude textová. Len priamo v programe priradíme premennej x hodnotu 10.2, premennej y hodnotu 11.2 a premennej z hodnotu Ahoj. Ide o snahu autorov prostredia zjednodušiť programátorovi prácu. 3.2.3 Zmena typu premenných Zmenou typu premennej (tzv. pretypovanie) nazývame proces predefinovania typu premennej. Ak je v premennej uložená nejaká hodnota, prevedie sa na hodnotu príslušného typu. Napríklad, premennú typu integer, v ktorej je uložená hodnota 10, prevedieme na premennú s takým istým názvom typu string a hodnota v nej uložená sa zmení na textový reťazec „10“. Niektoré druhy prevodov nie sú možné, napr. prevod premenných typu string, obsahujúcich písmená na premenné typu integer a float (v takomto prípade program vypíše chybu). Zoznam základných funkcií, ktoré sa využívajú na zmenu typu premenných nachádzame v Tabuľke 3.
  15. 15. 15 Tabuľka 3. Ukážka funkcií využívaných na zmenu typu premenných. funkcia popis príklad int() prevod na premennú typu integer int(12.7) = 12 float() prevod na premennú typu float float(12) = 12.0 str() prevod na premennú typu string str(12) = 12 Funkcia int() sa využíva na prevod textových reťazcov vo vhodnom tvare na celé číslo, alebo na prevod z reálneho čísla na celé tým, že sa oddelí desatinná časť (nie zaokrúhli). Funkcia float() sa využíva na prevod textových reťazcov vo vhodnom tvare na reálne číslo, alebo na prevod z celého čísla na reálne tým, že sa pridá jedno desatinné miesto s hodnotou 0. Funkcia str() sa využíva na prevod celého alebo desatinného čísla na textový reťazec, teda číslo ostane nezmenené, len je uložené ako text a nie je možné s ním operovať ako s číslom. Začínajúcemu používateľovi sa takéto prevody môžu zdať nelogické, ba až nadbytočné, avšak v ďalších kapitolách textu zistíme, že majú význam. a = 12.45 a = int(a) print a 12 # prevod realneho cisla na cislo cele b = 12.45 b = str (b) print b 12.45 # prevod realneho cisla na textovy retazec, pricom jeho hodnota ostane nezmenena 3.3 Práca s textovými reťazcami Práca s textovými reťazacmi (textom) sa bude začínajúcemu programátorovi javiť komplikovaná, pretože je pre používateľa zväčša jednoduchšie pracovať s číslami ako s textom. Textový reťazec je v jazyku Python reprezentovaný premennou typu string. Medzi základné operácie s touto premennou patrí jej formátovanie. V rámci tohto kurzu sa zameráme len na najzákladnejšie formátovanie textu, zvyšok ponecháme na samoštúdium. Ako bolo ukázané už vyššie, textové reťazce zapisujeme medzi úvodzovky. x = "Ahoj" print x Ahoj y = " Ahoj ako sa mas?" print y Ahoj ako sa mas? # Do retazca sa pocitaju aj prazdne znaky (medzery) a to aj pred slovami aj za slovami V prípade, že chceme využiť v rámci textového reťazca nový riadok alebo text oddeliť tabulátorom, je nevyhnutné využiť regulárne výrazy. Regulárne výrazy sú reťazce, ktoré zastupujú špecifický znak. Medzi najbežnejšie používané regulárne výrazy patria:
  16. 16. 16  n – nový riadok textu  t – tabulátor  s – medzera print "Ahoj ja som Jozef n A ty si kto?" Ahoj ja som Jozef A ty si kto? # v tomto pripade znak n zastupuje novy riadok a stlacenie klavesy ENTER print "t Ako sa máš" Ako sa máš # v tomto pripade znak t zastupuje tabulator a teda text je odsadeny Ďalšou častou operáciou je spájanie dvoch reťazcov alebo ich násobenie (multiplikácia). x = "Ahoj" y = " ako sa mas?" print x + y Ahoj ako sa mas? # dva retazce boli spojene znakom "+" x = "Si " y = "velmi " z = "super " print x + 3 * y + z Si velmi velmi velmi super # v tomto pripade sme spojili tri retazce do jedného retazca a retazec y sme multiplikovali tri krat Omnoho komplikovanejšie je spájanie znakových reťazcov s číslom. Jazyk Python nám neumožňuje jednoducho spájať znakový reťazec s číslom. x = "Ahoj" y = 3 print x + y Traceback (most recent call last): File "<pyshell#2>", line 1, in <module> print x + y TypeError: cannot concatenate 'str' and 'int' objects Existujú dve možnosti riešenia tohto problému: 1. V prvom prípade prevedieme všetky premenné na jeden formát, najčastejšie na znakový reťazec, ktorý sa dá bez problémov spájať. K tomuto využívame zmenu typu premenných (pretypovanie). x = "Ahoj" y = 3 y = str(y) print x + y ahoj3 # v tomto pripade sme najprv ciselnu premennú previedli na znakovy retazec a nasledne sme spojili dva znakove retazce.
  17. 17. 17 2. Druhou možnosťou je využiť formátovanie reťazcov a špecifický zápis, ktorý umožní spájať niekoľko premenných rozličných typov. meno = "Jozef" vek = 25 print "Ahoj, volam sa %s a mam %i rokov." %(meno,vek) Ahoj volam sa Jozef a mam 25 rokov. V tomto prípade sme vypísali znakový reťazec, ktorý obsahuje dve premenné (jednu znakovú a jednu číselnú). Znak % v textovom reťazci označuje začiatok formátovania a nasledujúce znaky za ním hovoria, na aký formát sa má premenná previesť (znak s označuje prevod na textový reťazec, znak i prevod na celé číslo). Za ďalším znakom % za textovým reťazcom sa nachádza zoznam premenných, ktoré musia byť uvedené v rovnakom poradí ako v predchádzajúcej časti. 3.4 Práca so súbormi V doterajších príkladoch sme vstupy zadávali len prostredníctvom klávesnice a výstupy sa zobrazovali priamo na obrazovke. Ide o najjednoduchší a zároveň najmenej efektívny spôsob výstupu. V prípade zložitejších operácií ide o značne nepohodlný spôsob. Predstavte si, že výsledkom skriptu je 10 000 hodnôt, ktoré je potrebné ručne prepisovať. Druhou často používanou možnosťou vstupu a výstupu je čítanie a zapisovanie do súboru, kde sa vstupné dáta čítajú a zapisujú z a do súboru. Najčastejšie sa pre základnú prácu so súbormi využíva textový formát *.txt. 3.4.1 Čítanie zo súboru Máme vytvorený súbor mena.txt, ktorý má nasledovný tvar. Magda Veronika Michaela Margita Zelmira Kvetoslava Miroslava Tatiana Chceme vytvoriť program, ktorý prečíta mená zo súboru a priradí ich do znakových premenných s názvami meno_1, meno_2, meno_3... Postup práce je nasledovný: 1. Otvoríme súbor mena.txt, ktorý sa nachádza v rovnakom priečinku ako nami vytvorený skript. 2. Prečítame prvý riadok v súbore a priradíme ho premennej meno_1. 3. Krok 2 opakujeme ešte sedemkrát. 4. Súbor mena.txt zavrieme. f = open('mena.txt', 'r') # otvorenie suboru mena.txt len na citanie meno_1 = f.readline() meno_2 = f.readline() meno_3 = f.readline() meno_4 = f.readline() meno_5 = f.readline()
  18. 18. 18 meno_6 = f.readline() meno_7 = f.readline() meno_8 = f.readline() # precitanie vzdy jedneho riadka a jeho priradenie premennej s prislusnym nazvom f.close() # uzatvorenie suboru mena.txt Vo vyššie uvedenom kóde sme sa zoznámili s tromi novými funkciami. Funkcia open() priradí do premennej (v našom prípade f) otvorený súbor, ktorého meno je deklarované v zátvorke. Inak povedané, otvoríme súbor mena.txt. Tento súbor sa musí nachádzať v rovnakom priečinku ako zdrojový kód. V prípade, že chceme zmeniť umiestnenie vstupného súboru mena.txt, je nevyhnutné zadať celú cestu k súboru nasledovným spôsobom "C:/mena.txt". V druhej časti tejto funkcie deklarujeme, čo máme v úmysle s týmto súborom robiť. V našom prípade budeme súbor čítať, teda pridáme symbol 'r' (read). V prípade, že by sme do súboru zapisovali, pridáme symbol 'w' (write), čím sa vymaže celý predošlý obsah súboru. V prípade, že chceme do súboru len informácie pridávať, pridáme symbol 'a' (append), kde sa každý ďalší riadok súboru len pridá na existujúci koniec súboru. Funkcia .readline() zabezpečí prečítanie prvého riadku súboru, teda všetky informácie až po prvý ENTER. Pred funkciu je nevyhnutné zadať aj názov premennej, ku ktorej je súbor priradený. Hlavnou nevýhodou tohto postupu je, že nie sme schopní priamo prečítať, napríklad, piaty riadok bez toho, aby sme neprečítali predošlé štyri riadky. Príkaz .close(), otvorený súbor uzatvorí, a taktiež uloží akékoľvek uskutočnené zmeny v ňom (platí len v prípade zápisu alebo pridávania do súboru). Pred funkciu je nevyhnutné zadať aj názov premennej, ku ktorej je súbor priradený. 3.4.2 Zapisovanie do súboru Metóda zápisu do súboru sa využíva najmä v prípade veľkého množstva textových výstupov. Napríklad, v prípade, že skript vygeneruje 200 znakových premenných, je vhodnejšie ich zapísať do súboru, ako ich len vypísať na monitor. V nasledujúcom príklade vytvoríme jednoduchú kalkulačku, ktorej z dvoch vstupných čísel vypočíta súčet, rozdiel, súčin, podiel a výsledok zapíše do nového súboru s názvom vysledok.txt. Postup práce je nasledovný: 1. Otvoríme si nový súbor s názvom vysledok.txt v móde na zapisovanie. 2. Zadáme hodnoty premennej x a premennej y. 3. Do prvého riadku súboru zapíšeme výsledok súčtu premennej x a premennej y. 4. Krok 3 zopakujeme aj pre rozdiel, súčin a podiel. 5. Súbor vysledok.txt zatvoríme. f = open('vysledok.txt', 'w') # otvori novy subor vysledok.txt v mode zapisovania x = 10.0 y = 3.0 # definuje hodnoty premennych x a y f.write("Sucet %i a %i je %in" %(x,y,x+y)) f.write("Rozdiel %i a %i je %in" %(x,y,x-y)) f.write("Sucin %i a %i je %in" %(x,y,x*y)) f.write("Podiel %i a %i je %fn" %(x,y,x/y))
  19. 19. 19 # vypocita sucet, rozdiel, sucin a podiel premenych x a y a vysledok priamo zapise do noveho riadku. f.close() # uzatvorenie suboru vysledok.txt Výsledný súbor vysledok.txt bude vyzerať nasledovne. Sucet 10 a 3 je 13 Rozdiel 10 a 3 je 7 Sucin 10 a 3 je 30 Podiel 10 a 3 je 3.333333 Funkcia open() je nám známa už z predošlého príkladu. V tomto prípade sme však využili už spomínaný mód zapisovania (editácie) 'w', ktorý najprv zmaže predošlý obsah súboru a následne začne zapisovať od prvého riadku. Súbor sa uloží do rovnakého adresára ako je umiestnený zdrojový kód. Funkcia .write()zapíše znaky uvedené v zátvorke do nového súboru. Pred funkciu je nevyhnutné zadať aj názov premennej, do ktorej je súbor priradený. Príkaz .close() otvorený súbor uzatvorí, a taktiež uloží v ňom uskutočnené zmeny. 3.5 Podmienky Podmienky (vetvenie, conditions) sú jednou z bežne používaných operácií v rámci pokročilých kódov. Podmienka je chápaná ako operácia rozhodovania, kde v prípade splnenia podmienky nastane jedna eventualita, a naopak, v prípade nesplnenia podmienky nastane eventualita druhá (Obrázok 10). Obrázok 10. Ukážka významu podmienok v programovaní. Podmienky v jazyku Python sú zastúpené príkazom if s ustálenou štruktúrou. if podmienka: eventualita_1 else: eventualita_2 Prvý riadok sa skladá z pevnej časti if, za ktorou nasleduje samotná podmienka, ktorá je ukončená dvojbodkou. V prípade, že sa tu dvojbodka nenachádza, príkaz je považovaný za chybný. Druhý riadok popisuje eventualitu 1, ktorá bude vykonaná v prípade, že je podmienka splnená. V treťom riadku nachádzame pevnú časť else opätovne ukončenú dvojbodkou. Štvrtý riadok popisuje eventualitu 2, ktorá bude vykonaná v prípade, že podmienka nebude splnená. Eventualita_1 a eventualita_2 sa skladá z jedného alebo viacerých príkazov, ktoré sa vykonajú v prípade splnenia, resp. nesplnenia podmienky.
  20. 20. 20 Môžeme si všimnúť, že tieto príkazy nie sú oddelené od posledného kódu zátvorkami. Jediným oddeľovačom je v tomto prípade umiestnenie na nový riadok a odsadenie (indentation), ktoré je v jazyku Python veľmi dôležité. Nie je predpísané, koľko medzier alebo tabulátorov sa má použiť na odsadenie, ale podstatné je, aby bolo toto odsadenie v celom kóde jednotné, inak sa kód nemusí správne interpretovať alebo program vypíše chybu (tzv. indetation error). Na toto si treba dávať pozor, najmä pri kopírovaní z textových editorov, ako napr. PSPad do prostredia, v ktorom sa vykonávajú príkazy jazyka Python. Na odsadenie sa obyčajne používajú 4 medzery (prípadne jeden tabulátor). Použitie podmienok si ukážeme na príklade skriptu, ktorý rozhodne, či nami zadané číslo je väčšie alebo menšie ako 100. Postup práce je nasledovný: 1. Premennej x priradíme hodnotu, ktorú budeme skúmať. 2. Vhodne zostavíme podmienku, ktorá bude testovať, či x je väčšie alebo rovné ako 100 a zistenie vypíše na obrazovku. x = 20 # premennej x priradime hodnotu 20 if x >= 100: print "Cislo je vacsie ako 100." else: print "Cislo je mensie ako 100." # definujeme, co sa stane v pripade ze cislo je vacsie alebo mensie ako 100 Nami zostavený skript sa dá využiť len pre jedno testované číslo, teda len pre číslo 20. V prípade, že chceme testovať iné číslo, musíme jeho hodnotu zmeniť v zdrojovom kóde. V nasledovnom príklade zmeníme pevné priradenie premennej na dynamické priradenie. Program sa nás teda opýta, aké číslo chceme testovať. Následne toto číslo zadáme a program nám vyhodnotí, či je toto číslo menšie alebo väčšie ako 100. x = input("Zadaj cislo ktore chces testovat n") # definujeme, aby sa skript vzdy dopytoval pouzivatela na hodnotu premennej x if x >= 100: print "Cislo je vacsie ako 100." else: print "Cislo je mensie ako 100." # definujeme, co sa stane v pripade ze cislo je vacsie alebo mensie ako 100 Jediná zmena oproti poslednému skriptu nastala v prvom riadku, kde sme pevné priradenie premennej x = 20 zamenili za variabilné priradenie prostredníctvom funkcie input(). Funkcia sa skladá z pevnej časti input a premenlivej časti ohraničenej zátvorkami. Premenlivá časť reprezentuje hlásenie, ktoré sa zobrazí pred zadaním hodnoty. V prípade, že ju necháme prázdnu, zobrazí sa len blikajúci kurzor a skript bude čakať na zadanie hodnoty. Úlohou ďalšieho skriptu bude spýtať sa nás na našu výšku v metroch a váhu v kilogramoch, z čoho následne vypočíta náš Body Mass Index (BMI). Na základe našej hodnoty BMI nám program vypíše, či máme nadváhu, normálnu váhu alebo podváhu. BMI sa počíta ako podiel hmotnosti v kilogramoch a druhej mocniny výšky v metroch. BMI nad 25 sa považuje za
  21. 21. 21 nadváhu a pod 19 za podváhu. Všetky hodnoty medzi tým reprezentujú normálnu hmotnosť. Postup práce je nasledovný: 1. Premenným hmotnost a vyska dynamicky priradíme hodnoty. 2. Vypočítame hodnotu BMI. 3. Zostavíme podmienku, ktorá bude vhodným spôsobom informovať, či má subjekt nadváhu, normálnu váhu alebo podváhu. vyska = input("Zadaj vysku v metroch n") vaha = input("Zadaj vahu v kilogramoch n") # dynamicke priradenie vahy a vysky vyska = float(vyska) vaha = float(vaha) # prevod vysky a vahy na typ float, aby bol vysledok BMI v desatinnych cislach bmi = vaha/(vyska**2) # vypocet BMI print "Tvoj BMI = %f" %(bmi) # vypis bmi if bmi < 19: print "Mas podvahu" if 19 <= bmi < 25: print "Mas normalnu vahu" if bmi >= 25: print "Mas nadvahu" # zistujeme ci ma subjekt nadvahu, normalnu vahu alebo podvahu a vysledok vypiseme na obrazovku V tomto prípade sme využili zápis podmienky, kde definujeme každú eventualitu zvlášť. Ide o najjednoduchší a zároveň menej korektný zápis. Vyššie uvedená podmienka sa dá zapísať aj nasledovným spôsobom. if bmi < 19: print "Mas podvahu" else: if 19 <= bmi < 25: print "Mas normalnu vahu" else: if bmi >= 25: print "Mas nadvahu" # definujeme ci ma subjekt nadvahu, normalnu vahu alebo podvahu V tomto prípade sme využili vnorenú podmienku, kde každá nesplnená podmienka vstupuje do ďalšieho testovania. Vnorené podmienky využívame najmä pri hierarchickom rozhodovaní, keď delíme celok na časti a tie ešte na ďalšie časti. Situácia prvej, aj druhej možnosti je zobrazená na Obrázku 11.
  22. 22. 22 Obrázok 11. Ukážka dvoch možností riešenia viacnásobných podmienok (vetvenia). a,– Každá eventualita je definovaná zvlášť b,– Takzvaná vnorená podmienka, keď sa v prípade nesplnenia prvej podmienky následne testuje druhá a v prípade nesplnenia druhej podmienky sa testuje tretia. V ďalšom príklade budeme simulovať trh s cennými papiermi. Skript nám najprv vypíše ponuku akcií od piatich firiem aj s ich cenou, ktorá bude náhodná. Následne si používateľ môže nakúpiť ľubovoľný počet akcií jednej firmy. Skript bude simulovať zmenu hodnoty akcie prostredníctvom generovania novej náhodnej hodnoty akcie. Nakoniec skript vypíše, koľko sme na operácii zarobili alebo prerobili. 1. Importujeme modul na prácu s generátormi náhodných čísel. 2. Vytvoríme výpis cien pre päť spoločností. 3. Zistíme, koľko akcií, od ktorej spoločnosti si chce používateľ nakúpiť. 4. Simulujeme zmenu akcií prostredníctvom náhodného generovania novej ceny akcie. 5. Vypočítame celkový zisk alebo stratu a zostavíme podmienku, ktorá nás bude o tejto skutočnosti vhodne informovať. import random # import modulu random a1 = random.randrange(5,28) a2 = random.randrange(5,28) a3 = random.randrange(5,28) a4 = random.randrange(5,28)
  23. 23. 23 a5 = random.randrange(5,28) # nahodne generovanie cien akcii piatich firiem print "1,t cena akcie spolocnosti Prva Udenarska a.s. je %i eur" %(a1) print "2,t cena akcie spolocnosti Cokoladovne a.s. je %i eur" %(a2) print "3,t cena akcie spolocnosti Plynarne Myjava a.s. je %i eur" %(a3) print "4,t cena akcie spolocnosti Vinohrady Kolarovo a.s. je %i eur" %(a4) print "5,t cena akcie spolocnosti Zemiakaren Nitra a.s. je %i eur" %(a5) # vypis cien akcii jednotlivych spolocnosti firma = input("Zadaj id spolocnosti od ktorej chces nakupovat n") pocet_akcii = input("Zadaj pocet akcii ktory chces nakupit n") # dynamicke priradenie id firmy a poctu akcii. if firma == 1: nakupna_cena = a1 if firma == 2: nakupna_cena = a2 if firma == 3: nakupna_cena = a3 if firma == 4: nakupna_cena = a4 if firma == 5: nakupna_cena = a5 # priradenie ceny nakupu akcii print "Celkova cena nakupu je %i eur" %(nakupna_cena * pocet_akcii) # vypis celkovej ceny nakupu predajna_cena = random.randrange(5,28) print "Cena predaja akcie je %i eur" %(predajna_cena) print "Vsetky akcie predas za %i eur" %(predajna_cena * pocet_akcii) # generovanie predajnej ceny akcie a nasledne jej vypis a vypis celkovej ceny predaja if predajna_cena >= nakupna_cena: print "Na obchode si zarobil %i eur" %((predajna_cena - nakupna_cena)*pocet_akcii) if predajna_cena < nakupna_cena: print "Na obchode si prerobil %i eur" %((nakupna_cena - predajna_cena)*pocet_akcii) # definujeme ci sme na obchode zarobili alebo prerobili
  24. 24. 24 V tomto prípade sme sa zoznámili s modulom random, ktorý pod sebou združuje niekoľko funkcií na generovanie náhodných čísel. Modul importujeme prostredníctvom príkazu import v prvom riadku. Viac o moduloch a ich importovaní a práci s nimi nachádzame v kapitole 3.8. Z modulu random sme využili funkciu randrange(), ktorá náhodne generuje celé čísla v nami definovanom intervale. Interval definujeme v premenlivej časti kódu tak, že najprv zapíšeme spodnú hranicu intervalu a za čiarku vrchnú hranicu intervalu. 3.6 Cykly Za cyklus (iteráciu) v ponímaní programovania považujeme proces, ktorý sa opakuje s pravidelným prírastkom minimálne jednej premennej vopred definovaným počtom krát, alebo pokiaľ nie je splnená vopred definovaná podmienka. Už z vyššie uvedenej definície je evidentné, že poznáme cyklus s vopred definovaným počtom opakovaní (funkcia for) a cyklus s nedefinovaným počtom opakovaní (funkcia while) (Obrázok 12.). Obrázok 12. Ukážka dvoch druhov cyklov. a, – Cyklus s vopred definovaným počtom opakovaní. b, – Cyklus s vopred definovanou podmienkou, ktorý sa opakuje pokiaľ je podmienka platná. V cykle vždy existuje unikátna premenná, ktorá v každom behu cyklu mení svoju hodnotu a nazývame ju iterátor. Iterátorom býva ordinálna (poradová) premenná, a to buď v podobe celého čísla, alebo v podobe zoznamu hodnôt. 3.6.1 Cykly s definovaným počtom opakovaní Cyklus s vopred definovaným počtom opakovaní sa v jazyku Python zapisuje prostredníctvom funkcie for. for i in rozsah hodnôt: ukon Prvý riadok funkcie sa skladá z pevnej časti for a časti premenlivej, ktorá je ukončená dvojbodkou. V prípade, že sa tu dvojbodka nenachádza, príkaz je považovaný za chybný. V premenlivej časti definujeme rozsah hodnôt (od – do), v ktorých sa iterátor bude pohybovať. Druhý riadok v sebe obsahuje úkon, alebo úkony, ktoré sa v každom opakovaní cyklu vykonajú. Tento riadok musí nevyhnutne byť odsadený podľa podmienok uvedených v kapitole 3.5 Podmienky. V prvom príklade vyskúšame prostredníctvom cyklu s vopred definovaným počtom opakovaní vypísať na obrazovku 20-krát "Ahoj, ako sa mas?". Postup práce je nasledovný:
  25. 25. 25 1. Vytvoríme telo cyklu, ktorý sa bude 20-krát opakovať. 2. Definujeme zápis, ktorý bude vždy do nového riadku vypisovať "Ahoj, ako sa mas?". for i in range(20): # telo funkcie for print "Ahoj, ako sa mas?" # vypis vety 20–krát V tomto prípade sme v prvom riadku využili príkaz range(), ktorý generuje sekvenciu čísel v zadanom rozsahu. Ak zadáme iba jeden parameter, chápe sa ako konečná hodnota (prvá, ktorá už nebude patriť do zoznamu). V takom prípade sa vygeneruje sekvencia, začínajúca číslom 0 a končiaca číslom 19. Premenná i v cykle nadobúda postupne tieto hodnoty, ale v tele cyklu ju nepoužívame, slúži iba na iteráciu (opakovanie). Daný príkaz print sa teda v cykle zopakuje 20-krát. V druhom príklade vyskúšame prostredníctvom cyklu s vopred definovaným počtom opakovaní vypísať na obrazovku prvých 20 čísel, pričom začneme číslom jeden. Postup práce je nasledovný: 1. Vytvoríme telo cyklu, ktorý sa bude opakovať 20-krát. 2. Definujeme zápis, ktorý bude postupne do nového riadku zapisovať čísla od 1 do 20. for i in range(1,21): # telo funkcie for print i # vypis V tomto prípade sme len pozmenili predošlý skript. V prvom rade sme definovali aj spodnú, aj hornú hranicu intervalu a v druhom rade sme zmenili vopred definovaný výpis za iterátor (premennú). V tomto prípade sa teda iterátor používa priamo vo výpise. V ďalšom príklade vyskúšame prostredníctvom cyklu s vopred definovaným počtom opakovaní vypísať na obrazovku jednostranný trojuholník zložený zo znaku "*", kde na začiatku skriptu budeme môcť definovať výšku tohto trojuholníka. Výsledok bude vyzerať nasledovne. * ** *** **** ... Postup práce je nasledovný: 1. Prostredníctvom dynamického dopytu zistíme od používateľa výšku trojuholníka. 2. Vytvoríme telo cyklu, ktorý sa bude opakovať toľko krát, aká bude výška trojuholníka. 3. Definujeme zápis, ktorý bude postupne do prvého riadka vypisovať jednu hviezdičku, do druhého dve hviezdičky, do tretieho tri hviezdičky, atď. vyska = input("Zadaj pocet riadkov n") # dynamicke priradenie vysky trojuholnika premennej "vyska" for i in range (1,vyska):
  26. 26. 26 # telo funkcie for, kde horna hranica intervalu je definovana premennou vyska print i*"*" # vypis Do predošlého skriptu sme pridali len dynamické priradenie premennej vyska, ktorá bude udávať počet riadkov, a tým aj výšku trojuholníka. Horná hranica intervalu v cykle je definovaná touto premennou. Taktiež sme vhodne upravili výpis. V ďalšom príklade vypíšeme prostredníctvom cyklu s definovaným počtom opakovaní maticu 4x4, ktorá bude obsahovať dvojice čísel, označujúce riadok (prvé číslo) a stĺpec (druhé číslo). Výstup nezobrazíme na monitor, ale vypíšeme do súboru matica.txt. Výsledok by mal vyzerať nasledovne. 1,1 1,2 1,3 1,4 2,1 2,2 2,3 2,4 3,1 3,2 3,3 3,4 4,1 4,2 4,3 4,4 Postup práce je nasledovný: 1. Otvoríme súbor matica.txt v móde na zápis, ktorý sa bude nachádzať priamo na disku C:. 2. Vytvoríme telo cyklu, ktorý bude zabezpečovať výpis riadkov. 3. Vytvoríme telo cyklu, ktorý bude zabezpečovať výpis stĺpcov. 4. Definujeme zápis, ktorý bude za seba zapisovať číslo riadka, čiarku a číslo stĺpca. 5. Definujeme zápis, ktorý zabezpečí ukončenie riadka. 6. Uzatvoríme súbor matica.txt. f = open('C:/matica.txt', 'w') # otvorenie suboru matica.txt len na citanie for i in range(1,5): for j in range(1,5): f.write("%i,%i " %(i,j)) f.write("n") # definovanie zapisu ktory do suboru vypise najprv cislo riadka, potom cislo stlpca, ktore su oddelene ciarkou a na konci riadka sa presunie a novy riadok. f.close() # uzatvorenie suboru mena.txt V tomto prípade sme nevyužili žiadny nový príkaz. Počet riadkov a stĺpcov definujeme prostredníctvom hornej hranice intervalu funkcie range(). Využili sme takzvaný vnorený cyklus (Obrázok 13), kde v rámci cyklu existuje cyklus nižšej hierarchickej úrovne (podobne ako vnorená podmienka).
  27. 27. 27 Obrázok 13. Ukážka štruktúry vnoreného cyklu. Najprv sa teda vypísali stĺpce v prvom riadku prostredníctvom cyklu s iterátorom j a následne sa riadok posunul prostredníctvom cyklu s iterátorom i. Ďalší riadok sa vypísal opätovne prostredníctvom cyklu s iterátorom j. Všimnime si, že samotný zápis do súboru využíva oba iterátory, i aj j. Vnorené cykly budeme v geoinformatickej praxi využívať najmä na testovanie rozličných nastavení algoritmov, kde môžeme relatívne pohodlne zostaviť, napríklad, skript na testovanie nastavení interpolačnej funkcie spline, kde budeme meniť parameter tenzie a parameter minimálneho počtu bodov vstupujúcich do výpočtu. V ďalšom príklade zostavíme prostredníctvom vnoreného cyklu binárnu maticu, ktorá bude nadobúdať hodnoty 0 a len na svojej diagonále bude nadobúdať hodnoty 1. Výsledok zapíšeme do súboru bin_matica.txt. Výsledok by mal vyzerať nasledovne. 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 Postup práce bude nasledovný: 1. Otvoríme súbor bin_matica.txt v móde na zápis. 2. Vytvoríme telo cyklu, ktorý bude zabezpečovať výpis riadkov. 3. Vytvoríme telo cyklu, ktorý bude zabezpečovať výpis stĺpcov. 4. Definujeme zápis, ktorý bude v prípade, že je hodnota riadka a hodnota stĺpca totožná, zapisovať hodnotu 1, v opačnom prípade hodnotu 0. 5. Uzatvoríme súbor bin_matica.txt. f = open('bin_matica.txt', 'w') # otvorenie suboru matica.txt len na citanie for i in range(1,8): for j in range(1,8): if i ==j: f.write("1 ") # v pripade, ze cislo riadka je totozne s cislom stlpca zapiseme 1
  28. 28. 28 else: f.write("0 ") # v pripade, ze cislo riadka nie je totozne s cislom stlpca zapiseme 0 f.write("n") f.close() # uzatvorenie suboru mena.txt V tomto príklade sme v podstate len zmenili skript z predošlého príkladu a pridali k nemu podmienku, ktorá testuje, či je číslo riadka totožné s číslom stĺpca. V prípade že áno, zapíše sa 1, v opačnom prípade sa zapíše 0. 3.6.2 Cykly s nedefinovaným počtom opakovaní Doteraz sme využívali len cykly s vopred definovaným počtom opakovaní. Ako bolo spomínané na začiatku, okrem tohto druhu cyklu existuje aj cyklus s nedefinovaným počtom opakovaní, kde je počet opakovaní obmedzený podmienkou, ktorá ak nie je splnená, cyklus skončí. V jazyku Python pre tento zámer slúži príkaz while. while podmienka: ukon Prvý riadok funkcie sa skladá z pevnej časti while a časti premenlivej, ktorá je ukončená dvojbodkou. V prípade, že sa tu dvojbodka nenachádza, príkaz je považovaný za chybný. V premenlivej časti definujeme podmienku, ktorá musí byť platná. Druhý riadok obsahuje úkon, alebo úkony, ktoré sa v každom opakovaní cyklu vykonajú. Tento riadok musí byť nevyhnutne odsadený podľa podmienok uvedených v kapitole 3.5 Podmienky. V prípade, že podmienka bude vždy platná, cyklus bude pokračovať donekonečna, preto je potrebné byť pri zadávaní podmienok opatrný. V ďalšom príklade budeme simulovať ročný nárast platu zamestnanca vo firme Čokoládovne a.s., ktorý k svojmu základnému nástupnému mesačnému platu 650€, bude získavať ročné zvýšenie platu vždy podľa vzorca: zvýšenia_platu [€] = odpracované_roky * 27 Zamestnanec tvrdí, že keď bude jeho mesačný plat 1020 €, odíde z firmy a založí si živnosť. Budeme simulovať, kedy sa to stane, a aký bude jeho každoročný mesačný plat. Postup práce bude nasledovný: 1. Vytvoríme premennú roky, ktorej priradíme hodnotu 0 a premennú plat, ktorej priradíme hodnotu 560. 2. Vytvoríme telo cyklu, ktorý bude prebiehať až dovtedy, kým mesačný plat zamestnanca nebude aspoň 1020 €. 3. Definujeme premennú, ktorá bude počítať odpracované roky. 4. Definujeme zápis, ktorý bude vypisovať každoročný plat zamestnanca. 5. Po ukončení cyklu vypíšeme na obrazovku, o koľko rokov bude mať zamestnanec plat aspoň 1020 €. roky = 0 # premennej roky priradenime hodnotu 0 plat = 560
  29. 29. 29 # premennej plat priradime hodnotu 560, ktora reprezentuje nastupny plat while plat <1020: # telo cyklu while s podmienkou roky = roky + 1 # pocitadlo odpracovanych rokov plat = plat +(roky*27) # vypocet mesacneho platu print "Mesacny plat po %i roku je %i eur" %(roky, plat) # vypis poctu rokov vo firme a mesacneho platu zamestnanca print "Zamestnanec odide o %i rokov" %(roky) # vypis poctu rokov,kedy zamestnanec odide V tomto prípade sme zabezpečili, že podmienka nebude vždy platná, preto nedôjde k vzniku nekonečného cyklu. 3.7 Zoznamy Zoznam môžeme definovať ako n-ticu prvkov (premenných alebo konštánt). Príkladom zoznamu môže byť n-tica čísel, napr. [12, 13, 14, 18, 4, 5, 6]. Jednotlivé prvky v zozname je možné meniť. Pre bežného používateľa, ktorý nemá znalosti z oblasti programovania, nemá zoznam hodnôt prílišný význam, avšak, pre vývojárov ide o prvok jazyka, ktorý je bežne a početne využívaný. Dobrým príkladom použitia je súbor, ktorý obsahuje v riadkoch mená osôb a počet týchto mien (počet riadkov) je neznámy. Nevieme teda, koľko premenných si máme pripraviť pred čítaním tohto súboru. Môžeme si však pripraviť zoznam, do ktorého budeme tieto mená postupne pridávať. Najjednoduchším spôsobom vytvorenia zoznamu je jeho enumerácia (vymenovanie), kde premennej priradíme hodnoty. zoznam1 = [] # vytvorenie prazdneho zoznamu zoznam1 = [1,15,12,14,75,8,4] # vytvorenie zoznamu s hodnotami V tomto prípade sme vytvorili zoznam s názvom zoznam1, ktorý bol prázdny. Následne sme mu priradili hodnoty 1, 15, 12... Ide o zoznam typu integer, pretože všetky hodnoty v ňom sú typu celého čísla. Ak dáme zoznam vypísať prostredníctvom príkazu print, zobrazí sa nám celý jeho výpis. zoznam1 = [1,2,3,4,5,6,7] print zoznam1 [1,2,3,4,5,6,7] # zoznam celých čísel zoznam2 = ["janko", "misko", "ferko"] print zoznam2 ['janko', 'misko', 'ferko'] # zoznam znakovych premennych
  30. 30. 30 Zoznam ako premenná sa javí ako jeden celok. Čo však v prípade, že chceme zobraziť (alebo použiť) len vybraný prvok zo zoznamu? Využívame takzvané indexovanie, čo znamená, že každá pozícia v zozname má svoj poradový identifikátor, ktorý je unikátny (Obrázok 14). Obrázok 14. Ukážka indexovania zoznamu, kde je evidentné, že indexovanie začína zľava doprava od hodnoty 0. Indexovanie zoznamu začína vždy zľava a začína pozíciou 0, pokračuje pozíciou 1, atď. V prípade, že chceme využiť len jednu hodnotu zo zoznamu, využívame nasledujúci príkaz. zoznam1 = [1,2,3,4,5,6,7] print zoznam1 [1] 2 print zoznam1 [3] 4 Pre potreby sofistikovanejšej práce so zoznamom využívame funkcie integrované v jazyku Python. Ukážeme si to na príklade funkcie len(), ktorá vracia dĺžku parametra zadaného medzi okrúhle zátvorky (v tomto prípade zadáme názov zoznamu). zoznam1 = [1,52,34,4,5,46,17] print len(zoznam1) 7 V tomto prípade sa výsledok funkcie vypíše na obrazovku, ale je možné priradiť ho aj do premennej a naďalej používať. V súčasnosti existuje skutočne široké spektrum funkcií na prácu so zoznamom, avšak, v tomto texte sa im nebudeme venovať. Mnohé funkcie implementované v jazyku Python pracujú so zoznamom poloautomaticky a dokážu sa v ňom samé pohybovať. Dobrým príkladom je cyklus for. V prípade, že chceme aby iterátor nadobúdal hodnoty, ktoré nie sú v logickej postupnosti, využijeme práve zoznam. zoznam = [1,52,34] for i in zoznam: print i 1 52 34 V tomto prípade sme cyklu for zadali len názov premennej (zoznamu) a cyklus sám pochopil, že v každom kroku má využiť vždy pozíciu s vyšším indexom. V prvom kroku za iterátor teda zvolil pozíciu 0 v zozname, ktorá nadobúda hodnotu 1, v druhom kroku za iterátor zvolil pozíciu 1 v zozname, ktorá nadobúda hodnotu 52 a v kroku treťom za iterátor zvolil pozíciu 2, ktorá nadobúda hodnotu 34. Následne sa cyklus automaticky ukončil.
  31. 31. 31 3.8 Funkcie Funkcie v programovacom jazyku sú časti kódu, ktoré možno opakovane spúšťať prostredníctvom ich zavolania. Vo všeobecnosti je funkcia časť zdrojového kódu, ktorá vykonáva nejakú konečnú činnosť (počíta faktoriál, kreslí štvorec) a vracia výsledok (faktoriál, nakreslený štvorec). Zdrojový kód funkcie sa skladá z dvoch častí: 1. Definovanie funkcie – časť zdrojového kódu, kde zapíšeme funkciu má nasledovnú štruktúru. def nazov (parametre): zdrojovy_kod return vystupna_premenna Pri tvorbe vlastnej funkcie v jazyku Python začíname kľúčovým slovom def, za ktorým nasleduje medzera a názov funkcie. Pre názvy funkcií platia rovnaké pravidlá ako pre názvy premenných, teda nesmú obsahovať medzery, diakritiku a musia byť odlišné od príkazov v jazyku Python. Za názvom funkcie nasledujú okrúhle zátvorky, v ktorých sú uvedené parametre (argumenty, vstupné premenné) funkcie a dvojbodka, ktorá je povinným znakom. Časť za dvojbodkou sa označuje ako telo funkcie a nachádzajú sa tam príkazy, ktoré sa vykonávajú po zavolaní funkcie. Tieto musia byť odsadené rovnako, ako v prípade podmienok a cyklov. Kľúčové slovo return na poslednom riadku deklaruje, akú hodnotu má funkcia vrátiť (výstupnú premennú z funkcie). Ukážku definovania jednoduchej funkcie vidíme na nasledovnom príklade. def stvorec(n): n2 = n*n return n2 # funkcia s nazvom stvorec vypocita druhu mocninu zadanej hodnoty V tomto prípade funkcia s názvom stvorec vráti hodnotu vypočítanej druhej mocniny parametra. 2. Volanie funkcie – časť zdrojového kódu, ktorou voláme funkciu, ktorá je v kóde už definovaná. Volanie funkcie má nasledovnú štruktúru. nazov(vstupne_premenne) Vyššie definovanú funkciu stvorec voláme prostredníctvom nasledovného zápisu. print stvorec(4) 16 # po zavolani funkcie s parametrom 4 sa vrati ako vysledok hodnota 16 Funkcia nemusí mať žiadne parametre, aj v tomto prípade sa však povinne uvádzajú prázdne okrúhle zátvorky, ktoré vyjadrujú, že sa jedná o funkciu. def prezident(): return 'Kiska' # funkcia na zistenie mena sucasneho prezidenta print prezident() Kiska Funkcia dokonca nemusí vracať žiadnu hodnotu, môže len vykonávať určitú činnosť: def pozdrav(meno):
  32. 32. 32 print ('Ahoj ' + meno + ', ako sa máš?') pozdrav('Mirka') Ahoj Mirka, ako sa mas? V rámci funkcie môžeme volať akékoľvek funkcie jazyka Python, ako aj vlastné funkcie: def pozdravPrezidenta(): print ('Ahoj ' + prezident() + ', ako sa máš?') # v tele funkcie sa zavolá funkcia prezident(), ktora vracia meno sucasneho prezidenta pozdravPrezidenta() Ahoj Kiska, ako sa máš? Funkcie sú veľmi častým prvkom najmä komplikovanejších skriptov, ktoré zrýchľujú, a najmä zjednodušujú proces tvorby skriptu. Avšak, pre začínajúceho programátora môžu (ale nemusia) pôsobiť priveľmi komplikovane. V ďalšom texte preto nebudeme využívať vlastné funkcie, iba funkcie jazyka Python a jeho knižníc (modulov). 3.9 Modulárna štruktúra jazyka Python Ako bolo spomínané už vyššie, jazyk Python je modulárny, teda je možné ho rozširovať prostredníctvom modulov (balíčkov, knižníc, packages, libraries...). Za balíček považujeme skupinu funkcií, ktorá rozširuje základnú funkcionalitu jadra jazyka Python (Obrázok 15.). Obrázok 15. Ukážka vzťahu medzi jadrom jazyka Python a modulmi. Inštalované moduly sa nachádzajú v operačnom systéme, avšak sú neaktívne až do času použitia. Všetky používané moduly musia byť inštalované v rámci používaného operačného systému, v rámci ktorého je vytvorený ich zoznam. V prípade, že chceme využiť akýkoľvek nástroj z
  33. 33. 33 jedného z týchto modulov, je nutné najprv modul importovať (aktivovať, vzbudiť). Toto uskutočníme prostredníctvom príkazu import. import numpy # import knižnice numpy import matplotlib # import knižnice matplotlib import os # import knižnice os Odporúča sa importovať len tie moduly, ktoré sú v skripte aj reálne využívané, pretože import každej knižnice zaberá nejaký čas, čo spomaľuje beh samotného skriptu. Časovo náročný je, napríklad, import modulu arcpy, ktorý slúži na prácu s priestorovými údajmi. V súčasnosti existuje niekoľko stoviek bežne používaných modulov, pričom každý z nich sa skladá z niekoľkých desiatok nástrojov. V prípade, že chceme knižnicu využívať, je nevyhnutné si overiť, či je korektne nainštalovaná. 4. Priestorová analýza prostredníctvom knižnice ArcPy Prvou knižnicou, s ktorou sa v rámci tohto textu bližšie zoznámime, bude knižnica ArcPy. Je súčasťou prostredia ESRI ArcGIS 10.X. Samotná knižnica umožňuje prostredníctvom jazyka Python ovládať základnú funkcionalitu prostredia ArcGIS 10.X, najmä ArcToolbox. Môžeme si ju predstaviť najmä ako komunikačný nástroj. Takmer každý nástroj v ArcToolbox-e je možné ovládať práve prostredníctvom tejto knižnice. Ponúka však aj ďalšie funkcie na zrýchlenie a zjednodušenie práce (napr., funkcie na tvorbu zoznamov vrstiev, polí v atribútovej tabuľke, atď.). Hlavnou výhodou ovládania nástrojov ArcToolbox-u prostredníctvom knižnice ArcPy je možnosť reťazenia a opakovaného použitia nástrojov, teda automatizácia spracovania. Nie je problémom, napríklad, vytvorenie reťazca nástrojov, ktorý vyčlení povodia na základe zvoleného digitálneho výškového modelu alebo cyklu, ktorý bude tvoriť digitálne výškové modely s rôznymi nastaveniami parametrov interpolácie. Pred použitím knižnice ArcPy je nevyhnutné ju importovať (vždy, keď nanovo spustíme ArcMap a okno Python Window). Proces importu zabezpečuje príkaz na import modulov: import arcpy # import knižnice ArcPy Modul v jazyku Python je súbor, ktorý obsahuje funkcie a triedy. Knižnica ArcPy obsahuje viacero modulov, medzi najdôležitejšie patrí modul Mapping (arcpy.mapping) na tvorbu mapových výstupov, modul Spatial Analyst (arcpy.sa) na prácu s rastrami a modul Geostatistical Analyst (arcpy.ga) na geoštatistické analýzy. Niektoré moduly nepodliehajú základnej licencii ArcGIS Desktop, preto je v prípade problémov s importom potrebné overiť dostupnosť licencie na ich používanie. Takisto je potrebné mať zapnuté príslušné rozšírenie. Moduly môžeme importovať viacerými spôsobmi. Výhodné je použiť príkaz from-import-*, ktorý umožňuje použitie funkcií a podmodulov príslušného modulu bez nutnosti písania predpony s názvom modulu a najmä bez nutnosti importu celého modulu ArcPy, ale len jeho časti: from arcpy import sa # import modulu Spatial Analysis – prvý spôsob # musíme písať predponu outRaster = (sa.Raster(inRaster1) + sa.Raster(inRaster2))
  34. 34. 34 from arcpy.sa import * # import modulu Spatial Analysis – druhý spôsob # nemusíme písať predponu outRaster = (Raster(inRaster1) + Raster(inRaster2)) Knižnica ArcPy obsahuje jednak geoprocesné nástroje dostupné aj v ArcToolbox-e a jednak vlastné funkcie. Z hľadiska používateľa, rozdiel medzi nimi spočíva v tom, že sú odlišne dokumentované a majú odlišnú syntax. Dokumentáciu ku geoprocesným nástrojom nájdeme v ArcGIS Desktop Help systéme (dostupný aj online), kde má každý nástroj svoju referenčnú stránku (Obrázok 16.). Referenčná stránka obsahuje základný popis nástroja, podrobné informácie o použití nástroja, popis vstupných a výstupných parametrov nástroja, ako aj ukážku syntaxe a príklad použitia kódu. Dokumentácia k ostatným nástrojom je súčasťou dokumentácie knižnice ArcPy, ktorá je takisto súčasťou ArcGIS Desktop Help systému. Ďalším rozdielom medzi geoprocesnými a vlastnými funkciami ArcPy je v tom, že geoprocesné nástroje sú licencované úrovňou produktu (ArcGIS Desktop Basic, Standard, Advanced) a rozšíreniami, podobne ako v ArcToolbox-e, kým funkcie sú nainštalované spolu s ArcPy sú vždy prístupné bez obmedzenia. Obrázok 16. Ukážka základných častí Pomocníka pre ľubovoľný nástroj z ArcGIS Toolbox. Počas práce s nástrojmi ArcPy netreba zabúdať na nasledujúce fakty: 1. Knižnica ArcPy umožňuje len komunikáciu s prostredím ArcGIS (najmä ArcToolbox), teda takmer všetky limitácie nástrojov ArcToolbox sa budú prejavovať aj v tomto prípade. 2. Pozor na prepisovanie už raz zapísaných dát, teda v prípade opakovaného spustenia toho istého skriptu dôjde k prepísaniu už existujúcich dát. Platí len v prípade, že máme povolenú možnosť prepisu dát (v menu Geoprocessing/Geoprocessing options/Overwrite the outputs of geoprocessing operations–Enable). 3. Niektoré skupiny nástrojov (napr. Spatial Analyst) sú samostatne licencované, teda treba si overiť, či má používateľ túto licenciu zakúpenú a aktivovanú (v menu Customize/Extensions...).
  35. 35. 35 V prípade, že chceme v rámci modulu ArcPy využiť nástroj, s ktorým sme ešte nepracovali, odporúčame nasledujúci postup: 1. Zistenie názvu nástroja. Tento krok býva v rámci riešenia problému najkomplikovanejší, vzhľadom na široké spektrum nástrojov v prostredí ArcGIS. V tomto prípade je vhodné využiť vyhľadávanie prostredníctvom internetu alebo využitie okna Search v prostredí ArcGIS (Obrázok 17.). To nám po zadaní kľúčových slov ponúkne nástroj alebo niekoľko nástrojov, ktoré sú k týmto slovám asociované. Obrázok 17. Ukážka okna Search v prostredí ArcGIS 10.X. 2. Oboznámenie sa s podrobným popisom nástroja v okne Pomocníka alebo prostredníctvom online Pomocníka. 3. Oboznámenie sa so vstupmi do nástroja. Vo všeobecnosti rozoznávame povinné a voliteľné vstupy. Ako ich názvy napovedajú, povinné vstupy sú nevyhnutné na beh modulu a voliteľné vstupy ponúkajú len viac možností nastavenia, ktoré ak používateľ nenastaví, automaticky sa nastavia prednastavené (default) hodnoty. Povinné parametre sú bez zátvoriek, voliteľné sú uvedené v hranatých zátvorkách. Samotná tabuľka, popisujúca vstupy ponúka aj exaktné definovanie typu vstupu (Data type), vďaka ktorému vieme, aký druh vstupu je možné v nastavení využiť. Počas zostavovania skriptu je nevyhnutné sa vždy uistiť, že používame správny druh vstupu. 4. Preštudovanie výstupov z modelu. V mnohých prípadoch je výstupom z modelu len záverečná správa (Log) alebo tabuľka (Table), ktorým treba venovať zvláštnu pozornosť. 5. Preštudovanie samotného zdrojového kódu uvedeného v časti s príkladmi (Code samples). V prípade začínajúcich používateľov, odporúčame tento kód kopírovať do vlastného skriptu a tu ho vhodne upraviť. V prípade, že sme sa oboznámili s vlastnosťami nástroja, ktorý chceme využívať, zameráme sa na samotné zostavenie skriptu. Je potrebné si uvedomiť, že knižnica ArcPy (ako akákoľvek iná knižnica v jazyku Python) má špecifickú syntax a vlastnosti, ktoré nie sú vždy totožné s vlastnosťami samotného jadra jazyka Python. Geoprocesné nástroje sa spúšťajú cez všeobecnú syntax arcpy.toolname_toolboxalias(), pričom do zátvorky sa zadávajú vstupné a výstupné parametre nástroja. Parametre musíme zadávať v predpísanom poradí, tak ako je
  36. 36. 36 definované v Help súbore. Ak nepovinné parametre nechceme zadať, nemôžeme ich vynechať, ale musíme namiesto toho uviesť prázdny reťazec (""). Dôležité je uvedomiť si, akého typu je príslušný parameter. V prípade, že vstupným parametrom je číslo, zadávame ho bez ohraničenia úvodzovkami. V prípade, že vstupným parametrom je znakový reťazec, tento ohraničujeme jednoduchými alebo dvojitými úvodzovkami. Ak je vstupným alebo výstupným parametrom vrstva, zadávame celú cestu k nej spolu s jej názvom a príponou, celé ohraničené úvodzovkami. Pri zadávaní vstupov môžeme využiť aj pomôcku v okne Python Window, ktoré ponúka ako vstupy vrstvy v práve otvorenom projekte (Obrázok 18.). Obrázok 18. Ukážka okna Python spolu s pomôckou s práve otvorenými vrstvami. Ukážeme si príklad skriptu na spustenie geoprocesného nástroja Buffer_analysis, ktorý vytvára vzdialenostné zóny okolo prvkov vektorovej vrstvy. Nástroj Buffer_analysis má tri povinné parametre – vstupnú triedu prvkov, výstupnú triedu prvkov a vzdialenosť. Ak sa pozrieme do dokumentácie k tomuto nástroju, môžeme vidieť, že okrem troch povinných parametrov, môžeme zadať aj voliteľné parametre: Buffer_analysis (in_features, out_feature_class, buffer_distance_or_field, {line_side}, {line_end_type}, {dissolve_option}, {dissolve_field}) Voliteľné parametre, uvedené v hranatých zátvorkách, umožňujú zvoliť, na ktorej strane línie chceme vytvoriť vzdialenostnú zónu (line_side), ako má byť tvarovaná zóna na konci línie (line_end_type), či sa majú zóny okolo jednotlivých prvkov zlúčiť (dissolve_option), prípadne, na základe ktorého poľa v atribútovej tabuľke majú byť zlúčené (dissolve field). Možnosti a predvolené hodnoty jednotlivých parametrov takisto nájdeme v dokumentácii. V nasledovnom príklade si ukážeme tvorbu vzdialenostných zón po oboch stranách ciest do vzdialenosti 100 metrov. import arcpy arcpy.Buffer_analysis("C:/py/cesty.shp", "C:/py/buffer1.shp", "100 Meters") Prvý riadok kódu zabezpečuje import modulu arcpy a druhý riadok priamo spúšťa modul Buffer_analysis. Ďalší príklad ukazuje tvorbu vzdialenostných zón po oboch stranách ciest do vzdialenosti 100 metrov so zlúčením zón do jedného prvku. import arcpy arcpy.Buffer_analysis("C:/py/cesty.shp", "C:/py/buffer2.shp", "100 Meters","FULL","","ALL","")
  37. 37. 37 Na vyššie uvedenom príklade sme si ukázali spôsob spúšťania nástrojov ArcToolbox-u pomocou knižnice ArcPy. Ak je výsledkom nástroja priestorová vrstva, ako je tomu, napríklad, pri nástrojoch balíka Spatial Analyst, použijeme nasledovný spôsob. import arcpy from arcpy.sa import * objekt = NaturalNeighbor("c:/vyska.shp ", "Z", 2) # skript, ktoreho vysledkom je rastrova vrstva reprezentovana ako objekt objekt.save("C:/dtm.tif") # ulozenie objektu vo formate "tiff" V tomto prípade v parametroch nástroja NaturalNeighbor nezadávame cestu k výstupnej vrstve, ale namiesto toho tento nástroj výstupnú vrstvu vracia ako objekt. Tento objekt najprv uložíme do premennej a v ďalšom riadku kódu použijeme funkciu save() na uloženie objektu vo formáte tiff na určené miesto na disku. V prípade, že žiadnu príponu nezadáme, súbor sa uloží vo formáte ESRI Grid. 4.1 Práca s vektorovými vrstvami Skriptovanie pomocou jazyka Python významne uľahčuje prácu s vektorovými vrstvami v prostredí ArcGIS, najmä ak sa jedná o dávkové (hromadné) spracovanie údajov, alebo zložitejšie operácie, vyžadujúce podmienkovú logiku. Spracovanie vektorových údajov si ukážeme na príklade odhadu negatívneho vplyvu hlučnosti a znečistenia ovzdušia v okolí ciest na škôlky, školy a nemocnice v okrese Banská Bystrica. Budeme mať k dispozícii vstupné vrstvy ciest, budov a hranice okresu Banská Bystrica. Postup bude pozostávať z týchto hlavných krokov: 1. Tvorba vzdialenostných zón okolo ciest prostredníctvom nástroja Buffer. 2. Výber škôl, škôlok a nemocníc z vrstvy budov prostredníctvom nástroja Select. 3. Orezanie výsledných vrstiev podľa hraníc okresu Banská Bystrica prostredníctvom nástroja Clip. 4. Priestorový prekryt vybraných budov so vzdialenostnými zónami prostredníctvom nástroja Intersect. Prvým krokom bude vytvorenie vzdialenostných zón okolo ciest. V príklade uvedenom vyššie sme si ukázali použitie nástroja Buffer_analysis(). Tento istý nástroj použijeme v cykle na vytvorenie zón v rôznych vzdialenostiach od ciest. import arcpy distList = [50,100,250] # vytvorenie zoznamu vzdialenosti for dist in distList: distString = "%s Meters" % dist outPath = "C:/py/data/buffer%s.shp" % dist arcpy.Buffer_analysis("C:/py/cesty.shp", outPath, distString,"FULL","","ALL","") V prvom kroku si vytvoríme zoznam vzdialeností, ktorým budeme prechádzať v cykle for. V samotnom tele cyklu si najprv musíme pripraviť dve premenné, ktoré budú vstupovať do
  38. 38. 38 nástroja Buffer_analysis(). Keďže parameter vzdialenosti sa zadáva ako textový reťazec aj s uvedením jednotiek, tento parameter si predpripravíme pomocou formátovania reťazcov a uložíme ho do premennej distString. Pri spúšťaní geoprocesných nástrojov v cykle je dôležité zabezpečiť, aby sa pri jednotlivých spusteniach neprepisovali výsledné vrstvy. Pre tento zámer si vytvoríme premennú outPath, predstavujúcu cestu k výstupnej vektorovej vrstve, v ktorej sa bude meniť hodnota vzdialenosti. Výsledkom skriptu budú tri vektorové vrstvy s názvami buffer50.shp, buffer100.shp a buffer250.shp. V druhom kroku je potrebné z vektorovej vrstvy budov vybrať všetky školy, škôlky a nemocnice a uložiť ich do samostatnej vrstvy. Použijeme na to nástroj Select_analysis(), ktorý slúži na atribútové výbery (dopyty). arcpy.Select_analysis("C:/py/budovy.shp", "C:/py/data/budovyVyber.shp",""" "typ" IN ('skola', 'skolka', 'nemocnica') """) Povinnými vstupnými parametrami nástroja Select_analysis() je názov vstupnej vrstvy, názov výstupnej vrstvy a SQL výraz s podmienkou výberu. Pri zadávaní podmienky sú názvy polí (stĺpcov) atribútovej tabuľky ohraničené dvojitými úvodzovkami a textové reťazce sú ohraničené jednoduchými úvodzovkami. Samotná podmienka je ako celok ohraničená tromi dvojitými úvodzovkami. Pri výbere sme použili operátor IN, ktorý umožňuje porovnanie s viacerými hodnotami (oproti tomu operátor = dovoľuje porovnávanie iba s jednou hodnotou). V tomto prípade porovnávame hodnoty v stĺpci typ v atribútovej tabuľke s tromi textovými reťazcami (stĺpec typ vo vrstve budovy.shp obsahuje informácie o druhu budovy). Ak budova patrí do jedného z troch typov, uloží sa do výslednej vrstvy. V treťom kroku orežeme vytvorené vektorové vrstvy budov a vzdialenostných zón podľa hraníc okresu Banská Bystrica. Na tomto príklade si ukážeme použitie listovacej funkcie knižnice ArcPy. Listovacia funkcia ListFeatureClasses() vracia zoznam všetkých vrstiev v pracovnom adresári. Vytvoreným zoznamom budeme následne prechádzať v cykle for pri orezávaní vrstiev. arcpy.env.workspace = "C:/py/data" # nastavenie pracovneho adresara fcList = arcpy.ListFeatureClasses() # vytvorenie zoznamu vrstiev v pracovnom adresari a ulozenie do premennej print fcList [u'budovyVyber.shp', u'buffer50.shp', u'buffer100.shp', u'buffer250.shp] for inFC in fcList: outFC = inFC.strip('.shp') + "BB.shp" arcpy.Clip_analysis(inFC, "C:/py/okresBB.shp", outFC) # prechadzanie zoznamom a orezanie vrstiev v cykle V tomto prípade sa stretávame s pracovným adresárom, čo je priestor na disku, z ktorého program predvolene číta a zapisuje dáta. V prípade, že používame pracovný adresár, nie je nutné definovať celé cesty k vrstvám. Pracovný adresár nastavíme pomocou premennej arcpy.env.workspace. Funkcia ListFeatureClasses() potom vráti zoznam všetkých vrstiev v adresári, ktorý je v našom prípade priradený do premennej fcList. Ako môžeme vidieť, zoznam obsahuje názvy jednotlivých vrstiev v podobe textových reťazcov (pred každým
  39. 39. 39 reťazcom je písmeno u, ktoré znamená, že sa jedná o reťazec typu Unicode). Takto vytvorený zoznam môžeme použiť pri akomkoľvek dávkovom spracovaní vektorových vrstiev pomocou geoprocesných nástrojov. V našom príklade vrstvy orezávame podľa hraníc okresu Banská Bystrica. Orezanie vrstiev v knižnici ArcPy zabezpečuje nástroj Clip_analysis(), ktorý má tri povinné parametre v poradí vstupná vrstva, vrstva, podľa ktorej orezávame a výstupná vrstva. Názov výstupnej vrstvy vytvoríme pridaním písmen BB za názov vstupnej vrstvy. Keďže súčasťou názvu je aj prípona .shp, musíme najprv túto príponu odstrániť funkciou strip() a následne pripojiť textový reťazec „BB.shp“. Výsledkom tretieho kroku teda budú štyri orezané vrstvy s názvami budovyVyberBB.shp, buffer50BB.shp, buffer100BB.shp a buffer250BB.shp V poslednom, štvrtom kroku, urobíme priestorový prekryt vybraných budov so vzdialenostnými zónami. V prostredí GIS je štandardným nástrojom na prekrytie dvoch vrstiev nástroj Intersect. V knižnici ArcPy ho nájdeme pod názvom Intersect_analysis() a má dva povinné parametre, zoznam vstupných vektorových vrstiev a názov výstupnej vektorovej vrstvy. Zoznam sa rovnako ako v jadre jazyka Python ohraničuje hranatými zátvorkami. Priestorový prekryt urobíme pre všetky tri vzdialenostné zóny, takže opäť využijeme cyklus: for dist in distlist: inFC = ["budovyVyberBB.shp", "buffer%sBB.shp" % dist] outFC = "budovy%s.shp" % dist arcpy.Intersect_analysis(inFC,outFC) V cykle postupne vybrané budovy prekryjeme s každou vdialenostnou zónou. Výsledkom budú tri vrstvy budovy50.shp, budovy100.shp a budovy250.shp, obsahujúce školy, škôlky a nemocnice do 50, do 100 a do 250 m od ciest v okrese Banská Bystrica. Tieto budovy môžu byť potenciálne ovplyvnené znečistením ovzdušia a hlučnosťou a deťom, študentom a pacientom v nich môže hroziť potenciálne zdravotné riziko. Na vyššie uvedených príkladoch sme si ukázali základné analytické nástroje na prácu s vektorovými vrstvami Select, Buffer, Clip a Intersect a vysvetlili sme princípy dávkového spracovania vektorových údajov v cykloch. 4.2 Práca s rastrovými vrstvami V predchádzajúcej kapitole sme sa oboznámili s využitím jazyka Python a knižnice ArcPy pre potreby práce s vektorovými priestorovými dátami. V tejto kapitole sa zameráme na prácu s rastrovými dátami. Kapitola sa sústreďuje na využitie skupiny nástrojov Spatial Analyst, ktorá je zameraná na priestorovú analýzu s vrstvami dát v rastrovom formáte. V nasledujúcom príklade zostavíme skript, ktorý spustí interpoláciu digitálneho výškového modelu prostredníctvom algoritmu idw. import arcpy from arcpy.sa import * # import kniznice arcpy a modulu Spatial Analyst outIDW = Idw("C:/vector/body.shp", "Z", 2, 2, RadiusVariable(10, 150)) # spustenie interpolacie a vytvorenie rastrovej vrstvy vo forme objektu outIDW.save("C:/raster/dtm.tif")
  40. 40. 40 # ulozenie vyslednej rastrovej vrstvy vo formate TIF Vstupná vektorová vrstva sa v tomto prípade volá body.shp a nachádza sa v priečinku vector, umiestnenom priamo na disku C. Názov stĺpca v tabuľke atribútov s hodnotou nadmorskej výšky je Z a rozlíšenie výstupnej rastrovej vrstvy (výstupného digitálneho výškového modelu) sú 2 metre. Exponent vzdialenosti je nastavený na hodnotu 2. Využitou metódou vyhľadávania okolitých bodov je RadiusVariable s minimálnym počtom bodov 10 a maximálnym vyhľadávacím okolím 150 jednotiek vzdialenosti. Výslednou rastrovou vrstvou bude dtm.tif. V tomto prípade sme spustili len jeden modul z knižnice ArcPy. Tento postup je adekvátny tomu, ak by sme spustili jeden modul prostredníctvom grafického rozhrania. V nasledujúcom príklade vytvoríme skript, ktorý vytvorí 8 rastrov (8 digitálnych výškových modelov), ktoré budú všetky vytvorené prostredníctvom interpolačnej funkcie IDW, pričom exponent vzdialenosti bude nadobúdať hodnoty (0.1, 0.3, 0.4, 0.6, 0.7 , 1, 1.3, 1.5 ). Postup práce bude nasledovný: 1. Vytvorenie zoznamu reprezentujúceho hodnoty exponentu vzdialenosti, ktoré budeme využívať pre interpoláciu. 2. Vytvorenie cyklu, ktorý bude meniť exponent vzdialenosti. 3. Interpolácia prostredníctvom algoritmu IDW. 4. Zápis výslednej rastrovej vrstvy s názvom dtm_10. 5. Opakovanie bodov 3 a 4 ďalších 7-krát. import arcpy from arcpy.sa import * # import kniznice arcpy a modulu Spatial Analyst p = [0.1, 0.3, 0.4, 0.6, 0.7 , 1, 1.3, 1.5 ] # vytvorenie zoznamu p, ktore obsahuje hodnoty exponentov vzdialenosti for pow in p: # vytvorenie cyklu zabezpecujuceho pohyb po zozname "p" objekt = Idw("C:/arcpy/body.shp", "ELEVATION", 2000, pow, RadiusVariable(10,200)) # vytvorenie vrstvy a ulozenie do podoby objektu objekt.save("C:/arcpy/raster/dtm_%i.tif" %(pow*10)) # ulozenie objektu do podoby rastrovej vrstvy V tomto prípade využívame fakt, že cyklus for sa dokáže automaticky posúvať po zozname. V prípade, že iterátor (v našom prípade pow) využívame v zápise funkcie ArcPy, je nevyhnutné pamätať na formát tohto iterátora, pretože niektoré parametre si vyžadujú len textové vstupy, a niektoré len číselné vstupy. Iterátorom je v tomto prípade desatinné číslo. Pri ukladaní novej rastrovej vrstvy je nevyhnutné pamätať na zmenu názvu vrstvy počas každej iterácie, aby nedochádzalo k prepisovaniu vždy tej istej výstupnej vrstvy. V prípade, že by sme nechali zapísať priamo iterátor do názvu, došlo by k ukončeniu skriptu, pretože názov rastrovej vrstvy nesmie obsahovať znak bodky. Preto iterátor násobíme číslom 10 a až následne používame v názve výstupnej vrstvy. Vo vyššie uvedenom prípade sme spustili len jeden nástroj ArcToolbox s ôsmimi odlišnými nastaveniami. V ďalšom príklade zostavíme algoritmus na vytvorenie 20 rastrových vrstiev prostredníctvom algoritmu Spline, pričom vrstvy budú nadobúdať 4 rozlíšenia rastra (1 m, 2 m, 3 m, 4 m) a 5
  41. 41. 41 nastavení váhy (0.1, 0.2, 0.3, 0.4, 0.5). Je teda nutné zostaviť skript, ktorý bude generovať všetky možnosti nastavenia týchto dvoch parametrov. Postup práce je nasledovný: 1. Vytvorenie zoznamu reprezentujúceho rozlíšenie rastra. 2. Vytvorenie zoznamu reprezentujúceho hodnoty váh. 3. Vytvorenie cyklu, ktorý bude meniť rozlíšenie rastra. 4. Vytvorenie cyklu, ktorý bude meniť hodnoty váh. 5. Interpolácia prostredníctvom algoritmu Spline. 6. Zápis výslednej rastrovej vrstvy s názvom dtm_1_10. 7. Opakovanie krokov 5 a 6 ďalších 19-krát. import arcpy from arcpy.sa import * # import kniznice arcpy a modulu Spatial Analyst rozlisenie = [1, 2, 3, 4] # vytvorenie zoznamu "rozlisenie", ktore obsahuje hodnoty rozliseni rastra vaha = [0.1, 0.2, 0.3, 0.4, 0.5] # vytvorenie zoznamu "vaha", ktory obsahuje hodnoty vah for res in rozlisenie: # vytvorenie cyklu zabezpecujuceho pohyb po zozname "rozlisenie" for wei in vaha: # vytvorenie cyklu zabezpecujuceho pohyb po poli "vaha" objekt = Spline("C:/arcpy/body.shp", "ELEVATION", res, "REGULARIZED", wei) # vytvorenie vrstvy a ulozenie do podoby objektu objekt.save("C:/arcpy/raster/dtm_%i_%i.tif" %(res, wei*10)) # ulozenie objektu do podoby rastrovej vrstvy Vo svojej podstate ide len o vnorený cyklus, s ktorým sme sa už zoznámili v predošlých kapitolách a využívali sme ho na zapisovanie matíc. V tomto prípade jeden cyklus zabezpečuje pohyb po zozname rozlisenie a druhý cyklus pohyb po zozname vaha. Je nutné zabezpečiť, aby výsledná rastrová vrstva mala v každom cykle vždy originálny názov. V nasledujúcom príklade sa zameráme na vývoj algoritmu, ktorý zo vstupnej vektorovej bodovej vrstvy nadmorskej výšky vygeneruje digitálny výškový model a odvodené polia sklonu georeliéfu, orientácie georeliéfu voči svetovým stranám a normálovej krivosti v smere dotyčnice k spádnici (profile curvature). Postup práce je nasledovný: 1. Interpolácia rastrovej vrstvy z vrstvy bodovej prostredníctvom nástroja Spline. 2. Vytvorenie rastrovej vrstvy sklonu prostredníctvom nástroja Slope. 3. Vytvorenie rastrovej vrstvy orientácie reliéfu voči svetovým stranám prostredníctvom nástroja Aspect. 4. Vytvorenie krivosti georeliéfu v smere dotyčnice k spádnici prostredníctvom nástroja Curvature.
  42. 42. 42 import arcpy from arcpy.sa import * # import kniznice arcpy a modulu Spatial Analyst outSpline = Spline("C:/arcpy/body.shp", "ELEVATION", 2, "REGULARIZED", 0.1) outSpline.save("C:/arcpy/raster/dtm") # interpolacia dtm prostrednictvom algoritmu spline outSlope = Slope("C:/arcpy/raster/dtm", "DEGREE") outSlope.save("C:/arcpy/raster/slope") # vypocet rastrovej vrstvy sklonu georeliefu outAspect = Aspect("C:/arcpy/raster/dtm") outAspect.save("C:/arcpy/raster/aspect") # vypocet rastrovej vrstvy orientacie georeliefu voci svetovym stranam outCurve = Curvature("C:/arcpy/raster/dtm", 1, "C:/arcpy/raster/prof_curv" ) # vypocet rastrovej vrstvy normalovej krivosti voci svetovym stranam Vyššie uvedený algoritmus je lineárny, teda nedochádza k vetveniu alebo opakovaniu niektorých nástrojov s rozličným nastavením vstupných parametrov. Skript využíva najmä nástroje knižnice Spatial Analyst, ktoré len vhodne radí za seba. V prvom kroku vygeneruje digitálny výškový model na základe vstupnej bodovej vrstvy s názvom body.shp. Z digitálneho výškového modelu sa následne generujú polia sklonu, orientácie voči svetovým stranám a pole normálovej krivosti v smere dotyčnice k spádnici. V ďalšom príklade zostavíme algoritmus, ktorý na základe vstupnej bodovej vrstvy vytvorí vektorové vrstvy subpovodí. Následne tento algoritmus upravíme pre niekoľko nastavení váhy interpolačnej funkcie Spline. Postup práce je nasledovný: 1. Interpolácia rastrovej vrstvy z vrstvy bodovej prostredníctvom nástroja Spline. 2. Hydrologická korekcia digitálneho výškového modelu prostredníctvom nástroja Fill. 3. Výpočet smerov odtoku prostredníctvom nástroja Flow direction. 4. Výpočet príspevkových plôch prostredníctvom nástroja Flow accumulation. 5. Reklasifikácia rastrovej vrstvy príspevkových plôch prostredníctvom nástroja Reclassify, na základe čoho je možné zostaviť potenciálnu sieť vodných tokov. Hranicou pre vznik potenciálneho vodného toku bude hodnota príspevkovej plochy nad 1000 buniek. 6. Unikátne pomenovanie segmentov tokov prostredníctvom nástroja Stream Link. 7. Výpočet rastra povodí prostredníctvom nástroja Watershed. 8. Transformácia rastrovej vrstvy povodí na vektorovú vrstvu prostredníctvom nástroja Raster to Polygon. import arcpy from arcpy.sa import * # import kniznice arcpy a modulu Spatial Analyst
  43. 43. 43 outSpline = Spline("C:/arcpy/body.shp", "ELEVATION", 5, "REGULARIZED", 0.1) outSpline.save("C:/arcpy/raster/dtm") # interpolacia dtm prostrednictvom algoritmu spline outFill = Fill("C:/arcpy/raster/dtm") outFill.save("C:/arcpy/raster/dtm_fill") # hydrologicka korekcia vstupneho digitalneho vyskoveho modelu outFlowDirection = FlowDirection("C:/arcpy/raster/dtm_fill", "NORMAL") outFlowDirection.save("C:/arcpy/raster/flow_dir") # vypocet smerov odtoku outFlowAccumulation = FlowAccumulation("C:/arcpy/raster/flow_dir") outFlowAccumulation.save("C:/arcpy/raster/flow_acc") # vypocet rastrovej vrstvy prispevkovych ploch outReclass2 = Reclassify("C:/arcpy/raster/flow_acc", "Value", RemapRange([[0,1000,"NODATA"],[1000,22000,1]])) outReclass2.save("C:/arcpy/raster/fl_acc_rec") # reklasifikacia rastrovej vrstvy prispevkovych ploch outStreamLink = StreamLink("C:/arcpy/raster/fl_acc_rec", "C:/arcpy/raster/flow_dir") outStreamLink.save("C:/arcpy/raster/str_lnk") # unikatne pomenovavanie segmentov vodnych tokov outWatershed = Watershed("C:/arcpy/raster/flow_dir", "C:/arcpy/raster/str_lnk") outWatershed.save("C:/arcpy/raster/basins") # vytvaranie povodi na zaklade rastra smeru odtoku a unikatne pomenovanych segmentov potencialnych vodnych tokov arcpy.RasterToPolygon_conversion("C:/arcpy/raster/basins", "C:/arcpy/basins.shp", "NO_SIMPLIFY", "VALUE") # konverzia rastrovej vrstvy povodi na vektorovu vrstvu povodi Samotný postup práce skriptu je popísaný v niekoľkých publikáciách (e.g. Silhavy, 2010), preto sa mu nebudeme podrobne venovať a zameráme sa najmä na postup tvorby skriptu. Vyššie uvedený algoritmus je lineárny, teda nedochádza k vetveniu alebo opakovaniu niektorých modulov s iným nastavením vstupných parametrov. Skript využíva najmä nástroje modulu Spatial Analyst, ktoré len vhodne radí za seba. V prvom kroku sa generuje digitálny výškový model prostredníctvom algoritmu Spline. Vstupom je vrstva body.shp, ktorá v sebe obsahuje informácie o nadmorskej výške vo vybraných bodoch. V druhom kroku sa tento digitálny výškový model hydrologicky koriguje, teda sa vyplnia bezodtokové depresie, ktoré by mohli podmieniť vznik umelých subpovodí. Následne sa vypočíta rastrová vrstva smeru odtoku, ktorú budeme využívať ako vstup do ďalších nástrojov. V nasledujúcom kroku vypočítame rastrovú vrstvu príspevkových plôch, ktorú následne reklasifikujeme na novú binárnu rastrovú vrstvu. Pre potreby reklasifikácie sme zvolili hranicu 1000 buniek, teda všetky bunky, ktorých príspevková plocha nadobúda hodnotu pod 1000, budú reklasifikované
  44. 44. 44 na hodnotu "NO DATA" a všetky ostatné bunky budú reklasifikované na hodnotu 1. Pre potreby reklasifikácie využívame nástroj Reclassify s nastavením RemapRange, ktorý reklasifikuje intervaly. Výsledkom je rastrová vrstva potenciálnej siete vodných tokov. Každý samostatný segment vodného toku následne unikátne pomenujeme prostredníctvom modulu Stream Link. Samotné povodia vytvoríme prostredníctvom nástroja Watershed, do ktorého vstupuje rastrová vrstva unikátne pomenovaných segmentov toku a rastrová vrstva smeru odtoku. Výsledkom je rastrová vrstva povodí, kde každé povodie nadobúda inú hodnotu. V poslednom kroku prevedieme rastrovú vrstvu povodí na vrstvu vektorovú prostredníctvom nástroja RasterToPolygon. Výsledný algoritmus následne upravíme tak, aby generoval subpovodia pre niekoľko váh interpolačnej interpolácie (konkrétne pre váhy 0.5, 1.1, 1.9), teda lineárny algoritmus zmeníme na cyklický algoritmus. import arcpy from arcpy.sa import * # import kniznice arcpy a modulu Spatial Analyst vaha =[0.5, 1.1, 1.9] # vytvorenie zoznamu vah interpolacnej funkcie for i in vaha: # cyklus pre zmenu vah interpolacie outSpline = Spline("C:/arcpy/body.shp", "ELEVATION", 5, "REGULARIZED", i) outSpline.save("C:/arcpy/raster/dtm") # interpolacia dtm prostrednictvom algoritmu spline outFill = Fill("C:/arcpy/raster/dtm") outFill.save("C:/arcpy/raster/dtm_fill") # hydrologicka korekcia vstupneho digitalneho vyskoveho modelu outFlowDirection = FlowDirection("C:/arcpy/raster/dtm_fill", "NORMAL") outFlowDirection.save("C:/arcpy/raster/flow_dir") # vypocet smerov oddtoku outFlowAccumulation = FlowAccumulation("C:/arcpy/raster/flow_dir") outFlowAccumulation.save("C:/arcpy/raster/flow_acc") # vypocet rastrovej vrstvy prispevkovych ploch plochy outReclass2 = Reclassify("C:/arcpy/raster/flow_acc", "Value",RemapRange([[0,1000,"NODATA"],[1000,22000,1]])) outReclass2.save("C:/arcpy/raster/fl_acc_rec") # reklasifikacia rastrovej vrstvy prispevkovych ploch outStreamLink = StreamLink("C:/arcpy/raster/fl_acc_rec", "C:/arcpy/raster/flow_dir")
  45. 45. 45 outStreamLink.save("C:/arcpy/raster/str_lnk") # unikatne pomenovavanie segmentov vodnych tokov outWatershed = Watershed("C:/arcpy/raster/flow_dir", "C:/arcpy/raster/str_lnk") outWatershed.save("C:/arcpy/raster/basins") # vytvaranie povodi na zaklade rastra smeru odtoku a unikatne pomenovanych segmentov potencialnych vodnych tokov arcpy.RasterToPolygon_conversion("C:/arcpy/raster/basins", "C:/arcpy/basins_%i.shp" %(i*10), "NO_SIMPLIFY", "VALUE") # konverzia rastrovej vrstvy povodi na vektorovu vrstvu povodi V tomto prípade bude dochádzať k prepisovaniu medzivýsledkov a jedine výsledná vektorová vrstva bude niesť vždy unikátny názov. 4.3 Tvorba nástroja v ArcToolbox Doteraz sme sa v tomto texte zameriavali na vytvorenie skriptov vhodných na jednorazové použitie. Všetky vstupné parametre sú teda v týchto skriptoch pevne definované a v prípade, že by sme ich chceli zmeniť, musíme zmeniť zdrojový kód skriptu. Tento fakt si ukážeme na príklade skriptu na výpočet základných morfometrických charakteristík digitálneho výškového modelu. import arcpy from arcpy.sa import * # import kniznice arcpy a modulu Spatial Analyst outSpline = Spline("C:/arcpy/body.shp", "ELEVATION", 2, "REGULARIZED", 0.1) outSpline.save("C:/arcpy/raster/dtm") # interpolacia dtm prostrednictvom algoritmu spline outSlope = Slope("C:/arcpy/raster/dtm", "DEGREE") outSlope.save("C:/arcpy/raster/slope") # vypocet rastrovej vrstvy sklonu georeliefu outAspect = Aspect("C:/arcpy/raster/dtm") outAspect.save("C:/arcpy/raster/aspect") # vypocet rastrovej vrstvy orientacie georeliefu voci svetovym stranam outCurve = Curvature("C:/arcpy/raster/dtm", 1, "C:/arcpy/raster/prof_curv" ) # vypocet rastrovej vrstvy normalovej krivosti voci svetovym stranam Ak chceme meniť názov vstupnej vrstvy, musíme vstúpiť priamo do zdrojového kódu a v štvrtom riadku textu zmeniť hodnotu "C:/arcpy/body.shp" z body.shp na iný názov vstupnej vrstvy. S najväčšou pravdepodobnosťou bude nevyhnutné upraviť aj názov stĺpca, ktorý bude obsahovať informáciu o nadmorskej výške, z "ELEVATION" na iný názov. Celá práca so zostaveným skriptom sa vďaka týmto obmedzeniam stáva ťažkopádna a komplikovaná pre používateľa, ktorý nedisponuje aspoň základnými znalosťami z oblasti tvorby skriptov.
  46. 46. 46 Riešením tohto problému je vytvorenie skriptu na výpočet základných morfometrických charakteristík, ktorý bude disponovať graficky prívetivým a interaktívnym používateľským prostredím, vďaka ktorému bude možné meniť názvy vstupných a výstupných vrstiev. Vytvorenie takéhoto prostredia je v bežnej praxi časovo náročné a vyžaduje si pokročilé znalosti z oblasti programovania. Tento problém je v prostredí ArcGIS vyriešený prostredníctvom skupiny nástrojov na tvorbu grafického rozhrania pre vlastné nástroje, naprogramované v jazyku Python. Vlastné nástroje s grafickým rozhraním sú potom dostupné v prostredí ArcToolbox spolu s ostatnými nástrojmi ArcGIS. Štruktúra prepojenia medzi grafickým rozhraním a nástrojom je znázornená na Obrázku 19. Obrázok 19. Ukážka štruktúry novovytvoreného nástroja prostredníctvom Python skriptu a grafického rozhrania, ktoré je poskytované ArcToolbox-om. Ako vidíme na Obrázku 19, funkčný nástroj ArcToolbox-u, ktorý je vytvorený na základe Python skriptu, sa skladá z dvoch častí. Prvou z nich je samotný skript v jazyku Python. Premenné, ktoré bude možné pri každom spustení nástroja meniť (parametre), sú samostatne označené v zdrojovom kóde (viď nižšie). Druhou časťou je pripravené grafické rozhranie, ktoré je súčasťou ArcToolbox-u. Vo svojej podstate ide o rozhranie, ktoré je známe každému používateľovi ArcGIS. V rámci tohto rozhrania je možné nastaviť hodnoty parametrov, ktoré budú používané pri spúšťaní skriptu. Aj napriek faktu, že ide o zjednodušenie vytvorenia nového komunikačného prostredia, aj toto riešenie má svoje úskalia, na ktoré je potrebné si zvyknúť. Pri zostavovaní nového nástroja do prostredia ArcToolbox je potrebné si uvedomiť najmä fakt, že nástroj bude určený širokému spektru používateľov, ktorí nebudú mať znalosť o jeho funkčnosti. Preto je nevyhnutné zostaviť ho jednoznačne a jednoducho. Funkcionalitu vyššie uvedeného riešenia si ukážeme na jednoduchom príklade skriptu, ktorý na základe vstupného bodového výškového poľa vo formáte ESRI shape vytvorí tri rastrové vrstvy nadmorskej výšky. Vrstvy budú vytvorené prostredníctvom algoritmu IDW s hodnotami exponentu 0.2, 1.2, 1.8. Postup práce bude nasledovný: 1. Vytvorenie skriptu, ktorý bude vykonávať vyššie uvedenú úlohu.

×