Mönsterkortet

Det här är ett referensdokument, kom hit när du behöver minnas hur ett mönster ser ut. Kör exemplen direkt på sidan, ändra värdena och se vad som händer. Mönstren är ordnade efter när de introduceras i kursen, så första besöket är en rundtur, inte en läsläxa: förstår du bara det första mönstret är allt som det ska. Kortet växer i takt med dig, och varje del skickar dig hit när ett nytt mönster är ditt.

Hur du läser en uppgift

Innan du skriver kod, ställ dig tre frågor:

1. Behöver jag spara något? Tillståndsvariabler
2. Behöver jag upprepa något? Loopar
3. Behöver jag välja något? Villkor

De flesta program kombinerar flera av dessa för att nå sitt mål. När du ser ett mönster i en uppgift, gå hit och hitta det. Det är troligen redan namngivet och beskrivet.

1. Inläsning

Inläsaren

“Fråga användaren om ett värde och lagra det med rätt datatyp.”

namn = input("Vad heter du? ")
ålder = int(input("Hur gammal är du? "))

print(f"Hej {namn}! Du är {ålder} år.")
print(f"Om 10 år är du {ålder + 10} år.")

input() returnerar alltid str. Glömmer du konvertera kraschar matematiken.

2. Villkor

Klassificeraren

“Tilldela en kategori utifrån var ett värde ligger i ett intervall.”

poäng = 85

if poäng >= 90:
    betyg = "A"
elif poäng >= 70:
    betyg = "B"
elif poäng >= 50:
    betyg = "C"
else:
    betyg = "F"

print(f"Poäng: {poäng} -> Betyg: {betyg}")

Ordningen spelar roll, kontrollera alltid det strängaste villkoret först.

Kombinationsvillkoret

“Kontrollera att flera krav uppfylls samtidigt, eller att minst ett gör det.”

if ålder >= 18 and har_biljett:
    print("Välkommen.")

if är_student or är_pensionär:
    print("Rabatt beviljad.")

if ålder >= 18 and (är_student or är_anställd):
    print("Åtkomst beviljad.")

Med and måste båda villkoren stämma, med or räcker det att ett gör det. Parenteserna i sista exemplet gör kombinationen tydlig att läsa.

Standardvärdet

“Använd ett normalvärde om inget särskilt villkor stämmer.”

är_student = False
är_pensionär = True
pris = 200

rabatt = 0
if är_student:
    rabatt = 0.2
elif är_pensionär:
    rabatt = 0.15

slutpris = pris * (1 - rabatt)
print(f"Rabatt: {int(rabatt * 100)}%")
print(f"Slutpris: {slutpris:.0f} kr")

3. Loopar

Vet du hur många gånger?         -> for i in range(n)
Har du en samling att gå igenom? -> for item in lista
Vet du när det ska sluta?        -> while villkor
Är det användaren som bestämmer? -> while True + break
Upprepar du tills det lyckas?    -> while True + try/except + return

N gånger-mönstret

for i in range(5):
    print(f"Omgång {i + 1} av 5")

Tills-mönstret

import random

spelare_hp = 20
fiende_hp = 15

while spelare_hp > 0 and fiende_hp > 0:
    spelare_slag = random.randint(3, 8)
    fiende_slag = random.randint(2, 6)
    fiende_hp -= spelare_slag
    spelare_hp -= fiende_slag
    print(f"Du: {max(0,spelare_hp)} HP | Fiende: {max(0,fiende_hp)} HP")

if spelare_hp > 0:
    print("Du vann!")
else:
    print("Fienden vann.")

Menymönstret

while True:
    print("\n1. Visa hälsning")
    print("2. Visa poäng")
    print("3. Avsluta")
    val = input("Välj: ")

    if val == "1":
        print("Hej!")
    elif val == "2":
        print("Poäng: 1 250")
    elif val == "3":
        print("Hej då!")
        break
    else:
        print("Ogiltigt val.")

Samlings-mönstret

Se Sökmönstret och Filtret under Listor nedan, båda itererar över en samling med for item in lista:.

Ackumuleringsmönstret

Se Räknaren och Samlaren under Tillståndsvariabler nedan: en tillståndsvariabel utanför loopen som uppdateras varje varv. Det är loopens vanligaste jobb.

4. Listor

Samlingsbyggaren

“Bygg upp en lista dynamiskt under programkörning.”

inmatningar = []

while True:
    svar = input("Lägg till (eller 'klar'): ")
    if svar.lower() == "klar":
        break
    inmatningar.append(svar)

print(f"Du lade till: {inmatningar}")

Filtret

“Bygg en ny lista med bara de element som uppfyller ett krav.”

alla = [45, 78, 32, 91, 55, 67, 88, 41]
godkända = []

for resultat in alla:
    if resultat >= 50:
        godkända.append(resultat)

print(f"Alla:      {alla}")
print(f"Godkända:  {godkända}")

Sökmönstret

“Hitta det första elementet som stämmer med ett krav.”

fiender = ["Goblin", "Troll", "Drake", "Lich"]
sökterm = "Drake"
hittad = None

for fiende in fiender:
    if fiende == sökterm:
        hittad = fiende
        break

if hittad:
    print(f"Hittade: {hittad}")
else:
    print(f"{sökterm} finns inte i listan.")

Transformationen

“Skapa en ny lista där varje element är en bearbetad version av originalet.”

råa_namn = ["  maja  ", "KALLE", "linnea  ", "  erik"]
formaterade = []

for namn in råa_namn:
    formaterade.append(namn.strip().lower())

print(formaterade)

5. Tillståndsvariabler

Variabler som sätts upp utanför en loop och uppdateras inuti.

Räknaren

