Kap 2.6 – Problemlösning med listor

Mål med lektionen

När du har arbetat klart med denna lektion ska du:

• Kunna använda listor för att lösa sammansatta programmeringsuppgifter.
• Kombinera listor med funktioner, loopar och villkor.
• Analysera och bryta ner problem i steg.
• Strukturera kod som hanterar inmatning, lagring och bearbetning av data.

Så här lär du dig bäst

Börja med att analysera uppgiften noggrant. Skapa en algoritm i form av pseudokod eller punktlista innan du börjar koda. Skriv din kod steg för steg och testa varje del. Använd print() för att följa vad som händer i listan under körning.

Scenario: Poänghantering i ett spel

Du ska skapa ett program som:

• tar emot namn och poäng från flera användare,
• sparar resultaten i en lista,
• skriver ut en topplista baserat på poäng,
• håller igång tills användaren väljer att avsluta.

Det här är ett bra exempel på problemlösning med listor eftersom programmet måste samla flera värden, bearbeta dem och sedan presentera dem i en annan ordning än de matades in.

Programstruktur

Pseudokod:

Skapa en tom lista

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

Sortera listan efter poäng
Skriv ut topplistan

Planera datan först

Innan du skriver funktionerna behöver du bestämma hur varje resultat ska lagras. I exemplet används en lista med tuples:

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

Listan behövs eftersom det finns flera resultat. Varje tuple behövs eftersom namn och poäng hör ihop. När du planerar ett program med listor bör du alltid fråga: vad är ett element i listan?

Tuple eller dictionary? En tuple fungerar här eftersom varje resultat bara består av två värden som inte behöver ändras: namn och poäng. Om programmet senare ska kunna ändra poäng, lägga till datum eller spara flera uppgifter om spelaren är en dictionary ofta tydligare.

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

Kodexempel

# Funktion som lägger till ett nytt resultat i listan
def add_score(scores):
    # Läs in spelarens namn
    name = input("Ange namn: ")

    # Försök göra om poängen till ett heltal
    try:
        points = int(input("Ange poäng: "))

        # Spara namn och poäng tillsammans som en tuple
        scores.append((name, points))
    except ValueError:
        # Om poängen inte är ett heltal visas ett felmeddelande
        print("Du måste ange ett heltal.")

# Funktion som sorterar och skriver ut topplistan
def print_high_scores(scores):
    # Sortera listan efter poängen, alltså värdet på index 1 i varje tuple
    scores.sort(key=lambda x: x[1], reverse=True)

    print("\nTopplista:")

    # Gå igenom varje tuple och packa upp namn och poäng
    for name, points in scores:
        print(f"{name}: {points}")

# Programmets huvudfunktion
def main():
    # Här sparas alla resultat
    scores = []

    # Loopen håller programmet igång tills användaren vill sluta
    while True:
        add_score(scores)
        cont = input("Vill du lägga till fler resultat? (j/n): ")

        # Om användaren inte skriver j avslutas loopen
        if cont.lower() != "j":
            break

    # När inmatningen är klar skrivs topplistan ut
    print_high_scores(scores)

# Startar programmet
main()

Steg för steg: så fungerar hela programmet

1. main() startar programmet och skapar en tom lista: scores = [].
2. while True gör att programmet kan fortsätta fråga efter fler resultat.
3. add_score(scores) anropas och får listan scores som argument.
4. I add_score() frågar programmet efter namn och poäng.
5. int(input(...)) försöker göra om poängen till ett heltal.
6. Om det lyckas sparas resultatet som en tuple, till exempel ("Anna", 120).
7. Om användaren skriver något som inte är ett heltal fångas felet av except ValueError.
8. Efter varje inmatning frågar programmet om användaren vill fortsätta.
9. Om svaret inte är j körs break, och loopen avslutas.
10. print_high_scores(scores) sorterar listan och skriver ut topplistan.

Vad är lambda?

lambda är ett kort sätt att skriva en liten funktion direkt där den behövs. I det här kapitlet används den för att tala om vilken del av varje tuple sorteringen ska titta på.

Den här raden:

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

betyder ungefär samma sak som:

def get_points(x):
    return x[1]

scores.sort(key=get_points, reverse=True)

Om varje resultat är en tuple som ("Anna", 120), betyder x[0] namnet och x[1] poängen. Därför sorterar lambda x: x[1] efter poäng.

Obs: scores.sort(...) ändrar listan direkt. Om du vill behålla originalordningen kan du använda sorted(scores, ...), som skapar en ny sorterad lista.

Vad händer i programmet?

• Listan scores innehåller tuples med namn och poäng.
• sort() med lambda gör att listan sorteras efter poäng.
• Funktioner används för att strukturera koden.

Testfall och kantfall

Testa inte bara när användaren gör rätt. Ett program med listor behöver också klara tomma listor, felaktig inmatning och flera värden med samma poäng.

Utvidgning

• Lägg till kontroll för dubbletter.
• Lägg till möjlighet att spara listan till en fil.
• Skapa ett alternativ för att ta bort en spelare.

Öva själv

1. Skapa filen kap2-6-topplista.py i din kursmapp.
2. Skriv först en kort plan: input, bearbetning, output, datastruktur och funktioner.
3. Bygg ett menyprogram där användaren kan lägga till resultat, visa hela topplistan och avsluta.
4. Lägg till ett val som bara visar de tre bästa resultaten.
5. Testa minst tre kantfall från tabellen och skriv ner vad som händer.

När du har försökt själv kan du ladda ner ett lösningsförslag: kap2-6-topplista-losningsforslag.py

Lösningsförslaget använder en lista med dictionaries eftersom varje resultat får tydliga nycklar: name och points. Det gör programmet lättare att bygga vidare på än om varje resultat bara sparas som en tuple.

Reflektion

• Vad gjorde listor till rätt val i detta program?
• Hur hjälpte det att använda tuples i listan?
• Vilka delar av programmet blev enklare tack vare funktioner?