Szkriptnyelvek: Dr. Dombi József Dániel Antal Gábor

Szkriptnyelvek
Dr. Dombi József Dániel

Antal Gábor
Szegedi Tudományegyetem
Informatikai Intézet
Szoftverfejlesztés Tanszék
2018
Szkriptnyelvek 2018 Python 1 / 60

Tartalom
2 Objektumorientált tervezés alapfogalmak

Modellezés Objektumorientáltság Pythonban
1 Python UML Objektumorientáltság Python
Objektumorientáltság Objektumorientáltság nyelven
Szkriptnyelvek 2018 Python 2 / 60

Tartalom

Szkriptnyelvek 2018 Python Objektumorientáltság 3 / 60

Szkriptnyelvek
Dr. Dombi József Dániel

Antal Gábor
Szegedi Tudományegyetem
Informatikai Intézet
Szoftverfejlesztés Tanszék
2018
Szkriptnyelvek 2018 Objektumorientált tervezés 4 / 60

Tartalom

Szkriptnyelvek 2018 Objektumorientált tervezés 5 / 60

Tartalom

Szkriptnyelvek 2018 Objektumorientált tervezés Modellezés 6 / 60

Vizuális modellezés
Programozás lépései
modellezés és tervezés
kódolás
dokumentálás, tesztelés
Modellezés
a probléma leírása a valós világból vett ötletekkel
a rendszer lényeges részeit vizsgáljuk
vizuális: szabványos grafikai eszközökkel

Miért modellezünk?
Alkalmas üzleti folyamatok leírására

Esettanulmányok a felhasználó szempontjából
Kommunikációs eszköz
Komplexitás kezelése
Fejlesztési idő és rizikó csökkentése
Szoftver architektúra definiálása
„1 bitmap = 1 megaword” (ismeretlen szerző)

Tartalom

Szkriptnyelvek 2018 Objektumorientált tervezés UML 9 / 60

UML
Unified Modeling Language

(Egységesített Modellező Nyelv)
Egy nyelv: szintaktikai és szemantikai szabályok összessége
Szoftverrendszer elemeinek
vizualizálására
specifikálására
létrehozására
dokumentálására
Teljes UML dokumentáció
http://www.uml.org

UML előnyei
Nyílt szabvány
(Object Management Group – OMG által)
Teljes szoftverfejlesztési életciklust támogatja
Különböző alkalmazási területekre alkalmazható
Hatalmas tapasztalati tudásra épít
Sok eszköz támogatja
(Rose, MSVC, Visio, GDPro, Together, dia, Eclipse, NetBeans, Visual
Paradigm. . . )
Támogatók: Rational, HP, IBM, Microsoft, Oracle, Platinum, TI,
Sun, DEC,. . .
Bővebben: https://en.wikipedia.org/wiki/List_of_Unified_
Modeling_Language_tools

Modell, nézet és diagram
Modell: a rendszer teljes leírása
„adatbázis”
Nézet: az architektúra „4+1” nézete
logikai, komponens...
Diagram: a modell különböző vetületei
valamely résztvevő szemszögéből
részleges reprezentációja a rendszernek
szemantikailag konzisztens a többi nézettel

Diagramok
UML diagram
Statikus diagram Dinamikus diagram

Használati eset
(Use case)
Osztály Objektum Együttműködési Szekvencia
(Class) (Object) (Collaboration) (Sequence)
Komponens Telepítési Állapotátmeneti Aktivitás

(Component) (Deployment) (Statechart) (Activity)

Tartalom

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság alapfogalmak14 / 60

Az objektum fogalma
Egy entitás ábrázolása (valós világból, vagy elvonatkoztatott)

Pl.:
személy (akinek vannak adatai, tud járni, futni)
kurzus (aminek van kódja, neve, lehet nyitott, és fel lehet rá venni
hallgatókat)
e-mail (aminek van feladója, címzettje, törzse, képesek vagyunk
mellékletet hozzáadni, és elküldeni)
Minden objektum rendelkezik:
állapottal
viselkeséssel
identitással

Objektum állapota
Egy a lehetséges létezései közül

Időben változó
Attribútumok határozzák meg
Példa:
egy Kurzus típusú objektum állapota nyitott, ha kevesebb, mint 20
jelentkező van, egyébként zárt

