5. Villkor
Logga in
Ett fel uppstod, försök igen senare!
Kapitel 7
5.
Villkor
Sidans innehåll fokuserar på villkor i programmering, en viktig aspekt av matematik och programmering. Det förklarar hur villkor används för att jämföra två saker med varandra, som att avgöra om en variabel har ett specifikt värde eller om ett tal är tillräckligt litet. Det illustrerar också användningen av olika jämförelseoperatorer som "är lika med", "är mindre än" och "är större än". Sidan innehåller exempel på hur man använder if, else och elif-satser för att skapa olika utfall baserat på givna villkor. Det förklarar också komplexa koncept som att använda logiska operatorer som "och" och "eller" för att slå ihop eller ändra villkor.
Visa mindre Visa mer expand_more 
Inställningar & verktyg för lektion
| | 9 sidor teori |
| | 14 Uppgifter - Nivå 1 - 3 |
| | Varje lektion är menad motsvara 1-2 lektioner i klassrummet. |
Villkor
Sida av 9
Ofta behöver instruktioner delas upp i olika fall beroende på ett villkor:
Om figuren är en cirkel, använd areaformeln πr2, men om figuren är en triangel, använd 2bh.På den här sidan får du lära dig skriva kod som tolkar villkor och gör olika saker beroende på utfallet.
x = 20 if x > 20: print('Hej!')
elif x >= 0: print('Hejsan!')
else: print('Hallå!')Vad tror du kommer att hända när du kör programmet? Vad tror du kommandona if, elif och else gör? Vad händer om du byter elif mot if på rad 5? Kan du ändra på värdet i x så att programmet skriver ut Hallå!?
I den här lektionen går vi igenom följande begrepp:
- Villkor
- If-sats
- Else-sats
- Elif-sats
- Logiska operatorer
Teori
Jämförelseoperatorer
Jämförelseoperatorer används för att jämföra två saker med varandra. De används t.ex. för att avgöra om en variabel har ett specifikt värde, om ett tal är litet nog eller om en lista är tillräckligt lång. Resultatet av en jämförelse är av datatypen bool, alltså antingen
True eller False.Om jämförelsen är sann får man resultatet True och om den är falsk får man False.
| Jämförelseoperatorer | |
|---|---|
==
|
Utläses är lika medoch returnerar True om objekten är lika, t.ex. 3 == 6/2
|
!=
|
Utläses är inte lika medoch returnerar True om objekten inte är lika, t.ex. 3 != 4. Symbolen != kan jämföras med tecknet = inom matematiken.
|
>
|
Olikheten är större änreturnerar True om det första talet är större än det andra, t.ex. 4 > 3.
|
<
|
Olikheten är mindre änreturnerar True om det första talet är mindre än det andra, t.ex. 5 < 10.
|
>= och <=
|
Som > respektive <, men returnerar True även om talen är lika. >= och <= kan jämföras med tecknen ≥ respektive ≤ i matematiken.
|
Det går även att skriva dubbla olikheter för att undersöka om ett värde ligger inom ett intervall, t.ex.
0 < 5 <= 28== fungerar även för andra datatyper.Exempel
Vad blir resultatet av jämförelsen?
Följande program gör ett antal jämförelser och skriver ut resultatet.
x = 5
print(x == 7)
print(x != 7)
print(-10 < x < 10)Svar
>
False
True
TrueLedtråd
Kom ihåg att jämförelseoperatorer alltid returnerar antingen True eller False.
Lösning
Vi går igenom rad för rad och undersöker vad som händer.
x = 5Först skapas en variabel x där värdet 5 sparas. Notera att det är ett enkelt likhetstecken, så det är en tilldelning som görs, inte någon jämförelse.
print(x == 7)De dubbla likhetstecknen betyder att vi gör en jämförelse mellan x och 7, och om de är lika med varandra är jämförelsen sann. I det här fallet finns värdet 5 lagrat i x, så jämförelsen blir 5 == 7, vilket är falskt. Resultatet blir då värdet False, som också är vad som skrivs ut.
print(x != 7)Nu undersöker vi istället om x inte är lika med 7. Det är sant att 5 och 7 är olika tal, så True kommer att skrivas ut.
print(-10 < x < 10)Den sista jämförelsen undersöker om värdet i x ligger mellan −10 och 10. Det gör det, så i det här fallet jämförelsen är sann, vilket ger resultatet True. Om vi kör programmet ser vi att detta stämmer.
x = 5
print(x == 7)
print(x != 7)
print(-10 < x < 10)>
False
True
TrueTeori
if-sats
if-satser används för kodstycken som endast ska köras om ett visst villkor är uppfyllt. För att skriva en sådan sats börjar man med ordet if, alltså om
, följt av ett villkor och sedan ett kolon. För att markera den kod som bara ska köras om villkoret är uppfyllt använder man indrag.
x = 5
if x == 5: print('Talet är fem!')- Visa resultat
>
Talet är fem!Talet är fem! om villkoret x == 5 faktiskt är sant, alltså om x har tilldelats värdet 5 på rad 1. Om villkoret är falskt hoppar programmet över de indragna raderna och fortsätter under dem.Teori
else-sats
Man vill ofta att programmet gör olika saker beroende på om ett villkor är sant eller falskt. Då använder man en else-sats nedanför if-satsen genom att skriva ordet else, alltså annars
, följt av ett kolon. All efterföljande indragen kod kommer då bara att köras om villkoret i if-satsen är falskt.
x = 6
if x == 5: print('Talet är fem!')
else: print('Talet är inte fem!')- Visa resultat
>
Talet är inte fem!if-sats följd av en else-sats skapar en struktur på formen Om villkoret är sant, gör si. Annars, gör så.
Teori
elif-sats
Det händer ofta att man vill göra mer komplicerade förgreningar i sitt program. Då är det bekvämt att använda elif-satser, som används efter en if-sats eller en annan elif-sats.
x = 10
if x == 5: print('Talet är fem!')
elif x == 10: print('Talet är tio!')
else: print('Talet är varken fem eller tio!')- Visa resultat
>
Talet är tio!elif som en kombination av else och if, där villkoret bara undersöks om de ovanstående villkoren är falska.Exempel
Tolka villkoren
Vad kommer att hända om man kör följande program?
x = 10
if x > 0: if x > 100: print('Ett stort tal!') else: print('Ett ganska stort tal!')
else: if x < -100: print('Ett litet tal!') else: print('Ett ganska litet tal!')x = -123?
Svar
Utskrift när x = 10:
>
Ett ganska stort tal!
Utskrift när x = -123:
>
Ett litet tal!Ledtråd
Hur fungerar villkor?
Lösning
Vi stegar oss igenom programmet och undersöker vilken väg som tas vid villkoren, först för x = 10 och sedan för x = -123.
x = 10
På rad 2 börjar vi med att undersöka villkoret x > 0, alltså om 10 är större än 0, vilket det är. Det betyder att vi går in i if-satsen och kommer direkt till ett nytt villkor: x > 100. Det är inte sant, så vi hoppar över den indragna raden och går till else-satsen på rad 5. Där får vi följande utskrift.
>
Ett ganska stort tal!Eftersom if-satsen på rad 2 var sann kommer vi inte att gå in i else-satsen på rad 7 och hoppar därför över alla rader som kommer efter.
x = -123
Om det istället står x = -123 på första raden kommer villkoret på rad 2 vara falskt eftersom −123 är mindre än 0. Då hoppar vi över raderna 3 - 6 och går istället in i else-satsen på rad 7. Där stöter vi på villkoret x < -100. Det är sant, så vi går in i den satsen och och får följande utskrift.
>
Ett litet tal!Den efterföljande else-satsen kommer inte att köras eftersom if-satsen på rad 8 var sann.
Teori
Logiska operatorer
Logiska operatorer används för att slå ihop eller ändra villkor. Ett vanligt fall är att man har två villkor som ska gälla samtidigt, t.ex. att två variabler ska vara positiva. Då används operatorn and, dvs. och
, mellan villkoren.
x = 7
y = 18
if x>0 and y>0: print('Punkten ligger i första kvadranten!')- Visa resultat
>
Punkten ligger i första kvadranten!Ibland har man två villkor där minst ett ska gälla. Då används operatorn or, dvs. eller
, mellan de två villkoren.
x = 5
y = -2
if x<0 or y<0: print('Punkten ligger INTE i första kvadranten!')- Visa resultat
>
Punkten ligger INTE i första kvadranten!Man kan också vända ett villkor till dess motsats med operatorn not, dvs. inte
. Om ett tal inte är större än noll så måste det vara noll eller mindre. Exemplet nedan blir därför samma sak som att använda villkoret x <= 0.
x = -3
if not x>0: print('Talet är INTE större än noll!')- Visa resultat
>
Talet är INTE större än noll!Exempel
Använd logiska operatorer
Programmet nedan utför beräkningen x2+9 om talet x är 3 eller 4.
x = 4
if x == 3: print(x**2 + 9)
elif x == 4: print(x**2 + 9)- Visa resultat
>
25Svar
x = 4
if x==3 or x==4: print(x**2 + 9)Ledtråd
Använd den logiska operatorn or.
Lösning
Eftersom beräkningen endast utförs om x är 3 eller 4 behöver bara ett av villkoren x == 3 och x == 4 vara sant. Det är ett perfekt tillfälle att använda or-operatorn.
x = 4
if x==3 or x==4: print(x**2 + 9)- Visa resultat
>
25Istället för att skriva beräkningen på två ställen i koden har vi alltså angett två olika sätt att hitta till
beräkningen. Det är en bra princip att försöka undvika upprepad kod. På det sättet blir programmet mer överskådligt, och om beräkningen ska ändras behöver man bara göra det på ett ställe.
Villkor
Uppgift 3.1
Fredrik skriver ett program som tar reda på om en punkt (x,y) ligger i något av de blå områdena.
Han har skrivit koden nedan. Den undersöker de blå områdena separat och ser om den aktuella punkten ligger där.
x = 12
y = -8
if x > 0:
if y < 0:
if y > -x:
print('Punkten ligger i det blå området.')
if x < 0:
if y > 0:
if y > -x:
print('Punkten ligger i det blå området.')Fredrik tror att han kan korta ned koden. Visa hur han kan använda logiska operatorer för att sortera fram relevanta punkter med en enda if-rad.
security
report
code
security
report
code
Bara om en if-sats är sann går programmet in på raden nedanför och tolkar den inskjutna koden. Därför kommer programmet bara till print-kommandot om alla tre nedanstående villkor gäller. De beskriver fjärde kvadranten, ovanför y = -x.
if x > 0: if y < 0: if y > -x:
Istället för upprepade if-satser kan vi rada upp villkoren med and-operatorn.
if x>0 and y<0 and y>-x:
Samma sak kan göras med den andra gruppen if-satser.
if x>0 and y<0 and y>-x: # Villkoren beskriver fjärde kvadranten, ovanför y = -x if x<0 and y>0 and y>-x: # Villkoren beskriver andra kvadranten, ovanför y = -x
Nu vill vi ha en kod som avgör om punkten ligger i andra eller fjärde kvadranten. Precis den sortens hopslagning görs av or-operatorn.
if (x>0 and y<0 and y>-x) or (x<0 and y>0 and y>-x): print('Punkten ligger i det blå området.')
Notera att parenteserna är nödvändiga för att gruppera villkoren. if-satsen blir nu sann antingen om de vänstra tre villkoren är sanna samtidigt, eller om de högra tre är sanna samtidigt.
Lösningen ovan fungerar, men har en svårläst villkorsrad. Ett sätt att förenkla den är att utgå från vad de två blå områdena har gemensamt: Båda ligger ovanför linjen y = - x, vilket man också ser genom att båda villkorsgrupper använder y > -x. Då kan vi börja if-satsen med det, vilket grafiskt ser ut som det gröna området nedan.
Vi ser nu att vi inte kan låta y > -x vara det enda villkoret, eftersom det tillåter även punkter i första kvadranten. Därför måste vi bygga ut villkoret lite så att dessa punkter sållas bort. Vi vill alltså få if-satsen att uttrycka följande.
Om punkten ligger ovanför y=-x och inte i första kvadranten:
I första kvadranten är både x och y positivt, dvs. x>0 and y>0. Att punkten inte ligger där kan uttryckas med ett not framför. Den fullständiga if-satsen kan då se ut så här.
if y>-x and not(x>0 and y>0): print('Punkten ligger i det blå området.')
Man kan också använda or-operatorn för att korta ned det ännu mer.
if y>-x and (x<0 or y<0): print('Punkten ligger i det blå området.')
Det finns alltid många olika sätt att lösa ett programmeringsproblem på.
security
report
code
Charlie har skrivit ett program som avgör om en given punkt ligger på en ram eller inte. Ramen definieras av ett antal variabler som anger de största och minsta x- och y-värdena för ramens inner- och yttermått i ett koordinatsystem.
x = 0 y = 0 x_inre_min = 0 x_inre_max = 20 y_inre_min = -5 y_inre_max = 10 x_yttre_min = -5 x_yttre_max = 25 y_yttre_min = -10 y_yttre_max = 15 if (x >= x_yttre_min and x <= x_inre_min) and (y >= y_yttre_min and y <= y_inre_min): print("På ramen!") elif (x >= x_yttre_min and x <= x_inre_min) and (y >= y_inre_max and y <= y_yttre_max): print("På ramen!") elif (x >= x_inre_max and x <= x_yttre_max) and (y >= y_yttre_min and y <= y_inre_min): print("På ramen!") elif (x >= x_inre_max and x <= x_yttre_max) and (y >= y_inre_max and y <= y_yttre_max): print("På ramen!") elif (x >= x_inre_min and x <= x_inre_max) and (y >= y_yttre_min and y <= y_inre_min): print("På ramen!") elif (x >= x_inre_min and x <= x_inre_max) and (y >= y_inre_max and y <= y_yttre_max): print("På ramen!") elif (x >= x_yttre_min and x <= x_inre_min) and (y >= y_inre_min and y <= y_inre_max): print("På ramen!") elif (x >= x_inre_max and x <= x_yttre_max) and (y >= y_inre_min and y <= y_inre_max): print("På ramen!") else: print("Inte på ramen!")helphelphelphelphelphelphelphelp
Charlies program fungerar men han tycker att det är rätt långt och krångligt, och han misstänker att det går att göra samma sak på ett mer effektivt sätt. Hjälp honom att förbättra programmet genom att skriva om if-satserna.
security
report
code
security
report
code
Charlies program ser onekligen ganska krångligt ut, så det är bäst att börja med att gå igenom det och se vad det faktiskt gör innan vi skriver om det. På de första raderna definieras punkten som ska undersökas och alla gränserna för ramen. Sedan kommer en ganska hemsk samling if-satser. Vi tittar på den första och tolkar villkoret som undersöks i den.
if (x >= x_yttre_min and x <= x_inre_min) and (y >= y_yttre_min and y <= y_inre_min):
Här kontrollerar vi först om x är större än eller lika med x_yttre_min och mindre än eller lika med x_inre_min, alltså om
x_yttre_min ≤ x ≤ x_inre_min.Sedan undersöks om y är större än eller lika med y_yttre_min och mindre än eller lika med y_inre_min, alltså om
y_yttre_min ≤ y ≤ y_inre_min.Villkoret undersöker om punkten ligger mellan de minsta värdena för yttre delen av ramen och de minsta värdena för den inre delen av ramen, alltså den kvadrat som finns i nedre vänstra hörnet.
Fortsätter man att undersöka villkoren kommer man fram till att programmet delar upp ramen i 8 olika kvadrater och undersöker dem i tur och ordning.
En snabb förenkling man skulle kunna göra här är att slå ihop några av rektanglarna så att det blir 4 istället för 8.
Det går dock att effektivisera saker ytterligare genom att tänka om lite. Om man först undersöker om punkten ligger på eller innanför yttermåtten och sedan om den ligger på eller utanför innermåtten räcker det med två jämförelser för att avgöra om den ligger på ramen eller inte. Vi börjar med den första jämförelsen, som kan skrivas
(x_yttre_min <= x <= x_yttre_max) and (y_yttre_min <= y <= y_yttre_max).Här har vi gjort saker liter mer kompakta genom att använda dubbla olikheter som undersöker om x och y ligger inom intervall. Vi sparar resultatet från den här jämförelsen i en variabel som vi kallar innanfor_eller_pa_yttre. Värdet som sparas är av datatypen bool och är antingen True eller False, alltså sant eller falskt.
x = 0 y = 0
x_inre_min = 0 x_inre_max = 20 y_inre_min = -5 y_inre_max = 10 x_yttre_min = -5 x_yttre_max = 25 y_yttre_min = -10 y_yttre_max = 15
innanfor_eller_pa_yttre = (x_yttre_min <= x <= x_yttre_max) and (y_yttre_min <= y <= y_yttre_max)
När det gäller att undersöka om punkten ligger utanför eller på innermåtten är det faktiskt enklare att undersöka det motsatta, alltså om punkten ligger innanför innermåtten, och sedan vända på jämförelsen med kommandot not. Då kan vi först skapa en variabel innanfor_inre där vi undersöker om punkten ligger innanför innermåtten och sparar resultatet.
x = 0 y = 0
x_inre_min = 0 x_inre_max = 20 y_inre_min = -5 y_inre_max = 10 x_yttre_min = -5 x_yttre_max = 25 y_yttre_min = -10 y_yttre_max = 15
innanfor_eller_pa_yttre = (x_yttre_min <= x <= x_yttre_max) and (y_yttre_min <= y <= y_yttre_max) innanfor_inre = (x_inre_min < x < x_inre_max) and (y_inre_min < y < y_inre_max)
Om punkten ligger innanför eller på yttermåtten men inte innanför innermåtten måste den ligga på ramen, alltså när följande jämförelse är sann.
innanfor_eller_pa_yttre and not innanfor_indreVi sparar resultatet av detta i en variabel pa_ramen som innehåller svaret på om punkten ligger på ramen eller inte.
x = 0 y = 0
x_inre_min = 0 x_inre_max = 20 y_inre_min = -5 y_inre_max = 10 x_yttre_min = -5 x_yttre_max = 25 y_yttre_min = -10 y_yttre_max = 15
innanfor_eller_pa_yttre = (x_yttre_min <= x <= x_yttre_max) and (y_yttre_min <= y <= y_yttre_max) innanfor_inre = (x_inre_min < x < x_inre_max) and (y_inre_min < y < y_inre_max) pa_ramen = innanfor_eller_pa_yttre and not innanfor_inre
Nu kan vi använda resultatet i en if-sats som skriver ut att punkten är på ramen om pa_ramen är sant och att den inte är det om pa_ramen är falskt.
x = 0 y = 0
x_inre_min = 0 x_inre_max = 20 y_inre_min = -5 y_inre_max = 10 x_yttre_min = -5 x_yttre_max = 25 y_yttre_min = -10 y_yttre_max = 15
innanfor_eller_pa_yttre = (x_yttre_min <= x <= x_yttre_max) and (y_yttre_min <= y <= y_yttre_max) innanfor_inre = (x_inre_min < x < x_inre_max) and (y_inre_min < y < y_inre_max) pa_ramen = innanfor_eller_pa_yttre and not innanfor_inre
if pa_ramen: print("På ramen!") else: print("Inte på ramen!")
> På ramen!
Vårt program är nu färdigt och inte nog med att vi har kortat ner det ordentligt, det är förhoppningsvis också tydligare vad de olika raderna gör.
security
report
code
Villkor
Rekommenderade uppgifter
Logga in för att få personliga rekommenderade uppgifter.
Laddar innehåll
Laddar innehåll