def get_max_value(values):
    max_value = values[0] # 1
    for value in values: # len(values) = n
        if value > max_value: # 1
            max_value = value # 1
    return max_value # 1

def get_max_value(values):
    max_value = values[0]
    for value in values:
        if value > max_value:
            max_value = value
    return max_value

def get_max_value(values):
    max_value = values[0] # 1
    for value in values: # len(values)
        if value > max_value: # 1
            max_value = value # 1
    return max_value # 1

import random

def sum_all(values):
    acc = 0
    for value in values:
        acc += value
    return acc

%%timeit

sum_all(random.sample(range(1_000_000), k=10))

2.98 μs ± 42.8 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)

%%timeit

sum_all(random.sample(range(1_000_000), k=20))

5 μs ± 73.9 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)

%%timeit

sum_all(random.sample(range(1_000_000), k=40))

8.17 μs ± 52.1 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)

%%timeit

sum_all(random.sample(range(1_000_000), k=400))

71.3 μs ± 684 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

%%timeit

sum_all(random.sample(range(1_000_000), k=4000))

689 μs ± 4.7 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

def make_pairs(values):
    # pre-allocate result list to avoid allocation artefacts 
    pairs = [None]*(values**2)
    current_index = 0
    for v1 in values:
        for v2 in values:
            pairs[current_index] = str(v1) + ":" + str(v2)
            current_index += 1
    return pairs

def make_pairs(values):
    # pre-allocate result list to avoid allocation artefacts 
    pairs = [None]*(len(values)**2)
    current_index = 0
    for v1 in values:
        for v2 in values:
            pairs[current_index] = str(v1) + ":" + str(v2)
            current_index += 1
    return pairs

%%timeit

make_pairs(range(10))

10.7 μs ± 120 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)

%%timeit

make_pairs(range(20))

42.4 μs ± 678 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

  %%timeit  

make_pairs(range(40))

169 μs ± 1.05 μs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

%%timeit

make_pairs(range(80))

671 μs ± 6.71 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

%%timeit

make_pairs(range(160))

2.72 ms ± 60 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)

def add_values1(v1, v2):
    return v1 + v2

def add_values2(v1, v2):
    return v1 * v2

# båda anropen returnerar 4, är båda implementationerna korrekta?
print(add_values1(2, 3))
print(add_values2(2, 3))

5
6

from math import floor

def split_winnings(cash_prize_amount, number_of_winners):
    return floor(cash_prize_amount / number_of_winners)

split_winnings(1000, '2')

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[19], line 1
----> 1 split_winnings(1000, '2')

Cell In[14], line 4, in split_winnings(cash_prize_amount, number_of_winners)
      3 def split_winnings(cash_prize_amount, number_of_winners):
----> 4     return floor(cash_prize_amount / number_of_winners)

TypeError: unsupported operand type(s) for /: 'int' and 'str'

def keep_even_values(values):
    output = []
    for value in values:
        if value % 2 == 0:
            output.append(value)
    return output

print(keep_even_values([]))
print(keep_even_values([1]))
print(keep_even_values([2]))
print(keep_even_values([1, 2, 3, 4]))

[]
[]
[2]
[2, 4]

def keep_even_values(values):
    output = []
    for value in values:
        if value % 2 == 0:
            output.append(value)
    return output


def test_keep_even_values():
    if keep_even_values([]) != []:
        return False
    if keep_even_values([1]) != []:
        return False
    if keep_even_values([2]) != [2]:
        return False
    if keep_even_values([1, 2, 3, 4]) != [2, 4]:
        return False
    return True


if test_keep_even_values():
    print("keep_even_values() fungerar.")
else:
    print("keep_even_values() fungerar INTE.")

keep_even_values() fungerar.

assert uttryck

def keep_even_values(values):
    output = []
    for value in values:
        if value % 2 == 0:
            output.append(value)
    return output


