Objekt

Objekt kirjeldab ära konkreetse loogilise kogumi
- näiteks õues olev punane auto on üks objekt
- selle taga olev roheline auto on teine objekt jne
Tavaliselt mõtleme me arvust kui ühest väärtusest (nt 7)
Objekt koosneb tavaliselt mitmest väärtusest
- värv, mark, mudel, pikkus, registrimass jne

clase objekt
{
“name”: |”ago”| “kati”|
“id-code”:| | |
“phone:”| | |
}
[{ago…}, {kati…}]
[“ago”, “kati”]
[111, 112]
.
.
.
[…, …]

Klass

Klass kirjeldab ära struktuuri
- näiteks autol on värv, pikkus jne
Klass (üldiselt) ei sisalda andmeid
Klass on andmetüüp
Samatüüpi andmed pärinevad köik ühest klassist
- punane auto on auto, roheline auto on auto jne
Kuigi meil on maailmas mitu autot (objekti), siis meil on ü auto

OOP

Objekt-orienteeritud programmeerimine (OOP) on programmeerimise paradigma, mis kasutab objekte
Python on objekti-orienteeritud programmeerimiskeel (OOP)
Pythonis kõik asjad on objektid

OOP tehnikad

Kapseldamine (encapsulation)
- funktsionaalsus peidetakse
Modulaarsus (modularity)
- programm jagatakse iseseisvateks tükkideks
Polümorfism (polymorphism)
- alamklass saab meetodeid üle kirjutada
Pärimine (inheritance)
- alamklass saab meetodeid üle kirjutada
Abstraktioon
- aitab luua klassi, kasutatakse tarbetu teabe peitmiseks ja ainult vajaliku teabe kuvamiseks suhtlevatele kasutajatele

Sõne

Sõne on objekt
Kui loote uue sõne, siis tegelikult luuakse uus objekt, mille tüüp on str.
Sõne “funktsioone” kutsutakse meetoditeks
- ehk siis klassis kirjeldatud funktsioonid on meetodid

s = "Hello"
print(type(s)) # < class 'str' >
print(id(s)) # 30773472
print(id(s.replace( "H", "h"))) # 61507648

Loome sõne s ja küsime selle tüübi. Tüüp on str klass
id tagastab objekti kohta unikaalse arvu. Kui id on erinev, siis on ka objekt erinev (st mälus erinevas kohas)
replace teeb uue sõne, seda näeme ka id-ga

List

a = [1, 2, 3]
b = [1, 2, 3]
c = b
print(id(a))   # 44058024
a.append(4)
print(id(a))   # 44058024 still the same
print(id(b))   # 44059184
print(id(c))   # 44059184 - same as b
b.pop()
print(id(b))   # 44059184 - still the same
print(id(c))   # 44059184 - and same

Veel objekte

print(type(1))     # <class 'int'>
print(type(True))  # <class 'bool'>
print(type(1.2))   # <class 'float'>
print(type(None))  # <class 'NoneType'>
print(type(len))   # <class 'builtin_function_or_method'>
print(type(type))  # <class 'type'>

Klass kui andmetüüp

Iga klass on andmetüüp
Näiteks on Pythonis klass str
Iga konkreetne sõne, näiteks "tere", on selle klassi objekt (ehk isend)
Ühest klassist saab luua lõpmata palju objekte
Objekti kohta öeldakse ka isend ja instants
- Üldiselt mõeldakse “objekt”, “isend”, “instants” terminitega samu asju
- Erinevates allikates võivad neil erinevused olla

Teeme oma klassi

class Student:
    pass

s = Student()
print(type(s))  # <class '__main__.Student'>
print(id(s))    # 12448112

t = Student()
print(type(t))  # <class '__main__.Student'>
print(id(t))    # 12423408

Klass Student. pass on tühi korraldus
Loome kaks isendit – nende id on erinev (nad on mälus erinevas kohas)

Objektide võrdlemine

Objektide võrdlemine == võrdlusega kontrollib vaikimisi seda, kas nad viitavad samale objektile
Seda, mida täpselt kontrollitakse, saab üle kirjutada
- Näiteks sõne puhul kontrollitakse seda, kas sisu (st sümbolid) on samad jne

s1 = Student()
s2 = Student()
s3 = s1