Objektum viselkedése
Annak módja, hogyan reagál egy objektum más objektumok kéréseire

Mindent definiál, amit az objektum „csinálhat”
Operációk határozzák meg
egy Kurzus típusú objektumnak lehetnek hallgató_felvétel és
hallgató_törlés operációi

Objektum identitása
Minden objektum egyedi, akkor is, ha állapotuk azonos

Példa:
a programozások és algoritmusok különböző objektumok, annak
ellenére, hogy mindkettő valamilyen kurzus
ugyanabba, a Kurzus osztályba tartoznak
programozas : Kurzus algoritmusok : Kurzus

nyitott : bool = true nyitott : bool = false

Osztály fogalma
Leírás objektumok csoportjához, amelyeknek közösek az
attribútumaik, operációik;
más objektumokkal való kapcsolataik és
szemantikus viselkedésük
Egy minta objektumok létrehozásához (példányosításához):
minden objektum pontosan egy osztály példánya
az osztály az objektum típusa
Kurzus
nyitott : bool
hallgatoFelvetel()
hallgatoTorles()

Csomagok
Nagy rendszereknél elkerülhetetlen az osztályok csoportosítása

Hierarchikus szerkezetet biztosít
Magasabb szintű absztrakciót valósít meg
Minden csomag tartalmaz(hat)
interfész osztályokat (publikus) és
implementációs osztályokat (belső, privát)
Kurzusok
Kurzus
nyitott : bool
hallgatoFelvetel()
hallgatoTorles()

Osztálydiagramok
Csomagokba szervezett osztályok önmagukban nem elegendőek
(modell)
nehezen olvasható
A modell különböző vetületei a tényleges megjelenítései a rendszernek
Követhetik a modellt, de általában nem:
pl. a modell egy osztálya több különböző vetületen (diagramban) is
megjelenhet
Mindig van egy fődiagram, amely tipikusan a rendszer fő csomagjait
tartalmazza
Minden csomagnak is van saját fődiagramja, amely a publikus
interfész osztályokat jeleníti meg

Kapcsolatok
Objektum-kölcsönhatások megvalósulásai
objektum-üzeneteknek a „csatornái”
Kapcsolatok az osztálydiagramokon:
asszociáció
aggregáció és kompozíció (rész-egész kapcsolatok)
öröklődés
Kapcsolatok tulajdonságai:
név, irány, szerep, multiplicitás, . . .

Asszociáció
Osztályok közötti kétirányú összeköttetés (navigálási irány megadható

– üzenet iránya)
„Használati kapcsolat”, létük egymástól általában független, de
legalább az egyik ismeri és/vagy használja a másikat
Szemantikus összefüggést ábrázol:
nem adatfolyam (mindkét irányba lehet információ/adat továbbítás)
Gyakorlatilag az osztályokból létrejövő objektumok között van
összefüggés
Kurzus
nyitott : bool J oktat
Oktato
hallgatoFelvetel() * 1
hallgatoTorles()

Aggregáció
Asszociáció egy speciális formája

„Rész-egész” kapcsolat (erősebb mint az asszociáció)
Az egyik objektum fizikailag tartalmazza vagy birtokolja a másikat
A rész-objektum(ok) léte az egész-objektumtól függ
UML (rombusz a tartalmazó oldalán)
Kurzus
nyitott : bool J oktat
Oktato Tanszek
hallgatoFelvetel() * 1 * 1
hallgatoTorles()

Aggregáció (folyt.)
Mikor legyen egy asszociáció helyett inkább aggregáció?
a kapcsolat leírásánál a „része” használható
az egész-objektum bizonyos műveletei automatikusan a
rész-objektumokra is vonatkoznak (pl. megszűnés)
sok esetben nem egyértelmű (ugyanaz a kapcsolat két alkalmazásban
másként jelenhet meg)
Kétféle létezik
gyenge tartalmazás – általános aggregáció
erős tartalmazás (Kompozíció) – részek élettartama szigorúan
megegyezik az egészével

Öröklődés
Osztályok közötti kapcsolat (reláció), ahol egy osztály megosztja a

