Oppgaver
7.04: Plante og Hage
a) Lag en klasse Plante. Hver plante har sin egen vann_beholder og max_grense_vann. Plante har følgende grensesnitt:
class Plante:
def __init__(self, max_grense_vann):
def vann_plante(self, cl_vann):
# Øker vann_beholder med cl_vann.
# Om vann_beholder blir større enn
# max_grense_vann, dør planten
def ny_dag(self):
# For hver nye dag minker vann_beholder med 20 (siden
# planten drikker vannet). Om vann_beholder blir mindre
# enn 0 dør planten.
def er_levende():
# Om planten er levende skal det returneres True, om planten
# ikke er levende skal det returneres False.
# Hint: Det kan være lurt å ha en variabel som holder styr på
# om planten er levende eller ikke.
b)
1. Opprett et Plante-objekt med en max max_grense_vann på 40 og et annet Plante-objekt med max_grense_vann på 90.
2. Vann begge plantene med 10 cl.
3. La det gå to dager for begge plantene.
4. Sjekk om plantene er levende og skriv ut status til skjerm.
c) Lag en klasse Hage. Du skal ha en liste av Plante-objekter. Init skal ta et parameter som sier hvor mange planter du kan ha i hagen.
Hage har følgende grensesnitt:
class Hage:
def __init__(self, plass_i_hagen):
def vann_planter(self, cl_vann):
# Alle hagens planter blir vannet
def gro_plante(self, max_grense_vann):
# Ny plante blir laget og satt inn i listen.
# Om hagen er full blir det skrevet ut en feilmelding.
def ny_dag_til_alle_mine_planter(self):
# Kaller på alle plantene i hagen sin ny_dag()-funksjon
def ant_planter(self):
# Returnerer antall planter
def rensk_opp_hage(self):
# Sjekker om noen av plantene i hagen er døde.
# I det tilfellet blir de slettet fra listen
# Hint: Her kan du bruke liste.pop(index) for å fjerne
# planten ved plass index.
d)
1. Opprett et Hage-objekt og la den ha en grense på fem planter.
2. Opprett tre planter med maxGrense på 40, 60 og 80.
3. Vann alle plantene med 25 cl.
4. Rensk opp hagen.
5. Skriv ut hvor mange planter som er i hagen.
6. La det gå tre nye dager.
7. Rensk opp hagen og print til skjerm hvor mange planter som er igjen.
# A
class Plante:
def __init__(self, max_grense_vann):
self._max_grense_vann = max_grense_vann
self._vann_beholder = 0
self._død = False
def vann_plante(self, cl_vann):
self._vann_beholder += cl_vann
if self._vann_beholder > self._max_grense_vann :
self._død = True
def ny_dag(self):
self._vann_beholder-= 20
if self._vann_beholder < 0 :
self._død = True
def er_levende(self):
return not self._død
# C
class Hage:
def __init__(self, plass):
self._plass_i_hagen = plass
self._planter = []
def vann_planter(self, cl_vann):
for plante in self._planter :
plante.vann_plante(cl_vann)
def gro_plante(self, max_grense_vann):
if len(self._planter) > self._plass_i_hagen :
print("Det er ikke plass til flere planter i hagen")
else:
self._planter.append(Plante(max_grense_vann))
def ny_dag_til_alle_mine_planter(self) :
for plante in self._planter :
plante.ny_dag()
def ant_planter(self):
return len(self._planter)
def rensk_opp_hage(self):
teller = 0
while teller < len(self._planter):
if not self._planter[teller].er_levende():
self._planter.pop(teller)
print("Plante #", teller+1, "er død og ble fjernet")
teller+=1
# B
# 1)
plante_liten = Plante(40)
plante_stor = Plante(90)
# 2)
plante_liten.vann_plante(10)
plante_stor.vann_plante(10)
# 3)
plante_liten.ny_dag()
plante_liten.ny_dag()
plante_stor.ny_dag()
plante_stor.ny_dag()
# 4)
if plante_liten.er_levende() :
print("Den lille planten er levende")
else:
print("Den lille planten er død")
if plante_stor.er_levende() :
print("Den store planten er levende")
else:
print("Den store planten er død")
# D
# 1)
hage = Hage(5)
# 2)
hage.gro_plante(40)
hage.gro_plante(60)
hage.gro_plante(80)
# 3)
hage.vann_planter(25)
# 4)
hage.rensk_opp_hage()
# 5)
print("Det er nå", hage.ant_planter(), "plante(r) igjen i hagen")
# 6)
hage.ny_dag_til_alle_mine_planter()
hage.ny_dag_til_alle_mine_planter()
hage.ny_dag_til_alle_mine_planter()
# 7)
hage.rensk_opp_hage()
print("Det er nå", hage.ant_planter(), "plante(r) igjen i hagen")