Komma igång med Python-tolken

Under första halvan av kursen kommer vi att arbeta med Python genom att skriva programkod i texteditorn Emacs och sedan köra koden direkt från Python-prompten. Detta sätt att jobba på återkommer sedan i många programmeringskurser på både U- och D-programmen.

Starta Python

Python finns tillgängligt på IDA:s Linux-datorer och du startar det genom att skriva python3 vid prompten. Observera att du måste avsluta kommandot med siffran 3 för att starta rätt versionav Python. Om du bara skriver python startas en tidigare version av Python som fungerar lite annorlunda. Om allt fungerar bör det nu se ut ungefär så här:

li1-1:~$ python3
Python 3.6.8 (default, Jan 14 2019, 11:02:34) 
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Istället för den vanliga prompten i terminalen visas nu Python-prompten >>>. För att avsluta Python kan du antingen skriva exit() eller quit() eller genom att hålla inne Ctrl och trycka på d (Ctrl-d).

I python-prompten kan man direkt köra python-kod en rad i taget. Detta är väldigt användbart när man vill prova vad några få rader kod gör och detta kommer användas mycket i resten av studiematerialet. Varje gång det finns kod som börjar med >>> betyder det att koden körs i en python-prompt.

När man har mer än några få rader kod blir det dock jobbigt att göra allt i python-prompten. Man kan inte ändra tidigare rader och det finns inget bra sätt att spara det man skrivit in för att köra i framtiden.

Därför är det bättre att skriva koden i en textfil och låta python exekvera den.

Att anropa funktioner

En av de viktigaste byggstenarna till ett program i python är funktioner. Likt matematiska funktioner tar de någon indata, gör lite beräkningar och ger tillbaka ett resultat av beräkningarna. Python har en mängd inbyggda funktioner, bland annat absolutbelopp (abs) och avrundning (round). För att anropa funktioner skrivs funktionens namn följt av paranteser. Inom paranteserna skrivs indatan till funktionen. Om funktionen tar mer än en parameter separeras de med ,

>>> abs(3)
3
>>> abs(3-6)
3
>>> round(2.45)
2

En annan funktion som ofta dyker upp är funktionen print som skriver ut värdet av parametrarna som skickas in.

>>> print("Hello world")
Hello world
>>> print("Sum", 1+2)
Sum 3

Vårt första program

Nu är det dags för vårt första Python-program. Det kan vara en bra idé att samla dina program i en egen mapp. Skapa en mapp med valfritt namn, t.ex. tdde23, och byt katalog till den mapp du just skapat (genom att skriva t.ex. cd tdde23). Öppna en ny fil i Emacs som heter hello.py (genom att skriva emacs hello.py &. &-tecknet säger åt linux att du vill köra detta som en bakgrundsprocess, och på så sätt kan du använda terminalen till annat medan Emacs är öppet). Skapa funktionen hello_world och få den att skriva ut texten "Hello world!" genom att skriva följande i Emacs-fönstret:

def hello_world():
    print('Hello World')

hello_world()

De två första raderna definierar en ny funktion med namnet hello_world som inte tar några parametrar och skriver ut texten 'Hello world'. Exakt hur det fungerar kommer att beskrivas i senare kapitel.

Den sista raden är inte helt nödvändig, men det är ett enkelt sätt att se till att funktionen hello_world körs automatiskt om filen hello.py anropas.

Köra Python-program

Det finns i princip tre olika sätt att köra vårt program. Det första sättet är att köra programmet från kommandoraden:

li1-1:~$ python3 hello.py
Hello world!

Detta läser in filen och exekverar den som om varje rad hade skrivits in i prompten.

Det andra sättet är att starta Python-interpretatorn och köra programmet från Python-prompten:

>>> import hello
Hello world!
>>> hello.hello_world()
Hello world!

Den första utskriften härrör från när programmet importeras och funktionen hello_world anropas. Nu finns programmet tillgängligt och vi kan anropa det igen om vi vill, som görs på den andra raden ovan.

Det tredje sättet importerar modulens funktioner så att de blir tillgängliga direkt i prompten och det ser ut så här:

>>> from hello import hello_world
Hello world!
>>> hello_world()
Hello world!

Den stora skillnaden här är att vi slipper skriva modulnamnet hello när vi vill anropa hello_world igen. Vill man importera fler funktioner eller variabler från en modul listar man upp dem efter import och separerar dem med kommatecken:

