Start | listor
 

Listor



En lista är en struktur där siffror, strängar eller vilka objekt som helst faktiskt, ligger i en lista åtskild av kommatecken. Det kan se ut som nedan.

Nyckelorden här är omslutet av hakparenteser och åtskilda av kommatecken.

Alla datatyper är välkomna

Lista av data


colors = ["Grönt","Blått","Rött","Gult"] print(colors)
Vi kan komma åt listans värden genom att lista variabler i vilka vi vill att de ska hamna.
a,b,c,d = ["Grönt","Blått","Rött","Gult"] print(a)
Vill vi bara komma åt de första värdet eller de första 2 värdena kan vi använda stjärnoperatorn.
a,*resten = ["Grönt","Blått","Rött","Gult"] print(a) print() a,b,*resten = ["Grönt","Blått","Rött","Gult"] print(a) print(b)
Omvänt kan vi komma åt de sista värdena på samma sätt.
*borjan, a = ["Grönt","Blått","Rött","Gult"] print(a) print() *borjan, a,b = ["Grönt","Blått","Rött","Gult"] print(a) print(b)
Observera att du kan skriva utan hakparentser.
lista = "Grönt","Blått","Rött","Gult" print(lista)
Men du kommer då få en tuple (vilket känns igen med parentesen runt), dvs du kommer kunna göra en del av de operationer du kan på en lista, eftersom en tuple och en lista är rätt så lika - men du kommer tex inte kunna ändra något värde och den egenskapen är kanske det du önskar mest. Så glöm inte: en lista omges av hakparenteser.

Fack med nummer


En mycket viktig egenskap för listor är att vi kan komma åt dem med deras index.
colors = ["Grönt","Blått","Rött","Gult"] print(colors[0]) print(colors[3])
Man kan tänka sig lådor med ett nummer på. Vi börjar alltid räkna på 0.

0123
GröntBlåttRöttGult


Listor av int


Listan kan också bestå av rena siffror.
listan = [4,2,1,4,5] print(listan)
01234
42145

x = listan[i]

Vi kommer åt talen som individer genom att känna deras position, deras index i listan. Det första elementet är indexerat som 0. En lista med 10 objekt numreras alltså 0-9
listan = [4,2,1,4,5] x = listan[0] y = listan[3] print(x) print(y)

s[i] = x

Vi kan ändra dem på motsvarande sätt
listan = [4,2,1,4,5] listan[0] = 999 listan[3] = 777 print(listan)
Före

01234
42145


Efter

01234
999217775


loopa över lista

summera talen i en lista


lst = [34,56,2,234,67,90] def summa(lsta): sum = 0 for i in lsta: sum += i return(sum) print(summa(lst))

print ut färger i lista


farger = ["röd","grön","blå","gul"] def printa(lsta): for f in lsta: print(f) printa(farger)

loopa över lista, skapa ny lista

Detta är superviktigt. Ibland kommer en uppgift som går ut på att vi ska göra något med varje element i en lista. Det betyder att vi skapar en ny lista med de nya önskvärda egenskaperna. Vissa element kanske inte ska tas med i den nya listan, andra kanske ska modifieras.

lägg till 1 på alla tal i lista


lst = [34,56,2,234,67,90] def modifiera(lsta): nylista = [] for i in lsta: nylista.append(i+1) return(nylista) print(modifiera(lst))
Du kan förstås skriva såhär också ...
lst = [34,56,2,234,67,90] def modifiera(lsta): for i in range(len(lsta)): lsta[i] += 1 modifiera(lst) print(lst)
Observera att följande inte kommer lämna några bestående förändringar på listan...
lst = [34,56,2,234,67,90] def modifiera(lsta): for i in lsta: i += 1 modifiera(lst) print(lst)

tag bort varannat tal


