Loopar

I en aritmetisk talföljd börjar man med startvärdet och räknar sedan ut efterföljande element genom att lägga till steglängden gång på gång. Vi ska alltså göra samma sak många gånger på rad, och då låter det rimligt att använda en loop. Vi börjar dock med att skapa variabler för antalet element som ska skriva ut, k, steglängden, d och det nuvarande elementet, element.

k = 20 d = 3 element = 7

Talföljden ska börja på 7, så vi sätter element till det värdet. Vi lägger sedan till en for-sats som upprepas k gånger, vilket vi kan göra med kommandot range(k) och en variabel i som vi aldrig använder.

k = 20 d = 3 element = 7 for i in range(k):

Inne i loopen skriver vi ut element och lägger sedan till steglängden för att beräkna nästa element.

k = 20 d = 3 element = 7 for i in range(k): print(element) element = element + d

7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 52 55 58 61 64

Som programmet är skriver räknas det ut ett extra element på slutet av den sista iterationen som aldrig skrivs ut, men det gör inget. Om man vill undvika det går det att skriva om loopen så att utskriften sker efter att det nya elementet har beräknats, men då måste man också lägga till en extra utskrift före loopen samt att loopen då bara körs k -1 gånger.

Uppgiften är att lösa ekvationen genom "upprepad prövning". Det innebär alltså att vi prövar en mängd olika x-värden och ser om likheten gäller. Vi börjar med att testa ett enda x-värde. Ekvationen kan inte skrivas in rakt av, utan tre saker måste ändras:

• Operatorn * ska användas vid multiplikation.
• Operatorn ** ska användas i potenser.
• Likhetstecknet ska bytas mot jämförelseoperatorn ==.

Vi sätter ihop ett program som testar ett x och skriver ut det om likheten är uppfylld.

x = 0 if x**4 - 99*x**3 - 2786*x**2 - 1980*x - 56120 == 0: print(x)

>

x = 0 löser inte ekvationen, så inget skrivs ut. Vi vill nu göra det här testet för alla x-värden i intervallet. if-satsen läggs då i en for-sats som räknar upp x-värdena.

for x in range(-1000, 1001): if x**4 - 99*x**3 - 2786*x**2 - 1980*x - 56120 == 0: print(x)

> -23 122

Genom att ange två argument till funktionen range() kan vi ange intervallet som ska prövas. Eftersom range() inte tar med den övre gränsen man anger skriver vi 1001 istället för 1000. Ekvationens två lösningar är alltså x=-23 och x=122.

Vi är ute efter det första positiva heltalet med en tillräckligt stor kvadrat. Vi kan då börja med ett lågt tal, t.ex. tal = 1, och sedan öka talet ett steg i taget med en while-sats.

tal = 1 while #villkor: tal = tal + 1

Vi behöver bara formulera loopens villkor. Talet ska fortsätta öka så länge talets kvadrat tal**2 är mindre än 123 456.

tal = 1 while tal**2 < 123456: tal = tal + 1

Loopen avslutas när kvadraten på tal är minst 123 456, och då är tal värdet vi är ute efter. Därför skriver vi ut det efter att loopen kört klart.

tal = 1 while tal**2 < 123456: tal = tal + 1 print(tal)

> 352

Alltså är 352 det minsta positiva heltalet med en kvadrat på minst 123 456.

Det här är en typisk situation då loopar är väldigt användbara: Då programmet ska göra samma sak för flera olika fall. Lösningen borde alltså bygga på att koden som skapar ettans tabell ligger inuti en loop, så att koden upprepas. Vi ska göra 10 tabeller, så vi gör en for-sats med 10 upprepningar.

for a in range(10): print('{}:ans tabell'.format(1)) for b in range(1, 11): print(1*b, end=' ')

> 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10

Här ser vi att "rubriken" för varje ny tabell hamnar i slutet på föregående rad, istället för på en ny rad. Det beror på att vi använt end=' ' där tabellen skapas. Det gör att nästa utskrift hamnar bredvid den förra istället för under. Vi kan lösa det med ett tomt print()-kommando i slutet av varje tabell, eller print('\n') om man vill lufta utskrifterna lite.

for a in range(10): print('{}:ans tabell'.format(1)) for b in range(1, 11): print(1*b, end=' ') print()

> 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10

Men nu är det hög tid att få in lite variation i loopandet. Kommandot format(1) på rad 2 ersätter klammerparenteserna i textsträngen med en etta. Genom att byta bort ettan kan vi alltså ändra i rubrikerna. Vi vill att rubriken ska variera, så vi byter ettan mot variabeln a.

for a in range(10): print('{}:ans tabell'.format(a)) for b in range(1, 11): print(1*b, end=' ') print()