>>> from hello import hello_world, goodbye_world

Moduler och import-satsen

I stycket ovan använde vi oss av flera nya termer som inte är helt uppenbara. Till att börja med nämnde vi något som vi kallade modul (en. module). I Python är en modul en fil med Pythonkod som definierar olika saker (till exempel funktioner, variabler och konstanter). Filen hello.py som vi skapade tidigare är ett exempel på en modul. Modulens namn är hello och den innehåller funktionen hello_world. För att vi ska kunna använda den här funktionen i andra Pythonfiler eller direkt i interpretatorn måste vi importera den. Det gör vi med import-satsen.

import är en sats som enligt ovan kan användas på tre olika sätt men alla har en sak gemensam. Den hämtar definitioner från en modul.

1. Importera modulen själv (se "import hello" ovan) vilket gör att alla definitioner kan kommas åt genom hello.<definition_name> (se hello.hello_world ovan).
2. Importera vissa definitioner från en modul (se from hello import hello_world ovan) vilket gör att de definitioner man importerade blir tillgängliga direkt (se hello_world ovan).
3. Den så kallade wildcard import. Den här typen av import ska, enligt pep-8, enbart användas om man ska skapa ett publikt API som använder sig av allt från andra moduler. Vidare är detta riskabelt att använda då en modul mycket väl kan innehålla en definition med samma namn som en annan definition man använder. Det resulterar i att importen kommer skriva över den andra definitionen. Man får även tänka på att om det inte finns något i modulen som är problematiskt för närvarande kan det introduceras problematiska saker om modulen uppdateras. Till slut gör en wildcard import även att det blir svårt att se varifrån en definition har blivit importerad. Avslutaningsvis kan vi nämna att eftersom wildcard imports enbart ska användas i så sällsynta fall är det en bra tumregel att aldrig använda dem.

En sista sak som kan vara värd att nämna om import-satsen är att Python måste kunna se var modulen är placerad. Det finns fler sätt att se moduler på olika mappar i filsystemet men i den här kursen nöjer vi oss med att säga att import-satsen ser alla moduler som ligger i samma mapp som den själv (det inkluderar att import-satser i interpretatorn ser alla moduler som ligger i samma mapp som interpretatorn startades i).

Köra Python inifrån Emacs

Om man inte vill öppna Python-interpretatorn i terminalen går den att öppna direkt i Emacs. När du öppnar en fil med filändelsen .py ställs Emacs om till Python-läge. Detta gör bland annat att du får s.k. syntax highlighting (programkoden färgas för att bli mer lättläst) och tillgång till en meny med alternativ för Python. Python-menyn hittar du näst längst till höger i menyraden. För att starta interpretatorn i Emacs klickar du antingen på Start Interpreter eller Switch to Interpreter i Python-menyn, eller genom kommandot Ctrl-c Ctrl-z, vilket är snabbkommandot för Switch to Interpreter. Här kan du nu importera modulen hello och köra programmet på samma sätt som vid Python-prompten i terminalen.

En fördel med att öppna Python i Emacs istället för i terminalen är att du slipper att skriva kommandona för att importera dina funktioner. Om du placerar markören i fönstret som innehåller hello.py och kör kommandot Ctrl-c Ctrl-c så evalueras hello.py och resultatet blir detsamma som att skriva from hello_world import *, d.v.s. du får tillgång till dina funktioner och variabler direkt vid prompten. Dessutom fungerar piltangenterna, baksteg, delete och alla andra knappar på det sätt du antagligen förväntar dig vid prompten i Emacs. Vidare kan du gå fram och tillbaka i historiken av dina inmatade kommandon genom att trycka Ctrl-uppåtpil och Ctrl-nedåtpil.

Att sätta rätt Python-version i Emacs

För att få Emacs på IDA att använda den version av Python vi använder i kursen (version 3) måste du göra en smärre ändring i Emacs konfigurationsfil. Dessutom är det bra att på samma gång se till att Python kan importera moduler från den aktuella katalogen. Så här gör du:

1. Öppna ~/.emacs (filen .emacs i din hemkatalog) genom att skriva emacs ~/.emacs. Om den inte finns skapar Emacs den.
2. Skriv in följande i filen:

(setq python-remove-cwd-from-path nil)
(custom-set-variables
  '(python-python-command "python3")
    '(python-shell-interpreter "python3"))

3. Spara filen (med Ctrl-x Ctrl-s)
4. Starta om Emacs