5. Moment05 - Funktioner och datalagring

Funktioner och datalagring är bra redskap för att skapa en bättre och tydligare struktur i applikationer. Funktioner används för att samla exempelvis beräkningar som ska göras flera gånger i koden under ett funktionsnamn. Det är också möjligt att skapa separata .py filer där alla funktioner som används i en kod samlas.

I avsnittet om datalagring kommer vi titta lite på hur vi med hjälp av Python kan läsa, manipulera och skriva data till textfiler (.txt). Detta kommer vara ett ytterligare steg i vår resa att arbeta med applikationer som består av flera olika filer som påverkar varandra.

Info

Till detta moment finns en sida med lösningsförslag och videoklipp.

5.1 Funktioner

Vi har tidigare tittat på några inbyggda funktioner och det finns väldigt många sådana men vi kan också skapa egna funktioner.

En funktion är en del kod som utför någon beräkning, utskrift eller något liknande som vi behöver i vår kod. En funktion är perfekt att använda till saker som skall göras flera gånger, behöver vi ändra något så ändras det bara på ett ställe och slår igenom i hela applikationen. I vissa programmeringsspråk pratar vi om metoder men det är samma sak som en funktion.

Grundtanken är att en funktion skall göra en sak, behöver vi utföra två beräkningar är det ofta bättre att ha en funktion till varje beräkning.

Varför vill vi ha två funktioner? Tänk dig att vi skall skapa funktioner för att beräkna area och omkrets på en cirkel. I detta exempel kan vi skapa en gemensam funktion som räknar ut båda sakerna samtidigt och skriver ut resultatet, men sedan vill vi bara beräkna arean i en annan uppgift och har vi då en sammansatt funktion så kan vi inte använda den utan måste skapa en ny. Av denna anledning så är det enklare att skapa två funktioner som vi anropar.

5.1.1 Funktionsanrop

Låt oss återvända till grunderna och den klassiska applikationen Hello World och bygga om applikationen så att det innehåller en egen funktion, hello_world().

Kodexempel: Hello World-funktionen

def hello_world():
  print('Hello, World!')

För att definiera en ny funktion börjar vi med att skriva def, följt av funktionens namn. Lägg märke till att likt loopar måste vi ha ett : i slutet på raden med funktionsnamnet och allt som ska tillhöra funktionen måste indenteras.

Skulle vi köra applikationen som det ser ut nu kommer ingenting att hända. Detta beror på att funktionen endast är definierad, men aldrig anropas.

Kodexempel: Hello World-funktionen med funktionsanrop

def hello_world():
  print('Hello, World!')

hello_world()

Utskrift

Hello, World!

Var noga med att inte anropa funktioner innan de definierats, nedanstående exempel producerar en error:

Kodexempel: Hello World-funktionen med funktionsanrop

hello_world()

def hello_world():
  print('Hello, World!')

Error

NameError: name 'hello_world' is not defined

Uppgift: m05u01

Skapa en funktion som skriver ditt namn, din klass och din skola. Anropa sedan funktionen.

5.1.2 Inparametrar

Vi kan börja se en ordentlig fördel med funktioner om vi tillåter inparametrar, helt enkelt att en och samma funktion kan anropas med flera olika in-värden. Inparametrar kan vara av vilken datatyp som helst, så det är viktigt att du kommenterar vad dina funktioner gör och vilken datatyp funktionen förväntar sig.

Ska vi i en applikation utföra addition av två tal och skriva ut svaret upprepade gånger kan det vara fördelaktigt att skapa en funktion som beräknar summan.

Kodexempel: En enkel summafunktion

def summa(a, b):
  c = a + b
  print('{} + {} = {}'.format(a, b, c))

summa(1, 3)
summa(1.5, 3.14)

a = 2
b = -5
summa(a, b)

summa(4567, 8901)

x = 2
y = 13
summa(x, y)

Utskrift

1 + 3 = 4
1.5 + 3.14 = 4.640000000000001
2 + -5 = -3
4567 + 8901 = 13468
2 + 13 = 15

5.1.2.1 lokal vs globala variabler (lite överkurs)