> 0:ans tabell 1 2 3 4 5 6 7 8 9 10 1:ans tabell 1 2 3 4 5 6 7 8 9 10 2:ans tabell 1 2 3 4 5 6 7 8 9 10 3:ans tabell 1 2 3 4 5 6 7 8 9 10 4:ans tabell 1 2 3 4 5 6 7 8 9 10 5:ans tabell 1 2 3 4 5 6 7 8 9 10 6:ans tabell 1 2 3 4 5 6 7 8 9 10 7:ans tabell 1 2 3 4 5 6 7 8 9 10 8:ans tabell 1 2 3 4 5 6 7 8 9 10 9:ans tabell 1 2 3 4 5 6 7 8 9 10

Rubrikerna ändras, men de har fel värden. range() börjar räkna från 0, och därför blir det fel. Vi ändrar så den räknar från 1 istället, och kom ihåg att höja den övre gränsen från 10 till 11 också så den inte slutar räkna för tidigt.

for a in range(1, 11): print('{}:ans tabell'.format(a)) for b in range(1, 11): print(1*b, end=' ') print()

> 1:ans tabell 1 2 3 4 5 6 7 8 9 10 2:ans tabell 1 2 3 4 5 6 7 8 9 10 3:ans tabell 1 2 3 4 5 6 7 8 9 10 4:ans tabell 1 2 3 4 5 6 7 8 9 10 5:ans tabell 1 2 3 4 5 6 7 8 9 10 6:ans tabell 1 2 3 4 5 6 7 8 9 10 7:ans tabell 1 2 3 4 5 6 7 8 9 10 8:ans tabell 1 2 3 4 5 6 7 8 9 10 9:ans tabell 1 2 3 4 5 6 7 8 9 10 10:ans tabell 1 2 3 4 5 6 7 8 9 10

Nu går variabeln a genom alla tal från 1 till 10, och rubrikerna ser ut att stämma. Slutligen måste vi bara rätta till tabellernas innehåll. Tabellerna byggs upp av den inre loopen, där variabeln b anger antalet ettor att räkna ihop och skriva ut.

for b in range(1, 11): print(1*b, end=' ')

Men i tvåans tabell är det ju inte ettor man ska räkna på utan tvåor, och i treans tabell är det treor osv. Därför byter vi ut ettan mot tabellnumret a.

for a in range(1,11): print('{}:ans tabell'.format(a)) for b in range(1, 11): print(a*b, end=' ') print()

> 1:ans tabell 1 2 3 4 5 6 7 8 9 10 2:ans tabell 2 4 6 8 10 12 14 16 18 20 3:ans tabell 3 6 9 12 15 18 21 24 27 30 4:ans tabell 4 8 12 16 20 24 28 32 36 40 5:ans tabell 5 10 15 20 25 30 35 40 45 50 6:ans tabell 6 12 18 24 30 36 42 48 54 60 7:ans tabell 7 14 21 28 35 42 49 56 63 70 8:ans tabell 8 16 24 32 40 48 56 64 72 80 9:ans tabell 9 18 27 36 45 54 63 72 81 90 10:ans tabell 10 20 30 40 50 60 70 80 90 100

Vi börjar med att skapa en variabel n som anger antalet udda tal. Eftersom vi ska bygga upp listan med hjälp av en loop måste vi också skapa en tom lista som vi sedan kan lägga in våra element i.

n = 10

lista = []

Variabeln n anger antalet element som ska läggas till, så vi fortsätter med att skapa en for-sats som har så många iterationer.

n = 10

lista = [] for i in range(n):

I det här fallet kommer i att gå från 0 till och med 9, alltså 10 gånger. I varje iteration kan vi sedan använda i för att beräkna ett udda tal med formeln 1 + 2i. Det kommer att ge oss 1 + 2 * 0 = 1 i första iterationen, 1 + 2 * 1 = 3 i den andra, osv. Vi beräknar detta i varje iteration och lägger till det till listan med kommandot append().

n = 10

lista = [] for i in range(n): udda_tal = 1 + 2*i lista.append(udda_tal)

Till sist ska vi bara skriva ut vår lista.

n = 10

lista = [] for i in range(n): udda_tal = 1 + 2*i lista.append(udda_tal) print(lista)

