Laboration 6: Objektorienterad problemuppdelning on Programmering, grundkurs

Laboration 6: Objektorienterad problemuppdelning

Thu, 09 Apr 2026 00:00:00 +0000

I laboration 6 kommer ni fortsätta öva på att skapa egna klasser. Denna gång ska ni dock lagra instanser av klasser i andra instanser, samt skapa metoder som delegerar vidare den uppgift som ska lösas.

Redovisning och kompletteringar

Information om den muntliga redovisningen, samt eventuella kompletteringar kan ni läsa om på sidan Redovisning.
Vid inlämning av era filer, se till att ni laddar upp alla era filer med kod. Se även till att allt fortfarande fungerar om ni har fått komplettering för något och ändrat i koden sedan redovisningstillfället.

Lärandemål

kunna ge exempel och förklara hur ett programmeringsproblem kan brytas ner när man använder sig av objektorienterad programmering (t.ex. delegering av uppgifter, ansvarsuppdelning m.m. se föreläsning)
kunna peka ut exempel i egen objektorienterad kod på hur ett problem brutits ner i mindre delar
kunna skriva ett objektorienterat program med egna klasser där instanser av en egenskriven klass lagras i en instans av en annan egenskriven klass
kunna skriva ett skript med interaktivt text-gränssnitt med felhantering

Krav för godkänd kod på Del 1-2

Koden ska följa PEP 8.
Moduler (själva filen), funktioner, klasser och metoder ska kommenteras enligt PEP 257.
Koden ska följa koddispositionen nedan.
Koden ska utföra uppgifterna enligt respektive uppgiftsbeskrivning.
Koden ska vara uppdelad i olika filer enligt instruktionerna för respektive uppgift.

För hjälp med kontroll av PEP, se PEP 8 och PEP 257.

Mergesort

Wed, 16 Oct 2024 00:00:00 +0000

Du kan läsa mer om Mergesort på Wikipedia och (enbart i in-place-versionen) i boken av Miller & Ranum. Ni kan också söka ytterligare källor via t.ex. Google.

En bra visualisering av hur Mergesort fungerar kan ni se på Youtube.

Klassisk version

 1def merge(left_lst, right_lst):
 2    merged = []
 3    while left_lst or right_lst:
 4        if not left_lst:
 5            merged.extend(right_lst)
 6            return merged
 7        elif not right_lst:
 8            merged.extend(left_lst)
 9            return merged
10        elif left_lst[0] <= right_lst[0]:
11            merged.append(left_lst.pop(0))
12        else:
13            merged.append(right_lst.pop(0))
14    return merged
15
16
17def mergesort(lst):
18    if len(lst) < 2:
19        return lst
20    else:
21        mid = len(lst) // 2
22        left_sorted = mergesort(lst[:mid])
23        right_sorted = mergesort(lst[mid:])
24        return merge(left_sorted, right_sorted)
25
26
27if __name__ == "__main__":
28    print("Without repeated values:")
29    values = [9, 1, 10, 2, 8, 7, 3, 6, 4, 5]
30    print(f"Before sorting:\n{values}")
31    values = mergesort(values)
32    print(f"After sorting:\n{values}")
33    
34    print("\nWith repeated values:")
35    values = [7, 9, 10, 4, 8, 1, 10, 1, 8, 7]
36    print(f"Before sorting:\n{values}")
37    values = mergesort(values)
38    print(f"After sorting:\n{values}")

Quicksort

Wed, 16 Oct 2024 00:00:00 +0000

Nedan följer två exempelimplementationer av Quicksort i Python.

Ni kan läsa mer om Quick Sort på Wikipedia och (enbart in-place-versionen) i boken av Miller & Ranum. Ni kan också söka ytterligare källor via t.ex. Google.

En bra visualisering av hur Quick Sort fungerar kan ni se på Youtube.

Out-of-place list-baserad version

