Pythoni huviring 2010-2011

Lingitud videod (võib parema kvaliteedi valida):

Meil jäi pooleli töö Galaktikat näitava programmiga.
Jätkame sellega tegutsemist, lisame tähele lisaandmed – tähe värvi.
Parem on tähed koondada ehk omaette objekti – galaktikasse.
Teeme ümber tähe kuvamise, joonistame tõesti tähe kujulised tähed taevasse.

Näiteks tähe joonistamiseks teeme lisafunktsiooni (siin on juba värv lisatud tähele):

def taheke(self, dc, taht):
dc.SetBrush(wx.Brush(taht.annaVarv()))
dc.DrawPolygon(((taht.annaX()-4, taht.annaY()-4), (taht.annaX()-4, taht.annaY()), (taht.annaX(), taht.annaY()-4), (taht.annaX()+4, taht.annaY()+4)))

Nime võib ka lisada, selleks tahekese funktsiooni alla kirjutaja:

dc.DrawLabel(taht.annaVarv(), (taht.annaX(), taht.annaY(), taht.annaX()+20, taht.annaY()+20))

Tähtede nimede nimekirja leiab Wikipediast: http://en.wikipedia.org/wiki/List_of_proper_names_of_stars

Räägime täna natuke UMList ehk plokkskeemidest. Objekte kasutavaid programme peab täpselt planeerima, parem on kõik põhjalikult läbimõelda, et keset tööd ei tuleks ootamatuid halbu üllatusi. Selleks on hea koostada plokkskeem – iga objekt (class) eraldi koos oma andmetüüpidega (nimed, arvud, nimekirjad, alamobjektid) ja objektide omavahelised suhted, st kus kasutatakse ühte objekti teise sees.

!/usr/bin/python
-*- coding: utf-8 -*-

galaktika.py:

class Taht() :
    nimi = u""
    koordX = 0
    koordY = 0
    def __init__(self, koordX, koordY) :
       self.koordX=koordX
       self.koordY=koordY
    def annaX(self):
       return int(self.koordX)
    def annaY(self):
       return int(self.koordY)

GalTest.py:

import wx
import random
import galaktika
class GalTest(wx.Frame):
    tahed = []
    def __init__(self, parent, id, title):
       for i in range (1, 100):
          self.tahed.append(galaktika.Taht(random.randint(50, 900), random.randint(50, 500)))
       wx.Frame.__init__(self, parent, id, title, size=(1000, 600))
       self.Bind(wx.EVT_PAINT, self.joonistaja)
       self.Centre()
       self.Show(True)
    def joonistaja(self, event):
    #dc - drawing contect - ehk joonistusala, selle võib ümbernimetada ka
       dc = wx.PaintDC(self)
       dc.SetPen(wx.Pen('#000000', 1, wx.SOLID))
       dc.SetBrush(wx.Brush('#112233'))
       dc.DrawRectangle(10, 15, 980, 560)
       for taht in self.tahed:
          dc.SetBrush(wx.Brush('#ffdd33'))
          dc.DrawEllipse(taht.annaX(), taht.annaY(), 10 , 8)
app = wx.App()
GalTest(None, -1, 'Galaktika test')
app.MainLoop()

Kuidas saada kätte ekraani suurus?
ekraan=wx.GetDisplaySize()
laius = wx.GetDisplaySize().GetWidth()
korgus=wx.GetDisplaySize().GetHeight()

Täna vaatame veel edasi võimalusi luua graafilisi ehk akendes töötavaid programme. Seekord võtame selleks veidi teise akenderaamistiku nimega wx.

