Du er ikke logget inn. Så lenge du ikke er logget inn går du glipp av muligheten for å holde styr på din egen progresjon.

inf1001 høst2016

Grunnkurs i objektorientert programmering (med Python)

Valgte tags:

inf1001 høst2016 uke7 øving

Filtrering:

7.01: Teller

Lag en klasse Teller. Den skal ha følgende grensensnitt:

class Teller:
    def __init__(self, startverdi):
        # Telleren skal starte på startverdi

    def oek_teller(self):
        # Øker teller med 1

    def hent_verdi(self):
        # Returnerer verdien til teller

    def nullstill(self):
        # Setter telleren til å være startverdi

Opprett to objekter av typen Teller, 'teller1' og 'teller2' der startverdien til 'teller1' er 0 og 'teller2' er 5. Øk så begge tellerne fem ganger (gjerne med en for-løkke). Sjekk at de har verdiene 5 og 10 ved å hente verdiene og printe dem. Nullstill så teller2, og kall hent-funksjonen på begge tellerne igjen. Print og sjekk at begge har verdien 5.

class Teller:
    def __init__(self, startverdi):
        self._teller = startverdi
        self._startverdi = startverdi

    def oek_teller(self):
        self._teller+= 1

    def hent_verdi(self):
        return self._teller

    def nullstill(self):
        self._teller = self._startverdi

teller1 = Teller(0)
teller2 = Teller(5)

for i in range(5) :
    teller1.oek_teller()
    teller2.oek_teller()

print("Teller 1 har verdien", teller1.hent_verdi())
print("Teller 2 har verdien", teller2.hent_verdi())

teller2.nullstill()

print("Teller 1 har verdien", teller1.hent_verdi())
print("Teller 2 har verdien", teller2.hent_verdi())

if teller1.hent_verdi() == teller2.hent_verdi() : 
    print("Det er det samme")
else:
    print("Det er ikke det samme")

7.02: Liste av emner

Filnavn: nye_emner.py

a) Lag en liste av emner som skal brukes til å lagre emnekoder.

b) Legg til ett element i listen for hvert av emnene du tar dette semesteret.

c) Spør bruker om å oppgi en emnekode, og les inn. Hvis denne allerede finnes i listen, tar du emnet ut av listen. Ellers legger du emnet til bakerst i emnelisten.

d) Skriv ut på skjerm alle elementene i listen emner, ett på hver linje.

# A
emner = []

# B
emner.append("INF1001")
emner.append("INF1400")
emner.append("MAT1100")

# C
inp = input("Oppgi et emne: ")

sett_inn = True

if inp in emner:
    emner.remove(inp)
else:
    emner.append(inp)

# D
for emne in emner:
    print(emne)

7.03: PersonSystem

Filnavn: person_system.py

a) Lag en klasse PersonSystem som inneholder en liste av Personer.

b) Lag en metode legg_til_person i PersonSystem som tar i mot et objekt av klassen Person og som legger inn dette objektet i listen av Personer.

c) Lag en metode finn_person som finner en person med et gitt navn dersom personen finnes i listen.

d) Lag et objekt av klassen PersonSystem. Legg til 5 personer i objektet ved hjelp av metoden legg_til_person og sjekk deretter at et av objektene er blitt lagt til ved hjelp av metoden finn_person.

Du kan ta utgangspunkt i denne klassen for Person:

class Person:
    def __init__(self, navn):
        self._navn = navn

    def hent_navn(self):
        return self._navn

class Person:
    def __init__(self, navn):
        self._navn = navn

    def hent_navn(self):
        return self._navn

class PersonSystem:
    def __init__(self):
        self._personer = []

    def legg_til_person(self, person):
        self._personer.append(person)

    def finn_person(self, navn):
        for person in self._personer:
            if person.hent_navn() == navn:
                return person
        return None

# Lager et objekt og legger til 5 personer.
system = PersonSystem()
system.legg_til_person(Person("Anne"))
system.legg_til_person(Person("Brikt"))
system.legg_til_person(Person("Carina"))
system.legg_til_person(Person("David"))
system.legg_til_person(Person("Else"))

# Sjekker at personen er i systemet.
assert system.finn_person("Carina") != None

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")

7.06: Garasje og biler

Arne con Carne er glad i biler, og ønsker et program for å holde oversikt over bilene han har i garasjen.

  1. Skriv en klasse Bil. Biler har egenskapene modell, og vekt.
  2. Skriv en konstruktør for klassen Bil, samt en funksjon def skriv_info(self): som skriver ut informasjon om bilen.
  3. Skriv klassen Garasje. Det er fem parkeringsplasser i garasjen. Den skal derfor ha en liste av Bil-pekere som man kun kan sette inn 5 elemeneter i.
  4. Skriv en funksjon def sett_inn_bil(self, nyBil): i klassen Garasje. Denne skal sette inn bilen som blir sendt med som parameter i garasjen.
  5. Skriv funksjonen def bil_på_plass(self, plass): i klassen Garasje. Metoden skal skrive ut informasjon om bilen på plassen, dersom det står en bil der. Står det ikke en bil der, skal det skrives ut Plassen er tom.
  6. Skriv en klasse Test_bil. Opprett tre biler, og en garasje. Sett bilene inn i garasjen, og skriv ut informasjon om alle plassene i garasjen.