Tutorial on environment

_data/navigation.yml

@@ -9,34 +9,29 @@ modules:
     prev: index
     next: variables
   variables:
-    title: Variabler
+    title: Variabler och funktioner
     path: /modules/variables/lab/instruction
     prev: overview
-    next: functions
-  functions:
-    title: Funktioner
-    path: /modules/functions/lab/instruction
-    prev: variables
     next: conditionals
   conditionals:
     title: Villkorssatser
     path: /modules/conditionals/lab/instruction
-    prev: functions
-    next: containers
-  debug:
-    title: Felsökning
-    path: /modules/debug/lecture
+    prev: variables 
+    next: iterations
+  iterations:
+    title: Upprepningar
+    path: /modules/iterations/lab/instruction
     prev: conditionals
     next: containers
   containers:
     title: Behållare
     path: /modules/containers/lab/instruction
-    prev: conditionals
-    next: files
-  exceptions:
-    title: Särfall
-    path: /modules/exceptions/lecture
-    prev: containers
+    prev: iterations
+    next: functions
+  functions:
+    title: Mer funktioner och moduler
+    path: /modules/functions/lab/instruction
+    prev: iterations
     next: files
   files:
     title: Filer

modules/classes/lab/Makefile

@@ -14,5 +14,5 @@ clean:
 	${RM} ${HTML_FILES} ${PDF_FILES}
 
 
-include ../../html.mk
+include ../../../html.mk
 

modules/classes/lab/instruction.md

@@ -1,15 +1,20 @@
 # Laboration: Klasser och objekt
 
-I förra laborationen lär vi användaren mata in ett filnamn och programmet läste 
-därefter $q$-värdena från filen och returnerade summan.
+Hittils har vi använt funktioner för att beräkna $g_n$ på olika sätt (konstant 
+$q$ och en lista med $q$-värden). Syftet med klasser (och objekt) är att de 
+bättre liknar objekt i verkligheten. Exempelvis är en talföljd väldigt lik en 
+lista, det är ju trots allt en (möjligtvis oändlig) lista med tal, men mindre 
+lik en funktion för att beräkna talen i följden.
 
-I den här laborationen ska vi förenkla hanteringen av olika geometriska summor.
+Fördelen med att representera objekt på ett bättre sätt är att det underlättar 
+för den som ska programmera. Det kan göra koden mer intuitiv, mer läsbar. Detta 
+minskar risken för fel (buggar).
 
 
 ## Uppgift
 
 Nu ska vi skriva klasser som hanterar talföljder. Låt klasserna vara en del av 
-en modul för talföljder. De ska hantera den karakteristiska egenskapen för en 
+din modul för talföljder. De ska hantera den karakteristiska egenskapen för en 
 talföljd: det ska gå att få ut det $n$:te elementet (använd 
 [`__getitem__`][getitem]).
 
@@ -33,9 +38,6 @@ def main():
   for i in range(20):
     print(f"a[{i}] = {a[i]}")
 
-  # Skriv ut summan av de första 20 elementen
-  print(f"sum(a) = {sum(a[:20])}")
-
   g1 = it.input_type(float, "g1 = ")
   q = it.input_type(float, "q = ")
   g = myseq.GeometricSequence(g1, q)
@@ -68,10 +70,25 @@ myseq.MultiplicativeSequenceFromFile("file.txt")` (som läser in en sekvens frå
 fil, likt föregående laboration) och resten av koden i exemplet ovan kommer att 
 fortsätta att fungera.
 
-För raden `sum(a[:20])` (se [här][slice-notation] för förklaring av notationen) 
-krävs att din kod hanterar [sliceobjekt][slice-docs]. Följande exempelkod är 
-bra att experimentera med:
+**Inlämning**: Lämna in en modul (`my_sequence_library.py`) som fungerar med 
+testprogrammet ovan. Den måste då innehålla klasserna `ArithmeticSequence`, 
+`GeometricSequence` och `MultiplicativeSequenceFromFile`.
 
+**Krav**: Du ska ha felhantering. Exempelvis hantera att filen inte finns, att 
+talföljden (från fil) inte har tillräckligt många element. Exempelvis om den 
+innehållet data för 12 månader, då finns inte `a[20]`.
+
+
+## Extrauppgift
+
+Hantera [slice-notation][slice-notation], exempelvis:
+```
+# Skriv ut summan av de första 20 elementen
+print(f"sum(a) = {sum(a[:20])}")
+```
+
+För raden `sum(a[:20])` krävs att din kod hanterar [sliceobjekt][slice-docs]. 
+Följande exempelkod är bra att experimentera med för att komma igång:
 ```python
 class Test:
   def __getitem__(self, key):
