Start | datatyper
 

Variabler & Datatyper



Variabler håller värde av olika slag t.ex. heltal och strängar. Ofta är det till stor hjälp med en datatyp som är mer anpassad för det man vill göra, t.ex. listor eller mängder.

Tal & Matematik

Vi går igenom alla viktiga datatyper lite ytligt. Det finns mer att säga om respektive datatyp, men det kommer längre fram.

operatorer och operander



Det finns ett gäng operatorer som vi kan använda. Såklart de vanliga räknesätten men också jämförelser och lite annat.

OperationOperatorExempel
 
Addition+4+5, x+y
Subtraktion-4-5, x-y
Multiplikation*4*5, x*y
Division*4/5, x/y
 
Modulo%5%4=1, x%y
Heltalskvot//5//4=1, x%y
 
Större än>5 > 4, x > y
Större än eller lika med>=5 >= 4, x >= y
Mindre än<4 < 5, x < y
Mindre än eller lika med<=4 <= 5, x <= y
 
ochanda and b
ellerora or b


Om du ska bli kodare, då måste du snacka som en kodare. Nu har vi lärt oss att plus och minus är operatorer. Så varför inte lika gärna klämma in att siffror och variabler kallas operander.


prioriteringsregler



Multiplikation går före addition, som vi lärt oss i matten, dvs multiplikation har högre prioritet än addition.
x = 10 y = 10 z = x + y * y print(z)
Vill vi bryta den normala prioritetsordningen så använder vi parenteser. Det som står inom parenteser utförs alltid först, dvs har högst prioritet. På så vis kan vi styra vad som utförs först.
x = 10 y = 10 z = (x + y) * y print(z)

modulo och heltalskvot



Modulo är en operator som returnerar resten efter en division.
x = 10 y = 5 rest = x%y print(rest)
Om vi dividerar 10/5 blir kvoten 2 och resten blir 0. Det går jämt upp.
x = 11 y = 5 rest = x%y print(rest)
Om vi dividerar 11/5 så blir kvoten 2 och resten blir 1. Vi återkommer vad man kan använda modulo till under loopar. Modulo är en användbar operator om vi t.ex. vill kolla om ett tal är ett udda eller jämt tal. Eller vad som är delbart med 7 eller 10 eller något annat.
x = 13 y = 4 rest = x%y kvot = x//y print("Om vi delar",x,"med",y,"får vi",kvot,"hela och",rest,"stycken 1/",y,"-delar")
Vi kan med // -operatorn räkna ut heltalskvoten också, som du ser.

Logik

and



Både A och B (eller alla om det är fler) måste vara sanna (True) för att svaret skall vara True.

ABA and B
FalseFalseFalse
FalseTrueFalse
TrueFalseFalse
TrueTrueTrue
a = True b = True c = a and b print(c)
Vi kan sätta ihop längre kombinatoriska satser.
a = True b = False x = True y = True c = a and b and x and y print(c)

or



Räcker med att A eller B är sann (True) för att svaret skall vara True.

ABA or B
FalseFalseFalse
FalseTrueTrue
TrueFalseTrue
TrueTrueTrue


Vi kan använda parenteser om det behövs, även för logik.
a = True b = False c = True d = a and (b or c) print(d)
Det finns även en logisk operator not, som inverterar. Not True = False, Not False = True.
a = True b = False c = not (a or b) print(c)

Strängar " ... "

En sträng är helt enkelt en text, en sträng av tecken. En sträng omges av citat-tecken när den tilldelas ett värde.
s = "Detta är en sträng av tecken" print(s)
Vi kan komma åt varje enskilt tecken i strängen. Första tecknet har index = 0.

01234567891011121314151617
Detta är en sträng
s = "Detta är en sträng av tecken" t = s[0] print(t)
Vi kan plocka ut tecken lite här och var och skapa något nytt.
s = "Detta är en sträng av tecken" t = s[0] + s[2] + s[3] + s[9] print(t)
Stämmer det?

01234567891011121314151617
Detta är en sträng