I funktionen summa(a, b) är variablerna a och b lokala. Med detta menas att a och b endast existerar inuti funktionen och om vi har skapat variablerna a och b utanför funktionen är dessa globala variabler. De lokala och globala variablerna påverkas inte av varandra så länge vi inte gör ett aktivt val.

Här följer två exempel på en funktion som beräknar arean av rektanglar. Det första exemplet använder de lokala variablerna sida1 och sida2 och det andra exemplet saknar inparametrar och arbetar istället direkt med de globala variablerna sida1 och sida1.

Kodexempel: En konstig areaberäknare, version 1

# Här påverkar funktionens variabler sida1 och sida2  inte globala variablerna
# sida1 och sida2

sida1 = 4
sida2 = 5

def rektangel_area(sida1, sida2):
  sida1 += 1
  sida2 += 1
  area = sida1 * sida2
  print(area)

print('Rektangelns area med sidorna {} och {} är: '.format(sida1, sida2), end='')
rektangel_area(sida1, sida2)
print('Rektangeln har sidorna {} och {}'.format(sida1, sida2))

Utskrift

Rektangelns area med sidorna 4 och 5 är: 30
Rektangeln har sidorna 4 och 5

Kodexempel: En konstig areaberäknare, version 2

# Här påverkar funktionen de globala variablerna sida1 och sida2

sida1 = 4
sida2 = 5

def rektangel_area():
  # I funktionen anges global före variabelnamnet för att komma åt variabler
  # som deklarerats utanför funktionen.
  global sida1
  global sida2
  sida1 = sida1 + 1
  sida2 = sida2 + 1
  area = sida1 * sida2
  print(area)

print('Rektangelns area med sidorna {} och {} är: '.format(sida1, sida2), end='')
rektangel_area()
print('Rektangeln har sidorna {} och {}'.format(sida1, sida2))

Utskrift

Rektangelns area med sidorna 4 och 5 är: 30
Rektangeln har sidorna 5 och 6

Var försiktig de gånger du väljer att låta funktioner bearbeta globala variabler. Vill du vara helt säker på att de inte påverkar varandra så ge variablerna inne i funktionen och i programmet olika namn.

Uppgift: m05u02

Gå tillbaka till inlämningsuppgiften moment02a och arbeta om applikationen så att beräkningar och utskrifter för area och omkretsen utförs i två olika funktioner.

5.1.3 Returvärde

I funktionerna summa och rektangel_area är det främsta syftet kanske inte att skriva ut någon snygg formaterad text, utan snarare att utföra någon beräkning.

Vill vi bara få ut det beräknade värdet i en funktion kan vi använda return.

Beräkna area av rektangel

a = 3
b = 4
c = 5
d = 6

def rektangel_area(sida1, sida2):
  area = sida1 * sida2
  return area

print('En rektangel med sidorna {} och {} har arean {}'.format(a, b, rektangel_area(a, b)))
print('och en rektangel med sidorna {} och {} har arean {}'.format(c, d, rektangel_area(c, d)))

rektanglar_summa = rektangel_area(a, b) + rektangel_area(c, d)
print('Summan av rektanglarnas areor är {}'.format(rektanglar_summa))
  

Utskrift

En rektangel med sidorna 3 och 4 har arean 12
och en rektangel med sidorna 5 och 6 har arean 30
Summan av rektanglarnas areor är 42

Uppgift: m05u03

Arbeta om funktionerna i uppgift m05u02 så att det endast är värdet på cirkelns area och omkrets som returneras från funktionerna.

Uppgift: m05u04 (extra)

Arbeta om inlämningsuppgift m03 (den svåraste nivån du gjorde) och skapa funktioner som utför de olika skatteberäkningarna i uppgiften.

5.1.4 Funktioner i separat fil

Vi ska nu ta första klivet från att endast jobba i en fil per applikation och skapa en separat fil, functions.py, där vi lägger in våra funktioner.

Detta är ett smidigt sätt att snygga till våra filer och förhoppningsvis öka läsbarheten.

Kodexempel: functions.py

def hello_world():
    print('Hallå, världen!')

def summa(tal1, tal2):
    return tal1 + tal2