Här måste vi känna till i för att kunna kolla om det är udda eller jämt, så att vi vet om det är "varannat" tal.
lst = [34,56,2,234,67,90] def modifiera(lsta): nylista = [] for i in range(len(lsta)): if(i%2): nylista.append(lsta[i]) return(nylista) print(modifiera(lst))
Det går också göra såhär. Range har en 3:e parameter, hur mycket den ska stega.
lst = [34,56,2,234,67,90] def modifiera(lsta): nylista = [] for i in range(0,len(lsta),2): nylista.append(lsta[i]) return(nylista) print(modifiera(lst))

gör om till uppercase


farger = ["röd","grön","blå","gul"] def upper_lista(lsta): nylista = [] for f in lsta: nylista.append(f.upper()) return(nylista) print(upper_lista(farger))

loopa över inkonsistent lista


Konsistens betyder sammanhängande, konsekvent, ungefär. Något sånt krav finns inte.
mix = [2, "röd",2, "grön",2, "blå",2, "gul"] def printa(mix): for f in mix: print(f) printa(mix)

len(s) = antal element

Med len() kan vi se längden på listan och vi kan köra en loop över listan och skriva ut dem. I nedan for -loop så blir i ett index mellan 0 och längden på listan - 1.
listan = [4,2,1,4,5] for i in range(0,len(listan)): print(listan[i], end=":")
Det finns dock ett smartare sätt iterera över listor. I nedan for -loop blir i det aktuella elementet inuti loppen.
listan = [4,2,1,4,5] for i in listan: print(i, end=":")
Vilken av ovan 2 metoder som passar bäst beror på om du behöver ha tillgång till indexet, för att göra eller jämföra något, eller inte.


lista = lista1 + lista2

Vi kan lägga ihop två listor.
a = [1,2,3,4,5] b = [1,2,3,4,5] c = a + b print(c)
Vi kan lägga till en lista såhär också.
a = [1,2,3,4,5] a += a print(a)

append


Vill du lägga till ett element i en lista kan du använda append.
a = [1,2,3,4,5] print(a) a.append(99) print(a)
Du kan också skapa en listvariabel genom att omge den med hakparenteser och då går den lägga till.
a = [1,2,3,4,5] print(a) a += [99] print(a)
Vi skapar en variabel och lägger till ...
a = [1,2,3,4,5] nytt_element = 9999 a += [nytt_element] print(a)
Det går att lägga till en lista på detta sätt också.
a = [1,2,3,4,5] print(a) a += [99,999,9999] print(a)

lista = lista1 * 2

Vi kan skapa en lista genom att repetera en lista a 5 gånger.
a = [1,2,3,4,5] c = a *5 print(c)
Eller direkt såhär ...
lista = [2,1]*5 print(lista)

Listor av strängar


Listor kan bestå av strängar.
a = ["Lisa","Anna","Kalle","Richard"] print(a)

lista[i:j] = t, från pos i gå fram j steg

Om listan består av strängar kan vi segmentvis ändra innehållet såhär. Siffran 0 i a[0:1] pekar på "Lisa" och 1:an syftar på ett element fram, dvs enbart Lisa skall ersättas. Lisa ersätts sedan med ["Olof","Pecka","Sven"] och vi får en ny lista.
a = ["Lisa","Anna","Kalle","Richard"] a[0:1] = ["Olof","Pecka","Sven"] print(a)
Vi kan ersätta de 3 första namnen med 3 nya sähär.
a = ["Lisa","Anna","Kalle","Richard"] a[0:3] = ["Olof","Pecka","Sven"] print(a)

klippa ut lista[i:j]

Detta fungerar precis som med strängar. Om du glömt hur detta med slice funkar, titta tillbaka på strängar.

Vi klipper ut med start från 1 till (med inte inklusive) 3. Det betyder att enbart Anna och Kalle kommer med.
a = ["Lisa","Anna","Kalle","Richard"] b = a[1:3] print(b)
Vänder en lista baklänges. Om denna fråga kommer på en tenta, så kommer du troligtvis få fel om du använder detta "hack". Läraren vill nog att du ska skriva en loop som gör samma sak. Fråga!
a = ["Lisa","Anna","Kalle","Richard"] b = a[::-1] print(b)
En funktion som vänder listan. Vi stegar bakifrån och skapar en ny, som vi sedan returnerar.
a = ["Lisa","Anna","Kalle","Richard"] def vandlista(lst): baklanges_lista = [] for i in range(len(lst)): baklanges_lista.append(lst[-i-1]) return baklanges_lista print(vandlista(a))