Vi kan sätta ihop enskilda tecken till strängar men också strängar till nya strängar.
s = "Ute är det " t = "solig" u = "." v = s[1] x = s + t + v + u print(x)
Behöver vi en nyrad i vår utskrift kan vi använda \n
s = "Ute är det " t = "solig" u = "." v = s[1] r = 'inne är det soligt framför dataskärmen' x = s + t + v + u + "\n" + r print(x)
Vi kan indexera en lista bakifrån med negativt index.
s = "bilmotor" print(s[-2])

Listor [ ... ]

En lista är en variabel med många fack, precis som en sträng där varje bokstav var ett fack. En lista omges av hakparenteser och har värden åtskilda av kommatecken. Vi kan komma åt dess olika fack genom dess index, på samma sätt som bokstäverna i strängen.
q = [10,20,88,44,3,112] print(q)
012345
102088443112


Listan q består av 6 stycken fack. Vi kan komma åt dessa fack som individer, de numreras (indexeras) med 0 som bas. Dvs första lådan har nummer 0 och sista lådan har index 5.
q = [10,20,88,44,3,112] print(q[0])
Dvs 3:e lådan är nummer 2.
q = [10,20,88,44,3,112] print(q[2])
Detta påminner om något, gör det inte? Det påminner om hur textsträngar fungerar!
s = "Textsträng" t = ["T","e","x","t","s","t","r","ä","n","g"] print(s[0]) print(t[0])
Textsträngar lagras som en lista av tecken. Verkar vettigt, gör det inte? Ett ord består av en lista av tecken.

Så vi såg här att listor kan bestå av listor av tal eller listor av tecken. Faktum är att listorna kan vara listor av lite allt möjligt.
s = ["Apelsin","Gurka","Tomat","Surströmming"] print(s[3]+" ska bort, det är ingen grönsak")
Vi kan indexera en lista med negativa index och positionen räknas då bakifrån, precis som med strängar. Så för att få andra positionen från slutet i en lista kan vi göra såhär:
s = ["Apelsin","Gurka","Tomat","Surströmming"] print(s[-2])

Tupler ( ... )

Tupler är speciella på det sättet att de kan inte ändras. Detta plus att de är snabba, ifall den detaljen spelar roll i koden. Annars fungerar tupler som listor fast istället för att omges med hakparenteser [ ... ] så omges tupler av parenteser ( ... ).
q = (10,20,88,44,3,112) print(q)
Dess värden kan kommas åt med index.
q = (10,20,88,44,3,112) print(q[0]) print(q[2])

Set (mängder)

Set är alltså engelska för mängder. Poängen med denna datatyp är helt enkelt att göra det möjligt att betrakta data som mängder, vilket kan vara väldigt användbart ibland.
Mängder skrivs inom klammer { ... } - till skillnad från listor som skrivs inom hakparenteser [ ... ] eller tuples som skrivs inom parenteser ( ... )
A = {"Äpple","Päron","Tomat","Potatis","Rödbeta"} print("Detta är en mängd ", A)

unionen av 2 mängder



Unionen av 2 mängder är som att ta summan och ta bort dubbletter. Finns inga dubbletter i mängder. Observera också att vi här använder den bit-logiska operatorn eller. Tänk såhär: Det räcker att ett element finns i någon av mängderna för att få tillhöra resultatet (summan). Eller hur? Det är ju exakt så operatorn eller fungerar.
A = {"Äpple","Päron","Tomat","Potatis","Rödbeta"} B = {"Potatis","Rödbeta","Vete","Ax"} C = A | B print(C)

en mängd minus en annan



Vi kan ta en mängd och ta bort elementen som finns i en annan mängd.
A = {"Äpple","Päron","Tomat","Potatis","Rödbeta"} B = {"Potatis","Rödbeta","Vete","Ax"} C = A - B print(C)

snittet mellan 2 mängder





