Alla program hanterar värden av olika slag. De grundläggande värdena är heltal, flyttal och sanningsvärden. Varje värde har en datatyp. Ofta säger man bara typ istället för datatyp. Det betyder att Python är ett typat språk. Det här avsnittet går igenom dessa tre grundläggande datatyperna, vilka värden de kan ta och vilka operationer man kan göra på dem.

1. Olika sorters tal
2. Sanningsvärden
3. Variabler
4. Funktioner
5. Sammanfattning

I de flesta programspråk finns det flera olika typer av tal. Python har bland annat heltal och flyttal.

Heltal svarar på frågan "Hur många?". På engelska kallas heltal integers och därför heter datatypen för heltal int i Python. Heltal kan vara både positiva och negativa och kan, åtminstone i teorin, vara hur stora som helst. I Python ser heltal ut precis som vanligt, till exempel 2, -4, 0, 4711.

Flyttal svarar på frågan "Hur mycket?". Det handlar alltså om reella tal, rent matematiskt. På engelska kallas de floting point numbers och därför heter datatypen för flyttal float i Python. I Python, precis som i de flesta andra programspråk, används decimalpunkt i stället för decimalkomma. Vi skriver alltså 2.0, 3.14 eller -276.15.

Det som är flytande i flyttalen är decimalpunkten. Internt lagras flyttal i så kallad vetenskaplig notation, något som vi känner igen från fysik och kemi, som ett sätt att hantera riktigt små eller riktigt stora tal. Ett exempel är talet 6,022 x 10²³ som vi i Python skulle skriva 6.022e23.

Det är viktigt att skilja flyttal och heltal åt, eftersom de lagras på olika sätt. Flyttal kan inte alltid representeras exakt, så närhelst flyttal är inblandade finns risk för avrundningsfel.

