Med interaktiv testning ber du pythontolken att läsa in ditt program och sedan starta det interaktiva läget. Säg att du står i samma katalog som din kodfil och att den filen heter kod.py med följande innehåll:

import random

def get_random_numbers(max_num, amount):
    """Returnera en lista med amount slumpade heltal mellan 0 och max_num."""
    random_numbers = []
    num = 0
    while num < amount:
        random_numbers.append(random.randint(0, max_num))
        num += 1
    return random_numbers

my_number = 10

Med pythontolken ipython3 (rekommenderas) skriver du då

$ ipython3 -i kod.py

ipython3 kommer då läsa och köra ditt program, men istället för att avslutas startas det interaktiva läget:

Python 3.6.8 (default, Jan 14 2019, 11:02:34)
Type "copyright", "credits" or "license" for more information.

IPython 5.5.0 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.

In [1]:

Du kan nu anropa på en funktion du skrivit i din kodfil, eller använda en variabel som är definierad i din kod:

In [1]: my_number
Out[1]: 10

In [2]: get_random_numbers(5, 3)
Out[2]: [2, 2, 4]

Rader som börjar med In [siffra] är saker du skrivit. Rader som börjar med Out[siffra] är det returnerade resultatet av det du skrivit i din rad med motsvarande siffra. På detta sätt kan du utforska olika anrop och se vad dina funktioner returnerar.

Fördelar och nackdelar med interaktiv testning

Med interaktiv testning kan du testa olika saker och utforska vad du får för resultat utan att veta allt du vill testa i förväg. Om du sparar resultatet till en variabel kan du också arbeta interaktivt med den, t.ex.

In [10]: nums = get_random_numbers(5, 3)

In [11]: nums
Out[11]: [5, 0, 0]

In [12]: nums[0]
Out[12]: 5

Ovan sparas resultatet till variabeln nums och sen på rad 11 respektive 12 så tittar vi på resultatet och sedan på det första elementet. Detta kan vara väldigt praktiskt framförallt när en funktion returnerar mycket mera data, eller om du vill använda det en funktion returnerar som input till andra funktionsanrop.

Nackdelar med interaktiv testning är om du vill testa samma saker upprepade gånger, eller om det är många saker du vill testa. Du kan dock kombinera interaktiv testning med förberedd testkod i din kodfil (se nedan).

Viktigt när du ändrat i din fil!

När du ändrat i din fil är det viktigt att du laddar om den inlästa filen i det interaktiva läget. I terminalen, tryck CTRL-D och tryck enter:

In [9]:
Do you really want to exit ([y]/n)?

Ladda in filen igen genom att skriva samma kommando som tidigare (tips: tryck på uppåt-pilen för att ta fram föregående kommando).

Du kan också skriva de testanrop du vill göra direkt i kodfilen. Säg att följande står i filen kod.py:

import random

def get_random_numbers(max_num, amount):
    """Returnera en lista med amount slumpade heltal mellan 0 och max_num."""
    random_numbers = []
    num = 0
    while num < amount:
        random_numbers.append(random.randint(0, max_num))
        num += 1
    return random_numbers

my_number = 10

print(my_number)
print(get_random_numbers(5, 3))

Du kan nu köra filen med valfri pythontolk (python3 eller ipython3):

$ ipython3 kod.py
10
[3, 5, 2]
$

Pythontolken kommer att köra filen och sedan avslutas. Skulle du vilja ändra på det du testar måste du ändra i kodfilen och köra om den.

Fördelar och nackdelar

Fördelen med att utskrifter av testanrop i din kodfil på förhand är om du vill testa samma sak flera gånger (varje gång du gör en ändring), eller om det finns flera saker du vill testa.

Nackdelen är att du inte kan improvisera fram test på en gång utan måste skriva in dem i din kodfil.

En nackdel med att det är utskrifter är att du måste utföra en manuell okulär besiktning av alla utskrifter för verifiera om funktionen gör det den ska göra. Med hjälp av t.ex. assert satser (se nedan) kan vi komma bort från detta.

Dock kan du kombinera färdiga test i kodfilen med interaktiv testning genom att köra din förberedda kodfil interaktivt! Säg att följande stod längst ner i kod.py:

my_numbers = get_random_numbers(5, 10)
print(my_numbers)

Du skulle då kunna köra kodfilen med flaggan -i och hamna i det interaktiva läget:

$ ipython3 -i kod.py
Python 3.6.8 (default, Jan 14 2019, 11:02:34)
Type "copyright", "credits" or "license" for more information.

IPython 5.5.0 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.
[3, 3, 2, 5, 4, 5, 1, 5, 3, 2]

In [1]:

Nu har testet körts och du kan skriva in test interaktivt eller t.ex. jobba med värdet som den globala varibeln my_numbers refererar till.

En variant av att använda testanrop och utskrifter är att lägga till villkorssatser som kontrollerar om funktionen returnerade rätt/fel. Om du gör detta slipper du fundera på om utskriften var ett korrekt eller felaktigt resultat.

def get_last(values):
    return values[-1]

if get_last([1, 2, 3]) != 3:
    print("get_last(), returnerade inte 3")

Enklare är dock att använda assert-satser som beskrivs nedan.

För att komma ifrån manuella okulära besiktningar av utskrifter kan vi antingen använda villkorssatser som kontrolerar returvärden, eller assert-satser.

Exempel

if get_length("hejsan") != 6:
    print('get_length("hejsan") != 6')

I ovanstående kod skrivs ett meddelande ut när något går fel.

assert get_length("hejsan") == 6

Ovanstående exempel kommer utföra anropet get_length("hejsan") och om returvärdet inte är 6, så kommer vi få ett runtime-fel.

På pythontutor.com kan du klistra in pythonkod och stega igenom den.

Fördelen är att att du ser varje steg som Python gör. Du ser vad olika variabler har för värden för varje rad som körs.

Nackdelen är att vissa moduler inte fungerar i webbtjänsten och att om du vill ändra och testa något så får du kopiera och klistra mellan din kodfil och webbtjänsten.