[[PageOutline]]
= Python =
Python je skriptni jezik, pri katerem se stvari izvajajo ob tem, ko naleti 
interpreter na vrstico. Se pravi, da se vse ukaza, kot tudi
upravljanje s spremenljivkami oz podatki izvaja dinamično. Pomembno tudi to, 
da vse prednosti in slabosti iz drugih jezikov nakako v Pythonu bolje
rešene. Ena od pomembnih novosti je seveda zamikanje ukazov. Ker potem programi 
vsi izgledajo bolje in jih lažje beremo. Po nekih raziskava je bilo ugotovljeno,
da program enkrat pišemo, beremo ga pa večkrat. In prav berljivost je pomembna!

== Prvi program ==
Uvod v programski jezik običajno pokažemo z enostavnim primerom, ki prikaže osnovni potek
programiranja:
 1. Odpremo IDLE (Python GUI) in odtipkamo naslednjo vrstico
{{{
#!python
print "Hello, world!"
}}}
 2. Pred shranjevanjem v IDLE še nastavimo Options->Configure Idle->General->Sefault Source Encoding->UTF-8.
 3. Shranimo datoteko z ukazom File->Save->hello.py 
 4. Poženemo skript z F5 ali Run->Run Module

== Drugi program ==
Jezik nekoliko bolje predstavimo z drugim programom, ki vsebuje funkcijo in bere 
{{{
#!python
# drugi program
import math

def ploscina(d):
    return  math.pi*d**2/4

d = input("Vnesi premer kroga: ")
print u"Ploščina kroga je %.2f" % ploscina(d)
}}}


== Spremenljivke ==
Imena spremenljivk so poljubna. Python je občutljiv na velike in male črke. Sledimo dogovoru in priporočilom, kot je to v podobnih jezikih.


Vse spremenljivke so nakako avtomatske. Torej so generirane ob prvi uporabi. Tako imamo lahko par različih (osnovnih) tipov kot so:
 1. integer (int, short, cardinal)- cela števila  - v dogovoru se izbirajo za kratka imena spremenljivk i, j, k, l, m, n
 2. floating point (real, float, double) - plavajoča vejica ali realna ševila
 3. niz znakov ali string 
 4. bool ali true/false označevanje, ki pa je prav zaprav integer
 5. Kompleksna števila (Realni+Imaginarni''i'') 

Sedaj lahko sestavljamo osnovne tipe tu v sestavljene tipe, kot so na primer:
 1. Array - vektor - matrika - list - seznam ne nujno istovrstnih osnovnih tipov
 2. Slovarji (map) - dictionary - asociativni seznami
 3. Terke (''tuple'') ali se seznami fiksnih velikosti, ki se uporabljajo za hranjenje različnih osnovnih tipov v enem skupku.
 4. Strukture (razredi)

Kateri tip se je ob prireditvi podal lahko preverimo z ukazom
 type(tip)

== Operatorji ==

Operirajo s spremenljivkami. Vsak programski jezik ima nabor teh stvari in se ne razlikuje od novejših jezikov. 
Ima python prav nekaj ''lepih'' operatorev (npr tuple, +). 

Obstajajo seveda vsi normalni operatorji, +, -, *, /, //, %
Okrajšani operatorji +=, -=, 

Primer:

{{{
#!python
# -*- coding: cp1250 -*-
# komentar se prične z # in veja do konca vrstice

i = 1 # celoštevilčna
a = 1.2 # realno število
t = "besedilo" # niz znakov
t2 =  'ni nobene razlike' # razen v prirocnisti
c = 1 + 2j # kompleksno 

# Operatorji na osnovnih tipih

print i+1
print a+i
print t+str(a)

i, j = (1, 2) # skupek prireditev (tuple)
i, j = j, i 
print i, j

# Sestavljeni tipi 
b = [1, 2, 3] # seznam ali list
print b[0]
b.append(4) # dodamo element na koncu
b[5]=5

# Matrike
m = [1,2,3,4,5,6,7,8,9]
# Vektor m lahko interpretiramo kot matriko s tem, da preračunavamo indeks
i=1
j=2
print m[i*3+j]
}}}