def division(täljare, nämnare):
    return täljare / nämnare

def rektangel_area(sida1, sida2):
    if sida1 == sida2:
        area = sida1**2
        return area
    else:
        area = sida1 * sida2
        return area

Det viktiga att tänka på är att alla filer som tillhör samma projekt eller applikation läggs i samma mapp. I det här fallet ligger filen functions.py i samma mapp som test.py.

Här följer tre olika sätt att använda functions.py från test.py.

Kodexempel: Variant 1 av test.py

# För att komma åt funktioner från functions.py måste vi
# skriva functions.funktionens_namn()
import functions

functions.hello_world()

Kodexempel: Variant 2 av test.py

# Importerar alla funktioner från functions.py och vi
# behöver inte använda functions.funktionens_namn()
from functions import *

hello_world()

Kodexempel: Variant 3 av test.py

# Importerar endast funktionen hello_world och ger den
# Importerar funktionerna hello_world och rektangel_area
# och ger funktionerna nya anropsnamn
from functions import hello_world as hello
from functions import rektangel_area as rekt

hello()
print(rekt(5, 3))

Uppgift: m05u05

Flytta ut alla dina funktioner från m05u03 i en separat fil. Importera sedan funktionerna på valfritt sätt.

Filmad genomgång av funktioner [klicka för att visa]

5.1.5 Dokumentation av funktioner

När vi skriver egna funktioner börjar dokumentationen bli allt viktigare, särskilt när du senare i kursen kommer arbeta på projekt som sträcker sig över längre tid.

Det kan vara bra att skaffa sig en god vana i att dokumentera sina funktioner tydligt men kortfattat.

5.1.5.1 Enkelt sätt att dokumentera funktioner

Innan vi går in på pythonspecifika sätt att kommentera och dokumentera funktioner så kan det vara bra att se på ett allmänt exempel. Detta sätt att kommentera fungerar alltid.

Kodexempel: Enkel dokumentation av funktioner

# area_kvadrat
# funktionen beräknar arean av en kvadrat
# inparameter: sida, kvadratens sida
# returvärde: kvadratens area
def area_kvadrat(sida):
  area = sida ** 2
  return area

Det viktigaste är att ni kommenterar koden och funktionerna, sedan vilken teknik ni använder er av har underordnad betydelse. Tänk på att du snart kommer bygga större projekt med många funktioner som ligger i en egen fil, då är det viktigt att kommentera/dokumentera dessa funktioner på ett bra sätt.

I en enklare och kortare funktion så räcker det ofta med denna typ av dokumentation. Givetvis är det alltid bra att komplettera med kommentarer för koden också.

5.1.5.2 Pythons egen struktur

I python finns tydliga rekommendationer kring hur saker dokumenteras, bland annat funktioner. Detta är inget unikt med Python utan de flesta programmeringsspråk har sin standard. Ofta vill man använda en standard för att sedan kunna generera dokumentationer av dessa kommentarer. Nedan följer några exempel samt en checklista att följa när du dokumenterar dina funktioner.

Kodexempel: Funktionsdokumentation flera rader

def division(täljare, nämnare):
    """Beräknar kvoten mellan två tal.
 
    Nämnaren får ej vara 0.
    """

    return täljare / nämnare

I exemplet ser vi att på första raden ges en kort förklaring på vad funktionen gör. Nästa rad lämnas tom för att markera att sammanfattningen är slut och på den tredje raden står det en kort information om att nämnaren ej får anges som 0.

Märk att i sammanfattningen ska inte funktionens namn anges. Sammanfattningen ska dessutom inte vara för teknisk.

Kodexempel: Fler dokumentationsexempel

def hello_world():
    """Skriver ut hallå världen."""

    print('Hallå, världen!')

def summa(tal1, tal2):
    """Beräknar summan av två tal."""

    return tal1 + tal2

def rektangel_area(sida1, sida2):
    """Beräknar arean av en rektangel."""

    if sida1 == sida2:
        area = sida1**2
        return area
    else:
        area = sida1 * sida2
        return area