pop(), ta bort element


Vi kan plocka bort det första namnet.
a = ["Lisa","Anna","Kalle","Richard"] a = a[1:] print(a)
Detta kan vi också göra med pop(0)
a = ["Lisa","Anna","Kalle","Richard"] a.pop(0) print(a)
Vi kan plocka bort det sista namnet.
a = ["Lisa","Anna","Kalle","Richard"] a = a[:-1] print(a)
Detta kan vi också göra med pop() utan argument. Om inget argument ges till pop så letar pop upp sista elementet.
a = ["Lisa","Anna","Kalle","Richard"] a.pop() print(a)
Vi kan ta bort ett element inne i lista med pop, genom att ange dess index. Detta är säkrare än att göra samma sak med slice. Göm inte att listan börjar med 0

0123
LisaAnnaKalleRichard

a = ["Lisa","Anna","Kalle","Richard"] a.pop(2) print(a)
Så, med append kan du lägga till element i lista och med pop kan du ta bort element i en lista.
a = ["Lisa","Anna","Kalle","Richard"] a.append("Julia") print(a) a += ["Olle"] print(a) a.pop(0) print(a) a = a[:-1] print(a)

klyv en lista i 2 delar


Vi klipper ut första halvan från start till (men inte inklusive) vad len(L)//2 blir. Detta är listans längd dividerat med 2 med eventuella decimaler är bortplockade. Andra halvan startar vid det tecken som ej var inkluderat i första halvan och sedan fram till slutet av listan.
L = [1,2,3,4,5,6,7,8,9,10] A = L[:len(L)//2] B = L[len(L)//2:] print(A) print(B)

listor, split & join

Med split kan du snabbt skapa en lista av en sträng. Är det nödvändigt kan du ta listan och åter bygga ihop den till en sträng med join. Så kom ihåg split & join. Hur får vi ut bepa nedan?

1. Vi splittar s på mellanslag och får en lista
2. Vi plockar ut första elementet ur listan, vilket är en sträng.
3. Vi splittar denna sträng på : och får en lista
4. Vi plockar ut elementet med index 1.
s = "apa:bepa:cepa depa lepa repa tepa" text = s.split()[0].split(":")[1] print(text)
Hur får vi ut datumet och hur skriver vi om datum på svenskt format?
s = "apa;bepa;cepa;depa;lepa;11/07/2024;11:56" datum_us = s.split(";")[5].split("/") datum_se = datum_us[2]+'-'+datum_us[0]+'-'+datum_us[1] s_se = ";".join(s.split(";")[:-2])+';'+datum_se+';'+s.split(";")[-1] print(s_se)
Läs mer om split här.

referens vs verklig kopia

referens


Observera här, att om du ändrar i den ursprungliga listan, så kommer ändringarna synas i alla referenser av listan. Det finns ju bara en lista, eller hur? En referens är inte en kopia.
a = ["Lisa","Anna","Kalle","Richard"] b = a print(b) a[0]="Olle" print(b)

verklig kopia


Vill vi ha en verklig kopia så måste vi först skapa den. Som du ser nedan så kommer inte ändringar i lista a att längre påverka lista b, därför att lista b är en verklig kopia - inte en referns.
a = ["Lisa","Anna","Kalle","Richard"] b = a[:] print(b) a[0]="Olle" print(b)
Du kan också skapa en verklig kopia med metoden copy(). Se nedan.
a = ["Lisa","Anna","Kalle","Richard"] b = a.copy() print(b) a[0]="Olle" print(b)
Såhär fungerar det med listor, set och dictionarys. Om vi tilldelar en variabel till en annan lista, så kommer båda variabler att bli synonymer för samma lista. Vill vi att det inte ska vara så, att den nya variabeln ska vara en egen lista, så måste vi se till att skapa en verklig kopia, antingen med copy() eller ovan slice -trick där vi slice:ar hela listan. Dvs, det skiljer sig från vanliga variabler med heltal eller flyttal, där talen automatiskt är verkliga kopior, egna boxar med värden.

tentauppgift


Att vi bara skapar en referens till en lista är viktigt förstå. Låt oss titta på en tenta -uppgift. Frågan på tentan är: "Vad blir utskriften?". Så, vad händer nedan? Ta det steg för steg och notera noga på papper eller i dokument.

Lösning:
1) lista1 = [4,3,2,1]
2) lista2 = lista1, detta betyder att lista2 och lista1 nu är synonymer för samma lista. Ungefär som Elisabeth kallas Lisa. Det är samma person.
3) eftersom element i [0] (dvs 4) är större än [1] (dvs 3) så byts plats på dessa element. lista 1 OCH lista 2 (det är ju numera samma lista) är alltså hädanefter [3,4,2,1]
4) lista1 = lista1[1:], dvs som vi lärde oss längre upp plockar vi bort första elementet. lista1 OCH lista2 (det är fortfarande samma lista) 'r nu [4,2,1]
5) Utskrift av [4,2,1]

