Databehandling med Python

Python er et flott verktøy for å behandle og manipulere data. Med grunnleggende kontrollstrukturer som for-løkker og if-setninger kan du filtrere, transformere og analysere data på en enkel og effektiv måte.

Grunnleggende løkker i Python

En av de viktigste strukturene i programmering er løkker, som lar deg gjenta kode for hvert element i en samling.

For-løkker

For-løkker brukes til å iterere gjennom en sekvens (liste, tuppel, streng) eller andre iterable objekter.

# Enkel for-løkke over en liste
tall = [1, 2, 3, 4, 5]

for nummer in tall:
    print(nummer)
    
# Output:
# 1
# 2
# 3
# 4
# 5

# For-løkke med range
for i in range(5):  # range(5) gir tallene 0, 1, 2, 3, 4
    print(f"Indeks {i}: {tall[i]}")
    
# Output:
# Indeks 0: 1
# Indeks 1: 2
# Indeks 2: 3
# Indeks 3: 4
# Indeks 4: 5

If-setninger

If-setninger brukes til å utføre kode bare hvis en bestemt betingelse er oppfylt.

tall = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for nummer in tall:
    if nummer % 2 == 0:  # Sjekker om tallet er delelig med 2 (partall)
        print(f"{nummer} er et partall")
    else:
        print(f"{nummer} er et oddetall")
        
# Output:
# 1 er et oddetall
# 2 er et partall
# 3 er et oddetall
# ...etc.

Filtrere data med løkker og betingelser

En vanlig oppgave er å filtrere ut bestemte elementer fra en liste basert på visse kriterier.

# Liste med testresultater
resultater = [65, 72, 81, 58, 93, 45, 86, 79, 61, 94]

# Filtrere ut resultater over 80 (bestått med glans)
bestaatt_med_glans = []

for resultat in resultater:
    if resultat >= 80:
        bestaatt_med_glans.append(resultat)
        
print(f"Resultater over 80: {bestaatt_med_glans}")
# Output: Resultater over 80: [81, 93, 86, 94]

# Filtrere ut resultater under 60 (ikke bestått)
ikke_bestaatt = []

for resultat in resultater:
    if resultat < 60:
        ikke_bestaatt.append(resultat)
        
print(f"Resultater under 60: {ikke_bestaatt}")
# Output: Resultater under 60: [58, 45]

# Beregne antall i hver kategori
antall_glans = len(bestaatt_med_glans)
antall_ikke_bestaatt = len(ikke_bestaatt)
antall_vanlig = len(resultater) - antall_glans - antall_ikke_bestaatt

print(f"Bestått med glans: {antall_glans}")
print(f"Bestått: {antall_vanlig}")
print(f"Ikke bestått: {antall_ikke_bestaatt}")

# Samme filtrering som over, men med list comprehension
bestaatt_med_glans = [resultat for resultat in resultater if resultat >= 80]
ikke_bestaatt = [resultat for resultat in resultater if resultat < 60]

print(f"Resultater over 80: {bestaatt_med_glans}")
print(f"Resultater under 60: {ikke_bestaatt}")

Transformere data

Løkker og betingelser kan brukes til å transformere data fra ett format til et annet.

# Omregne temperaturer fra Celsius til Fahrenheit
celsius = [0, 5, 10, 15, 20, 25, 30, 35, 40]
fahrenheit = []

for temp in celsius:
    # Formelen for omregning: F = (C × 9/5) + 32
    temp_f = (temp * 9/5) + 32
    fahrenheit.append(temp_f)
    
print(f"Celsius: {celsius}")
print(f"Fahrenheit: {fahrenheit}")
# Output: Fahrenheit: [32.0, 41.0, 50.0, 59.0, 68.0, 77.0, 86.0, 95.0, 104.0]

# Med list comprehension
fahrenheit = [(temp * 9/5) + 32 for temp in celsius]

Telle og summere basert på betingelser

For-løkker er svært nyttige for å beregne summer og tellinger basert på bestemte kriterier.

# Elevdata med navn, alder og karakterer
elever = [
    {"navn": "Anna", "alder": 15, "karakter": 5},
    {"navn": "Bjørn", "alder": 16, "karakter": 4},
    {"navn": "Camilla", "alder": 15, "karakter": 6},
    {"navn": "David", "alder": 16, "karakter": 3},
    {"navn": "Emma", "alder": 15, "karakter": 5},
    {"navn": "Fredrik", "alder": 16, "karakter": 4},
    {"navn": "Gina", "alder": 15, "karakter": 5}
]

# Telle antall elever med karakter 5 eller bedre
antall_over_4 = 0
for elev in elever:
    if elev["karakter"] >= 5:
        antall_over_4 += 1
        
print(f"Antall elever med karakter 5 eller 6: {antall_over_4}")
# Output: Antall elever med karakter 5 eller 6: 4

# Beregne gjennomsnittsalder
total_alder = 0
for elev in elever:
    total_alder += elev["alder"]
    
gjennomsnitt_alder = total_alder / len(elever)
print(f"Gjennomsnittsalder: {gjennomsnitt_alder}")
# Output: Gjennomsnittsalder: 15.43...

