M05 Hjälp till uppgifter

# m05u09a, lista med listor
# Ex. "[['Hedvig', 19],['Milo', 48]]"
# Snygga utskrifter är inte prioriterade, vissa uppgifter
# beräknas men skrivs inte ut.

# Listan
l_resultat = []

# Inläsning från filen
with open('poäng.txt', 'r', encoding='utf-8') as f:
    for rad in f:
        rad = rad.split("|")
        l_resultat.append([rad[0], int(rad[1])])

# Skriv ut hela listan
print(l_resultat)

# 1. Skriv ut provpoängen och tillhörande elev sorterat från det lägsta till högsta
# Viktigt att lagra den sorterade listan, sorted() påverkar inte orginallistan
l_resultat = sorted(l_resultat, key=lambda x: x[1])
# Skriv ut listan sorterad från lägst till högst.
print(l_resultat)

# 2. Beräkna och skriva ut medelvärdet av provpoängen
summa = 0
for l in l_resultat:
    summa += l[1]
medel = summa / len(l_resultat)

# Alternativt skrivsätt
# i "_" lagras namnen, men de är ointressanta i detta läget.
# Skrivsättet kallas list comprehension
summa1 = sum(poäng for _, poäng in l_resultat)
summa2 = sum(l[1] for l in l_resultat)
print(summa1, summa2)

# 3. Skriva ut eleven med sämst och bäst resultat
# de två indexen är plats i listan 0 är först, -1 är sist.
print(f"Sämsta resultat: {l_resultat[0][0]} med {l_resultat[0][1]} poäng")
print(f"Bästa resultat: {l_resultat[-1][0]} med {l_resultat[-1][1]} poäng")

# m05u09c, lista med större dictionarys
# Ex. "[{'name': 'Hedvig', 'result': 19}, {'name': 'Milo', 'result': 48}]"
# Snygga utskrifter är inte prioriterade, vissa uppgifter
# beräknas men skrivs inte ut.

# Listan
l_resultat = []

# Inläsning från filen
with open('poäng.txt', 'r', encoding='utf-8') as f:
    for rad in f:
        rad = rad.split("|")
        l_resultat.append({'name': rad[0], 'result': int(rad[1])})

# Skriv ut hela listan
print(l_resultat)

# Sortering kan göras i ett stag i detta fall
sorterade_resultat = sorted(l_resultat, key=lambda x: x['result'])
# Skriv ut listan
print(sorterade_resultat)
# Skriv ut den sorterade listan elev för elev
for elev in sorterade_resultat:
    print(f"{elev['name']}: {elev['result']}")

# 2. Beräkna och skriva ut medelvärdet av provpoängen, viktigt att använda listan med tuples
summa = 0
for elev in sorterade_resultat:
    summa += elev['result']
medel = summa / len(l_resultat)

# Alternativ skrivsätt
# Här använder jag mig av något som kallas generator expression som liknar list comprehension.
# Generator expressions använder en liknande syntax som list comprehensions men skapar inte en lista i minnet.
# Istället produceras värdena ett i taget och konsumeras av den omslutande funktionen, i det här fallet sum().
# Detta gör generator expressions till ett minneseffektivt sätt att utföra operationer på samlingar av data,
# speciellt för stora dataset.
total_summa = sum(elev['result'] for elev in l_resultat)
# Beräkna medelvärdet
medelvarde = total_summa / len(l_resultat)

# 3. Skriva ut eleven med sämst och bäst resultat
# -1 för att det är sista elementet i den sorterade listan.
print(f"Sämsta resultat: {sorterade_resultat[0]['name']} med {sorterade_resultat[0]['result']} poäng")
print(f"Bästa resultat: {sorterade_resultat[-1]['name']} med {sorterade_resultat[-1]['result']} poäng")

# m05u09c, lista med större dictionarys
# Ex. "[{'name': 'Hedvig', 'result': 19}, {'name': 'Milo', 'result': 48}]"
# Snygga utskrifter är inte prioriterade, vissa uppgifter
# beräknas men skrivs inte ut.

# Listan
l_resultat = []

# Inläsning från filen
with open('poäng.txt', 'r', encoding='utf-8') as f:
    for rad in f:
        rad = rad.split("|")
        l_resultat.append({'name': rad[0], 'result': int(rad[1])})

# Skriv ut hela listan
print(l_resultat)

# Sortering kan göras i ett stag i detta fall
sorterade_resultat = sorted(l_resultat, key=lambda x: x['result'])
# Skriv ut listan
print(sorterade_resultat)
# Skriv ut den sorterade listan elev för elev
for elev in sorterade_resultat:
    print(f"{elev['name']}: {elev['result']}")

# 2. Beräkna och skriva ut medelvärdet av provpoängen, viktigt att använda listan med tuples
summa = 0
for elev in sorterade_resultat:
    summa += elev['result']
medel = summa / len(l_resultat)

# Alternativ skrivsätt
# Här använder jag mig av något som kallas generator expression som liknar list comprehension.
# Generator expressions använder en liknande syntax som list comprehensions men skapar inte en lista i minnet.
# Istället produceras värdena ett i taget och konsumeras av den omslutande funktionen, i det här fallet sum().
# Detta gör generator expressions till ett minneseffektivt sätt att utföra operationer på samlingar av data,
# speciellt för stora dataset.
total_summa = sum(elev['result'] for elev in l_resultat)
# Beräkna medelvärdet
medelvarde = total_summa / len(l_resultat)

