2. Moment02 - Grunderna

I detta moment kommer vi börja arbeta med grunderna i Python. Du får lära dig att skriva ut text på skärmen, kommentera din kod, använda speciella tecken i utskrifter (så kallade escapetecken), skapa variabler och arbeta med olika datatyper. Vi avslutar med att titta på olika sätt att skriva ut text tillsammans med variabler. Målet är att du ska förstå hur man bygger upp de enklaste programmen och hur datorn tolkar din kod.

2.1 Introduktion

I detta avsnitt bekantar vi oss med våra allra första Python-program. Vi börjar med att skriva ut text på skärmen och lär oss sedan använda några specialtecken för att formatera utskriften.

2.1.1 Första programmet

Ett datorprogram består av instruktioner som datorn följer steg för steg. Vi börjar med det enklaste programmet: att skriva ut en text på skärmen.

print("Hello World")

Hello World

• print() är en funktion som används för att skriva ut information. Allt inom parentesen skrivs ut på skärmen.
• Text i Python kallas för en sträng och markeras med citattecken ("..." eller '...').
  Så print('Hello World') kommer ge samma utskrift.

2.1.2 Escapetecken

Ibland vill vi skriva ut specialtecken eller formatera texten på ett speciellt sätt. Då använder vi escapetecken. Några vanliga är:

• \n = radbrytning
• \t = tab (indrag)
• \\ = ett omvänt snedstreck (backslash)
• \" = citattecken

print("Hej\nVärlden")       # Skriver ut på två rader
print("En\tTvå\tTre")       # Tabbar mellan orden
print("C:\\Users\\Anna")    # Skriv ut sökvägar
print("Hon sa: \"Hej!\"")   # Skriver ut text med citattecken

Hej
Världen
En   Två   Tre
C:\Users\Anna
Hon sa: "Hej!"

2.2 Kommentarer

När du programmerar är det bra att skriva kommentarer som förklarar vad koden gör. Kommentarerna körs inte av datorn, de är bara till för oss människor.

# Detta är en kommentar
print("Hej")  # Denna rad skriver ut texten Hej

"""
Detta är en flerradig kommentar.
Den kan användas för längre förklaringar.
"""

• # gör resten av raden till en kommentar.
• """ ... """ kan användas för att skriva längre förklaringar på flera rader.

Hur mycket kommentarer behöver du skriva i din kod? Grundtanken är att kommentarer skall hjälpa dig och andra att förstå koden. Att skriva en kommentar för varje rad som utför något enkelt kommando gör att koden snabbt blir överkommenterad. Jag brukar ha två saker som riktmärke för kommentarer:

• Kommentera de delar som är nya och som du tränar på i just detta momentet.
• Om du av någon anledning inte kodade en rad på tre månader och fick se en gammal kod du har skrivit, då skall den vara så välkommenterad så att du själv direkt förstår, och kommer ihåg, vad koden gör och hur du skall rätta den ifall det behöver göras.

Allt eftersom du blir duktigare på att koda så kommer det bli naturligt för dig hur mycket du skall kommentera. Håller du dig till de två riktlinjerna ovan så kommer du och de som ser din kod få den hjälp som ni behöver.

Uppblandat med övningar kommer ibland lite större uppgifter där du får möjlighet att visa att du behärskar de delar som du precis har arbetat med.
Denna första övningen behandlar utskrifter, kommentarer och escapetecken.

Jag heter <mitt namn> och jag läser programmering på Alströmergymnasiet.
Jag tycker att det verkar "kul" med programmering.

Dessa tre rader
har jag skrivit med
en enda print().

Följande saker har jag kommenterat i min kod:
  * Hur jag skrev ut dubbelfnuttarna på andra raden
  * Hur jag kunde skriva ut tre rader med en print().
  * Hur jag använde mig av tab, för att göra denna listan.

2.3 Variabler

En variabel fungerar som en låda där vi sparar information. Varje gång vi vill använda informationen kan vi hämta den från variabeln.

namn = "Anna"       # en sträng
ålder = 16          # ett heltal (int)
längd = 1.72        # ett decimaltal (float)

2.3.1 Namngivningskonventioner

