A1

import math
class Fyrkant():
    def __init__(self, sida):
        pi = math.pi
        self.hojd = 2 * sida
        self.bredd = 3 * sida
        self.area = self.hojd * self.bredd
        self.vinklar = [pi/2., pi/2., pi/2., pi/2.]
        self.diag1, self.diag2 = 2 * [math.sqrt(self.hojd ** 2 
                                      + self.bredd ** 2)]
    def parallellogram(self, ang):
        self.vinklar = [ang, pi - ang, ang, pi - ang]
        self.diag1 = math.sqrt(self.hojd ** 2 + self.bredd ** 2 
                               + 2 * self.hojd * self.bredd * math.cos(ang))
        self.diag2 = math.sqrt(self.hojd ** 2 + self.bredd ** 2 
                               - 2 * self.hojd * self.bredd * math.cos(ang))
    def __str__(self):
        return f'Area = {self.area}'

Betrakta koden ovan. Vilket alternativ använder korrekt terminologi för de olika komponenterna i koden?

Välj ett alternativ

moduler: math, self
klasser: Fyrkant
funktioner: sqrt, cos
metoder: __init__(), __str__(), diag1, diag2, vinklar
attribut: hojd, bredd, area

moduler: math
klasser: Fyrkant
funktioner: sqrt, cos, area, parallellogram()
metoder: __init__(), parallellogram(), __str__()
attribut: hojd, bredd, area, vinklar, diag1, diag2

moduler: math
klasser: Fyrkant
funktioner: sqrt, cos
metoder: __init__(), parallellogram(), __str__()
attribut: hojd, bredd, area, vinklar, diag1, diag2

moduler: math
klasser: Fyrkant
funktioner: sqrt, cos, parallellogram()
metoder: __init__(), __str__()
attribut: hojd, bredd, area, vinklar, diag1, diag2, self

Lösning

Svar: Alternativ 3

A2

import random as rd
import matplotlib.pyplot as plt
from math import sqrt
from turtle import Turtle

Betrakta koden ovanför. För varje påstående nedanför, markera om det är sant eller falskt.

Du måste markera alla 4 påståendena korrekt för att få 1 poäng på den här uppgiften.

1. sqrt och Turtle är en funktion respektive en klass från modulerna math respektive turtle :

• Sant

• Falskt

2. sqrt och Turtle är funktioner från modulerna math respektive turtle :

• Sant

• Falskt

3. rd och plt är funktioner från modulerna random respektive matplotlib.plt:

• Sant

• Falskt

4. rd och plt är import-alias till modulerna random och matplotlib.plt:

• Sant

• Falskt

A 3

Skriv en funktion summa_av_slumptal(tol) som summerar en serie slumpmässiga heltal mellan 0 och 10 och returnerar summan av slumptalen. Summan ska returneras när nästa term i serien hade gjort att summan blivit större än en angiven tolerans tol.

Förutom summan ska även antalet termer i summan returneras.

Ledning: Slumptalsgeneratorn importeras med import random. Metoden random.randint(a,b) ger slumpmässiga heltal mellan a och b.

Exempel: Följande kod