Den här varianten är enklare att sätta sig in i och gör det lättare att förstå den mer avancerade in-place-varianten.

 1def partition(lst):
 2    pivot_value = lst[-1]
 3    left_lst = []
 4    right_lst = []
 5    for value in lst[:-1]:
 6        if value < pivot_value:
 7            left_lst.append(value)
 8        else:
 9            right_lst.append(value)
10    return left_lst, [pivot_value], right_lst
11
12def quicksort(lst):
13    if len(lst) < 2:
14        return lst
15    else:
16        left_lst, pivot_list, right_lst = partition(lst)
17        return quicksort(left_lst) + pivot_list + quicksort(right_lst)
18
19if __name__ == "__main__":
20    print("Without repeated values:")
21    values = [9, 1, 10, 2, 8, 7, 3, 6, 4, 5]
22    print(f"Before sorting:\n{values}")
23    last_index = len(values) - 1
24    values = quicksort(values)
25    print(f"After sorting:\n{values}")
26
27    print("\nWith repeated values:")
28    values = [7, 9, 10, 4, 8, 1, 10, 1, 8, 7]
29    print(f"Before sorting:\n{values}")
30    last_index = len(values) - 1
31    values = quicksort(values)
32    print(f"After sorting:\n{values}")

In-place index-baserad version

 1def partition(seq, start_index, stop_index):
 2    pivot = seq[stop_index]
 3    i = start_index
 4    for j in range(start_index, stop_index):
 5        if seq[j] < pivot:
 6            swap(seq, i, j)
 7            i += 1
 8    swap(seq, i, stop_index)
 9    return i
10
11
12def swap(seq, i, j):
13    seq[i], seq[j] = seq[j], seq[i]
14
15
16def quicksort_in_place(seq, start_index, stop_index):
17    if start_index < stop_index:
18        pivot_index = partition(seq, start_index, stop_index)
19        quicksort_in_place(seq, start_index, pivot_index - 1)
20        quicksort_in_place(seq, pivot_index + 1, stop_index)
21
22if __name__ == "__main__":
23    print("Without repeated values:")
24    values = [9, 1, 10, 2, 8, 7, 3, 6, 4, 5]
25    print(f"Before sorting:\n{values}")
26    last_index = len(values) - 1
27    quicksort_in_place(values, 0, last_index)
28    print(f"After sorting:\n{values}")
29
30    print("\nWith repeated values:")
31    values = [7, 9, 10, 4, 8, 1, 10, 1, 8, 7]
32    print(f"Before sorting:\n{values}")
33    last_index = len(values) - 1
34    quicksort_in_place(values, 0, last_index)
35    print(f"After sorting:\n{values}")

Mon, 01 Jan 0001 00:00:00 +0000

Här ska ni skapa tre klasser som representerar olika beståndsdelar av en text. Varje klass tar hand om uppgifter på sin nivå och delegerar vidare uppgifter till instanser på lägre nivåer.

Utskrift

När ni läst in texten och skapar instanserna skriver ni ut något i stil med nedanstående. Mellanslag och radbrytningar behöver inte räknas in i antalet tecken (olika utskriftsalternativ finns längre ner på sidan).

Texten innehåller 15 meningar, 133 ord/skiljetecken, 676 tecken.
Mening 1 innehåller 22 ord/skiljetecken (105 tecken)
Mening 2 innehåller 7 ord/skiljetecken (35 tecken)
Mening 3 innehåller 8 ord/skiljetecken (44 tecken)
Mening 4 innehåller 6 ord/skiljetecken (32 tecken)
Mening 5 innehåller 6 ord/skiljetecken (33 tecken)
Mening 6 innehåller 8 ord/skiljetecken (35 tecken)
Mening 7 innehåller 8 ord/skiljetecken (44 tecken)
Mening 8 innehåller 7 ord/skiljetecken (29 tecken)
Mening 9 innehåller 10 ord/skiljetecken (57 tecken)
Mening 10 innehåller 10 ord/skiljetecken (47 tecken)
Mening 11 innehåller 9 ord/skiljetecken (44 tecken)
Mening 12 innehåller 6 ord/skiljetecken (34 tecken)
Mening 13 innehåller 10 ord/skiljetecken (50 tecken)
Mening 14 innehåller 7 ord/skiljetecken (41 tecken)
Mening 15 innehåller 9 ord/skiljetecken (46 tecken)

