Klassiks nimetatakse seda "raamfuktsiooni", milles sisalduvad kohad andmete ja alamfunktsioonide jaoks. Klassi võib käsitleda ka kui prototüüpi või mudelit, millele vastavad konkreetsed objetkid konkreetsete väärtustega.

Pythonis on klassi defineerimiseks võtmesõna class. Konstruktorina kasutatakse funktsiooni __init__(). Selle funktsiooni abil defineeritakse vastava klassi objektidele atribuudid.

Defineerime klassi jalgratas:

Olgu meil näiteks tarvis kirjeldada erinevaid jalgrattaid. Olgu meil antud ülesanne, kus on vaja arvutada, mitu meetrit jalgratas edasi liigub, kui meil on teada, mitu vändapööret sõitja teeb. Lähteandmetena on iga jalgratta kohta ka teada, mitu hammast on väntadega hammasrattal ja mitu hammast on tagumisel hammasrattal, mis ajab ratast ringi. (Lihtsuse mõttes eeldame, et tegemist on ilma käikudeta jalgratastega.)

Et lahendada seda ülesannet objektorienteeritud stiilis, defineerime kõigepealt jalgratta klassi. Et süntaks oleks korrektne, ütleme, et ta ei pea alguses midagi tegema. (Selleks kasutame võtmesõna pass.)

>>> class jalgratas():
...     pass

Kontrollime, kas töötab:

>>> a = Jalgratas()
>>> print a
<__main__.Jalgratas instance at 0xb7d772cc>

Klass Jalgratas töötab, me võime luua selle klassi eksemplare.

Meil ei ole palju praktilist kasu jalgrattast, millega midagi teha ei saa, mida isegi kirjeldada ei saa. Palju kasu pole sellestki, kui defineerime oma jalgratta klassi interaktiivses sessioonis. Sestap avame uue faili ja kirjutame oma jalgratta definitsiooni sinna.

Alustame uuesti otsast peale. Kõigepealt loome klassi jalgratas, koos klassiga ka kirjelduse - dokumentatsiooni osa.

Nüüd näeb meie fail välja selline:

class Jalgratas:
    '''
    Jalgratta klass.
    '''

Klassi eksemplari loomisel käivitatakse kõigepealt funktsioon __init__(). Kuna meie klass on loodud "puhta lehena", siis peame defineerima kõigepealt selle funktsiooni. Kirjeldame seal atribuute, mida tahame kasutada. Atribuutideks on omanik, see hakkab hoidma omaniku nime; esimene, sinna tuleb esimese hammasratta hammaste arv; tagumine (tagumise hammasratta hammaste arv), rattad, (rataste läbimõõt tollides, ehk kummi mõõt).

Kui me tahame, et kõiki neid atribuute oleks võimalik sättida ka klassi eksemplari loomisel, siis peame nad kirjutama ka __init__() argumentideks.

Nüüd näeb meie fail välja selline:

class Jalgratas:
    '''
    Jalgratta klass.
    '''
    def __init__(self,omanik="jalgratta omanik",
                 esimene=0, tagumine=0,
                 rattad=0):
        self.omanik = omanik
        self.esimene = esimene
        self.tagumine = tagumine
        self.rattad = rattad
        self.kumm = 1

Vahepeal võib tekkida isu proovida, kas loodud klass ka funktsioneerib. Salvestame faili nimega kulgurid.py - võibolla on meil vaja defineerida veel mõnda liiklusvahendit ;).

Nüüd on võimalik seda faili juba proovida. Kuigi meil pole tegemist käivitatava failiga, saame seda välja kutsuda kui moodulit. Selleks käivitame interpretaatori ja kasutame selles käsku import:

>>> import kulgurid
>>> a = kulgurid.Jalgratas()
>>> print a.omanik
jalgratta omanik
>>> print a.esimene
0

Näeme, et klassi eksemplari loomine õnnestub ja atribuutidel on esialgsed väärtused olemas.

Nüüd võime ka imporditud mooduli kohta abi küsida:

>>> help(kulgurid.Jalgratas)
Help on module kulgurid01:

NAME
    kulgurid01

FILE
    /home/nemee/Pythoniasjad/kulgurid01.py

CLASSES
    Jalgratas

    class Jalgratas
     |  Jalgratta klass.
     |
     |  Methods defined here:
     |
     |  __init__(self, omanik='jalgratta omanik', esimene=0, tagumine=0, rattad=0)

See tuletab meile meelde, et on paras aeg täiendada jalgratta klassi dokumentatsiooni. Ilus on kirjeldada ära klassi atribuudid, näiteks nii:

    Atribuudid:

    omanik - omaniku nimi (string)
    esimene - esimese (väntadega) hammasratta hammaste arv (int)
    tagumine - tagumise hammasratta hammaste arv (int)
    rattad - kummi siseläbimõõt tollides (int)
    kumm - kummi paksus (tollides), vaikimisi 1