# 3. Skriva ut eleven med sämst och bäst resultat
# -1 för att det är sista elementet i den sorterade listan.
print(f"Sämsta resultat: {sorterade_resultat[0]['name']} med {sorterade_resultat[0]['result']} poäng")
print(f"Bästa resultat: {sorterade_resultat[-1]['name']} med {sorterade_resultat[-1]['result']} poäng")

# m05u09d, Lista med tuples
# Ex. [('Hedvig', 19), ('Milo', 48), ('Elsa', 35)]
# Snygga utskrifter är inte prioriterade, vissa uppgifter
# beräknas men skrivs inte ut.

# Listan
l_resultat = []

# Inläsning från filen
with open('poäng.txt', 'r', encoding='utf-8') as f:
    for rad in f:
        rad = rad.split("|")
        l_resultat.append((rad[0], int(rad[1])))

# Skriv ut hela listan
print(l_resultat)

# 1. Skriv ut provpoängen och tillhörande elev sorterat från det lägsta till högsta
# Här visar jag att det går att direkt loopa igenom den sorterade listan utan att
# lagra denna listan separat, samma teknik går att använda även i de andra exemplen.
for namn, poang in sorted(l_resultat, key=lambda x: x[1]):
    print(f"{namn}: {poang}")

# 2. Beräkna och skriva ut medelvärdet av provpoängen
# Här skriver jag det så kort som möjligt, förklaring vad som händer finns i m05u09a
print(f"Medelvärdet av provpoängen är: {sum(poang for _, poang in l_resultat) / len(l_resultat)}")

# 3. Skriva ut eleven med sämst och bäst resultat
# Eftersom jag inte har någon sorterad lista så hämtar jag ut två tuple med dessa värden
sämsta = min(l_resultat, key=lambda x: x[1])
bästa = max(l_resultat, key=lambda x: x[1])
print(f"Sämsta resultat: {sämsta[0]} med {sämsta[1]} poäng")
print(f"Bästa resultat: {bästa[0]} med {bästa[1]} poäng")

Min tanke med att visa fyra olika lösningar är att visa att det finns flera olika alternativ på lösning för denna uppgiften. Att jobba med listor, dictionarys och tuples på olika sätt och i olika kombinationer ger lite olika möjligheter, utmaningar och eventuellt fördelar. Det viktigaste är att lösa uppgiften, sedan kan vi alltid diskutera vilken lösning som är bäst lämpad vid varje unikt tillfälle. Oftast är det inte så stora skillnader på lösningarna och det utgår nog mer ifrån vilka tekniker programmeraren gillar bäst.

Om vi låter ChatGPT analyser likheter och skillnader på de fyra olika varianterna, vilken analys görs då?

När vi lägger till en fjärde teknik, en lista av tuples, till de tidigare nämnda teknikerna för att lagra och hantera provresultat, blir analysen mer nyanserad. Här är en uppdaterad jämförelse av de fyra teknikerna med deras för- och nackdelar:

A. Lista i lista

Exempel: [['Hedvig', 19], ['Milo', 48]]

Fördelar:

• Enkel att använda och förstå.
• Lätt att sortera och iterera över.

Nackdelar:

• Mindre explicit vad gäller att koppla samman namn och poäng jämfört med dictionaries.

B. Lista med dictionaries

Exempel: [{'Hedvig': 19}, {'Milo': 48}]

Fördelar:

• Tydlig koppling mellan elevnamn och poäng.
• Flexibel med möjlighet att lägga till fler attribut per elev.

Nackdelar:

• Kan vara mindre effektiv för sortering och beräkningar.

C. Lista med större dictionaries

Exempel: [{'name': 'Hedvig', 'result': 19}, {'name': 'Milo', 'result': 48}]

Fördelar:

• Mycket tydlig struktur och lättläst.
• Flexibel för framtida tillägg av fler attribut.

Nackdelar:

• Kräver mer skrivande och uppmärksamhet vid sortering och jämförelser.

D. Lista av tuples

Exempel: [('Hedvig', 19), ('Milo', 48)]

Fördelar:

• Minneseffektiv genom oföränderlighet.
• Enkel och direkt för sortering och iterering.
• Explicit koppling mellan namn och poäng.

Nackdelar:

• Mindre flexibel om strukturen behöver utökas.
• Oföränderlighet kan vara en begränsning vid uppdatering av data.

Analys och rekommendation

När vi överväger de olika teknikerna för att lösa de specifika uppgifterna (sortering, beräkning av medelvärde, hitta högsta och lägsta poäng) blir det tydligt att varje teknik har sina styrkor i olika sammanhang:

1. Sortera och skriva ut från lägst till högst: Teknik A och D är båda enkla och effektiva för sortering, med teknik D som ger en tydligare koppling mellan namn och poäng. Teknik C är också bra men kräver lite mer kod.
2. Beräkna och skriva ut medelvärde: Alla tekniker kan hantera detta effektivt, men teknik D erbjuder en balans mellan minneseffektivitet och enkelhet i kodningen.
3. Hitta och skriva ut högsta och lägsta poängen: Teknik D är återigen mycket lämplig för sin enkelhet och direkt tillgång till data för jämförelse, likaså teknik A och C.

Slutsats: För de specifika uppgifterna i ditt scenario skulle jag rekommendera teknik D (lista av tuples) som det föredragna valet. Denna teknik erbjuder en bra balans mellan effektivitet, enkelhet, och direkt koppling mellan elevens namn och poäng, vilket gör den idealisk för sortering, medelvärdesberäkning, och identifiering av extrema värden. Om du dock förväntar dig att behöva utöka datamodellen med fler attribut per elev i framtiden, kan teknik C vara ett mer flexibelt alternativ.