@@ -92,18 +109,8 @@ print(isinstance(t[4], slice))
 [slice-notation]: https://docs.python.org/3/tutorial/introduction.html#strings
 [slice-docs]: https://docs.python.org/3/library/functions.html#slice
 
-**Inlämning**: Lämna in en modul (`my_sequence_library.py`) som fungerar med 
-testprogrammet ovan. Den måste då innehålla klasserna `ArithmeticSequence`, 
-`GeometricSequence` och `MultiplicativeSequenceFromFile`.
-
-**Krav**: Du ska ha felhantering. Exempelvis hantera att filen inte finns, att 
-talföljden (från fil) inte har tillräckligt många element. Exempelvis om den 
-innehållet data för 12 månader, då finns inte `a[20]`.
-
 
-## Extrauppgift
-
-Denna uppgift är för extra utmaning och behöver inte lämnas in.
+## Ytterligare extrauppgift
 
 Implementera [`__setitem__`][setitem] för `MultiplicativeSequenceFromFile` för 
 att sätta värden. När värdena sätts ska respektive $q$-värde beräknas från 
@@ -112,3 +119,4 @@ $q$-värden till en fil som kan läsas in med `MultiplicativeSequenceFromFile`
 nästa körning.
 
 [setitem]: https://docs.python.org/3/reference/datamodel.html#object.__setitem__
+

modules/conditionals/lab/instruction.md

@@ -1,20 +1,47 @@
 # Laboration: Inmatning och styrstrukturer
 
 I denna laboration ska vi utöka programmet vi skrev i föregående laboration.
-
-I föregående laboration använde vi variablerna $a_1, d, g_1, q$ och $n$ för att 
-beräkna en aritmetisk och en geometrisk summa.
+I föregående laboration skrev vi två funktioner, en som beräknar en aritmetisk 
+summa och en som beräknar en geometrisk summa.
 
 
 ## Uppgift
 
-Låt användaren mata in värdena för $a_1, d, g_1, q$ och $n$. (I föregående 
-program skrev vi in värdena direkt i källkoden.) Efter att summorna är 
-beräknade, använd lämplig styrstruktur för att skriva ut enligt följande:
+Låt användaren mata in värdena för $a_1, d, g_1, q$ och $n$. Efter att summorna 
+är beräknade, använd lämplig styrstruktur för att skriva ut enligt följande:
 
 - "Den aritmetiska summan är störst" om den aritmetiska summan är (strikt) 
   större än den geometriska,
 - "Den geometriska summan är störst" om den geometriska är (strikt) störst,  
   eller
 - "Summorna är lika" om de är lika.
 
+Exempelvis:
+```
+Data för den aritmetiska summan:
+a_1: 1
+d: 2
+Data för den geometriska summan:
+g_1: 1.01
+q: 1.10
+Antal termer i summorna:
+n: 10
+Den aritmetiska summan är störst.
+```
+
+
+## Extrauppgift
+
+Låt programmet först fråga användaren om en summa är aritmetisk eller 
+geometrisk. På så vis kan användaren jämföra en aritmetisk summa med en 
+geometrisk eller två aritmetiska summor.
+```
+Är den första summan [a]rtimetisk eller [g]eometrisk? a
+a_1: 1.02
+d: 0.1
+Är den andra summan [a]ritmetisk eller [g]eometrisk? g
+g_1: 1.02
+q: 1.1
+Hur många termer, n? 10
+Den andra summan är störst.
+```

modules/containers/lab/instruction.md

@@ -1,52 +1,54 @@
-# Laboration: Listor, for-slingor och uppslagslistor
+# Laboration: Behållare och iterationer
 
-I denna laboration ska vi utöka programmet vi skrev i föregående laboration.
+Hittills har vi arbetat med aritmetiska och geometriska talföljder, d.v.s. att 
+$d$ och $q$ har varit konstanta. Nu ska vi fokusera på den geometriska 
+talföljden och vi ska dessutom låta värdet på $q$ variera över tid. Som vi 
+nämnt tidigare kan geometriska talföljder användas för att räkna på räntor. 
+Räntor kan dock variera över tid och det är därför vi vill låta $q$ variera. 
 
