From 8540f7ca17b029b12bee6d8bef1c3e8911d688a4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20Mo=C5=BEina?= Date: Wed, 2 Nov 2016 14:06:33 +0100 Subject: Text explaining modules and methods. --- .../problems/functions_and_modules/methods_sl.html | 388 +++++++++++++++++++++ .../problems/functions_and_modules/modules_sl.html | 251 +++++++++++++ python/problems/functions_and_modules/sl.py | 5 +- 3 files changed, 643 insertions(+), 1 deletion(-) create mode 100644 python/problems/functions_and_modules/methods_sl.html create mode 100644 python/problems/functions_and_modules/modules_sl.html diff --git a/python/problems/functions_and_modules/methods_sl.html b/python/problems/functions_and_modules/methods_sl.html new file mode 100644 index 0000000..676ca5d --- /dev/null +++ b/python/problems/functions_and_modules/methods_sl.html @@ -0,0 +1,388 @@ + + + + + + + + + + +

Kako kličemo metode

+ +

Funkcijam, ki smo jih srečevali doslej, smo, da so kaj naredile, morali dati + podatke, na katerih so delale. Funkcija len kot argument + zahteva seznam ali niz, katerega dolžino bi radi izvedeli. Funkcija + input kot argument želi niz z vprašanjem, ki bi ga radi + zastavili uporabniku. Razen argumentov, ki jih podamo, te funkcije nimajo + drugih podatkov (vsaj ne, da bi mi vedeli zanje).

+ +

Ko smo se učili o seznamih, pa smo mimogrede naleteli na neko nenavadnost: + za dodajanje novega elementa v seznam nismo poklicali funkcije, ki bi ji + podali seznam in element (na primer append(imena, "Ana")), + temveč smo morali napisati ime seznama, ki mu je sledila pika in + append, kot argument pa smo navedli le element, ki smo ga + želeli dodati, torej imena.append("Ana").

+ +
>>> imena = []
+>>> imena.append("Ana")
+>>> imena.append("Berta")
+>>> imena
+['Ana', 'Berta']
+ +

append je očitno nenavaden, ne kličemo ga tako kot druge + funkcije. Funkcija append "pripada" seznamu; zato mu pravimo + imena.append. Naredimo še en seznam.

+ +
+>>> teze = []
+>>> teze.append(55)
+>>> imena.append("Cene")
+>>> imena
+['Andrej', 'Branka', 'Cene']
+>>> teze
+[55]
+ +

Vsak seznam ima svoj append: imena imajo + imena.append in teze imajo + teze.append.

+ +

Takšnim funkcijam pravimo metode. Klic imena.append + si predstavljamo, kot da seznamu imena rečemo "dodaj si + element" "Cene" in klic teze.append(55) + pomeni, da seznamu teze rečemo "dodaj si element" + 55.

+ +

Pika, . izraža nekakšno pripadnost, vsebovanost. Ko smo +spoznali module, smo videli, da z math.sqrt pridemo do +"math"ove funkcije z imenom "sqrt". Z imena.append zahtevamo +"imenovo" metodo "append". In z teze.append "tezovo" metodo +"append".

+ +

Takšnih metod je še veliko: takole prosimo niz ime, naj nam + pove, koliko črk "n" vsebuje.

+ +
>>> ime = "Benjamin"
+>>> ime.count("n")
+2
+ +

Takole pa niz fname vprašamo, ali se konča s "torrent": + +

>>> fname.endswith("torrent")
+True
+ +

Kako bi Benjamina spremenili v Benjamaxa? Težko: kot vemo, so nizi + nespremenljivi (tako kot terke; od vsega, o čemer smo govorili prejšnji + teden, lahko spreminjamo samo sezname). Pač pa lahko vprašamo niz, kako bi + bil videti, če "min" zamenjano z "max".

+ +
>>> ime.replace("min", "max")
+'Benjamax'
+ +

Metode niso povezane s tem, ali je niz shranjen v spremenljivki ali ne. + Metodo moremo poklicati tudi na nizu "kar tako". +

>>> "Maja".lower()
+'maja'
+ +