Tuple ali terke se uporabljajo predvsem za sestavljanje podatkov. 
Najpogostejši primer je prenašanje rezultatov iz funkcij oziroma podprogramov.
Skupek je običajno v okroglih oklepajih, ki pa se lahko tudi opustijo.

== Kontrolni ukazi ==
 * if
 * for
 * while
 * funkcije ali podprogrami

 Pomembno je, da za vsakim kontrolnim ukazom podamo dvopičje, ki pomeni, da se v naslednjih vrsticah pričakuje zamaknjen blok ukazov.

{{{
#!python
i = input("Stevilo zob:")

if i < 5 :
    print "Premajhno stevilo zob"
else:
    print "OK"
}}}

Stavek for je iterator. LE ta pa "iterira" po vseh elementih. 
Zato običajno nimamo podanega obsega, ki pa ga pridelamo z ukazom range().

{{{
#!python
for i in range(10):
    i = i + 1
    print i
}}}

Za prekinitev zanke for uporabimo ukaz break.  
Ta ukaz takoj prekine vse nadaljnjne iteracije.
Ukaz continue v zankah pa nadaljuje z naslednjim elementom.

Funkcije oz. podprograme pišemo in uporabljamo praktično povsod. 
Začnejo se z ukazom def, sledi ime in argumenti, 
ter konča z : Telo funkcije je zamaknjeno.
Vsaka funkcija vrača nek rezultat. Rezultate vračamo s skupkom
(tuple)
{{{
#!python
def zamenjaj(i, j):
    return (j, i)

i, j = 1, 2
i, j = zamenjaj (i, j)
print i, j
}}}

= Vaje programiranja v jeziku Python =

Znanje programskega jezika Python najlažje pridobimo z vajo. Namen domačih nalog
predstavljenih na tej strani je predvsem utrditi določene programske konstrukte,
ki se lahko rešijo v krajših programih, katere pravilnost delovanja ni težko
preveriti. Naloge se izdelujejo z orodji (Tortoise, Idle, PythonOcc), ki so predvidene za izdelavo projekta.
To pomeni, da je vsako vsako vajo, ki jo izdelujemo najprej preveriti na lokalnem
računalniku. Ko naloga št.??? deluje, jo shranimo na strežnik s Tortoise (Add, Commit) ter preverimo 
njeno delovanje. Pomembno je, da se vsaka dodeljena vaja shrani z malimi črkami. Ime datoteke je vaja, 
sledi številka naloge in končnica .py, vse brez presledkov.