count,summa = summa_av_slumptal(21)
print(f'Summan av {count} slumptal är lika med {summa}.')`

ska till exempel kunna ge utskriften:

Summan av 5 slumptal är 19.

Utskriften kommer att variera då det är en summa av slumptal.

Lösningsförslag

import random

def summa_av_slumptal(tol):
    tol = int(tol)
    summa = 0
    count=0
    kast = 0
    while summa +kast <=tol:
        summa += kast
        count +=1
        kast = random.randint(0,10)
    count = count-1
    return count,summa

count,summa = summa_av_slumptal(21)
print(f'Summan av {count} slumptal är lika med {summa}.') 

A4

Kast med en tärning modelleras av klassen Dice,

import random

class Dice:
    def __init__(self, sides):
        self.sides = sides
        self.number = 1
        self.value = random.randint(1, self.sides)
        
    def __str__(self):
        return f'Sidor: {self.sides:2d}, 
               f'summa: {self.value:2d} efter {self.number} kast'
               
    def roll(self,number):
            self.value =random.randint(1, self.sides)

Uppdatera metoden roll så att den beräknar summan av number tärningskast. Summan ska sedan lagras i instansvariablen value.

Om man anger ett värde på number som är mindre än 1, skall metoden använda number=1.

Utskriften ska bli av formen nedan

Önskad utskrift

d1 = Dice(6)
d1.roll(5)
print(d1)
d1.roll(-2)
print(d1)

Utskrift:

Sidor: 6, summa: 17 efter 5 kast
Sidor: 6, summa: 5 efter 1 kast

Notera att du endast får uppdatera metoden roll i klassen. Du får INTE göra några andra ändringar i koden.

Lösningsförslag

import random
class Dice:
    def __init__(self, sides):
        self.sides = sides
        self.number = 1
        self.value = random.randint(1, self.sides)
        
    def __str__(self):
        return f'Sidor: {self.sides:2d}, summa: {self.value:2d} efter {self.number} kast'
        
    def roll(self,number):
        if number <1:
            number = 1
        self.number = number
        self.value = 0
        for _ in range(number):
            self.value +=random.randint(1, self.sides)

d1 = Dice(6)
print(d1)
d1.roll(3)
print(d1)

A 5

Skriv ett skript som anropar en funktion rakna_ord(text) som tar en textsträng text som input och returnerar statistik över förekomsten av olika ord.

Funktionen rakna_ord(text) ska returnera en lista med de olika orden samt hur ofta orden förekommer. Listan skall vara sorterad i bokstavsordning.

Ledning 1: Använd lexikon.

Ledning 2: Du kan plocka ut de enstaka orden i en text med hjälp av följande kod

import re
ordlista = re.findall(r'[a-zA-ZåäöÅÄÖ]+', text) 

Se exemplet och utskriften nedan.

Exempel Med följande kod

text_ut = rakna_ord(text)
for element in text_ut:
    print(f'{element[0]}:{element[1]}', end='  ')

ska textsträngen

text = 'O jerum, jerum, jerum, O quae mutatio rerum'

resultera i utskriften

O:2 jerum:3 mutatio:1 quae:1 rerum:1

Lösningsförslag

import re

def rakna_ord(text):
    ordlista = re.findall(r'[a-zA-ZåäöÅÄÖ]+', text)
    antal_ord = {}
    for ord in ordlista:
        if ord in antal_ord:
            antal_ord[ord] += 1
        else:
            antal_ord[ord] = 1
    return (sorted(antal_ord.items()))

text = 'O jerum, jerum, jerum, O quae mutatio rerum'
text_ut = rakna_ord(text)
#print(text_ut)
for element in text_ut:
    print(f'{element[0]}:{element[1]}',end = ' ')
    

A 6

En text är skriven på ett tangentbord som saknar de svenska bokstäverna å, ä, ö, Å, Ä samt Ö. Istället har man använt { för å, } för ä och | för ö, samt [ för Å, ] för Ä och _ för Ö

Skriv en funktion svenska_tecken(text_in) som tar en textsträng text_in och returnerar en textsträng text_ut där {,},|,[,] och _ ersatts med å, ä, ö, Å, Ä och Ö.

Exempel (från en dikt av Gustav Fröding)

Med

text_in = "D’} e {, vett ja”, skrek ja, f|r ja ble rasen, ”{ i {a } e |, h|rer han lite, d’} e {, { i {a } e |."

ska

print(svenska_tecken(text_in))

resultera i

text_ut ="D’ä e å, vett ja”, skrek ja, för ja ble rasen, ”å i åa ä e ö, hörer han lite, d’ä e å, å i åa ä e ö."

Lösningsförslag

def svenska_tecken(text):
    text=text.replace('{','å')
    text=text.replace('}','ä')
    text=text.replace('|','ö')
    text=text.replace('[','Å')
    text=text.replace(']','Ä')
    text=text.replace('_','Ö')
    return text

eller

def svenska_tecken_alt(text_in):
    text_ut = text_in
    byta = {'{': 'å', '}': 'ä', '|': 'ö', '[': 'Å', ']': 'Ä', '_': 'Ö'}
    for old, new in byta.items():
        text_ut = text_ut.replace(old, new)
    return text_ut


text_in = "D’} e {, vett ja”, skrek ja, f|r ja ble rasen, ”{ i {a } e |, h|rer han lite, d’} e {, { i {a } e |."
print(svenska_tecken(text_in))

A 7

Skriv en funktion statistik(lst) som beräknar medelvärde och median för en lista lst med n tal. Funktionen behöver kunna hantera listor med både ett jämt och ett udda antal värden.

OBS! Du får inte använda modulen statistics.

Ledning 1: Medianen definieras som det mittersta värdet av listan om n är udda. Om n är jämnt är medianen medelvärdet av de mittersta värdena i listan.

Ledning 2: För beräkning av medianen behöver listan vara sorterad i storleksordning.

Exempel Med listan

lst = [10,1,3,4,2]

skall koden

medelvarde,median = statistik(lst)
print(f' Medianen är {median} och medelvärdet är {medelvarde}.')

resultera i

Medianen är 3 och medelvärdet är 4.0.

Lösningsförslag

def statistik(lst):
    lst = sorted(lst)
    length = len(lst)
    medelvarde = sum(lst)/len(lst)
    if length%2 !=0:
        return medelvarde, lst[length//2]
    else:
        return medelvarde,(lst[length//2-1]+lst[length//2])/2

    
lst = [10,1,3,4,2]
medelvarde,median = statistik(lst)
print(f' Medianen är {median} och medelvärdet är {medelvarde}.')

A 8

Du har gjort ett experiment tillsammans med en kursare där ni, var för sig, varje timme mätt temperaturen T i ett prov.

Mätningarna är sparade i varsitt lexikon med klockslaget som nyckel och temperaturen (i grader Celsius) som värde. I labbrapporten ska ni redovisa medelvärdet per timme av era temperaturmätningar.

Det visar sig dock att ni sparat datat på två olika sätt.

• Du har sparat datat som lexikonet data_1 = {'12':1.1,'13':2.8,'14':3.4}

• Din kursare har sparat datat som lexikonet data_2 = {'14:00':'3.5','13:00':'2.9','12:00':'1.4'}

Skriv en funktion temperatur_matning(data_1,data_2) som läser in de två olika mätningarna och returnerar medelvärdet av temperaturen per timme.

Ledning: Du kan utgå ifrån att data läses in i ordningen data_1, data_2.

Med koden

matning = temperatur_matning(data_1,data_2)
for m in matning:
    print(f' Kl {m} var temperaturen {matning[m]} grader Celsius.')

ska utskriften från programmet ska se ut som nedan:

Kl 12 var temperaturen 1.25 grader Celsius.
Kl 13 var temperaturen 2.85 grader Celsius.
Kl 14 var temperaturen 3.45 grader Celsius.

Lösningsförslag

def temperatur_matning(data_1,data_2):
    matning = {}
    for e in data_1:
        matning[e]= round((float(data_1[e])+ float(data_2[e+':00']))/2,2)
    return matning

data_1 = {'12':1.1,'13':2.8,'14':3.4}
data_2 = {'14:00':'3.5','13:00':'2.9','12:00':'1.4',} 

matning = temperatur_matning(data_1,data_2)
for m in matning:
    print(f' Kl {m} var temperaturen {matning[m]} grader Celsius.')

B

På midsommaafton på landet brukar man arrangera ett ”potatisrace”. Racet går ut på att man placerar en potatis på en sked, som man sätter i munnen, och man ska sedan gå en sträcka och balansera potatisen.

Regler:

• Först i mål vinner.

• Tappar man potatisen måste man gå tillbaks till start ett steg i taget och börja om från början.

• Om två personer kommer i mål samtidigt vinner den som är yngst.

B1: Skapa en klass Potatisrace.

Skriv en konstruktor __init__(self,length,number) som tar parametrarna length (heltal, längden på banan) och number (heltal, antal deltagare).

Vid initieringen ska åldern på varje deltagare slumpas till mellan 10 och 80 år.

Ledning 1: Använd import random samt random.randint(min,max) för att slumpa fram åldrarna.

Ledning 2: Ett lexikon kan vara användbart för att hålla ordning på de olika deltagarna.

Ledning 3: Förutom length och number kan position, riktning (framåt/bakåt) och ålder vara bra att definiera i konstruktorn.

Exempel:

import ....
class Potatisrace:
    def __init__(self,length,number):      
        
    def __str__(self):
    def kliva(self,tol):
    
    def mal(self):

B2 Lägg till en __str__() metod som illustrerar loppet vid varje tidssteg. Positionen för varje deltagare markeras med bokstaven P.

Utskriften ska se ut som nedan, vilket ger en ögonblicksbild för tre deltagare (number = 3) och med en banlängd om 10 (length =10)

[   P                 ]
[     P               ]
[         P           ]

B3 Lägg till en metod kliva(tol) för deltagarna att ta ett steg framåt.

Vid varje steg så avgör slumpen om en deltagare n tappar sin potatis.
Om man tappar sin potatis måste man återvända till start, ett steg i taget, och börja om.

Sannolikheten för att tappa potatisen ges av en tolerans tol som ges som input till metoden.

Metoden ska alltså:

ta ett steg framåt och kolla om man tappat potatisen.
    Om man tappat potatisen, måste man gå ett steg bakåt de kommande gångerna tills man nått startpunkten, och sedan börja gå framåt igen.

Du kan kan lämna in svaret vid uppgift B4.

B4 Skriv en metod mal() för att avgöra om någon kommit i mål, och i så fall vem om kommit först i mål. Simuleringen skall avbrytas når någon kommit i mål.

Om flera kommer i mål samtidigt, vinner den som är yngst.

Utskriften vid vinst ska se ut som nedan.:

Racet klart! Vinnare är bana 1 med en deltagare som är 47 år gammal

[         P ]
[         P ]
[ P         ]

def main():
    tol = 20
    p1 =Potatisrace(5,3)
    print(p1)
    klar = False
    while not klar:
        p1.kliva(tol)
        print(p1)
        klar,alder,bana =p1.mål()
        if klar:
            break
    print(' ')
    print(f'Racet klart! Vinnare är bana {bana+1} med en deltagare som är {alder} år gammal')
    print(p1)

if __name__ == '__main__':
    main()

Lösningsförslag

import random 

class Potatisrace:
    def __init__(self,length,number):
        self.length = length
        self.race={}
        pos = 0
        direction = 1
        for n in range(number):
            age = random.randint(10,70)
            self.race[n]=[pos, direction, age]
    
    def __str__(self) :
        res = '\n'
        for n in self.race:
            track = [' ']*self.length
            track[self.race[n][0]]='P'
            row_str = ' '.join([str(track[_]) for _ in range(self.length)])
            res += '[ ' + row_str + ' ]\n'
        return res

    def kliva(self,tol):
            for k in self.race:
                self.race[k][0] += self.race[k][1]
                slumptal = random.randint(1,100)
                if slumptal<tol and self.race[k][0]>0:
                       self.race[k][1]= -1
                if self.race[k][0]<=0:
                    self.race[k][0]=0
                    self.race[k][1]=1
                if self.race[k][0]>self.length:
                    self.race[k][0]=self.length
    def mål(self):
        klar = False
        alder = 100
        bana = 1
        for k in self.race:
            if self.race[k][0]>= self.length-1:
                if self.race[k][2]<alder:
                    alder = self.race[k][2]
                    bana = k
                klar = True
        return klar,alder,bana

bana = 0
tol = 20
p1 =Potatisrace(5,3)
print(p1)
klar = False
while not klar:
    p1.kliva(tol)
    print(p1)
    klar,alder,bana =p1.mål()
    if klar:
        break
print(' ')
print(f'Racet klart! Vinnare är bana {bana} med en deltagare som är {alder} år gammal')
print(p1)