Säg att vi vill veta snittet mellan 2 mängder, dvs vad 2 mängder har gemensamt. Snitt heter på engelska intersection och vi kan använda metoden intersection eller operatorn &. Tänk såhär, snitt är det som finns i A och B, så är det lätt komma ihåg &
A = {"Äpple","Päron","Tomat","Potatis","Rödbeta"} B = {"Potatis","Rödbeta","Vete","Ax"} gemensamt = A.intersection(B) print(gemensamt) gemensamt = A & B print(gemensamt)
Poängen med mängder (set) är att vi får ett gäng mängd-operatorer som vi kan använda på denna datatyp. T.ex. snitt, union, skillnad, summa osv. Mängder är optimerade för dessa mängdoperationer, därför saknas t.ex. indexering av elementen, vilket finns i listor.

Dictionary { key:value }

Dictionary betyder ordbok. I en en dictionary skapar vi par av { key : value }, dvs vi kopplar en nyckel till ett värde, ungefär som en ordbok.


d = {"Röd" : "Red", "Blå" : "Blue"} print(d["Röd"]) print(d["Blå"])
För att göra dictionary tydligare brukar man ofta pretty -printa såhär:





d = {"Röd" : "#FF0000", "Grön" : "#00FF00", "Blå" : "#0000FF"} print("Röd färg har färgkoden "+d["Röd"]) print("Grön färg har färgkoden "+d["Grön"])
Vi kan ändra innehållet i en dictionary genom att tilldela ett nytt värde...


d = {"Favoritmat" : "Hamburgare", "Favoritdryck" : "Saft"} d["Favoritmat"] = "Kebabrulle" d["Favoritdryck"] = "Mjölk" print(d)
Value kan även vara en lista av något, i nedan kod är utrustning en lista av saker.







d = {"Poäng" : 45, "Utrustning" : ["Mat","Tält","Sovsäck","Liggunderlag"]} print(d["Utrustning"])
Vi kan komma åt enskilda element i listan, med dess index.
d = {"Poäng" : 45, "Utrustning" : ["Mat","Tält","Sovsäck","Liggunderlag"]} print(d["Utrustning"][0])
d = {"Poäng" : 45, "Utrustning" : ["Mat","Tält","Sovsäck","Liggunderlag"]} print(d["Utrustning"][1])