Pravilnost vaših nalog shranjene na strežniku s Subversion lahko tudi sami preverite z
[http://lecad.fs.uni-lj.si/cgi-bin/pyclass.cgi Ocenjevalcem Python nalog], ki izvede test delovanja
s tem da pregleda izvorno kodo in požene kontrolni test. Pri kontroli
delovanja je možno, da ocenjevalec javi daj program ne deluje pravilno. Če pa
menite, da Vaš program deluje pravilno, je možno da je kontrolni test napačen ali
pa besedilo vaje ni dovolj jasno. V tem primeru odprite [http://trac.lecad.fs.uni-lj.si/vaje/newticket Nov Zahtevek]
in opišite težavo. Če želite odgovor tudi po e-pošti morate vpisati vaš poštni naslov v polje ''Preferences->Email address:''.


Izdelane vaje morajo pravilno delovati, kar preverjamo z [http://lecad.fs.uni-lj.si/cgi-bin/pyclass.cgi Ocenjevalcem Python nalog].
V primeru, da vaja ne prestane testa, ne bo upoštevana kot narejena. Zaželjeno je tudi, da naredimo
čim več vaj, ni pa potrebno izdelati več kot je zahtevano.


= Vprašanja za utrjevanje =
 1. Kdaj je potrebno napisati vrstico {{{import sys}}}
 2. Kako uporabljamo komentarje?
 3. Zakaj je zamikanje stavkov pomembno? Ali interpreter Pythona upošteva zamikanje?
 4. Koliko decimalk hrani tip {{{integer}}} in {{{float}}}?
 5. Kakšna je razlika pri prireditvi konstante spremenljivkama '''c''' in '''d'''
{{{
#!python
   c = 3/2;
   d = 3.0/2;
}}}  
 6. Kaj je funkcija dvopičja v kontrolnem stavku? Naštej kje vse ga je potrebno uporabiti.
 7. Koliko je numerična vrednost naslednjega izraza
{{{
#!python
   i = 7 / 3;
}}}
 8. Pod katerimi pogoji naslednja koda izpiše '''voda'''? Kako bi jasneje napisali 
napisane pogojne stavke z uporabo primernejšega zamikanja?
{{{
#!python
if temp < 0:
    print "led"
elif (temp < 100):
    print  "voda"
else:
    print "para"
}}} 
 9. Kaj izpiše naslednja koda?
{{{
#!python
  x = 3;
  if(x):
     print "da"
  else:
     print "ne"
}}}
 10. Kaj bo izpisala naslednja koda?
{{{
#!python
  int i;
  for i in range(3):
    print "a"
  print "b"

  print "c"
}}}
 11. Koliko elementov vsebuje polje oz. vektor '''a'''? Kateri je prvi element? Kateri je zadnji?
{{{
#!python
  a = [1,2,3,4,5];
}}} 
 12. Kaj je narobe v naslednjem izvlečku kode?
{{{
#!python
  a = [];
  for i in range(5):
    a[i] = 0;
}}}
 13. Kateri so štirje pomembni deli funkcije? Katere tri mora klicoči program poznati?


= Domače naloge =

== vaja1 ==
Napiši program, ki zahteva vnos dveh celih številk z dvema {{{input()}} in nato izpiše njuno vsoto.

== vaja2 ==
[http://en.wikipedia.org/wiki/Gaussian_quadrature Gaussovo kvadratura] naj vpraša za meji integriranja funkcije f(x) = 2x^4^- x^3^ +1
in rezultat izpiše na zaslon. Uporabite 4 točkovno kvadraturo.


== vaja3 ==
Izdelaj program ki izpiše naslednje zanke:
{{{
#!python
for i in range(0, 10, 2):
	print i

for i in range(100, 0, -7):
	print i

for i in range(1, 10)
	print i

for i in [2*x for x in range(2,50)]:
    print i
}}}
Razjasni si, kako te zanke delujejo in program popravi tako, da
bodo v zanki uporabljeni while z operatorji +=, -=, *=

== vaja4 ==
Napiši program ki izpiše ta trikotnik:
{{{
        *
        **
        ***
        ****
        *****
        ******
        *******
        ********
        *********
        **********
}}}    
Ne uporabi desetih print ampak uporabi zanko.
{{{
#!python
for i in range(10):
   # Več stavkov
   # gre lahko tukaj
}}}

== vaja5 ==
Izpiši v zanki cela števila od 1 do 10 in njihove kvadrate.
{{{
	1	1
	2	4
	3	9
	...
	10	100
}}}

== vaja6 ==
Stavek '''for''' je prav zaprav, okrajšava za stavek '''while'''.

Predelaj program, ki izpiše naslednjo zanko:
{{{
#!python
for i in range(10):
    print "i je %d" % i
}}}
z uporabo stavka '''while''', ki ima naslednjo obliko
{{{
#!python
while(pogoj):
    # vpiši stavek za povečanje števca in izpis
}}}
Napotek: V primeru da se nam program ''obesi'' v neskončni zanki,
ga prekinemo s pritiskom na crtl-C


== vaja7 ==
Pretipkaj in poženi naslednji program:
{{{
#!python

print "stavek 1"
printf "stavek 2"
for i in range(10):
    print "stavek 3"
    print "stavek 4"
print "stavek 5"
}}}
Program ne naredi nič posebnega. Z njim želimo le pojasniti vpliv
zamikanja v zanki in dobiti željen ''potek programa''. 


== vaja8 ==
Pretipkaj in poženi naslednji program:
{{{
#!python
print "zacetek programa"

for i in range(3):
    print "i je %d" % i
    for j in range(5):
        print "i je %d, j je %d" % (i, j)
    print "konec v zanki i = %d" % i

print "konec programa"
}}}
Tudi ta program ne naredi kaj dosti koristnega. Želi pokazati, kako zanke
delujejo in kako jih ''gnezdimo''. V vaji 4 je potrebno uporabiti prikazani
način dvojne zanke.

== vaja9 ==
Program naj prebere štiri cele številke in izpiše povprečno vrednost kot realno številko.

== vaja10 ==
Program naj prebere vrednost x, izračuna kvadrat prebranega števila (x^2^) in  ga izpiše na zaslon.
Izdelaj podprogram sqr(x).
 
== vaja11 ==
Program naj prebere vrednost x in n, kot celi števili. Izdelaj podprogram power(x, n), ki izračuna n to potenco 
števila x in jo izpiše na zaslon.

= Pogojni stavek in zahtevnejše zanke =

== vaja20 ==
Napiši program, ki z zanko in pogojnim stavkom ugotovi, koliko števil od 1 do 10 je večjih od 3 in seveda
izpiše rezultat 7.

== vaja21 ==
Program naj poleg številk od 1 do 20 izpiše še ali je liha ali soda v obliki
{{{
#!rst
.. code-block:: python

 1 je liha
 2 je soda
 3 je liha
 ...

Napotek: Uporabi operator ``%``
}}}

== vaja22 ==
Izdelaj program, ki izpiše v katero smer se je 2D točka največ premaknila, glede na
koordinatno izhodišče. Možni odgovori so:
 - levo
 - desno
 - gor
 - dol
Za prebrano točko 2 1 bo program odgovoril ''desno''.

Program naj vpraša za koordinato točke z ukazom:
{{{
#!python
x = input("Pomik v smeri x:")
y = input("Pomik v smeri y:")
...
}}}

== vaja23 ==
Tako kot v vaji 22 naj dodatno še izpiše v kater smer se je premaknila. S tem da 
se najprej izpiše večji pomik in nato manjši. Za prebrano točko 2 1 bo program odgovoril {{{desno gor}}}.

== vaja24 ==
Napiši program, ki izpiše prvih 7 pozitivnih števil in njihovo faktorielo (fakulteto). (Faktoriela 1 je 1, 
faktoriela 2 je 1*2=2, faktoriela 3 je 1 * 2 * 3 = 6, faktoriela 4 je 1 * 2 * 3 * 4 = 24, itd.)

== vaja25 ==
Program naj izračuna prvih 30 [http://sl.wikipedia.org/wiki/Fibonaccijevo_%C5%A1tevilo Fibonaccijevih števil].
Vsaka Fibonaccijeva številka je vsota prejšnjih dveh števil F(n) = F(n-1) + F(n-2), F(0) = 1, F(1) = 1.
Izpis naj bo v obliki:
{{{
 1 + 1 = 2
 1 + 2 = 3
 2 + 3 = 5
 3 + 5 = 8
 5 + 8 = 13
...
}}}

== vaja26 ==
Napiši program ji za podano število izpiše {{{je praštevilo}}} ali {{{ni praštevilo}}}. 
[http://sl.wikipedia.org/wiki/Pra%C5%A1tevilo  Práštevílo] je naravno število n > 1, če ima natanko dva pozitivna delitelja (faktorja), število 1 in samega sebe kot edini prafaktor. 

== vaja27 ==
Pohitri {{{vaja26}}} z dejstvom, da razen 2 nobeno sodo število ni praštevilo. Glej {{{vaja21}}}.

== vaja28 ==
Napiši program, ki tabelira poštevanko od 1 do 10, tako da izpiše vse skupaj v 10 vrsticah v
obliki:
{{{
1*1=1 1*2=2 1*3=3
...
10*1=1 10*2=20 ...
}}}

Za izpis ki ne gre v novo vrstico lahko uporabite vejico na koncu print ukaza. Na primer:
{{{
#!python
       ...
       print "%d*%d=%d" % (i,j,j*i),
    ...
}}}

== vaja29 ==
Za dan vektor {{{B[7]}}} uredi števila po velikosti od najmanjšega do največjega in jih zapiši v vekotor v
naslednji obliki -> {{{B[min]...B[max]}}}. S pomočjo for zanke izpiši vrednosti urejenega vektorja {{{B}}} 
na zaslon po vrsticah od najmanjšega do največjega.
{{{
#!python
  B = [3.3, -23.2, -4.5, 56.0, 45.5, 69.9, 40.5]
}}}

== vaja30 ==
Za matriko {{{A[25]}}} podano v vaja46 določi mesto maksimalnega števila in vrednost elementa izpiši na zaslon.

== vaja31 ==
Na zaslon izpiši [http://en.wikipedia.org/wiki/Pascal's_triangle Pascal-ov trikotnik] ([http://sl.wikipedia.org/wiki/Pascalov_trikotnik Pascal's triangle]) za 8 vrstic v spodaj prikazani obliki.

{{{
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
}}}

Če v ukazu print ne želimo prehod v novo vrsto dodamo na koncu vejico!

= Nizi, vektorji, matrike =

== vaja40 ==
Program iz vaje 28 priredi tako, da bo se zmnožek najprej predizračunal v polje
{{{
#!rst

.. code-block:: python

  a[]

in nato naj program vpraša za dve števili, ter izpiše rezultat, ki ga vzame iz polja ``a[]``.
}}}

== vaja41 ==
Napiši program ki bo v polje števil nadomesitil z njihovnimi kvadrati. Program naj vpraša
kateri indeks iz polja želimo in naj izpiše vrednost v polju. S stavkom if mora
tudi kontrolirati meje indeksov. Indeksi se seveda začnejo z 0.
{{{
#!c
  a = [1, 2, 9, 33, 22, 11, 3, 4, 3, 55, 
             66, 33, 22, 22, 33, 54, 5, 6, 7, 
             8, 223, 34]
}}}


== vaja42 ==
Za podano kvadratno matriko {{{a[16]}}} in vektor {{{x[4]}}} 
{{{
#!rst
.. code-block:: python

     a    =     [1, 2, 3, 4, 
                 0, 1, 2, 3,
                 2, 3, 4, 5,
                 3, 2, 2, 1]

napiši program, ki prebere štiri vrednosti in izpiše zmnožek matrike 
in vektorja '''b'''='''A'''*'''x''' s stavkom

.. code-block:: python

  print "%.1f %.1f %.1f %.1f\n" % (b[0], b[1], b[2], b[3])

}}}
Številke ločene s presledkom v eni vrstici lahko preberemo z ukazom
{{{
#!python
x = [eval(s) for s in raw_input().split(" ")]
}}}


== vaja43 ==
Program naj prebere datoteko. Prvo število je n, drugo število je št. delitev div, nato pa
prva dva stolpca sta x in y točke p0, druga dva stolpca sta (x1, y1) točke p1,
ter zadnji stolpec je pretok q.
{{{
8 1
00 00 06 00 0
06 00 14 00 -1
14 00 20 00 0
20 00 20 10 0
20 10 14 10 0
14 10 06 10 1
06 10 00 10 0
00 10 00 00 0
}}}

Datoteko preberite v spremenljivke
{{{
#!python

 p0[], p1[], q[]
 n, div
}}}
in vsako vrstico v zanki izpišite z naslednjim formatnim stavkom:

{{{
#!python
   print "%4.1f %4.1f %4.1f %4.1f %4.1f "  % ( p0[2*i], p0[2*i+1], p1[2*i], p1[2*i+1], q[i]  )
}}}
prve in druge točke elementa ter q.

Rešitev:
{{{
#!python
f= open("vaja43.dat", "r")
lines = f.readlines()
n, div = [eval(s) for s in lines[0].split(" ")]
print n,div
p0 = []
p1 = []
q = []
for i in range(8):
    x0,y0,x1,y1,qi=[eval(s) for s in lines[1+i].split(" ")]
    p0.append(x0)
    p0.append(y0)
    p1.append(x1)
    p1.append(y1)
    q.append(qi)
    print "%4.1f %4.1f %4.1f %4.1f %4.1f "  % ( p0[2*i], p0[2*i+1], p1[2*i], p1[2*i+1], q[i]  )
f.close()
}}}

== vaja44 == 
Za podano kvadratno matriko {{{A[]}}} velikosti 5x5, ki je podana kot seznam,
zmanjšaj diagonalne elemente za vrednost 1 in 
spremenjene diagonalne elemente matrike {{{A}}} s pomočjo for zanke izpiši na zaslon. 
{{{ 
#!python
A =  [3, 5, 90, 2 ,1, 
      1, 71, 59, 5, 5, 
      1, 2, 3, 54, 2, 
      12, 56, 32, 11, 1, 
      34, 56, 78, 45, 12]
}}}

Pri ukazu print lahko na koncu ukaza uporabimo vejico in s tem zagotovimo, 
da izpis ne gre v novo vrsto. Ni pa to nujno za to nalogo.

== vaja45 ==
Polje {{{a[]}}} iz vaje 41 prepišite v matriko {{{b[]}}}
velikost 8x3. S tem sa so elementi, ki manjkajo postavljeni na 0.
Vrstice izpišite na eno decimalko natančno.

== vaja46 ==
Za podano kvadratno matriko {{{A}}} zmanjšaj diagonalne elemente za vrednost 1.1, prepiši 
enodimenzionalno  A v seznam B, ki ga prav tako računamo kot matriko 5x5 in
izpišemo z dvojno zanko na zaslon.
{{{
  A = [3.3, 5.2, 90.5, 2.3 ,1.1,
       1.9, 71.0, 59.5, 5.3, 5.5,
       1.0, 2.2, 3.5, 54.3, 2.2,
       12.4, 56.1, 32.2, 11.4, 1.6,
       34.8, 56.4, 78.9, 45.3, 12.3
      ]
}}}

== vaja47 ==
Za izračun Pascal-ovega trikotnika (glej vaja31) uporabi podprogram pascals_triangle(n), kjer je n=8.
Vsako vrstico Pascal-ovega trikotnika zapiši v vrstico matrike P[64]. Prazna mesta matrike postavi
na vrednost 0. Izpiši matriko na zaslon (Uporabi for zanko).
Primer izgleda izpisa ene vrstice:
{{{
#!python
  print "%d %d %d %d %d %d %d %d" % (P[0], P[1], P[2], P[3], P[4], P[5], P[6], P[7], P[8])
}}}


= Podprogrami =
== vaja60 ==
Predelajte program za množenje matrike z vektorjem iz vaje 42, tako da boste
pred izpisom uporabili klic podprograma s stavkom
{{{
#!python
b = mat_vec4(a, x)
print "%.1f %.1f %.1f %.1f" % (b[0], b[1], b[2], b[3])
}}}

== vaja61 ==
Predelajte program vaje4 tako, da boste napisali podprogram, ki ga boste klicali
v naslednji zanki
{{{
#!python
for i in range(10):
    print_stars(i)
}}}


== vaja62 ==
Napišite podprogram {{{def celsius(fahrenheit):}}}, ki pretvori Fahrenheitove stopinje v Celsiusove. 
Formula za pretvorbo je °C = 5/9 * (°F - 32). Program naj naprej vpraša za
stopinje F in nato na decimalko natačno izpiše vrednost v Celzija. Zapomnite si, da
celoštevilčni izraz 5/9 da rezultat 0, zato ne smete uporabiti celoštevilčnega deljenja.

== vaja63 ==
Stavek 
{{{
#!python
from random import randint

r = randint(1,6)
}}} 
vrne naključno številko med 1 in 6. 
Izdelajte program, ki simulira metanje kocke. Izdelajte program, ki simulira zaporedno
metanje dveh kock in izriše histogram za 100 metov v (približno) taki obliki:
{{{
#!rst
::

 2: 2    **
 3: 5    *****
 4: 4    ****
 5: 10   **********
 6: 15   ***************
 7: 28   ****************************
 8: 12   ************
 9: 9    *********
 10: 7   *******
 11: 5   *****
 12: 3   ***

Prva številka pomeni vsoto pik na obeh kockah, druga številka pa pomeni koliko
krat se je dogodek zgodil, kar je tudi grafično narisano z podprogramom iz vaje 23.

Napotek: Pogled v navodila za funkcijo rand vam bo razkril, da je 
potrebno vklučiti header ``<stdlib.h>`` in povezovati z ``-lc``.
}}}

== vaja64 ==

Izdelajte podprogram za linearno interpolacijo. Program naj vpraša za dve
točki (x,,0,,,y,,0,,) in (x,,1,,,y,,1,,) ter mesto na osi ''x'' za katero
želimo vrednost ''y''. Npr. za 
{{{
0
0 
1
1 
0.5
}}}
 mora vrniti 0.5.
Podprogram naj ima naslednji prototip:
{{{
#!python
def linear_interpolation(x, p0, p1):
}}}
s tem da sta točki p0 in p1 seznama 2D


== vaja65 ==
Podprogram za parametrizacijo daljice naj izpiše koordinato glede na
parameter ''t'', ki je v mejah od 0 do 1. Podobno kot pri vaji 64 preberemo
točki (x,,0,,,y,,0,,) in (x,,1,,,y,,1,,) in parameter ''t''. Prototip
{{{
#!python
def linear_interpolation(t, p0, p1)
}}}
naj izpiše točko s formatom "%.1f %.1f" % (x,y). Prednost parametrične interpolacije
je v tem, da deluje tudi za navpično daljico. Npr.
{{{
0
0
0
2
0.5
}}}
izpiše 0.0 1.0 

Ko je parameter t=0 se izpiše začetna točka. Pri t=1 pa končna.
Parametrična oblika zapisa je pojasnjena na http://mathworld.wolfram.com/Line.html


== vaja66 ==
Podobno kot v vaji 65 izdelajte podprogram, ki za parameter t v mejah
od -1 do 1 izpiše točko med podanima točkama.
Ko je parameter t=-1 se izpiše začetna točka. Pri t=1 pa končna. Za t=0 se izpiše točka na sredini.

== vaja67 ==
Napiši podprogram decToBin(x), ki poljubno vrednost celega števila x prebranega iz zaslona pretvori
v binarni zapis in vrednost izpiše na zaslon.
Primer:
||25||:2||
||12||1||
||6||0||
||3||0||
||1||1||
||0||1||

Ostanke deljenja decimalnega števila izračunanega po zgornjem primeru preberemo v nasprotnem vrstnem redu.
Za zgornji primer dec: 25 -> bin: 11001.
Uporabi operator %. (Primer: 25%2 = 1)!


= Delo z datotekami =

== vaja80 ==
Program naj prebere datoteko '''vaja80.dat''', ki vsebuje seznam celih številk in izpiše njihovo vsoto. 
V prvi vrstici je število celih števil ki sledijo v naslednjih vrsticah. Primer:
{{{
4
13
23
21
11
}}}
Za ta primer mora program izpisati 72. Število vrstic v datoteki {{{vaja80.dat}}} je lahko največ 100.


== vaja81 ==
Podobno kot v vaji 80 preberite datoteko '''vaja81.dat''' s tem da seštevek sproti izpisujemo.

== vaja82 ==
Preberi datoteko {{{vaja82.dat}}} v kateri sta zaporedno zapisani dve 4x4 matriki. Na primer:
{{{
1 2 3 4
5 6 7 8
9 0 1 1
1 2 2 2
1 1 1 1
1 1 1 1
1 2 5 6
3 4 5 2
}}}

Program naj prebere datoteko v dve matriki in nato sešteje obe matriki v novo matriko (matrike seštevamo
po elementih). Ko imamo novo matriko naj program vpraša kateri element matrike želimo izpisati in sicer i-to vrstico
in j-ti stolpec (npr. i=1 in j=3 -> 9) in element i,j izpiše na zaslon. 


== vaja83 ==
Program naj prebere iz datoteke '''vaja83.dat''' matriko velikosti ixj in izpiše element {2, 3}. Format datoteke je
{{{
4 5
1 2 3 4 5
4 5 5 6 6
4 4 4 99 4
6 7 7 8 1
}}}
V prvi vrstici piše število vrstic in število kolon matrike. Izpisal pa bi 99.


== vaja84 ==
Matriko iz tako kot pri vaji 83 preberemo iz datoteke '''vaja84.dat''' in
izpišemo v transponirani obliki kot cela števila.
Matriko celih števil dinamično alocirajte z malloc.

== vaja85 ==
Matriko iz tako kot pri vaji 83 preberemo iz datoteke '''vaja85.dat''' in 
Vse elemente matrike kvadriramo in zapišemo v datoteko  '''vaja85.rez''', v istem
formatu celih števil. 

= PythonOCC =

== vaja 120 ==
S pomočjo štirih točk v prostoru izdelaj štrikotnik s stranico a. Vse točke naj imajo enako z os.
Površino izvleči v smeri vektorja vec{v}, ki ni enak vektorju normale izvlečene površine.
Vektor vec{v} in stranico a podamo programu na začetku. 

== vaja 121 ==
V izhodišče lokalnega koordinatnega sistema postavite kocko s stranico a. Na sredino zgornje ploskve
postavite valj premera r, v smeri normale površine na katero je valj postavljen.
Uporabite funkciji:
{{{
#!python
BRepPrimAPI_MakeBox(...) #CAD model škatle
BRepPrimAPI_MakeCylinder(...) #CAD model valja
}}}

== vaja 122 ==
Izdelajte mrežo iz točk P1(-10, -10, 0), P2 (-10, -20, 0) in P3(10, -10, 0) in jo prezrcalite okoli osi X.
Za vsako mrežo posebej izdelajte prizmo (torej dve prizmi) in ju različno obarvajte (display.DisplayColoredShape(myShape, 'GREEN')).
{{{
#!python
P1 = gp_Pnt(x, y, z) #definiranje točke v prostoru

##Definiranje barve 3D modela -- myShape -- zelena barva
display.DisplayColoredShape(myShape, 'GREEN')
}}}

== vaja 123 ==
Vajo131 izdelajte na naslednji na?in:
* Štirikotnik narišemo z dvema točkama, ki jih zrcalimo preko x-osi, ter izvle?emo v smeri vektorja normale površine!
* Na začetku naj nas program vpraša, pod kakšnim kotom izvlečemo valj!
* Barva kocke naj bo rumena, barva valja pa modra (npr. display.DisplayColoredShape(myShape, 'GREEN')).
{{{
#!python
#Določevanje vektorja v prostoru
aVector = gp_Vec(myWidth , myThickness , myHeight)
}}}

== vaja 124 ==
Izdelajte kocko s stranico a (uporabite funkcijo BRepPrimAPI_MakeBox). Na vseh robovih kocke izdelajte zaokrožitve velikosti a/10.
{{{
#!python
#Primer dodajanja zaokrožitev na CAD model myBody
# Telo: Dodamo zaokrožitve (fillet)
mkFillet = BRepFilletAPI_MakeFillet(myBody.Shape())
topology_traverser = Topo(myBody.Shape())
for aEdge in topology_traverser.edges():
    mkFillet.Add(myThickness / 12. , aEdge)
myBody = mkFillet.Shape()
}}}

== vaja 125 ==
Izdelajte valj tako, da osnovno površino izdelate z uporabo krožnih lokov.
Uporabite funkcijo:
{{{
#!python
aPnt2 = gp_Pnt(x, y, z) #definiranje točke v prostoru
GC_MakeArcOfCircle(aPnt2,aPnt3 ,aPnt4) #aPnt spremenljivke predstavljajo točke v prostoru
}}}
Kocko izrišite v rjavi barvi (primer spremembe barve display.DisplayColoredShape(myShape, 'GREEN')).