print(s1 == s2)   # False
print(s1 == s3)   # True
print(s2 == s3)   # False

Meetod

Klassis sisalduvaid funktsioone nimetatakse meetoditeks

class Student:
    """Student class."""

    def hello(self):  # method, "self" is a special parameter
        """Method (function) which just prints out "Hello!"."""
        print("Hello!")


s = Student()   # s is an object of class Student
s.hello()       # no "self" argument

`self`

Kõik objekti meetodid sisaldavad esimest parameetrit self
- selle parameetri nimi võib ka midagi muud olla; kasutage self
self viitab isendile
Eelmises näites oli väljakutse s.hello()
- kui hello() meetod käima pannakse, antakse sellele s kaasa
Meetodi jaoks vajalike väärtuste jaoks lisatakse need peale self parameetrit

self ja parameetrid

class Student:
    def greet_friend(self, friend_name):
        print(f"Hello, {friend_name}")

s = Student()
s.greet_friend("Kaia")

Meetodi kirjelduses esimesel kohal on self, teisel kohal friend_name.
Kui kutsume välja greet_friend meetodit, siis esimesena kaasa antud argument läheb teise parameetrisse jne.

Konstruktor

Objekti loomisel pannakse käima eriline meetod ehk konstruktor
Meetod kirjeldatakse: __init__(self)
See meetod pannakse käima üks kord objekti loomisel
Eelnevas näites s = Student() kutsub välja konstruktori
Konstruktori kirjeldamine ei ole kohustuslik
Konstruktor peab tagastama None (eraldi return lauset ei kirjutata).

Konstruktor

Kirjeldatakse nagu tavaline meetod
Eraldi pole vaja välja kutsuda

class Student:
    def __init__(self):
        print("Initializing student..")

s = Student()  # Initializing student..

Student() kutsub Student klassi konstruktori välja.

Konstruktor, objekti muutujad

self viitab loodavale/loodud objektile
Konstruktorisse saab kaasa anda argumente (nagu tavaline funktsioon)
Esimene parameeter on alati self
Objekti muutujad on seotud ühe konkreetse objektiga (isendiga)
Objekti muutujaid väärtustatakse: self.name = ...
Tavaliselt luuakse konstruktoris vajalikud väljad ära
Objekti muutujaid saab teistes objekti meetodites kasutada

class Student:
    def __init__(self, name, title):
        self.name = name
        self.title = title

ago = Student("Ago", "Sir")
print(ago.name)

leela = Student("Leela", "Captain")
print(leela.title)

Konstruktori parameeter self viitab loodavale objektile.
Parameetrid name ja title salvestatakse objekti muutujateks: self.name ja self.title

Objekti muutujad

class Shop:
    def __init__(self, name, age, products_file=None):
        self.products = []
        self.name = name
        self.established = 2020 - age
        if products_file is not None:
            # open the file and read products from it
            pass

    def inventory(self):
        print(f"Inventory for {self.name} (est. {self.established}:")
        for p in self.products:
            print("product: ..")

**Klass (class)**

Defineerib andmetüübi
Šabloon, mida saab hiljem kasutada, et luua konkreetseid objekte (isendeid)

class Point2D:
    """Point in (x, y) coordinate space."""
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def print_point(self):
        print(f"({self.x:.2f}, {self.y:.2f})")

**Objekt (object)**

Konkreetne isend, instants (instance)
Luuakse klassi kirjeldusest
Klassist võib luua lõpmata palju objekte
Samast klassist loodud objektid on sarnase struktuuriga (neil on samad meetodid ja muutujad)
Aga igal objektil on oma olek (muutujate väärtused)

p1 = Point2D(1.234, 0.23456)
p2 = Point2D(-1, 3)

p1.print_point()   # (1.23, 0.23)
p2.print_point()   # (-1.00, 3.00)

Klass ja objekt

class Point2D:
    """Point in (x, y) coordinate space)."""
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def print_point(self):
        print(f"({self.x:.2f}, {self.y:.2f})")


p1 = Point2D(1.234, 0.23456)
p2 = Point2D(-1, 3)

p1.print_point()   # (1.23, 0.23)
p2.print_point()   # (-1.00, 3.00)

Objektide võrdlemine

p3 = Point2D(3, 3)
p4 = Point2D(3, 3)
p5 = p4   # both refer to the same object in memory