So z metodami obdarjeni samo nizi? Je to edinstven primer objektov v + Pythonu, ki imajo metode? Ne, nič ne bi moglo biti dalj od resnice! Skoraj + vsaka reč v Pythonu ima metode (ali vsaj nekaj podobnega). Celo običajna + števila imajo metode, čeprav zgolj tehnično in z zelo čudnimi imeni, kot + lahko vedoželjen študent hitro preveri: +

>>> (-231).__abs__()
+231
+ +

Med tipi, ki smo jih spoznali doslej, pa imajo uporabe vredne metode nizi + in seznami. V okviru predavanj ne bomo podrobneje spoznavali vse mogočih + podatkovnih tipov. Temeljiteje pa bomo pogledali metode nizov, seznamov + in podobnih reči, ki jih pri programiranju v Pythonu vsakodnevno + uporabljamo. Obenem bomo tako dobili vtis, kako te reči izgledajo. Najprej + nizi.

+ +

Metode nizov

+ +

Nekaj smo jih že spoznali: count, replace in + lower. Zadnja ima sestro, upper, ki vrne niz, + pri katerem so vse črke pretvorjene v velike črke.

+
>>> "Maja".lower()
+'maja'
+>>> "Maja".upper()
+'MAJA'
+ +

V žlahti z njima sta še (ne posebej uporabna) capitalize in + title.

+ +
+>>> "benjamin".capitalize()
+'Benjamin'
+>>> "tole je stavek, ki ga bomo povelikocrkali po anglesko".title()
+'Tole Je Stavek, Ki Ga Bomo Povelikocrkali Po Anglesko'
+ +

Da ne bi kdo pozabil, za vsak slučaj še enkrat spomnimo: te metode ne + spreminjajo niza, temveč vračajo nove nize. Nizi ostanejo takšni, kot so + bili. Po tem primeru bi moralo biti jasno, kaj ne deluje in kako je + potrebno pisati, da bo delovalo. +

>>> s = "benjamin"
+>>> s
+'benjamin'
+>>> s.capitalize()
+'Benjamin'
+>>> s
+'benjamin'
+>>> s = s.capitalize()
+>>> s
+'Benjamin'
+ +

Metodo count smo že spoznali. Povejmo le še, da lahko išče + tudi daljše podnize, ne le posamezne znake.

+ +
>>> "Maja".count("a")
+2
+>>> "Maja".count("aj")
+1
+ +

Poleg count imamo tudi nekaj funkcij, ki povedo, kje v nizu + se nahaja določen podniz. Prvi sta find in index. +

+ +
>>> s
+'Benjamin'
+>>> s.find("jam")
+3
+>>> s.index("jam")
+3
+ +

Edina razlika med njima je v tem, kaj storita, če iskanega niza ni. + find vrne -1, index pa javi napako.

+ +
>>> s.find("maj")
+-1
+>>> s.index("maj")
+Traceback (most recent call last):
+  File "", line 1, in 
+ValueError: substring not found
+ +

Če se dani podniz pojavi večkrat, bosta funkciji vrnili indeks prve + pojavitve - razen, če jima z dodatnimi argumenti povemo, od kod naprej + naj iščeta. Poleg find in index obstajata še + funkciji rfind in rindex, ki iščeta s konca in + tako vrneta zadnjo pojavitev podniza v nizu.

+ +

Mimogrede smo že omenili tudi preprosto, a zelo uporabno funkcijo + endswith, ki pove, ali se niz konča s podanim podnizom. + Poleg njega obstaja še startswith, ki pove ali se niz + začne z danim podnizom.

+ +

Metode ljust, rjust in center + dopolnijo niz s presledki z leve, z desne ali z obeh strani, tako da je + dolg toliko, kot želimo. Takole napihnemo Benjamina na 15 znakov:

+ +
>>> s.ljust(15)
+'Benjamin       '
+>>> s.rjust(15)
+'       Benjamin'
+>>> s.center(15)
+'    Benjamin   '
+ +

(Še enkrat: te metode ne spreminjajo niza, temveč vrnejo nov niz!)

+ +

Metoda strip naredi ravno nasprotno: odbije presledke (in + tabulatorje in znake za prehod v novo vrstico) na levi in desni strani + niza. lstrip in rstrip pospravita samo levo in + samo desno stran.

