Utforskning 5

Denne uken skal vi se på noen eksempler på lister og hva man kan gjøre med dem.

Basics

Du kan bruke len for å finne antall elementer i en liste.

a = [5, 7, 2, 9, 10]
print(f'{a = }')
print(f'{len(a) = }')

Du kan bruke in -operatoren for å sjekke om en verdi finnes i en liste.

a = [5, 7, 2, 9, 10]
if 9 in a:
    print(f"9 is in the list {a = }!")

Lister kan ha blandede typer.

b = [5, "str", [0.1, 0.2], 9.3]
print(f'{b = }')

Vi kan sette sammen lister.

a = [5, 7, 2, 9, 10]
b = [5, "str", [0.1, 0.2], 9.3]
c = a + b
print(f"{c = }")

Indekser

Hvert element i en liste har en indeks, dette tilsvarer elementets posisjon i listen. Det første elementet har indeks 0, neste har indeks 1, og så videre. Vi kan bruke indeks for å få hente ut verdien på en viss posisjon i listen.

Vi kommer til verdien på indeks i ved å skrive liste[i].

en_liste = ["a", "b", "c", "d", "e"]
print(f"{en_liste = }")


print(f"{en_liste[0] = }")
print(f"{en_liste[1] = }")

Siden indeks begynner på 0 så kommer det siste elementet ha indeks én mindre enn lengden av listen.

en_liste = ["a", "b", "c", "d", "e"]
print(f"{en_liste[4] = }")
print(f"{en_liste[5] = }")  # Krasjer, IndexError: list index out of bounds

Indeks på siste elementet er alltid lengden av listen minus én.

en_liste = ["a", "b", "c", "d", "e"]
print(f"{en_liste[len(en_liste) - 1] = }")

Men vi kan også få det siste elementet ved å skrive kun [-1]. Python subtraherer negative indeksverdier fra len() automatisk

en_liste = ["a", "b", "c", "d", "e"]
print(f"{en_liste[-1] = }")

Vi kan også mutere verdiene i listen ved å bruke indeks.

en_liste = ["a", "b", "c", "d", "e"]
print(f"{en_liste = }")
print("Vi muterer listen ved å skrive: en_liste[2] = 'å'")
en_liste[2] = "å"
print(f"{en_liste = }")

Beskjæring

Vi kan bruke beskjæring (engelsk: slicing) for å klippe ut en del av en liste. Vi kan få ut dellisten fra og med index \(i\) til og opp til men ikke inkludert \(j\) ved å skrive [i:j] rett etter listen.

en_liste = ["a", "b", "c", "d", "e"]
print(f"{en_liste[1:4] = }")

Vi kan hoppe med ulike steg-lengder (akkurat som med range-funksjonen).

en_liste = ["a", "b", "c", "d", "e"]
print(f"{en_liste[0:5:2] = }")  # en_liste[start:stop:step]

Vi kan bruke negative steg.

en_liste = ["a", "b", "c", "d", "e"]
print(f"{en_liste[3:1:-1] = }")

Vi må ikke angi start og/eller stop om vi vil gå helt fra start og/eller helt til slutten.

en_liste = ["a", "b", "c", "d", "e"]
print(f"{en_liste[:3] = }")
print(f"{en_liste[3:] = }")
print(f"{en_liste[3::-1] = }")
print(f"{en_liste[:] = }")

Eksempel 3: Listefunksjoner

Her er noen ulike metoder man kan bruke på lister. Du kan finne flere på Python sin offisielle dokumentasjon.

a = [5, 7, 2, 9, 10]
print(f"{a = }")


# .append()
a.append(7)
print(f"We append 7: {a}")


# .insert()
a.insert(2, 6)
print(f"We insert 6 at index 2: {a}")


# .reverse()
a.reverse()
print(f"We reverse a: {a}")


# .remove()
a.remove(7)
print(f"We remove the first occurence of 7: {a}")


# .sort()
a.sort()
print(f"We sort a: {a}")

Eksempel 4: Vanlige løkkestrukturer

Følgende er noen eksempler på en vanlig løkkestruktur når vi jobber med lister.

Summere alle alementer i en lisete med tall.

