Embed Size (px)
Citation preview
UNIVERZA V LJUBLJANI
PEDAGOŠKA FAKULTETA
DARJA PREVC
UČENJE PROGRAMIRANJA V PYTHONU V
OSNOVNI ŠOLI
DIPLOMSKO DELO
LJUBLJANA, 2015
UNIVERZA V LJUBLJANI
PEDAGOŠKA FAKULTETA
MATEMATIKA – RAČUNALNIŠTVO
DARJA PREVC
MENTOR: IZR. PROF. DR. JANEZ DEMŠAR
UČENJE PROGRAMIRANJA V PYTHONU V
OSNOVNI ŠOLI
DIPLOMSKO DELO
LJUBLJANA, 2015
Zahvala
Zahvaljujem se mentorju dr. Janezu Demšarju za strokovno vodenje in pomoč
pri nastajanju diplomskega dela.
Zahvaljujem se tudi družini, prijateljem in fantu, ki so me podpirali in
spodbujali v času študija ter med pisanjem diplomskega dela.
Povzetek
V diplomskem delu se ukvarjamo s sestavljanjem »učnih priprav« in nalog, preko katerih bi
učence učili programirati v Pythonu s pomočjo knjižnice turtle.
V prvem delu smo predstavili problem programiranja v osnovnih šolah, saj le malo vsebin pri
izbirnih predmetih vključuje tudi programiranje. Predstavili smo programski jezik Python in
izpostavili lastnosti, zaradi katerih je primeren za poučevanje. Opisali smo namestitev
Pythona ter predstavili razvojno okolje IDLE, ki bi ga uporabljali za poučevanje programskega
jezika Python. Večji poudarek smo dali predstavitvi knjižnice želva, ki je implementirana v
Pythonu in izhaja iz programskega jezika Logo, ki je bil zasnovan kot jezik za učenje
programiranja. Želvo lahko premikamo in obračamo, pri čemer za seboj vleče črto. Zaradi
tega izrisa si učenci lažje predstavljajo in vidijo, kaj določeni ukazi naredijo.
S pomočjo želve smo želeli predstaviti osnovne koncepte programiranja, kot so pogojni
stavek, zanke in funkcije. Zato smo se v drugem delu osredotočili predvsem na razlago teh
konceptov, ki smo jih uvedli prek nalog, ki jih je potrebno izvesti s pomočjo želve. Besedilo v
tem delu je zapisano v slogu, bližjem učencem, zato so nekateri izrazi poenostavljeni. Naloge
se začnejo z ukazi za premikanje in obračanje, za kar morajo učenci poznati le kote. Nato
preko risanja likov, v katerih se določen del večkrat ponovi, spoznamo zanko oz. ponavljanje.
Nadaljujemo s spremenljivkami in definiranjem novih funkcij (za preprostejšo razlago jih
imenujemo »ukazi«). Da smo lahko sestavili primerne naloge za pogojni stavek in zanko
while, smo predstavili še funkcije za komunikacijo z uporabnikom in knjižnico random, ki
omogoča naključno izbiranje števil. Vsakemu sklopu nalog sledi pomoč oziroma namigi, ki
pomagajo učencem pri reševanju teh nalog, ter tudi rešitve.
Ključne besede: programiranje v osnovnih šolah, programski jezik Python, knjižnica želva,
aktivnosti za učne ure
Abstract
In this thesis, we present a set of lesson plans with tasks for teaching pupils how to program
in Python using the turtle module.
The first part discusses the problem of programming in primary schools: we note that
programming presents only a small and optional fraction of the elective class about
computing. Next we present programming language Python along with characteristics that
make it suitable for teaching. We describe its installation and the development environment
IDLE. Presentation of the turtle module, implemented in Python, which comes from the
Logo programming language that was designed for learning to program, was emphasized.
When being moved and turned, turtle draws a line. This drawing helps the pupils visualize
what certain commands do.
The second part of the thesis focuses on the explanation of basic programming concepts,
such as conditional statements, loops and functions, which we introduce through tasks that
need to be solved by using the turtle. The text in this part is written in a style that is closer
to pupils, therefore we occasionally stray away from the standard terminology, e.g. by
referring to functions as "statements". The first tasks deal with moving and turning the
turtle. Then we introduce repeating a block of statements - a loop -, through tasks for
drawing shapes in which a certain part is repeated multiple times. We continue with
variables and definitions of functions. For preparing suitable tasks about conditional
statements and the while loop, we introduce functions for communication with user and
computation of random numbers. Each set of the tasks is followed by help or tips, which
help the pupils solve these tasks, as well as the solution.
Key words: programming in primary schools, programming language Python, turtle module,
class activities
Vsebina 1 Uvod ................................................................................................................................................ 1
2 Problem programiranja v osnovnih šolah ....................................................................................... 2
3 Programski jezik Python .................................................................................................................. 4
3.1 Python v izobraževanju ........................................................................................................... 5
3.2 Namestitev Pythona ................................................................................................................ 8
3.3 Razvojno okolje IDLE ............................................................................................................... 8
4 Želva .............................................................................................................................................. 11
5 Aktivnosti za učne ure iz Pythona in želve .................................................................................... 15
5.1 Uvod ...................................................................................................................................... 15
5.2 Ponavljanje ............................................................................................................................ 19
5.3 Spremenljivke........................................................................................................................ 24
5.4 Spremenljivke so spremenljive ............................................................................................. 26
5.5 Definiranje novih ukazov ...................................................................................................... 28
5.6 Komunikacija z uporabnikom ................................................................................................ 32
5.7 Pogojni stavek ....................................................................................................................... 33
5.8 Žrebanje ................................................................................................................................ 36
5.9 Zanka s pogojem ................................................................................................................... 39
6 Preizkus nalog ............................................................................................................................... 43
7 Zaključek ....................................................................................................................................... 45
8 Literatura....................................................................................................................................... 46
Kazalo slik
Slika 1: IDLE Python ................................................................................................................................. 9
Slika 2: Ukazno okno ............................................................................................................................... 9
Slika 3: Urejevalno okno ....................................................................................................................... 10
Slika 4: Definiranje želve ....................................................................................................................... 12
Slika 5: Ob pogonu programa je želva vedno na sredi ekrana .............................................................. 16
Slika 6: Želvo smo premaknili naprej za 100 korakov ........................................................................... 16
Slika 7: Želvina pot (prehodi 100 korakov, se obrne za 60 stopinj v desno, prehodi še 50 korakov) ... 17
Slika 8: Želvina pot (obrne se za 60 stopinj v levo in naredi 100 korakov) ........................................... 17
Slika 9: Narišemo hišo ........................................................................................................................... 18
Slika 10: Pot Anice in Frančka ............................................................................................................... 19
Slika 11: Vijuga ...................................................................................................................................... 19
Slika 12: Del vijuge (strešica) ................................................................................................................. 19
Slika 13: Želva, ki je pripravljena za nadaljevanje ................................................................................. 19
Slika 14: Dve strešici .............................................................................................................................. 20
Slika 15: Stopnišče ................................................................................................................................. 22
Slika 16: Kvadratna vijuga ..................................................................................................................... 22
Slika 17: Črtkana črta ............................................................................................................................ 22
Slika 18: Spirala ..................................................................................................................................... 27
Slika 19: Primer s štirimi in petimi kvadrati .......................................................................................... 30
Slika 20: Več kvadratov ......................................................................................................................... 30
Slika 21: Primer, ko uporabnik vpiše število ......................................................................................... 32
Slika 22: Primer, ko uporabnik vpiše besedilo ...................................................................................... 32
Slika 23: Pogojni stavek ......................................................................................................................... 33
Slika 24: Karlina slika ............................................................................................................................. 37
Slika 25: Zanka s pogojem ..................................................................................................................... 39
Slika 26: Učenci rišejo hišo .................................................................................................................... 43
Slika 27: Učenci samostojno rešujejo nalogo iz ponavljanja ................................................................. 44
1
1 Uvod
Dandanašnji otroci so obdani z zelo hitro razvijajočo se tehnologijo, ki jo sicer znajo
uporabljati, ne razumejo pa njenega delovanja. Boljše poznavanje ozadja teh tehnologij bi
jim omogočalo tudi naprednejšo rabo. Poleg tega si želimo vzgojiti tudi prihodnje inženirje,
ki tehnologij ne bodo le uporabljali, temveč tudi razvijali. Zato je potrebno, da se otroci že v
osnovnošolskih letih seznanijo z algoritmičnim razmišljanjem, saj je zmožnost takega
razmišljanja predpogoj za razumevanje sodobnih tehnologij. Algoritmično razmišljanje je
mogoče uriti na abstraktnem nivoju, na konkretnem pa lahko uporabljamo različne naloge,
ki zahtevajo programiranje določenih postopkov.
V diplomskem delu bomo predstavili problem programiranja v osnovnih šolah, saj so le trije
izbirni predmeti iz področja računalništva v tretji triadi, s šolskim letom 2014/15 pa so uvedli
neobvezni izbirni predmet v drugi triadi. Vsebine izbirnih predmetov vključujejo le malo
programiranja, medtem ko se vsebine pri neobveznem predmetu navezujejo na
algoritmično razmišljanje in navajanje učencev na osnovne programske koncepte.
Uporabljajo program Scratch, ki temelji na sestavljanju blokov, ki predstavljajo različne
ukaze, in je s svojo grafično podobo primeren za poučevanje predvsem v prvi in drugi triadi.
Ker pa želimo nekaj podobnega tudi v višjih razredih, a hkrati zmogljivejšega, bi bila za to
primerna želva, ki je implementirana v programski jezik Python kot knjižnica.
V diplomskem delu bomo torej predstavili programski jezik Python, lastnosti, zaradi katerih
je primeren za poučevanje ter razvojno okolje IDLE, ki bi ga uporabili za programiranje v
Pythonu. Večji poudarek bomo dali knjižnici želva, saj je po našem mnenju primerna za
začetno učenje programiranja. Želva namreč predstavlja primeren kontekst za učenje
programiranja, ker so naloge iz risanja za otroke dovolj avtentične, da jih motivirajo.
Obenem dobijo od želve takojšnjo povratno informacijo o tem, ali so nalogo rešili pravilno
ali ne.
Glavni cilj diplomskega dela je sestaviti primerne naloge za spoznavanje osnovnih konceptov
programiranja, kot so zanke, pogojni stavek in funkcije. V okviru diplomskega dela bomo
razmišljali o tem, kako zastaviti pouk programiranja v Pythonu preko aktivnosti z želvo.
Besedilo, ki ga bomo v tem poglavju pisali, bo naslovljeno na učence, poleg tega pa bodo
nekateri izrazi poenostavljeni, da ne bi bilo za učence preveč zahtevno in nerazumljivo. Kot
smo že omenili, bomo predstavili osnovne koncepte programiranja, poleg tega pa še nekaj
drugih stvari, brez katerih ne bi mogli sestaviti dovolj primernih nalog s pomočjo želve, to so
spremenljivke, komunikacija z uporabnikom in knjižnica random, ki naključno izbere neko
število.
2
2 Problem programiranja v osnovnih šolah
V osnovni šoli so le trije izbirni predmeti v tretji triadi iz področja računalništva. Njihove
vsebine zajemajo različna področja računalništva, malo pa je takih, ki vključujejo
programiranje.
Učni sklop Programiranje je v učnem načrtu označen z zvezdico (*), saj spada pod dodatne
vsebine.
V spodnji tabeli je prikazano, kateri operativni cilji, dejavnosti, vsebine so zapisane pod
sklopom Programiranje pri vseh treh izbirnih predmetih.
UREJANJE BESEDIL RAČUNALNIŠKA
OMREŽJA
MULTIMEDIJA
OPERATIVNI
CILJI
Po končanem
izobraževanju
znajo učenke
in učenci:
napisati algoritem,
ki reši preprost
vsakdanji problem;
izdelati in
spremeniti preprost
računalniški
program.
napisati algoritem z
odločitvijo, ki reši
preprost vsakdanji
problem;
izdelati in
spremeniti
računalniški
program z
odločitvijo.
napisati algoritem,
ki reši zahtevnejši,
vendar njim znan in
razumljiv problem;
izdelati in
spremeniti
računalniški
program z zanko in
vejiščem.
DEJAVNOSTI
Učenke in
učenci:
analizirajo preprost
problem;
uporabljajo osnovne
korake
programiranja.
analizirajo preprost
problem;
uporabljajo osnovne
korake
programiranja.
analizirajo
zahtevnejši, vendar
njim znan in
razumljiv problem;
spoznavajo
zahtevnejše korake
pri programiranju.
VSEBINE risanje diagrama za
linearen problem;
izdelava
računalniškega
programa.
risanje diagrama
poteka za problem z
odločitvijo;
izdelava
računalniškega
programa.
risanje diagrama
poteka za problem z
vejiščem in zanko;
izdelava
računalniškega
programa.
PRIPOROČILA zbirno poglavje zbirno poglavje zbirno poglavje
POVEZAVE matematika matematika matematika
(Izbirni predmet Računalništvo, 2002)
3
V učnem načrtu za izbirne predmete računalništva (Urejanje besedil, Računalniška omrežja,
Multimedija) so zapisali, da lahko učenci odvisno od zanimanja in predznanja izdelajo
računalniški program, s katerim rešijo določen problem. Z njim prikažemo učencem
drugačen način uporabe računalnikov, to je z izdelavo lastnih programov. Pri tem jih
seznanimo z osnovnimi zakonitostmi pravilnega reševanja nalog, ki jih lahko rešimo s
pomočjo algoritmov. Učencem prikažemo, kako postopno rešimo problem tako, da ga
razgradimo na posamezne korake, ki nas pripeljejo do rešitve naloge, in kakšno vlogo ima pri
tem računalnik. (Izbirni predmet Računalništvo, 2002)
S šolskim letom 2014/15 se je začel izvajati neobvezni izbirni predmet v drugi triadi.
Neobvezni izbirni predmet seznanja učence z različnimi področji računalništva. Predmet ne
temelji na spoznavanju dela s posameznimi programi, ampak učence seznanja s temeljnimi
računalniškimi koncepti in procesi. Učenci se pri računalništvu seznanjajo s tehnikami in
metodami reševanja problemov in razvijajo algoritmičen način razmišljanja, spoznavajo
omejitve računalnikov in njihov vpliv na družbo. Način dela pri predmetu spodbuja
ustvarjalnost, sodelovanje in poseben način razmišljanja ter delovanja. S spoznavanjem
računalniških konceptov in razvijanjem postopkovnega načina razmišljanja učenci
pridobivajo znanja, spretnosti in veščine, ki so veliko bolj trajni kot hitro razvijajoče se
tehnologije. Ta znanja so neodvisna od tehnologij. (Neobvezni izbirni predmet
Računalništvo, 2013).
Pri tem predmetu uporabljajo program Scratch, ki temelji na principu sestavljanja blokov, ki
predstavljajo dele programa, to je različne ukaze (izpiši, premakni, pokaži...) in kontrolne
strukture (pogoji, zanke...). S svojo grafično podobo in naborom nalog, kakršne lahko
rešujemo z njim, je primeren predvsem za prvo in drugo triado. Za starejšo starostno
skupino je morda primernejši programski jezik Python. Ali to drži in ali je za Python mogoče
sestaviti primerne naloge za poučevanje osnovnih konceptov iz programiranja v osnovnih
šolah, bomo raziskovali v pričujočem diplomskem delu.
4
3 Programski jezik Python
Programski jezik Python je nizozemski programer Guido van Rossum začel razvijati konec
osemdesetih. Prvo javno različico je objavil februarja 1991 (Rossum, 2009). Poimenoval ga je
po znani britanski nadaljevanki Monty Python's Flying Circus in ne po pitonu (kači). (Briggs,
2013)
Guido van Rossum je želel ustvariti programski jezik, ki bi imel naslednje lastnosti:
- je skriptni jezik,
- uporablja zamike,
- uporablja visoko nivojske podatkovne tipe,
- je razširljiv,
- je interpretiran (tolmačeni) jezik.
(Maruch in Maruch, 2006)
»Python je splošnonamenski, objektno orientiran, ukazni, funkcijski in skriptni jezik, ki
poudarja berljivost kode. Osnovna sintaksa je relativno preprosta« (Kononenko, Robnik
Šikonja, Bosnić, 2008), ki se jo je lahko naučiti. Python nima veliko sintaktičnih posebnosti (v
funkciji je dovolj le zamik kode, namesto besed begin in end v Pascalu oziroma zavitih
oklepajev v C-ju). »Python uporablja dinamično tipiziranje in avtomatsko dodeljevanje in
sproščanje pomnilnika. Pogosto se vključuje v različne produkte kot skriptni jezik.«
(Kononenko, Robnik Šikonja, Bosnić, 2008)
Python je visokonivojski programski jezik, ki ga lahko razširjamo in vstavljamo (vključujemo v
aplikacije). Primeren je za projekte, ki zahtevajo hiter razvoj. Podpira več programskih
filozofij, zato je Python dober za programe, ki zahtevajo prilagodljivost. Vsebuje veliko
paketov in modulov, ki omogočajo večnamenskost programskega jezika in ki programerju
prihranijo čas (Maruch in Maruch, 2006).
Python uporabljajo tako individualni uporabniki kot tudi podjetja, ki ga uporabljajo za
komercialne projekte, kot na primer:
- Google,
- YouTube,
- BitTorrent,
- Industrial Light & Magic, Pixar,
- NASA …
(Lutz, 2008)
Tim Peters je v eseju The Zen of Python navedel vodila programskega jezika Python. Našteli
bomo le nekaj izmed njih:
- Lep je bolje kot grd. Beautiful is better than ugly.
5
- Eksplicitno je boljše od implicitnega. Explicit is better than implicit.
- Preprosto je boljše od zahtevnega. Simple is better than complex.
- Zahtevno je boljše od zapletenega. Complex is better than complicated.
- Berljivost je pomembna. Readability counts.
3.1 Python v izobraževanju
Tollervey (2015) je v knjigi Python v izobraževanju predstavil lastnosti, zaradi katerih je
programski jezik Python primeren za poučevanje.
1. Berljivost kode
Kadar želimo napisati seznam stvari, ki jih moramo narediti, zapišemo približno tako:
trgovina
pospravi stanovanje
Če ta seznam še malo razširimo, bi zapisali:
Trgovina:
kruh
mleko
solata
Pospravi stanovanje:
posesaj
pobriši prah
pomij po tleh
Intuitivno vidimo, da je glavno opravilo razbito na več nalog, ki so zamaknjene pod opravilo,
na katerega se nanašajo. Tako hitro vidimo, katere naloge in opravila se povezujejo.
Podobno je tudi pri programskem jeziku Python. Naslednja koda enostavno pove, da
funkcija, ki smo jo poimenovali pozdravi, vpraša uporabnika, kako mu je ime, nato pa izpiše
pozdrav.
def pozdravi():
ime = input('Kako ti je ime?')
print('Živjo, ' + ime)
Tako je videti izpis, ko poženemo program (uporabnikov vnos je v odebeljenem tisku):
Kako ti je ime? Darja
Živjo, Darja.
6
Opazimo, kako so vrstice v funkciji pozdravi zamaknjene kot v seznamu opravil. Poleg tega je
vsak ukaz v svoji vrstici. Kodo lahko enostavno preberemo in tudi razumemo. Zaradi zamikov
je jasno, katere vrstice so med seboj povezane.
V primerjavi z drugimi programskimi jeziki ima Python zelo enostavno sintakso, potrebno je
le zamikati vrstice kode. Python ne uporablja simbolov, kot so zaviti oklepaji ({ }), hash (#),
znaki dolar ($), podpičje (;), zato je kodo v Pythonu lažje napisati, prebrati in razumeti, zaradi
česar je primernejši za učence začetnike.
2. Preprostost
V nekaterih jezikih bomo morali, če želimo ustvariti, na primer, seznam stvari, uporabiti
različno poimenovane konstrukte, kot so arrays, arrayslists, vectors in collections. V Pythonu
pa uporabimo tako imenovan list (seznam), ki ga definiramo z oglatimi oklepaji [] ali list(). Tu
je seznam opravil, ki smo jih napisali prej:
seznam_opravil = ['trgovina', 'pospravi stanovanje']
Ta koda dodeli seznam vrednosti – to so nizi znakov, ki vsebujejo besede, ki opisujejo
opravila v mojem seznamu opravil – objektu z imenom seznam_opravil, na katerega se lahko
potem sklicujemo.
Podobno je z, na primer, slovarji. Za njihovo definicijo bomo morali uporabiti različno
poimenovane konstrukte, kot so hashtables, associative arrays, maps or tables. V Pythonu
ga definiramo z zavitimi oklepaji {} ali dict().
Tu je kot primer slovar držav in njihovih glavnih mest:
glavna_mesta = {'Nemčija' : 'Berlin' , 'Slovenija' : 'Ljubljana' , 'Italija' : 'Rim'}
ter primer razširjenega seznama opravil:
opravila = { 'trgovina' : ['kruh', 'mleko', 'solata'] ,
'stanovanje' : ['posesaj', 'pobriši prah', 'pomij po tleh']
}
Če želimo poiskati glavno mesto določene države, zapišemo v oglatih oklepajih državo poleg
objekta z imenom glavna_mesta:
glavna_mesta['Slovenija']
Dobimo: 'Ljubljana'
7
Ali podobno za opravila:
opravila['stanovanje']
['posesaj', 'pobriši prah', 'pomij po tleh']
Prednost Pythona je torej, da so višjenivojske podatkovne strukture tesno vdelane v jezik. Za
njihovo deklaracijo ni potrebno nalagati različnih knjižnic in za pogoste operacije na njih (kot
je, recimo, indeksiranje slovarjev) uporabljamo preproste operatorje in ne metod.
3. Razširljivost
Programerji velikokrat uporabljajo knjižnice, ki so jim v pomoč, da jim ni potrebno začeti iz
nič ali izumljati česa novega vsakič, ko naletijo na kakšen problem. Ob namestitvi Pythona že
dobimo obsežno zbirko standardnih knjižnic, od osnovnih matematičnih do knjižnic za, na
primer, delo s spletom. Med temi knjižnicami je tudi turtle, ki ga bomo uporabljali v tem
delu. Na uradnem repozitoriju PyPi je mogoče dobiti še skoraj 65 000 dodatnih knjižnic za
različne namene.
Python je odprtokodni projekt, kar pomeni, da lahko vsak sodeluje pri razvoju jezika s
predložitvijo poročila o napakah. Na voljo je tudi razumljiv in preprost postopek, s pomočjo
katerega lahko programerji predlagajo in sprogramirajo nove funkcije jezika.
4. Dostopnost v različnih operacijskih sistemih
Python deluje na več platformah: na operacijskih sistemih Windows, Mac OS X, Linux in na
številnih drugih operacijskih sistemih in napravah. Uporabljamo ga lahko tudi prek spleta,
kot na primer prek strani Python Anywhere.
To je pomembno, saj Python deluje na šolskih računalnikih z različnimi operacijskimi sistemi.
Tako lahko učenci, ki se učijo programski jezik Python, svoje znanje obnovijo tudi doma, ne
glede na to, kakšen računalnik in operacijski sistem imajo. Poleg tega je Python kot storitev
preko spletne strani odlična rešitev za vse tiste učitelje, ki jim šolski administratorji ne
pustijo nalagati ničesar na šolske računalnike. Python pa lahko deluje tudi na napravah, kot
je na primer Raspberry Pi.
8
3.2 Namestitev Pythona
Na spletni strani https://www.python.org/downloads/ je na voljo več različic Pythona.
Za namestitev programskega jezika Python predlagamo najnovejšo verzijo Pythona 3. V
času, ko je nastajalo to diplomsko delo, je to Python 3.4.
Potek namestitve je preprost:
1. Kliknemo Run.
2. Izberemo Install for all users.
3. Ciljno mapo pustimo nespremenjeno. Kliknemo Next.
4. Prilagoditve Pythona ignoriramo in kliknemo Next.
5. Počakamo, da se Python naloži.
3.3 Razvojno okolje IDLE
Z namestitvijo Pythona avtomatsko dobimo program IDLE, integrirano razvojno okolje, ki ga
je ustvaril Guido van Rossum.
IDLE je napisan v Pythonu z uporabo grafičnega orodja Tkinter (Tk/Tcl). Deluje na vseh
operacijskih sistemih Windows, Unix in Mac OS X.
Njegov uporabniški vmesnik je preprost in enostaven. Čeprav je primeren za začetnike, ima
IDLE vse, kar potrebujejo tudi napredni uporabniki za razvoj programov v Pythonu
(http://www.python.org/idle/).
IDLE ima dve vrsti oken, in sicer ukazno okno in urejevalno okno. Ukazno okno ali
interaktivni interpreter ima v zadnji vrstici vedno >>>, kar pomeni, da je IDLE pripravljen in
čaka na vnos ukaza.
IDLE omogoča, kot tudi druga okolja, barvno poudarjanje sintakse (v obeh oknih),
samodokončanje napisanih korenov besed, avtomatsko zamikanje kode (na primer v
funkcijah, zankah …).
Če želimo odpreti IDLE, kliknemo Start, nato Vsi programi ter poiščemo mapo Python in
izberemo IDLE (Slika 1).
9
Slika 1: IDLE Python
Odpre se ukazno okno (Slika 2).
Slika 2: Ukazno okno
10
Če želimo urejevalno okno (Slika 3), izberemo File ter New File.
Slika 3: Urejevalno okno
V tem oknu pišemo kodo, jo urejamo. Ko želimo program pognati, kliknemo na Run ter Run
Module ali pritisnemo F5.
11
4 Želva
Prvi roboti želve so bili radijsko kontrolirani roboti, ki so imeli svinčnik, zvonec, senzorje na
dotik in so se lahko premikali naprej, obračali v levo in desno, dvigovali in spuščali svinčnik …
Leta 1966 sta Seymour Papert in Wally Feurzeig ustvarila Logo, enostaven programski jezik,
ki je bil namenjen predvsem za učenje programiranja. Logo se je uporabljal sprva za
programiranje robotov želv. Kasneje se je razvil v programski jezik, ki je omogočal risanje po
računalniškem ekranu s pomočjo želve, ki se je obnašala podobno kot robot želva (Mount,
Shuttleworth, Winder, 2008).
Logo omogoča otrokom, da nadzirajo gibanje želve z ukazi premikanja (forward) in
obračanja (turn ali right/left). Ti ukazi so koristni za otrokovo uvajanje v geometrijo in
razumevanje le-te z uporabo svinčnika za risanje oblik po zaslonu ali pa na tleh z uporabo
želve robota. Ideja je bila, da otroci preizkušajo želvo, z njo rišejo ter tako sami odkrijejo,
kako narisati trikotnik, kvadrat, mnogokotnik in različne druge oblike. Ta ideja temelji na
konstruktivističnem učenju (Papert je bil nekaj časa namreč sodelavec Jeana Piageta), pri
čemer se otrok uči preko eksperimentiranja in opazovanja. V tem primeru se otrok nauči
načel geometrije z igranjem z želvo, s pomočjo katere riše različne geometrijske oblike.
Otroci si želvo predstavljajo kot pravo želvo, ki hodi naprej za določeno razdaljo in se obrača
za določen kot. Otroci se lahko tudi vživijo v želvo in preden zapišejo ukaze, jih lahko
poskusijo s hojo po prostoru. Tako si lažje predstavljajo, kaj v resnici naredijo zapisani ukazi.
Želva kot animiran objekt izvede napisane ukaze in tako lahko učenci preko slike vidijo, ali je
narisana slika res tisto, kar so želeli narisati. Ker je izpis grafičen, otroci takoj vidijo napake.
Želva ne uporablja kartezičnega koordinatnega sistema, s čimer se izognemo potrebi po
trigonometriji. Na ta način je risanje, na primer, mnogokotnika veliko preprostejše, kot če bi
morali računati koordinate oglišč (http://scratch.redware.com/content/history-scratch,
http://scratch.redware.com/lessonplan/turtlegraphics).
Iz Loga se je kasneje razvil StarLogo, ki je temeljil na uporabi blokov, ki so predstavljali
sestavne dele programa in je omogočal lažje učenje, saj se ni bilo potrebno ukvarjati s
tipkarskimi in sintaktičnimi napakami (http://scratch.redware.com/content/history-scratch).
Naslednik Loga pa je tudi Scratch (http://scratch.mit.edu), izobraževalni programski jezik, ki
ga je razvil Mitchel Resnick (bil je Papertov učenec) s sodelavci na MIT (Massachusetts
Institute of Technology - Tehnološki inštitut v Massachusettsu) v sklopu Lifelong
Kindergarten Group (http://wiki.scratch.mit.edu/wiki/Scratch).
Scratch temelji na idejah in konceptih programskega jezika Logo, le da namesto zapisanih
ukazov uporablja bloke. Otroci vlečejo bloke iz palete blokov in jih povežejo z drugimi bloki,
kot sestavljanko. Tak način programiranja se imenuje povleci-in-spusti (drag-and-drop).
12
Scratch je primeren za otroke od osmega leta starosti naprej. Zasnovan je tako, da je
programiranje z njim zabavno, izobraževalno in se ga je enostavno naučiti. Z njim lahko
izdelamo interaktivne zgodbe, animacije, igre …
Ker je Scratch grafičen in privlačen za otroke, je primeren za poučevanje v nižjih razredih
osnovne šole. V višjih razredih pa si nekateri otroci zaželijo »pravega programiranja«. Da bi
preprosteje premostili razliko med Scratchem in podobnimi programi ter programiranjem,
lahko programiranje uvajamo prek uporabe želve v Pythonu. Naloge, ki jih rešujemo, so
lahko podobne nekaterim nalogam iz Scratcha (predvsem nalogam iz risanja) oziroma iz
Loga. Jezik, ki ga uporabljamo, pa je običajen programski jezik z lastnostmi, primernimi za
učenje programiranja.
Ker ima Python že vgrajen modul želva, je potrebno za njegovo uporabo napisati le from turtle import *
Želvi bomo dali ime, na primer francek. Zato zapišemo: francek = Turtle()
Ko poženemo program, se pokaže tako okno (Slika 4):
Slika 4: Definiranje želve
Puščica na sredi okna predstavlja želvo, ki smo jo poimenovali francek. V začetku se želva
nahaja vedno na sredini okna, obrnjena v desno.
13
Modul želva ima na voljo veliko metod za premikanje, uporabo svinčnika, stanje želve …
Našteli jih bomo le nekaj (povzeto po https://docs.python.org/3.6/library/turtle.html):
1. Premikanje
naprej forward(razdalja) francek.forward(100)
nazaj backward(razdalja) francek.backward(50)
levo left(kot) francek.left(45)
desno right(kot) francek.right(90)
krog circle(polmer) francek.circle(20)
pika dot(premer) francek.dot(80, 'green')
hitrost speed(hitrost) če želimo najhitrejšo želvo, uporabimo
francek.speed(0)
2. Uporaba svinčnika:
svinčnik spuščen pendown() francek.pendown()
svinčnik dvignjen penup() francek.penup()
širina svinčnika pensize(širina) francek.pensize(15)
barva svinčnika pencolor(barva) francek.pencolor('red')
svinčnik spuščen pendown() francek.pendown()
svinčnik dvignjen penup() francek.penup()
Primer: from turtle import *
francek = Turtle()
francek.forward(50)
francek.pensize(10)
francek.forward(50)
francek.penup()
francek.forward(100)
francek.pendown()
francek.pencolor('red')
francek.forward(50)
3. Stanje želve:
skrij želvo hideturtle() francek.hideturtle()
pokaži želvo showturtle() francek.showturtle()
barva želve color(barva) francek.color('green')
velikost želve turtlesize(velikost) francek.turtlesize(10)
1. 2. 3. 4.
1.
2.
3.
4.
14
pusti odtis stamp() francek.stamp()
oblika želve shape(oblika) francek.shape('turtle')
Modul želva ima več različnih oblik: arrow, turtle, circle, square, triangle, classic
15
5 Aktivnosti za učne ure iz Pythona in želve
V tem poglavju bomo predstavili, na kakšen način bi učence učili programiranja v Pythonu s
pomočjo želve. Menimo, da Python še ni primeren za drugo triado (za njih je primernejši
Scratch), zato smo se odločili, da se bomo osredotočili na učence v začetku tretje triade,
torej 7. in 8. razred. Besedilo bomo napisali na način, ki naslavlja učence (čeprav v tej obliki
še ni neposredno uporaben zanje), zato bomo občasno uporabljali nekoliko poenostavljene
izraze. Tako bomo namesto o funkcijah govorili kar o ukazih; ti tudi ne bodo »vračali
rezultatov«, temveč bodo »dali rezultat«. Prav tako bomo namesto o nizih govorili o
besedilu. Menimo namreč, da je takšen besednjak učencem bližji.
V nadaljevanju bomo spoznali osnovne koncepte programiranja z želvo in nato nadaljevali s
spoznavanjem zanke for, funkcij, pogojnega stavka ter zanke while. Vsi ti koncepti bodo
uvedeni skozi naloge, ki bodo temeljile na uporabi želve. Menimo, da bi učenci preko
grafičnega prikaza spoznali in razumeli zanki, pogojni stavek ter funkcije lažje kot s klasičnimi
programskimi nalogami za začetnike, ki navadno zahtevajo različne matematične izračune ali
delo s seznami.
5.1 Uvod
Da lahko uporabimo želvo, moramo na začetek vedno napisati from turtle import *
Želvo bomo poimenovali, in sicer ji bomo dali ime francek (kot iz risanke Franček). Zato
zapišemo: francek = Turtle()
Ti dve vrstici morata biti vedno zapisani na začetku vsakega programa.
Ko poženemo vrstici from turtle import *
francek = Turtle()
se nam pokaže okno (Slika 5):
16
Slika 5: Ob pogonu programa je želva vedno na sredi ekrana
Tako smo ustvarili želvo z imenom francek. Franček bo ob zagonu vedno stal v sredini
okna, obrnjen v desno. Želva je po navadi na ekranu prikazana kot majhna puščica, trikotnik
ali želva. Želva ima »pritrjen« svinčnik, da lahko za sabo vleče sled.
Našo želvo francek lahko premikamo z ukazom forward(). V oklepaj zapišemo razdaljo,
za katero naj se premakne. Zapisati moramo francek.forward(100), kar pomeni, da
smo želvi francek (ki smo jo že prej ustvarili z ukazom francek = Turtle()), ukazali,
naj se premakne naprej za določeno razdaljo – v našem primeru za 100 (Slika 6). Ne
spreglejte, da je med besedama »francek« in »forward« pika.
Slika 6: Želvo smo premaknili naprej za 100 korakov
Želvo lahko obrnemo v levo ali desno. Pri tem uporabimo ukaza left() za levo ali right()
za desno. V oklepaj zapišemo, za koliko stopinj naj se obrne.
Ukaz francek.left(90) pomeni, da se bo želva obrnila v levo za 90 stopinj.
17
Napišimo program, kjer se bo želva premaknila za 100, se obrnila v desno za 60 stopinj in se
nato premaknila še za 50 korakov (Slika 7).
from turtle import * francek = Turtle() francek.forward(100) se premakne za 100 francek.right(60) se obrne za 60 stopinj v desno francek.forward(50) gre naprej še za 50
Slika 7: Želvina pot (prehodi 100 korakov, se obrne za 60 stopinj v desno, prehodi še 50 korakov)
Zdaj pa napišimo program, kjer naj se želva najprej obrne v levo za 60 stopinj, nato pa se
premakne za 100 (Slika 8).
francek.left(60)
francek.forward(100)
Slika 8: Želvina pot (obrne se za 60 stopinj v levo in naredi 100 korakov)
18
Da dobimo občutek za risanje z želvo, narišimo hišo, kot prikazuje slika 9.
Slika 9: Narišemo hišo
Stranici strehe sta stranici enakostraničnega trikotnika. Vemo, da so vsi notranji koti v
enakostraničnem trikotniku skladni in merijo 60 stopinj. Premisliti moramo, za koliko stopinj
se mora obrniti želva, ko naredi kot med steno in streho ter na vrhu stene.
francek.forward(100)
francek.left(90)
francek.forward(100)
francek.left(30)
francek.forward(100)
francek.left(120)
francek.forward(100)
francek.left(30)
francek.forward(100)
Ni nujno, da je želvi vedno ime francek. Lahko si izberemo poljubno ime ali pa imamo
naenkrat celo več želv. Poglejmo si primer, ko imamo dve želvi, Frančka in Anico. Franček se
bo premaknil naprej za 100 korakov, se obrnil v desno za 45 stopinj in se premaknil za 50
korakov. Anica pa se bo najprej obrnila za 100 stopinj v levo in nato naredila 200 korakov
(Slika 10).
francek = Turtle() ustvarimo želvo francek anica = Turtle() ustvarimo želvo anica francek.forward(100) Franček se premakne naprej za 100 francek.right(45) Franček se obrne za 45 stopinj v desno francek.forward(50) Franček se premakne za 50 anica.left(100) Anica se obrne v levo za 100 stopinj anica.forward(200) Anica se premakne naprej za 200
19
Slika 10: Pot Anice in Frančka
5.2 Ponavljanje
Narisali bomo vijugo, ki je prikazana na sliki 11.
Slika 11: Vijuga
To bomo storili postopoma. Najprej narišimo del vijuge, ki je označen v rdečem okvirju.
Želva se mora najprej obrniti za 45 stopinj v levo, nato se premakne naprej za 20 korakov,
obrne za 90 stopinj v desno ter ponovno naredi 20 korakov (Slika 12). francek.left(45)
francek.forward(20)
francek.right(90)
francek.forward(20)
Slika 12: Del vijuge (strešica)
Kaj pa, če želimo narisati dve taki strešici? Kot prikazuje slika 12, je želva obrnjena navzdol.
Zato se mora najprej obrniti v levo za 90 stopinj, da bomo lahko nadaljevali in narisali še eno
strešico. Dodamo ukaz francek.left(90)
Slika 13: Želva, ki je pripravljena za nadaljevanje
Anica
Franček
20
Sedaj, ko je želva prav obrnjena (Slika 13), se mora premakniti za 20 korakov, se obrniti v
desno za 90 stopinj ter ponovno narediti 20 korakov. Prejšnjim vrsticam dodamo naslednje
vrstice: francek.forward(20)
francek.right(90)
francek.forward(20)
francek.left(90)
Celoten program za dve strešici (Slika 14): francek.left(45)
francek.forward(20)
francek.right(90)
francek.forward(20)
francek.left(90)
francek.forward(20)
francek.right(90)
francek.forward(20)
francek.left(90)
Slika 14: Dve strešici
Narišimo sedaj tri strešice. Ponovno mora želva narediti 20 korakov, se obrniti v desno za 90
stopinj in se premakniti za 20 korakov. Ampak, ali nismo teh ukazov že napisali? Poglejmo si
program:
francek.left(45)
francek.forward(20)
francek.right(90)
francek.forward(20)
francek.left(90)
francek.forward(20)
francek.right(90)
francek.forward(20)
francek.left(90)
francek.forward(20)
francek.right(90)
francek.forward(20)
francek.left(90)
Kaj opazimo? Da se nekateri deli programa ponavljajo; in sicer ukazi
francek.forward(20), francek.right(90), francek.forward(20) in
francek.letf(90). Kolikokrat? Ponovijo se trikrat, tolikokrat, koliko strešic smo želeli
narisati.
21
Program lahko skrajšamo tako, da zahtevamo od Pythona, da nekaj vrstic večkrat ponovi.
V našem primeru želimo trikrat ponoviti ukaze francek.forward(20),
francek.right(90), francek.forward(20) in francek.letf(90). To storimo
takole:
francek.left(45)
for i in range(3):
francek.forward(20)
francek.right(90)
francek.forward(20)
francek.left(90)
Kaj pomeni for i in range(3)? Pomeni "trikrat ponovi", ponovil pa bo stvari, ki smo jih
lepo umaknjene pisali znotraj za vrstico, ki zahteva ponavljanje. Paziti moramo na nekaj
podrobnosti zamikanja: vse, kar se ponavlja, mora biti enako zamaknjeno – najboljše, da za
štiri presledke.
Ker ukaz francek.letf(45) uporabimo samo enkrat, ga ne vključimo v zanko for.
Temu, kar smo pravkar sestavili, rečemo zanka for. Uporabna je še za marsikaj drugega.
Zakaj pišemo besede »for i in range« namesto kakega preprostega »repeat«, bomo spoznali
kasneje.
Opazimo, da je koda z zanko for krajša. V tem primeru razlika sicer ni tako velika, saj imamo
samo tri strešice. Kaj pa, če bi želeli narisati vijugo z desetimi strešicami? Potem bi morali
ukaze francek.forward(20), francek.right(90), francek.forward(20) in
francek.letf(90) zapisati desetkrat. Tako bi dobili program, dolg 41 vrstic, če ne
štejemo ukazov from turtle import * in francek = Turtle(). V tem primeru bi bil
program z zanko for vidno krajši.
francek.left(45)
for i in range(10):
francek.forward(20)
francek.right(90)
francek.forward(20)
francek.left(90)
V oklepaju v vrstici for i in range() je lahko katerakoli številka, odvisno od tega,
kolikokrat želimo, da se zanka for ponovi. Ko smo želeli tri strešice, smo zapisali range(3), ko
smo jih želeli deset, smo zapisali range(10).
Dolžina programa je, kot vidimo, neodvisna od tega, koliko strešic narišemo.
22
Naloge:
1. Nariši stopnišče, v katerem naj bo 8 stopnic (Slika 15). Uporabi zanko for.
Slika 15: Stopnišče
2. Nariši vijugo, kot prikazuje slika 16. Uporabi zanko for.
Slika 16: Kvadratna vijuga
3. Nariši prekinjeno črto, kot je prikazana na sliki 17. Pri tej nalogi boš potreboval ukaza
francek.penup(), da bo želva dvignila svinčnik (tako za sabo ne bo puščala sledi) ter
francek.pendown(), da bo ponovno spustila svinčnik.
Slika 17: Črtkana črta
4. S pomočjo zanke for nariši kvadrat s stranico 100. Nato nariši še pravokotnik s
stranicama 100 in 50.
5. Nariši pet- in šest-kotnik. Pri tem uporabi zanko for.
Pomoč:
1. Najprej nariši samo eno stopnico. Nato te vrstice vključi v zanko for. Je naloga
kaj podobna primeru iz opisa zanke?
2. Razmisli o vzorcu, ki se ponavlja pri vijugi. Najprej nariši samo ta del. Podobno nalogo
smo rešili na začetku snovi o ponavljanju.
3. Razmisli o vzorcu, ki se ponavlja.
4. Najprej napiši programa brez zanke, da boš videl, kateri ukazi se ponavljajo. Tako boš
videl razliko pri zanki for med kvadratom in pravokotnikom.
5. Razmisli, kakšen kot moraš podati. Pri štirikotniku se bo želva štirikrat obrnila in na
koncu bo obrnjena v isto smer, kot je bila v začetku. Za koliko stopinj se obrneš, če se
zavrtiš za poln krog? Če se za poln krog zavrtiš v štirih korakih, za koliko se zavrtiš v
vsakem? Kaj pa, kadar rišemo šestkotnik? Za koliko se obrneš v vsakem od šestih
korakov?
23
Rešitve:
1.
Ena stopnica: francek.left(90)
francek.forward(20)
francek.right(90)
francek.forward(20)
Stopnišče: for i in range(8):
francek.left(90)
francek.forward(20)
francek.right(90)
francek.forward(20)
2.
Del vzorca, ki se ponavlja: francek.forward(10)
francek.left(90)
francek.forward(10)
francek.right(90)
francek.forward(10)
francek.right(90)
francek.forward(10)
francek.left(90)
Vijuga: for i in range(10):
francek.forward(10)
francek.left(90)
francek.forward(10)
francek.right(90)
francek.forward(10)
francek.right(90)
francek.forward(10)
francek.left(90)
3. for i in range(8):
francek.forward(10)
francek.penup()
francek.forward(10)
francek.pendown()
4.
Kvadrat brez zanke for: francek.forward(100)
francek.left(90)
francek.forward(100)
francek.left(90)
francek.forward(100)
francek.left(90)
francek.forward(100)
francek.left(90)
Kvadrat z zanko for: for i in range(4):
francek.forward(100)
francek.left(90)
Pravokotnik brez zanke for: francek.forward(100)
francek.left(90)
francek.forward(50)
francek.left(90)
francek.forward(100)
francek.left(90)
francek.forward(50)
francek.left(90)
Pravokotnik z zanko for: for i in range(2):
francek.forward(100)
francek.left(90)
francek.forward(50)
francek.left(90)
24
5.
Kot za 5 – kotnik: 360/5 = 72
Kot za 6 – kotnik: 360/6 = 60
5 – kotnik:
for i in range(5):
francek.forward(100)
francek.left(72)
6 – kotnik: for i in range(6):
francek.forward(100)
francek.left(60)
5.3 Spremenljivke
Kadar želimo shraniti neko vrednost (na primer število, besedo …), uporabimo
spremenljivke. Za spremenljivke smo že slišali pri matematiki pri izrazih s spremenljivkami in
pri enačbah. Podobno je tudi pri programiranju. Zapišemo lahko
velikost = 35
S tem smo zapisali, da je velikost enaka 35. Kjerkoli bomo poslej uporabili ime
velikost, bo to isto, kot če bi pisali 35. Če bomo, na primer, napisali
francek.forward(velikost), bo šla želva naprej za 35, in če bomo napisali
francek.left(velikost), se bo obrnila za 35 stopinj levo.
velikost-i rečemo, tako kot v matematiki, spremenljivka. Enačaj (=) ima drugačno vlogo
kot pri matematiki, saj pomeni shranjevanje: Python bo tisto, kar je desno od enačaja,
shranil v spremenljivko, katere ime smo napisali na levi.
Poglejmo si primer, ki ga poznamo iz matematike:
x = 4
y = x + 3
Koliko je y? y je 4 + 3, torej 7.
Podobno je tudi pri programiranju. Ukaz print(), ki ga bomo sedaj uporabili, izpiše tisto,
kar je zapisano v oklepaju. Če torej zapišemo v IDLE:
x = 4
y = x + 3
print(y)
25
se bo izpisala vrednost, ki smo jo shranili v spremenljivko y, torej 7.
Kaj pa, če imamo
x = 5
x = x + 1
Vrstica x = x +1 ne predstavlja enačbe, kot jo poznamo pri matematiki, kjer x nikakor ne
bi mogel biti isto kot x + 1. Ko Python vidi to vrstico, izračuna, kar piše na levi; x + 1 je isto
kot 5 + 1, torej 6. Izračunano vrednost shrani (nazaj) v x. Vrstica x = x + 1 v resnici
pomeni, da vrednost v spremenljivki x povečamo za 1.
V spremenljivko lahko shranimo tudi besedila.
ime = 'Petra'
V spremenljivko z imenom ime smo shranili besedilo 'Petra'. Besedila označujemo z
enojnim (') narekovajem. Če bi pisali le ime = Petra, bi Python mislil, da želimo v
spremenljivko ime shraniti vrednost spremenljivke Petra. To bi delovalo le, če bi le-ta
obstajala
Petra = 18
ime = Petra
Naloge:
1. Napiši program, ki bo narisal 5 stopnic, pri čemer naj bo globina stopnice 30 »korakov«,
višina stopnice pa 10.
2. Program iz prejšnje naloge spremeni tako, da bo narisal 8 stopnic, globina stopnice bo
10 »korakov«, višina stopnic pa se bo večala za 2 – vsaka stopnica naj bo za 2 večja od
prejšnje.
Pomoč:
1. Naloga je podobna 1. nalogi iz poglavja o ponavljanju (5.2).
2. Namesto, da bi višino podal s številko, jo podaj s spremenljivko. To spremenljivko med
risanjem stopnic ob vsaki ponovitvi povečaj.
26
Rešitve:
1. visina = 10
globina = 30
n = 5
for i in range(n):
francek.left(90)
francek.forward(visina)
francek.right(90)
francek.forward(globina)
2. visina = 5
globina = 10
n = 8
for i in range(n):
francek.left(90)
visina = visina + 2
francek.forward(visina)
francek.right(90)
francek.forward(globina)
5.4 Spremenljivke so spremenljive
Zdaj, ko smo naredili kar nekaj nalog z zanko for, se osredotočimo na pomen vrstice for i
in range(). Vemo že, kaj pomeni številka v oklepaju pri range(), to je, kolikokrat naj se
zanka for ponovi. Kaj pa i? i v zanki for je spremenljivka, ki se v resnici spreminja. Ob prvi
ponovitvi zanke ima vrednost 0, ob drugi 1, nato 2 in tako naprej. Kar poglejmo:
for i in range(5):
print(i)
0
1
2
3
4
Program izpiše 5 števil, od 0 do 4, ravno toliko, kot je številka v oklepaju pri range(). Če bi
zapisali zanko for z range(8), bi zgornja koda izpisala števila od 0 do 7.
27
Naloge:
1. Nariši spiralo, pri čemer naj bodo dolžine stranic enake 1, 2, 3, 4 (Slika 18). Ne uporabljaj
zank; tvoj program bo dolg 7 vrstic. (Slika bo v resnici zelo majhna, tako da jo boš komaj
videl. To naj te ne moti.)
Slika 18: Spirala
2. Zapiši zanko for, ki bo izpisala števila od 0 do 3.
3. Z zanko for nariši spiralo, ki bo imela dolžine stranic enake 0, 1, 2, 3.
4. Spirala, ki ima le štiri stranice, ni preveč resna spirala. Nariši takšno s 100 stranicami.
5. Zdaj si risal kvadratno spiralo. Sedaj pa nariši spiralo iz 5- in 6-kotnika. Uporabi program
iz prejšnje naloge. Razmisli, za kakšen kot se mora želva obrniti.
Pomoč:
1. To je podobno kot kvadrat, le z različno dolgimi stranicami.
2. Če si pozabil kako, poglej besedilo.
3. Združi rešitev 1. in 2. naloge. Če pogledaš prvo, boš videl, da nekaj ponavljaš, le da je
neka številka v vsaki ponovitvi drugačna. To, kar ponavljaš, zapri v zanko, številko, ki se
spreminja, pa naračunaj iz i-ja.
4. Kako smo spremenili število vijug, ko smo se učili o zankah? Tudi tule je podobno; če
hočeš, da program nariše spiralo s sto stranicami, je potrebno le malenkost spremeniti
program, ki riše takšno s štirimi. Da bo slika bolj razločna, pomnoži spremenljivko v
ukazu forward() s poljubnim številom (presodi sam).
5. Spomni se 5. naloge iz poglavja 5.2 (Ponavljanje).
Rešitve:
1. francek.forward(1)
francek.left(90)
francek.forward(2)
francek.left(90)
francek.forward(3)
francek.left(90)
francek.forward(4)
28
2. for i in range(4):
print(i)
3. for i in range(4):
francek.forward(i)
francek.left(90)
4. for i in range(100):
francek.forward(i*2)
francek.left(90)
5.
Spirala iz 5-kotnika: for i in range(100):
francek.forward(i*2)
francek.right(360/5)
Spirala iz 6-kotnika: for i in range(100):
francek.forward(i*2)
francek.right(360/6)
5.5 Definiranje novih ukazov
V eni od prejšnjih lekcij smo risali kvadrate. Ne bi bilo imenitno, če bi imeli kar ukaz kvadrat,
ki bi narisal, recimo, kvadrat s stranico 100?
Ni ga. A česar ni, se pa naredi. Da, v Pythonu si lahko izmišljamo tudi nove ukaze.
Nov ukaz v Pythonu definiramo z def in pripišemo ime ukaza, ki ga bomo definirali. Temu
morata vedno slediti oklepaj in zaklepaj (čemu služita, bomo še videli). Sledi dvopičje. Nato
napišemo vrstice, ki jih mora Python izvesti, ko pokličemo ta ukaz.
def kvadrat():
for i in range(4):
francek.forward(100)
francek.left(90)
Vrstice, ki smo jih tule zaprli v okvir, so natančno takšne, kot bi jih uporabili za risanje
kvadrata. Vse, kar je del ukaza, mora biti znotraj njega, zato so vrstice zamaknjene. Ker sta
ukaza forward in left znotraj zanke, ki je znotraj novega ukaza kvadrat(), sta
zamaknjeni dvakrat.
Ko želimo torej izrisati kvadrat, uporabimo naš novi ukaz:
kvadrat()
29
Doslej smo pri ukazih v oklepaju napisali, recimo, za koliko naj se želva premakne ali obrne.
Tu ne potrebujemo ničesar takega, zato pustimo oklepaj prazen. Izpustiti pa ga ne smemo.
Pa bomo vedno risali le kvadrate s stranico 100? Kaj pa, če želimo kvadrat s stranico 50?
Uporabimo spremenljivko, zapišimo:
def kvadrat():
for i in range(4):
francek.forward(dolzina)
francek.left(90)
Tole (še) ne dela: Python ne ve, kaj je dolzina, saj spremenljivke s tem imenom nimamo.
Dodati moramo še nekaj: def kvadrat() bomo spremenili v def kvadrat(dolzina).
def kvadrat(dolzina):
for i in range(4):
francek.forward(dolzina)
francek.left(90)
Sedaj lahko svojemu ukazu dolzina v oklepaju podamo dolžino, zapišemo kvadrat(50).
Ko Python vidi ta ukaz, na hitro naredi spremenljivko z imenom dolzina (ker smo to ime
napisali v vrstici def kvadrat) in ji da vrednost iz oklepaja (50). Kjerkoli znotraj ukaza
uporabljamo ime dolzina, bo to isto, kot če bi napisali 50.
Ko torej kličemo ukaz kvadrat, v oklepaj zapišemo dolžino stranice, torej neko številko. Na
primer:
kvadrat(20) izriše kvadrat s stranico dolžine 20
kvadrat(100) izriše kvadrat s stranico dolžine 100
kvadrat(30) izriše kvadrat s stranico dolžine 30
Če bi bilo ukazu potrebno podati več številk, imena v vrstici "def" ločimo z vejico.
Naloge:
1. Sestavi ukaz za izris 6-kotnika.
2. Nariši sliki, ki sta prikazani na sliki 19. Uporabi ukaz za izris kvadrata.
30
Slika 19: Primer s štirimi in petimi kvadrati
3. Sedaj pa 90-krat nariši kvadrat, pri čemer po vsaki ponovitvi obrneš želvo za 4 stopinje.
4. Napiši ukaz, ki bo izrisal mnogokotnik z določeno stranico in določenim številom kotov.
5. Nariši tako sliko, kot je prikazana na sliki 20. Stranice merijo 0, 2, 4, 6, 8, … Uporabi ukaz
kvadrat(dolzina), ki ga uporabiš v primerno sestavljeni zanki.
Slika 20: Več kvadratov
6. Uporabi program iz prejšnje naloge. Ob vsaki ponovitvi zanke for želvo obrni za 6
stopinj.
Pomoč:
1. Ukaz je podoben ukazu, ki smo ga napisali za kvadrat. Razmisliti moraš le o kotu in
število ponovitev.
2. Kaj ponavljaš? Risanje in obračanje, risanje in obračanje, risanje in obračanje...
4. V oklepaju pri definiranju novega ukaza morata biti dve spremenljivki (dolzina in n).
5. Najprej napiši zanko for, ki bo izpisala zaporedje števil 0, 2, 4, 6, 8, 10, … Spomni se, da
smo v zanki nekoč uporabljali števila od 1 do 5 tako, da smo k i-ju, ki se je spreminjal od
0 do 4, prišteli 1. Kaj pa moramo narediti z njim, da bo šel prek vseh sodih števil? Ko boš
odkril to, bo risanje kvadratov mala malica.
6. To je podobno kot prejšnja naloga, le še obračanje moraš dodati. To pa ne bo težko.
Rešitve:
1. def sest_kotnik():
for i in range(6):
francek.forward(100)
francek.right(360/6)
sest_kotnik()
31
2. def kvadrat(dolzina):
for i in range(4):
francek.forward(dolzina)
francek.right(90)
Prva slika: for i in range(4):
kvadrat(100)
francek.right(360/4)
Druga slika: for i in range(54):
kvadrat(100)
francek.right(360/5)
3. def kvadrat(dolzina):
for i in range(4):
francek.forward(dolzina)
francek.right(90)
for i in range(90):
kvadrat(100)
francek.right(4)
4. def mnogokotnik(dolzina, n):
for i in range(n):
francek.forward(dolzina)
francek.left(360/n)
for j in range(60):
mnogokotnik(5,90)
francek.left(6)
5. def kvadrat(dolzina):
for i in range(4):
francek.forward(dolzina)
francek.left(90)
for i in range(10):
kvadrat(i*2)
6. def kvadrat(dolzina):
for i in range(4):
francek.forward(dolzina)
francek.left(90)
for i in range(100):
kvadrat(i*2)
francek.right(6)
32
5.6 Komunikacija z uporabnikom
Nekatere od nalog, ki jih bomo reševali kasneje, bodo zahtevale, da uporabnika kaj
vprašamo.
- Če želimo, da uporabnik vpiše število, uporabimo ukaz
numinput(naslov,vprašanje).
Ukaz numinput() v oklepaju zahteva dve besedili, in sicer naslov okvirčka, ki se pojavi,
in vprašanje, ki ga zastavimo uporabniku (Slika 21). Ko uporabnik odgovori na vprašanje,
moramo njegov vnos shraniti v neko spremenljivko, da ga bomo lahko kasneje uporabili.
stevilo = numinput('Stevilo', 'Vpisi neko stevilo:')
Slika 21: Primer, ko uporabnik vpiše število
V spremenljivko stevilo smo torej shranili vrednost, ki jo vpiše uporabnik. Naslov
'Stevilo' in vprašanje 'Vpisi neko stevilo:' sta besedili, zato ju zapišemo v
narekovajih.
- Če želimo, da uporabnik vpiše črko ali besedilo: textinput(naslov,vprašanje).
Ukaz textinput() ravno tako v oklepaju zahteva dve besedili (Slika 22). Uporabnikov
vnos moramo shraniti, zato uporabimo spremenljivko.
odgovor = textinput('Smer', 'V katero smer naj grem? l/d')
Slika 22: Primer, ko uporabnik vpiše besedilo
33
5.7 Pogojni stavek
Pogojni stavki so zelo pomemben koncept v programiranju. Pogojni stavek uporabimo
takrat, ko želimo preveriti nek pogoj in se potem glede na resničnost tega pogoja odločamo
naprej (Slika 23). Velikokrat med govorom uporabimo pogojni stavek, kot recimo: »Če bo
sonce, bom šel na igrišče, drugače bom gledal televizijo«.
Podobno je pri programiranju. Pogojni stavek zapišemo takole:
if pogoj:
vrstica 1 (vrstice), ki se izvede(jo), če je pogoj resničen
else:
vrstica 2 (vrstice), ki se izvede(jo), če je pogoj neresničen
Slika 23: Pogojni stavek
Poglejmo si primer: for i in range(10):
if 3 < i < 7:
print(i)
else:
print('*')
Spremenljivka i gre od 0 do 9. Kadar je i večja od 3 in manjša od 7 (kot zahteva pogoj 3 <
i < 7), se izvede vrstica print(i), torej se izpiše vrednost i-ja. Če pa pogoj ni resničen,
torej v vseh primerih, ko je i manjši ali enak 3 ali večji ali enak 7, se izvede print('*'),
torej se izpiše zvezdica.
Ko zaženemo, program izpiše: *
*
*
*
4
34
5
6
*
*
*
V pogoju lahko seveda uporabljamo tudi druge znake, ne le <. Znak > pomeni »večji«. Če
hočemo preveriti, ali je nekaj večje ali enako od nečesa, le dodamo enačaj, torej <= oziroma
>=.
Pri preverjanju enakosti ne uporabimo =, kot bi pričakovali iz matematike. V Pythonu ima =
drugo delo, uporabljamo ga za shranjevanje vrednosti v spremenljivke. Za primerjanje
uporabljamo dvojni enačaj ==.
Napišimo program, ki bo uporabnika vprašal, ali naj nariše krog ali črto. Če bo uporabnik
vpisal 'k', bo želva narisala krog s polmerom 100, če bo uporabnik vpisal 'c', bo narisala črto
dolžine 200. Ukaz, s katerim od želve zahtevamo, da nariše krog, se imenuje circle, v
oklepaju pa povemo polmer.
V spremenljivko odgovor bomo shranili uporabnikov vnos.
odgovor = textinput('Krog ali črta','Vpisi k za krog ali c za
črto:')
Sedaj pa sledi pogojni stavek: »če je odgovor enak 'k', nariši krog s polmerom 100, če je
odgovor enak 'c', nariši črto dolžine 200«.
Pogojni stavek bi izgledal tako:
if odgovor == 'k':
francek.circle(100)
if odgovor == 'c':
francek.forward(200)
Naloge:
1. Napiši program, ki bo uporabnika vprašal, ali naj nariše 8-kotnik s stranico 100 ali rožo (iz
8 krogov s polmerom 100).
2. Napiši program, ki bo uporabnika vprašal, kakšne barve spiralo želi. Če bo uporabnik
vpisal 'r', se bo izrisala rdeča 5-kotna spirala, če bo vpisal 'm', se bo izrisala modra 6-
kotna spirala in če bo vpisal 'z', se bo izrisala zelena 7-kotna spirala. Ukaz za barvo je
35
francek.color(barva); v oklepaju moraš napisati ime barve v angleščini – kot
besedilo, torej pod narekovaji.
Pomoč:
1. Program ni veliko drugačen od tega, ki smo ga napisali kot primer.
2. Ukaz spirala(n) naj bo napisan za poljuben n-kotnik. Pomagaj si s 5. nalogo iz poglavja 5.4
(Spremenljivke so spremenljive).
Rešitve:
1. oblika = textinput('Oblika', 'Vpisi n za 8-kotnik ali r za
rožo:')
for x in range(8):
if oblika == 'r':
francek.circle(100)
francek.left(360/8)
if oblika == 'n':
francek.forward(100)
francek.left(360/8)
2. def spirala(n):
for x in range(50):
francek.forward(x*2)
francek.left(360/n)
barva = textinput('Barva spirale', 'Vpisi r za rdečo spiralo, m
za modro ali z za zeleno')
if barva == 'r':
francek.color('red')
spirala(5)
if barva == 'm':
francek.color('blue')
spirala(6)
if barva == 'z':
francek.color('green')
spirala(7)
36
5.8 Žrebanje
Da bomo lahko rešili naslednje naloge, se bomo naučili žrebati naključna števila. Za to
uporabimo ukaz randint(a,b), ki naključno izbere neko poljubno število med številoma
a in b, ki ju zapišemo v oklepaj.
Podobno kot pri želvi moramo na začetku napisati from random import *
Recimo, da želimo igrati igro Človek ne jezi se, vendar smo pozabili kocko. Z ukazom
randint lahko ustvarimo svojo kocko, ki bo naključno izbirala števila od 1 do 6. Zapišemo:
kocka = randint(1,6)
Za izpis naključnega števila zapišemo
print(kocka)
Na podoben način si lahko naredimo "kocko" s stotimi ploskvami.
stevilo =randint(0,100)
V spremenljivko z imenom stevilo smo shranili neko poljubno naključno število med 0 in
100, ki si ga izmisli ukaz randint.
Naloge:
1. Želva Anica rada hodi okrog po svetu, pri čemer vedno naredi naključno dolg korak
(med 10 in 30), poleg tega pa se vedno obrača le za 90 stopinj. Napiši program, ki se
vede, kot smo opisali. (Za naključno obračanje boš najpreprosteje poskrbel tako, da
naključno izbereš število 1 ali 2. Če je izbrano število 1, se Anica obrne v levo, če pa je
število enako 2, se obrne v desno.)
2. Želvi Anici se je pri sprehajanju pridružil tudi Franček. Anica vztraja pri svoji hoji, tako
kot je hodila že prej (glej 1. nalogo). Franček se premakne naprej za isto dolžino kot
Anica, obrača pa se ravno obratno kot Anica. Če je izbrano število enako 1, se obrne v
desno, če pa je enako 2, se obrne v levo. Za razliko od Anice se Franček obrača za
naključen kot med 30 in 90 stopinjami.
Namig: Da boš ločil Anico in Frančka, jima spremeni barvo. Anica naj bo rdeča, Franček
pa moder.
3. (težja naloga) Želva Karla je prav zares čudna želva. Zelo rada si izmišljuje naključna
števila med 10 in 50, rada ima barve ter rada riše kroge in pike. Tvoja naloga je, da ji
37
pomagaš napisati program, da bo lahko delala vse, kar najraje počne – riše čudne slike.
A ima kar nekaj navodil in pogojev:
- Število si želi izmisliti 50-krat.
- Na začetku je vedno klasične oblike ('classic') in zelene barve.
- Če bo naključno število večje ali enako 10 in manjše od 20, bo spremenila barvo
v modro, spremenila obliko v obliko 'turtle' ter pustila odtis.
- Če bo naključno število večje ali enako 20 in manjše od 30, bo narisala rumeno
piko s premerom, kot je naključno število, nato se bo obrnila v desno za
naključno število ter naredila toliko korakov, kot je naključno število.
- Če bo naključno število večje ali enako 30 in manjše od 40, bo naredila toliko
korakov kot je naključno število, spremenila barvo na rdečo ter naredila krog s
polmerom, kot je naključno število.
- Drugače pa se bo obrnila v levo za naključno število ter se premaknila za
naključno število korakov.
Primer slike, ki jo je narisala (Slika 24):
Slika 24: Karlina slika
Pomoč:
1. Pri naključni izbiri števila in dolžine uporabi ukaz randint. Da boš določil, v katero
smer naj se želva obrne, uporabi pogojni stavek.
2. Uporabi program, ki si ga napisal pri 1. nalogi. Dopiši ukaze, ki jih potrebuješ za
premikanje in obračanje Frančka. Pri Frančku ti ni potrebno ničesar žrebati!
3. Znotraj zanke si izmisli naključno število, ki ga shraniš v spremenljivko stevilo. Karli
spremeni barvo in obliko. Nato začni s pogojnimi stavki. Sledi navodilom.
38
Rešitve:
1. anica = Turtle()
for i in range(200):
st = randint(1,2)
dolzina = randint(10,30)
anica.forward(dolzina)
if st == 1:
anica.left(90)
if st == 2:
anica.right(90)
2. francek = Turtle()
anica = Turtle()
anica.color('red')
francek.color('blue')
for i in range(100):
st = randint(1,2)
dolzina = randint(10,30)
kot = randint(30,90)
francek.forward(dolzina)
anica.forward(dolzina)
if st == 1:
anica.left(90)
francek.right(kot)
if st == 2:
anica.right(90)
francek.left(kot)
3. karla = Turtle()
for i in range(50):
stevilo = randint(10,50)
karla.shape('classic')
karla.color('green')
if 10 <= stevilo < 20:
karla.color('blue')
karla.shape('turtle')
karla.stamp()
if 20 <= stevilo < 30:
karla.dot(stevilo, 'yellow')
karla.right(stevilo)
karla.forward(stevilo)
if 30 <= stevilo < 40:
karla.forward(stevilo)
39
karla.color('red')
karla.circle(stevilo)
else:
karla.left(stevilo)
karla.forward(stevilo)
5.9 Zanka s pogojem
Zanka while se izvaja toliko časa, dokler je pogoj, ki ga zapišemo v zanki while, resničen. Ko
pogoj ni več resničen, se zanka konča (Slika 25). Kaj pa se zgodi, če je pogoj vedno izpolnjen?
Če bi napisali, recimo while 1 + 1 == 2. V tem primeru se zanka pač ne bo nikoli končala,
temveč se bodo vrstice, ki so znotraj zanke, ponavljale v neskončnost.
Slika 25: Zanka s pogojem
Sintaksa zanke while je:
while pogoj:
izvajaj vrstice znotraj zanke
Ponovno moramo biti pozorni na dvopičje in zamike znotraj zanke.
Napišimo program, ki bo narisal kvadrat, vendar tokrat z zanko while.
Najprej ustvarimo želvo z imenom niko. from turtle import *
40
niko = Turtle()
Spomnimo se, kaj smo zapisali znotraj zanke for. niko.forward(100)
niko.left(90)
Ta dva ukaza smo ponovili štirikrat. Torej moramo ukaze v zanki while tudi ponoviti štirikrat.
Uvedli bomo novo spremenljivko, recimo st, ki jo bomo nastavili na 1. st = 1
Nastaviti moramo tak pogoj, da se bo zanka while ponovila štirikrat while st < 5
pri čemer moramo ob vsaki ponovitvi st povečati za 1. To storimo z ukazom st = st + 1.
Ker je spremenljivka st na začetku enaka 1, ker smo tako nastavili, in zaradi pogoja ter
povečanja st za 1, se bo zanka while res ponovila štirikrat. Zanka while je podobna zanki for,
le da v tem primeru mi povečujemo spremenljivko.
Celotna koda za kvadrat bi bila videti tako:
from turtle import *
niko = Turtle()
st = 1
while st < 5:
niko.forward(100)
niko.left(90)
st = st + 1
Zanka while se bo ponavljala toliko časa, dokler bo pogoj st < 5 resničen. Pri tem bo vsakič
narisala eno stranico kvadrata ter spremenljivko st povečala za 1. Ko pogoj ne bo več
resničen, se bo zanka nehala izvajati.
Na začetku smo ustvarili spremenljivko st in jo nastavili na 1; pravimo, da inicializiramo. V
zanki while imamo pogoj, da mora biti st manjši od 5. Znotraj zanke se izvedeta ukaza
niko.forward(100) in niko.left(90) ter ukaz, ki poveča st za 1. Ob vsaki ponovitvi
zanke se torej st poveča za 1. Zanka se izvaja toliko časa, dokler je pogoj resničen. Ko st
postane 5, pogoj postane neresničen in zanka se konča. Če bi na začetku st nastavili na 0, bi
morali v pogoj napisali st < 4. Ravno tako bi zanka while narisala kvadrat.
Naloge:
1. Želva hodi naključno po svetu toliko časa, dokler ji ne zmanjka »goriva«. Na začetku ima
poln tank, to je 2000 litrov. Dolžina, ki jo lahko prehodi naenkrat, je naključno število
41
med 0 in 50. Obrača se za naključen kot med 30 in 90. Če je naključno število med 1 in 2
enako 1, se želva obrne v levo, če je enako 2, se obrne v desno. Uporabi zanko while.
2. Napiši program, ki bo uporabnika spraševal za smer toliko časa, dokler ne bo vnesel
prazne besede (''), to je, dokler ne bo kliknil ENTER. Napiši program, ki bo uporabnika
vprašal, v katero smer naj gre (levo 'l' ali desno 'd'). Če bo vpisal 'l', se bo želva obrnila v
levo za neko stopinjo in naredila nekaj korakov. Če pa bo vpisal 'd', se bo obrnila v desno
za neko stopinjo in naredila nekaj korakov. Uporabnika naj program vpraša tudi po
stopinjah in dolžini.
Pomoč:
1. Naloga je podobna 1. oziroma 2. nalogi iz poglavja 5.8 (Žrebanje). Pri tej nalogi smo
uporabili zanko for, tokrat uporabimo zanko while. Razmisli o pogoju v zanki, saj se bo
želva premikala toliko časa, dokler tank ne bo prazen (to je manjši od 0). V primeru, da
bo tank manjši od 0, se mora program končati. Spremenljivka tank se mora ob vsaki
ponovitvi zanke while zmanjšati za dolžino, ki jo je želva prehodila. Ponovno moraš
uporabiti ukaz randint za naključno dolžino, kot ter naključno število, od katerega je
odvisno, kam se želva obrne.
2. Zanka while se glasi: »dokler je smer različna od prazne besede ('')«. Spomni se, kako
smo napisali zanko while za kvadrat (kje v programu smo nastavili vrednost
spremenljivke st na 1 in kje smo jo povečali za 1). Podobno je pri tej nalogi. Razmisli,
katero spremenljivko imamo pri tej nalogi namesto spremenljivke st (pri kvadratu).
Rešitve:
1. tank = 2000
while tank > 0:
dolzina = randint(0,50)
francek.forward(dolzina)
st = randint(1,2)
kot = randint(30,90)
if st == 1:
francek.left(kot)
if st == 2:
francek.right(kot)
tank = tank - dolzina
2. smer = textinput('Smer','V katero smer naj grem? l/d:')
while smer != '':
stopinje = numinput('Kot', 'Za koliko stopinj naj se
obrnem? Vpisi stevilo med 0 in 360:')
42
dolzina = numinput('Dolzina', 'Za koliko naj se
premaknem?:')
if smer == 'l':
francek.left(stopinje)
francek.forward(dolzina)
if smer == 'd':
francek.right(stopinje)
francek.forward(dolzina)
smer = textinput('Smer','V katero smer naj grem? l/d:')
43
6 Preizkus nalog
V osnovni šoli Železniki so nam omogočili izvajanje aktivnosti v času ene šolske ure. V
računalniški učilnici se je zbralo 11 učencev tretje triade, od tega 9 deklet in 2 fanta. Nihče
izmed učencev se še ni srečal s programiranjem. Najprej smo jih seznanili s razvojnim
okoljem IDLE, kako ga odpremo, shranimo in poženemo. Omenili smo, da bomo uporabljali
programski jezik Python, katerega del je tudi želva, ki jo bomo uporabljali.. Nato smo
ustvarili želvo ter jo poimenovali. Vsak učenec si je izbral svoje ime. Predstavili smo jim
ukaze za premikanje in obračanje, nato pa so individualno narisali hišo (Slika 26). Največ
težav pri tem so jim delali koti, saj niso vedeli, za koliko stopinj se mora želva obrniti (še
posebej, ko so risali streho). Ko so nekateri že končali, so začeli risati še vrata hiše, ena
učenka pa se je lotila risati odsev hiše. Nadaljevali smo s ponavljanjem. Skupaj smo spoznali
zanko for, kako jo zapišemo in kaj pomeni range(). Nato so učenci samostojno rešili prvo
nalogo, narisati so morali stopnišče (Slika 27). Ker nam je zmanjkalo časa, več nalog žal
nismo mogli narediti, saj smo imeli na voljo le eno šolsko uro.
Učenci so bili motivirani in zainteresirani za delo, saj se jim je zdelo programiranje z želvo
zelo zanimivo. Še nikoli prej niso videli kaj takega, zato so na začetku mislili, da bo
programiranje kot tako zahtevno, vendar so se v celotni uri zelo zabavali. Všeč jim je bilo, da
lahko vidijo, kaj zapisani ukazi naredijo. Ko so risali hišo, so si lažje predstavljali, za kakšen
kot se morajo obrniti, saj so lahko gledali sliko. Poleg tega pa so takoj vedeli, kdaj so se
zmotili, ko se je želva narobe obrnila ali naredila premalo oziroma preveč korakov.
Slika 26: Učenci rišejo hišo
44
Slika 27: Učenci samostojno rešujejo nalogo iz ponavljanja
45
7 Zaključek
V diplomskem delu smo predstavili problem programiranja v osnovnih šolah, saj izbirni
predmeti v tretji triadi vsebujejo zelo malo vsebin iz programiranja. Ker so v šolskem letu
2014/15 uvedli neobvezni izbirni predmet v drugo triado, ki učence seznanja s temeljnimi
računalniškimi koncepti in procesi ter navaja na osnovne programerske koncepte, smo
razmišljali, da bi bilo dobro kaj podobnega izdelati tudi za učence višjih razredov. Zato smo
se v diplomskem delu osredotočili na programski jezik Python, saj je zaradi pregledne kode
in preproste sintakse primeren za poučevanje, poleg tega pa je tudi dovolj zmogljiv za
naprednejše programiranje. Pri neobveznem izbirnem predmetu uporabljajo program
Scratch, saj učence motivira zaradi grafičnih elementov, zato smo želeli nekaj podobnega
tudi za tretjo triado. Odločili smo se za želvo, ki je implementirana v Pythonu kot knjižnica.
Želva omogoča učencem, da preko animacije vidijo, kaj naredijo njihovi zapisani ukazi. Za
uporabo želve učencem ni potrebno predstavljati zahtevnih ukazov, spoznati morajo le
ukaze za premikanje in obračanje, pri čemer morajo poznati le kote.
Glavni namen diplomskega dela je bil sestaviti aktivnosti za učne ure iz Pythona, kjer bi
učenci s pomočjo želve spoznali osnovne koncepte programiranja, kot so zanke, pogojni
stavek in funkcije. Ker smo imeli v osnovnošolski računalniški učilnici na voljo samo eno
šolsko uro, smo lahko preizkusili le nekaj aktivnosti, ki so jih učenci z veseljem in
zanimanjem reševali. Ugotovili smo, da so takšne naloge za učence zanimive in bi z njimi
zagotovo lahko dosegali zastavljene učne cilje. Po drugi strani je bilo že sestavljanje teh
»učnih priprav« in nalog prvi korak v razmišljanju, kako zastaviti pouk iz programiranja.
Pri pisanju nalog in aktivnosti za učne ure smo imeli kar nekaj težav, kako sestaviti primerne
in ne preveč zahtevne naloge ter na kakšen način razložiti učencem osnovne koncepte.
Največ težav smo imeli pri sestavljanju nalog za pogojni stavek in zanko s pogojem. Ravno
zato smo morali vpeljati še ukaze za komunikacijo z uporabnikom in knjižnico random, da
smo s pomočjo le-teh izdelali primerne naloge.
Če želimo vpeljati v šole bolj poglobljen pouk računalništva, ki naj bi vključeval tudi
programiranje, bo potrebno za to sestaviti primeren učni program in naloge. Predstavljeno
diplomsko delo lahko predstavlja enega od korakov na tej poti.
46
8 Literatura
Briggs, J. (2007). Snake wrangling for kids: Learning to program with Python.
Briggs, J. (2013). Python for Kids: A playful introduction to programming. San Francisco,
California: No Starch Press, Inc.
Lutz, M. (2008). Learning Python. Third edition. Sebastopol, California: O'Reilly Media, Inc.
Kononenko, I., Robnik Šikonja, M. in Bosnić, Z. (2008). Programiranje in algoritmi. Ljubljana:
Fakulteta za računalništvo in informatiko.
Maruch, S. in Maruch, A. (2006). Python for Dummies. Hoboken, New Jersey: Wiley
Publishing.
Mount, S., Shuttleworth, J. in Winder, R. (2008). Python for rookies. A first course in
programming. London: Thomson Learning.
Tollervey, N. (2015). Python in education: Teach, learn, program. Sebastopol, California:
O'Reilly Media, Inc.
Grehan, R. (2010). PyScripter review. Pridobljeno 31. 8. 2015 s spletne strani
http://www.techworld.com/review/programming-software/pyscripter-review-3238828/
History of Scratch. Hove (England). Redware. Pridobljeno 31. 8. 2015 s spletne strani
http://scratch.redware.com/content/history-scratch
IDLE. Python Software Foundation. Pridobljeno 31. 8. 2015 s spletne strani
http://www.python.org/idle/
Turtle graphics. Hove (England). Redware. Pridobljeno 31. 8. 2015 s spletne strani
http://scratch.redware.com/lessonplan/turtlegraphics
Izbirni predmet Računalništvo (Urejanje besedil, Računalniška omrežja, Multimedija). Učni
načrt. (2002). Pridobljeno 31. 8. 2015 s spletne strani
http://www.mizs.gov.si/fileadmin/mizs.gov.si/pageuploads/podrocje/os/devetletka/predm
eti_izbirni/Racunalnistvo_izbirni.pdf
Neobvezni izbirni predmet Računalništvo. Učni načrt. (2013). Pridobljeno 31. 8. 2015 s
spletne strani
47
http://www.mizs.gov.si/fileadmin/mizs.gov.si/pageuploads/podrocje/os/devetletka/progra
m_razsirjeni/Racunalnistvo_izbirni_neobvezni.pdf
Rossum, G. (2009). Perosnal history – part 1, CWI. Pridobljeno 31. 8. 2015 s spletne strani
http://python-history.blogspot.co.uk/2009/01/personal-history-part-1-cwi.html
Peters, T. The Zen of Python. Pridobljeno 31. 8. 2015 s spletne strani
https://www.python.org/doc/humor/#the-zen-of-python
Scratch. Scratch Wiki. Pridobljeno 31. 8. 2015 s spletne strani
http://wiki.scratch.mit.edu/wiki/Scratch
Želva. Python Software Foundation. Pridobljeno 31. 8. 2015 s spletne strani
https://docs.python.org/3.6/library/turtle.html