def sortTwoFirst(lst): if(lst[0] > lst[1]): lst[0], lst[1] = lst[1], lst[0] def tail(lst): return(lst[1:]) lista1 = [4,3,2,1] lista2 = lista1 sortTwoFirst(lista2) lista1 = tail(lista1) print(lista1)

2D -listor ?

Ja, vi kan skapa en lista av listor.

012
012
abc
012
def
012
ghi
spelplan = [["a","b","c"], ["d","e","f"], ["g","h","i"]] for i in range(0,3): for j in range(0,3): print(spelplan[i][j], end=" ") print()
Poängen med detta kan vara att vi t.ex. vill kunna använda spelplan[x][y], där x och y är koordinataxlar i ett koordinatsystem.

Vi kan såklart skapa en 1D -lista och med lite matematik förvandla den till en 2D -spelplan.
spelplan = ["a","b","c", "d","e","f", "g","h","i"] for i in range(0,3): for j in range(0,3): print(spelplan[i*3+j], end=" ") print()
Ponera att detta råkar vara luffarschack, där 1 och 2 är spelare 1 och 2.
spelplan = [[0,0,2],[0,1,0],[0,0,0]] for i in range(0,3): for j in range(0,3): print(spelplan[i][j], end=" ") print()
Om vi vill att pjäserna skall representeras av X och O
pjas = ['.','X','O'] spelplan = [[0,0,2],[0,1,0],[0,0,0]] for i in range(0,3): for j in range(0,3): print(pjas[spelplan[i][j]], end=" ") print()
Summera talen i en lista av listor.
lst2d = [[1,2,3],[11,22,33],[111,222,333]] def summa(lstlst): sum = 0 for lst in lstlst: for tal in lst: sum = sum + tal return(sum) print(summa(lst2d))
Om vi vet att det alltid är exakt 3 element i den inre listan, kan vi summera såhär.
lst2d = [[1,2,3],[11,22,33],[111,222,333]] def summa(lstlst): sum = 0 for lst in lstlst: [a,b,c] = lst sum = sum + a + b + c return(sum) print(summa(lst2d))
Vi kan skapa listor av godtycklig dimension om det är nödvändigt, genom att köra listor i listor ...

Lista av tuples


Vi kan plocka ut värden ur tupplerna, inspirerade av ovan exempel.
lt = [("ris", 120),("gurka", 20),("mjölk", 50)] def summa(lst): sum = 0 for i in range(len(lst)): (mat,cal) = lst[i] sum = sum + cal return(sum) print(summa(lt))

Lista av sets


l = [{1,2,4,5},{4,5,3,7},{2,4,8,9}] def printa(lst): for s in lst: print(s) printa(l)

