Programmeringsteknik Python — Tentaguide

Ta exemplet från en tenta:

Egenskaper:
  attempts: int (publikt åtkomlig)
      Antalet försök. Från början är antalet försök 0.
  solved_time: int (publikt åtkomlig)
      Tidpunkten i minuter när uppgiften är löst. Från början är
      uppgiften olöst och värdet är därför -1.

Läs varje rad i tre delar — namn, typ och startvärde (som ofta gömmer sig i beskrivningen):

def __init__(self):
    self.attempts = 0       # publikt, startvärde ur texten
    self.solved_time = -1   # -1 betyder "ännu olöst"

Lägg märke till: ingen av dem skickas in som parameter — de börjar på ett bestämt värde. Startvärdet står nästan aldrig som en siffra i listan, utan i den löpande texten: "från början…", "initialt…", "därför…".

Står parametern i konstruktorns signatur? Då sparar du den rakt av:

def __init__(self, namn, pris):
    self.namn = namn      # self.X = X — samma namn, alltid
    self.pris = pris

Om beskrivningen pratar om något objektet ska "hålla reda på" som inte skickas in, skapar du det tomt. Vilket tomt värde? Det beror på vad det ska göra:

# Exempel: "håller reda på alla ordrar" + "lediga platser"
def __init__(self, total_seats):
    self.total_seats = total_seats   # STEG 1: parameter
    self.free_seats = total_seats    # härledd från parameter
    self.bookings = set()           # STEG 2: tom, "unika bokningar"

Om du måste minnas något om varje element (t.ex. "är den här frågan rätt besvarad?"), skapa en lista lika lång som datan:

def __init__(self, questions):
    self.questions = questions          # datan
    self._correct = [False] * len(questions)  # privat: egen statusflagga

"Koppla bordsnummer till order, men spara också alla ordrar under dagen" → båda behövs:

self._orders = {}      # bordsnr → senaste order (kan skrivas över)
self._all_orders = []  # historik: varje order någonsin

När du lägger till uppdaterar du båda:

def add_order(self, table, order):
    self._orders[table] = order   # skriver över om bordet fanns
    self._all_orders.append(order) # läggs alltid till i historiken

# Antal element → len
return len(self.items)

# Räkna de som uppfyller villkor → räknare i loop
n = 0
for x in self.items:
    if <villkor>:
        n += 1
return n

Returnera villkoret direkt — skriv aldrig if villkor: return True else: return False.

# Finns elementet?
return (name, num) in self.bookings

# Gäller det för ALLA? → börja True, sätt False vid motbevis
for c in self._correct:
    if not c:
        return False
return True          # kortform: return all(self._correct)

Ingen return. Du ändrar self (eller en inskickad dict — "in-place").

def add_dish(self, name, price, is_vegan):
    self.dishes.append(Dish(name, price, is_vegan))

result = []
for x in self.items:
    if <villkor>:
        result.append(x)
return result

Behöver du behålla ursprunglig ordning? Loopa över range(len(...)) så du har index till parallella listor:

for i in range(len(self.items)):
    if not self._correct[i]:
        result.append(self.items[i])

def __str__(self):
    if not self.dishes:               # specialfall först
        return "Inga rätter beställda."
    text = ""
    for d in self.dishes:
        text += str(d) + "\n"    # en rad per rätt
    text += f"\nTotalt: {self.total_price()} kr"
    return text

Återanvänd dina egna metoder istället för att skriva om logiken:

def new_list(self):
    return MultiplicationList(self.get_incorrect())

# Räkna förekomster i ett dict
counts = {}
for x in alla:
    counts[x.name] = counts.get(x.name, 0) + 1

# Den med högst antal (None om tomt)
if not counts:
    return None
return max(counts, key=counts.get)

# attempts: antal försök, börjar på 0
# solved_time: minut då löst, eller -1 om OLÖST  ← viktig konvention
def __init__(self):
    self.attempts = 0
    self.solved_time = -1

Returtyp bool + "om" → returnera ett villkor. Men hur vet vi att den är löst? Det står inte här — det stod i egenskaperna: löst = solved_time är inte -1.

def is_solved(self) -> bool:
    return self.solved_time != -1

Plocka isär texten mening för mening — varje fras är en kodrad:

def total_time(self) -> int:
    if not self.is_solved():        # återanvänd metoden ovan!
        return 0
    extra = 20 * (self.attempts - 1)  # 20 min per misslyckat försök
    return self.solved_time + extra

När en beskrivning är klurig — luta dig mot exemplen. De låser formatet exakt:

def __str__(self) -> str:
    if self.is_solved():
        return f"{self.attempts} {self.solved_time}"   # "3 77"
    return f"{self.attempts} -"                    # "2 -"

# TableBooking: specen listar total_seats, free_seats, bookings
# under "Egenskaper:" → alla tre är PUBLIKA
def __init__(self, total_seats):
    self.total_seats = total_seats   # publik (egenskap)
    self.free_seats = total_seats    # publik (egenskap)
    self.bookings = set()           # publik (egenskap)

# Restaurant: specen listar INGA egenskaper → allt PRIVAT
def __init__(self):
    self._orders = {}                 # privat (eget val)
    self._all_orders = []             # privat (eget val)

Använd sedan samma namn (med eller utan _) konsekvent i alla metoder inne i klassen:

def total_sales(self):
    total = 0
    for o in self._all_orders:   # _ här också
        total += o.total_price()
    return total

# Tal? Glöm inte int(...) — input ger alltid en sträng
low = int(input("Skriv in den lägsta tabellen: "))

# Flera ord på en rad? .split() delar på mellanslag
words = input("Ange fyra ord: ").split()

Använd while not <klar>: — fråga en metod om spelet är slut.

while not game.is_finished():
        print("\nKvarvarande ord:")
        print(sorted(game.remaining_words))   # sortera innan utskrift!
        words = input("Ange fyra ord: ").split()
        result = game.guess(words)
        if result == -1:
            print("Felaktig inmatning av grupp.")
        elif result == 4:
            print("Rätt grupp!")
        else:
            print(f"Fel grupp. {result} av fyra var rätt.")
    print("Alla grupper hittade!")

• Läs hela specen för uppgiften innan du skriver ett tecken.
• Titta på returtypen (-> ???) → slå upp receptet i avsnitt 2 & 6.
• Konstruktorn: parametrar → self.x = x; egna egenskaper → tom [] {} set() 0 False.
• Valde du datastruktur efter specens ord (unika→set, koppla→dict, ordning→list)?
• Privat är standard → self._x. Bara det som står under "Egenskaper:" är publikt (self.x).
• Lös metoderna i ordning — testfallen bygger på varandra.
• Fastnar du >5 min? pass och gå vidare — delpoäng finns.
• Återanvänd dina egna metoder istället för att kopiera logik (ger avdrag annars).
• __str__ och utskrifter: matcha formatet tecken för tecken. "Show Differences".
• Element som skrivs ut i ett program: sortera först (sorted()).
• Returnerar metoden None? Ändra self, skriv ingen return.
• Kör din lösning mentalt mot exempelkörningen i uppgiften.