Objektumok megkülönböztetése, egyenlőségvizsgálata általában a példányra definiált adatattribútumok összehasonlításával történik. Azonban a pusztán csak az adatattribútumokon alapuló egyenlőségvizsgálat nem minden valós helyzetet tud megfelelően modellezni. Egy ilyet mutat be a következő ábra egyszerű, hétköznapi példája.
A történet röviden: Jancsi és Pisti két kisgyerek, akik együtt szoktak játszani a közeli játszótéren. Egyszer Pisti egy szép piros gumilabdával jelent meg és büszkélkedve rugdosta és pattogtatta új játékát. Jancsi persze mint általában a gyerekek többsége, rögtön megirigyelte Pisti új labdáját, és otthon addig nyaggatta az apját, hogy vegyen neki egy ugyanolyan labdát, mígnem az elment a játékboltba és vett egy ránézésre ugyanolyan gumilabdát, vagyis ami színben és méretben (átmérőben) is megegyezett Pistiével. Jancsi nagyon megörült mikor megkapta az apjától, mert most már neki is volt egy ugyanolyan labdája, mint Pistinek. Az öröme azonban nem tartott sokáig. Ugyanis amikor Pistivel a játszótéren újra találkoztak, és mindketten hozták a kinézetre ugyanolyan labdájukat, az első pattogtatások után kiderült, hogy labdája mégsem ugyanolyan, mert Pisti labdája magasabbra tud pattanni, ami nyilván nagyobb játékélményt jelent. Jancsi ezért újra elégedetlen lett, mert mégsem ugyanolyan labdát kapott. Mindez azért történt, mert apja az „ugyanolyan” fogalmán kinézetbeli, kivitelbeli (jelen esetben, anyag, szín és méret) jellemzők egyezését értette, holott – ahhoz, hogy Pisti labdájával a játék, a használat szempontjából is egyező legyen – a labda bizonyos (jelen esetben a visszapattanási) képességét, viselkedését, ill. annak eredményét is tesztelni kellett volna.
A lényeg tehát, hogy e valós helyzet szoftvermodelljében, a labdát képviselő Ball osztály __eq__ metódusában az egyenlőség megállapításához a kivitelt/kinézetet leíró adatattribútumokon (szín, méret) felül egy képességet, viselkedést (visszapattanás) leíró metódust, pontosabban annak eredményét is vizsgálni szükséges.
Egy labda visszapattanási magassága a valóságban több fizikai tényezőtől függ, amelyek közül elsősorban az ejtési magasság (drop height), a labdába fújt levegő nyomása (pressure), valamint a labda anyagának a sűrűsége (density) a meghatározó. A játékboltban a labdavásárló ezekből egyedül az ejtési magasságot határozhatja meg, de a másik két paraméter értéke a vásárló számára nem hozzáférhető, hiszen senki nem vesz úgy játéklabdát, hogy egy nyomás- és anyagsűrűségmérővel felszerelkezve méréssorozatokat végez a labdákon. Ezért a Ball osztályban a nyomás és anyagsűrűség értékek privát adatattribútumok, amelyek értéke a példányosításkor (ami a valóságban a labda gyártásának felel meg) kerül meghatározásra.
A visszapattanási magasság tehát az ejtési magasság, a nyomás és a sűrűség függvénye, vagyis a Ball osztályban a visszapattanási magasságot meghatározó bounce() metódus ezeket használja, ahol az ejtési magasság a metódus argumentuma. Bár a valóságban nem pontosan igaz, de az egyszerűség kedvéért feltételezzük, hogy a visszapattanási magasság e három tényezővel egyenesen arányos.
A kérdés az, hogy a Ball osztályban implementált, egyenlőségvizsgálatra szolgáló __eq__ metódusban hogyan állapítsuk meg – a szín és méret egyezőségén felül – a visszapattanási magasság egyezőségét egy másik Ball példánnyal összevetve?
Gondolhatnánk arra, hogy mivel a bounce() determinisztikus függvénye a nyomásnak és a sűrűségnek, ezért a szín és méret adatattribútumokhoz hasonlóan össze kell vetni a nyomás és sűrűség privát adatattribútumokat is. Ha ezek megegyeznek az összehasonlított példányéval, akkor a visszapattanási magasságok is egyezők, és ha a szín és méret is azonos, akkor a két példány biztos, hogy egyenlő. Ezzel a gondolatmenettel kialakított Ball osztály definícióját és tesztelését láthatjuk alább:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 |
class Ball: def __init__(self, color, size, _pressure, _density): self.color, self.size, self._pressure, self._density = color, size, _pressure, _density def __repr__(self): return (f'{type(self).__name__}(color="{self.color}", size={self.size}, pressure={self._pressure}, density={self._density})') def bounce(self, height) -> float: """Adott magasságból leejtve a felpattanási magasságot adja vissza. Egyszerűség kedvéért feltétezzük, hogy a felpattanás mértéke egyenesen arányos az ejtési magassággal, a belső nyomással és a labda anyagának sűrűségével. """ return 0.25 * height * self._pressure * self._density def __eq__(self, ball): """Az egyenlőségvizsgálat az adatattribútumok alapján történik.""" if not isinstance(ball, type(self)): return NotImplemented return (self.color, self.size, self._pressure, self._density) == (ball.color, ball.size, ball._pressure, ball._density) # TESZT pressure_density_pairs = zip([1, 1, 2, 2, 0.5], [1, 1, 1, 0.5, 2]) # Az egyes labdapéldányokhoz a nyomás és sűrűség értékek. balls = [Ball('red', 1, p, d) for p, d in pressure_density_pairs] # Labdapéldányok létrehozása. # Az első labdapéldány összehasonlítása a többi labdával. for ball in balls[1:]: print('A két összehasonlított labda: {} és {}'.format(balls[0], ball)) txt = ('Ezek színe és mérete megegyezik, a nyomás és anyagsűrűség {}, és {}m magasról leejtve {:.2f} és {:.2f} méter magasra pattannak fel.') s = 'szintén megegyezik' if (balls[0]._pressure, balls[0]._density) == (ball._pressure, ball._density) else 'valamelyike eltér' print(txt.format(s, h := 3, balls[0].bounce(h), ball.bounce(h))) print('A két labda {}.\n'.format('egyenlő'.upper() if balls[0] == ball else 'nem egyenlő'.upper())) # Eredmény: # A két összehasonlított labda: Ball(color="red", size=1, pressure=1, density=1) és Ball(color="red", size=1, pressure=1, density=1) # Ezek színe és mérete megegyezik, a nyomás és anyagsűrűség szintén megegyezik, és 3m magasról leejtve 0.75 és 0.75 méter magasra pattannak fel. # A két labda EGYENLŐ. # # A két összehasonlított labda: Ball(color="red", size=1, pressure=1, density=1) és Ball(color="red", size=1, pressure=2, density=1) # Ezek színe és mérete megegyezik, a nyomás és anyagsűrűség valamelyike eltér, és 3m magasról leejtve 0.75 és 1.50 méter magasra pattannak fel. # A két labda NEM EGYENLŐ. # # A két összehasonlított labda: Ball(color="red", size=1, pressure=1, density=1) és Ball(color="red", size=1, pressure=2, density=0.5) # Ezek színe és mérete megegyezik, a nyomás és anyagsűrűség valamelyike eltér, és 3m magasról leejtve 0.75 és 0.75 méter magasra pattannak fel. # A két labda NEM EGYENLŐ. # # A két összehasonlított labda: Ball(color="red", size=1, pressure=1, density=1) és Ball(color="red", size=1, pressure=0.5, density=2) # Ezek színe és mérete megegyezik, a nyomás és anyagsűrűség valamelyike eltér, és 3m magasról leejtve 0.75 és 0.75 méter magasra pattannak fel. # A két labda NEM EGYENLŐ. |
Ez a megoldás azonban nem teljesen kielégítő. Mégpedig azért, mert akkor, és csak akkor tekinti visszapattanási magasság szempontjából a két labda példányt egyenlőnek, ha a nyomás és sűrűség egyenlő. Ez a teszteredményekből is látható. Holott ugyanakkora visszapattanási magasság a nyomás és sűrűség kombinációinál is kiadódhat, mégpedig minden olyan nyomás- sűrűség pár esetén, amelyeknél a szorzat az inicializálási értékek szorzatával egyező (pl. kétszeres nyomás, fele akkora sűrűség, vagy fordítva feleakkora nyomás és kétszeres sűrűség esetén).
Az eddigi megközelítés tehát nem egészen jó; helyette az egyenlőségvizsgálatban a bounce() metódust kell meghívni, és a visszatérési értékeket kell összehasonlítani. Az ennek megfelelően módosított __eq__ metódussal a Ball osztály a teszteredményekkel a következő. Ezek közül az utolsó kettő is az elvárásoknak megfelelő, ellentétben az előző változatéval.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
from math import isclose class Ball: def __init__(self, color, size, _pressure, _density): self.color, self.size, self._pressure, self._density = color, size, _pressure, _density def __repr__(self): return (f'{type(self).__name__}(color="{self.color}", size={self.size}, pressure={self._pressure}, density={self._density})') def bounce(self, height) -> float: """Adott magasságból leejtve a felpattanási magasságot adja vissza. Egyszerűség kedvéért feltétezzük, hogy a felpattanás mértéke egyenesen arányos az ejtési magassággal, a belső nyomással és a labda anyagának sűrűségével. """ return 0.25 * height * self._pressure * self._density def __eq__(self, ball): """Az egyenlőségvizsgálat a nyilvános adatattribútumok és a felpattanási magasság alapján történik. A felpattanás mértékét egy 10 méternél nem nagyobb, önkényesen meghatározott ejtési magasságnál mérjük. """ if not isinstance(ball, type(self)): return NotImplemented drop_height = 2 # Ejtési magasság méterben. return (self.color, self.size) == (ball.color, ball.size) and isclose(self.bounce(drop_height), ball.bounce(drop_height)) # TESZT pressure_density_pairs = zip([1, 1, 2, 2, 0.5], [1, 1, 1, 0.5, 2]) # Az egyes labdapéldányokhoz a nyomás és sűrűség értékek. balls = [Ball('red', 1, p, d) for p, d in pressure_density_pairs] # Labdapéldányok létrehozása. # Az első labdapéldány összehasonlítása a többi labdával. for ball in balls[1:]: print('A két összehasonlított labda: {} és {}'.format(balls[0], ball)) txt = ('Ezek színe és mérete megegyezik, a nyomás és anyagsűrűség {}, és {}m magasról leejtve {:.2f} és {:.2f} méter magasra pattannak fel.') s = 'szintén megegyezik' if (balls[0]._pressure, balls[0]._density) == (ball._pressure, ball._density) else 'valamelyike eltér' print(txt.format(s, h := 3, balls[0].bounce(h), ball.bounce(h))) print('A két labda {}.\n'.format('egyenlő'.upper() if balls[0] == ball else 'nem egyenlő'.upper())) # Eredmény: # A két összehasonlított labda: Ball(color="red", size=1, pressure=1, density=1) és Ball(color="red", size=1, pressure=1, density=1) # Ezek színe és mérete megegyezik, a nyomás és anyagsűrűség szintén megegyezik, és 3m magasról leejtve 0.75 és 0.75 méter magasra pattannak fel. # A két labda EGYENLŐ. # # A két összehasonlított labda: Ball(color="red", size=1, pressure=1, density=1) és Ball(color="red", size=1, pressure=2, density=1) # Ezek színe és mérete megegyezik, a nyomás és anyagsűrűség valamelyike eltér, és 3m magasról leejtve 0.75 és 1.50 méter magasra pattannak fel. # A két labda NEM EGYENLŐ. # # A két összehasonlított labda: Ball(color="red", size=1, pressure=1, density=1) és Ball(color="red", size=1, pressure=2, density=0.5) # Ezek színe és mérete megegyezik, a nyomás és anyagsűrűség valamelyike eltér, és 3m magasról leejtve 0.75 és 0.75 méter magasra pattannak fel. # A két labda EGYENLŐ. # # A két összehasonlított labda: Ball(color="red", size=1, pressure=1, density=1) és Ball(color="red", size=1, pressure=0.5, density=2) # Ezek színe és mérete megegyezik, a nyomás és anyagsűrűség valamelyike eltér, és 3m magasról leejtve 0.75 és 0.75 méter magasra pattannak fel. # A két labda EGYENLŐ. |
Kérdésként merülhet fel, hogy a bounce() metódust milyen ejtési magasság értékre vagy értékekre kell meghívni az __eq__ metódusban. Általánosabban megfogalmazva a kérdés az, hogy ha az egyenlőségvizsgálatban metódust is meg kell hívni, és annak van paramétere, akkor milyen argumentummal kell azt meghívni? A válasz, hogy ez eset és modell függő.
Maradva a labdás példánál, semmi értelme, hogy az összehasonlításkor a bounce() argumentuma mondjuk 10 méternél több legyen, mert jelen példában kisgyerekekről van szó, és ők vagy a saját magasságukból dobják le a labdát, vagy egy mászóka tetejéről ejtik le, vagy felrúgják, ami kisgyerek esetén nem megy 10 méternél magasabbra. Ha megvan ez a felső limit, akkor az is csupán a követelményspecifikáció kérdése, hogy elég egyetlen ejtési magasságot figyelembe venni az összevetésnél, vagy többre van szükség. Ha a jelen példa valóságát vesszük, akkor elég egy érték, mert a szülők, amikor megveszik a labdát tesztelés céljából egy-kétszer lepattintják a boltban, de általában nem különböző magasságokból, hanem kb. csípő- vagy mellmagasságból.
Ha az egyéni __eq__ implementációban metódusok visszatérési értékét is össze kell hasonlítani, akkor célszerű a metódushívásokat az adatattribútumok összehasonlítását követően megtenni, hogy minél kisebb legyen a költsége az egyenlőségvizsgálatnak. Ugyanis, ha a balról jobbra történő kiértékeléskor először az adatattribútumok összevetése történik meg, akkor az esetleg futási időben költséges metódushívás csak akkor történik meg, ha minden adatattribútum megegyezik.
Lehetőség van persze arra, hogy az egyenlőségvizsgálatot a példányokat használó kliens kódban a példányok adatattribútumai alapján végezzük és az egyenlőség megállapításhoz még szükséges metódushívásokat, és ezek eredményének összehasonlítását is itt hajtjuk végre, majd a két kiadódó logikai érték alapján döntünk a példányok egyenlőségéről. Ez azonban a kód több pontján történő vizsgálat esetén kódismétlést eredményez, ami a hibalehetőséget növeli.
Egyenlőségvizsgálatról, valamint az __eq__ metódus, és általában az összehasonlító műveleteket megvalósító metódusok egyéni igényre szabásáról a Python tudásépítés lépésről lépésre című e-könyvben a „Kapcsolatban – relációk objektumok között” fejezet „Ami egyenlő az nem feltétlen azonos” alfejezetében, illetve a „Mágikus metódusok egyedi igényre szabott osztályokban” fejezet „Összehasonlító operátorok” alfejezetében kaphatunk további részleteket.