Klasser

Följande klasser ska skapas:

Mon, 01 Jan 0001 00:00:00 +0000

Krav på funktionalitet

Med skriptet ska användaren kunna göra följande:

visa vilka kommandon som användaren kan skriva
visa listan med saker som finns att göra, där varje uppgift har ett unikt ID, samt visa om uppgiften är gjord eller inte
kunna markera en uppgift som klar
avsluta skriptet med ett kommando
skriptet ska inte krascha vid felaktig input

Se föreläsningsbilderna för tips både skapande av text-gränssnittet och objektorienterad struktur.

Viktigt! Håll kod som ansvarar för interaktion med användaren separat från kod som modellerar data.

Mon, 01 Jan 0001 00:00:00 +0000

Samtliga uppgifter ovan utgår från att användaren alltid matar in exakt ett kommando och att programmet frågar efter eventuell ytterligare information i efterföljande frågor. Det är dock inte så användarvänligt.

Utöka funktionaliteten i programmet så att det går att mata in mer komplexa kommandon som innehåller både själva kommandot och den information som behövs för att utföra kommandot.

Utgå från lösningen med deluppgifter.

Exempel:

Ange kommando (q=avsluta, ?=hjälp): ny "Labb5"
Ange kommando (q=avsluta, ?=hjälp): ny "Del 1: Syntax" 0
Ange kommando (q=avsluta, ?=hjälp): ny "Del 2: Hantera objekt" 0
Ange kommando (q=avsluta, ?=hjälp): ny "Uppgift 1 - Husdjur" 1
Ange kommando (q=avsluta, ?=hjälp): ny "Uppgift 2 - Vektor" 1
Ange kommando (q=avsluta, ?=hjälp): ny "Uppgift 1 - row_layout" 2
Ange kommando (q=avsluta, ?=hjälp): visa
0. [ ] Labb5
├──1. [ ] Del 1: Syntax
├──├──3. [ ] Uppgift 1 - Husdjur
├──├──4. [ ] Uppgift 2 - Vektor
├──2. [ ] Del 2: Hantera objekt
├──├──5. [ ] Uppgift 1 - row_layout
Ange kommando (q=avsluta, ?=hjälp): klar 1
Ange kommando (q=avsluta, ?=hjälp): visa
0. [ ] Labb5
├──1. [X] Del 1: Syntax
├──├──3. [X] Uppgift 1 - Husdjur
├──├──4. [X] Uppgift 2 - Vektor
├──2. [ ] Del 2: Hantera objekt
├──├──5. [ ] Uppgift 1 - row_layout
Ange kommando (q=avsluta, ?=hjälp): visa 1
1. [X] Del 1: Syntax
├──3. [X] Uppgift 1 - Husdjur
├──4. [X] Uppgift 2 - Vektor

Notera att kommandona ny och visa är variadiska, dvs. de kan ta olika många argument.

Mon, 01 Jan 0001 00:00:00 +0000

I klassdiagrammet och uppgiftsbeskrivningen ovan har varje TodoApp -instans endast en TaskList -instans. Utöka funktionaliteten hos programmet så att man kan skapa flera uppgiftslistor. Det betyder att ni behöver

lägga till en instansvariabel så att TaskList -instanserna har namn
ändra på TodoApp -klassen så att den kan lagra en eller flera instanser av TaskList
lägga till ett kommando (och tillhörande funktionalitet) för att skapa nya TaskList -instanser
lägga till ett kommando för att visa vilka TaskLists som finns
ändra på kommandona som jobbar med Task -instanser, så att man även anger vilken TaskList -instans man vill jobba med.