+ +
>>> s = '     asdf  '
+>>> s.lstrip()
+'asdf  '
+>>> s.rstrip()
+'     asdf'
+>>> s.strip()
+'asdf'
+ +

Če se zdi ta metoda komu neuporabna, se moti. Zelo.

+ +

Nizi imajo še veliko metod. Pogledali bomo le še dve najzanimivejši.

+ +

Metoda split razbije niz na seznam podnizov, kakor jih ločujejo + presledki, tabulatorji in znaki za nove vrstice. (V prvem približku: + razbije jih na besede.)

+ +
>>> s = 'Metoda split razbije niz na seznam podnizov, kakor jih ločujejo presledki.'
+>>> s.split()
+['Metoda', 'split', 'razbije', 'niz', 'na', 'seznam', 'podnizov,', 'kakor', 'jih', 'locujejo', 'presledki.']
+ +

Presledkom, tabulatorjem in znakom za novo vrstico rečemo tudi beli + prostor (white space). Namesto glede na beli prostor lahko + split razbije niz tudi glede na kak drug znak, ki ga moramo + v tem primeru podati kot argument.

+ +
>>> "123-4123-21".split("-")
+['123', '4123', '21']
+>>> "123-4123-21".split("1")
+['', '23-4', '23-2', '']
+ +

Zadnja metoda, join, dela ravno obratno kot split: + združuje nize. Način, na katerega je obrnjena, je nenavaden, a če malo + razmislimo, vidimo, da drugače ne bi moglo biti.

+ +
>>> imena = ["Ana", "Berta", "Cilka", "Dani", "Ema"]
+>>> "".join(imena)
+'AnaBertaCilkaDaniEma'
+ +

Praznemu nizu, "", smo "naročili", naj združi nize iz podanega seznama. To + sicer ni videti preveč lepo, lepše bo, če jih združimo s kakim ločilom.

+ +
>>> "-".join(imena)
+'Ana-Berta-Cilka-Dani-Ema'
+>>> ", ".join(imena)
+'Ana, Berta, Cilka, Dani, Ema'
+>>> "--".join(imena)
+'Ana--Berta--Cilka--Dani--Ema'
+>>> " in ".join(imena)
+'Ana in Berta in Cilka in Dani in Ema'
+ +

Najlepše pa bo, če zadnjo vejico zamenjamo z "in". +

>>> ", ".join(imena[:-1]) + " in " + imena[-1]
+'Ana, Berta, Cilka, Dani in Ema'
+ +

Tule smo z join združili vse elemente razen zadnjega. K temu + nizu smo prišteli niz " in " in še zadnje ime s seznama.

+ +

Metode seznamov

+ +

Tako kot nizi imajo tudi seznami metodi count in + index, o katerih ne bomo izgubljali besed.

+ +

Omenili smo že append, ki v seznam doda nov element. Pazite, + tole je pa zelo drugače kot pri nizih! Metoda append ne vrača + novega seznama, temveč v resnici spreminja seznam.

+ +

Kako pa bi k nizu pripeli seznam? Tule nam append ne bo + pomagal: kar naredi, je povsem narobe.

+ +
>>> imena
+['Ana', 'Berta', 'Cilka', 'Dani', 'Ema', 'Fanci', ['Greta', 'Hilda']]
+ +

Kaj smo pa pričakovali? Metoda append doda k seznamu nov + element. Kar ji podamo kot argument, bo zadnji element seznama. Če torej + appendu podamo seznam, bo seznam zadnji element seznama.

+ +

Uporabiti moramo metodo extend.

+ +
>>> imena = ['Ana', 'Berta', 'Cilka', 'Dani', 'Ema', 'Fanci']
+>>> imena.extend(["Greta", "Hilda"])
+>>> imena
+['Ana', 'Berta', 'Cilka', 'Dani', 'Ema', 'Fanci', 'Greta', 'Hilda']
+ +

Mimogrede, isto bi dosegli tudi z

+ +
imena += ["Greta", "Hilda"]
+ +

Metode extend praktično ne uporabljamo, ker je nepotrebna.

+ +

Metodi insert podamo dva argumenta, indeks in element, pa bo + vstavila element pred element s podanim indeksom (to si zapomnimo + takole: argument, ki ga podamo, bo indeks novega elementa).

