Informatika2-2014/teszt

OOP

[[1]]

[[2]]

Egységbezárás (encapsulation)

a procedurális megközelítéssel ellentétben az adatok és a függvények a program nem különálló részét képezik, azok összetartoznak: együtt alkotnak egy objektumot. Az objektum felülete(ke)n (interfész, interface) keresztül érhető el a többi objektum számára.

Osztály (class)

egy objektum prototípusa, tulajdonságokkal ellátva, melyek jellemzik az osztály példányait. A tulajdonságok osztály és példányváltozók, és metódusok (tagfüggvények). Pont-jelöléssel érhetők el.

Attribútum/tulajdonság (attribute)

egy objektum tulajdonsága, jellemzője, az objektum nevét követő pont után írjuk a nevét.

Példány (instance)

egy osztályhoz tartozó egyedi objektum.

Példányosítás (instantiation)

egy osztály egy példányának létrehozása.

Példány változó (instance variable)

metóduson belül definiált változó, mely csak az osztály adott példányához tartozik.

Osztályváltozó (class variable)

változó, melyet az osztály minden példánya elér.

Metódus (method, tagfüggvény)

osztályon belül definiált spec. függvény, első argumentuma tipikusan a self.

Öröklődés (inheritance)

származtatással egy már meglévő osztályból egy újat hozunk létre. Ez rendelkezni fog az ős minden tulajdonságával, amihez továbbiakat ad(hat)unk.

Polimorfizmus/többalakúság (polymorphism)

különböző viselkedésmódokkal ruházzuk fel az egymásból származtatott objektumokat.

Névtér (namespace)

megadja, hogy egy név melyik objektumhoz tartozik (leképezés a nevekről az objektumokra). (Példák névterekre: foglalt nevek, globális változók, egy függvény lokális nevei).

Hatókör/szkóp (scope)

a kód azon része, ahol a névtér közvetlenül (a teljes elérési út magadása nélkül) elérhető.

>>> class Osztalyom:
...     "Egy egyszerű példa osztályra"
...     i = 123
...     def f(self, i):
...         self.i = i
...         return 'hello vilag'
... 
>>> x = Osztalyom()
>>> x.i
123
>>> x.f(5)
'hello vilag'
>>> x.i
5
>>> Osztalyom.i
123

Objektum kívülről ráaggatott attribútumokkal (ritkán van erre szükség):

>>> x.szamlalo = 1
>>> while x.szamlalo < 10:
...     x.szamlalo = x.szamlalo * 2
... 
>>> print x.szamlalo
16
>>> del x.szamlalo

Konstruktor __init__

class Komplex:
 
    def __init__(self, real, imag):
        self.r = real
        self.i = imag
 
    def konjugalt(self):
        return Komplex(self.r, -self.i)

Használatára létrejön egy példány, melynek memóriacímét kapjuk vissza nevének beírása után:

>>> z = Komplex(3, 4)
>>> z
<__main__.Komplex instance at 0x184a710>
>>> w = z.konjugalt()
>>> w
<__main__.Komplex instance at 0x184a758>

Tulajdonságaik lekérdezhetők:

>>> z.r, z.i
(3, 4)
>>> w.r, w.i
(3, -4)

További tulajdonságokkal ruházzuk fel a Komplex osztály objektumait. Ehhez a speciális metódusokat használjuk:

class Komplex:
    """Komplex számok kezelése."""
 
    def __init__(self, real, imag):
        """Komplex szám létrehozása"""
        self.r = real
        self.i = imag
 
    def konjugalt(self):
        return Komplex(self.r, -self.i)
 
    def __add__(self, z):
        """Az infix '+' művelet használatához."""
        return Komplex(self.r + z.r, self.i + z.i)
 
    def __repr__(self):
        """Komplex szám megjelenése interaktív módban. 
        Ugyanezt kapjuk a print parancsra is."""
 
        # ez egyelőre rossz, mert a 3 - 4i képe ez lesz: 3 + -4i
        return repr(self.r) + " + " + repr(self.i) + "i"

Alkalmazása:

>>> z1 = Komplex(3, 4)
>>> z2 = Komplex(1, 5)
>>> z1 + z2
4 + 9i
>>> z1
3 + 4i
>>> z2
1 + 5i
>>> z1 + z2
4 + 9i

>>> type(z1)
<type 'instance'>
>>> isinstance(z1, Komplex)
True
>>> z1.__class__
<class __main__.Komplex at 0x21ce3f8>
>>> z1.__module__
'__main__'
>>> z1.__class__.__name__
'Komplex'
>>> dir(z1)
['__add__', '__doc__', '__init__', '__module__', '__repr__', 'i', 'konjugalt', 'r']
>>> print z1.__doc__
Komplex számok kezelése.
>>> z1.konjugalt()
3 + -4i
>>> z1.__add__(z2)
4 + 9i

Egy példa az osztályváltozó alkalmazására:

