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 används ofta snake_case: mitt_variabelnamn.
• Andra varianter du kan se: camelCase, PascalCase, kebab-case. Viktigast är 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.

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 programet 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 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.8.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.8.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.8.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.8.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.8.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: TypeeError

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.8.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.8.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.8.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.8.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.9 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.9.1 Checklista inför diagnosen

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