+ +
>>> imena = ['Ana', 'Berta', 'Cilka', 'Dani', 'Ema', 'Fanci']
+>>> imena.insert(2, "PredCilka")
+>>> imena.insert(-2, "PreEma")
+>>> imena
+['Ana', 'Berta', 'PredCilka', 'Cilka', 'Dani', 'PreEma', 'Ema', 'Fanci']
+ +

Očitno deluje tudi indeksiranje s konca.

+ +

Elemente seznama lahko odstranjujemo na tri načine. Prvega smo spoznali že + prejšnjič: z ukazom del. Še enkrat: del ni metoda + in prihaja iz povsem drugega vica, a vseeno ga pač omenimo, ker sodi + sem.

+ +
>>> imena
+['Ana', 'Berta', 'PredCilka', 'Cilka', 'Dani', 'PreEma', 'Ema', 'Fanci']
+>>> del imena[2]
+>>> imena
+['Ana', 'Berta', 'Cilka', 'Dani', 'PreEma', 'Ema', 'Fanci']
+ +

Metoda pop vrne element s podanim indeksom in ga pobriše s + seznama.

+ +
>>> ime = imena.pop(2)
+>>> ime
+'Cilka'
+>>> imena
+['Ana', 'Berta', 'Dani', 'PreEma', 'Ema', 'Fanci']
+ +

Priznati moram, da metode pop nisem še nikoli uporabil na ta + način - vsaj ne da bi se tega spomnil. V resnici namreč vedno pobiramo + elemente z začetka ali s konca seznama. Metodo pop lahko zato + pokličemo tudi brez argumentov: v tem primeru vrača zadnji element.

+ +
>>> imena
+['Ana', 'Berta', 'Dani', 'PreEma', 'Ema', 'Fanci']
+>>> imena.pop()
+'Fanci'
+>>> imena.pop(0)
+'Ana'
+>>> imena
+['Berta', 'Dani', 'PreEma', 'Ema']
+ +

Če bi hoteli, recimo, prestaviti prvi element na konec, bi napisali +imena.append(imena.pop(0)).

+ +

Tretji način je, da elementa, ki ga želimo odstraniti, ne določimo z + indeksom, temveč z vrednostjo - povemo, kakšen element bi radi odstranili. + Temu je namenjena metoda remove.

+ +
>>> imena.remove("Dani")
+>>> imena
+['Berta', 'PreEma', 'Ema']
+ +

Pri tem ne odstrani vseh takšnih elementov, temveč le prvega, na katerega + naleti, kakor lahko vidimo v spodnjem primeru.

+ +
>>> s = [7, 1, 2, 3, 4, 1, 1, 2]
+>>> s.remove(1)
+>>> s
+[7, 2, 3, 4, 1, 1, 2]
+ +

Metoda s.copy() naredi kopijo seznama s, tako +kot da bi napisali s = s[:].

+ +

Metoda s.clear() ga +izprazni, kar je isto kot s[:] = [] in ni isto kot +s = []. Razlika je tako prefinjena, da bo vredna posebnega +predavanja.

+ +

Le še dve metodi sta nam ostali. reverse obrne vrstni red + elementov v seznamu.

+ +
+[7, 2, 3, 4, 1, 1, 2]
+>>> s.reverse()
+>>> s
+[2, 1, 1, 4, 3, 2, 7]
+ +

Zadnja je sort, ki uredi elemente po vrsti.

+ +
>>> s.sort()
+>>> s
+[1, 1, 2, 2, 3, 4, 7]
+ +

Metoda deluje nad vsakršnimi elementi, ki jih je mogoče primerjati - z njo + lahko uredimo seznam števil, nizov... Podamo ji lahko tudi kup argumentov, + ki pa jih v tem trenutku še nismo zmožni razumeti.

+ +

Ne spreglejte razlike med metodami nizov in seznamov. Metode nizov vračajo +nove nize; s.replace("min", "max") ni spremenil niza +s, temveč vrnil nov niz. Metode seznamov spreminjajo seznam; +s.insert(2, "Ana") ne vrne novega seznama, temveč spremeni +s.

+ +

Metode terk

+ +

