Föreläsningsöversikt, FÖ 2.1-2.2¶
- Recap Tema 1
- Tema 2: Informationsbearbetning
- Översikt
- Parprogrammering
- Programflöde
- Funktioner och scope
- Villkorssatser och sanningsuttryck
- Sekvenser och iteration
- Övrigt smått och gott i mån av tid
Reflektioner efter Tema 1¶
- Vad var svårt?
- Vad var lätt?
- Lade jag tid på rätt saker och i rätt ordning?
Jag fattar inte ett dugg efter Tema 1, hur körd är jag?¶
Tema 1¶
- Datorn och program
- Beståndsdelar i ett program:
- värden, datatyper: int, float, str, list
- variabler, operatorer, uttryck
- satser, nyckelord
- funktioner, argument, returvärden
- block
- Diskret matematik
- mängder
Tema 2: Informationsbearbetning¶
Tema 2¶
- Styra flöde i program
- Funktioner och scope
- Villkorssatser
- Repetition i program
- Bearbetning av värden i sekvens
- Datarepresentation
- Python: klasser för olika typer av data
- Begreppsseminarie 2: filer, filformat, komprimering, filsystem
- Diskret matematik
- tupler, relationer, grafer
Hur är man en bra förare?¶
Hur är man en bra observatör?¶
Fira när ni har löst ett problem

Anatomilektion¶
Vårt exempel¶
Funktionsdefinition¶
Funktionsdefinition - header¶
Funktionskropp¶
Funktionsanrop¶
Retursats¶
In [48]:
def triangle_area(height, width):
area = (height*width)/2
return area
triangle_area(7, 9)
Out[48]:
31.5
Anropsstacken (eng. call stack)¶
Datastrukturen stack¶
- En stapel av objekt:
- Lägg till objekt på toppen (eng: push)
- Ta bort översta objektet (eng: pop)
- Alla andra objekt i stacken är otillgängliga
- Liknelse: Lista där nya element bara kan läggas till i slutet (append), och bara det sista elementet kan tas bort (pop).
Programflöde - funktionsanrop¶
- Ett pythonprogram tolkas sekventiellt av pythontolken.
- Vi tänker oss att vi har en körmarkör som pekar på vad det som ska utföras näst
- När pythontolken ser ett funktionanrop görs följande
- eventuella argument i funktionsanropet beräknas
- eventuella argument skickas till den anropade funktionen och en frame för anropet skapas på toppen av stacken
- den anropade funktionens funktionskropp utförs sekventiellt - körmarkören flyttas till funktionskroppen
- när funktionen är klar tas dess frame bort och
- körmarkören flyttas tillbaka dit anropet påträffades och funktionens returvärde "ersätter" funktionsanropet
Exempel¶
In [ ]:
print("Första raden")
def calc_double(value):
new_value = value * 2
print("värdet på value:", value)
print("värdet på new_value:", new_value)
return new_value
def main():
print("Nu körs main()")
value = 5
double = calc_double(value)
print("Dubbla värdet är", double)
main()
print("Nu är programmet slut!")
Förtydligande efter pythonuppgifter:¶
return
eller print
¶
return
- En sats som styr programflödet
- Bara i funktioner
- Skickar ett värde tillbaka till koden som anropat funktionen
- Kan finnas på flera platser i en funktion men kan bara köras en gång och innebär alltid att funktionen avslutas
- Inga parenteser
print
- En funktion som skriver ut ett värde
- Kan göras hur många gånger som helst och (nästan) var som helst
- Påverkar inte programflödet
- Parenteser används för att anropa funktionen
print
¶
In [49]:
def add_1_and_print(value):
print(value+1)
add_1_and_print(1)
2
return
¶
In [50]:
def add_1_and_return(value):
return value+1
In [51]:
print(add_1_and_return(1))
2
In [52]:
print(add_1_and_return(add_1_and_return(1)))
3
print
¶
In [53]:
def add_1_and_print(value):
print(value+1)
add_1_and_print(1)
2
In [54]:
add_1_and_print(add_1_and_print(1))
2
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) Cell In[54], line 1 ----> 1 add_1_and_print(add_1_and_print(1)) Cell In[53], line 2, in add_1_and_print(value) 1 def add_1_and_print(value): ----> 2 print(value+1) TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
Såatte... Det här "scope" du skulle prata om...¶