class Alkalmazott:
    """Alkalmazottak osztálya"""
    alkSzamlalo = 0
 
    def __init__(self, nev, fizetes):
        """Konstruktor az alkalmazottaknak"""
 
        self.nev = nev
        self.fizetes = fizetes
        Alkalmazott.alkSzamlalo += 1
        self.sorszam = Alkalmazott.alkSzamlalo
 
    def szamlalot_kiir(self):
        mit = "{0} a {1}. alkalmazott az összesen {2} között"
        print mit.format(self.nev, self.sorszam, Alkalmazott.alkSzamlalo)
 
    def adatot_kiir(self):
        print "Név: ", self.nev,  ", Fizetés: ", self.fizetes

>>> a1 = Alkalmazott("Jóska", 1000000)
>>> a2 = Alkalmazott("Pista", 200000)
>>> a3 = Alkalmazott("Ildikó", 2000000)
>>> a2.szamlalot_kiir()
Pista a 2. alkalmazott az összesen 3 között
>>> a2.adatot_kiir()
Név:  Pista , Fizetés:  200000
>>> a3.adatot_kiir()
Név:  Ildikó , Fizetés:  2000000

Példa az öröklésre. Szülő osztály:

class Ellipszis:
 
    def __init__(self, kozeppont, felx, fely):
        self.kozeppont = kozeppont
        self.felx = felx
        self.fely = fely
 
    def terulete(self):
        return self.felx*self.fely*3.14159

Gyerek osztály:

class Kor(Ellipszis):
 
    def __init__(self, kozeppont, sugar):
        Ellipszis.__init__(self, kozeppont, sugar, sugar)
        self.sugar = sugar

>>> e = Ellipszis((0, 0), 3, 2)
>>> e.felx
3
>>> e.fely
2
>>> e.terulete()
18.849539999999998
>>> k = Kor((2, 0), 3)
>>> k.felx
3
>>> k.fely
3
>>> k.sugar
3
>>> k.terulete()
28.27431

Függvény felülírása:

class Kor(Ellipszis):
 
    def __init__(self, kozeppont, sugar):
        Ellipszis.__init__(self, kozeppont, sugar, sugar)
        self.sugar = sugar
 
    def terulete(self):
        return self.sugar**2*3.14159

class Square(object):
 
    def __init__(self, side):
        self.side = side
 
    def area(self):
        """Calculates the 'area' property."""
        return self.side ** 2

# Google példa: http://google-styleguide.googlecode.com/svn/trunk/pyguide.html#Python_Language_Rules
 
import math
 
class Square(object):
    """A square with two properties: a writable area and a read-only perimeter.
 
    To use:
    >>> sq = Square(3)
    >>> sq.area
    9
    >>> sq.perimeter
    12
    >>> sq.area = 16
    >>> sq.side
    4         
    >>> sq.perimeter
    16
    """
 
    def __init__(self, side):
        self.side = side
 
    def __get_area(self):
        """Calculates the 'area' property."""
        return self.side ** 2
 
    def ___get_area(self):
        """Indirect accessor for 'area' property."""
        return self.__get_area()
 
    def __set_area(self, area):
        """Sets the 'area' property."""
        self.side = math.sqrt(area)
 
    def ___set_area(self, area):
        """Indirect setter for 'area' property."""
        self.__set_area(area)
 
    area = property(___get_area, ___set_area,
                    doc="""Gets or sets the area of the square.""")
 
    @property
    def perimeter(self):
        return self.side * 4

Funkcionális programozás elemei

Iterátor (bejáró)

>>> L = [1,2,3]
>>> it = iter(L)
>>> print it
<...iterator object at ...>
>>> it.next()
1
>>> it.next()
2
>>> it.next()
3
>>> it.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
StopIteration
>>>

for i in iter(obj):
    print i
 
for i in obj:
    print i

>>> L = [1,2,3]
>>> iterator = iter(L)
>>> t = tuple(iterator)
>>> t
(1, 2, 3)

>>> L = [1,2,3]
>>> iterator = iter(L)
>>> a,b,c = iterator
>>> a,b,c
(1, 2, 3)

Generátorkifejezés

Hasonló a listaértelmezéshez.

 (expression for expr in sequence1
             if condition1
             for expr2 in sequence2
             if condition2
             for expr3 in sequence3 
             if condition3 ...
             for exprN in sequenceN
             if conditionN )

obj_total = sum(obj.count for obj in list_all_objects())

A generátor egy iterátort ad vissza mely adatok folyamát adja vissza.

def generate_ints(N):
    for i in range(N):
        yield i

>>> gen = generate_ints(3)
>>> gen
<generator object generate_ints at ...>
>>> gen.next()
0
>>> gen.next()
1
>>> gen.next()
2
>>> gen.next()
Traceback (most recent call last):
  File "stdin", line 1, in ?
  File "stdin", line 2, in generate_ints
StopIteration