# Kursolle - Pluggpapper summering
###### tags: `programmering` `exam`

## Moment05 - Funktioner och datalagring

Funktioner och datalagring hjälper till att skapa struktur i applikationer. Funktioner används för att samla beräkningar och kan lagras i separata .py-filer. I detta avsnitt fokuserar vi på att läsa, manipulera och skriva data till textfiler (.txt) med Python.
Som avslutning får du bygga en bankapplikation.

- [ ] 55.1 Funktioner
Funktioner är koddelar som liknar de som är i matematiken, du kan skicka in och sen få ut tal till exempel. Funktioner är ett begrepp och har många användningsområden:

Upprepa kod, generalisera kod eller printa till exempel, samt retunera.

De är användbara för uppgifter som ska göras flera gånger. En funktion ska göra en sak, och vi kan använda inparametrar för att skicka data till funktionen.

- [ ] 5.1.1 Funktionsanrop
För att anropa en funktion, skriv dess namn efter att ha definierat den. Exempel: `hello_world().`

- [ ] 5.1.2 Inparametrar
Inparametrar låter en funktion göra mer än att bara skriva ut samma sak. De kan vara av vilken datatyp som helst.

- [ ] 5.1.2.1 Lokala vs globala variabler
Lokala variabler existerar endast inuti funktionen, medan globala variabler finns utanför. De påverkas inte av varandra såvida vi inte gör ett aktivt val. Man bör aldrig använda `global` variabler, här är ett exempel från stackoverflow.

> Global variables are bad in any programming language.
> However, global constants are not conceptually the same as global variables; global constants are perfectly harmless. In Python the distinction between the two is purely by convention: CONSTANTS_ARE_CAPITALIZED and globals_are_not.
> The reason global variables are bad is that they enable functions to have hidden (non-obvious, surprising, hard to detect, hard to diagnose) side effects, leading to an increase in complexity, potentially leading to Spaghetti code.

- [ ] 5.1.3 Returvärde
För att få ut det beräknade värdet i en funktion kan vi använda return.

- [ ] 5.1.4 Funktioner i separat fil
Att lägga funktioner i en separat fil, functions.py, kan öka läsbarheten. Det finns olika sätt att importera och använda funktioner från en annan fil, t.ex. import functions, from functions import * och from functions import hello_world as hello.

- [ ] 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 med givna sidor."""
  return sida1 * sida2

- [ ] 5.2 Datalagring
Datalagring är viktigt för att hantera data i applikationer, exempelvis loggning eller analys av experimentdata. Textfiler kan lagras med olika ändelser, men vi fokuserar på ".txt". Det finns flera tekniker för datalagring såsom XML, JSON, databaser och API:er, men de tas upp i senare kurser. Data läst från en textfil är av datatypen string om den inte konverteras till annan typ, exempelvis heltal med int().

- [ ] 5.2.1 Läsa från fil
För att läsa från en textfil måste den först öppnas i vår .py fil. Vi rekommenderar att använda 'with open()' eftersom det säkerställer att filen stängs korrekt. Det finns flera metoder för att läsa och skriva ut data från en textfil, exempelvis dumpad utskrift, radvis läsning, lagring i en lista eller flera listor.

- [ ] 5.2.1.1 Dumpad utskrift
Enklaste sättet att skriva ut data från en fil är att använda 'print(f.read())'.

- [ ] 5.2.1.2 Läsa radvis från fil
För mer kontroll kan vi använda en for-loop för att arbeta rad för rad, exempelvis 'for rad in f: print (rad, end='')'.

- [ ] 5.2.1.3 Lagra textfil i en lista
Det är ofta användbart att lagra data från en textfil i en lista för att sedan bearbeta den utan att påverka textfilen.

- [ ] 5.2.1.4 Lagra textfil i flera listor
Om en textfil innehåller flera delar, kan vi dela upp den med hjälp av en delimiter och använda '.split(avdelare)' för att lagra varje del i olika listor.

- [ ] Uppgifter: m05u08 och m05u09
I dessa uppgifter ska du arbeta med en textfil med provpoäng och utföra olika beräkningar samt lagra data i listor.

1. Vi kör funktionen `times`
2. Vi skickar upp talen 10 och 9
3. a sätts till 10 och b sätts till 9
4. Vi sätter c likamed a gånger b och då
5. Vi skickar tillbaka svaret på detta, i vårt fall är det 10*9 = 90
6. 90 skrivs ut


---

### Uppgift 1

||Check if a string contains a substring:||

||my_string = "Hello, World!"
if "World" in my_string:
print("Found")
else:
print("Not found")||

### Uppgift 2
||Convert a string to lowercase:||

||my_string = "Hello, World!"
lower_string = my_string.lower()
print(lower_string)||

### Uppgift 3

||Get the length of a string:||

||my_string = "Hello, World!"
length = len(my_string)
print(length)||

### Uppgift 4
||Add two numbers together:||

||num1 = 3
num2 = 5
sum = num1 + num2
print(sum)||

### Uppgift 5

||Round to two decimals (3.14159) ||

||num = 3.14159
rounded_num = round(num, 2)
print(rounded_num)||

### Uppgfit 6

||Generate a random integer between two numbers:||

||import random
num = random.randint(1, 10)
print(num)||

### Uppgfit 7
||Sort a list of strings alphabetically:||

||my_list = ["apple", "banana", "cherry", "date"]
my_list.sort()
print(my_list)||

### Uppgift 8

||Check if a number is even or odd:||

||num = 7
if num % 2 == 0:
print("Even")
else:
print("Odd")||

### Uppgift 9
||Create a dictionary with key-value pairs:||

||my_dict = {"apple": 2, "banana": 3, "cherry": 1}
print(my_dict)||

### Uppgift 10

||Calculate the area of a rectangle:||

||width = 5
height = 8
area = width * height
print(area)||

### Uppgift 11
||Sort a list of numbers in descending order:||

||my_list = [4, 8, 2, 10, 5]
my_list.sort(reverse=True)
print(my_list)||

### Uppgift 12
||my_list = [4, 8, 2, 10, 5]
if 8 in my_list:
print("Found")
else:
print("Not found")||

### Uppgift 13
||Calculate the factorial of a number:||

||num = 5
factorial = 1
for i in range(1, num+1):
factorial *= i
print(factorial)||

### Uppgift 14

||Count the number of occurrences of a substring in a string:||

||my_string = "Hello, World!"
substring = "l"
count = my_string.count(substring)
print(count)||

### Uppgift 15

||Split a string into a list of words:||

||my_string = "Hello, World!"
word_list = my_string.split()
print(word_list)||

### Uppgift 16
||Join a list of strings into a single string:||

||my_list = ["Hello", "World", "!"]
my_string = " ".join(my_list)
print(my_string)||