Python kan i många fall växla automatiskt från heltal till flyttal. Så fort ett flyttal finns med i ett uttryck kommer resultatet att bli ett flyttal. Vidare så kommer även alla uttryck med "vanlig" division (ej den speciella operatorn // för heltalsdivision) att ge ett flyttal, även om täljare och nämnare är heltal och divisionen går jämt ut. Uttrycket 6/2 ger alltså resultatet 3.0, inte heltalet 3. Så länge ingen division förekommer så kommer ett uttryck med heltal endast ge heltal.

Läs mer i Python-dokumentationen för heltal och flyttal

Förutom att bara lagra tal behöver vi också kunna räkna med dem. Python har flera inbyggda operatorer som fungerar precis som de gör inom matematiken.

• De fyra räknesätten + - * /
• Upphöjt till **
• Heltalsdivision //
• Modulo (rest vid heltalsdivision) %

Python har även flera vanliga matematiska funktioner inbyggt. En funktion anropas på samma sätt som den skrivs inom matematiken. Du skriver alltså funktionens namn följt av parenteser, och mellan parenteserna skriver du den information som skickas in till funktionen, exempel funktion(indata).

• abs(x) returnerar absolutbeloppet med samma datatyp som indata
• round(x) returnerar indata avrundat till närmaste heltal
• pow(x,y) är ett alternativt sätt att räkna ut x upphöjt till y

>>> 1 + 1.0
2.0
>>> 2 ** 3
8
>>> 10 / 3
3.3333333333333335
>>> 10 // 3
3
>>> 10 % 3
1
>>> abs(-4711)
4711
>>> round(3.14)
3

Tal är användbara när man vill göra matematiska beräkningar, men när man programmerar vill man också uttrycka logiska samband. För detta har Python de logiska sanningsvärdena True och False. Sanningsvärden kallas på engelska boolean, uppkallade efter den brittiske matematikern George Boole.

Precis som tal är det bra att kunna göra beräkningar på sanningsvärden. De operationer som oftast används på sanningsvärden är and (båda sidor är True), or (minst ett av värdena är True) och not not True = False och not False = True.

Precis som inom matematiken kan parenteser användas för att ändra vilken ordning som operationer ska utföras, både för sanningsvärden och matematiska operationer

>>> not True
False
>>> True and False
False
>>> True and not False
True
>>> (not False or False) and False
False

Sanningsvärden och tal är bra att ha, men oftast vill man kombinera och konvertera mellan dem. Konvertering från tal till sanningsvärden görs främst med hjälp utav jämförelseoperatorer.

• < > mindre/större än
• <= >= mindre/större eller lika med.
• == lika med (Observera att detta inte skrivs som = vilket används för tilldelning som vi kommer se senare!)
• != inte lika med

Observera att större eller lika med inte skrivs som => utan >=. För att komma ihåg vilken ordning tecknen ska komma i kan man tänka att man skriver som man säger det större än (>) eller lika med (=).

>>> 3.5 > 5
False
>>> 3.5 >= 3.5
True
>>> 5 != 3
True
>>> 5 > 3 and 5 <= 6
True

Det vi nu introducerat kan användas för att låta Python agera som en enkel miniräknare, vilket kan kännas rätt långt ifrån ett program som ritar grafik, eller en robot som tar smarta beslut. Även om det är sant så är sanningsvärden och tal en av byggstenarna för det. För att komma närmare ett riktigt program behöver vi dock introducera några fler koncept vilket kommer att göras gradvis under kursen.

Det första konceptet vi kommer att behöva är variabler. Variabler i Python liknar de variabler som används inom matematiken med vissa skillnader.

Precis som inom matematiken har en variabel ett namn (som inom programmering kan vara mer än ett tecken) och ett värde som kan vara ett sanningsvärde, ett tal eller någon annan datatyp som vi introducerar senare i kursen.

För att skapa en variabel används operatorn =. Variabelns namn skrivs först, följt av värdet variabeln ska få. Vid Python-prompten kan värdet skrivas ut genom att skriva variabelns namn utan något annat i prompten.

>>> first_prime = 2
>>> first_prime
2
>>> message = "Hello, world"
>>> print(message)
"Hello world"

Att spara information är inte så användbart om man inte senare kan komma åt informationen. Att komma åt informationen i en variabel är väldigt enkelt: Överallt där man kan skriva ett värde direkt kan en variabel användas istället.

>>> 5 + 3
8
>>> five = 5
>>> five + 3
8

Resultatet av en beräkning kan också tilldelas till en variabel:

>>> sum = 5 + 8
>>> sum
13
>>> distance_squared = 5**2 + 4**2
>>> distance_squared
41

>>> price_lemon = 5
>>> price_lime = 3
>>> should_buy_lemon = price_lemon <= 4
>>> should_buy_lemon
False
>>> should_buy_lime = not should_buy_lemon and price_lime <= 3
>>> should_buy_lime
>>> True

Vad är egentligen en funktion? Vi har redan sett några stycken, hello_world till exempel. En funktion är ett kodblock som man definierar för att kunna återanvända vid ett senare tillfälle. De kan innehålla variabler, operander, loopar, nästan allting faktiskt.

För att skapa en funktion så skriver man def följt av namnet på sin funktion (samma krav som för variabler), och avslutar med två parenteser och ett kolon. Varför vi behöver ange parenteser kommer vi till alldeles strax.

# Här definierar vi vår funktion och beskriver för Python vad den ska göra
def hello_world():
    print("Hello world")

# För att det ska hända något så behöver vi anropa funktionen
hello_world()

hello_world är inte speciellt intressant, vi skulle ju lika gärna kunnat skriva print direkt utan att använda oss av någon funktion. En av de saker som gör funktioner användbara på riktigt är när vi kan skicka argument till dem. Argument är som värden som skickas till en funktion och är ett bra sätt att göra en funktion mer generell så vi kan återvända den flera gånger. Namnen på argumenten som en funktion tar emot kallas för parametrar och skrivs innanför parenteserna när vi definierar funktionen. Nedan har vi funktionen say_hello som tar parametern name. Inuti say_hello finns alltså variabeln name, som vid anropet får det värde som anroparen skickar med, inte ett värde som är angivet inuti funktionen. Funktioner kan även ha mer än en parameter:

def say_hello(name):
    print("Hello ", name, "!")

def print_difference(val1, val2):
    print(val1 - val2)

När vi sedan vill anropa funktionen så kan vi alltså göra det med olika argument. Argumenten till en funktion skrivs inom parenteserna när vi anropar funktionen. Det första argumentet som skrivs i anropet ges till den första parametern, det andra till den andra parametern och så vidare.

>>> say_hello("Sven-Ingvars")
"Hello Sven-Ingvars!"

>>> say_hello("Ingrid")
"Hello Ingrid!"

>>> print_difference(5,3):
2

Hittills har vi bara sett funktioner som skriver ut något på skärmen med print. Men tänk om vi skulle vilja ha ett resultat tillbaka istället? Då behöver vi return. Det som return gör är att avsluta funktionen och skicka tillbaka (returnera) resultatet till den som anropade. return är således oftast mer användbart eftersom vi då kan använda resultatet i andra beräkningar, som argument till andra funktioner och så vidare.

Nedan har vi ett exempel som räknar ut omkretsen på en cirkel:

def circumference(radius):
    pi = 3.14
    return 2 * pi * radius

Vi kan nu anropa funktionen på följande sätt och tilldela x returvärdet:

>>> x = circumference(5)
>>> print(x)
31.4

Om circumference(5) istället hade skrivit ut värdet 31.4, hade vi inte kunnat tilldela värdet till variabeln x.

• I Python finns heltal och flyttal som vi kan bearbeta med operatorer och inbyggda funktioner.
• Det finns bara två olika sanningsvärden och de uppkommer bland annat som resultat av jämförelseoperatorer.
• Variabler är, precis som i matematiken, namn på värden.
• Funktioner är block av programkod som vi ger ett namn för att kunna anropa senare.
• Funktioner kan ta argument. Hur många och vad de heter anges när vi definierar funktionen och dess parametrar.
• Funktioner får gärna returnera värden. I så fall kan funktionen användas som en del av ett större uttryck.

Finnes här