Skapa ett uppdaterat UML-diagram som har med de ändringar ni gjort.

Mon, 01 Jan 0001 00:00:00 +0000

Utskriften av deluppgifter är inte så vacker, snyggare blir det om man är lite mer flexibel med vilka tecken man använder. I den här frivillga uppgiften ska du ändra utskriften av deluppgifter så att det blir tydligare vilka uppgifter som är deluppgifter till vilka huvuduppgifter. Det kan du göra genom att använda indrag och olika tecken för att visa på hierarkin av uppgifter och deluppgifter.

För att göra det behöver du ändra i TodoApp-klassen, så att den inte längre skriver ut deluppgifter med enbart bindestreck, utan istället använder sig av indrag och olika tecken för att visa på hierarkin av uppgifter och deluppgifter. Det kan till exempel se ut så här:

Mon, 01 Jan 0001 00:00:00 +0000

För enkelhets skull rekommenderar vi att ni implementerar detta baserat på Uppgift 1 och instruktionerna nedan är baserade på det. Vill ni sedan kombinera detta med vad ni gjort i Uppgift 2 är det fritt fram.

Utöka funktionaliteten så att ni kan ge uppgifter en prioritet och lista uppgifterna sorterat på prioritet. Ni kan läsa på om två lämpliga alternativ för sorteringsalgoritm på sidorna om Quick Sort respektive Mergesort. Ni kan kopiera och utgå ifrån exempelimplementationerna men notera att dessa inte tar in någon key -funktion och att några exempel kan vara destruktiva (dvs. ändrar på listan som skickas in istället för att skapa en sorterad kopia).

Mon, 01 Jan 0001 00:00:00 +0000

Utöka funktionaliteten i programmet så att en användare kan spara och ladda data. Det är fritt för er att välja format som sparad data ska ha (t.ex. någon form av textbaserat format som json eller csv, eller om ni vill prova att använda Pythons pickle -modul). Ni behöver alltså göra följande:

bestämma filformat för sparad data
lägga till ett kommando för att läsa in data från sparad fil
lägga till ett kommando för att spara data till fil

Rita ett nytt UML-diagram som har med de ändringar ni gjort.

Mon, 01 Jan 0001 00:00:00 +0000

Som vi såg i körexemplet till uppgift 1 så har man ofta uppgifter som hänger ihop med varandra, t.ex. ingick ju alla uppgifter i körexemplet i en större uppgift som var att göra Labb6. I det exemplet var det dock inte möjligt att på något sätt visa att uppgifterna hörde ihop eller att markera att de hörde ihop. I denna extrauppgift ska vi lägga till funktionalitet för att hantera deluppgifter.

Mon, 01 Jan 0001 00:00:00 +0000

Utöka funktionaliteten så att ni kan skapa användare i programmet, samt ange användare för uppgifter. Kopiera era filer för Del 2, Uppgift 1 och ge filerna som hör ihop med denna extrauppgift suffixet _user, t.ex. del2_user.py.

Mon, 01 Jan 0001 00:00:00 +0000

Utöka funktionaliteten med både användare och deluppgifter. Utgå från lösningen på uppgiften med deluppgifter och lösningen på uppgiften med användare.

Uppdaterat klassdiagram

Programmet bör använda nedanstående klasser och de angivna relationerna kan finnas mellan klasserna. Klasserna bör innehålla minst de angivna metoderna och instansvariablerna.

Viktigt! Håll kod som ansvarar för interaktion med användaren separat från kod som modellerar data. Dvs. all kod som använder print eller input ska fortfarande endast ligga i klassen TodoApp och TodoApp ska fortfarande inte hantera Task -objekt direkt, utan ska alltid gå via TaskList -klassen för att hantera uppgifter.