-I vårt förra program lät vi användaren mata in värdena för variablerna $a_1, d, 
-g_1, q$ och $n$, därefter beräknade vi den aritmetiska och den geometriska 
-summan och, slutligen, skrev vi ut vilken av dem som var störst.
+När vi arbetar med räntor, då är det dock de olika talen i följden som är 
+intressanta, inte summan. Vi påminner oss om definitionen för en geometrisk 
+talföljd från tidigare: Låt oss säga att det första elementet i följden är 
+$g_1$ (det ursprungliga beloppet) och kvoten är $q$ (räntan som är densamma för 
+alla månader). Då kan vi beräkna $g_n = g_1 q^{n-1}$, d.v.s. beloppet $n$ 
+månader senare.
 
 
 ## Uppgift
 
-Som vi nämnt tidigare kan geometriska följder användas för att räkna på räntor. 
-Räntor kan variera över tid. Det ska vi ta hänsyn till i denna laboration.
-
-Vi kan nu lämna den aritmetiska delen (den som använder $d$) och fokusera på 
-den geometriska följden, den som använder $q$.
-
-Låt nu $q$ variera över tid. Tidigare hade vi endast ett värde i $q$ och 
+Skriv en funktion som returnerar $g_n$ givet en lista
+$$q = (q_1, \ldots, q_{n-1})$$
+(d.v.s. $q$ som varierar över tid). Tidigare hade vi endast ett värde i $q$ och 
 använde samma värde alla $n$ gånger. Låt $q$ innehålla en lista med $n$ värden 
-istället.
+istället. (Rent terminologiskt betyder detta också att vi inte längre arbetar 
+med en geometrisk talföljd, då definitionen förutsätter att $q$ är konstant.) 
+Vi måste alltså iterera över listan, då formeln inte längre fungerar.
 
-Observera att nu kan vi inte längre använda formeln, då de förutsätter att $q$ 
-är konstant. (Rent terminologiskt betyder detta också att talföljden inte 
-längre är en geometrisk talföljd, då definitionen förutsätter ett konstant 
-$q$.) Vi måste då iterera igenom alla $q$:n.
-
-**Test**: Vi kan testa koden med korta exempel som vi kan beräkna för hand. Vi 
-kan även testa koden genom att mata in samma värde för $q$ hela tiden, d.v.s. 
-att $q_1 = q_2 = \cdots = q_n$, för då kan vi använda formeln för att beräkna 
-summan.
+**Test**: Vi kan testa koden med korta exempel som vi kan beräkna för hand (som 
+ovan). Vi kan även testa koden genom att mata in samma värden för $q$, d.v.s. 
+att $q_1 = q_2 = \cdots = q_n$, för då kan vi använda formlerna för att beräkna 
+det sista talet i följden.
 
 **Exempeltillämpning**: Säg att vi har ett sparkonto där räntan varierar och vi 
 vill uppskatta inkomsten från räntan för ett år framåt. Då låter vi $g_1$ vara 
 vårt ursprungliga sparkapital, medan $q_1, \ldots, q_{12}$ är räntan för varje 
-månad.  Då ger räntan en avkastning på
-$g_1\cdot q_1\cdot q_2\cdots q_{12} - g_1$.
+månad.  Då kommer vi att ha $g_1\cdot q_1\cdot q_2\cdots q_{12}$ kronor på 
+sparkontot när alla månader passerat.
 
 **Inlämning**: Låt ditt program fråga användaren efter antalet månader ($n$) 
 och det ursprungliga sparkapitalet ($g_1$). Skriv ut sparkapitalets totala 
 värde och värdeökning månad för månad. Exempelvis:
 ```
 Hur mycket sparkapital har du (ange i kr)? 1000
 Hur många månader avser du spara? 2
-Ange ränta för månad 1: 1.02
-Ange ränta för månad 2: 1.01
+Ange ränta för månad 1 (i procent): 2
+Ange ränta för månad 2 (i procent): 1
 
          Total       Ökning
 Månad 0: 1000.00 kr   0.00 kr
 Månad 1: 1020.00 kr  20.00 kr
 Månad 2: 1030.20 kr  30.20 kr
 ```
-
+Använd din funktion för att beräkna värdena. (Inmatningarna ska givetvis 
+repeteras tills att värdena är korrekta, återanvänd funktionerna från 
+föregående laboration --- men du får givetvis skriva om dem om det behövs.)

modules/files/lab/Makefile

@@ -14,5 +14,5 @@ clean:
 	${RM} ${HTML_FILES} ${PDF_FILES}
 
 
-include ../../html.mk
+include ../../../html.mk
 

modules/files/lab/instruction.md

@@ -1,10 +1,9 @@
-# Laboration: Filer och filhantering
+# Laboration: Filer och felhantering
 
