Tuple

En tupel (eng. tuple) är en datastruktur som på flera sätt påminner listan. De största skillnaderna mellan dessa två är:

• tupler anges inom parenteser () medan listor anges inom hakparenteser []
• tupler är oföränderliga, medan innehållet i en lista kan ändra.

Den följande koden skapar en tupel som innehåller koordinaterna för en punkt:

punkt = (10, 20)

Vi kan komma åt element som är lagrade i tupler med index, på samma sätt som med listor:

punkt = (10, 20)
print("x-koordinat:", punkt[0])
print("y-koordinat:", punkt[1])

Värden som lagrats i en tupel kan inte ändras efter att tupeln har skapats. Det följande kommer därför inte att fungera:

punkt = (10, 20)
punkt[0] = 15

Vad behöver man tupler till?

Tupler är nyttiga i situationer där det finns en samling av värden som är sammankopplade på något sätt. Till exempel då man behandlar x- och y-koordinaterna hos en punkt, är tupeln ett naturligt val eftersom koordinater alltid består av två värden:

punkt = (10, 20)

Det är tekniskt möjligt att använda en lista för att lagra dessa:

punkt = [10, 20]

En lista är en samling av element i en viss ordning. Listans storlek kan också ändra. När vi arbetar med koordinater vill vi lagra en x-koordinat och en y-koordinat – inte en godtycklig lista med dessa värden.

Eftersom tupler är oföränderliga – till skillnad från listor – kan de användas som nycklar i lexikon. Det följande kodexemplet skapar ett lexikon där koordinater används som nycklar:

punkter = {}
punkter[(3, 5)] = "apa"
punkter[(5, 0)] = "banan"
punkter[(1, 2)] = "cembalo"
print(punkter[(3, 5)])

Det är inte möjligt att skapa ett liknande lexikon med hjälp av listor:

punkter = {}
punkter[[3, 5]] = "apa"
punkter[[5, 0]] = "banan"
punkter[[1, 2]] = "cembalo"
print(punkter[[3, 5]])

Tupler utan parenteser

Parenteser är inte obligatoriska då man skapar tupler. Följande variabeltilldelningar ger samma resultat:

siffror = (1, 2, 3)

siffror = 1, 2, 3

Det innebär att vi enkelt kan returnera flera värden med hjälp av tupler. Ta en titt på följande exempel:

def minmax(lista):
  return min(lista), max(lista)

lista = [33, 5, 21, 7, 88, 312, 5]

minst, storst = minmax(lista)
print(f"Minsta talet är {minst} och största är {storst}")

Funktionen returnerar två värden i en tupel. Returvärdet kan då tilldelas till två variabler samtidigt:

minst, storst = minmax(lista)

Att använda parenteser kan göra notationen tydligare. Till vänster av tilldelningssatsen har vi också en tupel som består av två variabelnamn. Värdena som finns i tupeln som funktionen returnerar tilldelas till dessa två variabler.

(minst, storst) = minmax(lista)

Du kanske minns metoden items från den förra delen. Vi använde den för att komma åt nycklarna och värdena som lagrats i ett lexikon:

lexikon = {}

lexikon["apina"] = "apa"
lexikon["banaani"] = "banan"
lexikon["cembalo"] = "cembalo"

for nyckel, varde in lexikon.items():
    print("nyckel:", nyckel)
    print("värde:", varde)

Tupler finns i bakgrunden här också. Metoden lexikon.items() returnerar varje nyckel-värdepar som en tupel, där det första elementet innehåller nyckeln och det andra värdet.

Ett annat användningsområde för tupler är att byta värden sinsemellan på två variabler:

tal1, tal2 = tal2, tal1

Tilldelningssatsen ovan svänger på värdena lagrade i variablerna tal1 och tal2. Resultatet är detsamma som vi skulle uppnå med hjälp av en hjälpvariabel:

hjalp = tal1
tal1 = tal2
tal2 = hjalp

Vänligen svara på en kort enkät gällande materialet för den här veckan.

Se dina poäng genom att klicka på cirkeln nere till höger av sidan.