# Beregne gjennomsnittskarakter per aldersgruppe
sum_15 = 0
antall_15 = 0
sum_16 = 0
antall_16 = 0

for elev in elever:
    if elev["alder"] == 15:
        sum_15 += elev["karakter"]
        antall_15 += 1
    elif elev["alder"] == 16:
        sum_16 += elev["karakter"]
        antall_16 += 1

gjennomsnitt_15 = sum_15 / antall_15 if antall_15 > 0 else 0
gjennomsnitt_16 = sum_16 / antall_16 if antall_16 > 0 else 0

print(f"Gjennomsnittskarakter for 15-åringer: {gjennomsnitt_15:.2f}")
print(f"Gjennomsnittskarakter for 16-åringer: {gjennomsnitt_16:.2f}")
# Output: 
# Gjennomsnittskarakter for 15-åringer: 5.25
# Gjennomsnittskarakter for 16-åringer: 3.67

Praktisk eksempel: Analyse av test-resultater

# Testresultater
poeng = [87, 65, 92, 78, 43, 56, 91, 75, 63, 88, 82, 71, 58, 95, 77, 69, 83, 52, 74, 86]

# Kategorier for karakter
# A: 90-100, B: 80-89, C: 70-79, D: 60-69, E: 50-59, F: 0-49

# Telle antall i hver kategori
antall_a = 0
antall_b = 0
antall_c = 0
antall_d = 0
antall_e = 0
antall_f = 0

for p in poeng:
    if p >= 90:
        antall_a += 1
    elif p >= 80:
        antall_b += 1
    elif p >= 70:
        antall_c += 1
    elif p >= 60:
        antall_d += 1
    elif p >= 50:
        antall_e += 1
    else:
        antall_f += 1

# Utskrift av resultatene
print(f"Analyse av {len(poeng)} testresultater:")
print(f"A (90-100): {antall_a} elever")
print(f"B (80-89): {antall_b} elever")
print(f"C (70-79): {antall_c} elever")
print(f"D (60-69): {antall_d} elever")
print(f"E (50-59): {antall_e} elever")
print(f"F (0-49): {antall_f} elever")

# Beregne prosentandeler
total = len(poeng)
prosent_a = (antall_a / total) * 100
prosent_b = (antall_b / total) * 100
prosent_c = (antall_c / total) * 100
prosent_d = (antall_d / total) * 100
prosent_e = (antall_e / total) * 100
prosent_f = (antall_f / total) * 100

print("
Prosentfordeling:")
print(f"A: {prosent_a:.1f}%")
print(f"B: {prosent_b:.1f}%")
print(f"C: {prosent_c:.1f}%")
print(f"D: {prosent_d:.1f}%")
print(f"E: {prosent_e:.1f}%")
print(f"F: {prosent_f:.1f}%")

# Beregne gjennomsnitt
gjennomsnitt = sum(poeng) / len(poeng)
print(f"
Gjennomsnittlig poengsum: {gjennomsnitt:.1f}")

# Finne høyeste og laveste poengsum
høyest = max(poeng)
lavest = min(poeng)
print(f"Høyeste poengsum: {høyest}")
print(f"Laveste poengsum: {lavest}")

# Finne antall bestått (poeng >= 60)
antall_bestått = 0
for p in poeng:
    if p >= 60:
        antall_bestått += 1
        
prosent_bestått = (antall_bestått / total) * 100
print(f"
Antall bestått: {antall_bestått} av {total} ({prosent_bestått:.1f}%)")

Mer avansert: Nestede løkker

Nestede løkker (løkker inne i løkker) kan brukes for mer komplekse databehandlingsoppgaver.

# Eksempel på bruk av nestede løkker for frekvenstabeller

# Data: antall mål per kamp
mål_per_kamp = [0, 1, 2, 3, 1, 2, 0, 2, 4, 1, 2, 3, 1, 2, 2, 3, 0, 1, 2, 1]

# Finne unike verdier
unike_verdier = []
for verdi in mål_per_kamp:
    if verdi not in unike_verdier:
        unike_verdier.append(verdi)
        
unike_verdier.sort()  # Sorterer verdiene i stigende rekkefølge

# Telle forekomster med en nestet løkke
frekvenser = []
for verdi in unike_verdier:
    teller = 0
    for mål in mål_per_kamp:
        if mål == verdi:
            teller += 1
    frekvenser.append(teller)
    
# Skriv ut frekvenstabell
print("Mål | Frekvens")
print("------------")
for i in range(len(unike_verdier)):
    print(f"{unike_verdier[i]}   | {frekvenser[i]}")

# Produsere en liste basert på frekvenstabellen
alle_mål = []
for i in range(len(unike_verdier)):
    # Legger til verdien det antall ganger den forekommer
    for j in range(frekvenser[i]):
        alle_mål.append(unike_verdier[i])
        
print(f"
Generert liste basert på frekvenstabellen:")
print(alle_mål)
# Denne listen skal være identisk med den opprinnelige mål_per_kamp-listen,
# men vil være sortert etter stigende verdi.