-I förra laborationen lät vi användaren skapa två geometriska följder och 
-jämföra deras summor. Vi underlättade programmeringen genom att göra 
-beräkningen av den geometriska summan till en funktion.
-
-Nu ska vi förbättra vårt program ytterligare.
+Tidigare har vi låtit användaren ange ett följd av $q$-värden som har använts i 
+beräkningarna av en talföljd. Ibland kan det bli långa följder, exempelvis om 
+vi har månadsräntorna för flera år. Då kan det vara bekvämt att lagra värdena 
+på fil och läsa dem därifrån.
 
 
 ## Uppgift
@@ -14,11 +13,30 @@ in dessa för hand. Vanligtvis finns dessa värden att tillgå i en fil.
 
 I denna laboration ska du låta användaren mata in namnet på en fil som 
 innehåller värdena för $q$. Därefter läser du in värdena och använder dem i 
-ditt program. Notera att du ska läsa in två följder av $q$-värden och jämföra 
-dem, precis som tidigare.
+ditt program. Om filen inte finns ska användaren mata in ett nytt filnamn.
 
 Du kan låta användaren mata in $g_1$, värdet för $n$ får du genom antalet 
-värden för $q$ som finns i filen.
+värden för $q$ som finns i filen. Ett exempel på inmatning:
+```
+Hur mycket sparkapital har du (ange i kr)? 1000
+Ange fil med förväntad ränteutveckling: räntor.txt
+
+         Total       Ökning
+Månad 0: 1000.00 kr   0.00 kr
+Månad 1: 1020.00 kr  20.00 kr
+Månad 2: 1030.20 kr  30.20 kr
+```
+Givetvis ska vi hantera att användaren försöker mata in felaktiga värden.
+
+
+## Extrauppgift
+
+Använd Pythons inbyggda [`csv`-modul][csv] för att läsa in en fil på 
+CSV-format. Då kan filen med räntor skapas i ett kalkylarksprogram som Google 
+Sheets, LibreOffice Calc eller Microsoft Excel.
+
+[csv]: https://docs.python.org/3/library/csv.html
+
+Om resultaten även skrivs till fil i CSV-format (med hjälp av `csv`-modulen), 
+då kan även resultatet importeras tillbaka i kalkylarksprogrammet.
 
-**Krav**: Du ska lämna in ett välskrivet program, d.v.s. det ska fortfarande ha 
-felhantering, vara uppdelat i lämpliga funktioner och moduler, etc.

modules/functions/lab/Makefile

@@ -14,5 +14,5 @@ clean:
 	${RM} ${HTML_FILES} ${PDF_FILES}
 
 
-include ../../html.mk
+include ../../../html.mk
 

modules/functions/lab/instruction.md

@@ -1,32 +1,26 @@
 # Laboration: Funktioner och moduler
 
-I föregående laboration beräknade vi aritmetiska och geometriska summor med 
-varierande $d$- och $q$-värden. I den här laborationen ska vi förbättra vårt 
-program genom att använda funktioner, vilket underlättar att jämföra olika 
-geometriska följder med olika variationer av $q$.
+Vi har skrivit flera funktioner hittills: flera för talföljder och åtminstone 
+en för inmatning. Hittills har vi inte haft något krav på att funktionerna ska 
+ligga i egna moduler.
 
 
 ## Uppgift
 
-Skriv om programmet så att det låter användaren att, först, mata in $n$ och, 
-sedan, mata in två följder med värden för $q$. (Användaren ska även mata in 
-$g_1$.) Sedan beräknar programmet talen i följderna och svarar vilken som gav 
-störst sista term.
+Lägg funktionerna i moduler (exempelvis en modul för talföljder och en modul 
+för inmatning) som du kan återanvända i andra program genom `import`. Skriv 
+sedan om programmet i föregående laboration så att det använder funktionerna 
+genom modulerna.
 
-```
-Hur långa är talföljderna? n = 3
-För den första talföljden, ange:
-g_1: 1000
-q_1: 1.02
-q_2: 1.03
+Använd även [`pylint`][pylint] för att säkerställa kodens kvalitet.
 
-För den andra talföljden, ange:
-g_1: 1000
-q_1: 1.01
-q_2: 1.04
+[pylint]: https://pylint.pycqa.org/en/latest/
 
-Det sista talet i den första är 1050.60, vilket är större än 1050.40.
-```
 
-**Krav**: Använd lämplig uppdelning i funktioner, minimera kodupprepning!
+## Extrauppgift
+
+Läs om [paketering][packaging] i Python och gör dina moduler installerbara 
+genom `pip`. Då kan andra enkelt installera dina moduler på sina system.
+
+[packaging]: https://packaging.python.org/tutorials/packaging-projects/
 

modules/iterations/.gitignore

@@ -0,0 +1,2 @@
+exercise.html
+lecture.html