TIP

De opgave van deze oefening bestaat uit relatief veel tekst. Daarom kan het handig zijn om 2 browser vensters te openen (eentje met de opgave en eentje waarin je de oplossing noteert), zodat je niet steeds moet scrollen.

Elk object van de klasse Figuur is opgebouwd uit een aantal Vormen. We beschouwen in deze oefening twee specifieke soorten vormen, namelijk rechthoeken (objecten van de klasse Rechthoek) en driehoeken (objecten van de klasse Driehoek). Omdat rechthoeken en driehoeken speciale soorten vormen zijn, erven beide klassen over van de klasse Vorm. Programmeer de klassen Vorm, Rechthoek, Driehoek en Figuur, volgens onderstaande richtlijnen.

Klasse Vorm

• Elke vorm heeft een naam en een type, beide string. De constructor van de klasse heeft 1 argument, namelijk de naam van de vorm. Het type initialiseer je op de tekst '?'.
• De methode __str__() levert de stringgedaante van de vorm, namelijk (naam,type) (dus naam en type, gescheiden door een komma, het geheel tussen ronde haakjes).
• Definieer de methode __eq__(), waarbij 2 vormen als gelijk beschouwd worden als en slechts als ze dezelfde naam hebben
• Programmeer een geschikte methode __hash__() die consistent is met de __eq__()-methode die je zonet programmeerde.
• Programmeer de methode oppervlakte() (zonder argumenten), die de waarde 0 als resultaat oplevert.

Voorbeeld (tabblad 1)

v1 = Vorm('A')
v2 = Vorm('B')
v3 = Vorm('A')
v4 = Vorm('C')
print(v1 == v2)                 #False
print(hash(v1) == hash(v2))     #False
print(v1 == v3)                 #True
print(hash(v1) == hash(v3))     #True
v = set([v1, v2, v3, v4])
print(set([str(e) for e in v])) #{'(B,?)', '(C,?)', '(A,?)'}

Klasse Rechthoek

De klasse Rechthoek erft over van Vorm. Gebruik zoveel mogelijk de functionaliteit uit de klasse Vorm!

• Programmeer een constructor met 3 argumenten, namelijk:
  • naam: naam van de vorm
  • l: lengte van de rechthoek (geheel)
  • b: breedte van de rechthoek (geheel)
  Zorg dat het type van de vorm nu gelijk is aan de string 'R'.