Checklista funktionsdokumentation
  • Inled med stor bokstav, avsluta med punkt. Bygg upp dokumentationen i en sträng med 3 dubbelfnuttar.
  • Den första raden är en sammanfattning / kort förklaring av funktionen.
  • Den andra raden ska vara tom.
  • Från rad tre kan du börja skriva detaljer om hur funktionen fungerar, dess begränsningar osv.

Mer läsning för den intresserade.

5.5.2.2 Pythons dokumentation i pycharm

Om du använder pycharm och börjar skriva tre citationstecken och trycker på enter så kommer du få fram hela funktionens struktur inom kommentaren. Då kan det se ut på följande sätt;

Kodexempel: pycharms dokumentationshjälp

def area_kvadrat(sida):
    """ Funktion som beräknar arean på en kvadrat
 
    :param sida: kvadratens sida
    :return: kvadratens area
    """
    area = sida ** 2
    return area

Där :param sida: står för den inparameter som finns till funktionen och :return: står för vad som skall returneras från funktionen.

Uppgift: m05u06

Fortsätt på m05u05 och kommentera dina funktioner enligt någon av exemplen för att kommentera funktioner.

Uppgift: m05u07

Filen m05u07.py får bara innehålla följande:

Filen m05u07.py

from m05u07_funktioner import *
 
julgran(10)
tomten()

Din uppgift är att skapa och arbeta med filen m05u07_funktioner.py så att m05u07.py producerar följande utskrift:

Kodexempel: Utskriften

*
**
***
****
*****
******
*******
********
*********
**********

Ho, Ho, Ho!
Jullovet är nära

Hjälp [klicka för att visa]

Om man vill skriva ut flera tecken, eller en sträng, som är lika så går det också att skriva ut på följande sätt;

Kodexempel: multiplicerad utskrift

print("text"*3)
print("X"*5)

Utskrift

texttexttext
XXXXX

Läge att träna på aktivitetsdiagram och pseudokod om du inte har lyckats med detta tidigare?

Tillägg (svårare) [klicka för att visa]

I grunduppgiften är granen du producerar inte så snygg, den är ju bara halv och saknar en fot.
Redigera funktionen julgran så en ordentlig julgran ritas ut.

Utskrift

         *
        ***
       *****
      *******
     *********
    ***********
   *************
  ***************
 *****************
*******************
        ***
        ***

Ho, Ho, Ho!
Jullovet är nära

5.2 Datalagring

Datalagring är bra att ha koll på av flera olika anledningar. Utvecklare kan ibland vilja skicka ut felmeddelande och variabelvärden i en loggfil. En fysiker som genomfört ett experiment för att bestämma hur mycket vi påverkas av gravitationskraften från jorden här i Alingsås har samlat in några hundra olika datapunkter i ett textdokument som nu ska analyseras. Då är det bra att ha koll på hur vi kan underlätta filhantering och arbeta med datalagring i Python.

En fil på en dator är en sammanhängande mängd data som lagras under ett specifikt namn. Vi kan välja att skapa en fil med massa olika ändelser men eftersom vi i början väljer att skapa textfiler så är det lämpligt att ge våra filer ändelsen ".txt".

När vi läser in data från textfiler är det viktigt att komma ihåg att all data som läses in är av datatypen string om vi inte aktivt gör något åt det. Till exempel genom att utnyttja den enkla konverteringen int() för att konvertera till heltal.

5.2.1 Läsa från fil

Filen vi kommer arbeta med heter datatyper.txt och är en enkel textfil som innehåller fyra rader text. Den här filen kommer vi arbeta med under hela avsnitt 5.2.1

datatyper.txt