> [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

Nu ska vi lägga ihop två listor element för element, vilket innebär att första elementen i ena listan ska läggas ihop med första elementet från den andra listan osv. Vi börjar med att skapa de två ursprungliga listorna samt en tom lista att lägga resultatet i.

lista_1 = [-13, -25, 22, 5, -29, -7, 10, -10, -30, -17, -16] lista_2 = [16, 10, -7, -21, 11, -21, 7, -9, 26, -19, 27]

ny_lista = []

Oftast när man går igenom elementen i en lista använder man en loop på formen for element in lista, men det fungerar inte i det här fallet eftersom vi behöver element från båda listorna. Då kan man istället använda ett index som man stegar upp för varje iteration.

lista_1 = [-13, -25, 22, 5, -29, -7, 10, -10, -30, -17, -16] lista_2 = [16, 10, -7, -21, 11, -21, 7, -9, 26, -19, 27]

ny_lista = [] langd = len(lista_1) for i in range(langd):

Här har vi först använt funktionen len() för att bestämma längden på listorna. Det hade gått lika bra att bestämma längden på lista_2 eftersom de är lika långa. Vi har sedan använt range() för att få en uppräkning från 0 till langd- 1. Variabeln i kommer då att gå igenom alla index för elementen i listorna.

lista_1 = [-13, -25, 22, 5, -29, -7, 10, -10, -30, -17, -16] lista_2 = [16, 10, -7, -21, 11, -21, 7, -9, 26, -19, 27]

ny_lista = [] for i in range(len(lista_1)): summa = lista_1[i] + lista_2[i] ny_lista.append(summa)

Inne i loopen lägger vi sedan ihop elementen med index i från lista_1 och lista_2. Denna summa lägger vi till på slutet av den nya listan med summorna. Allt vi behöver göra efter att loopen är färdig är att skriva ut resultatet.

lista_1 = [-13, -25, 22, 5, -29, -7, 10, -10, -30, -17, -16] lista_2 = [16, 10, -7, -21, 11, -21, 7, -9, 26, -19, 27]

ny_lista = [] for i in range(len(lista_1)): summa = lista_1[i] + lista_2[i] ny_lista.append(summa) print(ny_lista)

> [3, -15, 15, -16, -18, -28, 17, -19, -4, -36, 11]

Här kan vi använda en loop för att räkna upp alla heltal fram till talet n. Det går att använda antingen en while- eller for-sats till detta, men enklast är nog for tillsammans med range().

n = 5

for tal in range(1, n+1): print(tal)

> 1 2 3 4 5

Se till att du använder rätt argument till funktionen range(). Vi anger en etta så den inte räknar från 0, och eftersom range() inte använder den övre gränsen måste vi sätta gränsen till n+1 för att talet n ska ingå. En print-sats är bra för att kontrollera att loopen går igenom rätt värden. Dessa värden ska multipliceras ihop, så vi skapar variabeln produkt för att lagra resultatet.

n = 5

produkt = 1 for tal in range(1, n+1):

Tänk på att produkten inte kan börja på noll. I så fall kommer produkten alltid vara noll, oavsett vad man sedan multiplicerar med! 1 är därför rätt startvärde. Sedan måste vi få in själva multiplikationssteget i loopen, så att produkten byggs upp. Vi gör detta genom att i varje iteration skriva över värdet i produkt med produkt * tal.

n = 5

produkt = 1 for tal in range(1, n+1): produkt = produkt * tal

Efter första iterationen kommer värdet på variabeln produkt vara 1*2, efter andra iterationen kommer det vara 1*2*3, osv. När loopen har kört alla 5 iterationer vill vi slutligen skriva ut resultatet. Det räcker med print(produkt), men med format kan man få ett lite prydligare, mer komplett svar.

n = 5

produkt = 1 for tal in range(1, n+1): produkt = produkt * tal print('{}! = {}'.format(n, produkt))

> 5! = 120

Kontrollera också att programmet klarar av specialfallen 0! = 1 och 1! = 1. I vårt program kommer loopen aldrig startas för n=0, och då ligger produkt kvar på startvärdet 1 vilket blir rätt. För n=1 görs en iteration, men beräkningen blir då 1* 1 vilket gör att produkt ändå ligger kvar på 1, vilket är rätt svar.

Vi börjar med att titta på variablerna som skapas på rad 1 och 3.

lista = [3, 10, -3, 19, -91, 55]

b = True

Variabeln lista är bara vårt invärde, en lista med positiva och negativa tal. Det som står på rad 3 kan dock se lite mer ovant ut. Variabeln b tilldelas True, som är ett värde av datatypen bool. En bool kan antingen vara True eller False, alltså sann eller falsk. Vi börjar tydligen med något som är sant. Vi tittar sedan på loopen.

for x in lista: if x <= 0: b = False

Loopen går igenom varje värde i listan och undersöker om de är mindre än eller lika med 0. Om de är det sätts variabeln b till False. I den lista som finns som exempel i koden kommer detta att ske 2 gånger: för -3 och -91. Andra gången ändras dock inte värdet eftersom variabeln redan är satt till False. Vi tittar till sist på if-satserna.

if b: print('Ja') else: print('Nej')

Om b är sann, alltså om den har värdet True, skrivs Ja ut och annars, alltså om den har värdet False, skrivs Nej ut. Då är det enda sättet för programmet att skriva ut Ja om variabeln b aldrig ändras. Det sker bara om det inte finns några tal i listan som är mindre än eller lika med noll. Programmet svarar alltså på följande fråga.