• De methode __str__() bestaat uit dezelfde uitvoer als de methode __str__() uit de klasse Vorm (met uiteraard het juiste type), gevolgd door [lenge,breedte] (lengte en breedte, gescheiden door een komma, en dit tussen vierkante haakjes.
• De methode oppervlakte() levert nu de oppervlakte van de rechthoek (geheel getal).
• Let erop dat 2 vormen identiek zijn als en slechts als hun namen identiek zijn (ongeachte andere attributen van het object!).

Klasse Driehoek

Ook de klasse Driehoek erft over van Vorm. Gebruik ook hier zoveel mogelijk de functionaliteit uit de klasse Vorm!

• Programmeer een constructor met 3 argumenten, namelijk:
  • naam: naam van de vorm
  • b: basis van de driehoek (geheel)
  • h: hoogte van de rechthoek (geheel)
  Zorg dat het type van de vorm nu gelijk is aan de string 'D'. Verder is gegeven dat basis en hoogte niet beiden oneven zijn.
• De methode __str__() bestaat uit dezelfde uitvoer als de methode __str__() uit de klasse Vorm (met uiteraard het juiste type), gevolgd door [basis,hoogte] (basis en hoogte, gescheiden door een komma, en dit tussen vierkante haakjes.
• De methode oppervlakte() levert nu de oppervlakte van de driehoek (geheel getal, vermits basis en/of hoogte even zijn).
• Let erop dat 2 vormen identiek zijn als en slechts als hun namen identiek zijn (ongeachte andere attributen van het object!).

Voorbeeld (tabblad 2)

v = Vorm('A')
r1 = Rechthoek('B', 1, 2)
r2 = Rechthoek('C', 3, 4)
d1 = Driehoek('D', 2, 6)
d2 = Driehoek('B', 3, 4)

isinstance(r1, Rechthoek) #True
isinstance(r2, Vorm)      #True
isinstance(d1, Driehoek)  #True
isinstance(d2, Vorm)      #True

print(v)  #(A,?)
print(r1) #(B,R)[1,2]
print(r2) #(C,R)[3,4]
print(d1) #(D,D)[2,6]
print(d2) #(B,D)[3,4]

print(v.oppervlakte())  #0
print(r1.oppervlakte()) #2
print(r2.oppervlakte()) #12
print(d1.oppervlakte()) #6
print(d2.oppervlakte()) #6

vormen = set([v, r1, r2, d1, d2])
print(set([str(e) for e in vormen])) #{'(C,R)[3,4]', '(A,?)', '(D,D)[2,6]', '(B,R)[1,2]'}

Klasse Figuur

Elke figuur bestaat uit een verzameling Vormen. Initieel is deze verzameling leeg. De Figuur wordt dan opgebouwd door telkens een Vorm toe te voegen aan de Figuur via de +=-operator.

• de methode __str__() levert een stringgedaante, die bestaat uit alle stringgedaanten van de vormen waaruit de figuur opgebouwd is, gescheiden door komma's en het geheel tussen accolades. De stringedaanten van de vormen komen in alfabetische volgorde voor (alfabetisch op vormnaam).
• de operator += heeft als effect:
  • indien het rechteroperand een object van het type Vorm is, wordt deze vorm toegevoegd aan de verzameling vormen waaruit de figuur opgebouwd is (let op: vermits het om een verzameling gaat, en 2 vormen identiek zijn als ze identieke namen hebben, heeft deze operator geen effect als je een vorm probeert toe te voegen met een naam die al voorkomt in de figuur)
  • indien het rechteroperand een tuple is, is dit steeds een tuple dat bestaat uit 4 componenten, namelijk:
    • een string die het type van de vorm aangeeft, hier dus 'R' of 'D'
    • een string die de naam van de vorm aangeeft
    • een geheel getal, dat de lengte van een rechthoek of de basis van een driehoek voorstelt (naargelang de waarde van de eerste tuplecomponent)
    • een geheel getal, dat de breedte van een rechthoek of de hoogte van een driehoek voorstelt (naargelang de waarde van de eerste tuplecomponent)
• de methode oppervlakte() levert de som van de oppervlakten van alle vormen van de figuur
• de methode max_oppervlakte() levert de vorm met de grootste oppervlakte van de figuur (dus een object van de klasse Vorm of een subklasse ervan, en niet de waarde van de maximale oppervlakte). Indien er meerdere vormen dezelfde maximale oppervlakte hebben, dan mag je 1 van die vormen als resultaat teruggeven.

Voorbeeld (tabblad 3)

v = [Vorm(naam) for naam in ['A', 'B']]
r = [Rechthoek(naam, l, b) for (naam, l, b) in zip(['RA', 'RB'], [1, 2], [3, 4])]
d = [Driehoek(naam, b, h) for (naam, b, h) in zip(['DA', 'DB'], [2, 4], [3, 5])]

fig = Figuur()
for vorm in v + r + d:
	fig += vorm
print(fig) #{(A,?),(B,?),(DA,D)[2,3],(DB,D)[4,5],(RA,R)[1,3],(RB,R)[2,4]}

for e in [('R', 'RC', 4, 5), ('R', 'RD', 2, 7), ('D', 'DC', 2, 2), ('D', 'DD', 4, 4)]:
	fig += e
print(fig)
#{(A,?),(B,?),(DA,D)[2,3],(DB,D)[4,5],(DC,D)[2,2],(DD,D)[4,4],(RA,R)[1,3],(RB,R)[2,4],(RC,R)[4,5],(RD,R)[2,7]}

print(fig.oppervlakte())     #68
print(fig.max_oppervlakte()) #(RC,R)[4,5]