#!/usr/bin/python
# -*- coding: utf-8 -*-
import wx
#esmalt teeme raami ehk akna
class MinuRaam(wx.Frame):
    def __init__(self):
       wx.Frame.__init__(self, None, -1, "Minu raam", size=(300, 300))
       paneel = wx.Panel(self, -1) # raami (frame) lisatav paneel
       # kui hiir on paneelil, siis pannakse toimetama meetod Liigub (all pool)
       paneel.Bind(wx.EVT_MOTION, self.Liigub)
       # lisatakse seisev tekst "Hiire koht:"
       wx.StaticText(paneel, -1, "Hiire koht:", pos=(10, 12))
       self.kohaNaitaja = wx.TextCtrl(paneel, -1, "", pos=(90, 10)) # lisatakse tekstikast, milles saab teksti vahetada
    def Liigub(self, event): #meetod Liigub
       pos = event.GetPosition() # küsitakse hiire koordinaadid
       self.kohaNaitaja.SetValue("%s, %s" % (pos.x, pos.y)) # seatakse tekstikastis koordinaadid õigeks
if __name__ == '__main__':
    rakendus = wx.PySimpleApp()
    raam = MinuRaam()
    raam.Show(True)
    rakendus.MainLoop()


Pildi näitamine:

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""Tere wxPython!""" # dokument-kommentaar programmi juurde
import wx
class Raam(wx.Frame): # Raam on wx.Frame alamklass ehk järglasobjekt
    """Raam, mis kuvab pilti."""
    def __init__(self, pilt, vanem=None, id=-1,
          koht=wx.DefaultPosition,
          tiitel='Tere, wxPython!'):
       """Loob raami ja kuvab pildi."""
       temp = pilt.ConvertToBitmap()
       suurus= temp.GetWidth(), temp.GetHeight()
       wx.Frame.__init__(self, vanem, id, tiitel, koht, suurus)
       self.bmp = wx.StaticBitmap(parent=self, bitmap=temp)
class Rakend(wx.App):
    """Rakendus klass"""
    def OnInit(self):
       pilt = wx.Image('logo2.jpg', wx.BITMAP_TYPE_JPEG)
       self.frame = Raam(pilt)
       self.frame.Show()
       self.SetTopWindow(self.frame)
       return True
def peamine():
    rakendus= Rakend()
    rakendus.MainLoop()
#programmi põhimeetod
if __name__ == '__main__':
    peamine()


Joone tõmbamine 1 sekund pärast akna loomist:
#!/usr/bin/python
# -*- coding: utf-8 -*-
import wx
class naide(wx.Frame):
    def __init__(self, parent, title):
       super(naide, self).__init__(parent, title=title,
          size=(350, 170))
       wx.FutureCall(1000, self.joonistajoon)
       self.Centre()
       self.Show()
    def joonistajoon(self):
       dc = wx.ClientDC(self)
       dc.DrawLine(50, 30, 290, 150)
if __name__ == '__main__':
    rakendus = wx.App()
    naide(None, 'Line')
    rakendus.MainLoop()

#!/usr/bin/python
# Pliiatsid.py
import wx
class Pliiatsid(wx.Frame):
    def __init__(self, parent, id, title):
       wx.Frame.__init__(self, parent, id, title, size=(350, 190))
       self.Bind(wx.EVT_PAINT, self.joonistaja)
       self.Centre()
       self.Show(True)
    def joonistaja(self, event):
       dc = wx.PaintDC(self)

app = wx.App()
Pliiatsid(None, -1, 'Pliiatsid')
app.MainLoop()

Joonlaud on kasulik elementide kauguse mõõtmiseks :)
#!/usr/bin/python
import wx

class Ruler1(wx.Frame):
    def __init__(self, parent, id, title):
       wx.Frame.__init__(self, parent, id, title, size=(RW + 2*RM, 60),
          style=wx.FRAME_NO_TASKBAR | wx.NO_BORDER | wx.STAY_ON_TOP)
       self.font = wx.Font(7, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL,
          wx.FONTWEIGHT_BOLD, False, 'Courier 10 Pitch')
       self.Bind(wx.EVT_PAINT, self.OnPaint)
       self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
       self.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)
       self.Bind(wx.EVT_MOTION, self.OnMouseMove)
       self.Centre()
       self.Show(True)
    def OnPaint(self, event):
       dc = wx.PaintDC(self)
       brush = wx.Brush('#0d0060')
       dc.SetBrush(brush)
       dc.DrawRectangle(0, 0, RW+2*RM, RH)
       dc.SetFont(self.font)
       dc.SetPen(wx.Pen('#F8FF25'))
       dc.SetTextForeground('#F8FF25')
       for i in range(RW):
          if not (i % 100):
             dc.DrawLine(i+RM, 0, i+RM, 10)
             w, h = dc.GetTextExtent(str(i))
             dc.DrawText(str(i), i+RM-w/2, 11)
          elif not (i % 20):
             dc.DrawLine(i+RM, 0, i+RM, 8)
          elif not (i % 2): dc.DrawLine(i+RM, 0, i+RM, 4)
    def OnLeftDown(self, event):
       pos = event.GetPosition()
       x, y = self.ClientToScreen(event.GetPosition())
       ox, oy = self.GetPosition()
       dx = x - ox
       dy = y - oy
       self.delta = ((dx, dy))
    def OnMouseMove(self, event):
       if event.Dragging() and event.LeftIsDown():
          x, y = self.ClientToScreen(event.GetPosition())
          fp = (x - self.delta[0], y - self.delta[1])
          self.Move(fp)
    def OnRightDown(self, event):
       self.Close()
app = wx.App()
Ruler1(None, -1, '')
app.MainLoop()

Oleme seni vaadanud igasugu võimalusi, proovinud Pythonit siit ja sealt. Iga programmeerimiskeelega käib koos aga ka korralik dokumentatsioon – õpetused ja selgitused, et mis midagi selles keeles teeb. Ametlikud õpetused võivad teinekord küll keerulised olla, aga samas on nad ikkagi kõige õigemad ja annavad kõige enam infot, et kuidas midagi teha.

Pythoni ametlik kodulehekülg on PYTHON.ORG – ORG on mittetulunduslike organisatsioonide domeen, seal on veebilehed igasugustel seltsidel, ühendustel, standardeid defineerivatel organisatsioonidel jms. Pythoni keelt majandab ka vastav Pythoni tarkvarafond (Python Software Foundation), mis ei ole tulu taotlev organisatsioon (ettevõte/firma).

Veebilehe vasakul küljel on lingid, muuhulgas Pythoni dokumentatsioonile. Pythoni viimased versioonid on 2.7 ja 3.1, nende vahel on küllalt palju erinevusi ja enim leidub praegu internetis abi 2. seeria Pythoni kohta, seepärast oleme seni õppinud Python 2. näidete järgi ja jätkame ka sellega.

Kontrolli milline Pythoni versioon parasjagu arvutis aktiivne on sellise programmiga:

#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
print sys.version

Näiteks vastus >>> 2.6.6 (r266:84292, Sep 15 2010, 16:22:56) tähendab, et Python 2.6.6 on aktiivne.

Pythoni versioonide abifailide täpse nimekirja leiab sealt: http://python.org/doc/versions/

Näiteks meie kasutame tõenäoliselt seda: http://docs.python.org/release/2.6.5/

Kõige lihtsamalt, näidetega, annab infot “Tutorial” – http://docs.python.org/release/2.6.5/tutorial/

All pool on eraldi alajaotus “Brief Tour of the Standard Library”, seal all on Pythoniga kaasas olevad funktsioonid, mille kasutamiseks peab esmalt mõne mooduli importima, näiteks on seal lühike internetimooduli õpetus:

internet.py:
#!/usr/bin/python
# -*- coding: utf-8 -*-
import urllib2
for line in urllib2.urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):
   if 'UTC' in line: # otsi "Universal Time" ehk Greenwichi aega
      print line


parameeter.py:

#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
print sys.argv

Eelmise tunni programmi edasiarenduse kood on pakitud siia.

Esmalt jagame klassid mitmesse faili laiali.
Selleks teeme uue kausta – andmebaas
Laeme alla pakitud programmifailid ja pakime nad uude kausta lahti.

Python eristab klassi ehk objekti ja moodulit ehk faili.

Ülesanded:

1) Eristame eesnimefaile kaks tükki: tüdrukute nimede ja poiste nimedega.

2) Lisame õpilastele märkuse soo kohta ja võimaluse õpilasi soo järgi genereerida, et saaks teha tüdrukute klassi ja poiste klassi.

3) Lisame juhuslikult genereeritud õpilastele ka õppeained ja juhuslikud hinded.

4) Lisame hinnete ja ainete näitamise ka õpilaste tabelisse stiilis:
Juku Juurikas, 15 aastane
Matemaatika 4, 5, 4, 2, 3 : 3,8
Joonistamine 5, 4, 5, 4 : 4,5

5) Lisame absoluutse keskmise hinde – kõigi keskmiste hinnete keskmise arvutamiseks. Paneme õpilased vastavalt sellele hindele õigesse järjekorda.

#!/usr/bin/python
# -*- coding: utf-8 -*-
#
class Opilane:
   """Lihtne näidisobjekt"""
   vanus = 0
   eesnimi =u""
   perenimi =u""
   #õpilase looja
   def __init__(self, vanus, eesnimi, perenimi):
      self.vanus=vanus
      self.eesnimi=eesnimi.decode('utf-8')
      self.perenimi=perenimi.decode('utf-8')
   #õpilase näitaja
   def naita(self):
      print self.perenimi, ", ", self.eesnimi, " ", self.vanus
#programm ise
juku = Opilane(13, "Juku", "Juurikas")
juku.naita()

Edasi sama programm, kuid oluliste täiendustega:

#!/usr/bin/python
# -*- coding: utf-8 -*-
#klass Aine
class Aine:
    ainenimi=u""
    hinded = []
    def __init__(self, nimi, hinded):
       self.hinded=hinded
       self.ainenimi=nimi
    def lisaHinne(self, hinne):
       self.hinded.append(hinne)
    def naitaHinded(self):
       vastus = u""
       for hinne in self.hinded :
          if hinne > 1 and hinne < 6 : vastus = vastus + str(hinne) +", "        print vastus     def nimi(self):        return self.ainenimi     def keskHinne(self):        kokku = 0.0        n = 0        for hinne in self.hinded:           if hinne > 1 and hinne < 6 :           kokku = kokku + hinne           n = n + 1        return kokku / n #klass Opilane class Opilane:     vanus = 0     eesnimi =u""     perenimi =u""     ained = []     #õpilase looja     def __init__(self, vanus, eesnimi, perenimi):        self.vanus=vanus        self.eesnimi=eesnimi.decode('utf-8')        self.perenimi=perenimi.decode('utf-8')     #õpilase näitaja     def naita(self):        print self.perenimi, ", ", self.eesnimi, " ", self.vanus     #õpilasele aine lisaja     def lisaAine(self, aine):        self.ained.append(aine)     #ainete loetelu     def naitaAineid(self):        for aine in self.ained :           if aine != None : print aine.nimi(), aine.naitaHinded()     def aine(self, n):        return self.ained[n] #programm ise juku = Opilane(13, "Juku", "Juurikas") juku.naita() juku.lisaAine(Aine("Matemaatika", [])) juku.lisaAine(Aine("Füüsika", [])) print "Juku õpib aineid:" juku.naitaAineid() print "Paneme Jukule ainetesse hindeid" juku.aine(0).lisaHinne(5) juku.aine(0).lisaHinne(4) juku.aine(1).lisaHinne(5) juku.aine(1).lisaHinne(3) juku.aine(1).lisaHinne(2) juku.naitaAineid() print juku.eesnimi, "keskmine hinne aines", juku.ained[0].nimi(), " on ", juku.ained[0].keskHinne() print juku.eesnimi, "keskmine hinne aines", juku.ained[1].nimi(), " on ", juku.ained[1].keskHinne() opilased = [] opilased.append(juku) opilased.append(Opilane(15, "Mati", "Maasikas")) opilased.append(Opilane(14, "Kati", "Kaabu")) for opilane in opilased :     opilane.naita()

Juhuslikud arvud:

#!/usr/bin/python26
# -*- coding: utf-8 -*-
import random
# juhuslik kümnendmurd vahemikus 0 ja 1
print random.random()
# juhuslik täisarv vahemikus
print random.randint(45, 55)

Alustuseks üks sõrmkübaratäis objektorienteerimist:
#!/usr/bin/python
# -*- coding: utf-8 -*-
#defineeritakse isik
class isik:
   def ytleTere(self):
      print 'Tere, kuidas käsi käib?'
# siit lõppes objekti definitsioon ära ja programm alustab oma tavalisel moel
p = isik()
p.ytleTere()
# töötab ka: Person().ytleTere()

Me oleme varem kasutanud juba objektorienteerimisest tulenevat keelt: näiteks kuuluvad objektorienteerimise alla teksti ümberkodeerimine (tekst.encode(‘utf-8’)), faili kirjutamine fail.append moel jne.

Edasi esimene graafiline programm, mis midagi joonistada suudab:

#!/usr/bin/python
# -*- coding: utf-8 -*-
from Tkinter import * # siin haaratakse kaasa graafika Tkinter paketist
# Tk peafunktsioon
juur = Tk()
# loetakse lisaseaded failist, peabki olema väljakommenteeritud
#juur.option_readfile('optionDB')
# antakse nimi põhiobjektile juur
juur.title('Lõuend')
# luuakse lõuend - Canvas, määratakse kõrgus ja laius
louend = Canvas(juur, width =400, height=400)
# määrame joonistusala xy
xy = 10, 105, 100, 200
# loome lõuendisse kaare vastavate parameetritega
louend.create_arc(xy, start=0, extent=220, fill='gray90')
louend.pack()
# laseme käima peamise tsükli, mis lihtsalt on
juur.mainloop()


Värve on hea lisada RGB HEXis ehk kuusteistkümmendsüsteemis, näiteks #115588
# järel esimesed kaks kohta kuuluvad punasele – 00 on kõige “vähem punane” ja FF kõige “rohkem punane”,
9 järgnevad A, B, C, D, E ja F.
3-4 koht kuuluvad rohelisele ja 5-6 koht sinisele.
Võib vaadata näiteks tabelist.

Võib lisada erinevaid muid joonistusobjekte:

louend.create_line(105,10,200,105)
for i in range(1, 30, 3):
    louend.create_line(0, i, 60, i)
louend.create_line(0, 300, 156, 150, width=10, fill='red')
louend.create_oval(200, 200, 400, 400, width=2, fill='blue')
louend.create_polygon(205,105,285,125,166,177,210,199,205,105, fill='white')
louend.create_rectangle(20, 20, 300, 300, width=5, fill='red')

img = PhotoImage(file='./logo.gif')
louend.create_image(145,280, image=img, anchor=CENTER)

Edasi elemendid, mida saaks kasutada, et programmi hiirega toimetama panna:

#!/usr/bin/python
# -*- coding: utf-8 -*-
from Tkinter import *
#nupu loomine
aken = Button(text='Spam', padx=10, pady=10)
#suurus
aken.pack(padx=20, pady=20)
#hiirekursori seadmine
aken.config(cursor='gumby')
#kirjastiili seadmine
aken.config(font=('helvetica', 20, 'underline italic'))
mainloop()

Viimaks üks näide graafilisest nimekirjast:

#!/usr/bin/python
# -*- coding: utf-8 -*-
from Tkinter import *
    #
juur = Tk()
juur.title('nimekiribox')
nimekiri = Listbox(juur, width=15)
nimekiri.pack()
    #10 korda lisame numbri
for item in range(10):
    nimekiri.insert(END, item)
    #
juur.mainloop()

Viimaks üks põhjalikum dialoogidega aken:

from Tkinter import *
from tkMessageBox import askyesno, showerror
class NewDialogDemo(Frame):
    def __init__(self, master=None):
        Frame.__init__(self, master)
        Pack.config(self)
        self.createWidgets()
    def greet(self):
        print "hi"
    def greet2(self):
        print "neljas!"
    def createWidgets(self):
        Label(self, text='Nimi').pack(side=TOP)
        Button(self, text='Nupp 1', command=self.dialog1).pack()
        Button(self, text='Nupp 2', command=self.dialog2).pack()
        Button(self, text='Nupp 3', command=self.greet ).pack(side=LEFT)
        Button(self, text='Nupp 4', command=self.greet2 ).pack(side=RIGHT)
    def dialog1(self):
        ans = askyesno('Tiitel!', 'Tekst')
        if ans: self.dialog2()
    def dialog2(self):
        showerror('Vea tiitel', "Tekst")
if __name__ == '__main__': NewDialogDemo().mainloop()

Kontrollruudukesed:
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
from Tkinter import *
#
class Checkbar(Frame):
    def __init__(self, parent=None, picks=[], side=LEFT, anchor=W):
       Frame.__init__(self, parent)
       self.vars = []
       for pick in picks:
          var = IntVar()
          chk = Checkbutton(self, text=pick, variable=var)
          chk.pack(side=side, anchor=anchor, expand=YES)
          self.vars.append(var)
    def state(self):
       return map((lambda var: var.get()), self.vars)
#
#
class Quitter(Frame):
    def __init__(self, parent=None):
       Frame.__init__(self, parent)
       self.pack()
       widget = Button(self, text='Quit', command=self.quit)
       widget.pack(expand=YES, fill=BOTH, side=LEFT)
    def quit(self):
       quit(self)
#
#
if __name__ == '__main__':
    root = Tk()
    lng = Checkbar(root, ['Python', 'C#', 'Java', 'C++'])
    tgl = Checkbar(root, ['All'])
    lng.pack(side=TOP, fill=X)
    tgl.pack(side=LEFT)
    lng.config(relief=GROOVE, bd=2)
##
    def allstates(): print lng.state(), tgl.state()
    Quitter(root).pack(side=RIGHT)
    Button(root, text='Peek', command=allstates).pack(side=RIGHT)
    root.mainloop()

Vaheaja puhul postitan vaid ühe viite Delfi Fortele, kus kirjutatakse tiba-tiba programmeerimiskeeltest ja Pythonist.

Näide nimede faili kirjutamisest koos paari väikse lisaga, et täpitähed ka toimiks ja oleks nimed uuel real kõik:

# failinimi - lihtsalt nimi
failinimi = "test.txt"
# suvaline muutuja - null tähistab tõde, kõik muud numbrid valet.
valmis = 0
nimenimekiri = [] # täiesti tühi nimekiri

# kirjutame ükshaaval nimed faili:
for nimi in nimenimekiri:
    # enne nime kirjutamist kodeerime selle UTF-8 kodeeringusse, et täpitähed ka säiliks:
    fail.write(nimi.encode('utf-8')+"\n")
fail.close() # Fail tuleb alati sulgeda ka, et ta ikka kindlasti kirjutatud saaks

Samast failist nimede lugemine:

#!/usr/bin/python
# -*- coding: utf-8 -*-
sisu = []
# Kiire faili sisu lugemine
for joon in open("test.txt", "r"):
    sisu.append(joon)

for nimi in sisu:
    print nimi

Sellest näitest ka muudetud versioon, kus kasutatakse alammeetodit salvestamiseks: link

Põhjalikum failide näide, mis kasutab juba keele järgmise taseme tööriistu:

#!/usr/bin/python
# -*- coding: utf-8 -*-

nimi = raw_input("Faili nimi:")
print "Kontrollime kas leiame faili:"
os.path.exists(nimi)
if os.path.isfile(nimi) :
    # Kui fail on olemas
    print "Fail ", nimi, " on olemas" # Kas test.txt on olemas?
    if os.path.isabs(nimi) : # Kas see on absoluutne tee failinimi? Nt "/home/kasutaja/test.txt"
       pikktee = nimi
       lyhitee = os.path.basename(pikktee)
       # Get the type of shortpath:
       print "Faili ",shortpath," tüüp on", os.path.splitext(lyhitee)[1]
    print "Faili ",nimi," suurus on", os.path.getsize(nimi), " baiti (märki)"
else : print "Faili", nimi ," pole"
if os.path.isdir(nimi) :
    print "See on kaust!" # On see fail või kaust?
    def tagasitee( arg, kaustanimi, fnimed ):
       summa = 0
       for fail in fnimed:
       if not os.path.isdir(fail) :
          summa += os.path.getsize(fail)
       arg.append(summa)
    arglist = []
    # os.path.walk võimaldab kaustasid läbi käia
    # et muuta tervet failipuud:
    os.path.walk(nimi,tagasitee,arglist)
    summa = 0
    for vaartus in arglist:
       summa += vaartus
    print "Kausta ", nimi ," suurus on:" ,summa
else : print "See pole ka kaust!"

EKstreemseim näide tänaseks:

#!/bin/python
# -*- coding: utf-8 -*-

# Eeldame, et keskmine hinne on C
# Kirjeldame hinnete vahemikud:
C = KESKMINE
Cmaks = C + KESKMINE * .05
Cmin = C - KESKMINE * .05
Bmaks = Cmaks + KESKMINE * .1
Bmin = Cmaks
Amin = Bmaks
Dmaks = Cmin
Dmin = Cmin - KESKMINE * .1
Emaks = Dmin
# Kuvame statistika:
print "Keskmine selle kodutöö kohta:", KESKMINE
print "A vahemik:", ">="+str(Amin)
print "B vahemik:", Bmaks,"-", Bmin
print "C vahemik:", Cmaks,"-", Cmin
print "D vahemik:", Dmaks,"-", Dmin
print "E vahemik:", "<"+str(Emaks) # Iga MEIE hulka kuuluva kohta: for isik in MEIE:     if MEIE[isik] >= Amin:
        print isik,"(",MEIE[isik],")","sai ilmselt A ülesande eest."
    elif Bmaks > MEIE[isik] >= Bmin:
        print isik,"(",MEIE[isik],")","sai ilmselt B ülesande eest."
    elif Cmaks > MEIE[isik] >= Cmin:
        print isik,"(",MEIE[isik],")","sai ilmselt C ülesande eest."
    elif Dmaks > MEIE[isik] >= Dmin:
        print isik,"(",MEIE[isik],")","sai ilmselt D ülesande eest."
    else:
        print isik,"(",MEIE[isik],")","sai ilmselt E ülesande eest."

Juurde on tarvis seda faili.

Faili veakontroll (veakontroll.py):

#!/usr/bin/python
# -*- coding: utf-8 -*-
# veakontrolliga failioperatsioon
fnimi = raw_input("Faili nimi:")
try:
    fail = open(fnimi, "rb", 0) # null lõpus tähistab puhvrit, siin siis puhvrit pole
    try:
       print fail.mode
       print fail.name
       fail.seek(-128, 2) # siin
       andmed = fail.read(128)
       print andmed
    finally:
       fail.close()
except IOError:
    print "Faili viga!"
    pass