print(p3 == p4)   # False, although same values, objects are different
print(p4 == p5)   # True

p3.x = 10
p3.print_point()   # (10.00, 3.00)

p4.x = 11
p4.print_point()   # (11.00, 3.00)
p5.print_point()   # (11.00, 3.00), p5 points to p4

Erilised meetodid

Python võimaldab klassis ära kirjeldada objekti käitumist erinevates olukordades
Näiteks __eq__ meetodit kasutatakse selleks, et võrrelda objekte == võrdlusega
__str__ meetodit kasutatakse, et saada objektist sõne kuju
Lisaks näiteks __add__(self, other) objektide liitmiseks jne
__lt__(self, other) väikem-kui võrdluseks
__len__(self) kui rakendatakse len(self)

Objektide võrdlus

Punkti puhul oleks mõistlik realiseerida objektide võrdlus väärtuste järgi
Kui kahel punktil on mõlemad koordinaadid samad, siis on ka objektid võrdsed.

class Point2D:
    # constructor and print_point() same as previously
    def __eq__(self, other):
        if isinstance(other, Point2D):
            return self.x == other.x and self.y == other.y
        return False

__eq__ meetod käivitatakse võrdlemisel

p6 = Point2D(1, 2)
p7 = Point2D(1, 2)

print(p6 == p7)   # True
print(p6 is p7)   # False

p8 = p6
print(p6 is p8)   # True

Võrdleme nüüd kahte objekti == võrdlusega. Tulemus on tõene, kuna käivitub __eq__ meetod, mis võrdleb sisu.
is võrdlus kontrollib, kas viidatakse samale objektile

Objekt sõnena

__str__(self) meetod võimaldab kirjeldada, mida objekti puhul sõnena tagastatakse
Näiteks printimisel kasutatakse seda
Samuti str(obj) puhul.
Meetod tagastab sõne
Vaikimisi print(p1) kuvab midagi sellist <__main__.Point2D object at 0x0050D5D0>.

class Point2D:
    # ...
    def __str__(self):
        return f"({self.x:.2f}, {self.y:.2f})"
        
p1 = Point2D(1, 2)
print(p1)           # (1.00, 2.00)

Pythonis on eriline meetod __repr__, mille eesmärk on tagastada üheselt mõistetav sõne.
- Tihti tagastatakse sõne, millega saab objekti luua eval()funktsiooni abil
Kui __str__ pole defineeritud, kutsutakse __repr__ välja.
__str__ meetodi eesmärk on pigem olla informatiivne
Seega alati on mõistlik kirjeldada __repr__

class Point2D:
    def __repr__(self):
        return f"Point2D({self.x}, {self.y})"

Klassi muutujad

Klassi muutuja kirjeldatakse klassi sees väljaspool meetodeid
Klassi muutujal on üks väärtus läbi terve programmi
Sõltumata sellest, mitu objekti klassist luuakse, klassi muutujal on üks ühine väärtus
Üldiselt ei ole vaja kasutada

Klassi muutuja näide

class Doorbell:
    click_count = 0

    def __init__(self):
        self.click_count = 0

    def ring(self):
        print("Ringing..")
        self.click_count += 1
        Doorbell.click_count += 1

d1 = Doorbell()
d2 = Doorbell()
for _ in range(10): d1.ring()
for _ in range(4): d2.ring()
print(d1.click_count)         # 10
print(d2.click_count)         # 4
print(Doorbell.click_count)   # 14

Objekti väärtuste pärimine/muutmine

Kapseldamise eesmärk on peita objekti olek maailma eest ning lubada selle muutmine vaid läbi teatud meetodite.
Objekti väärtuste muutmiseks kasutatakse tavaliselt getter ja settermeetodeid
See annab võimaluse kontrollida, mida ja kuidas tagastatakse/muudetakse

class Student:
    def __init__(self, name):
        self.name = name

    def set_name(self, name):
        self.name = name

    def get_name(self):
        return self.name

Object-Oriented Programming (OOP)

Meetod

self

Konstruktor

Konstruktor

Konstruktor, objekti muutujad

Klass (class)

Objekt (object)

Erilised meetodid

Objektide võrdlus

Objekt sõnena

Klassi muutujad

Objekti väärtuste pärimine/muutmine

`self`

**Klass (class)**

**Objekt (object)**