Terke imajo enake metode kot seznami, manjkajo jim le metode, ki spreminjajo + seznam. Teh pa, roko na srce, ni veliko. ;) Terke imajo le dve metodi: + count in index.

+ + + diff --git a/python/problems/functions_and_modules/modules_sl.html b/python/problems/functions_and_modules/modules_sl.html new file mode 100644 index 0000000..ec414ef --- /dev/null +++ b/python/problems/functions_and_modules/modules_sl.html @@ -0,0 +1,251 @@ + + + + + + + + + + +

Kako uporabljamo module

+ +

Doslej smo spoznali le prgišče funkcij - input, + len, sqrt. V resnici pa skupaj s Pythonom dobimo + tisoče funkcij za vse mogoče reči, od pošiljanja pošte in kriptografije do + predvajanja zvoka in brskanja po datotekah .zip. Še večja gora funkcij + obstaja na spletu: karkoli si zamislite napisati, skoraj gotovo je nekdo + - če le gre za dovolj splošno reč - že potreboval kaj takšnega ter to tudi + napisal in vam dal na razpolago. Da se ne bi izgubili v gori funkcij (in + drugih reči), jih moramo nekako urediti.

+ +

Modul je zbirka funkcij (in omenjenih drugih reči). Veliko modulov dobimo + že kar ob namestitvi Pythona, druge poberemo z interneta. Da bi lahko + uporabljali funkcije iz modula, moramo modul najprej uvoziti, kar storimo + z ukazom import, ki mu sledijo imena enega ali več modulov. + S Pythonom dobimo, recimo, modul z matematičnimi funkcijami, ki se imenuje + math in ga uvozimo takole:

+ +
import math
+ +

To praviloma storimo na začetku programa. Ko je modul uvožen, kličemo + njegove funkcije. Do funkcije, ki se nahaja v modulu, pridemo tako, da + napišemo ime modula, piko, in ime funkcije.

+ +
>>> math.sqrt(2)
+1.4142135623730951
+>>> math.log(2.71828)
+0.99999932734728203
+>>> math.log10(100)
+2.0
+ +

Primer druge reči, ki je v modulu, so konstante.

+ +
>>> math.pi
+3.1415926535897931
+ +

Drug primer modula je, recimo, modul s funkcijami, ki vračajo naključna + števila (in počnejo tudi druge naključne reči), random. Ta + ima, recimo, funkcijo randint(a, b), ki vrne naključno število + med podanima vrednostima a in b (vključno z + b! Tu pravilo o tem, da b ni vključen, ne bi + imelo veliko smisla). Še dve zanimivi funkciji sta choice, + ki vrne naključno izbrani element seznama, in shuffle, ki + naključno premeša elemente seznama.

+ +
>>> import random
+>>> random.randint(10, 20)
+17
+>>> random.randint(10, 20)
+16
+>>> random.randint(10, 20)
+10
+>>> l = ["Ana", "Berta", "Cilka", "Dani", "Ema", "Fanci"]
+>>> random.choice(l)
+'Ana'
+>>> random.choice(l)
+'Dani'
+>>> random.shuffle(l)
+>>> l
+['Ana', 'Fanci', 'Dani', 'Cilka', 'Ema', 'Berta']
+ +

random.gauss(mu, sigma) vrača naključna števila iz Gaussove + distribucije s podanim poprečjem mu in varianco + sigma. Tule je pet števil iz distribucije N(10, 3):

+ +
>>> for i in range(5):
+... 	print(random.gauss(10, 3), end=" ")
+...
+8.96174816507 8.79299353551 8.75687382602 9.49106109252 8.21589651224
+ +

Poglejmo še en modul, os. Ta vsebuje goro funkcij, povezanih + z datotekami in direktoriji (podatki o datotekah, preimenovanje, brisanje), + programi, ki tečejo na računalniku in drugo. Tako recimo funkcija + os.listdir vrne seznam vseh datotek v direktoriju, katerega + ime podamo kot argument.

+ +
>>> os.listdir("/Users/janez/Dropbox/Pedagosko/P1/2014/03 seznami")
+['blagajna.py', 'palindrom.py', 'stetje.py', 'domaca', 'razpakiranje.py',
+'zapiski.html', 'fibo.py', 'seznami.py', 'zip.py']
+ +