Scope¶
- Den kontext där en variabel är giltig.
- En variabel som skapats inne i en funktion kallar vi för lokal variabel
- Scopet för en lokal variabel är den frame som skapades vid funktionsanropet.
- Dvs den lokala variabeln är endast giltig och tillgänglig i funktionsanopets frame.
- Variabler med samma namn kan existera i olika scopes med olika värden.
Lokala variabler¶
In [63]:
def calc_double(value):
new_value = value * 2
print("värdet på value inne i calc_double:", value)
print("värdet på new_value:", new_value)
return value
In [64]:
value = 10
print("värdet på value utanför:", value)
calc_double(value)
värdet på value utanför: 10 värdet på value inne i calc_double: 10 värdet på new_value: 20
Out[64]:
10
In [65]:
print("värdet på value utanför:", value)
värdet på value utanför: 10
In [66]:
print("värdet på new_value:", new_value)
--------------------------------------------------------------------------- NameError Traceback (most recent call last) Cell In[66], line 1 ----> 1 print("värdet på new_value:", new_value) NameError: name 'new_value' is not defined
Styra flöde med villkor¶
Villkorssatser¶
if
-satsen¶
- Sammansatt sats med en eller flera klausuler.
- Första klausulen börjar alltid med nyckelordet
if
. - Syntax:
if boolean:
# Code block that runs if boolean is True
Vad är en "boolean"?¶
- Booleska värden, (eng. boolean value), ett annat ord för sanningsvärden.
- I Python: Klassen
bool
med exakt två möjliga värden,True
ellerFalse
. - Oftast resultat av någon jämförelseoperator:
==
,!=
,<
,>
,<=
,>=
In [71]:
print(1 != 2)
True
In [75]:
def calculate_price(rider_age):
price = 30
if rider_age < 12:
price = 0
return price
print(calculate_price(12))
30
else
-klausulen¶
- En del av en sammansatt sats, i det här fallet en
if
-sats. - Alltid den sista klausulen och hanterar en "annars"-situation.
- Syntax:
if boolean:
# Code that runs if boolean is True
else:
# Code that runs if boolean is False
In [77]:
def calculate_price(rider_age):
if rider_age < 12:
price = 0
else:
price = 30
return price
print(calculate_price(5))
0
Men vi hade ju fyra fall i vårt första exempel!¶
- Två olika lösningar som lämpar sig olika väl i olika situationer:
- Nästling av
if
-satser, dvsif
-satser inne i andraif
-satser. elif
-klausuler.
Nästlade if
-satser¶
- Syntax:
if boolean_a:
# Code that runs if boolean_a is True
else:
if boolean_b:
# Code that runs if boolean_a is False but boolean_b is True
else:
# Code that runs if both booleans are False
Nästlade if
-satser för vårt exempel¶
In [82]:
def calculate_price(rider_age):
if rider_age < 12:
price = 0
else:
if rider_age < 18:
price = 20
else:
if rider_age < 65:
price = 30
else:
price = 15
return price
print(calculate_price(65))
15

elif
-klausulen¶
- Syntaktiskt socker för det vi just såg.
- Utökar
if
-satser med flera olika fall. - Fått namn av att det rent logiskt är som att ha en ny
if
-sats ielse
-klausulen. - Syntax:
if boolean_a:
# Code that runs if boolean_a is True
elif boolean_b:
# Code that runs if boolean_a is False but boolean_b is True
else:
# Code that runs if both booleans are False
elif
-klausuler för vårt exempel¶
In [83]:
def calculate_price(rider_age):
if rider_age < 12:
price = 0
elif rider_age < 18:
price = 20
elif rider_age < 65:
price = 30
else:
price = 15
return price
print(calculate_price(12))
20
Logiska operatorer¶
- Logiska operatorer används för att kombinera eller negera sanningsvärden.
- Uttryck med logisk operator beräknas alltid till ett sanningsvärde, dvs antingen True eller False.
and
:True
om båda operander är sannaor
:True
om minst en av operanderna är sannanot
:True
om operanden ärFalse
,False
om operanden ärTrue
- Exempel
- sensor1 > 100 and sensor2 <= 10
Logiska operatorer och mängdoperatorer¶
- De logiska operatorerna
and
,or
, ochnot
kan liknas vid mängdoperatorerna snitt, union och komplement. - Om ett element x tillhör både mängderna A och (
and
) B, dvs x∈A och (and
) x∈B, så gäller att x∈A∩B. - Om ett element x tillhör mängden A eller (
or
) mängden B, dvs x∈A eller (or
) x∈B, så gäller att x∈A∪B. - Om ett element x inte (
not
) tillhör mängden A, dvs x∉A, så gäller att x∈A∁.
Exempel, vädret¶