string | "@", "Johan", 'Sebastian' | Alla texter och tecken. Markeras med dubbelfnutt(") eller enkelfnutt (')
int | 1, 7, -9 | Står för integer och lagrar heltal
float | 0.0, 4.5, -9.7 | Flyttal, lagrar decimaltal, notera decimalpunkt enligt engelskspråkig standard
boolean | True, False | Boolesk variabel, lagrar sant eller falskt, ofta ett resultat av ett uttryck som (1 < 2)

Innan vi tittar på olika sätt att läsa och skriva ut data från datatyper.txt måste vi öppna filen i vår .py fil med namnet test.py. I exemplet kan du se två alternativ.

Kodexempel: metod 1

# Öppnar filen med open('filnamnet') och sparar i en variabel
f = open('datatyper.txt')

# Här skriver vi kod som läser data från textfilen datatyper.txt

# Stänger filen med .close(). Glömmer du det här riskerar du stöta på allehanda problem med att redigera textfilen.
f.close()

Kodexempel: metod 2

# Med kommandot with håller python filen öppen filen tills det att programmet avslutas
# eller vi hamnar utanför with.
# Använder vi with kan vi alltid vara säkra på att filen stängs korrekt i slutet av programmet,
# även om programmet avslutas oväntat på grund av en error.
with open('datatyper.txt') as f:

  # Här skriver vi kod som läser data från textfilen datatyper.txt.
  # Glöm inte att indentera!

# Skriver vi kod här har python stängt filen (utanför with).

När vi arbetar med filer i Python är det rekommenderat att använda metod 2, främst för att där säkerställs att filen stängs korrekt oavsett vad som händer i applikationen.

5.2.1.1 Dumpad utskrift

Det enklaste sättet att skriva ut data från en fil är helt enkelt att skriva ut allt som filen innehåller på en gång.

Kodexempel: Dumpad utskrift

with open('datatyper.txt') as f:
    print(f.read())

Utskrift

string | "@", "Johan", 'Sebastian' | Alla texter och tecken. Markeras med dubbelfnutt(") eller enkelfnutt (')
int | 1, 7, -9 | Står för integer och lagrar heltal
float | 0.0, 4.5, -9.7 | Flyttal, lagrar decimaltal, notera decimalpunkt enligt engelskspråkig standard
boolean | True, False | Boolesk variabel, lagrar sant eller falskt, ofta ett resultat av ett uttryck som (1 < 2)

5.2.1.2 Läsa radvis från fil

Vill vi ha lite mer kontroll kan vi med hjälp av for-loopar arbeta med textfilen rad för rad.

Kodexempel: Arbeta med textfilen rad för rad

with open ('datatyper.txt') as f:
    for rad in f:
        print (rad, end='')

Utskrift

string | "@", "Johan", 'Sebastian' | Alla texter och tecken. Markeras med dubbelfnutt(") eller enkelfnutt (')
int | 1, 7, -9 | Står för integer och lagrar heltal
float | 0.0, 4.5, -9.7 | Flyttal, lagrar decimaltal, notera decimalpunkt enligt engelskspråkig standard
boolean | True, False | Boolesk variabel, lagrar sant eller falskt, ofta ett resultat av ett uttryck som (1 < 2)

Här står det end='' i utskriften och det beror på att print()-funktionen i normala fall ger en radbrytning. Nu finns det dessutom en radbrytning i filen vilket gör att det skulle bli dubbla radbrytningar.

5.2.1.3 Lagra textfil i en lista

Det är ofta relevant att inte bara läsa från en textfil, utan att lagra i en lista för att senare i programmet kunna arbeta med listan utan att påverka textfilen. Sparar vi data i en lista kan vi dessutom utnyttja listfunktioner som sort() för att snabbt sortera värden i storleksordning.

Kodexempel: Lagra i en lista

datatyp = []

with open('datatyper.txt') as f:
    for rad in f:
        datatyp.append(rad)

# Här har textfilen stängts men eftersom raderna sparats i en lista kan vi komma åt innehållet.
for text in datatyp:
    print(text)

Utskrift

string | "@", "Johan", 'Sebastian' | Alla texter och tecken. Markeras med dubbelfnutt(") eller enkelfnutt (')

int | 1, 7, -9 | Står för integer och lagrar heltal

float | 0.0, 4.5, -9.7 | Flyttal, lagrar decimaltal, notera decimalpunkt enligt engelskspråkig standard

boolean | True, False | Boolesk variabel, lagrar sant eller falskt, ofta ett resultat av ett uttryck som (1 < 2)

5.2.1.4 Lagra textfil i flera listor

I datatyper.txt finns det tydliga tecken på att varje rad innehåller tre olika delar: namnet på en datatyp följt av exempel som följs av en förklaring. Varje del avgränsas med en så kallad delimiter, en avdelare. I datatyper.txt har | använts som avdelare.

Det finns ett värde i att i en och samma textfil använda samma avdelare genom hela filen. Då kan vi nämligen smidigt dela upp de olika delarna i olika listor. Enklaste sättet att dela upp raderna i en textfil efter deras avdelare är att använda .split(avdelare) som delar upp strängen i en lista.

Kodexempel: Lagra i flera listor

datatyp = []
ex_datatyp = []
info_datatyp = []

with open('datatyper.txt') as f:
    for rad in f:
        rad = rad.split('|')

        # Tar bort eventuella inledande mellanslag med .lstrip(' ')
        datatyp.append(rad[0].lstrip(' '))
        ex_datatyp.append(rad[1].lstrip(' '))
        info_datatyp.append(rad[2].lstrip(' '))

for i, t in enumerate(datatyp):

    # Vänsterformaterar text och skapar lagom mellanrum med {:<15}
    print('{:<15}{}
{:<15}{}
{:<15}{}'
          .format('Datatyp:', t, 'Exempel:', ex_datatyp[i], 'Förklaring:', info_datatyp[i]))

Utskrift

Datatyp:       string
Exempel:       "@", "Johan", 'Sebastian'
Förklaring:    Alla texter och tecken. Markeras med dubbelfnutt(") eller enkelfnutt (')

Datatyp:       int
Exempel:       1, 7, -9
Förklaring:    Står för integer och lagrar heltal

Datatyp:       float
Exempel:       0.0, 4.5, -9.7
Förklaring:    Flyttal, lagrar decimaltal, notera decimalpunkt enligt engelskspråkig standard

Datatyp:       boolean
Exempel:       True, False
Förklaring:    Boolesk variabel, lagrar sant eller falskt, ofta ett resultat av ett uttryck som (1 < 2)

Uppgift: m05u08

Skapa en fil i ditt projekt som du döper till provpoäng.txt kopiera sedan filens innehåll nedan till den filen du skapat. Filen innehåller 25 tal från 1 till 100 och lägg filen i samma mapp där du arbetar med uppgifter på moment 05. Exempelinnehållet skapas om ifall du laddar om sidan.

  1. Skriv ut talen sorterat från det lägsta till högsta.
  2. Skriv ut hur många tal som finns i listan (utgå ifrån att du inte vet hur många tal provpoäng.txt innehåller).
  3. Skriv ut medelvärdet av talen.

provpoäng.txt [klicka för att visa]

4
34
36
93
86
78
9
73
93
26
20
20
67
46
68
1
80
46
44
99
95
17
96
90
41

Uppgift: m05u09 (svårare)

Gå in och redigera provpoäng.txt, du ska lägga till ett namn till varje provpoäng enligt formatet:
Sebastian | 100 (Avdelaren får du med option+7)

  1. Skriv ut provpoängen och tillhörande elev sorterat från det lägsta till högsta.
  2. Skriv ut medelvärdet av provpoängen.
  3. Skriv ut eleven som fick det sämsta respektive bästa provresultatet.

provpoäng.txt [klicka för att visa]

Xerxes|15
Älva-My|77
Bertil|92
Åsa|78
Nicholas|67
Nicholas|91
Nicholas|10
Levi|63
Bertil|3
Theodor|42
Hedvig|9
Bertil|50
Franz|1
Liridon|5
Theodor|98
Bertil|86
Willy|89
Susan|96
Älva-My|82
Bertil|78
Mira|54
Rut|73
David|85
Xerxes|15
Katarina|55

5.2.2 Skriva till fil

I python kan vi inte bara läsa in data från filer, vi kan också skriva till filer och skapa nya textdokument.

Vi kan i funktionen open() ange vad vi vill kunna göra med filen på följande sätt:

  • open('filnamn') och open('filnamn', 'r') anger båda att filen öppnas i läsläge. I detta läge kan vi endast läsa från filen.
  • open('filnamn', 'w') anger att vi öppnar filen i write, skrivläge. Finns inte filen skapas en ny fil och finns filen redan skriver vi över den.
  • open('filnamn', 'a') anger att vi öppnar i skrivläge utan att skriva över befintlig data. a står för append och allt vi skriver till filen läggs till i slutet.

Kodexempel: Skriva över datatyper.txt

with open('datatyper.txt', 'w') as fw:
    fw.write('1 2 3 4 5\n6 7 8 9 0')

with open('datatyper.txt', 'r') as fr:
        print(fr.read())

Utskrift

1 2 3 4 5
6 7 8 9 0

Pseudokod till kodexempel: Skriva över datatyper.txt

  • Öppna eller skapa datatyper.txt om den inte existerar i skrivläge. Sätt filens storlek till 0 byte.
  • Skriv '1 2 3 4 5 6 7 8 9 0' till datatyper.txt
  • Spara och stäng datatyper.txt
  • Öppna datatyper.txt i läsläge
  • Skriv ut allt innehåll i datatyper.txt
  • Stäng datatyper.txt

Uppgift: m05u10

Förklara så noggrant du kan vad som händer i följande kod. Fundera även hur datatyper.txt ser ut om den öppnas i en textredigerare efter koden körts.

Kod till uppgift m05u10

with open('datatyper.txt', 'w') as fw:
  fw.write('''1 2 3
4 5 6
7 8 9
''')
  fw.write('
Här var det rutigt!')

with open('datatyper.txt', 'r') as fr:
    print(fr.read())

Uppgift: m05u11

Den här uppgiften använder samma information som uppgift m04u02.

Ulf har satt in 10 000kr på ett konto med 3 % årlig ränta, hur mycket pengar finns på kontot efter 15 år? Inga fler insättningar görs.
Spara följande information i en textfil för varje år:

  • Det aktuella året (år 1 - 15).
  • Hur mycket pengar som finns på kontot.
  • Den totala procentuella utvecklingen på kontot.

Se till att använda en valfri men tydlig avdelare (delimiter) mellan varje punkt. Avsluta med att skriva ut innehållet i filen på skärmen.

Uppgift: m05u12 (svårare)

Bygg vidare på m05u09. När du sorterat poängen, plockat ut medelvärdet och eleverna med sämst och bäst provresultat ska all den här informationen skriva över den befintliga informationen i provpoäng.txt.

För att kontrollera att allt ser bra ut ska du till slut läsa in provpoäng.txt och skriva ut hela filens innehåll.

5.3 Bankapplikation

Uppgift bankapplikation

Uppgiften är att skapa en fullt fungerande applikation som simulerar ett bankkonto. Det skall gå att sätta in pengar, ta ut pengar samt visa upp alla transaktioner. Transaktionerna skall lagras i en fil och saldot på kontot skall beräknas. Vid skapandet av ett bankkonto får kunden 1000kr insatt på kontot. Insättning och uttag får vara vilket belopp som helst, fast vi jobbar bara med hela kronor i grunduppgiften.

Hjälp tutorial [klicka för att visa]

Inlämningsinstruktioner

Innan du lämnar in uppgiften kolla att följande saker är gjorda;

  • Filen med källkod har rätt namn, klass_namn_bank.py, övriga filer namnges på liknande sätt.
  • Applikationen körs utan error. Koden är rensad från testdata och ser ok ut att lämna in.
  • Källkoden är kommenterad. För din egen del se till att du kommenterar koden eftersom den hela tiden byggs på.
  • Skapa ett huvud i källkoden där du som en kommentar skriver ditt namn och klass, om du har gjort några tilläggsuppgifter utöver tutorial och sedan en kort utvärdering av lösningen/ditt arbete.

Exempel på kodhuvud

# Anders Andersson, 18TEx
# Bankapplikationen, endast tutorial
# Det var en kul och utmanade uppgift där .......
# Det som var mest utmanande var ...
# ....

Uppgift bankapplikationen, fördjupande uppgift

Om du vill fortsätta utveckla applikationen vidare så kommer här några förslag på saker som kan byggas in;

  • Anpassa applikationen för decimaltal.
  • Skapa flera konton för en användare.
  • Skapa flera användare vilket kräver någon form av inloggning. Tips: Lagra alla användare i en fil.
  • Andra tips som du själv kommer på.