Funkcija os.remove pobriše datoteko s podanim imenom. Če bi + želeli v direktoriju c:\d\kontrabant pobrisati vse datoteke s + končnico .pyc, bi to storili takole:

+ +
for fname in os.listdir("/Users/janez/Dropbox/Pedagosko/P1/2014/03 seznami"):
+    if fname[-4:] == ".py":
+        os.remove("/Users/janez/Dropbox/Pedagosko/P1/2014/03 seznami" + fname)
+ +

Ob tej priliki povejmo, da ima v normalnih operacijskih sistemih vsak program + (bolj učeno: proces) nek "trenutni direktorij". Kadar imena direktorija + ne začnemo z / (ali \ ali c: ali čim podobnim na Windowsih), se ime nanaša + na datoteke oz. direktorije znotraj tega, trenutnega direktorija. Kakšen je + trenutni direktorij, nam pove funkcija getcwd() (get current + working directory), spremenimo pa ga z os.chdir. Kar smo + počeli zgoraj, bi se lahko napisalo tudi + +

Vse skupaj bi bilo morda lepše, če bi predtem zamenjali trenutni direktorij.

+ +
os.chdir("/Users/janez/Dropbox/Pedagosko/P1/2014/03 seznami")
+for fname in os.listdir("."):
+    if fname[-4:] == ".py":
+        os.remove(fname)
+ +

Ko smo ravno pri Windowsih, potarnajmo še, da ima znak \ v nizih v večini + programskih jezikov poseben pomen. Danes povejmo le, da moramo, če hočemo + dobiti \, napisati \\. Se pravi, ko bomo hoteli reči "c:\Users\janez", bomo + morali napisati "c:\\Users\\janez". Na srečo lahko tudi na Windowsih že + dolgo uporabljamo sicer običajnejši /.

+ +

Če bi datoteke raje preimenovali kot brisali - recimo tako, da bi k njihovem + imenu dodali .bak, to storimo z os.rename, ki ji podamo staro + in novo ime datoteke.

+ +
for fname in os.listdir("."):
+    if fname[-4:] == ".py":
+        os.rename(fname, fname + ".bak")
+ +

Ob modulu os se lahko naučimo še nečesa zanimivega: modul + lahko vsebuje celo druge module. Tako modul os vsebuje modul + path. Modula path nam ni potrebno uvoziti, + dovolj je, da uvozimo os. Lahko pa ga uvozimo tudi takole

+ +
import os.path
+ +

Razlike pravzaprav (skoraj) ni.

+ +

Modul os.path vsebuje različne funkcije povezane z imeni + datotek in njihovimi lastnostmi. Zanimiva je, denimo, + os.path.splitext, ki ji podamo ime datoteke in vrne terko z + dvema elementoma - osnovo imena in končnico. Pri tem ni potrebno, da + datoteka v resnici obstaja.

+ +
>>> os.path.splitext("/Users/janez/datoteka.txt")
+('/Users/janez/datoteka', '.txt')
+ +

Ker vemo, da lahko terko razpakiramo v dve spremenljivki, bomo pogosto rekli + kar

+ +
>>> osnova, koncnica = os.path.splitext("/Users/janez/datoteka.txt")
+ +

Gornji programček bi se torej še bolj lepo napisalo takole.

+ +
for fname in os.listdir("."):
+    if os.path.splitext(fname)[1] == ".py":
+        os.rename(fname, fname + ".bak")
+ +

Modul os.path ima še kup zanimivih funkcij, recimo + funkcijo, ki pove, ali določena datoteka oz. direktorij obstaja + (os.path.exists), funkcije, ki povedo ali določeno ime + predstavlja datoteko (os.isfile), direktorij + (os.isdir), povezavo (os.islink) ali kaj + drugega, kar je znano na Unixu, v Windowsih pa ne.

+ +

Uvažanje v globalni imenski prostor

+ +

Kaj je "imenski prostor" vam še ne nameravam, kaj "globalni", pa še ne + morem povedati. Vseeno se lahko naučimo, kako uvažamo vanj.

+ +

Stvar je namreč jako preprosta. Morda se mi ne da stalno pisati + math.sin, math.cos, math.pi. Če bi + raje pisal le sin, cos in pi, bom + namesto z + +