Exempel, vädret¶
In [3]:
def tell_me_about_the_weather(temp, precipitation):
if temp < 0 and precipitation:
print("I think it's snowing.")
if temp < 0 and not precipitation:
print("At least it's not snowing.")
if temp < -100 or temp > 100:
print("I think something is very wrong.")
tell_me_about_the_weather(106.2, False)
I think something is very wrong.
Enkla värden¶
- Vad kan representeras som ett enkelt värde?
- T.ex. heltal, flyttal, strängar (om vi ser på en sträng som ett enstaka värde)
Vad är en sekvens av värden¶
- Ordning
- A kommer före B
- B kommer före C
- C kommer före D
- ...
- Finns det scenarion där vi har
- en ändlig sekvens av värden?
- en oändlig sekvens av värden?
Sekventiell information och datorn¶
- Minnesplatser i RAM
- Värden lagrade i filer
- Värden från olika sensorer
- Inlägg i ett flöde i sociala medier
Från bits till tal, till tecken, till strängar¶
- Åtta bitar (binärt):
0b11111111
,0b00001111
,0b01010101
- Hexadecimalt:
0xff
,0x0f
,0x55
- Decimalt:
255
,15
,85
- Teckentabeller:
65 = 'A'
,97 = 'a'
- Strängen
"Aa"
=65 97 0
(decimalt), eller0x41 0x61 0x00
(hexadecimalt)- Värdet 0 används för att visa var strängen slutar (t.ex. om man läser strängenfrån minnet)
Filer och filformat¶
- Fil
- sekvens av värden (bytes) som hör ihop och lagras i ett filsystem.
- en byte kan användas för att representera ett värde mellan 0-255 (
0x00-0xFF
,0b00000000-0b11111111
)
- Filformat
- standard för hur information ska lagras (kodas) i en fil
- specifikation
- öppna kontra stängda filformat
Filer och filformat¶
- Textbaserade filformat
- Fördel: vi kan läsa och redigera informationen med en texteditor
- Nackdel: kan ta mycket mer plats än nödvändigt
- Exempel: csv, tsv, xml, html, css, json
- Binära filformat
- Fördel: tar mindre plats, snabbare/effektivare
- Nackdel: vi behöver använda speciell mjukvara för att läsa/ändra
- Exempel: jpg, png, gif, mp3, mov, m4v, pdf, doc
- Mixade filformat
- Exempel: pdf, docx, xlsx
Textbaserade filformat¶
Textfiler¶
- Filer där varje enhet data/värde ska tolkas som ett tecken
- Olika teckentabeller och teckenkodningar
- teckentabell: olika "skiffer", t.ex. "A" = 65 (i ASCII)
- teckenkodning: olika sätt att lagra teckenvärdena
- Följer ofta specificerade format
- T.ex. CSV, JSON, XML, YAML, etc.
Tabell-data, CSV¶
- "comma separated values"
- ofta används något annat tecken än kommatecken, ofta semikolon (vanligt i länder där decimaltal normalt sett skrivs med kommatecken, t.ex. Sverige och Tyskland) eller tabb-tecken (då kallas ofta formatet för TSV istället)
- Rader av värden
- Varje värde på raden skiljs åt av ett kommatecken (eller något annat tecken)
- Varje rad måste ha lika många värden
CSV-exempel¶
XML - Extensible Markup Language¶
- Ett uppmärkningsspråk som används för att strukturera data.
- Textbaserat, dvs information lagras som text.
- DTD (Document Type Definition)/Schema specificerar strukturen separat från dokumentet som innehåller data
- Kan användas för många olika typer av information.
- Hierarkisk struktur
- SVG: XML-baserat grafik-format
- HTML: XML-liknande dokumentstrukturformat
XML-exempel¶
<book>
<author>Ludwig Wittgenstein</author>
<title>Tractatus logico-philosophicus</title>
<year>1921</year>
</book>
XML-exempel¶
<book>
<author>Ludwig Wittgenstein</author>
<title>Tractatus logico-philosophicus</title>
<year>1921</year>
<contents>
<chapter>
<title>Inledning</title>
<section>
<title>1. Wittgenstein och Tractatus</title>
<paragraph>
...
</paragraph>
</section>
</chapter>
</contents>
</book>
Sensordata i JSON-format¶
[
{
"id": 10635823179,
"sampling_rate": null,
"timestamp": "2022-05-24 15:15:52",
"location": {
"id": 16232,
"latitude": "48.8",
"longitude": "9.002",
"altitude": "365.6",
"country": "DE",
"exact_location": 0,
"indoor": 0
},
"sensor": {
"id": 92,
"pin": "1",
"sensor_type": {
"id": 14,
"name": "SDS011",
"manufacturer": "Nova Fitness"
}
},
"sensordatavalues": [
{
"id": 23601965190,
"value": "1.44",
"value_type": "P1"
},
{
"id": 23601965192,
"value": "0.50",
"value_type": "P2"
}
]
},
{
"id": 10635811403,
"sampling_rate": null,
"timestamp": "2022-05-24 15:14:34",
"location": {
"id": 45999,
"latitude": "48.808",
"longitude": "9.182",
"altitude": "310.1",
"country": "DE",
"exact_location": 0,
"indoor": 0
},
"sensor": {
"id": 113,
"pin": "11",
"sensor_type": {
"id": 17,
"name": "BME280",
"manufacturer": "Bosch"
}
},
"sensordatavalues": [
{
"id": 23601938276,
"value": "49.26",
"value_type": "humidity"
},
...
]
},
...
]
Binära filformat¶
- Ofta förekommande struktur
- Header med metadata (data om data, t.ex. beskrivningar av format) lagrat som text följt av data lagrad binärt
- Specifikt användningområde
- Många format kan endast användas för att koda en specifik typ av information (t.ex. bild, ljud, presentation etc)
- Exempel på undantag (som kan lagra flera olika filer)
- (komprimerade) arkiv-format som zip, rar, 7z, etc.
Exempel: Bild¶
- Varje pixel kan t.ex. representeras som ett 24-bitars värde
- Tre bytes behövs för varje pixel
- 8 bitar för röd, 8 bitar för grön, 8 bitar för blå
Sekvenser i Python: Strängar¶
- En sekvens av tecken.
- I Python representerade av klassen
str
In [4]:
my_name = "Pikachu"
print(my_name[0])
P
In [5]:
print(my_name[1:3])
ik
In [6]:
print("Mr. " + my_name)
Mr. Pikachu
In [7]:
print(my_name + "Mr. ")
PikachuMr.
Sekvenser i Python: Listor¶
- Sekvens av objekt (t.ex. heltal, flyttal, strängar).
- En lista är också ett objekt, dvs en lista kan också innehålla andra listor.
- I Python representerade av klassen
list
.
In [8]:
candy1 = ["chocolate", "jellybeans", "fudge", "toffee"]
print(candy1[0])
chocolate
In [9]:
print(candy1[1:3])
['jellybeans', 'fudge']
In [10]:
print(["licorice"] + candy1)
['licorice', 'chocolate', 'jellybeans', 'fudge', 'toffee']
In [11]:
print(candy1 + ["licorice"])
['chocolate', 'jellybeans', 'fudge', 'toffee', 'licorice']
Minnesrepresentation av sekvenser, historiskt sett¶
- Lagrades i så kallade "fält" (eng: array) i minnet, dvs i direkt följd från en viss minnesadress.
- Minnesadressen pekade på början av första elementet i sekvensen.
- För att komma åt ett element på en viss position i sekvensen användes index som indikerade hur många steg från sekvensens start man behövde gå för att komma till elementet man ville ha.
- Första elementet låg alltså på sekvensens minnesadress + indexvärdet 0.
Exempel¶
In [13]:
spam = "EXEMPEL"
- Vi skapar en sträng
"EXEMPEL"
och sparar den i variabelnspam
- Vi antar att
spam
lagras på minnesplats0x0007
Exempel¶
In [14]:
spam
Out[14]:
'EXEMPEL'
- Om vi skriver ut variabeln
spam
får vi sekvensen som börjar på minnesadressen0x0007
och är 7 tecken lång
Exempel¶
In [ ]:
spam[0]
- Om vi använder indexering tar vi sekvensens minnesadress, adderar index-värdet, och läser ett element framåt från den beräknade minnesadressen
Exempel¶
In [ ]:
spam[1]
- Om vi använder indexering tar vi sekvensens minnesadress, adderar index-värdet, och läser ett element framåt från den beräknade minnesadressen
Exempel¶
In [15]:
spam[2:5]
Out[15]:
'EMP'
- Om vi använder "utsnitt" (eng: slice) adderar start- och stopvärdena till sekvensens minnesadress och läser från den den första och fram till den andra beräknade minnesadressen.
Programmatisk bearbetning av sekvenser¶
De flesta beräkningarna och processer i datorer är sekventiella¶
- Information läses sekventiellt från start till slut.
- Vad får detta för konsekvenser?
Från datorns perspektiv¶
- Har datorn en översiktsbild? Kan datorn titta på en hel sekvens på en gång?
- Datorn kan "titta" på ett element i taget, möjligtvis två precis vid en jämförelse
- Vi måste tillhandahålla arbetsminne
- Datorn kommer inte ihåg något "automatiskt"
Vad behövs för att bearbeta en sekvens av data?¶
- något sätt att gå igenom sekvensen
- något sätt att beskriva regler för vad som göras beroende på vad för värden vi har i sekvensen
- (låter detta bekant?)
Två iterationssatser i Python¶
while
-satsen- Som en
if
-sats, men blocket upprepas så länge som villkoret är uppfyllt. - För genrella tillämpningar.
- Som en
for
-satsen- Utför ett stycke kod för varje element i en sekvens.
- Mindre generell, men enklare att använda.
while
-loopen¶
- Satserna i blocket som tillhör
while
-loopen upprepas tillswhile
-satsens villkor blir falskt. - Efter sista satsen i blocket börjar loopen om från blockets första sats
- Varje "varv" loopen gör kallas för en iteration
while boolean:
# Code to repeat
Exempel¶
- Räkna upp till 10.
In [20]:
count = 0
while count <= 10:
print(count)
count += 1
print("Efter loopen är count: " + str(count))
0 1 2 3 4 5 6 7 8 9 10 Efter loopen är count: 11
Exempel¶
# evig loop
x = 0
while x <= 10:
print("En dator blir aldrig uttråkad.")
print(x)
Avbryta en loop, eller gå till nästa iteration i en loop¶
- Nyckelordet
break
användas för att avbryta en loop (hela loopen). - Nyckelordet
continue
används för att hoppa över resten av loop-blocket och börja om igen från början (nästa iteration)