struktúráját és/vagy a viselkedését egy vagy több másik osztállyal
Öröklődési hierarchia
származtatott osztály örököl az ősosztály(ok)tól
Az attribútumokat és operációkat a lehető legfelsőbb szinten kell
definiálni
A származtatott (gyerek) osztály mindent örököl az őstől (relációkat
is) és kiegészítheti ezeket sajátokkal

Öröklődés (folyt.)
A származtatott osztály egy örökölt operáció saját implementációját
is nyújthatja: polimorfizmus (felüldefiniálás, overriding)
Az öröklődés relációnak nincs neve, multiplicitása
Tipikus öröklődési szintek száma: 3-5
Az újrafelhasználhatóság egyik alapeszköze
Öröklődés feltárása
általánosítás és
specializálás
Felhasznalo
Oktato Hallgato

Többszörös öröklődés
Példa: a kétéltű jármű egy motorgépjármű (ami egy jármű) és egyben

egy vízi jármű is (ami ugyancsak egy jármű)
Jarmu
MotorGepJarmu ViziJarmu
KeteltuJarmu

Többszörös öröklődés (folyt.)
Problémák adódhatnak
Pl.:
név ütközések
többszörösen örökölt operációk, attribútumok
Megoldható: C++ virtuális öröklődés
Kevésbé karbantartható kódhoz vezet
csak akkor szabad használni, ha tényleg szükséges, de akkor is csak
nagy odafigyeléssel
Pythonban is használható, azonban csak a legvégső esetben érdemes

Tartalom

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság Pythonban 30 / 60

Tetszőleges számú argumentum
A paraméterlista végén megadhatunk egy paramétert, ami hatására

tetszőleges számú paramétert fogadhat a metódus
A *args nevű változóban egy tuple jön létre, amiben a paraméterek
lesznek.
Ezt használhatjuk a kódban, pl. bejárhatjuk for ciklussal.
d e f atlag ( szam1 , szam2 , szam3 =0): # 2 vagy 3 p a r a m e t e r

r e t u r n sum([ szam1 , szam2 , szam3 ]) / 3 # itt 3 van ...
d e f atlag2 (* args ): # b a r m e n n y i p a r a m e t e r t kaphat igy a f u g g v e n y

r e t u r n sum( args ) / l e n ( args )
p r i n t ( atlag (10 , 20 , 30))

p r i n t ( atlag2 (10 , 20 , 30))
20.0
20.0

A paraméterlista végén megadhatunk egy paramétert, ami hatására

tetszőleges számú paramétert fogadhat a metódus
A *args nevű változóban egy tuple jön létre, amiben a paraméterek
lesznek.
Ezt használhatjuk a kódban, pl. bejárhatjuk for ciklussal.
d e f atlag ( szam1 , szam2 , szam3 =0): # 2 vagy 3 p a r a m e t e r

r e t u r n sum([ szam1 , szam2 , szam3 ]) / 3 # itt 3 van ...
d e f atlag2 (* args ): # b a r m e n n y i p a r a m e t e r t kaphat igy a f u g g v e n y

r e t u r n sum( args ) / l e n ( args )
p r i n t ( atlag (10 , 20 , 30))

p r i n t ( atlag2 (10 , 20 , 30))
20.0
20.0

d e f p ri nt _p a ra me te r (* args ):
p r i n t ( args )
p ri nt _p a ra me te r ( " alma " , " korte " , " dinnye " )
( ’ alma ’ , ’ korte ’ , ’ dinnye ’)

Kicsomagolás
Ha van egy tuple-ünk, vagy listánk, amit szeretnénk átadni egy

függvénynek, de nem tömbként, hanem szétszedett, "kicsomagolt"
argumentumonként.
d e f print_info ( nev , kor ):

p r i n t ( " Adatok " , " nev : " , nev , " , kor : " , kor )
print_info ( " Tamas " , 22)

print_info ( " Zsolt " , 24)
adatok = [ " Imre " , 18]
print_info ( adatok ) # egy t ö mb a param é ter

print_info (* adatok ) # k i c s o m a g o l j u k a t ö mb ö t
20.0
20.0