Vi kan låta en dictionary innehålla en nästlad dictionary. För att komma åt ett värde, måste vi då ange de nycklar (key's) som följer hela vägen upp till vårt value.


kundregister = { 10 : { 'namn': 'Sven', 'efternamn': 'Svensson' }, 20: { 'namn': 'Anders', 'efternamn': 'Andersson' } } print(kundregister[20]["namn"])
Observera att siffrorna här inte är index, utan är de siffror vi angivit i vår dictionary. Vi hade kunnat skapa en lista av dictionary som nedan. Notera att dictionaryn nu är omsluten med hakparenteser.


kundregister = [ { 'namn': 'Sven', 'efternamn': 'Svensson' }, { 'namn': 'Anders', 'efternamn': 'Andersson' } ] print(kundregister[0]["namn"])

Om du ser det såhär ...

kundregister = [{ ... }, { ... }, { ... }]

Så ser du tydligare att det just är en lista (eller hur? Gå tillbaka upp på sidan och titta på listor om du tvekar!), där första dictionaryn nås med index = 0, medans om det ser ut såhär ...

kundregister = {10:{ ... }, 20:{ ... }, 30:{ ... }}

Då är det ingen lista utan en nästlad dictionary.

lista av dictionaries


kundregister =





kundregister = [{ "n":"Sven" }, { "n":"Lisa" },{ "n":"Ola" }] print(kundregister[0]["n"]) print(kundregister[1]["n"])

nästlad dictionary


kundregister =





kundregister = {10:{ "n":"Sven" },20:{ "n":"Lisa" },30:{ "n":"Ola" }} print(kundregister[10]["n"]) print(kundregister[20]["n"])

Dictionary är en mycket kraftfull datatyp. Tillsammans med listor kan man representera nästan vad som helst och så görs också.

Typiskt brukar man importera en stor datafil som är på JSON -format och lagra det som en dictionary i python -programmet. Därefter kan programmet skapa grafik eller göra annan analys.

Vi återkommer till dictionary och alla andra datatyper på denna sida framöver.

class

En sista datatyp vi skall titta på är class. Rätt så ofta, i verkligheten, i dataspel, i banksystem, i robotars hjärnor, överallt, så behöver vi lite mer omfattande variabler. Vi vill samla många data på samma ställe, i samma objekt. Vi kan göra detta med class.

Vi kanske har ett skrivbord på en dator. Där har vi bilder. Bilderna har dels ett namn, men också en bredd och höjd. Dessutom vill vi lagra vilken position bilden ska ritas på.
class Bild: namn = "unknown" x = 0 y = 0 width = 0 height = 0 nybild = Bild() print(nybild.namn)
Vi kan tilldela värden till detta objekt efter att vi skapat det och vi kan senare komma åt dem.
class Bild: namn = "unknown" x = 0 y = 0 width = 0 height = 0 nybild = Bild() nybild.namn = "bil.png" nybild.x = 100 nybild.y = 120 nybild.width = 200 nybild.height = 300 print(nybild.namn) print("x=",nybild.x) print("y=",nybild.y) print("width=",nybild.width) print("height=",nybild.height)
Vi kan skicka hela objektet som argument till en funktion. Vi slipper skicka alla ingående delar. Mycket praktiskt!
class Bild: namn = "unknown" x = 0 y = 0 width = 0 height = 0 def skriv_bilddata(bild): print(bild.namn) print("x=",bild.x) print("y=",bild.y) print("width=",bild.width) print("height=",bild.height) nybild = Bild() nybild.namn = "bil.png" nybild.x = 100 nybild.y = 120 nybild.width = 200 nybild.height = 300 skriv_bilddata(nybild)
För att göra skapandet av en instans av Bild() enklare, kan vi lägga till en konstruktor (__init__ -ieringsfunktion) i classen bild.
class Bild: def __init__(self, n, x, y, w, h): self.namn = n self.x = x self.y = y self.width = w self.height = h def skriv_bilddata(bild): print(bild.namn) print("x=",bild.x) print("y=",bild.y) print("width=",bild.width) print("height=",bild.height) print("---------------------") nybild = Bild("bil.png",100,120,200,300) entillbild = Bild("katt.png",220,130,300,300) lista = [ Bild("ros.png",250,50,70,70), Bild("sko.png",350,50,70,70), Bild("hast.png",450,50,70,70) ] skriv_bilddata(nybild) skriv_bilddata(entillbild) for bild in lista: skriv_bilddata(bild)

Vi går igenom class mer utförligt längre fram! Ville bara att du skulle ha sett en sådan. Poängen är att samla data som hör samman i egna objekt.

Lite frågor

Vad blir not( True and False or True)
  False
  True
Tänk dig s = "bilmotor". Hur kommer vi åt första bokstaven?
  s[1]
  s[0]
Tänk dig s = "bilmotor". Hur kommer vi åt sista bokstaven?
  s[-1]
  s[-0]
Tänk dig lst = ["Apelsin","Gurka","Tomat"]. Hur kommer vi åt sista elementet?
  lst[-0]
  lst[-1]
Vad är tupler för något?
  Fungerar som listor, en helt onödig datatyp
  Fungerar som listor, men är tänkt för värden som inte ändras
Vad är snittet mellan {1,2,3} & {2,3,4}
  {1,2,3,4}
  {2,3}
Om du har d = {"Röd" : "Red", "Blå" : "Blue"}, vad är value för röd?
  d["Red"]
  d["Röd"]
kundregister = {10:{ "n":"Sven" },20:{ "n":"Lisa" },30:{ "n":"Ola" }} print(kundregister[10]["n"]) print(kundregister[20]["n"])
Vad blir kundregister[30]["n"] i ovan kod?
  {"n","Ola"}
  Ola
  30:{"n","Ola"}


33.052921295166 ms