Villkor: Jämförelseoperatorer i programmering

Jämförelseoperatorer
`==`	Utläses är lika med och returnerar `True` om objekten är lika, t.ex. `3 == 6/2`
`!=`	Utläses är inte lika med och returnerar `True` om objekten inte är lika, t.ex. `3 != 4`. Symbolen `!=` kan jämföras med tecknet $\neq =$ inom matematiken.
`>`	Olikheten är större än returnerar `True` om det första talet är större än det andra, t.ex. `4 > 3`.
`<`	Olikheten är mindre än returnerar `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 $\geq$ respektive $\leq$ i matematiken.

Skriv följande villkor som kod.

$x$ är inte $- 13 .$

$n$ är mindre än eller lika med $10 .$

$y$ är antingen $- 1$ eller $2 .$

$a$ är större än $3$ och $b$ är $4 .$

Det finns en jämförelseoperator speciellt för att avgöra om två saker inte är lika med varandra: !=. Använder vi den får vi villkoret x != -13. Om man vill går det också att skriva med den logiska operatorn not, men då blir uttrycket lite längre: not x == -13.

Det finns en jämförelseoperator även för "mindre än eller lika med", <=, och använder vi den kan vi skriva villkoret som n <= 10.

Här ska vi undersöka om y är lika med -1, vilket kan skrivas y == -1, eller lika med 2, vilket kan skrivas y == 2. Det räcker att ett av dessa villkor är uppfyllt, vilket man kan skriva med den logiska operatorn or. Man sätter den mellan de två villkoren: y == -1 or y == 2.

Här är det två villkor som måste vara uppfyllda: a måste vara större än 3, a > 3, och b ska vara lika med 4, x == 4. För att se till att båda är uppfyllda sätter man den logiska operatorn and mellan dem: a > 3 and b == 4.

För vilka värden på x är följande villkor sanna?

6 < x <= 10

not x != 19

x != 3 or x != -3

Villkoret är en hopslagning av två villkor med två jämförelseoperatorer som båda måste vara sanna. Den första delen, 6 < x, betyder att 6 ska vara mindre än x, vilket är samma sak som att x är större än 6. Den andra delen, x <= 10, betyder att x är mindre eller lika med 10. Villkoret är alltså att x är större än 6 och mindre än eller lika med 10.

Vi börjar med att titta på x != 19, vilket betyder att x inte får vara 19. Vi har dock den logiska operatorn not framför detta, vilket vänder på villkoret. Man skulle kunna läsa det som "när inte x inte är lika med 19", vilket är lite förvirrande, men betyder samma sak som "när x är lika med 19". Villkoret är alltså sant när x = 19.

Här har vi två villkor som skiljs åt med operatorn or. Då räcker det med att något av delvillkoren är sant, alltså när x != 3 eller x != -3. Vi kan tolka dem som "x är inte lika med 3" respektive "x är inte lika med -3". Det första är bara falskt när x = 3 och den andra bara när x = -3, vilket aldrig kan hända samtidigt. Något av dem måste alltså alltid vara sant, så hela uttrycket är sant för alla x.

Skriv ett program som beräknar absolutbeloppet av ett tal x utan att använda den inbyggda funktionen abs().

När man bestämmer absolutbeloppet av ett tal börjar man med att undersöka huruvida det är positivt eller negativt. Om talet är positivt förändras det inte och om det är negativt byter man tecken på det så att det blir positivt.

Vi börjar med att skapa en variabel x för vårt tal och sätter det t.ex. till -4.

x = -4

Vi undersöker sedan med hjälp av en if-sats om vårt tal är större än eller lika med 0. Om det är det behöver vi inte göra något med talet, så vi skriver bara ut det.

x = -4 if x >= 0: print(x)

Om talet inte är större än eller lika med 0 måste det vara mindre än 0, så vi kan skriva en else-sats som skriver ut talet med omvänt tecken.

x = -4 if x >= 0: print(x) else: print(-x)

> 4

Nu har vi ett färdigt program som beräknar absolutbeloppet av x. För att vara säkra på att det fungerar kan även testa för ett positivt tal genom att ändra första raden till t.ex. x = 7. Då får vi resultatet 7, vilket är vad vi väntar oss.

Skriv ett program som givet en variabel

x

beräknar funktionsvärdet för

f (x) = \frac{1}{x} + \frac{1}{x - 2} .

Se till att ditt program ger ett lämpligt svar för alla

x

-värden.

Vi börjar med att ta en titt på funktionen som vi ska beräkna. f(x) = 1/x + 1/x - 2 Den är inte definierad för x = 0 eller x = 2 eftersom nämnaren i första respektive andra bråket då blir 0. Det är något vi måste tänka på när vi skriver programmet. Vi börjar dock med att skapa variabeln x. Vi kan sätta den till vad vi vill, så vi kan t.ex. välja x = 5.

x = 5

Nu måste vi först kontrollera om x är lika med 0 eller 2 och i så fall skriva ut ett meddelande som säger att funktionen inte är definierad för de värdena. Vi skulle kunna göra det som två if-satser med kontrollerna x == 0 och x == 2, men det är enklare att använda den logiska operatorn or och testa båda på en gång.

x = 5 if x == 0 or x == 2: print('Funktionen är inte definierad för x =', x)

Om x varken är 0 eller 2 måste den ha ett värde som faktiskt går att räkna ut. Sätter vi uträkningen av funktionsvärden inne i en else-sats finns det alltså ingen risk att det blir fel.

x = 5 if x == 0 or x == 2: print('Funktionen är inte definierad för x =', x) else: print(1/x + 1/(x - 2))

Kör vi den här koden får vi följande resultat.

> 0.5333333333333333

För att vara på säkra sidan testar vi också att ändra x till 2 och bekräftar att vi får rätt utskrift från programmet.

x = 2 if x == 0 or x == 2: print('Funktionen är inte definierad för x =', x) else: print(1/x + 1/(x - 2))

> Funktionen är inte definierad för x = 2

Gör ett program som tar en triangels sidlängder och använder dem för att skriva ut om triangeln är rätvinklig eller inte. T.ex. motsvarar sidlängderna $3,$ $4$ och $5$ en rätvinklig triangel. Programmet behöver inte själv avgöra vilken sida som är längst.

Pythagoras sats säger att endast rätvinkliga trianglar uppfyller att a^2 + b^2 = c^2, där c är triangelns längsta sida och a,b är kateterna. Den här likheten utgör ett villkor vi kan använda: Om triangelns sidlängder uppfyller att a^2 + b^2 är lika mycket som c^2, då är triangeln rätvinklig. Vi använder exemplet med sidlängderna 3-4-5, som vi vet motsvarar en rätvinklig triangel.

a = 3 b = 4 c = 5

För att skriva "upphöjt till" används räkneoperatorn **, och för att undersöka likheten används jämförelseoperatorn ==. Med en if-sats låter vi koden skriva ut olika saker beroende på om likheten gäller eller inte.

a = 3 b = 4 c = 5

if a**2 + b**2 == c**2: print('Triangeln är rätvinklig!') else: print('Triangeln är inte rätvinklig!')

> Triangeln är rätvinklig!

Utan att köra koden, avgör vad programmen kommer att skriva ut och förklara varför.

x = 7
if x == 9:
	print('Ja!')
else:
	print('Nej!')

x = 7
jamforelse = (x < 9)
if jamforelse:
	print('Ja!')
else:
	print('Nej!')

x = 7
variabel = False
if variabel:
	print('Ja!')
else:
	print('Nej!')

Vi går igenom koden och undersöker vad som händer, steg för steg.

x = 7

Först sparas värdet 7 i variabeln x.

if x == 9: print('Ja!')

Vi gör sedan en jämförelse där vi undersöker om värdet som finns lagrat i x är lika med 9. Vi gör alltså jämförelsen 7 == 9, vilket inte är sant. Det betyder att vi inte kommer att göra det som står inne i if-satsen utan går vidare till else-satsen.

else: print('Nej!')

Programmet går då in i else-satsen och skriver ut Nej!.

På samma sätt som i första programmet skapas först variabeln x och tilldelas värdet 7.

x = 7

Sedan skapas det en ny variabel, jamforelse.

jamforelse = (x < 9)

Här kommer jämförelsen till höger om likhetstecknet att undersökas och resultatet sparas i jamforelse. Resultatet kommer att vara av datatypen bool och antingen ha värdet True eller False, alltså sant respektive falskt. Det sant att 7 är mindre än 9, så det som sparas i jamforelse är True. Detta används sedan i if-satsen som kommer efter.

if jamforelse: print('Ja!')

Här har vi en if-sats som kan se lite obekant ut. Det verkar ju som att den inte har något villkor, men det har den faktiskt. Den tittar på vad som finns lagrat i jamforelse, vilket är resultatet från jämförelsen vi just gjorde. Det hade alltså kunnat stå if x < 9: och vi hade fått samma resultat. Eftersom jamforelse är True går vi in i if-satsen och skriver ut Ja!.

else: print('Nej!')

Eftersom if-satsen var sann går vi inte in else-satsen. Resultatet när man kör programmet är alltså att det skriver ut Ja!.

Vi går igenom programmet på samma sätt som tidigare, och på samma sätt börjar programmet med att skapa variabeln x och sätta den till värdet 7.

x = 7

Sedan skapas ytterligare en variabel med det något intetsägande namnet variabel som sätts till värdet False.

variabel = False

Notera att detta värde har datatypen bool, vilket är samma sak som vi skulle kunna ha fått från en jämförelse. Det går dock bra att skriva in det direkt som vi har gjort i det här fallet. Variabeln används sedan i en if-sats.

if variabel: print('Ja!')

Vi undersöker om värdet i variabel är sant eller falskt. Värdet som är lagrat där är False, så det är falskt. Då hoppar går vi inte in i if-satsen utan går vidare till else-satsen.

else: print('Nej!')

if-satsen var falsk, så vi går in i else-satsen och skriver ut Nej!.

Skriv ett program som avgör och skriver ut om ett tal är delbart med $7 .$ Testa det på talen $60463$ och $55307 .$

Ett sätt att avgöra om ett tal är delbart med 7 är att undersöka resten när man gör en heltalsdivision med 7. Om den är 0 måste talet vara delbart med 7. Vi börjar med att skapa vårt tal, som vi kan kalla x, och sätter det till 60 463. Vi använder sedan operatorn % för att beräkna resten när vi gör en heltalsdivision med 7.

x = 60463 rest = x % 7

Nu gör vi en if-sats som kontrollerar om resten är lika med 0, och om den är det skrivs ett meddelande ut.

x = 60463 rest = x % 7 if rest == 0: print(x, 'är delbart med 7')

Om vi nu skriver en else-sats kommer den att köras när resten inte är lika med 0, alltså när talet inte är delbart med 7.

x = 60463 rest = x % 7 if rest == 0: print(x, 'är delbart med 7') else: print(x, 'är inte delbart med 7')

> 60463 är inte delbart med 7

Kör vi programmet får reda på att 60 463 inte är delbart med 7. Byter vi ut första raden mot x = 55307 får vi istället resultatet 55307 är delbart med 7.

Flyttal är inte exakta. Det stämmer förstås att $0.1 + 0.2$ är exakt $0.3,$ men i exemplet nedan verkar beräkningen ge något annat i Python.

summa = 0.1 + 0.2
if summa == 0.3:
	print('Lika!')
else:
	print('Inte lika!')

Visa resultat

>
Inte lika!

Pythons summa blir alltså inte exakt 0.3, men med en print-rad kan man se att den är väldigt nära. Ändra villkoret så att talen ändå behandlas som lika.

Eftersom vi inte kan jämföra talen exakt får vi nöja oss med det näst bästa: att se om summan är "tillräckligt nära" 0.3. Det finns flera sätt att göra detta på. Man kan formulera ett intervall som summan får ligga inom t.ex. så här.

summa = 0.1 + 0.2 if 0.3-0.0000001 < summa < 0.3+0.0000001: print('Lika!') else: print('Inte lika!')

Det går också att undersöka differensen summa - 0.3 direkt. Differensen kan vara antingen positiv eller negativ, och för att förenkla jämförelsen kan vi använda absolutbeloppet abs(summa - 0.3). Då görs resultatet positivt, om det inte redan är det, och vi kan undersöka om avståndet är tillräckligt litet.

summa = 0.1 + 0.2 if abs(summa - 0.3) < 0.0000001: print('Lika!') else: print('Inte lika!')

Ett tredje sätt är att avrunda talen till ett visst antal decimaler och se om det blir samma.

summa = 0.1 + 0.2 if round(summa, 7) == round(0.3, 7): print('Lika!') else: print('Inte lika!')

Villkor

Förkunskaper

Jämförelseoperatorer

Vad blir resultatet av jämförelsen?

Svar

Ledtråd

Lösning

`if`-sats

`else`-sats

`elif`-sats

Tolka villkoren

Svar

Ledtråd

Lösning

`x = 10`

`x = -123`

Logiska operatorer

Använd logiska operatorer

Svar

Ledtråd

Lösning

Villkor

Rekommenderade uppgifter

	9 sidor teori
	14 Uppgifter - Nivå 1 - 3
	Varje lektion är menad motsvara 1-2 lektioner i klassrummet.