[[PageOutline]] = Python = Python je splošno uporaben programski jezik. Prednosti tega jezika so: - Berljivost kode, - relativno enostavna sintaksa, - ter deluje na vseh večjih platformah (Windows, OS X, Linux). Ena od pomembnih lastnosti Pythona je tudi dejstvo, da je Python interpreterski jezik (podobno kot Matlab). To pomeni, da ko skripto, napisano v tem jeziku, poženemo, računalnik kodo najprej interpretira in šele nato dejansko požene. Posledično je popravljanje in preizkušanje kode zelo enostavo, vendar pa je zato izvajanje same kode opazno počasnejše kot npr. v primerjavi v C oz. C++ jeziku napisanimi skriptami. (omenjena predstavnika nista interpreterska jezika, temveč se ju prevaja v strojno kodo, katera se ob zagonu prevede v samostojno zaženljivo aplikacijo/program. Primer prevedene kode so programi s končnicami .exe v Windowsu). == 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->Default Source Encoding->UTF-8. 3. Če bo program izpisoval slovenske črke je potrebno na začetku programa kot komentar dopisati vrstico {{{#!python # -*- coding: utf-8 -*- }}} kot je to razvidno v [#Drugiprogram naslednjem primeru]. 4. Shranimo datoteko z ukazom File->Save->hello.py 5. Poženemo skript z F5 ali Run->Run Module == Drugi program == Jezik nekoliko bolje predstavimo z drugim programom, ki vsebuje funkcijo in bere {{{ #!python # -*- coding: utf-8 -*- # drugi program import math def ploscina(d): return math.pi*d**2/4 d = float(input("Vnesi premer kroga: ")) print (u"Ploščina kroga je %.2f" % ploscina(d)) }}} == SPREMENLJIVKE == Spremenljivke se uporablja zato, da lahko shranjujemo neke vrednosti na katere se lahko kasneje v programu sklicujemo. Spremenljivka je del spomina, kateremu pripišemo ime. Vrednost ji pripišemo z operatorjem "=". Imena spremenljivk so poljubna, vendar lahko vsebujejo le črke, števke in/ali podčrtaj(e), ter se en smejo začeti s števkami. Python je občutljiv na velike in male črke. ZANIMIVOST: V Pythonu lahko pripisujemo vrednosti spremenljivkam tudi verižno: {{{ #!python # -*- coding: utf-8 -*- # Primer verižnega pripisa vrednosti spremenljivkam a = b = 5 print('a = ' + str(a)) print('b = ' + str(b)) }}} === Tipi spremenljivk === Vse spremenljivke so nakako avtomatske. Torej so generirane ob prvi uporabi (na primer, predenj spremenljivki pripišemo neko vrednost v jeziku C++, moramo spremenljivko najprej deklarirati. V Pythonu to ni potrebno). 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 se lahko piše z enojnimi ali dvojnimi narekovaji 4. bool ali true/false označevanje, ki pa je prav za prav integer z vrednostmi 0 ali 1 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 v oglatih oklepajih [] 2. Slovarji {map} - dictionary - asociativni seznami s ključi za izbor 3. Terke (''tuple'') ali ''skupki'' fiksnih velikosti, ki se uporabljajo za pakiranje različnih osnovnih tipov v enem skupku. 4. Strukture (razredi) Kateri tip se je ob prireditvi podal lahko preverimo kot je prikazano v nalsednjem programu: {{{ #!python # Za ugotavljanje tipa spremenljivke uporabimo naslednji ukaz: type(spremenljivka) number = 5 number_f = 5.4 print("Tip spremenljivke number: ", type(number)) print("Tip spremenljivke number_f: ", type(number_f)) }}} === Pretvorba tipa === V Pythonu za pretvorbo tipa uporabljamo naslednje funkcije: int(x), float(x) in str(x). Njihova uporaba je prikazana v naslednjem primeru: {{{ #!python number = 9 print("Tip spremenljivke number: ", type(number)) number_f = float(number) print("Tip spremenljivke number_f: ", type(number_f)) number_s = str(number) print("Tip spremenljivke number_s: ", type(number_s)) }}} Opomba: V vseh primerih pretvorba tipa ni mogoča. === Matematika v Pythonu - matematični operatorji === Operirajo s spremenljivkami. Vsak programski jezik ima nabor teh stvari in se ne razlikuje od novejših jezikov. Ima python prav nekaj ''lepih'' operatorjev (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 priročnosti c = 1 + 2j # kompleksno # Operatorji na osnovnih tipih print ("i+1 = %.2f" % (i+1)) print ("a+i = %.2f" % (a+i)) print ("i/2 = %f" % (i/2)) # Po deljenju dobimo tip float print ("10//3 = %.2f" % (10//3)) # Po deljenju zaokrozi na celo stevilo (zaokrozi navzdol) print ("10 % 3 = ", (10 % 3)) # Izracunamo in izpisemo ostanek po deljenju (po deljenju z 3 v tem primeru) print ('5**2 = ', 5**2) # "**" je operator za potenco 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[3]=5 p = [] # prazen seznam b = [1,2,3,4,5] b[-1]=4 c = b[1:-1] # Operator obsega : (range) do predzadnjega! d = b[1:] # pa do zadnjega print (c, b[-1]) tel = {'jack': 4098, 'sape': 4139, 4098 : 'janez'} # slovar (asociativni seznam) ime = {4098 : 'jack'} print (tel['jack']) print (tel[4098]) # 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]) }}} Za vaje se ne uporablja knjižnice http://www.numpy.org/ saj lahko indekse za matrike preračunavamo tako, kot je prikazano na zgornjem primeru. 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. === Operatorji - nadaljevanje === Poznamo še druge vrste operatorjev: - Prireditveni operatorji ( +=, -=, /=, ...) - Boolovi operatorji (not, and, or, is, ... ) - Primerjalni operatorji (==, !=, <, >, >=, <=) {{{ #!python # -*- coding: utf-8 -*- ########################### # Prireditveni operatorji x = 2 x += 3 print('x += y --> x = x+y') x -= 3 print('x -= y --> x = x-y') x *= 2 print('x *= y --> x = x*y') x /= 2 print('x /= y --> x = x/y') x **= 2 print('x **= y --> x = x**y') x %= 2 print('x %= y --> x = x%y') ########################### # Boolov operator a = 2 b = 3 je_enako = a == b print(je_enako) ########################### # Primerjalni operatorji one = 1 two = 2 three = 3 print(one < two < three) ni_enako = two != three print(ni_enako) }}} == NIZI (ang. "String(s)") == Nizi so, skupek znakov ujeti med enojne ali dvojne narekovaje. === Združevanje nizov === V angleščini, združevanje nizov z operatorjem "+" imenujemo "concatenation". {{{ #!python hello = "Hello" world = 'World' hello_world = hello + ' ' + world print(hello_world) }}} === Multiplikacija nizov === Python pozna množenje nizov s številom. na tak način multipliciramo niz znakov poljubno-krat. {{{ #!python hello = "hello " ten_of_hellos = hello * 10 print(ten_of_hellos) }}} === Indeksiranje nizov === Do nekega poljubnega znaka niza lahko do-stopamo, če poznamo pozicijo tega znaka v nizu. To bomo pokazali na naslednjem primeru. Pri tem moramo biti pozorni na to, da Python šteje on 0 naprej ! {{{ #!python python = "Python" print("h " + python[3]) # Opomba: indeksiranje niza se prične z 0 p_crka = python[0] print(p_crka) }}} V primeru (zelo) dolgih nizov, se velikokrat izkaže za uporabno tako imenovano NEGATIVNO INDEKSIRANJE. Na tak način lahko štejemo pozicije znakov od konca niza proti začetku. {{{ #!python dolg_niz = "This is a very long string!" klicaj = dolg_niz[-1] print(klicaj) }}} === Rezanje niza (ang. "slicing") === Rezanje niza uporabljamo zato, da bi iz niza dobili poljubni skupek znakov. Sintaksa rezanja je podobna tisti od indeksiranja. {{{ #!python x = "Monty Python" monty = x[:5] # ta zapis je enak x[0:5]. Torej, tako 1., kot tudi 2. indeks lahko izpustimo print(monty) python = x[6:] print(python) }}} === "in" operator === Da bi lahko preverili, če neki niz vsebuje specifični znak/črko/pod niz uporabljamo operator "in". {{{ #!python x = "ime spremenljivke" print("ime" in x) # Izpise direktno Boolovo vrednost izraza y = "spremenljivke" in x print(y) }}} === Funkcija "len()" === Funkcijo len() uporabljamo, da bi ugotovili koliko znakov poljubni niz vsebuje. {{{ #!python # -*- coding: utf-8 -*- # Izpis prve polovice niza x x = ''' To je zelo dolg niz, katerega omejujejo trojni narekovaji ''' print(x[int(len(x)/2)]) # Opomba: Ugotovite zakaj je bilo v tem primeru uporabiti funkcijo int() in pa kako še bi lahko # prišli do istega rezultata brez funkcije int() ? }}} === Izničevanje prvotne funkcije narekovajev === Z znakom "\" (backslash) lahko narekovaje uporabimo le kot neki znak, kjer nas njihova funkcija, da definirajo niz, ne "omejuje" več. {{{ #!python print('The name of this ice-cream is "Sweeet\'n\'Tasty"') }}} === Osnovne metode z nizi === Python ima številne funkcije za operiranje z nizi. Te funkcije so shranjene v knjižnici nizov. Vse te funkcije so ŽE vgrajene v vsak niz znakov. Te funkcije oz. včasih znane tudi kot metode (ker so funkcije definirane v razredi. Več o tem kasneje) lahko uporabimo tako, da spremenljivki niza dodamo "." in nato še metodo. Do vseh možnih metod lahko v PyCharmu dostopamo tako, da se postavimo za "." in izvedemo ukaz "Ctrl" + "Space". Sicer nam vse te možnosti PyCharm večinoma že sproti prikazuje. Mogoče je smotrno omeniti še to, da vse te funkcije osnovnega stringa oz. niza NE SPREMENIJO, temveč le vrnejo NOV niz, kateri je bil modificiran. Do tega pride zato, ker nizov po tem, ko so definirani ni več moč spreminjati. {{{ #!python # -*- coding: utf-8 -*- monty_python = "Monty Python" print(monty_python) print(monty_python.upper()) # Primer, kako lahko osnovni string # zapišemo z velikimi črkami print(monty_python[3].lower()) #################################################################################### # Metoda za iskanje pozicije pod-niza pozicija = monty_python.find('ty') print(pozicija) pos = monty_python.find('z') print(pos) # Ker črke "z" v nizu ni, Python izpiše vrednost -1 ! #################################################################################### # Metoda replace() # To je metoda podobna funkciji "Search and replace" v Word urejevalniku niz = ''' The game's largely favorable reviews praised its fast-paced action and surround sound, but faulted its high difficulty curve, generic soundtrack, and lack of an online multiplayer mode. ''' print(niz) niz1 = niz.replace('and', 'or') print(niz1) #################################################################################### # Metode za brisanje presledkov na obeh straneh niza x = ' Hello World ' print(x.strip()) print(x.lstrip()) print(x.rstrip()) #################################################################################### # Metoda za preverjanje poljubne predpone line = 'Please have a nice day' print(line.startswith('Please')) # Izpisalo se bo "True" print(line.startswith('please')) # Izpisalo se bo "False" #################################################################################### # Razčlenjevanje in ekstrakcija data = 'From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008' atpos = data.find('@') # Ugotovimo na katerem mestu se nahaja znak "@" print (atpos) sppos = data.find(' ', atpos) # Drugi argument metode pove od katerega mest naprej naj išče print(sppos) host = data[atpos+1 : sppos] print (host) }}} === Nizi so nespremenljivi === {{{ #!python x = 'Ime' # x[0] = 'i' # Program bo na tej vrstici izpisal napako print(x) }}} === Formatiranje nizov === Da bi lahko združevali niz s spremenljivkami oz. njihovimi vrednostmi uporabljamo "%" operator (v ang. "modulo" operator). {{{ #!python x = 8 y = 8.77 ime = "Andrej" print("%s ima %d let. Danes se je v soli \nucil o decimalnih stevilih in je izracunal,\nda ima na danasnji dan natanko %.3f let." % (ime, x, y)) }}} == PODATKOVNE STRUKTURE == === Seznami (ang. "Lists") === Seznam je podatkovna struktura, katero lahko uporabimo za shranjevanje zbirke različnih delčkov informacij pod imenom ene spremenljivke. Seznami v Pythonu so bolj fleksibilni, kot v drugih jezikih. To pomeni, da v sezname v Pythonu lahko shranjujemo tudi različne tipe podatkov in ne le en sam tip, kot je to v večini drugih jezikov. {{{ #!python kvadrati = [1, 4, 9, 16, 25] # Naredimo nov seznam. Podatki so med sabo ločeni z vejicami print(kvadrati) print(kvadrati[1:len(kvadrati)-1]) # Tudi pri seznamih lahko uporabimo "rezanje" oz. "slicing", podobno, kot pri nizih }}} ==== Operacije s seznami ==== Seznamom lahko dodajamo nove elemente in jih tudi spreminjamo. To bomo pokazali na primeru. {{{ #!python # -*- coding: utf-8 -*- stroj_elementi = ['vijak', 'moznik', 'tlacna_posoda', "zobnik"] # Naredimo nov seznam print(stroj_elementi) stroj_elementi += ["vzmet", 'zvar'] # Prvotnemu seznamu dodamo še dva nova elementa print(stroj_elementi) stroj_elementi.append("sklopka") # Drugi način kako lahko dodajamo elemente seznamu je z metodo "append" print(stroj_elementi) stroj_elementi[-1] = "torna_sklopka" # Elementu na koncu seznama spremenimo vrednost (ime v tem primeru) print(stroj_elementi) stroj_elementi[1:3] = [] # Elemente na pozicijah seznama od 2 do 4 pobrišemo print(stroj_elementi) stroj_elementi[2] = ['planetno_gonilo', 'enostavno_plan_gonilo'] # Seznam povečamo za 1 elementa, pri tem pa 1 zamenjamo print(stroj_elementi) }}} ==== Metode v seznamih ==== Obravnavali bomo le nekaj osnovnih metod, katere praktično uporabo si lahko ogledate na primerih spodaj. {{{ #!python # -*- coding: utf-8 -*- # Kako izgraditi seznam iz nič ? seznam = list() # Definiramo prazen seznam seznam.append('Napetost') # Dodamo element v seznam seznam.append('35') seznam.append('3') print(seznam) # Sortiranje v seznamih seznam.sort() # Pogoj, da bo ta vrstica delovala je, da so vsi elementi seznama istega tipa (drugače seznama ne zna uredit) print(seznam) # Odstranitev poljubnega elementa iz seznama seznam.remove('Napetost') print(seznam) seznam.remove(seznam[1]) print(seznam) # Razcep niza v seznam abc = 'Niz s štirimi besedami' x = abc.split() # Če ločila (parametra metode split) ne definiramo, potem loči po presledkih print(x) y = abc.split('š') # Elemente ločimo glede na črke(o) "š" print(y) y0 = y[0].split() # Možno je tudi ločevanje po tem, ko smo prvič že ločili elemente print(y0) }}} ==== V Python vgrajene funkcije za delo s seznami ==== Obstaja veliko takih funkcij. Nekaj osnovnih je prikazano na primerih spodaj. {{{ #!python stevila = [3, 41, 12, 9, 74, 15] print(len(stevila)) print(max(stevila)) print(min(stevila)) print(sum(stevila)) print(sum(stevila)/len(stevila)) }}} ==== Matrike ==== Python matrik, kot jih poznamo iz matematike ne pozna. Tukaj bomo pokazali, kako je vseeno možno delati z "matrikami". Drugače, za lažje delo z matrikami in matematičnimi operacijami povezanimi z matrikami lahko uporabimo knjižnico Numpy, katere sicer pri vajah ne bomo obdelali. {{{ #!python # -*- coding: utf-8 -*- M = [1,2,3,4, # Definiramo matriko, ki je sicer seznam v 5,6,7,8, # v več vrsticah 9,10,11,12, 13,14,15,16, 17,18,19,20] # Naloga: Izpišite število 14 iz matrike i = 3 # Vrstica v kateri iščemo željeni element j = 1 # Stolpec v katerem iščemo željeni element print(M) print(M[i*4+j]) # Ta enačba je univerzalna za iskanje # elementov v poljubni matriki. Pri tem # moramo paziti na to, da faktor s katerim # množimo "i" ustrezno reguliramo glede na # to, koliko elementov je v vrsticah matrike }}} === Terke (ang. "Tuples") === - Terke so podatkovni tip skoraj identičen seznamom. - Ena večjih razlik med seznami in terkami je ta, da terk ne moremo spreminjat (elementov ne moremo dodajat, spreminjat oz. brisat iz terke). - Terke so v primerjavi s seznami bolj enostavni, kar se tiče pomnilnika maj "požrešni" in zahtevajo manj računalniške moči za delo z njimi - Ko delamo začasne spremenljivke v programih zato raje uporabljamo terke, kot pa sezname {{{ #!python # -*- coding: utf-8 terka = ('a', 'b', 'c', 'd') # Terke definiramo z navadnimi oklepaji print(terka) }}} ==== Terke in prirejanje ==== Terke lahko postavimo tudi na levo stran enačbe {{{ #!python # -*- coding: utf-8 -*- (x,y) = (4, 'fred') print(x) print(y) i,k = (5, 'fredi') # Načeloma nam na levi strani enačaja ni nujno uporabiti oklepajev print(i) print(k) }}} ==== Terke se lahko primerjajo ==== Če je prvi element obeh terk, kateri primerjamo enak, potem Python primerja naslednji element v vrsti. Torej, primerjava se izvaja glede na istoležne elemente terk, s tem, da imajo elementi z nižjimi številkami pozicij večjo "težo". {{{ #!python # -*- coding: utf-8 -*- print((0,1,2) < (0,5,2)) print((0,3,4)>(0,1,2000000)) print(('Jonas', 'Metka') > ('Marija', 'Marijan')) }}} === Slovarji (ang. "Dictionaries") === Slovarji so podatkovna struktura podobna seznamom. Slovarji se od seznamov razlikujejo tako, da se do posameznih elementov slovarjev dostopa prek "ključa" oz. kjučne besede in ne prek indeksa, kot je to pri seznamih. Ključ je lahko ali niz ali pa številka. Slovarje definiramo z zaviti oklepaji "{" in "}". {{{ #!python # -*- coding: utf-8 -*- # Naredimo nov slovar phone_book = {"John": 123, "Jane": 234, "Jerard": 345} # "John", "Jane" in "Jerard" so ključi oz. ključne besede print(phone_book) # Dodamo nov element v slovar phone_book["Jill"] = 345786 print(phone_book) # Odstranimo ključ, ter pripadajočo vrednost iz slovarja del phone_book['John'] print(phone_book) # Izpis tel. številke Jane print(phone_book["Jane"]) }}} ==== Metode v slovarjih ==== Obstaja veliko različnih metod za delo s slovarjih. Do vseh dostopnih metod lahko v PyCharmu dostopamo tako, da za piko uporabimo komando "Ctrl" + "Space". Tukaj bomo pokazali le kako uporabimo metode "keys()" in "values()", ter items(), ostale pa lahko raziščete sami. {{{ #!python # -*- coding: utf-8 -*- phone_book = {"John": 123, "Jane": 234, "Jerard": 345} # Naredimo nov slovar print(phone_book) print(phone_book.keys()) # S pomočjo metode "keys()" lahko dostopamo do vseh ključev v slovarju print(phone_book.values()) # S pomočjo metode "values()" lahko dostopamo do vseh ključem pripadajočih # vrednosti v slovarju ########################################################################### # Slovarji in terke d = dict() d['a'] = 2 d['b'] = 4 d['f'] = 56 print(' ') for (k,v) in d.items(): print (k, v) print(' ') seznam = d.items() print(seznam) print(sorted(seznam)) # Z uporabo v python vgrajene funkcije sorted() lahko posortiramo elementev v # novem seznamu elementov iz slovarja }}} ==== Ključna beseda "in" ==== Ključno besedo "in" se uporablja z namenom preverjanja, če seznam ali slovar vsebuje neki specifičen element. To lahko uporabljamo na enak način, kot smo jo pri nizih. {{{ #!python # -*- coding: utf-8 -*- seznam_stroj_elementov = ["moznik", "vijak", 'zobnik'] # Naredimo nov seznam print("vijak" in seznam_stroj_elementov) # Preverimo, če je element "vijak" prisoten v seznamu slovar_stroj_elementov = {"moznik": 5, "vijak": 16, 'zobnik': 6} # Naredimo nov slovar print("zobnik" in slovar_stroj_elementov.keys()) # Pri slovarjih iščemo po ključih, kar pomeni, da moramo dodati metodo "keys()" }}} == FUNKCIJE == Funkcije so priročen način, kako lahko razdelimo naš program v uporabne bloke kode, katera sprejema argumente (več o tem kasneje). Na tak način lahko naredimo program lažje berljiv in prek funkcij lažje ponovno uporabljamo kodo, shranjeno v funkcijah. Funkcije definiramo s ključno besedo "def".[[BR]] Python sicer pozna "vgrajene", ter od uporabnika definirane funkcije. Med prve spadajo recimo: print(), len(), int() itd. {{{ #!python # -*- coding: utf-8 -*- # Definiranje funkcije def hello_world(): #ime_nase_funkcije print("Hello, World!") # S tem, ko funkcijo definiramo, se funkcija še NE izvede for i in range(5): hello_world() # Funkcijo kličemo 5 krat # Funkcija se dejansko izvede s tem, ko jo kličemo po imenu }}} === Parametri in argumenti funkcije === Funkcije postanejo zelo uporaben del kode s tem, ko jim predpišemo (definiramo) parametre. Parametri delujejo kot ime spremenljivke za sprejet argument, katere se definira znotraj oklepajev na koncu imenu funkcije. {{{ #!python # -*- coding: utf-8 -*- # Najprej definiramo funkcijo, ter njen parameter: def foo(x): # x je parameter funkcije. Torej, ko funkcijo sami definiramo, definiramo tudi PARAMETRE in NE argumente # Parameter je torej spremenljivka, katero uporabimo v sami definiciji funkcije in predstavlja "ročko" # katera omogoča kodi v funkciji, da dostopa do ARGUMENTOV. print("x = " + str(x)) # Funkciji podamo argument, ter jo izvedemo foo(6) # V tem primeru je vrednost 6 argument, katerega smo podali funkciji in NE parameter ! # Še en primer funkcije, katera bo zahtevala argument: def square(x): print(x ** 2) square(4) square(5) square(10) }}} === Vračanje vrednosti funkcije === Da bi lahko izračunano vrednost funkcije pripisali neki spremenljivki, ukažemo funkciji, naj nam "vrne" ovrednoteno vrednost funkcije. Uporabljamo besedno zvezo "return". {{{ #!python # -*- coding: utf-8 -*- def sum_two_numbers(a, b): return a + b # Ukažemo, da naj funkcija vrne njen rezultat klicatelju c = sum_two_numbers(3, 12) # Ovrednoteno vrednost funkcije pripišemo spremenljivki "c" }}} === Privzeti parameter === Včasih se izkaže za uporabno, da določimo privzeto vrednost enega ali več parametrov funkcije. Posledica tega je, da lahko funkcijo kličemo z manjšim številom argumentov. {{{ #!python # -*- coding: utf-8 -*- def pomnozi(a, b = 2, c = 3): return a * b * c print(pomnozi(3, 47, 1)) print(pomnozi(3)) # Na tak način kličemo funkcijo s prvim argumentom, katerega smo predpisali, drugi pa ostane privzet print(pomnozi(a = 2, c = 9)) # Način, kako funkciji posredujemo le nekatere od argumentov }}} === Globalne in lokalne spremenljivke === Pogoji globalne in lokalne spremenljivke ustrezajo določenem dosegu spremenljivke v skripti ali programu. Globalna spremenljivka je tista, do katere je mogoče dostopati kjerkoli v programu, med tem, ko je lokana spremenljivka tista, do katere je mogoče dostopati le v nekem določenem (omejenem) okviru kode/programa. {{{ #!python # -*- coding: utf-8 -*- vsota = 6 def sum(x, y): vsota = x + y print("Lokalna vsota je: ", vsota) # Pokličemo funkcijo sum sum(2, 3) print("Globalna vsota je: ", vsota) }}} == 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 = int(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) }}} == RAZREDI IN UVOD V OBJEKTNO PROGRAMIRANJE == Razredi so temeljni gradniki v Pythonu. Podobno, kot z besedno zvezo "def" definiramo funkcijo, z besedno zvezo "class" definiramo razred. [[BR]] Torej kaj sploh je razred ? Razred je, preprosto povedano, logično združevanje podatkov, ter funkcij (slednje, ko so definirane v razredih, pogosto imenujemo tudi "metode"). V takem primeru z "logičnim združevanjem" mislimo predvsem na to, da v praksi, ko delamo z razredi, poskušamo v razrede združevati le tiste podatke in le tiste funkcije, kjer obstaja neka logična povezava med njimi (recimo, imamo razred Strojni_element, v katerem združujemo podatke o materialu, geometriji..., ter razne funkcije, recimo za preračun trdnosti itd. V ta isti razred pa ne bi vnesli podatkov o našem počutju, vremenu, ipd.). Teoretično namreč, v razrede lahko vnašamo bilo katere funkcije in kakršne koli podatke, vendar potem vse skupaj ne bi več imelo nekega smisla. Z razredi si poskušamo programiranje olajšati in ne otežiti. Poleg tega, velikokrat razredi temeljijo na objektih iz realnega sveta (recimo "Kupec", "Produkt", "Avto" ...). [[BR]] Kljub vsemu povedanem so razredi tehnika modeliranja oz. način, kako mislimo o programih. Torej, ko programiramo na tak način, to je z razredi in objekti, rečemo, da izvajamo "objektno orientirano programiranje". === First-class Everything === Guido van Rossum (človek, ki je zasnoval Python) je Python udejanil po načelu "fist-class everyting", kar v bistvu pomeni da vse objekte, katere je v jeziku mogoče poimenovati imeli enak status (npr. integerji, nizi, slovarji, razredi...). Torej, to pomeni, da se vse v Pythonu obravnava enako, torej, vse je razred. {{{ #!python # -*- coding: utf-8 -*- x = 5 print(type(x)) y = 5.45 print(type(y)) def f(x): return x+1 print(type(f)) import math print(type(math)) }}} Iz primera ugotovimo, da so tako funkcije, kot tudi tipi spremenljivk v bistvu zapisani v razredu oz. so del nekega razreda. === Razredi so "načrti" za izdelavo objektov iz razreda === Objekt združuje spremenljivke in funkcije v eno. Objekti dobijo svoje spremenljivke in funkcije iz razredov. Torej iz tega sledi, da so razredi v bistvu neke predloge oz. načrti za izgradnjo naših objektov, medtem, ko objekte, si lahko zamišljamo kot podatkovno strukturo, ki vsebuje tako podatke, kot tudi funkcije. {{{ #!python # -*- coding: utf-8 -*- class Moj_Razred: def foo(self): # Parameter "self" bomo obrazložili kasneje print("Pozdrav iz funkcije foo") moj_objekt = Moj_Razred() # Spremenljivka "moj_objekt" vsebuje/drži objekt razreda "Moj_Razred, katere vsebuje spremenljivke, ter "foo" funkcijo }}} === Dostopanje do spremenljivk znotraj objekta === Vrednosti spremenljivk definiranih znotraj razreda lahko za različne objekte/pripadnika (ang. "instances") istega razreda spreminjamo. Poglejmo si to na primeru: {{{ #!python class MyClass: def __init__(self): # self je instanca objekta self.variable1 = 1 self.variable2 = 2 def foo(self): print("Hello from the function foo") my_object = MyClass() # objekt je ustvarjen my_object1 = MyClass() my_object.variable2 = 3 # Spremenimo vrednost shranjene vrednosti spremenljivke variable2 print(my_object.variable2) print(my_object1.variable2) my_object.foo() # call method foo() of object MyClass print(my_object.variable1) }}} === Import modulov in funkcij === {{{ #!python # -*- coding: utf-8 -*- vsota = 6 def sum(x, y): vsota = x + y print("Lokalna vsota je: ", vsota) def sub(x, y): raz = x - y print("Lokalna razlika je: ", raz) if __name__ == '__main__': # Pokličemo funkcijo sum sum(2, 3) sub(6, 4) print("Globalna vsota je: ", vsota) }}} Če bi hoteli uporabit določeno funkcijo iz programa prog1, lahko je "importamo" v novem programu prog2 z ukazom import. {{{ #!python # Python scripta # -*- coding: utf-8 -*- from prog1 import sum x = 4 y = 5 sum(x, y) }}} == DELO Z DATOTEKAMI == Običajno je, da se delo programa shranjuje v datoteke. Najpogosteje so to branje vhodnih podatkov in izpisi rezultatov. Za manjše datoteke je najenostavneje prebrati celotno datoteko v eno spremenljivko, ki je ločena po vrsticah in jo naslavljamo z indeksom seznama. Primer takega načina je prikazan v vaji43. Pri pisanju se uporablja ukaz write, ki pa sprejme le tekst, zato je potrebno pretvoriti številčne izraze s funkcijo str() ali format(). Lahko pa uporabimo tudi formatni stavek, kot je to prikazano v naslednjem primeru: {{{ #!python i=1.2 f = open("rezultat.dat", "w") f.write("Rezultat = %d\n" % i); f.close() }}} Več podatkov v vrstici formatirano zapišemo s skupkom. {{{ #!python f = file("a.txt", "w") f.write("%d %d\n" % (1, 2)) f.close() }}} Realna števila pišemo namesto %d z %f oziroma %.3f za tri cifre za decimalno piko. = 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 == Napiši program, ki prebere tri realna števila podana v eni vrstici in jih izpiše seštete. Uporabite {{{ #!python a, b, c = ( float(x) for x in input.split() ) }}} == 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 spremeni tako, da bo namesto **for** uporabljal zanke **while** skupaj 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 {{{for}}} 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") print("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 cela števila v štirih vrsticah 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 v dveh vrsticah. 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 = float(input("Pomik v smeri x:")) y = float(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), end="") ... }}} == 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 preberemo z ukazom {{{ #!python x = [float(s) for s in 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 da so elementi, ki manjkajo postavljeni na 0. Vse vrednosti morajo biti izpisane na **eno decimalko natančno**. Končni izpis matrike naj bo v obliki: {{{ #!python b_11 b_12 b_1n b_21 b_22 b_2n ... b_m1 b_m2 b_mn }}} == 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 ] }}} '''Opomba:''' Nalogo je potrebno narediti brez uporabe Numpy knjižnice! == vaja47 == Za izračun [http://en.wikipedia.org/wiki/Pascal%27s_triangle 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])) }}} = Funkcije oz. 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])) }}} Podatke podane v eni vrstici preberete tako kot v vaji42! == 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. Izpis lažje dosežemo z operatorjem množenja kot je na primer: {{{ #!python ... i=6 sum=10 print(i,': ',sum, '*'*sum) }}} == 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 definiramo točki (x,,0,,,y,,0,,) in (x,,1,,,y,,1,,) in parameter ''t''. Vseh pet vrednosti (4 koordinate in parameter) naj se definira z uporabo {{{input()}}} funkcije, vsak posamezen input() naj sprejme največ po eno številko. Prototip funkcije ('''uporabite isto ime funkcije'''): {{{ #!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 enega celega števila x prebranega iz zaslona ( uporabite {{{input()}}} ) 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)! == vaja68 == [http://en.wikipedia.org/wiki/Gaussian_quadrature Gaussova 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. Če ne razumete [http://en.wikipedia.org/wiki/Gaussian_quadrature razlage] z Wikipedije si lahko dodatno razjasnite ta primer, ki je opisan v [raw-attachment:bflow.pdf:wiki:WikiStart priponki vaj RPK2008]. Integracija je torej enostavno seštevanje in množenje! = Delo z datotekami = == vaja80 == Program naj odpre datoteko '''vaja80.dat''', ki vsebuje seznam celih števil (v vsaki vrstici ena število), prebere in sešteje vsa števila ter izpiše njihovo vsoto. Primer oz. vsebina datoteke '''vaja80.dat''': {{{ 5 13 23 21 11 8 }}} Za ta primer mora program izpisati število 81. Število vrstic v datoteki '''vaja80.dat''' je lahko največ 100. Opomba: tudi '''vaja80.dat''' mora biti dodana na SVN. == vaja81 == Podobno kot v vaji 80 preberite datoteko '''vaja81.dat''' s tem da seštevek sproti izpisujemo (izpis seštevka 1. in 2. števila, v naslednji vrstici izpis seštevka (1. + 2. število) + 3. število itd.). Opomba: tudi '''vaja81.dat''' mora biti dodana na SVN. == 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. Opomba: Nalogo je potrebno narediti '''brez uporabe Numpy knjižnice'''. == vaja84 == Matriko iz tako kot pri vaji 83 preberemo iz datoteke '''vaja84.dat''' in izpišemo (na zaslon oz. terminal) v transponirani obliki kot cela števila. Oblika izpisa transponirane matrike naj bo enak vhodni datoteki, torej v obliki {{{ m n a_11 a_12 ... a_1n a_21 a_22 ... a_2n ... a_m1 a_m2 ... a_mn }}} == 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. Matriko tudi izpišite v tem formatu z uporabo 'print' funkcije. Opomba: tudi '''vaja85.dat''' mora biti dodana na SVN. = Razredi in objekti = == vaja90 == Napisi razred {{{ImaginarnoStevilo}}}. Ta naj vsebuje metodo {{{nastavi}}}, ki prejme dva argumenta: realnega in imaginarnega. Nato s pomočjo objekta izpiši imaginarno stevilo v obliki {{{Kompleksno stevilo = a + bi}}}, kjer {{{a}}} in {{{b}}} predstavljata realno in imaginarno število. Končni program naj vsebuje/uporabi naslednje vrednosti: - a: {{{5}}} - b: {{{81}}} Pomoč pri izpisu: V print() uporabi ukaz " sep='' " == vaja91 == Napiši razred {{{Kocka}}}, v katerem je definiran konstruktor ({{{__init__}}} funkcija), ki sprejme parameter {{{stranica_kocke}}} ter tako le z definiranjem objekta izpiši rezultat na zaslon v obliki {{{Volumen kocke je X cm^3}}}, kjer {{{X}}} predstavlja izračunan volumen kocke. Končni program naj vsebuje/uporabi naslednje vrednosti: - stranica_kocke: {{{4}}} Pomoč pri izpisu: V print() uporabi ukaz " sep='' " == vaja92 == Napiši razred {{{Lomljenka}}}, ki ima naslednji funkciji: - {{{dodaj(x, y)}}} za dodajanje točk in - funkcijo za izracun {{{dolzina()}}} lomljenke. Uporabi naslednje naslednje ukaze in vrednosti za klic objekta: {{{ #!python lomljenka = Lomljenka() lomljenka.dodaj(0, 1) lomljenka.dodaj(2, 1) lomljenka.dodaj(2, 0) print(lomljenka.dolzina()) }}} == vaja93 == Namesto funkcije {{{dolzina()}}} iz vaja92 izdelajte {{{obseg()}}}, ki poleg dolžine dodanih točk prišteje še dolžino med prvo in zadnjo točko ( -> sklenjena lomljenka). Izpis rezultata naj bo na **tri decimalke natančno**. Uporabi naslednje naslednje ukaze in vrednosti za klic objekta: {{{ #!python lomljenka = Lomljenka() lomljenka.dodaj(1, 2) lomljenka.dodaj(1, 3) lomljenka.dodaj(3, 3) lomljenka.dodaj(3, 0) print(...) # Izpis na tri decimalke natančno }}} == vaja94 == Napiši razred {{{Valj()}}}, ki sprejme dva vhodna argumenta {{{radij}}} in {{{visina}}}. Razred naj vsebuje tudi metodo {{{prostornina()}}}, ki vrne prostornino valja. Definiraj objekt z radijem 20 in višino 30. Nato s funkcijo {{{print()}}} izpiši prostornino omenjenega objekta. Za število pi vzemite vrednost 3.14. == vaja95 == Napiši razred {{{Pravokotnik()}}}, ki v konstruktorju (funkcija {{{__init__}}}) sprejme dva vhodna argumenta širino {{{a}}} in dolžino {{{b}}}. Omenjeni razred naj vsebuje dve metodi: - {{{jeInteger}}}, ki sprejme dva vhodna argumenta in vrne {{{True}}}, če sta vhodna argumenta tipa {{{integer}}}, in {{{False}}}, če je eden izmed vhodnih argumentov drugega tipa. - {{{povrsina}}}, ki najprej z metodo {{{jeInteger}}} preveri tipa argumentov {{{a}}} in {{{b}}}. Če argumenta nista tipa {{{int}}}, naj metoda vrne string **Napacen tip argumentov** (brez šumnikov!). Če sta argumenta tipa {{{int}}}, naj metoda vrne površino pravokotnika. Nato definiraj dva objekta: - pravokotnik1 z vhodnima argumentoma {{{a=12}}} in {{{b=15}}} - pravokotnik2 z vhodnima argumentoma {{{a="12"}}} in {{{b=15}}} {{{ #!python pravokotnik1 = Pravokotnik(12,15) pravokotnik2 = Pravokotnik("12",15) }}} Nato izpiši izhodne vrednosti metod {{{povrsina}}} za oba objekta na sledeč način: {{{ #!python print(pravokotnik1.povrsina()) print(pravokotnik2.povrsina()) }}} == vaja96 == Definiraj razred {{{Tocka}}}, ki v konstruktorju (funkcija {{{__init__}}}) sprejme koordinate {{{x}}},{{{y}}} in {{{z}}}. Nato definiraj metodo {{{koordinate}}}, ki vrne seznam. Vrnjen seznam vsebuje tri elemente: prvi element je koordinata x, drugi koordinata y in tretji koordinata z. Nato definiraj tri objekte razreda Tocka: - tocka1 s koordinatami x=1,y=0,z=0 - tocka2 s koordinatami x=2,y=0,z=0 - tocka3 s koordinatami x=3,y=0,z=0 na sledeč način {{{ #!python tocka1 = Tocka(1,0,0) tocka2 = Tocka(2,0,0) tocka3 = Tocka(3,0,0) }}} Nato definiraj nov razred {{{Krivulja}}}, ki vsebuje spremenljivko z imenom {{{seznam_tock}}}. Ta spremenljivka vsebuje prazen seznam. V razredu {{{Krivulja}}} definirajte tudi metodo {{{dodajTocko}}}, ki sprejme objekt razreda {{{Tocka}}} in ga doda v spremenljivko {{{seznam_tock}}}. Nato v istem razredu definiraj še metodo {{{tocke}}}, ki naredi iteracijo skozi seznam v spremenljivki {{{seznam_tock}}} in za vsak objekt razreda {{{Tocka}}} izpiše koordinate x,y in z. Primer izpisa metode {{{tocke}}} za zgornje točke je sledeč: {{{ 1 0 0 2 0 0 3 0 0 }}} Definiraj objekt razreda {{{Krivulja}}} z imenom {{{krivulja}}} in vanj s pomočjo metode {{{dodajTocko}}} dodaj točke {{{tocka1}}}, {{{tocka2}}} in {{{tocka3}}}. Nato pokliči metodo {{{tocke}}} na sledeč način {{{ #!python krivulja.tocke() }}} == vaja97 == Dedovanje v Pythonu pomeni, da lahko razred deduje in uporablja metode drugega razreda. Primer je prikazan spodaj {{{ #!python #A --> Razred(parent) #B --> Izpeljanirazred(child) class A: # Definiramo razred A _vrednost = 100 def __init__(self): print("Klicanje (parent) razreda A.") def A_metoda(self): print('Klicanje metode (parent) razreda A.') def doloci_lastnost(self, lastnost): A.a_vrednost = lastnost def dobi_lastnost(self): print("Lastnost (parent) razreda A :", A.A_vrednost) class B(A): # Izpeljani razred, vzamemo lastnosti iz (parent) razreda def __init__(self): print("Klicanje konstruktorja izpeljanega razreda B.") def B_metoda(self): print('Klicanje metode izpeljanega razreda razreda B.') c = B()# Objekt (child) izpeljanega razreda B c.B_metoda()# Izpeljani razred kliče svojo metodo c.A_metoda()# Izpeljani razred kliče metodo svojega (parent) razreda c.doloci_lastnost(200)#Izpeljani razred spet kliče metodo svojega (parent) razreda c.dobi_lastnost()# Izpeljani razred spet kliče metodo svojega (parent) razreda }}} Definiraj razred {{{GeometrijskaTelesa()}}}, ki vsebuje metodo {{{opis}}} in s pomočjo funkcije {{{print}}} izpiše sledeče besedilo "Ta razred definira geometrijsko telo". Nato definiraj razrede {{{Kvader}}}, {{{Krogla}}} in {{{Valj}}}, ki vse tri dedujejo metode razreda {{{GeometrijskaTelesa}}}. Nato definiraj objekte vseh treh razredov in preko njih pokliči dedovano metodo {{{opis}}} na sledeč način {{{ #!python kvader = Kvader() krogla = Krogla() valj = Valj() kvader.opis() krogla.opis() valj.opis() }}} == vaja98 == Definiraj razred {{{GeometrijskaTelesa}}}, ki v konstruktorju {{{__init__}}} sprejme spremenljivko {{{tip_geometrijskega_telesa}}}. V istem razredu definiraj tudi metodo {{{vrniTip}}}, ki vrne spremenljivko {{{tip_geometrijskega_telesa}}}. Nato definiraj štiri objekte omenjenega razreda na sledeč način {{{ #!python krogla = GeometrijskaTelesa('krogla') kvader = GeometrijskaTelesa('kvader') torus = GeometrijskaTelesa('torus') valj = GeometrijskaTelesa('valj') }}} Nato te objekte dodaj v seznam na sledeč način {{{ #!python geometrijskatelesa = [krogla,kvader,torus,valj] }}} Nato naredi iteracijo skozi omenjen seznam in v vsakem koraku s pomočjo metode {{{vrniTip}}} in funkcije {{{print}}} izpiši tip geometrijskega telesa v posameznem objektu. = PythonOCC = Linki: * [[wiki:PythonOcc|PythonOCC primeri]] * [[wiki:PythonOcc/primitives|primitivi]] in * [[wiki:OpenCascade|MakeBottleCAD(C++)]] V programih ne uporabljajte ukaza {{{input()}}}. Program naj že na začetku v oknu pravilno prikaže model. Ocenjevalec ne ocenjuje pravilnost programa ampak le prikaže posnetek zaslona posamezne vaje. == vaja120 == S pomočjo štirih točk v prostoru izdelaj štrikotnik s stranico a. Vse točke naj imajo enako koordinato z. Nato izvleči površino v smeri vektorja vec{v}, ki ni enak vektorju normale izvlečene površine (oz. izvlecite površino postrani). Vektor vec{v} in stranico a podamo programu na začetku. == vaja121 == Izdelajte kocko s središčem v izhodišču lokalnega sistema ter 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 }}} == vaja122 == Vajo 121 izdelajte na naslednji način: * Izdelajte kocko tako, da definirate površino (točke->rob->mreža->površina) in jo izvlecite. * Valj izdelajte prav tako z definiranjem površine in nato z izvlekom pod kotom alpha=30 in beta=40. {{{ #!python #Definiranje krožnice s pomočjo treh točk, skozi katere poteka krožnica Potek_roba_krog = GC_MakeCircle(tocka_na_krogu_1, tocka_na_krogu_2, tocka_na_krogu_3) Rob_krog = BRepBuilderAPI_MakeEdge(Potek_kroga.Value()) #Primer definicije vektorja za izvlek pod kotom import math Vektor = gp_Vec(math.cos(alpha*math.pi/180),math.cos(beta*math.pi/180), h) }}} * Barva kocke naj bo rumena, barva valja pa modra (npr. {{{display.DisplayColoredShape(myShape, 'GREEN'))}}}. == vaja123 == Izdelajte mrežo iz točk P1(-10, -10, 0), P2 (-10, -20, 0) in P3(10, -10, 0). Z izvlekom izdelajte prizmo ter jo 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')}}} }}} == vaja124 == 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 Oblika # Telo: Dodamo zaokrožitve zaokrozitev = BRepFilletAPI_MakeFillet(Oblika) anEdgeExplorer = TopExp_Explorer(oblika, TopAbs_EDGE) while anEdgeExplorer.More(): anEdge = topods.Edge(anEdgeExplorer.Current()) zaokrozitev.Add(Radij_1, anEdge) #zaokrozitev.Add(Radij_1, Radij_2, anEdge) anEdgeExplorer.Next() zaokrozitev.Build() oblika = zaokrozitev.Shape() }}} == vaja125 == [[Image(DN125_2.png, right, 103)]] [[Image(DN125_1.png, right, 100)]] Izdelajte 3D model steklenice (oblika steklenice je poljubna, primer je prikazan na sliki) z uporabo krožnega izvleka. {{{ #!python #Izdelava krožnega izvleka kr_izvlek = BRepPrimAPI_MakeRevol(Povrsina , Os) }}} Steklenico izrišite v rjavi barvi. {{{ #!python #primer spremembe barve display.DisplayColoredShape (myShape, 'GREEN') }}} Poglejte si '''color''' funkcijo ter prednastavljene barve v [http://github.com/tpaviot/pythonocc-core/blob/master/src/Display/OCCViewer.py#L419 OCCViewer.py] in Quantity_NOC_BARVA v [https://github.com/tpaviot/pythonocc-core/blob/master/src/SWIG_files/wrapper/Quantity.i#L136 Quantity.i] Možno je tudi RGB barvanje z RGB {{{barva=Quantity_Color(0.1, 0.8, 0.1)}}} {{{ #!python # Uvoz knjižnice, potrebne za rgb obarvanje. from OCC.Quantity import * from OCC.Display.OCCViewer import * # ctrl + desni miškin gumb na "OCCViewer" odpre OCCViewer.py. Tam poiščite funkcijo za rgb obarvanje, # katera nadomesti <'IME_BARVE'> v DisplayColoredShape() }}} == vaja126 == Izdelajte valj velikosti myHeight in radija R in ga postavite v izhodišče. Na valj postavite kocko s stranico A. Na kocki zaokrožite vse robove z radijem A/10. Kocko in valj združite s funkcijo: {{{ #!python #Združevanje dveh 3D modelov myBody = BRepAlgoAPI_Fuse(valj, kocka) }}} in izvozite v STEP format: {{{ #!python #Izdelava STEP datoteke from OCC.STEPControl import * step_writer = STEPControl_Writer() step_writer.Transfer(myBody, STEPControl_AsIs) status = step_writer.Write("valj-kocka.stp") }}} ter model prikažite na zaslonu. == vaja127 == Izdelajte preprosti model stenske ure, ki kaže uro 02:30. Stenska ura ima gaberitne mere premer ure 500mm, ter debelina ure 40mm. Minutni kazalci so dolžine 150mm, urni kazali pa dolžine 70mm. == vaja128 == Izdeljate preprosti model ločnega mostu s tremi loki. Dolžina celotnega mostu znaša 100m, višina znaša 30m, širina pa 6m. Ob cestišču poteka varnostna ograja. Namig: uporaba Boolove operacije odštevanja == vaja129 == Izdelajte model, prikazan na sliki. Klikni na sliko za povečavo. [[Image(vaja129.png, center, 400)]] == vaja130 == Izdelajte model, prikazan na sliki. Klikni na sliko za povečavo. [[Image(DN130.png, center, 400)]] == vaja131 == Izdelajte model, prikazan na sliki. Klikni na sliko za povečavo. [[Image(DN131.png, center, 400)]] == vaja132 == Izdelajte model, prikazan na sliki. Klikni na sliko za povečavo. [[Image(DN132.png, center, 400)]] == vaja133 == Izdelajte model, prikazan na sliki. Klikni na sliko za povečavo. [[Image(DN133.png, center, 400)]] == vaja134 == Izdelajte model, prikazan na sliki. Klikni na sliko za povečavo. [[Image(DN134.png, center, 400)]] == vaja135 == Izdelajte model, prikazan na sliki. Klikni na sliko za povečavo. [[Image(DN135.png, center, 400)]] == vaja136 == Izdelajte model, prikazan na sliki. Nato model izvozite v STL format, ter uvozite v modelirnik (SolidWorks, NX, Catia,...). Izpišite volumen kosa. Klikni na sliko za povečavo. [[Image(DN136.png, center, 400)]] == vaja137 == Izdelajte model, prikazan na sliki. Nato model izvozite v STL format, ter uvozite v modelirnik (SolidWorks, NX, Catia,...). Izpišite volumen kosa. Klikni na sliko za povečavo. [[Image(DN137.png, center, 400)]] == vaja138 == Izdelajte model, prikazan na sliki. Nato model izvozite v STL format, ter uvozite v modelirnik (SolidWorks, NX, Catia,...). Izpišite volumen kosa. Klikni na sliko za povečavo. [[Image(DN138.png, center, 400)]] == vaja139 == Izdelajte model, prikazan na sliki. Nato model izvozite v STL format, ter uvozite v modelirnik (SolidWorks, NX, Catia,...). Izpišite volumen kosa. Klikni na sliko za povečavo. [[Image(DN139.png, center, 400)]] == vaja140 == Izdelajte model, prikazan na sliki. Širina kosa je 140!. Nato model izvozite v STL format, ter uvozite v modelirnik (SolidWorks, NX, Catia,...). Izpišite volumen kosa. Klikni na sliko za povečavo. [[Image(DN140.png, center, 400)]] == vaja141 == Z zrcaljenjem preko X osi izdelajte poenostavljen IPE200 profil (poenostavljen pomeni, da je brez zaokrožitev). Dolžina IPE200 profila naj bo 200mm. 3D model IPE200 profila prikažite na zaslonu. == vaja142 == S pomočjo funkcije za izdelavo krožnega loka izdelajte polkrog z radijem R: {{{ #!python #Izdelava krožnega loka polkrog = GC_MakeArcOfCircle(aPnt1, aPnt2 ,aPnt3) }}} in ga nato prezrcalite preko X osi, da dobite cel krog z radijem R: {{{ #!python #Zrcaljenje preko X osi xAxis = gp_OX() aTrsf = gp_Trsf() aTrsf.SetMirror(xAxis) aBRepTrsf = BRepBuilderAPI_Transform(aWire.Shape() , aTrsf) }}} krog nato izvlecite v smeri vektorja vec, ki je 30° glede na X os (potrebno je določiti koordinate vektorja) in dolžine vecLength. Končen 3D model prikažite na zaslonu. == vaja143 == Iz tanke pločevine (1mm) izdelajte škatlo s stranico 10mm (definirati morate toliko oblik, kolikor je stranic), ki je na eni strani odprta. {{{ #!python #Izdelava stranice s funkcijo stranica = BRepPrimAPI_MakeBox(a, a, a) }}} Vse elemente združite v skupni sestav: {{{ #!python # Izdelava sestava sestav = TopoDS_Compound() aBuilder = BRep_Builder() aBuilder.MakeCompound (sestav) aBuilder.Add (sestav, stranica1) aBuilder.Add (sestav, stranica2) . .#za ostale stranice velja enako }}} in izvozite sestav v IGES formatu: {{{ #!python #Izdelava IGES datoteke sestav_iges = IGESExporter("sestav.iges") sestav_iges.add_shape(sestav) sestav_iges.write_file() }}} ter končen sestav prikažite na zaslonu. == vaja144 == Izdelajte modularni projekt sestavljen iz dveh PythonOcc modelov iz prejšnje in predprejšnje domače naloge. Skupni program vaja144.py naj uvozi (ukaz import) oba CAD modela, ki sta v ločenih python datotekah. Dopolnite prejšnji nalogi tako, da se vsak CAD model prikaže tako ločeno, kot tudi v skupnem modelu s tem, da vsak vsebuje pogojno izvajanje glavnega programa z {{{ #!python if __name__ == '__main__': level_of_detail = 1 # koda za izdelavo in prikaz modela }}} CAD modela naj imata kot argumente funkcije osnovne parametre in naj vrneta model za prikaz. Kot parametere vpeljite tudi {{{level_of_detail}}}, ki naj ima pri obeh modelih iz prejšnjih domačih nalog vsaj nivoja podrobnosti 0 in 1. Modele zaradi tega ustrezno dopolnite s podrobnostmi, ki si jih lahko izmislite, če vam manjkajo. Na primer: {{{ #!python def make_bottle(level_of_detail, myWidth, myThickness, myHeight): ... return aRes }}} Skupna postavitev modelov v glavnem modulu vaja144.py naj bo taka, da prvi model sledi eni od mer (parametra) drugega modela. == vaja150 == Uporabite [wiki:PythonOcc/elbow osnovo komolca] in izdelajte okvir šotora. [[Image(sotor.svg,right)]] Osnovne dimenzije naj bodo okoli 2m. Komolec in dodatne elemente ter cevi poenostavite, da ne bo notranjosti in jih zlijte v en sam kos ter nato izvozite v STL ter prikažite na vaši spletni strani kot model s knjižnico JSC3D. == vaja151 == Uporabite [wiki:PythonOcc/elbow osnovo komolca] in izdelajte okvir klopi. [[Image(klop.svg,right)]] Dolžina naj bodo okoli 1.5m. Višina 55cm. Komolec in dodatne elemente ter cevi poenostavite, da ne bo notranjosti in jih zlijte v en sam kos ter nato izvozite v STL ter prikažite na vaši spletni strani kot model s knjižnico JSC3D. == vaja152 == Uporabite [wiki:PythonOcc/elbow osnovo komolca] in izdelajte okvir šotora. [[Image(plezalnik.svg,right)]] Osnovne dimenzije naj bodo okoli 2m. Komolec in dodatne elemente ter cevi poenostavite, da ne bo notranjosti in jih zlijte v en sam kos ter nato izvozite v STL ter prikažite na vaši spletni strani kot model s knjižnico JSC3D. = PythonOCCT = Linki: * [[wiki:occt|PythonOCCT primeri]] == vaja200 == PythonOCC nalogo iz vaše prejšnje domače naloge predelajte za PyOCCT knjižnico. Model naj bo prikazan z uporabo funkcije {{{BasicViewer()}}} (na voljo v okolju PyCharm). == vaja201 == PythonOCC nalogo iz vaše prejšnje domače naloge predelajte za PyOCCT knjižnico. Program naj bo zapisan tako, da se bo ob zagonu programa ('Load Script') v SMITER okolju model prenesel oz. prikazal v modulu ''Geometry''. = SALOME (SHAPER modul) = V nadaljevanju so predstavljene naloge za uporabo v SALOME SHAPER modulu. Python ocenjevalec za takšne naloge ni primeren tako se bo uspešnost domačih nalog preverjalo na podlagi: * pregleda vsebine kode ter * delovanja programa (pogon skripte v SHAPER MODULU). Uporabne povezave: * [wiki:salome] - Razvojno okolje SALOME * [wiki:salome_shaper] - SHAPER primeri * [https://events.prace-ri.eu/event/896/sessions/2723/attachments/998/1676/SHAPER_AShortIntro_2.pdf Predstavitev SHAPER modula] * [https://docs.salome-platform.org/latest/gui/SHAPER/index.html SHAPER dokumentacija] * [https://www.youtube.com/channel/UCm7CSP3v1VF6brzmTlV9c3Q SHAPER primeri na Youtube] * [http://www.learnsalome.org/shaper/interactive_tutorial SHAPER interaktivni tutorial] == vaja300 == [[Image(vaja300.PNG, right, 500)]] Napišite program (.py skripto), katerega se lahko požene v SALOME, in ki izdela model, prikazan na sliki. Klikni na sliko za povečavo. Model naj bo narejen z uporabo izvleka v prostor + 2x izrez. '''Opomba''': Na risbi sta si stranici pod kotom (gledano s strani) vzporedni. Program naj vsebuje: * funkcijo '''osnovna_oblika''', ki naredi osnovno obliko modela z uporabo izvleka v prostor; * funkciji '''izrez_1''' in '''izrez_2'''. Vsaka izmed funkcij naj izvede enega izmed potrebnih izrezov; * funkcijo '''izracun_volumna''', ki izračuna ter vrne volumen modela (uporaba {{{return}}}), '''Opomba:''' Izračun volumna morate izpeljati sami (seštevanje posameznih "koščkov", odštevanje volumnov na podlagi izrezov ipd.). Neke splošne funkcije, ki bi sam izračunal volumen, v SHAPERju ni; * izpis volumna (enote prevzamimo, da so v {{{mm}}}, torej izpis volumna naj bo v {{{mm^3}}}. '''Opomba''': Ne pozabite na dokumentiranje funkcij ipd. Za preverjanje volumna, če vaša implementacija vrne pravilen rezultat, lahko preverite z dodatnim ukazom {{{ #!python from GeomAlgoAPI import GeomAlgoAPI_ShapeTools as ShapeTools result = koncni_model.defaultResult() # Vrne objekt tipa ModelAPI.ModelAPI_Result volumen = ShapeTools.volume(result.shape())) }}} {{{ #!comment Rezultat za volumen (na podlagi Solidworks modela): 36243.26 osnova = 41536 izrez_valj = 2412.74 izrez_kvader = 2880 }}}