Detta skapar en PDF som du sedan kan skriva ut. Du kan även spara ner PDFn och skriva ut senare.
Titel på utskriften?
Tack för ditt bidrag
Om vi kan använda det så lägger vi upp det på sidan. Nedan en länk till ditt bidrag om du vill spara det.
Spara som ...
Du sparar ditt skript under detta namn och kan sedan hämta tillbaka det med samma namn.
Läs in
Läs in ett tidigare sparat skript. Obs att du enbart kan läsa in skript i den webbläsare där du sparade skriptet. Vill du kunna läsa in och spara skript oberoende av webbläsare, så behöver du skaffa ett login (enkelt och gratis).
Skicka in bidrag
Föreslå rubrik
Beskriv vad din kod gör
Skapa kort länk
Använd en kort URL för att skicka länk till koden via SMS eller epost. När mottagaren klickar på länken, så öppnas denna webbsida, med din kod och din text. Länken rensas bort automatiskt om den inte används.
Rubrik (frivilligt)
Beskrivning (frivilligt)
Länk (kopiera hela)
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.
Operation
Operator
Exempel
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
och
and
a and b
eller
or
a 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)
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)
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)
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)
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")
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.
A
B
A and B
False
False
False
False
True
False
True
False
False
True
True
True
a = True
b = True
c = a and b
print(c)
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)
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.
A
B
A or B
False
False
False
False
True
True
True
False
True
True
True
True
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)
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)
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)
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.
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
D
e
t
t
a
ä
r
e
n
s
t
r
ä
n
g
s = "Detta är en sträng av tecken"
t = s[0]
print(t)
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)
s = "Detta är en sträng av tecken"
t = s[0] + s[2] + s[3] + s[9]
print(t)
Stämmer det?
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
D
e
t
t
a
ä
r
e
n
s
t
r
ä
n
g
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)
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)
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])
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)
q = [10,20,88,44,3,112]
print(q)
0
1
2
3
4
5
10
20
88
44
3
112
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])
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])
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])
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")
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])
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)
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])
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)
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)
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)
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)
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å"])
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"])
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...
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"])
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"][0])
d = {"Poäng" : 45, "Utrustning" : ["Mat","Tält","Sovsäck","Liggunderlag"]}
print(d["Utrustning"][1])
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.
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.
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 ...
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)
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)
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!
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)
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?