Added new exercises with recursion.

Added description for functions.
author: Martin Možina <martin.mozina@fri.uni-lj.si> 2016-10-25 11:44:09 +0200
committer: Martin Možina <martin.mozina@fri.uni-lj.si> 2016-10-25 11:44:09 +0200
commit: 0bfa95be7046b101a00f83f082260b5d0e007159 (patch)
tree: 3d40f550b1b4ac620ca16914cef62f7066d2ef12 /python/problems/functions/functions_sl.html
parent: f12796f00b36d143d8e2735cbec988cad3a3e9e3 (diff)
1 files changed, 587 insertions, 0 deletions
diff --git a/python/problems/functions/functions_sl.html b/python/problems/functions/functions_sl.html
new file mode 100644
index 0000000..1bd0a25
--- /dev/null
+++ b/python/problems/functions/functions_sl.html
@@ -0,0 +1,587 @@
+<!DOCTYPE html>
+<html lang="sl">
+<head>
+  <meta charset="utf-8" />
+  <title></title>
+  <link rel="stylesheet" type="text/css" href="/css/codeq.css" />
+  <link rel="stylesheet" type="text/css" href="../../style.css" />
+</head>
+<body>
+
+<h1> Kako definiramo funkcije? </h1>
+
+<p>Funkcije smo si doslej predstavljali kot škatlice: nekaj gre noter
+(temu smo in bomo rekli <em>argument</em>), nekaj pride ven (temu se reče
+ rezultat funkcije), vmes pa se lahko še kaj opaznega dogaja, recimo
+ izpisuje. Primer funkcije, ki je počela vse to, je <code>input</code>: kot
+argument smo ji povedali, kaj naj vpraša uporabnika; kot rezultat je vrnila,
+kar je vtipkal uporabnik; vmes se je zgodilo to, da je funkcija nekaj vprašala
+uporabnika in počakala, da je le-ta odgovoril. Druga funkcija, ki smo jo
+srečali, je bila <code>sqrt</code>, ki dobi kot argument neko število in vrne
+njegov koren. Vmes se ne dogaja nič opaznega, funkcija le "neopazno" naredi,
+kar mora narediti.</p>
+
+<p>S tem, kako delujejo funkcije in kako kaj naredijo, se doslej nismo
+ukvarjali. Te stvari so za nas napisali drugi (hvala, hvala) in mi jih lahko
+uporabljamo, ne da bi nas vznemirjalo vprašanje, kako so napisane. S tem, kako
+so napisane funkcije, ki so jih naredili drugi, se tudi v prihodnje ne bomo
+ukvarjali. Pač pa se bomo danes naučili pisati svoje.</p>
+
+
+<h2>Popolna števila</h2>
+
+<p>Število je <em>popolno</em>, če je enako vsoti svojih deliteljev. 28 je
+deljivo z 1, 2, 4, 7 in 14 ter je popolno, saj je 1+2+4+7+14 ravno 28. Napišimo
+program, ki sestavi seznam vseh popolnih števil do 1000.</p>
+
+<h3>Delitelji števila</h3>
+
+<p>Znamo napisati program, ki sestavi seznam vseh deliteljev nekega števila
+    <em>n</em>?</p>
+
+<pre>
+n = int(input("Vnesi število: "))
+
+s = []
+for i in range(1, n):
+    if n % i == 0:
+        s.append(i)
+
+print(s)</pre>
+
+<p>Najprej naredimo prazen seznam, nato gremo prek vseh števil od 1 do n in
+če število deli <code>n</code>, ga dodamo v <code>s</code>.</p>
+
+<p>Kaj ne bi bilo lepo, če bi imel Python kar funkcijo <code>delitelji</code>,
+ki bi jo lahko uporabili? Potem bi lahko napisali kar</p>
+
+<pre>
+stevilka = int(input("Vnesi število: "))
+s = delitelji(stevilka)
+print(s)</pre>
+
+<p>Napišimo si takšno funkcijo, da jo bomo lahko klicali.</p>
+
+<pre>def delitelji(n):
+    s = []
+    for i in range(1, n):
+        if n % i == 0:
+            s.append(i)
+    return s</pre>
+
+<p>Definicijo funkcije začnemo z <code>def</code>; to je rezervirana beseda, ki
+pomeni, da to, kar sledi, ni "program, ki ga je treba takoj izvesti", temveč
+funkcija. Z drugimi besedami, <code>def delitelji</code> pomeni: "<em>kadar bo
+kdo poklical funkcijo <code>delitelji</code>, naredi naslednje:</em>".</p>
+
+<p>Imenu sledijo oklepaji, v katerih navedemo <em>imena argumentov
+funkcije</em>. V našem primeru bo funkcija zahtevala en argument. Torej, ta,
+ki bo poklical funkcijo, bo moral v oklepaje napisati eno reč (upamo, da bo
+napisal število, sicer pa naj si sam pripiše posledice).</p>
+
+<p>Tista reč, ki jo bomo ob klicu funkcije podali kot argument, se bo znotraj
+funkcije pojavila kot spremenljivka z imenom <code>n</code>. Takšno ime smo
+namreč uporabili v prvi vrstici, v "glavi" funkcije. Vrednosti ji ne bomo
+priredili: ko bo nekdo poklical funkcijo, bo Python tej "spremenljivki" kar sam
+od sebe priredil vrednost, ki jo bo "klicatelj" napisal kot argument funkcije.
+Če torej nekdo pokliče
+
+<pre>s = delitelji(35)</pre>
+
+bo imel <code>n</code> vrednost 35 in če pokliče
+
+<pre>s = delitelji(13)</pre>
+
+bo imel <code>n</code> vrednost 13. <code>n</code> ima vrednost argumenta.</p>
+
+<p>Za <code>def delitelji(n)</code> sledi dvopičje in zamik. Vse, kar sledi
+takole zamaknjeno, je koda funkcije. Kaj mora narediti le-ta? No, tisto, kar
+pač dela funkcija: sestaviti seznam deliteljev <code>n</code>. To pa ne le
+znamo narediti, temveč smo celo ravno prejle tudi zares naredili in lahko le
+skopiramo.</p>
+
+<p>Na koncu (ali tudi že kje vmes - bomo že videli primer) funkcija pove, kaj
+naj klicatelj dobi kot rezultat. To stori s stavkom <code>return s</code>.</p>
+
+<h3>Geometrija</h3>
+
+<p>Napišimo funkcijo, ki dobi kot argument dolžine stranic trikotnika in vrne
+   njegovo ploščino. Ta funkcija bo imela tri argumente; poimenujmo jih
+   <code>a</code>, <code>b</code> in <code>c</code>.
+
+
+<pre>from math import *
+def ploscina_trikotnika(a, b, c):
+    s = (a + b + c) / 2
+    return sqrt(s * (s - a) * (s - b) * (s - c))</pre>
+
+<p>Ko smo pri tem, napišimo še funkcijo funkcijo za obseg trikotnika ter za
+    obseg in ploščino kroga.</p>
+
+<pre>from math import *
+
+def obseg_trikotnika(a, b, c):
+    return a + b + c
+
+def ploscina_kroga(r):
+    return pi * r ** 2
+
+def obseg_kroga(r):
+    return 2 * pi * r</pre>
+
+<h3>Vsota števil v seznamu</h3>
+
+<p>Zdaj napišimo drugo funkcijo: funkcijo, ki dobi seznam števil in izračuna
+njihovo vsoto.</p>
+
+<pre>def vsota(s):
+    vsota = 0
+    for e in s:
+        vsota += e
+    return vsota</pre>
+
+<p>Funkcija ima spet en argument, tokrat smo ga poimenovali <code>s</code>.
+Ta argument bo seznam števil, ki jih je potrebno sešteti. Funkcija gre - z
+zanko <code>for</code> - prek tega seznama in sešteva, kot smo počeli že
+prejšnji teden, le brez funkcij. Na koncu rezultata ne izpiše
+(<code>print</code>), kot smo delali doslej, temveč ga vrne
+(<code>return</code>).</p>
+
+<p>(Mimogrede povejmo še, da nam funkcije <code>vsota</code> ne bi bilo
+potrebno napisati, saj obstaja: imenuje se <code>sum</code>.)</p>
+
+
+<h4>Za napredno misleče</h4>
+
+<p>Nekateri se sprašujejo, kako funkcija ve, kakšnega tipa bodo argumenti,
+ki jih bo dobila. Nekateri se zdaj, ko so izvedeli, da se nekateri sprašujejo
+o tem, sprašujejo, zakaj bi se kdo to spraševal.</p>
+
+<p>Vsebina tega razdelka je namenjena samo prvim. Kasneje bo vse, kar pišemo
+tu, postalo samoumevno, ne da bi bilo potrebno razlagati. Tule pa povejmo
+zaradi tistih, ki prihajajo iz drugih jezikov.</p>
+
+<p>V nekaterih jezikih je potrebno za vsako spremenljivko, preden jo uporabimo,
+povedati, kakšnega tipa bo. Python ni eden izmed teh "nekaterih jezikov".
+Podobno je z argumenti funkcij. V nekaterih jezikih bi morali povedati,
+kakšnega tipa bodo argumenti funkcije in kakšen bo rezultat. Tudi takšen
+Python ni. Funkcija sprejme, kar sprejme in vrača, kar vrača.</p>
+
+<p>Za primer vzemimo preprostejšo funkcijo <code>vsota</code>, ki ji podamo dva
+    argumenta, funkcija pa vrne njuno vsoto.</p>
+
+<pre>def vsota(a, b):
+    return a + b</pre>
+
+<p>Če jo pokličemo z <code>vsota(2, 5)</code>, vrne <code>2 + 5</code>, torej
+    <code>7</code>. Če jo pokličemo z <code>vsota("Ana", "Marija")</code> vrne
+    <code>"Ana" + "Marija"</code>, torej <code>"AnaMarija"</code>. Če jo
+    pokličemo z <code>vsota(2, "Ana")</code>, poskuša izračunati
+    <code>2 + "Ana"</code> in vrne napako, ker se ne da seštevati števil in
+    nizov.</p>
+
+<p>Jezikom, ki delajo tako, pravimo dinamično tipizirani jeziki. Stvar deluje
+(približno) tako, da Python, ko pride do <code>a + b</code>, reče objektoma
+<code>a</code> in <code>b</code>, naj se seštejeta. Če se znata, je to v redu,
+če ne, pa javita napako in Python jo izpiše. Python v resnici ne zna seštevati,
+seštevati (se) znajo objekti.</p>
+
+<p>Vrnimo se k prvi funkciji <code>vsota</code>, oni od prej. Kaj bi se
+    zgodilo, če bi dali funkciji namesto seznama kaj drugega, recimo
+    terko ali kaj podobnega? No, preskusimo jo nekoliko.</p>
+
+<pre> vsota([1, 5, 3])
+9
+>>> vsota((1, 5, 3))
+9
+>>> vsota(range(4))
+6</pre>
+
+<p>S seznamom dela. Prvi klic pomeni isto, kot če bi napisali:
+<pre>s = [1, 5, 3]
+v = 0
+for e in s:
+    v += e</pre>
+
+Drugi klic je podoben, le da je <code>s</code> zdaj terka <code>(1, 5, 3)</code>,
+torej dobimo
+
+<pre>v = 0
+for e in (1, 5, 3):
+    v += e</pre>
+
+Tretji klic pa je isto, kot če bi rekli
+
+<pre>v = 0
+for e in range(4):
+    v += e</pre>
+</p>
+
+<p>Kaj pa, če bi namesto seznama celih števil podali seznam necelih?</p>
+
+<pre>>>> vsota([1.3, 2.2, 3.1])
+6.6</pre>
+
+<p>Dela, jasno. Zakaj pa ne bi?</p>
+
+<p>Kaj pa, če bi dali seznam nizov? Poglejmo, poučno bo.</p>
+
+<pre>>>> vsota(["Ana", "Berta", "Cilka"])
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+  File "<stdin>", line 4, in vsota
+TypeError: unsupported operand type(s) for +=: 'int' and 'str'</pre>
+
+<p>Zgodi se tole. Najprej je <code>v</code> enak 0. V prvem koraku zanke
+poskuša izračunati <code>0 + "Ana"</code>, kar se ne da.</p>
+
+<p>Funkcijo je mogoče popraviti, da bo delovala tudi za nize. </p>
+
+<pre>def vsota(s):
+    v = None
+    for e in s:
+        if v == None:
+            v = e
+        else:
+            v += e
+    return v</pre>
+
+<p>(<br/>Komur se mozga, naj razmisli, zakaj dela tudi naslednja (grda)
+    različica funkcije:</p>
+<pre>def vsota(s):
+    v = None
+    for e in s:
+        v = v and v + e or e
+    return v</pre>
+<p>.)</p>
+
+<p>Tule smo torej naleteli na <code>None</code>. Tole je kar tipična situacija,
+    v kateri ga uporabimo. <code>v</code>-ju moramo bo v začetku dati neko
+    vrednost, ki bo povedala, da še nima nobene vrednosti. <code>None</code> je
+    idealna konstanta, s katero povemo kaj takega. V zanki preverimo, ali je
+    <code>v</code> še vedno nič in mu v tem primeru priredimo <code>e</code>,
+    sicer mu prištejemo <code>e</code>.</p>
+
+<p>Razlika je v tem, da <code>v</code>-ju zdaj ne priredimo vrednosti že pred
+zanko, temveč jo dobi šele pri prvem elementu zanke. Tako bo gotovo pravega
+tipa. Zdaj zna seštevati vse živo.</p>
+
+<pre>>>> vsota([1, 2, 3])
+6
+>>> vsota(["Ana", "Benjamin", "Cilka"])
+'AnaBenjaminCilka'</pre>
+
+<p>Kaj pa tole?</p>
+
+<pre>>>> vsota("Benjamin")
+'Benjamin'</pre>
+
+<p>Zanka <code>for</code> gre prek niza in sešteje njegove črke. Rezultat je,
+seveda, spet isti niz.</p>
+
+<p>Pač pa funkcija ne deluje, če ji damo seznam, ki vsebuje reči, ki jih ni
+mogoče sešteti.</p>
+
+<pre>>>> vsota([1, "a"])
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+  File "<stdin>", line 8, in vsota
+TypeError: unsupported operand type(s) for +=: 'int' and 'str'</pre>
+
+
+
+<h3>Popolno število</h3>
+
+<p>Vrnimo se k popolnim številom. Rekli smo, da je število popolno, če je enako
+    vsoti svojih deliteljev. Lahko bi torej rekli</p>
+
+<pre>stevilo = int(input("Vnesi število: "))
+d = delitelji(stevilo)
+v = vsota(d)
+if v == d:
+    print("Število", stevilo, "je popolno")
+else:
+    print("Število", stevilo, "ni popolno")</pre>
+
+<p>vendar ne bomo. Napisali bomo funkcijo, ki vrne <code>True</code>, če je
+število popolno in <code>False</code>, če ni.</p>
+
+<pre>def popolno(n):
+    d = delitelji(n)
+    v = vsota(d)
+    return v == n</pre>
+
+<p>Pazite, tule nismo pisali</p>
+
+<pre>def popolno(n):
+    d = delitelji(n)
+    v = vsota(d)
+    if v == n:
+        return True
+    else:
+        return False</pre>
+
+<p>Lahko bi, vendar bi bilo smešno. Pač pa lahko funkcijo še skrajšamo (in
+navadno bi jo tudi res), takole</p>
+
+<pre>def popolno(n):
+    return vsota(delitelji(n)) == n</pre>
+
+<p>Končno ostane še program, ki bo z uporabo gornje funkcije sestavil seznam
+vseh popolnih števil manjših od 1000.
+V njem z zanko <code>for</code> preštejemo do 1000, za vsako število posebej
+preverimo, ali je popolno in če je, ga dodamo na seznam.</p>
+
+<pre>s = []
+for i in range(1, 1001):
+    if popolno(i):
+        s.append(i)
+
+print(s)</pre>
+
+<p>Lepo prosim, ne pišite <code>if popolno(i) == True:</code>. Smo že povedali,
+zakaj, ne?</p>
+
+<h2>Klici funkcij</h2>
+
+<p>Najprej zberimo vse skupaj:</p>
+
+<pre>def delitelji(n):
+    s = []
+    for i in range(1, n):
+        if n % i == 0:
+            s.append(i)
+    return s
+
+def vsota(s):
+    v = 0
+    for e in s:
+        v += e
+    return v
+
+def popolno(n):
+    d = delitelji(n)
+    v = vsota(d)
+    return v == n
+
+
+s = []
+for i in range(1, 1001):
+    if popolno(i):
+        s.append(i)
+
+print(s)</pre>
+
+<p>Kako se izvaja tako napisan program? Malo drugače, kot smo vajeni. Začetek
+programa - vse do mesta <code>s = []</code>, so definicije funkcij. Python tega
+dela programa ne izvede, le zapomni si funkcije, da jih bo kasneje lahko
+poklical. Stvari se začnejo zares dogajati šele, pri <code>s = []</code>. Ko
+program pride do klica funkcije <code>popolno</code>, skoči v to funkcijo --
+vendar si zapomni, odkod je skočil, tako da se bo kasneje lahko vrnil na to
+mesto.</p>
+
+<p>Prav. Zdaj smo v funkciji <code>popolno</code> in <code>n</code> je neka
+številka (najprej 1, naslednjič bo 2 in tako naprej). Že takoj, v prvi
+vrstici skoči izvajanje v funkcijo <code>delitelji</code>. Ta sestavi seznam
+deliteljev in ga vrne - tistemu, ki jo je poklical, funkciji
+<code>popolno</code>. Nato se nadaljuje izvajanje funkcije <code>popolno</code>:
+ta v naslednji vrsti pokliče funkcijo <code>vsota</code>. Funkcija
+<code>vsota</code> izračuna in vrne vsoto. Spet smo v funkciji
+<code>popolno</code>, ki izračuna vrednost izraza <code>v == n</code>;
+vrednost izraza je <code>True</code> ali <code>False</code>. Funkcija
+<code>popolno</code> ga vrne tistemu, ki jo je klical, se pravi oni zanki
+na koncu skripte. Če je rezultat <code>True</code>, dodamo število v seznam,
+sicer ne.</p>
+
+<p>Ta program je lep zato, ker je pregleden. Razdelili smo ga na tri funkcije,
+vsaka opravlja svoje delo. Ko pišemo eno funkcijo, se ne ukvarjamo
+s celo sliko, temveč le s tem, kar počne ta funkcija. Če mislimo
+le na eno stvar naenkrat, nam bo lažje programirati in manj se bomo motili.</p>
+
+<h2>Rezultat sredi funkcije</h2>
+
+<p>Napišimo funkcijo, ki pove, ali je dano število praštevilo. Vrnila bo
+<code>True</code> (je) ali <code>False</code> (ni).</p>
+
+<p>Prejšnjič smo v te namene spoznali <code>break</code> - <code>break</code>
+    je bil ukaz, s katerim smo lahko prekinili zanko. No, prekinemo jo lahko
+    tudi z <code>return</code>.</p>
+
+<pre>def prastevilo(n):
+    for i in range(2, n):
+        if n % i == 0:
+            return False
+    return True
+</pre></p>
+
+<p>Prvi <code>return</code> je znotraj stavka <code>if</code>. Če odkrijemo,
+da kakšno število med 2 in n-1 deli n (se pravi, če je ostanek po deljenju
+<code>n</code> z <code>i</code> enak 0), dano število ni praštevilo in vrnemo
+<code>False</code>. S tem se izvajanje funkcije prekine, funkcija vrne
+rezultat in konec. Nobenega <code>break</code> ali česa podobnega ne
+potrebujemo. <code>return</code> vedno konča izvajanje funkcije. Do drugega
+<code>return</code>a tako pridemo le, če se ni izvedel prvi
+<code>return</code>. To pa seveda pomeni, da ni bilo nobenega števila, ki bi
+delilo dano število <code>n</code>.</p>
+
+
+<h2>Funkcije (navadno) vračajo rezultate, ne izpisujejo</h2>
+
+<p>Iz neznanega razloga so študentom - kot opažam na izpitih in v domačih
+nalogah - veliko bolj pri srcu funkcije, ki nekaj izpišejo, kot funkcije,
+ki vračajo rezultat. Tako bi jih mikalo, recimo, funkcijo za <code>vsoto</code>
+napisati tako, da bi na koncu namesto <code>return v</code> pisalo
+<code>print(v)</code>.</p>
+
+<p>Vendar to ni prav! S takšno funkcijo si nimamo kaj pomagati! Ne potrebujemo
+funkcije, ki <em>izpiše</em> vsoto; potrebujemo funkcijo, ki <em>vrne</em>
+vsoto, da bomo lahko s to vsoto še kaj počeli. Če jo bomo hoteli izpisati, bomo
+pač poklicali funkcijo in izpisali, kar vrne. Funkcija naj jo le izračuna. Si
+predstavljate, kako neuporabna bi bila funkcija <code>sin</code>, če bi le
+izpisala sinus, namesto da ga vrne? Bi si lahko pri programiranju topov z njo
+sploh kaj pomagali?</p>
+
+<p>To seveda ne pomeni, da funkcije ne smejo ničesar izpisovati. Smejo; nekatere
+so pač namenjene temu. Najbolj očiten primer takšne funkcije je očitno kar
+<code>print</code>.</p>
+
+<h2>Funkcije, ki ne vračajo ničesar</h2>
+
+<p>Vse funkcije v Pythonu vračajo rezultat. Če funkcija ne vrača ničesar, vrača
+   nič, torej <code>None</code>. To se bo zgodilo, kadar funkcija nima
+    <code>return</code> ali kadar se ta ne izvede.</p>
+
+<p>Napišimo, na primer, funkcijo, ki kot argument dobi seznam in vrne prvo sodo
+    število v njem.</p>
+
+<pre>def prvo_sodo(s):
+    for e in s:
+        if e % 2 == 0:
+            return e</pre>
+
+<p>In zdaj jo preskusimo:
+<pre>>>> prvo_sodo([1, 2, 3, 4, 5])
+2
+>>> prvo_sodo([1, 3, 5])
+>>> print(prvo_sodo([1, 3, 5]))
+None</pre>
+
+<p>Prvi klic je jasen: funkcija vrne 2. V drugem primeru pa nikoli ne pride do
+    <code>return</code>a, zato funkcija pač ne vrne ničesar. Ko smo jo
+    poklicali, se tudi ni nič izpisalo, saj Python, kadar ga poganjamo v
+    načinu za čvekanje, ne izpiše <code>None</code> ... razen, kadar ga k temu
+    prisilimo s <code>print</code>, kot smo storili v zadnji vrstici.</p>
+
+<p>Konstanta <code>None</code> se šteje za neresnično. To je praktično, saj jo
+lahko uporabljamo v pogojnih stavkih. Imejmo nek seznam <code>s</code> in
+izpišimo prvo sodo število ali pa povejmo, da v seznamu ni sodih števil.</p>
+
+<pre>sodo = prvo_sodo(s)
+if sodo:
+    print("Prvo sodo število je", sodo)
+else:
+    print("V seznamu ni sodih števil.")</pre>
+
+<p>Vendar moramo biti pri takšnem početju majčkeno previdni. Kaj, če je prvo sodo
+število v seznamu 0? Ker je tudi 0 neresnično, bo program v tem primeru napisal,
+da ni sodih števil. Pravilno bi bilo torej</p>
+
+<pre>sodo = prvo_sodo(s)
+if sodo != None:
+    print("Prvo sodo število je", sodo)
+else:
+    print("V seznamu ni sodih števil.")</pre>
+
+<p>Iz nekega razloga, ki ga bomo pojasnili čez dva tedna, pa običajno pišemo</p>
+
+<pre>sodo = prvo_sodo(s)
+if sodo is not None:
+    print("Prvo sodo število je", sodo)
+else:
+    print("V seznamu ni sodih števil.")</pre>
+
+
+<h2>Več rezultatov</h2>
+
+<p>Funkcija lahko vrača tudi "več rezultatov", tako kot tale funkcija, ki vrne,
+kvadrat in kub števila.</p>
+
+<pre>def kk(x):
+    return x ** 2, x ** 3</pre>
+
+<p>Pokličemo jo lahko takole.</p>
+
+<pre>kvad, kub = kk(5)</pre>
+
+<p>Pozoren študent je najbrž že spregledal mojo laž. V resnici funkcija
+vrača en sam rezultat, namreč terko in ob klicu funkcije to terko razpakiramo.
+Vendar nam o tem, tehničnem vidiku zadeve, ni potrebno razmišljati. Mirno se
+lahko vedemo, kot da smo dobili dve vrednosti.</p>
+
+<p>V tem primeru navadno ne pišemo oklepajev okrog terk. Funkcija bo delovala
+tudi, če pišemo <code>return (x ** 2, x ** 3)</code>, vendar to ni običajen
+zapis za vračanje dveh vrednosti.</p>
+
+<h2>Več returnov</h2>
+
+<p>Funkcija ima seveda lahko več <code>return</code>ov. Izvede se tisti, na
+   katerega naleti. En primer smo že videli (določanje praštevilskosti).
+   Naredimo še enega: funkcijo, ki vrne absolutno vrednost danega števila.</p>
+
+<pre>def abs(x):
+    if x < 0:
+        return -x
+    else:
+        return x
+</pre>
+
+<p>Funkcija ima torej dva <code>return</code>. Eden se izvede, če je število
+    negativno in drugi, če pozitivno.</p>
+
+
+<h2>Funkcije brez argumentov</h2>
+
+<p>Funkcija je lahko tudi brez argumentov. Tule je funkcija, ki nima argumentov,
+    vrne pa 42. Vedno.</p>
+
+<pre>def odgovor():
+    return 42
+</pre>
+
+<p>Tako funkcijo je potrebno tudi poklicati s praznim seznamov argumentov -
+oklepajev pa vseeno ne smemo pozabiti.</p>
+
+<pre>koliko = odgovor()</pre>
+
+<p>Malo pametnejši primer funkcije brez argumentov bi bila funkcija, ki
+    uporabniku zastavi račun in pove (s <code>True</code> ali
+    <code>False</code>), ali ga je pravilno rešil.</p>
+
+<pre>def uganka():
+    a = randint(2, 10)
+    b = randint(2, 10)
+    c = int(input("Koliko je {}x{}? ".format(a, b)))
+    return a * b  == c</pre>
+
+<p>Z njo postane rešitev lanske domače naloge precej preglednejša.</p>
+
+<pre>from random import *
+from time import *
+
+konec = time() + 20
+tock = 0
+while time() < konec:
+    if uganka():
+        print("Pravilno.")
+        tock += 1
+    else:
+        print("Napačno.")
+print("Dosegli ste", tock, "tock")</pre>
+
+<p>Zdaj, ko znamo definirati funkcije, bo postalo naše življenje veliko lažje
+in preglednejše. Naši programi so, z vsem kar znamo, začeli postajati
+dolgi in razvlečeni. Zdaj jih bomo lahko razsekali v posamezne funkcije in se
+v njih tako lažje znašli.</p>
+
+</body>
+</html>
author	Martin Možina <martin.mozina@fri.uni-lj.si>	2016-10-25 11:44:09 +0200
committer	Martin Možina <martin.mozina@fri.uni-lj.si>	2016-10-25 11:44:09 +0200
commit	0bfa95be7046b101a00f83f082260b5d0e007159 (patch)
tree	3d40f550b1b4ac620ca16914cef62f7066d2ef12 /python/problems/functions/functions_sl.html
parent	f12796f00b36d143d8e2735cbec988cad3a3e9e3 (diff)