3. Olika sätt att köra program

När man programmerar växlar man ofta fram och tillbaka mellan att redigera och testköra. Det finns lite olika arbetssätt för att få det här att funka smidigt, med sina för- och nackdelar. Grundidén som vi utgår från i den här kursen är dock fortfarande att du redigerar program i Emacs och kör dem i terminalen. Om du har tidigare erfarenhet av programmering och vill arbeta i en integrerad utvecklingsmiljö, t.ex. Visual Studio Code, får du gärna göra det, men då får du just nu lösa det på egen hand.

I det här kapitlet ska vi jämföra tre olika arbetssätt. Det är svårt att säga vilket av dem som är bäst. Ibland kan man behöva växla mellan olika arbetssätt under samma laborationspass. Pröva gärna själv vilket som känns bäst.

1. Köra hela programmet i terminalen

I det första kapitlet i studiematerialet introducerade vi arbetssättet att skriva program i Emacs och sedan köra hela programmet i ett svep i terminalfönstret. Om programmet funkar är det här ett bra arbetssätt, men tyvärr är det ju ofta så att våra program inte är helt perfekta från början. Om vi vill testköra olika små delar av programmet var för sig finns alternativa sätt att jobba.

Dessutom, för att det här arbetssättet ska funka behöver vi komma ihåg att göra ett anrop till någon av våra funktioner för att något överhuvudtaget ska hända. Kolla på det här kodexemplet:

def hello():
    print("Hello, world!")

def greet(person):
    print("Hello,", person, "!")

greet("Lancelot")

Om vi missar den sista raden och försöker köra programmet, då kommer ju ingenting att hända. Vi har definierat en massa funktioner som aldrig används.

2. Importera programmet till Python

Ett alternativt arbetssätt är att starta Python och sedan importera programmet. Då är vi fortfarande kvar vid Python-prompten och kan testa enskilda funktioner. Kodexemplet ovan finns sparat i filen hello.py och då kan vi använda Python-kommandot import som i det här exemplet:

li1-1:~$  python3
Python 3.10.12 (main, Feb  4 2025, 14:57:36) [GCC 11.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import hello
Hello, Lancelot !
>>>

Observera att vi inte ska skriva .py efter namnet när vi importerar. Python förutsätter att filen har det efternamnet. Observera också att import inte är en funktion som behöver parenteser, utan en speciell sats.

Eftersom vi har den sista raden i kodexemplet, med ett anrop till greet, så körs det direkt vid importen. Men nu borde vi kunna testköra de två funktionerna:

>>> greet("Guinevere")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'greet' is not defined

Varför blev det fel? Jo, vi har nu importerat innehållet i filen hello.py som en modul. Om vi vill komma åt funktionerna måste vi även inkludera modulnamnet, som alltså är hello, så här:

>>> hello.greet("Guinevere")
Hello, Guinevere !

Det här arbetssättet kanske känns krångligt. Det är säkert bra om man har många olika moduler som man behöver hålla isär, men om man bara skriver små program som man vill testa lite snabbt, finns det inget enklare sätt? Om vi vill slippa använda modulnamnet kan vi göra en mer specifik import:

>>> from hello import hello, greet
>>> greet("Arthur")
Hello, Arthur !

Med det här sättet att importera kan vi peka ut en eller flera funktioner som vi vill importera lite mer direkt, så att säga. De blir tillgängliga utan att vi behöver skriva modulnamnet.

Genom att importera får vi alltså möjlighet att testköra programmets funktioner en i taget. Det gör det lättare för oss att lokalisera och förstå eventuella fel.

En nackdel är att du inte på något enkelt sätt kan gå tillbaka och ändra koden, importera den igen och testa ändringen. Python kommer ihåg vad den har importerat. Även om du skriver import en gång till, så kommer Python inte att läsa in ändringarna, utan du behöver i så fall starta om hela Python.

3. Köra programmet i Emacs

Ett tredje alternativ är att köra Python inifrån Emacs. När du öppnar en fil med ändelsen .py ställs Emacs om till Python-läge. Det gör att du får tillgång till en del Python-specifika möjligheter i en särskild meny. För att starta Python inifrån Emacs, välj alternativet Start Interpreter som finns i Python-menyn, alternativt tryck Ctrl-c Ctrl-p. Då får du upp en särskild Python-buffert i Emacs där du kan importera modulen på samma sätt som om du startat Python vid terminalen.

Detta kansks i sig inte är så revolutionerande, men en fördel med att använda Python via Emacs är att du inte nödvändigtvis behöver importera. Emacs kan lösa det åt dig. Ställ markören i den buffert som innehåller din programkod och kör kommandot Ctrl-c Ctrl-c, alterativt välj Eval buffer från Python-menyn. Detta innebär att hela din fil evalueras om och du har nu tillgång till funktionerna vid Python-prompten i Emacs, utan att behöva skriva modulnamnet först. Vidare kan du gå fram och tillbaka i historiken av dina inmatade kommandon genom att trycka Ctrl-uppåtpil och Ctrl-nedåtpil.

Sammanfattning

• Att köra hela programmet på en gång kan göra det svårt att felsöka.
• Genom att använda import kan vi testa enskilda funktioner var för sig.
• Vi kan peka ut enskilda funktioner och importera dem så att vi slipper skriva modulnamnet framför, men det är svårt att ladda in ändringar.
• Det går också att köra Python inifrån Emacs.

Extramaterial

Python-dokumentationen för import-satsen