def my_sum(numbers):
    # Instansiere en variabel å bygge på.
    running_total = 0

    # Kjør en for-løkke som bygger opp verdien i variabelen.
    for number in numbers:
        running_total += number

    return running_total

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
total = my_sum(num_list)
print(f'{total = }')

Beregner minimum av en liste med helltall.

def my_min(numbers):
    # Instansiere en variabel å bygge på.
    minimum = numbers[0]

    # Kjør en for-løkke som bygger opp verdien i variabelen.
    for number in numbers:
        if number < minimum:
            minimum = number

    return minimum

num_list = [1, 2, -3, 4, 5, -6, 7, 8, 9, 10]
minimum = my_min(num_list)
print(f'{minimum = }')

Returnerer alle verdiene i lista xs som er større enn lower_bound.

def filter_greater_than(xs, lower_bound):
   # Instansiere en variabel å bygge på.
   filtered_list = []

   # Kjør en for-løkke som bygger opp verdien i variabelen.
   for number in xs:
       if number > lower_bound:
           filtered_list.append(number)

   return filtered_list

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

filtered_list = filter_greater_than(num_list, 4)
print(f'{filtered_list = }')

Eksempel 5: Tupler

Tupler er litt som en liste, men bruker () isteden for []. Vi bruker vanligvis tupler for objekter hvor lengden ikke vil endres, dvs. antall objekter/elementer forventes å være statiske. Det er noen viktige forskjeller på tupler og lister som vi skal se på seinere. I dette eksempelet lager vi noen tupler og ser hvordan de kan brukes.

# a tuple with three elements:
bergen = ("rain", 60.39, 5.32)  # bergen weather, latitude, longitude

# a tuple with one element
# (notice the comma - what happens if you remove the comma?)
bergen_weather = ("rain",)

print("Two tuples:")
print(f"bergen = {bergen}\nbergen_weather = {bergen_weather}\n")

Vi kan “pakke opp” en tupel til flere variabler.


bergen = ("rain", 60.39, 5.32)

(weather, latitude, longitude) = bergen 
print(f"weather = {weather}")
print(f"latitude = {latitude}")
print(f"longitude = {longitude}")

Lister over tupler.

# here is a list of tuples
bergen_temp_forecast = [
   (16.0, "onsdag"),
   (14.0, "torsdag"),
   (13.0, "fredag"),
   ]

# we can unpack them automatically while going through the list
for temp, day in bergen_temp_forecast:
   print(f"På {day} blir det {temp} grader.")

Eksempel 6: Mutasjon

Lister, tupler og strenger er like på mange måter, hovedforskjellen er at listene kan muteres (endres), mens tupler ikke kan muteres.

Her er noen eksempler på forskjellen mellom lister (som kan muteres) og tupler (som er uforanderlige, engelsk: immutable).

a = [2, 4, 8, 16]
b = a
c = a[:]
print(f"{a = }\n{b = }\n{c = }")

print("Muterer a:")
a[0] = 42

print(f"{a = }\n{b = }\n{c = }")
print("Muterer b:")
b[1] = 111
print(f"{a = }\n{b = }\n{c = }")

# Tupler (og strenger) er ikke muterbare
a = (2, 4, 8, 16)
b = a
c = a
d = a[:]
print(f"{a = }\n{b = }\n{c = }")

print("Prøver å mutere a:")
a[0] = 42 # Krasjer

I noen tilfeller gjør tilsynelatende samme operasjon ulike ting.

print("Lister v1")
a = [1, 2, 3]
b = a

print(f"  {a = }\n  {b = }")
print("Utfører a += [42, 43]")
a += [42, 42] # Muterer listen
print(f"  {a = }\n  {b = }")
print()

print("Tupler")
a = (1, 2, 3)
b = a

print(f"  {a = }\n  {b = }")
print("Utfører a += (42, 43)")
a += (42, 42) # Oppretter en ny tupel
print(f"  {a = }\n  {b = }")
print()

print("Lister v2")
a = [1, 2, 3]
b = a

print(f"  {a = }\n  {b = }")
print("Utfører a = a + [42, 43]")
a = a + [42, 42] # Oppretter en ny liste
print(f"  {a = }\n  {b = }")
print()