Listor av dictionaries

Vi kan faktiskt skapa listor av lite allt möjligt. Användbart - och vanligt - är t.ex. listor av dictionaries.
personer = [{"namn":"kalle","skonummer":43},{"namn":"olle","skonummer":48}] for person in personer: print(person["namn"])
Vi kan nästla listor av dictionaries, vars variabler är listor av listor eller dictionaries, osv hypotetiskt i all oändlighet. Detta är vanligt i t.ex. json -formaterad data, som går att hämta hem och läsa in.

Lista av dictionaries, med listor i


Försök se strukturen ovanifrån och in. Ta dig lite tid. De yttre [ .. ] hakparenteserna säger att vi har en lista av något. De inre krullparenteserna säger att vi har en lista av dictionaries. Slutligen ser vi att den ena av dictionaryns key, nämligen ammo, är av typen lista.




setup = [ {"enemy":1, "ammo":["granat","quantumwarp"]}, {"enemy":23, "ammo":["timedisruptor","quantumwarp"]}, {"enemy":89, "ammo":["granat"]}, ] def printa(lst): for enemy in lst: print(enemy["enemy"],"har",enemy["ammo"]) def vem_har(w,lst): who = [] for enemy in lst: for weapon in enemy["ammo"]: if(weapon==w): who.append(enemy["enemy"]) return(who) printa(setup) print() print(vem_har("granat",setup))


totalt inkonsistenta listor

Listor behöver inte en ens bestå av samma typ i samma lista.
lst = [1,2.1,{"x":1},None,"Hejsan",{1,2},False,[]] def dang_i_hate_this_horse(items): for item in items: if(isinstance(item,int)): print("Jaha ett heltal...",item) elif(isinstance(item,float)): print("Där var tydligen en float...",item) elif(isinstance(item,str)): print("Där har vi en sträng...",item) elif(isinstance(item,bool)): print("Där var en bool...",item) elif(isinstance(item,dict)): print("Hoppsan en dictionary...",item) elif(isinstance(item,set)): print("Hoppsan ett set...",item) elif(isinstance(item,list)): print("Hoppsan en lista...",item) elif(item == None): print("Där var ingenting...",item) dang_i_hate_this_horse(lst)

Packa upp med * stjärnoperator

Man kan tänka på stjärnoperatorn som att den packar upp listan, dvs plockar bort [] runt listan och kvar är bara en serie data (tal, strängar, annat). Den upp-packade listan kan du sedan paketera på nytt i något annat sammanhang. Du borde komma ihåg från ovan att du kan lägga till värden i en lista, genom att först göra dem list -liknande. Se nedan. Vill vi addera 999 till listan sätter vi hakparenteser runt så att 999 liknar en lista.
lista = [1,2,3,4,5,6] lista += [999] print(lista)
Så, stjärnoperatorn gör ungefär, typ, motsatsen (kan man säga så?). Stjärnoperatorn plockar bort listan runt talserien och kvar är en naken talserie. Talserien kan sedan monteras ihop igen och bli en ny lista.
lista1 = [1,2,3,4,5,6] lista2 = [7,8,9,10,11] kombinerad = [*lista1,*lista2] print(kombinerad)

mönstermatchning med * stjärnoperator


Om vi har en lista, vill plocka ut första eller sista och göra något med resten så kan vi använda stjärnoperator.
lista1 = [1,2,3,4,5,6] forsta, *resten = lista1 print(forsta) print(resten)
Eller ...
lista1 = [1,2,3,4,5,6] *borjan, sista = lista1 print(borjan) print(sista)
Eller ...
lista1 = [1,2,3,4,5,6] forsta, *mitten, sista = lista1 print(forsta) print(mitten) print(sista)

* stjärnoperator med print


