Problemlösning med listor

Mål

Efter lektionen ska du kunna...

• använda listor i sammansatta uppgifter
• kombinera listor med funktioner och loopar
• välja hur varje element i listan ska lagras
• testa vanliga fall och kantfall

Scenario

Poänghantering i ett spel

• ta emot namn och poäng
• spara flera resultat i en lista
• sortera resultaten efter poäng
• skriva ut en topplista

Plan

Pseudokod först

Skapa en tom lista

WHILE användaren vill fortsätta:
    Läs in namn och poäng
    Lägg till resultatet i listan
    Fråga om användaren vill fortsätta

Sortera listan efter poäng
Skriv ut topplistan

Datastruktur

Vad är ett element?

scores = [
    ("Anna", 120),
    ("Erik", 95),
    ("Sara", 150)
]

Listan innehåller flera resultat.

Varje tuple kopplar ihop namn och poäng.

Alternativ

Tuple eller dictionary?

("Anna", 120)

{"name": "Anna", "points": 120}

Funktion

Lägg till resultat

def add_score(scores):
    name = input("Ange namn: ")

    try:
        points = int(input("Ange poäng: "))
        scores.append((name, points))
    except ValueError:
        print("Du måste ange ett heltal.")

Stegvis

Vad händer i funktionen?

1. name får spelarens namn.
2. int(input(...)) försöker läsa poäng som heltal.
3. append() lägger till en tuple i listan.
4. except ValueError fångar fel poänginmatning.

Sortering

Först: enkel sortering

numbers = [5, 2, 9, 1]

numbers.sort()

print(numbers)

[1, 2, 5, 9]

Sortering

Men vad ska Python sortera på?

scores = [
    ("Anna", 120),
    ("Erik", 95),
    ("Sara", 150)
]

Varje element innehåller två delar.

Ska listan sorteras efter namn eller poäng?

Tuple

Index visar vilken del

result = ("Anna", 120)

result[0]  # "Anna"
result[1]  # 120

0 är namnet.

1 är poängen.

Key

key väljer sorteringsvärde

def get_points(result):
    return result[1]

scores.sort(key=get_points)

För varje tuple hämtar funktionen poängen.

Python använder poängen när listan sorteras.

Lambda

En kort funktion direkt i raden

def get_points(result):
    return result[1]

lambda result: result[1]

Lambda

Läs raden i delar

scores.sort(key=lambda result: result[1], reverse=True)

• scores.sort(...) sorterar listan.
• key=... säger vad Python ska sortera på.
• lambda result: result[1] hämtar poängen.
• reverse=True ger högsta poängen först.

Sortering

I programmet

def print_high_scores(scores):
    scores.sort(key=lambda result: result[1], reverse=True)

    print("\nTopplista:")

    for name, points in scores:
        print(f"{name}: {points}")

Exempel

Före och efter sortering

[("Anna", 120), ("Erik", 95), ("Sara", 150)]

[("Sara", 150), ("Anna", 120), ("Erik", 95)]

Huvudprogram

Loopen styr flödet

def main():
    scores = []

    while True:
        add_score(scores)
        cont = input("Fler resultat? (j/n): ")

        if cont.lower() != "j":
            break

    print_high_scores(scores)

Koppling

Delarna samarbetar

• Listan sparar alla resultat.
• Tuplen håller ihop namn och poäng.
• Funktioner delar upp ansvaret.
• Loopen låter användaren lägga till flera resultat.
• Villkor avgör när programmet ska avslutas.

Testning

Testa även kantfall

Vanligt fall:
Anna 120, Erik 95, Sara 150
Förväntat: Sara visas först

Fel poäng:
Anna abc
Förväntat: felmeddelande

Tom lista:
Användaren avslutar direkt
Förväntat: programmet hanterar det tydligt

Utveckling

Bygg vidare

• visa bara de tre bästa resultaten
• kontrollera dubbletter
• ta bort en spelare
• spara topplistan till fil senare

Öva själv

Topplista

1. Skriv först en plan.
2. Bygg ett menyprogram.
3. Låt användaren lägga till resultat.
4. Visa hela topplistan.
5. Visa bara de tre bästa resultaten.

Sammanfattning

Kom ihåg

• Fråga alltid vad ett element i listan är.
• Välj tuple eller dictionary efter behov.
• append() lägger till nya resultat.
• sort(key=...) kan sortera efter en del av varje element.
• Kantfall visar om programmet är robust.