import math
+ +

modul uvozil z

+ +
from math import sin, cos, pi
+ +

S tem povem dve reči. Prva: zanimajo me le tri reči, sin, + cos in pi. Ostalih, recimo sqrt, + ne potrebujem in naj jih ne uvaža. (Dejanski mehanizem je malo drugačen, + tudi sqrt je v resnici uvožen, vendar ga ne vidim, a to ni + pomembno.) Druga: nočem, da se funkcije "skrivajo" v modulu + math, hočem jih "tu", torej, hočem jih klicati, ne da bi moral + prej pisati math..

+ +

Pogosto smo leni ali, še pogosteje, ne vemo točno, katere vse funkcije + bomo potrebovali, zato rečemo kar

+ +
from math import *
+

Zvezdica pomeni "vse funkcije" in hočemo jih tu, ne v math. + Za to obliko uvoza sem vam, da nam je bilo enostavneje, pokazal, ko smo + začeli streljati s topom.

+ +

Temu načinu uvažanja se načelno izogibamo. Pogosto ga uporabljamo pri modulu + math, iz drugih modulov pa uvažamo le posamične funkcije + (from random import randint) ali pa pustimo modul kot modul + (import random).

+ +

Kako pišemo module

+ +

Napišimo program, ki bo vseboval konstanto odgovor, +ki bo imela vrednost 42, in funkcijo, ki računa Fibonaccijeva števila. + +

odgovor = 42
+
+def fibonacci(n):
+    a = b = 0
+    for i in range(n):
+        a, b = b, a+b
+    return a
+Program shranimo pod imenom fibo.py.

+ +

To je to. V drugem programu lahko rečemo + +

import fibo
+print("Odgovor je", fibo.odgovor)
+print("Deseto Fibonaccijevo število pa je", fibo.fibonacci(10))
+ +

Tudi vse ostale finte, na primer, from fibo import odgovor, + delujejo.

+ +

Modul ni nič drugega kot program, ki ga uvozimo.

+ +

Tudi vsi drugi programi, ki ste jih napisali doslej, so hkrati moduli: + lahko jih uvozite. Pazite le na tole: ko modul uvozimo, + se ta v resnici izvede, čisto tako, kot bi se izvajal program. + Vse, kar se v tem programu-modulu definira, ostane definirano in se + nahaja v modulovem imenskem prostoru. Vendar se zgodi tudi vse ostalo, + kar piše v modulu: če pri izvajanju naleti na print("Foo") + se bo ob uvozu modula izpisalo Foo. Če program-modul vsebuje klic funkcije + (in ne le definicij), se bo ta funkcija poklicala tudi ob uvozu.

+ +

Kje Python išče module? Navadno v trenutnem direktoriju, + poleg tega pa še v drugih. Na Windowsih v, recimo, + c:\Python34\lib\site-packages. + Več o tem si lahko preberete v dokumentaciji.

+ +

Tudi sicer ne bomo rinili prav globoko v module, + samo še eno stvar omenimo, da vas ne bo presenetila. + Ko boste prvič uvozili modul, se bo poleg datoteke s končnico .py + pojavila še ena, za enakim imenom, a končnico .pyc. + Python si vanjo "prevede" (pravzaprav bi smeli pisati brez narekovajev, + temu se v resnici reče prevajanje) v obliko, v kateri ga bo lahko + naslednjič hitreje uvozil. Pri manjših modulih se to ne pozna, + pri velikem številu velikih modulov pa. Če vas moti, jo lahko pobrišete; + drugič se bo pač spet pojavila ponovno.

+ + + diff --git a/python/problems/functions_and_modules/sl.py b/python/problems/functions_and_modules/sl.py index e4321ec..624a532 100644 --- a/python/problems/functions_and_modules/sl.py +++ b/python/problems/functions_and_modules/sl.py @@ -1,3 +1,6 @@ name = 'Funkcije in delo z moduli' -description = 'Uporaba funkcij in delo z moduli (predvsem z nizi).' +description = '''Uporaba funkcij in delo z + moduli. + Na primeru nizov spoznamo, + kako kličemo metode.''' -- cgit v1.2.1