def test_keep_even_values():
    try:
        assert keep_even_values([]) == []
        assert keep_even_values([1]) == []
        assert keep_even_values([2]) == [2]
        assert keep_even_values([1, 2, 3, 4]) == [2, 4]
        return True
    except AssertionError:
        return False


if test_keep_even_values():
    print("keep_even_values() fungerar.")
else:
    print("keep_even_values() fungerar INTE.")

keep_even_values() fungerar.

# öppna fil för att lägga till text till
datafile = open("filnamn.txt", "a")
datafile.write("Glöm inte bort")
datafile.write("radbryt!\n")

# stäng filen som vi öppnat
datafile.close()

TDDE44 Programmering, grundkurs¶

Föreläsning 7¶

Johan Falkenjack, johan.falkenjack@liu.se¶

Föreläsningsöversikt¶

Datorsalstentan¶

logistik på plats, upplägg, inlämning

Datorsalstenta, 3 juni kl. 8.00-12.00¶

Sal, inloggning, kontroll av bok¶

Filer: tenta, datafiler, referens-PDF¶

Skriva tentan - rekommendation¶

Frågor under tentan¶

Tentaupplägg¶

Del 1¶

Del 2¶

Del 2 - Vad menas med "bra" lösning?¶

Betyg¶

Inlämning av uppgifter¶

Prova-på-tenta 21 maj 10.15-11.00 och 11.15-12.00¶

På kurshemsidan¶

Laboration 7¶

Stavningskontroll

Laboration 7¶

Laboration 7: Rättstavning¶

Laboration 7: filer¶

Kortaste redigeringsavståndet¶

Laboration 7: Klasser¶

Förberedelser innan ni börjar implementera¶

Tips¶

Konsekvenser av öka mängden data att bearbeta¶

Laboration 7¶

Exempeluppgift¶

Loopar: Se upp för att göra om saker i onödan. Alt 1¶

Loopar: Se upp för att göra om saker i onödan. Alt 2¶

Loopar: Se upp för att göra saker i onödan¶

Kan vi snabba på detta ytterligare?¶

Loopar: Se upp för att göra saker i onödan¶

Alternativ 1: Alla ord i en bucket¶

Alternativ 2: Ord av olika längd i olika buckets¶

Alternativ 3: Massor med buckets¶

Det verkar knöligt, måste vi göra detta själva?¶

Komplexitet¶

Hur krävande är det att lösa en specifik uppgift med en specifik algoritm?

Vad är en algoritm?¶

En algoritms komplexitet¶

Olika typer av komplexitet¶

Tidskomplexitet, hur många operationer krävs?¶

Tidskomplexitet, hur många operationer krävs?¶

Asymptotisk analys¶

Ordo-notation¶

Ordo-reglerna¶

Exempel $O(n)$¶

Komplexitet, nästlade loopar¶

Exempel $O(n^2)$¶

Några komplexitetsklasser i stigande ordning¶

Några komplexitetsklasser i stigande ordning¶

Några komplexitetsklasser i stigande ordning¶

Några komplexitetsklasser i stigande ordning¶

Se också https://www.bigocheatsheet.com/¶

Testning av kod¶

Testning och felsöking¶

Felsökning¶

Testning¶

Testning i denna kurs och utanför denna kurs¶

Testning i denna kurs¶

Testning inom mjukvaruutveckling¶

Automatiserad testning¶

Vilka typer av test ingår i kursen?¶

Vad ska man tänka på vid testning?¶

Vad behöver man veta för att testa sin kod?¶

Vad måste vi veta för att testa en enhet?¶

Testdata¶

Typfall och gränsfall¶

Vad behöver man göra för att testa sin kod?¶

Göra sitt program lättare att testa¶

Hur kan man testa?¶

Exempel på automatisering av test¶

Exempel på automatisering av test¶

Exempel på automatisering av test¶

Nyckelordet assert¶

Exempel på automatisering av test (med assert)¶

Nyckelordet `assert`¶