Järgmisena loome objektile rakendatava funktsiooni ehk meetodi. Meil oli tarvis välja arvutada teekond, mille jalgratas teatava hulga vändapööretega läbib. Võtame siis vaikimisi vändapööreteks ühe, hiljem saame vajaliku numbri anda loodavale funktsioonile argumendiks ja sellega siis lõpptulemuse läbi korrutada.

defineerime funktsiooni teekond()

    def teekond(self,p=1):

Funktsiooni teekond() argumentideks on self - see tähistab objekti ennast - ja p, mille puhul me leppisime kokku, et see tähistab vändapöörete arvu ja seda kasutame pärast. self võimaldab meil kasutada funktsiooni __init__() abil defineeritud atribuute.

Meil on vaja teada esimese hammasrata hammaste arvu - selle annab meile atribuut self.esimene ja tagumise hammasratta hammaste arvu - selle annab meile atribuut self.tagumine. Nende abil arvutame ülekande, tähistame selle muutujaga ylekanne. Ülekanne on lihtsalt esimese ja tagumise hammasratta suuruste suhe (meil siis hammastes), saame, kui jagame atribuudid esimene ja tagumine. Funktsioon näeb meil nüüd välja järgmine:

    def teekond(self,p=1):
        ylekanne = self.esimene / self.tagumine         

Tagumine ratas liigub koos tagumise hammasrattaga, edasi on vaja arvutada, kui pika maa ratas läbib ühe pöördega. Ühe pöördega läbib ratas teekonna, mis on võrdne ratta ümbermõõduga: läbimõõt korda pii. Läbimõõdu saame nii, kui võtame pöia mõõdu ja lisame sellele kahekordse kummi paksuse (mis on sama palju kui laius, enamvähem). Pöia mõõt on meil atribuudis rattad , kummi laius(=kõrgus) atribuudis kumm. Läbitud vahemaa kokku on ylekanne * (rattad + 2 * kumm) * pii. Me ei pea võtma uut muutuja nime, omistame lihtsalt muutujale ylekanne uue väärtuse. Nüüd on meie funktsioon kasvanud jälle rea võrra:

    def teekond(self,p=1):
        ylekanne = self.esimene / self.tagumine         
        ylekanne = ylekanne * (self.rattad + 2*self.kumm) * 3.14

Kuna rataste läbimõõt ja kummi paksus on antud tollides, siis arvutame tulemuse meetriteks ümber, arvestusega 1" = 2,54cm ja 1cm = 0,01m. Seega teekond = ylekanne * 2.54 * 0.01 ja muutuja teekond tagastatakse käsuga return.

    def teekond(self,p=1):
        ylekanne = self.esimene / self.tagumine         
        ylekanne = ylekanne * (self.rattad + 2*self.kumm) * 3.14
        teekond = ylekanne * 2.54 * 0.01
        return teekond

Kirjutame funktsiooni kohta jutu dokumentatsiooniridadle ja saame lõpliku klassi:

class Jalgratas:
    '''
    Jalgratta klass.

    Atribuudid:

    omanik - omaniku nimi (string)
    esimene - esimese (väntadega) hammasratta hammaste arv (int)
    tagumine - tagumise hammasratta hammaste arv (int)
    rattad - kummi siseläbimõõt tollides (int)
    kumm - kummi paksus (tollides), vaikimisi 1

    Meetodid:

    teekond(p=1)
    tagastab vändapööretega p läbitud teekonna (meetrites)
    '''
    def __init__(self,omanik="",
                 esimene=0, tagumine=0,
                 rattad=0):
        self.omanik = omanik
        self.esimene = esimene
        self.tagumine = tagumine
        self.rattad = rattad
        self.kumm = 1

    def teekond(self,p=1):
        '''
        Arvutab vändapööretega läbitud teekonna.

        Sisendiks on klassieksemplar (self) ja
        vändtud pöördeid (p), mis on vaikimisi 1.

        Sel ajal kui vändahammasratas teeb 1 pöörde,
        teeb tagumine hammasratas esimene/tagumine pööret.

        See on ylekanne.

        Tagumine ratas liigub koos tagumise hammasrattaga.

        Ühe pöördega läbib ratas teekonna, mis on võrdne
        ratta ümbermõõduga: läbimõõt korda pii.

        Läbitud vahemaa kokku on ylekanne * (rattad + 2 * kumm) * pii.

        Kuna rataste läbimõõt ja kummi paksus on antud tollides,
        siis arvutame tulemuse meetriteks ümber, arvestusega
        1" = 2,54cm ja 1cm = 0,01m. Seega
        
        teekond = ylekanne * 2.54 * 0.01

        Väljastatakse teekond.

        '''
        ylekanne = self.esimene / self.tagumine
        ylekanne = ylekanne * (self.rattad + 2*self.kumm) * 3.14
        teekond = ylekanne * 2.54 * 0.01
        return teekond

Nüüd on võimalik küsida ka täielikumat abi, kasutades päringut help(kulgurid.Jalgratas)