In [21]:
count = 0
while count < 10:
if count == 3 or count == 5:
count += 1
continue
if count > 7:
print("Nu orkar jag inte mer." + "(count: " + str(count) + ")")
break
elif count > 3:
print("Är vi framme snart?" + "(count: " + str(count) + ")")
elif count > 4:
print("Har vi kört vilse?" + "(count: " + str(count) + ")")
else:
print("Det här är roligt!" + "(count: " + str(count) + ")")
count += 1
Det här är roligt!(count: 0) Det här är roligt!(count: 1) Det här är roligt!(count: 2) Är vi framme snart?(count: 4) Är vi framme snart?(count: 6) Är vi framme snart?(count: 7) Nu orkar jag inte mer.(count: 8)
for
-loopen¶
for element in a_sequence:
# Code to run for every element in a_sequence
- Vi säger att
for
-loopen loopar över en sekvens. - I varje iteration innehåller
element
det aktuella värdet i sekvensen. - Ingen manuell kontrollvariabel.
Gå igenom en lista med for
¶
In [22]:
names = ["Ada", "Beata", "Cecilia", "Diana"]
for name in names:
print(name)
Ada Beata Cecilia Diana
Gå igenom en sträng med for
¶
In [23]:
word = "fantastic"
for char in word:
print(char)
f a n t a s t i c
Byt ut bokstäver¶
In [24]:
word = "fantastic"
new_word = ""
for char in word:
if char == "a":
new_word += "å"
elif char == "s":
new_word += "l"
else:
new_word += char
print(new_word)
fåntåltic
Funktionen range
¶
- Skapar en "virtuell lista med heltal" (tekniskt sett en sk generator) som man kan använda som en vanlig lista med heltal.
range(stop)
: Börja från 0, öka med 1 och fortsätt generera heltal så länge som heltalet är mindre änstop
range(start, stop)
: Börja frånstart
, öka med 1 och fortsätt generera heltal så länge som heltalet är mindre änstop
range(start, stop, step)
: Börja frånstart
, öka medstep
och fortsätt att generera heltal så länge som heltalet är mindre änstop
- För att få en riktig lista kan vi skicka returvärdet från
range
till funktionenlist
, t.ex.list(range(10))
Funktionen range
¶
In [25]:
list(range(10))
Out[25]:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [26]:
list(range(4,6))
Out[26]:
[4, 5]
In [29]:
list(range(10, 101, 10))
Out[29]:
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
In [30]:
list(range(10, 110, 10))
Out[30]:
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
In [33]:
list(range(10, 0, -1))
Out[33]:
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
In [34]:
list(range(10, 3, -2))
Out[34]:
[10, 8, 6, 4]
for
med range
¶
In [35]:
# Skriv ut siffrorna 0 till 9 (10 siffror)
for i in range(10):
print(i)
0 1 2 3 4 5 6 7 8 9
for
med range
över längden på en sekvens¶
Ofta överflödigt:
In [ ]:
names = ["Adam", "Bethany", "Chris"]
# Skriv ut elementen i listan names
for i in range(len(names)):
print(names[i])
- Lämpligare och enklare att loopa direkt över namnen.
for
med range
över längden på en sekvens¶
men ibland praktiskt:
In [ ]:
names = ["Adam", "Bethany", "Chris"]
# Skriv ut elementen i listan names
for i in range(len(names)):
print(names[i] + " likes " + names[(i+1) % len(names)])
(För den som vill se en mer "pythonic" approach, kolla upp funktionen enumerate
.)
Felsökning¶

