Värden och typer

Ett värde är ett grundläggande ting - såsom en bokstav, ett tecken, eller en siffra - vilket ett program kan manipulera (exempelvis kombinera med andra värden, utföra beräkningar på värdet och dylikt). I föregående kapitel så stötte vi på ett textuellt värde i form av "Hello, world!" när vi skrev vårt första program - som utmynnade i att skriva ut texten "Hello, world!".

"Hello, world!" är ett exempel på ett textuellt värde, men värden kan även vara av andra typer. Textuella värden, som består av mer än ett tecken, kallas exempelvis för stängar (strings) medan heltalet 2 skulle klassificeras som just ett heltal (integer). Du (såväl som Python-tolkaren) kan särskilja en sträng från ett heltal baserat på huruvida värdet är omgivet av citationstecken (").

Starkt typat programmeringsspråk

Python är ett starkt typat språk (strongly typed language) vilket innebär att det spelar roll vilken datatyp en variabel innehåller. Det är exempelvis skillnad på strängen "1" och siffran 1. Vi skulle därför stöta på problem om vi exempelvis försöker utföra en matematisk operation på textuella värden och vice versa.

Det är således viktigt att vi är medvetna om vilken datatyp vi lagrar och/eller arbetar med för att undvika eventuella fel som kan uppstå alt. ett oväntat beteende i vårt program.

`type()`-funktionen

Likt hur vi tidigare skrev ut "Hello, world!" med hjälp av print()-funktionen så skulle vi likväl kunna skriva ut ett heltal med: print(23). Detta då allt som hanteras genom terminalen (d.v.s. input och output) automatiskt kommer att behandlas som textuella värden.

Om du skulle vara osäker på vilken typ ett värde har så kan kompilatorn berätta det för dig genom användningen av type()-funktionen:

print(type("Hello, world!"))
print(type(23))

< class 'str' >
< class 'int' >

Andra datatyper

Det finns självfallet även andra typer av värden som inte riktigt passar som varken ett heltal eller en sträng.

Float: Exempelvis behandlas decimaltal annorlunda än heltal och klassificeras därför som typen float.
```
  print(type(3.2))
```
```
< class 'float' >
```
Vi skulle nu även kunna testa vårt påstående avseende att datorn tolkar strängar som de värden som anges inom citationstecken. Exempelvis kan vi genom type-funktionen se att "3.2" och 3.2 inte är samma typ:
```
  print(type("3.2"))
  print(type(3.2))
```
```
< class 'str' >
< class 'float' >
```
Booleans: En binär datatyp som enbart kan ges värdena True eller False.
```
  guess = True
  print(type(guess))
```
```
< class 'bool' >
```

Datetime: En datatyp som måste importeras och som sedan kan nyttjas för att representera datum eller utvinna datumrelaterad information (såsom dagens datum).

  import datetime                 # import is used to import the library 'datetime', which allow us to use datetime objects
  print(type(datetime))
  print(datetime.datetime.now())  # The value will differ depending on when you execute the function

< class 'module' >
2024-03-20 17:00:50.932698

Det finns självfallet även många andra datatyper som nyttjas i olika avseenden och med olika syften och vi kommer att stöta på flera typer i framtida kapitel.

Formatet är viktigt!

Det är även viktigt att ta formatet på värdet i beaktande när man anger det. Exempelvis så skulle type(1,000,000) generera ett oförväntat resultat då det inte kan tolkas som ett giltigt heltal p.g.a. de kommatecken som nyttjas. Det skulle istället snarare tolkas som en kommaseparerad lista som innehåller värdena 1 0 0, vilket vi kan se ett exempel på om vi försöker skriva ut det enligt:

print(1,000,000)

1 0 0

Ovan felaktiga tolkning är ett exempel på ett s.k. semantiskt fel, d.v.s. att koden tillåts utföras utan att ett faktiskt felmeddelande genereras, men det kommer att resultera i ett annat värde än vad vi förväntar oss. Om vi istället skulle försöka utföra koden: type(1.000.000) så skulle vi få ett s.k. kompileringsfel när vi försöker exekvera koden. Ett kompileringsfel innefattar med andra ord att koden inte är körbar medan semantiska fel istället kan resultera i körbar kod som ger oförväntade resultat.

Sammanfattning

I detta kapitel har vi utforskat Python-syntaxens grundläggande element - värden och datatyper. Vi har sett exempel på olika typer som används i olika syften och hur vi kan använda type()-funktionen för att identifiera vilka datatyper vi arbetar med. Vi har även diskuterat implikationerna av att Python är ett starkt typat språk, t.ex. att vi måste vara säkra på att det är numeriska värden vi arbetar med om vi ämnar utföra matematiska operationer.