Kicsomagolás
d e f p r i n t _ p a r a m e t er 2 ( elso , masodik = None , harmadik = None ):
p r i n t ( ’ elso ’ , elso )
p r i n t ( ’ masodik ’ , masodik )
p r i n t ( ’ harmadik ’ , harmadik )
tomb = [ " alma " , " korte " , " dinnye " ]
p r i n t _ p a r a m e t er 2 ( tomb )
p r i n t ( ’ --- ’)
p r i n t _ p a r a m e t er 2 (* tomb )
elso [ ’ alma ’ , ’ korte ’ , ’ dinnye ’]

masodik None
harmadik None
---
elso alma
masodik korte
harmadik dinnye

kwargs
Az eddigi megoldás a változó számú paramétert enged ugyan,

azonban ha egymást követő paramétereket nevesítve próbáljuk meg
használni, az már nem fog működni.
Erre megoldás a **kwargs (bármi lehet a neve, azonban általában
kwargsnak nevezzük)
Így névtelen paraméterek (tuple) helyett nevesített kulcs-érték
párokat fogadhat a függvényünk (dictionarry)
Viszont ha kulcs-érték párokat fogad a függvényünk, akkor már név
nélküli paramétereket nem adhatunk át neki!
d e f k u l c s _ e r t e k _ a r g u m e n t u m o k (** kwargs ):
p r i n t ( ’A fuggveny az alabbi param eterekke l lett meghivva ’)
f o r kulcs , ertek i n kwargs . items ():
p r i n t ( kulcs , ’ -> ’ , ertek )
k u l c s _ e r t e k _ a r g u m e n t u m o k ( nev = ’ Kiss Tamas ’ , kor =21 , email = ’ k t o m i 1 2 8 1 4 2 @

kwargs kibontása
Az eddig látott tuple kibontáshoz hasonlóan kibonthatjuk a

dictionary-kat is
Ez akkor jöhet jól, amikor egy függvény nevesített paraméterei egy
szótárban vannak letárolva, ekkor:
kwargs: Az argumentumokat tároló dictionary (kulcs-érték párok
halmaza)
*kwargs: A dictionary kulcsai
**kwargs: A kibontott dictionary

kwargs kibontása
d e f p r i n t _ p a r a m e t er 2 ( elso , masodik = None , harmadik = None ):
p r i n t ( ’ elso ’ , elso )
p r i n t ( ’ masodik ’ , masodik )
p r i n t ( ’ harmadik ’ , harmadik )
tomb = {
’ elso ’: ’ alma ’ ,
’ masodik ’: ’ korte ’ ,
’ harmadik ’: ’ dinnye ’
}
p r i n t _ p a r a m e t er 2 ( tomb )
p r i n t ( ’ --- ’)
p r i n t _ p a r a m e t er 2 (** tomb )
elso { ’ masodik ’: ’ korte ’ , ’ elso ’: ’ alma ’ , ’ harmadik ’: ’ dinnye ’}

masodik None
harmadik None
---
elso alma
masodik korte
harmadik dinnye

Tartalom

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság Python nyelven

39 / 60
Osztályok készítése Python nyelven
c l a s s Osztaly :
pass
c l a s s Osztaly2 ( o b j e c t ): # orokles
pass
A Pythont használhatjuk objektum-orientált módon is.

Osztály létrehozásához a class kulcsszó használat az elterjedt, ez
Pythonban is így van.
Ezt követi az osztály neve, majd az osztály(ok), ami(k)ből öröklődik
az osztály, sima zárójelpár között felsorolva
Python 3-ban nem szükséges kiírni, ha az object nevű osztályból
származunk (ez az öröklődési hierarcia teteje)
Kompatibilitási célból azonban így érdemes, mivel Python 2-ben
másképp viselkedhet a kód, ha nem írjuk oda.
Ezt követően jönnek az osztályban lévő utasítások (természetesen
beljebb indentálva)
40 / 60
Osztályok készítése Python nyelven
Osztályon belül létrehozhatunk metódusokat, adattagokat.

Alapvetően itt minden osztály-beli tagfüggvény esetében bekerül egy
első paraméter, amit explicit módon ki is kell írni, ez a self nevet
viseli (bármi lehet a név, de ez a szokásos elnevezés).
Ez mindig az aktuális objektumra való hivatkozás (más nyelvekben
this-ként lehet ismerős).
Ezt követik a metódusok rendes paraméterei.
c l a s s Taska ( o b j e c t ):
d e f info ( self ):
p r i n t ( " Ez egy taska . " )

41 / 60
Adattagok
Az adattagokat alapvetően egy kitüntetett metódusban szokás
létrehozni, ez pedig az __init__ metódus.
Ez a kitüntetett metódus lesz felelős az osztályból készült objektum
kezdeti inicializálásáért
Gyakorlatilag ez a konstruktor Pythonban (technikailag nem az, de
tekinthetünk rá konstruktorként)
Az adott objektumpéldány saját adattagjaira szintén a self
segítségével lehet hivatkozni, így jelezzük, hogy ez nem egy lokális
változó, hanem az objektumpéldány saját tulajdonsága (és a
megszokott pont operátor)
d e f __init__ ( self , marka = " Nincs " , szin = " fekete " ):
self . marka = marka
self . szin = szin

42 / 60
Példa
d e f __init__ ( self , marka = " Nincs " , szin = " fekete " , noi = False ):
self . marka = marka
self . szin = szin
self . noi = noi
self . tartalma = l i s t ()
d e f berak ( self , targy ):

self . tartalma . append ( targy )
d e f keres ( self , mit ):

i f self . noi :
p r i n t ( " Ez egy noi taska , ki tudja benne van - e a keresett t
r e t u r n None
e l i f mit i n self . tartalma :
p r i n t ( " Megtalaltam a keresett targyat " )
r e t u r n self . tartalma . pop ( self . tartalma . index ( mit ))
else :
p r i n t ( " Nem talaltam a targyat ! " )
r e t u r n None
43 / 60
Objektumok példányosítása
Ez eddig jó, de most már használni is kéne az osztályokat, erre való a
példányosítás
Az a folyamat, amikor az osztályból készítünk egy példányt.
Pythonban egyszerű: leírjuk az osztály nevét, majd zárójelben a
paramétereit (ha nincs, üres zárójelpárat írunk)
en_taskam = Taska ()
en_taskam . berak ( " kulcs " )
en_taskam . berak ( " toll " )
en_taskam . berak ( " fuzet " )
en_taskam . keres ( " kulcs " ) # keres
noi_taska = Taska ( " Samsonite " , " rozsaszin " , True )

noi_taska . berak ( " kulcs " )
noi_taska . berak ( " alma " )
noi_taska . berak ( " konyv " )
noi_taska . keres ( " kulcs " ) # keres
Megtalaltam a keresett targyat

Ez egy noi taska , ki tudja benne van - e a keresett targy

44 / 60
Dinamizmus
d e f __init__ ( self ):


i f mit i n self . tartalma :
p r i n t ( " Megtalaltam a keresett targyat " )
else :
p r i n t ( " Nem talaltam a targyat ! " )
d e f berak_atveres ( targy ):
p r i n t ( " Ugy teszek , mintha beraknam a kovetkezo targyat : " , targy )
en_taskam . berak ( " Konyv " )
en_taskam . hatizsak = True
en_taskam . berak = berak_atveres
en_taskam . berak ( " laptop " )
en_taskam . keres ( " laptop " )

45 / 60
Dinamizmus
laptop
Nem talaltam a targyat !
A Python dinamizmusa miatt azonban a létrejövő objektumokat lehet

piszkálni
Például új adattagot hozzáadni, meglévőt törölni, új viselkedést
hozzáadni, meglévőt módosítani.
Azonban ezt csak legutolsó megoldást lehet/szokták alkalmazni,
hiszen azért készítünk osztályt, hogy az objektumainknak legyen egy
formális definíciója

46 / 60
Láthatóságok
Más OOP nyelvekben megszokhattuk a különböző láthatósági

módosítáokat
Pythonban ezek nem léteznek, nincs lehetőség a láthatóság állítására
Konvencionálisan az egy alulvonás a név előtt jelenti azt, hogy az
adott tagváltozó vagy tagmetódus nem publikus használatra szánt,
például: _nev
Két alulvonás a név előtt konvencionálisan privát láthatóság jelzésére
szolgál, azonban itt az interpreter is dolgozik: mangling történik, a
__foo változó osztályon kívül ezen a néven elérhetetlen (de ez sem
igazi privát láthatóság, megkerülhető)
Két alulvonás a név előtt és után is: Python-beli speciális függvények
Egy alulvonás a név után: konvencionálisan arra használjuk, hogy egy
beépített névvel való névelfedést elkerüljünk, például: str_ = "Egy
szoveg"

47 / 60
Típusellenőrzés - isinstance
Mivel a Python nem fordított nyelv, így statikus típusellenőrzés sincs
benne
Ami aggasztó lehet, ha szeretnénk ellenőrizni, hogy a metódusunk egy
bizonyos típusú paramétert kapott-e (például egy Táska objektumot,
de akár számot, szöveget, stb.)
Sajnos ezt csak dinamikusan, futás közben tudjuk ellenőrizni, az
isinstance nevű beépített fügvénnyel.
Két paramétere van, az első az objektum, amit vizsgálunk, a második
pedig a típus, amire vizsgálunk.
Típusnak csak a nevét kell megadni (ha osztály típust adunk meg,
akkor az osztály nevét).
>>> i s i n s t a n c e (2345 , i n t )
True
>>> i s i n s t a n c e ( " 222 " , i n t )
False
>>> a = " Cseresznye "
>>> i s i n s t a n c e (a , s t r )
True
48 / 60
Objektumok reprezentálása szövegként
Néhány beépített függvénynek speciális jelentése is van: például

segítségükkel felüldefiniálhatjuk az operátorok működését.
Talán a leghíresebb ilyen függvény a __str__, amely az objektumot
szövegként reprezentálja.
Ez a metódus egy szöveggel tér vissza, ami bármi lehet.
Ezt követően az objektumunkat simán kiírhatjuk, például az
alapértelmezett kimenetre.

49 / 60
Objektumok reprezentálása szövegként
d e f __init__ ( self ):


i f mit i n self . tartalma :
p r i n t ( " A keresett targy megvan . " )
d e f __str__ ( self ):
r e t u r n " Ez egy taska , amiben % d elem van " % l e n ( self . tartalma )
p r i n t ( en_taskam )
en_taskam . berak ( " tolltarto " )
p r i n t ( en_taskam )
Ez egy taska , amiben 0 elem van

Ez egy taska , amiben 1 elem van

50 / 60
Objektumok összehasonlítása
Egy másik ilyen speciális metódus a __eq__ ami az objektumot

hasonlítja össze egy másikkal, és megmondja, hogy egyenlőek-e
c l a s s Ember ( o b j e c t ):
fizet es_emele s = 1.04
d e f __init__ ( self , nev , ig_szam ):
self . nev = nev
self . ig_szam = ig_szam
d e f __eq__ ( self , masik ):

i f n ot i s i n s t a n c e ( masik , Ember ):
r e t u r n False
r e t u r n self . ig_szam == masik . ig_szam
e1 = Ember ( " Zsolt " , " 123456 AA " )

e2 = Ember ( " Zsolt " , " 123456 AA " )
p r i n t ( e1 == e2 )
True

51 / 60
Operátorok felüldefiniálása
Összeadás: __add__(objektum + masik), __radd__(reverse add,

masik+objektum), __iadd__ (objektum += masik), __isub__
(objektum -= masik)
Egyenlőség: __eq__(objektum == masik), __neq__ (objektum !=
masik)
Összehasonlítás: __lt__ (objektum < masik), __gt__(objektum >
masik), __le__(objektum <= masik), __ge__(objektum >=
masik)

52 / 60
Öröklődés
A deklaráció helyén tudjuk megadni az ősosztály nevét. A Python

támogatja a többszörös öröklődést.
A hivatkozott attribútum nem található meg a leszármazott
osztályban, akkor a keresés az ősosztályban folytatódik. Ez rekurzívan
folytatódik az ősosztály ősére is.
A leszármazott osztályok felüldefiniálhatják az ősosztályok
attribútumait.
Ezt követően az objektumunkat simán kiírhatjuk, például az
alapértelmezett kimenetre.
print(help(osztálynév)) függvény kiírja az osztály információkat
c l a s s Vezet ő ( Ember ):
pass

53 / 60
Öröklődés
Meghívható a leszármazott osztályból az ősosztály metódusa.

A super() függvényt tudjuk használni, ha egyszeres öröklődáés van.
Többsözör öröklődés esetén az osztálynevét kell használnunk.
c l a s s Vezet ő ( Ember ):
fizet es_emele s = 1.10
d e f __init__ ( self , nev , ig_szam , beosztas ):
s u p e r (). __init__ ( nev , ig_szam )
# Ember . _ _ i n i t _ _ ( nev , ig_szam )
self . beosztas = beosztas

54 / 60
Öröklődés
Típus ellenőrzésre használhatjuk a isinstance(objektum,

osztály) függvényt
Öröklődést tudjuk ellenőrizni a issubclass(osztály, ősosztály)
v = Vezeto ( " Zsolt " , " 123456 AA " ," vezet ő " )
i s i n s t a n c e (v , Vezeto ) # True
i s i n s t a n c e (v , Ember ) # True
i s s u b c l a s s ( Vezeto , Ember ) # True

55 / 60
Getter/setter
Attól, hogy nem tudunk láthatóságokat megadni az adattagoknak,

még nem szükségszerű elhagyni a getter/setter függvényeket, hiszen
ezek által lehet ellenőrzött módon lekérni/frissíteni az objektum
adattagjának értékét
Ez más nyelvekből ismerős módon történik, egyszerűen az adattag
nevéből készítünk get_adattag és set_adattag függvényeket.
Így ellenőrzött módon férhetünk hozzá/módosíthatjuk az objektumok
tulajdonságait.

56 / 60
Getter/setter
c l a s s Celsius :
d e f __init__ ( self , homerseklet = 0):
self . se t_ ho m er se kl e t ( homerseklet )
d e f fahrenheit ( self ):
r e t u r n ( self . get_ h om er se kl e t () * 1.8) + 32
d e f g et _h om e rs ek le t ( self ):
r e t u r n self . _homerseklet
d e f s et _h om e rs ek le t ( self , value ):
i f value < -273:
p r i n t ( " -273 fok alatti homerseklet nem lehet " )
else :
self . _homerseklet = value
c1 = Celsius (30)
p r i n t ( c1 . fahrenheit ())
c1 . s e t_ ho me rs e kl et ( -1000)
86.0
-273 fok alatti homerseklet nem lehet

57 / 60
Propertyk
Azonban Pythonban ezt a formát ritkán használjuk, inkább
propertyket használunk ilyen célból.
Egyébként is mennyire csúnya lenne a Pont osztályunk, ha így kellene
beállítani a koordinátákat két pont átlagaként: p3.set_x(p1.get_x()
+ p2.get_x())
Így kívülről a kód használója úgy látja, mintha sima, publikus
adattagokkal dolgozna, azonban az objektum adatmanipulációja így is
ellenőrizve van.
Célja: objektum adattagjainak ellenőrzött elérése
Használata: a propertyvá kívánt tenni változó neve elé alulvonást
rakunk (nem publikus használatra szánjuk), majd készítünk két
metódust, egy "gettert" (a metódus fölé írjuk a @property
dekorátort), és egy "settert" (a metódus fölé írjuk a
@<adattag>.setter dekorátort)
A beállításra és lekérésre használt metódusok hagyományos
getter-setter függvények.
58 / 60
Propertyk
c l a s s Celsius :
d e f __init__ ( self , homerseklet = 0):
self . _homerseklet = homerseklet
@property
d e f homerseklet ( self ):
p r i n t ( " Lekerjuk " )
r e t u r n self . _homerseklet
@homerseklet . setter
d e f homerseklet ( self , value ):
i f value < -273:
p r i n t ( " Nem lehet -273 foknal hidegebbet beallitani " )
else :
p r i n t ( " Beallitjuk " )
self . _homerseklet = value
c1 = Celsius (30)
c1 . homerseklet = 100
p r i n t ( c1 . homerseklet )
Beallitjuk
Lekerjuk
100
59 / 60
Köszönöm a figyelmet!
Szkriptnyelvek 2018 60 / 60

Szkriptnyelvek: Dr. Dombi József Dániel Antal Gábor

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Szkriptnyelvek: Dr. Dombi József Dániel Antal Gábor

Uploaded by

Copyright:

Available Formats

Szkriptnyelvek

Dr. Dombi József Dániel

Szkriptnyelvek 2018 Python 1 / 60

2 Objektumorientált tervezés alapfogalmak

Szkriptnyelvek 2018 Python 2 / 60

2 Objektumorientált tervezés alapfogalmak

Szkriptnyelvek 2018 Python Objektumorientáltság 3 / 60

Dr. Dombi József Dániel

Szkriptnyelvek 2018 Objektumorientált tervezés 4 / 60

2 Objektumorientált tervezés alapfogalmak

Szkriptnyelvek 2018 Objektumorientált tervezés 5 / 60

2 Objektumorientált tervezés alapfogalmak

Szkriptnyelvek 2018 Objektumorientált tervezés Modellezés 6 / 60

Szkriptnyelvek 2018 Objektumorientált tervezés Modellezés 7 / 60

Alkalmas üzleti folyamatok leírására

Szkriptnyelvek 2018 Objektumorientált tervezés Modellezés 8 / 60

2 Objektumorientált tervezés alapfogalmak

Szkriptnyelvek 2018 Objektumorientált tervezés UML 9 / 60

Unified Modeling Language

Szkriptnyelvek 2018 Objektumorientált tervezés UML 10 / 60

Szkriptnyelvek 2018 Objektumorientált tervezés UML 11 / 60

Szkriptnyelvek 2018 Objektumorientált tervezés UML 12 / 60

Statikus diagram Dinamikus diagram

Komponens Telepítési Állapotátmeneti Aktivitás

Szkriptnyelvek 2018 Objektumorientált tervezés UML 13 / 60

2 Objektumorientált tervezés alapfogalmak

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság alapfogalmak14 / 60

Egy entitás ábrázolása (valós világból, vagy elvonatkoztatott)

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság alapfogalmak15 / 60

Egy a lehetséges létezései közül

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság alapfogalmak16 / 60

Annak módja, hogyan reagál egy objektum más objektumok kéréseire

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság alapfogalmak17 / 60

Minden objektum egyedi, akkor is, ha állapotuk azonos

programozas : Kurzus algoritmusok : Kurzus

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság alapfogalmak18 / 60

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság alapfogalmak19 / 60

Nagy rendszereknél elkerülhetetlen az osztályok csoportosítása

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság alapfogalmak20 / 60

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság alapfogalmak21 / 60

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság alapfogalmak22 / 60

Osztályok közötti kétirányú összeköttetés (navigálási irány megadható

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság alapfogalmak23 / 60

Asszociáció egy speciális formája

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság alapfogalmak24 / 60

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság alapfogalmak25 / 60

Osztályok közötti kapcsolat (reláció), ahol egy osztály megosztja a

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság alapfogalmak26 / 60

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság alapfogalmak27 / 60

Példa: a kétéltű jármű egy motorgépjármű (ami egy jármű) és egyben

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság alapfogalmak28 / 60

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság alapfogalmak29 / 60

2 Objektumorientált tervezés alapfogalmak

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság Pythonban 30 / 60

A paraméterlista végén megadhatunk egy paramétert, ami hatására

d e f atlag ( szam1 , szam2 , szam3 =0): # 2 vagy 3 p a r a m e t e r

d e f atlag2 (* args ): # b a r m e n n y i p a r a m e t e r t kaphat igy a f u g g v e n y

p r i n t ( atlag (10 , 20 , 30))

Szkriptnyelvek 2018 Objektumorientált tervezés Objektumorientáltság Pythonban 31 / 60

A paraméterlista végén megadhatunk egy paramétert, ami hatására

d e f atlag ( szam1 , szam2 , szam3 =0): # 2 vagy 3 p a r a m e t e r

d e f atlag2 (* args ): # b a r m e n n y i p a r a m e t e r t kaphat igy a f u g g v e n y

p r i n t ( atlag (10 , 20 , 30))

Egy másik ilyen speciális metódus a eq ami az objektumot

d e f eq ( self , masik ):

Összeadás: add(objektum + masik), radd(reverse add,