Olika typer av fel¶
- Syntaxfel: Koden bryter mot programspråkets grammatiska regler, exempelvis
- använda reserverade ord på fel sätt, t.ex. att döpa en variabel till
return
eller en funktion tillif
- saknat kolon i slutet av if-sats
- använda reserverade ord på fel sätt, t.ex. att döpa en variabel till
- Runtime-fel: Fel som uppstår vid körning och resulterar i en krasch, exempelvis
- Division med 0
- Försöka läsa en fil som inte existerar
- Logiska fel: Fel som uppstår när programmet fungerar men inte gör vad som var tänkt.
- Felaktig operatorprioritet, t.ex. råka skriva
x + y * 5
när man menade(x + y) * 5
- Off-by-one-fel, t.ex. glömma bort att indexering börjar på 0, inte 1
- Felaktig operatorprioritet, t.ex. råka skriva
Spårutskrifter¶
- Utskrift av variabelvärden
- Utskrift av text för att visa var i koden pythontolken befinner sig
- Hur vi skrev ut variabeln
value
på olika ställen för att se vilket värde den hade i en viss kontext
Felsökning av olika typer av fel¶
- Syntaxfel: kontrollera syntax, antal blanksteg, parenteser, kolon, etc.
- Runtime-fel: tolka felmeddelandet, lägg till spårutskrifter
- Logiska fel i programmet: försök att isolera felet, på vilka ställen i koden används variabeln/funktionen som har med felet att göra? Lägg till spårutskrifter.
- När det är svårt att hitta felet: det är bättre att vara noggrann och dubbelkolla med spårutskrifter än att göra antaganden om att man gjort rätt.
Programabstraktion¶
Dela upp ett problem i delproblem¶
- Samma grundidé som i många andra delar av ingenjörskonsten
- Lättare att lösa ett mindre och avgränsat problem än ett stort, komplext problem
- Exempel
- all konstruktion...
- hus
- bilar
- telefoner
- datorer
Program- och dataabstraktion¶
- Programabstraktion
- nedbrytning av uppgifter och processer
- Dataabstraktion
- nedbrytning av hur information är strukturerad
Bygga upp ett program med hjälp av funktioner¶
- Istället för att ha en funktion som gör allt
- identifiera mönster
- deluppgifter som förekommer på flera olika ställen i ett program
- Skriv en funktion för varje deluppgift
- Uppdelningen kan vara hierarkisk:
- Problem A består av delproblemen B och C
- Problem B består av delproblemen E, F och G
- Problem C består av delproblemen H, E och I
Välj beskrivande variabelnamn...¶
i = ""
while i != 'q':
i = input("Skriv något: ")
p = None
h = False
for c in i:
if p and p == c:
h = True
p = c
if h:
print("Det du skrev har upprepade bokstäver i sig!")
else:
print("Det finns inga upprepade bokstäver där.")
print("Hej då.")
Välj beskrivande variabelnamn...¶
user_input = ""
while user_input != 'q':
user_input = input("Skriv något: ")
prev_char = None
has_repeated = False
for curr_char in user_input:
if prev_char and prev_char == curr_char:
has_repeated = True
prev_char = curr_char
if has_repeated:
print("Det du skrev har upprepade bokstäver i sig!")
else:
print("Det finns inga upprepade bokstäver där.")
print("Hej då.")
Vi kan skapa egna abstraktioner med t.ex. funktioner¶
def has_repeated_char(s):
prev_char = None
for curr_char in s:
if prev_char and prev_char == curr_char:
return True
prev_char = curr_char
return False
user_input = ""
while user_input != 'q':
user_input = input("Skriv något: ")
if has_repeated_char(user_input):
print("Det du skrev har upprepade bokstäver i sig!")
else:
print("Det finns inga upprepade bokstäver där.")
print("Hej då.")
Kommentarer kan göra det lättare att förstå koden, men bara om de stämmer!¶
def has_repeated_char(s):
"""Returnera True om upprepade tecken finns i s, annars False."""
prev_char = None
for curr_char in s:
# Kolla om föregående tecken är samma som aktuellt tecken.
if prev_char and prev_char == curr_char:
return True
prev_char = curr_char
return False
# Fråga användaren om ett ord och berätta om det innehåller upprepade tecken
# eller inte.
user_input = ""
while user_input != 'q':
user_input = input("Skriv något: ")
if has_repeated_char(user_input):
print("Det du skrev har upprepade bokstäver i sig!")
else:
print("Det finns inga upprepade bokstäver där.")
print("Hej då.")
Exempel (skiss)¶
def ta_emot_kommando():
satser
return kommando
def kommando1():
satser
def kommando2():
satser
def utför_kommando(kommando):
satser
def main():
while True:
kommando = ta_emot_kommando()
utför_kommando(kommando)
Exempel (skiss)¶
def ladda_ordlistor():
satser
def ladda_ordlista(ordlista):
satser
def autocomplete_strategi1():
satser
def autocomplete_strategi2():
satser
def autocomplete(strategi, ord, ordlistor)
satser
def välj_strategi():
satser
def main():
ordlistor = ladda_ordlistor()
strategi = välj_strategi()
while True:
ord = input("Skriv ett ord: ")
if ord != "q":
kompletterat_ord = autocomplete(strategi, ord, ordlistor)
print(kompletterat_ord)
Läsa från textfil¶
Läsa data från textfil¶
- Läsning sker sekventiellt
- Olika strategier
- hela filen som en textsträng
- en rad i taget, en rad → en sträng
- hela filen som en lista, varje rad blir ett element i en lista
Förberedelser innan läsning¶
- Filen måste öppnas för läsning
- Liknelse: undersöka innehåll i en låda från en lagerlokal
- ange vilken låda - ange sökväg till filen
- öppna låda för att plocka ut saker - öppna filen i "läsläge"
- plocka fram innehåll - läs från fil
Läsa in information från en fil¶
- Funktionen
open
tar in en sträng (namn på fil), och öppnar filen och returnerar den öppna filen (speciell datatyp)
file = open(filnamn)
file = open(filnamn, 'r') # read - endast läsning
file = open(filnamn, 'w') # write - skriva över
file = open(filnamn, 'a') # append - lägga till
Läsa in information från en fil¶
- Metoden
.readlines
läser innehållet i filen och returnerar det som en lista av strängar.- (metod: funktion som sitter ihop med ett värde)
file = open("hemligt.txt")
contents = file.readlines()
Stänga fil¶
- Vi stänger en fil när vi är klara med den (praxis, för att undvika diverse problem)
file = open("data.csv")
contents = file.readlines()
file.close()
Funktionen repr¶
repr
returnerar sträng inklusive citattecken för att indikera att det är en sträng
In [ ]:
print(True)
print("True")
print(repr(True))
print(repr("True"))
729G46 Informationsteknologi och programmering Tema 2, Föreläsning 1-2 Johan Falkenjack, johan.falkenjack@liu.se