Detta skapar en PDF som du sedan kan skriva ut. Du kan även spara ner PDFn och skriva ut senare.
Titel på utskriften?
Tack för ditt bidrag
Om vi kan använda det så lägger vi upp det på sidan. Nedan en länk till ditt bidrag om du vill spara det.
Spara som ...
Du sparar ditt skript under detta namn och kan sedan hämta tillbaka det med samma namn.
Läs in
Läs in ett tidigare sparat skript. Obs att du enbart kan läsa in skript i den webbläsare där du sparade skriptet. Vill du kunna läsa in och spara skript oberoende av webbläsare, så behöver du skaffa ett login (enkelt och gratis).
Skicka in bidrag
Föreslå rubrik
Beskriv vad din kod gör
Skapa kort länk
Använd en kort URL för att skicka länk till koden via SMS eller epost. När mottagaren klickar på länken, så öppnas denna webbsida, med din kod och din text. Länken rensas bort automatiskt om den inte används.
Rubrik (frivilligt)
Beskrivning (frivilligt)
Länk (kopiera hela)
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.
lista = "Grönt","Blått","Rött","Gult"
print(lista)
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.
Man kan tänka sig lådor med ett nummer på. Vi börjar alltid räkna på 0.
0
1
2
3
Grönt
Blått
Rött
Gult
Listor av int
Listan kan också bestå av rena siffror.
listan = [4,2,1,4,5]
print(listan)
listan = [4,2,1,4,5]
print(listan)
0
1
2
3
4
4
2
1
4
5
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)
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)
listan = [4,2,1,4,5]
listan[0] = 999
listan[3] = 777
print(listan)
Före
0
1
2
3
4
4
2
1
4
5
Efter
0
1
2
3
4
999
2
1
777
5
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))
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)
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))
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)
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)
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))
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))
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))
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)
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=":")
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=":")
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)
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)
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)
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)
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)
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)
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)
a = [1,2,3,4,5]
c = a *5
print(c)
Eller direkt såhär ...
lista = [2,1]*5
print(lista)
lista = [2,1]*5
print(lista)
Listor av strängar
Listor kan bestå av strängar.
a = ["Lisa","Anna","Kalle","Richard"]
print(a)
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)
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)
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)
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)
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))
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)
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)
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)
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)
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
0
1
2
3
Lisa
Anna
Kalle
Richard
a = ["Lisa","Anna","Kalle","Richard"]
a.pop(2)
print(a)
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)
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)
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)
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?
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)
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)
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)
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]
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()
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()
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()
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()
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))
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))
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))
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)
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"])
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))
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)
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)
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.
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=":")
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
def summa(xs):
sum = 0
for x in xs:
sum+=x
return(sum)
print(summa([1,2,3,4,5,6]))
def summa(xs):
sum = 0
for x in xs:
sum+=x
return(sum)
print(summa([1,2,3,4,5,6]))
■ Skriv en funktion som tar en lista av tal och returnerar det största talet
Visa lösning
def max(xs):
storst = -99999
for x in xs:
if x > storst:
storst = x
return(x)
print(max([1,2,3,4,5,6]))
def max(xs):
storst = -99999
for x in xs:
if x > storst:
storst = x
return(x)
print(max([1,2,3,4,5,6]))
■ 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
def primttal(tal):
for d in range(2,tal):
if tal%d==0:
return False
return True
print(primttal(11))
print(primttal(10))
def primttal(tal):
for d in range(2,tal):
if tal%d==0:
return False
return True
print(primttal(11))
print(primttal(10))
■ 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
def primtal(tal):
for d in range(2,tal):
if tal%d==0:
return False
return True
prim = [x for x in range(1,30) if primtal(x)]
print(prim)
def primtal(tal):
for d in range(2,tal):
if tal%d==0:
return False
return True
prim = [x for x in range(1,30) if primtal(x)]
print(prim)