För att skriva kod som är lätt att förstå och underhålla behöver vi följa vissa regler och riktlinjer när vi väljer namn på våra variabler.

• Variabelnamn får inte börja med en siffra eller innehålla mellanslag.
• Tillåtna tecken är bokstäver (a–ö, A–Ö), siffror (0–9) och underscore _.
• Bra namn beskriver vad variabeln innehåller: omkrets är bättre än o, ålder är bättre än a.
• I Python är det rekommenderade sättet att använda snake_case: mitt_variabelnamn.
• Andra varianter du kan se: camelCase och PascalCase. Även kebab-case används inom vissa programmeringsspråk men det är ej godkänt i Python. Oavsett vilken modell som används så är det viktigaste att vara konsekvent.
• Välj också konsekvent språk: blanda inte engelska och svenska i samma program.
• I Python kan du använda svenska tecken som å, ä och ö i variabelnamn. Det fungerar, men i många andra programmeringsspråk är det inte tillåtet. Därför är det ofta enklare och mer framtidssäkert att hålla sig till engelska variabelnamn. I praktiken blir det oftast enklast att använda engelska namn – då matchar variabelnamn bättre mot dokumentation, bibliotek och exempel ni hittar online. Det blir också lättare att få hjälp av fler om du kodar på ett sätt som fler förstår.

Använd inte namn som redan finns i Python (t.ex. list, str, sum, input, print) – det kallas att skugga inbyggda namn och leder lätt till svårtolkade fel. Välj hellre egna, beskrivande namn. Om ett värde inte ska ändras i programmet kan du markera det som konstant genom att skriva med versaler, t.ex. MAX_SPEED = 120.

2.4 Datatyper

Python använder olika datatyper beroende på vilken sorts information som lagras. En styrka i Python är att datatyperna är dynamiska: du behöver inte tala om i förväg vilken typ det ska vara, Python håller reda på det åt dig.
Fördelar: enkelt att skriva kod snabbt.
Nackdelar: lättare att göra misstag, t.ex. försöka räkna ihop text och tal.

2.4.1 Vanliga datatyper i Python

Det finns många olika inbyggda datatyper i Python, men vi börjar med de allra vanligaste och lägger till fler senare i kursen.

Varför spelar datatyper roll?

• Operatorn + adderar tal, men konkatenerar text: 2 + 2 blir 4, medan "2" + "2" blir "22".
• Operatorn * multiplicerar tal och text: 3 * 2 blir 6, medan 3 * "2" blir "222".
• Blandar du text och tal utan konvertering får du fel, t.ex. print("Ålder: " + 16) → TypeError.

# Vanlig fallgrop: blanda text och tal
age = 16          # int
print("Ålder: " + str(age))   # OK
print("Ålder: " + age)        # TypeError: can only concatenate str (not "int") to str

2.4.2 type() – kolla datatypen

Ibland är det viktigt att veta vilken datatyp en viss variabel innehåller. Med funktionen type() kan vi kontrollera datatypen. Detta kan till exempel vara användbart när du försöker räkna ihop tal och text av misstag – Python behöver veta om du menar siffror eller strängar.

namn = "Anna"
print(type(namn))   # 

ålder = 16
print(type(ålder))  # 

pi = 3.14
print(type(pi))     # 

pi = "3.14"
print(type(pi))     # 

2.5 Aritmetik

Python kan användas som en miniräknare. Med variabler och datatyper blir det möjligt att räkna på olika sätt.

2.5.1 Vanliga operatorer

• + addition
• - subtraktion
• * multiplikation
• / division (ger alltid ett decimaltal)
• // heltalsdivision (avrundar nedåt)
• % modulo (resten vid division)
• ** upphöjt till

Ett viktigt begrepp när vi räknar i Python är prioritet mellan operatorer. Python följer samma regler som i matematiken: multiplikation och division görs före addition och subtraktion. Vill du vara säker på ordningen kan du alltid använda parenteser.

print(2 + 3 * 4)     # 14, eftersom multiplikationen görs först
print((2 + 3) * 4)   # 20, parenteserna styr ordningen

x = 12
y = 5