“Håll koll på hur många gånger något har hänt.”

antal_träffar = 0
slag = [True, False, True, True, False, True]

for träff in slag:
    if träff:
        antal_träffar += 1

print(f"Träffar: {antal_träffar} av {len(slag)}")

Samlaren

“Räkna ihop ett totalt värde steg för steg.”

poäng = [100, 250, 75, 430, 180]
total = 0

for p in poäng:
    total += p

print(f"Total: {total}")
print(f"Snitt: {total // len(poäng)}")

Om startvärdet sätts inuti loopen nollställs det varje varv.

Flaggan

“Kom ihåg om något har hänt, för att kolla svaret efteråt.”

fiender = ["Goblin", "Troll", "Drake", "Lich"]
sökterm = "Drake"
hittad = False

for fiende in fiender:
    if fiende == sökterm:
        hittad = True
        break

if hittad:
    print(f"{sökterm} hittades!")
else:
    print(f"{sökterm} finns inte.")

Jämför med Sökmönstret under Listor ovan: koden är nästan identisk, men Flaggan minns bara att något hände, Sökmönstret minns vad som hittades.

Toppnoteraren

“Håll koll på det högsta eller lägsta värdet hittills.”

resultat = [73, 91, 45, 88, 62, 95, 77]
bäst = resultat[0]

for värde in resultat:
    if värde > bäst:
        bäst = värde

print(f"Resultat: {resultat}")
print(f"Bäst: {bäst}")

Starta med lista[0], inte 0: om listan innehåller negativa tal är 0 fel startvärde.

6. Funktioner

Introduceras i Din första funktion.

Beräknaren

“Ta emot värden, beräkna något, returnera svaret.”

def beräkna_skada(attack, försvar):
    return max(0, attack - försvar)

print(beräkna_skada(15, 5))
print(beräkna_skada(5, 15))
print(beräkna_skada(20, 8))

Kör exemplet: mittenanropet ger 0, inte -10. max(0, ...) garanterar att skadan aldrig blir negativ.

Presentatören

“Samla utskriftslogik på ett ställe, skriver ut, returnerar inget.”

def visa_status(spelare_hp, fiende_hp):
    print(f"Din HP:     {spelare_hp}")
    print(f"Fiendens HP: {fiende_hp}")
    print("-" * 20)

visa_status(100, 75)
visa_status(65, 40)

Valideringsfunktionen

“Kontrollera om något är giltigt, returnera True eller False.”

def är_giltigt_lösenord(lösenord):
    return len(lösenord) >= 8

print(är_giltigt_lösenord("hemligt"))
print(är_giltigt_lösenord("hemligtord"))
print(är_giltigt_lösenord("abc"))

Formatiseraren

“Ta ett eller flera värden och returnera en färdig sträng.”

def formatera_spelare(namn, hp, poäng):
    return f"{namn} | HP: {hp} | Poäng: {poäng}"

print(formatera_spelare("Maja", 100, 250))
print(formatera_spelare("Kalle", 65, 410))

Vakten

“Kontrollera ett krav tidigt. Om det inte uppfylls, avsluta. Normal kod följer orörd.”

def beräkna(tal):
    if tal < 0:
        print(f"{tal} är negativt, avbryter.")
        return

    resultat = tal * 2
    return resultat

print(beräkna(5))
print(beräkna(-3))
print(beräkna(10))

Valideraren

“Fråga om och om igen tills ett giltigt svar ges.”

def läs_int(prompt="Ange ett heltal: "):
    while True:
        try:
            return int(input(prompt))
        except ValueError:
            print("Inte ett heltal. Försök igen.")

tal = läs_int("Ange ett tal 1-10: ")
print(f"Du angav: {tal}")

Kopiera den fritt in i alla projekt. Den byggs i Kraschsäkring.

7. Filer & persistent lagring

Introduceras i Filen som minns.

Persistent lagring

“Spara data till disk och ladda det vid nästa start.”

FILNAMN = "data.txt"

def ladda():
    try:
        with open(FILNAMN, "r", encoding="utf-8") as fil:
            return fil.read().splitlines()
    except FileNotFoundError:
        return []

def spara(data):
    with open(FILNAMN, "w", encoding="utf-8") as fil:
        for rad in data:
            fil.write(rad + "
")

Anropa ladda() vid start, spara() precis innan avslut. Kräver filsystem, kan inte köras i sandlådan.

8. GUI & tillstånd

Introduceras i Fönsterhanteraren.

GUI-tillståndsmönstret

“Håll tillstånd globalt, uppdatera i funktioner, synka GUI i en separat funktion.”

# --- Tillstånd ---
spelare_hp = 100
fiende_hp = 80

# --- Logik ---
def attack():
    global spelare_hp, fiende_hp
    # ... beräkna skada ...
    uppdatera_gui()

# --- Visning ---
def uppdatera_gui():
    spelare_etikett.config(text=f"HP: {spelare_hp}")
    fiende_etikett.config(text=f"Fiende HP: {fiende_hp}")

Kräver tkinter, kan inte köras i sandlådan.

Hur mönster kombineras

De flesta program kombinerar flera mönster. Brawl kombinerar:

Tills-mönstret          -> while spelare_hp > 0 and fiende_hp > 0
  Samlaren              -> total_skada ackumuleras varje tur
  Klassificeraren       -> if hp <= 0 avgör vinnare
  Inläsaren             -> input() för spelarens val
Valideraren             -> läs_int() för säker inmatning

Inventoryt får minne lägger till:

Persistent lagring      -> ladda/spara inventoryt mellan körningar
Vakten                  -> try/except vid den första körningen

Ser du ett mönster inuti ett annat, det stämmer. Namnge båda.