Det kan också vara användbart packa upp listan vid utskrifter av listor.
a = ["Lisa","Anna","Kalle","Richard","Moa","Olle"] print(a)
Ovan utskrift är vad vi hade fått om vi bara printade ut listan. Studera resultatet nedan, när vi packa upp listan och skriver ut den.
a = ["Lisa","Anna","Kalle","Richard","Moa","Olle"] print(*a)
Vi kan ändra sep som normalt är mellanrum, till nyrad.
a = ["Lisa","Anna","Kalle","Richard","Moa","Olle"] print(*a, sep='\n')

inbyggda listfunktioner

Klicka för mer exempel hur dessa inbyggda list -funktioner fungerar.

append(it)Lägger till element i lista
clear(it)Tar bort alla element i lista
copy(it)Skapar en kopia av en lista
extend(it)Bygger ut lista med annan lista
enumerate(it,s)Skapar itererbar lista
insert(it)Lägger till element
pop(it)Plocka ut sista element
remove(it)Tar bort element i lista
reverse(it)Vänder på lista
join(it)Bygger sträng av lista
map(it)Kör funktion på alla element
sorted(it)Sorterad lista
len(it)Längen av lista
list(it)Skapar lista
filter(f,it)Filtrerar element i lista
reversed(s)Returnerar reverserad iterator
min(o)Minsta elementet
max(o)Största elementet
sum(o)Summan av objekten
iter(it)Skapar iter & ret nästa element
next(o,s)Nästa element i iterator
split(sep)Splittar med valfri separator
rsplit(sep)Splittar med begränsning
splitlines()Splittar med radslut som sep
count(sub)Räknar förekomsten
index(sub)Index för matchande
partition(it)Tar bort alla element i lista
rpartition(sep)Splittar 3 delar
range(f,t,s)From, to, step

Lite frågor

farger = ["Grönt","Blått","Rött","Gult"]
a,b,*resten = farger 
Vad är b i ovan kod?
  Grönt
  Blått
  Gult
Titta på koden ovan igen, vad är farger[2] ?
  Blått
  Gult
  Rött
Vad är farger[-1] ?
  Blått
  Gult
  Rött
listan = [4,2,1,4,5] for i in range(0,len(listan)): print(listan[i], end=":") print() for i in listan: print(i, end=":")
Titta på ovan kod. När är det lämpligt loopa med index skapat av range (övre) och när är det lämpligt loopa med elementet i loopen?
  Om du behöver använda indexet till något, så är det lämpligt loopa med range men om du inte behöver det så är det enklare och snyggare loopa med elementet i loopen.
  Det spelar ingen roll, den kortare versionen är dock snyggare.
Om du vill lägga till ett element i lista (en lista av siffror), hur skriver du då om du måste välja av nedanstående?
  lista += siffra
  lista += [siffra]
a = [1,2,3,4]
a[0:1] = [6,7,8]
Vad blir a i ovanstående kod?
  [7,8]
  [6]
  [6, 7, 8, 2, 3, 4]
a = [1,2,3,4]
a[0:3] = [6,7,8]
Vad blir a i ovanstående kod?
  [7,8]
  [6, 7, 8, 4]
  [6, 7, 8]
a = [1,2,3,4]
b = a
a[0]=5
print(b)
Vad blir utskriften i ovanstående kod ?
  [1, 2, 3, 4]
  [5, 2, 3, 4]

övningar

■ Skriv en funktion som tar en lista av tal och summerar alla talen.
  Visa lösning
■ Skriv en funktion som tar en lista av tal och returnerar det största talet
  Visa lösning
■ Skriv en funktion primttal(n) som tar ett tal som argument (n), som returnerar True om talet är delbart med något tal som inte är 1 eller talet själv (a.k.a. "primtal"). Du kan t.ex. köra en loop mellan 2 och talet och testa att dela med alla dessa tal däremellan. Är det del bart med ett enda tal så returnerar du direkt True. Om du efter att ha provat dela med alla tal inte hittar något, så returnerar du false.
  Visa lösning
■ Skriv en generator som skapar en lista av tal mellan 1 och 30 och som bara inkluderar tal som är primtal. Du kan testa om det är ett primtal med funktionen du nyss skapade.
  Visa lösning


38.50793838501 ms