print(x + y)   # 17
print(x - y)   # 7
print(x * y)   # 60
print(x / y)   # 2.4
print(x // y)  # 2
print(x % y)   # 2
print(x ** y)  # 248832

Vi kan också kombinera operatorer med tilldelning:

a = 10
a += 2   # a = a + 2
print(a) # 12

Andra varianter: -=, *=, /=, //=, %=, **= fungerar på samma sätt.

2.6 Utskrifter – olika sätt

Nu när vi har variabler kan vi kombinera dem med text på flera olika sätt. Du kommer stöta på flera varianter i guider på nätet, men vi fokuserar mest på f-strings eftersom de är enklast och mest flexibla.

namn = "Anna"
ålder = 16

# kommaseparerat – varje del separeras automatiskt med mellanslag
print(namn, "är", ålder, "år gammal.")

# konkatenering – sätter ihop textsträngar, allt måste vara strängar
print(namn + " är " + str(ålder) + " år gammal.")

# "öppen print" utan radbrytning (end="")
print(namn, "är ", end="")
print(ålder, "år gammal.")

# format-metoden – äldre men fortfarande fungerande sätt
print("{} är {} år gammal.".format(namn, ålder))

# f-string – modernt och tydligt sätt (rekommenderad metod)
print(f"{namn} är {ålder} år gammal.")

# bygga strängen i en variabel innan utskrift
text = f"{namn} är {ålder} år gammal."
print(text)

Alla sätten ovan fungerar, men de är olika smidiga:

• , i print() är snabbt och enkelt men ger ofta extra mellanslag.
• + kan sätta ihop text, men fungerar bara om båda delarna är strängar.
• Öppen print är användbar när vi bara vill skriva en del av en sträng just nu och fylla på med mer text alldeles strax. Särskilt användbart när det gäller selektioner och loopar, vilket vi kikar på i senare moment.
• .format() används ibland i äldre exempel.
• f-strings är den metod vi kommer använda mest eftersom de är tydliga och kraftfulla.
• Bygga strängen i en variabel, väldigt användbart om vi i flera steg vill bygga på en variabel innan utskrift.

Varför f-string är att föredra i de flesta fall, med f-strings kan du:

• Blanda text och variabler på ett läsbart sätt.
• Styra formateringen, t.ex. antal decimaler.
• Skriva kortare och tydligare kod.

namn = "Anna"
ålder = 16

# Exempel på f-string med flera variabler och beräkning
print(f"{namn} är {ålder} år gammal och om 5 år är {ålder + 5}.")

Det blir direkt begripligt vad som kommer att skrivas ut.

print("A", "B", "C", sep=" | ")    # A | B | C
print("Hej", end="...")            # Hej...  (ingen radbrytning)

2.6.1 Ytterligare formatering

Med f-strings kan vi också formatera tal. Här styr vi antal decimaler och ibland även fältbredd.

• :.2f betyder: två decimaler (f = float, decimalformat).
• :7.2f betyder: totalt 7 tecken brett fält, med två decimaler. Bra om flera tal ska visas under varandra.
• :.0f betyder: inga decimaler (avrundas till heltal).

pi = 3.14159265359
print(f"Pi med två decimaler: {pi:.2f}")       # 3.14
print(f"Pi utan decimaler: {pi:.0f}")          # 3
print(f"Pi i ett fält med bredd 7: {pi:7.2f}") # '   3.14'

2.6.2 Utskrift med formatering – två kolumner

Ibland vill vi skriva ut data snyggt i två kolumner. Ett tips är att man kan tilldela flera variabler på samma rad genom att använda kommatecken som avskiljare:

vara1, pris1 = "Penna", 4
vara2, pris2 = "Suddgummi", 9.5

Med f-strings kan vi sedan styra bredd och justering:

• < vänsterjustera
• > högerjustera
• ^ centrera
• ett tal anger fältbredd (t.ex. :<12)

print(f"{'Vara':<15}{'Pris (kr)':>10}")
print(f"{'-'*15}{'-'*10}")
print(f"{vara1:<15}{pris1:>10.2f}")
print(f"{vara2:<15}{pris2:>10.2f}")

Vara            Pris (kr)
-------------------------
Penna                4.00
Suddgummi            9.50

Tips: Välj fältbredder som passar dina längsta texter/tal. :.2f ger alltid två decimaler.

2.6.3 Justerad text – tabellformat med f-strings

Här är ett exempel där vi skriver ut flera rader i tabellformat med hjälp av f-strings:

namn1 = "Anna"
namn2 = "Bo"
namn3 = "Carl"

ort1 = "Alingsås"
ort2 = "Ås"
ort3 = "Västra yttre skogen"

årslön1 = 1200000
årslön2 = 24000
årslön3 = 600000

print(f"|{namn1:<20s}|{ort1:<20s}|{årslön1:<10.0f}kr|")
print(f"|{namn2:^20s}|{ort2:^20s}|{årslön2:^10.0f}kr|")
print(f"|{namn3:>20s}|{ort3:>20s}|{årslön3:>10.0f}kr|")

|Anna                |Alingsås            |1200000   kr|
|         Bo         |         Ås         |  24000   kr|
|                Carl| Västra yttre skogen|    600000kr|

Jag handlade 3 pennor för 12kr och 1 äpple för 3.80kr vilket totalt blev 15.80kr.

2.6.4 Reflektion på uppgiften

Troligtvis har du märkt att beräkningar av datatypen float kan ge lite slumpmässigt felaktiga utskrifter. När vi förväntar oss ett värde med två decimaler så blir istället svaret två korrekta decimaler följt av en mängd nollor innan det slutligen finns ett, som det verkar, slumpmässigt tal. För er som har läst en hel del matematik verkar ju detta helt ologiskt, men det finns naturligtvis en förklaring på detta fenomen. Vi skall kika på en film där orsaken behandlas.

Där har du förklaringen, du behöver inte kunna den utantill men du måste förhålla dig till den. I de uppgifter vi jobbar med i denna kursen så spelar det inte så stor roll om den 6:e, 8:e eller 10:e decimalen är lite felaktig men det kan vara viktigt i andra sammanhang. Det finns alltid lösningar om det måste vara exakt och det gås igenom i slutet av filmklippet.

2.7 Input

Hittills har vi bara använt färdiga variabler i våra program. Med funktionen input() kan vi låta användaren skriva in data när programmet körs.

# funktionen input skriver ut strängen och väntar sedan på en inmatning
namn = input("Ange ditt namn: ")
print(f"Hej {namn}")

Utskrift

Lägg märke till att alla inmatningar gör du i konsollen, alltså den delen där du ser hur själva programmet körs.

När du använder input() blir resultatet alltid en sträng (text), även om användaren skriver in siffror. Vill du räkna på värdet behöver du konvertera det till int eller float.

ålder = int(input("Hur gammal är du? "))
print(f"Om fem år är du {ålder + 5} år gammal.")

pris = float(input("Ange pris i kronor: "))
print(f"Priset är {pris:.2f} kr")

Penna, 5st á 3kr           15.00 kr
Äpplen, 550g á 22.90 kr    12.60 kr
-----------------------------------
Summa                      27.60 kr

2.8 Stränghantering i Python

Att kunna hantera strängar är en grundläggande färdighet inom programmering. Strängar används för att representera text, och i många program behöver vi bearbeta och analysera textdata. I detta avsnitt kommer vi att utforska varför stränghantering är viktigt, lära oss några viktiga funktioner i Python för att manipulera strängar, och avsluta med en uppgift där du får tillämpa dessa kunskaper.

2.8.1 Varför är stränghantering viktigt?

• Interaktion med användaren: Många program tar emot inmatning från användaren i form av text. För att förstå och reagera på denna inmatning behöver vi kunna bearbeta strängar.

• Datahantering: Mycket data lagras och överförs som text. För att extrahera information från denna data behöver vi kunna söka, dela upp och modifiera strängar.

• Felhantering: Användare kan mata in oväntade eller felaktiga data. Genom att hantera strängar effektivt kan vi validera och sanera inmatningar för att förhindra fel i programmet.

2.8.2 Viktiga strängfunktioner i Python

Här är några grundläggande strängfunktioner och metoder i Python som är användbara att känna till:

1. Längd på en sträng med len(): Returnerar antalet tecken i strängen.

   Kodexempel: len()

   text = "Hej världen"
   print(len(text))  # Output: 11

2. Åtkomst till tecken med index:

   En sträng kan ses som en sekvens av tecken där varje tecken har en position, kallad index. Indexeringen börjar från 0 för det första tecknet, 1 för det andra, och så vidare. Man kan också använda negativa index för att räkna baklänges från slutet av strängen (-1 för sista tecknet, -2 för näst sista, osv).

   Kodexempel: index

   text = "Python"
   print(text[0])    # Output: P (första tecknet)
   print(text[1])    # Output: y (andra tecknet)
   print(text[-1])   # Output: n (sista tecknet)
   print(text[-2])   # Output: o (näst sista tecknet)
   

3. Konkatenering (sammanfogning) av strängar:

   Kodexempel: konkatenering

   text1 = "Hej"
   text2 = "världen"
   sammanfogad = text1 + " " + text2
   print(sammanfogad)  # Output: Hej världen

4. Ändra mellan versaler och gemener med str.lower(), str.upper(), str.capitalize(), str.title():

   • str.lower(): Konverterar alla bokstäver till små bokstäver.
   • str.upper(): Konverterar alla bokstäver till stora bokstäver.
   • str.capitalize(): Gör första bokstaven stor och resten små.
   • str.title(): Gör första bokstaven i varje ord stor och resten små.

   Kodexempel: versaler och gemener

   text = "heJ vÄrLdEn"
   print(text.lower())      # Output: hej världen
   print(text.upper())      # Output: HEJ VÄRLDEN
   print(text.capitalize()) # Output: Hej världen
   print(text.title())      # Output: Hej Världen
   

5. str.strip(): Tar bort inledande och avslutande blanksteg.

   Kodexempel: strip()

   text = "  hej "
   print(text.strip())   # Output: "hej"
   print(text.lstrip())  # Output: "hej ", tar bort på vänster sida
   print(text.rstrip())  # Output: "  hej", tar bort på höger sida
   

6. str.replace(old, new): Ersätter en del av strängen med något annat.

   Kodexempel: replace()

   text = "Jag älskar programmering"
   print(text.replace("älskar", "gillar"))  # Output: Jag gillar programmering
   

7. str.find(substring): Söker efter en delsträng och returnerar dess startposition (index). Index börjar på 0. Hittas inget returneras -1.

   Kodexempel: find()

   text = "Hej världen"
   position = text.find("världen")
   print(position)  # Output: 4
   

text = text.strip()

2.8.3 Kedjade metoder (method chaining)

Det är vanligt att bearbeta text i flera steg på samma rad. I Python kan vi kedja metod-anrop: resultatet från en metod blir direkt underlag till nästa.

svar = input("Vill du köra igen (j/n)? ")      # t.ex. "   JA   "
svar = svar.strip().upper()                    # "JA" – tar bort mellanslag + gör versaler
första_tecknet = svar[0]           # "J" 

print("Normerat svar:", första_tecknet)        # -> "J"

# Allt i en rad (utan mellanvariabler):
första = input("Köra igen (j/n)? ").strip().lower()[0]  # t.ex. "j" eller "n"

# Bara versal/gemen, utan att plocka ut första tecknet:
normerat = input("Svara ja/nej: ").strip().upper()      # "JA", "NEJ", "J", "N"

Om du använder [0] så blir det fel om strängen är tom men det får vi leva med för tillfället, i nästa moment löser vi det problemet.

Nu när du har läst om några av de vanligaste strängmetoderna i Python är det dags att testa dem i praktiken. Genom att experimentera med korta program blir det lättare att förstå hur metoder som len(), .lower() och .strip() fungerar och när de är användbara. Börja med att köra exemplen nedan och observera hur resultatet förändras beroende på vad du skriver in.

text = input("Skriv en kort mening: ")

print("Gemener:", text.lower())
print("Versaler:", text.upper())
print("Stor första bokstav:", text.capitalize())
print("Antal tecken:", len(text))
print("Text utan mellanslag i början/slutet:", text.strip())
    

text = input("Skriv en kort mening: ")

# Skriver ut texten med små bokstäver
print("Gemener:", text.lower())

# Skriver ut texten med stora bokstäver
print("Versaler:", text.upper())

# Gör första bokstaven stor och resten små
print("Stor första bokstav:", text.capitalize())

# Skriver ut antalet tecken i texten
print("Antal tecken:", len(text))

# Tar bort eventuella mellanslag i början och slutet
print("Text utan mellanslag i början/slutet:", text.strip())

2.8.4 Exempel: Bearbeta en mening

Låt oss använda några av dessa funktioner i ett sammanhang. Antag att vi har följande sträng:

mening = "  Hej och välkommen till programmeringskursen!  "

Vi vill bearbeta denna sträng på flera sätt:

1. Ta bort extra blanksteg:

   Kodexempel: strip()

   mening = mening.strip()
   print(mening)  # Output: Hej och välkommen till programmeringskursen!
   

2. Konvertera till versaler:

   Kodexempel: upper()

   versaler = mening.upper()
   print(versaler)  # Output: HEJ OCH VÄLKOMMEN TILL PROGRAMMERINGSKURSEN!
   

3. Ersätta ord:

   Kodexempel: replace()

   ny_mening = mening.replace("programmeringskursen", "Python-kursen")
   print(ny_mening)  # Output: Hej och välkommen till Python-kursen!
   

4. Åtkomst till enskilda tecken:

   Kodexempel: använda index

   första_tecken = mening[0]
   sista_tecken = mening[-1]
   print(f"Första tecknet: '{första_tecken}', Sista tecknet: '{sista_tecken}'")
   # Output: Första tecknet: 'H', Sista tecknet: '!'
   

text = "Jag älskar programmering i Python"

# Hitta var ett ord börjar i texten
print("Position för ordet 'Python':", text.find("Python"))

# Ersätt ett ord med ett annat
print("Text efter ersättning:", text.replace("Python", "Java"))
    

text = "Jag älskar programmering i Python"

# Hitta var ett ord börjar i texten
position = text.find("Python")
print("Position för ordet 'Python':", position)

# Testa att söka efter ett ord som inte finns
position = text.find("Java")
print("Position för ordet 'Java':", position)  # -1 betyder att ordet inte hittades

# Ersätt ett ord med ett annat
ny_text = text.replace("älskar", "gillar")
print("Text efter ersättning:", ny_text)

# Eget exempel – byt språk
egen_mening = "Python är ett kraftfullt programmeringsspråk"
print("Egen mening:", egen_mening)
print("Ersatt språk:", egen_mening.replace("Python", "Java"))

# Extra: använd f-string för snyggare utskrift
print(f"'{text}' innehåller {len(text)} tecken.")

Nu har du fått testa flera vanliga strängmetoder och sett hur de kan användas för att analysera och ändra text. I nästa uppgift ska du ta det ett steg vidare och kombinera flera av dessa metoder i ett och samma program. Du kommer att arbeta med inmatad text, bearbeta den och presentera resultatet på ett tydligt sätt.

Ange en mening:   jag lär mig att programmera i python!  
Antal tecken i meningen: 37
Meningen med stor bokstav i varje ord:
Jag Lär Mig Att Programmera I Python!

Ange en mening: Jag älskar att programmera. Att programmera är kul!
  Ange ordet du vill ersätta: programmera
  Ange det nya ordet: koda

  Den nya meningen är:
  Jag älskar att koda. Att koda är kul!
  

Ange e-post:  test@example.com

E-postadress: test@example.com
Antal @: 1
@-tecknet finns på position: 4
Det finns en punkt efter @ på position: 12

2.8.5 Sammanfattning

Stränghantering är en viktig del av programmering som låter oss bearbeta och analysera textdata. Genom att behärska grundläggande strängfunktioner kan vi skapa mer interaktiva och robusta program. Uppgiften ovan ger dig möjlighet att öva på dessa färdigheter i praktiken.

2.9 Syntaxfel

Nu samlar vi ett praktiskt arbetssätt för att hitta och åtgärda de fel som ni troligen redan mött i momentet. Målet här är snabb förståelse: vilka fel är vanliga och hur löser du dem steg för steg. Vi fokuserar på de fel som dyker upp när man jobbar med utskrift, variabler, typer, aritmetik och inmatning.

2.9.1 Grundläggande felsökningsstrategi

1. Läs felmeddelandet noggrant. Det anger ofta feltyp och radnummer.
2. Titta på raden som anges. Kontrollera stavning, parenteser och citationstecken.
3. Sök efter närliggande fel. Ibland är problemet en rad innan den som pekas ut.
4. Använd PyCharms färgmarkering och körtips. De visar ofta problem direkt.
5. Testa små förändringar och kör ofta. Mindre ändringar gör det lättare att hitta orsaken.

2.9.2 Vanliga feltyper och exempel (som ni kan stöta på)

Här går jag igenom de vanligaste feltyperna, ofta är de utskrivna i samband med att felet visas.

2.9.2.1 SyntaxError

• Orsak: fel i språkets struktur – t.ex. saknat citattecken, parentes eller kolon.

Kodexempel: SyntaxError

print("Hello World)   # saknat slut-citattecken → SyntaxError
print("Hej"           # saknar slutparentes → SyntaxError

• Åtgärd: läs raden, räkna parenteser och kontrollera citattecken.

2.9.2.2 NameError

• Orsak: du försöker använda en variabel som inte är definierad (stavat fel eller deklarerad senare).

Kodexempel: NameError

print(namn)    # NameError om 'namn' inte finns
namm = "Anna"
print(namm)    # stavfel ger NameError om du skrev 'namn' tidigare

• Åtgärd: kontrollera stavning och att variabeln skapats innan användning.

2.9.2.3. TypeError

• Orsak: du använder en operation på en olämplig typ, t.ex. försöker lägga ihop str och int.

Kodexempel: TypeError

print("Ålder: " + 16)       # TypeError: kan inte lägga ihop str och int
print("Ålder: " + str(16))  # Rätt – konvertera tal till str

• Åtgärd: kontrollera typer med type() och konvertera med str(), int(), float().

2.9.2.4 ValueError

• Orsak: felaktigt värde vid typkonvertering, t.ex. int("hej").

Kodexempel: ValueError

x = int("fem")   # ValueError: invalid literal for int()

• Åtgärd: se till att input är ett nummer innan konvertering, eller fånga felet (senare moment).

2.9.2.5 ZeroDivisionError

• Orsak: division med noll.

Kodexempel: ZeroDivisionError

x = 10
y = 0
print(x / y)   # ZeroDivisionError

• Åtgärd: kontrollera att nämnaren inte är 0 innan division.

2.9.3 Felsökningsexempel – steg för steg

1. Kör koden och kopiera felmeddelandet. Läs vilken rad och vilken feltyp det är.
2. Öppna filen i PyCharm och titta på den angivna raden.
3. Om det är en SyntaxError, kontrollera: citattecken, parenteser, kolon (:) i block, och indentering.
4. Om det är en NameError, sök efter stavfel eller om variabeln deklarerats i en annan funktion/block.
5. Om det är en TypeError/ValueError, skriv ut type() för de inblandade variablerna för att se vad de innehåller.
6. Skriv små testutskrifter (t.ex. print(type(x))) för att isolera problemet.

2.9.4 Tips att ge eleverna när de fastnar

• Kommentera ut delar av koden (#) för att isolera problemet.
• Dela upp en svår rad i flera rader – enklare att hitta felet.
• Läs feltexten högt – ibland blir det tydligare.
• Jämför med ett fungerande exempel (kopiera en enkel version, kör, och bygg upp stegvis).

# Skriv en kommentar för varje fel du identifierar och löser.
# Beskriv vad som var fel och hur du har löst det.
exchange_rate dollar_to_sek = 8,82
print(Detta är ett program där vi kan växla mellan SEK & dollar)
1sek = input("Hur många SEK vill du växla till dollar: )
dollar = 1sek / exchange_rate_dollar_to_sek
print("Du ville växla {0} SEK vilket blir {1} dollar.".format(1sek, dollar)

2.10 Avrundning av momentet

Detta moment avslutas med två diagnoser som säkerställer att du har förstått grunderna:

• En teoretisk diagnos i form av en quiz med 10 frågor på de viktigaste begreppen.
• En praktisk diagnos där du får skriva kod och lösa en eller flera uppgifter med fokus på det du lärt dig i momentet.

Syftet är att både kontrollera dina kunskaper och ge dig en chans att öva på provliknande situationer.

2.10.1 Checklista inför diagnosen

För att vara förberedd bör du kunna: