Man kan skrive kode med en enkel teksteditor, men det er lettere å bruke et program som er spesiallaget til dette formålet. Derfor bruker vi gjerne en *IDE* (Integrated Development Environment). Det finnes flere IDE'er som er brukbare for hvert språk, og noen IDE'er kan brukes til flere programmeringsspråk. Vi skal bruke en enkel IDE som er spesiallaget for Python-undervisning. Denne IDE'en heter "Thonny" og vi kan laste den ned herfra: [http://thonny.org](http://thonny.org). Hvis noen ønsker å bruke en mer avansert IDE er det mulig å bruke andre, f.eks [PyDev](http://www.pydev.org/),
men jeg vil anbefale å bruke Thonny da det er denne som brukes i undervisningen.
Last ned Thonny og følg instruksjonene på nettsiden for å installere den på din maskin. Når du så starter Thonny vil du få opp et vindu som ser slik ut (Windows):
Dette vinduet har 3 ruter. I ruten øverst til venstre skriver vi kode, i ruten under ser vi resultatet når vi kjører koden, og ruten til høyre brukes for "debugging". Vi skal se litt på debugging tilslutt i denne leksjonen.
Hvis du ikke ser "Variables"-vinduet kan du velge `View/Variables` fra menyen.
## Hello World
Nå kan vi lage vårt første program i Python. Skriv følgende kode i ruten øverst til venstre:
```python
print("Hei verden!")
```
Dette er et enkelt men fullverdig Python-program hvor vi ganske enkelt sier at programmet skal skrive ut teksten "Hei verden!". For at vi skal kunne kjøre programmet må vi først lagre det i en fil. Velg *File/Save* eller trykk på diskett-knappen, velg en passende mappe og bruk f.eks filnavnet *hello.py*. Vi bruker alltid filetternavnet *.py* for Python-programmer.
Kjør programmet ved å trykke på den grønne start-knappen på verktøylinja. Da vil du se at teksten "Hei verden!" blir skrevet ut i ruten nederst til venstre:
Merk at koden i Thonny blir fargelagt etter visse regler. Dette kalles "syntax highlighting" og gjør at det blir lettere å lese koden.
## Instruksjoner
Et program består av en serie med instruksjoner (eller kommandoer). Vi forteller Python hvordan en oppgave skal utføres ved å gi den en rekke instruksjoner, litt på samme måte som en matoppskrift gir oss instruksjoner om hvordan vi skal lage en rett.
I den virkelige verden kunne man ha laget instruksjoner for å betale i en selvbetjent kasse i butikken:
```
Så lenge det er varer i handlevogna:
ta ut en vare
scan strekkode
trykk på "Ferdig"
utfør betaling
```
Dette er ikke et Python-program men bruker samme oppbygning og kalles gjerne *pseudo-kode*. For Python og andre programmeringsspråk er det mer eller mindre strenge regler for hvordan man skal skrive koden.
## Kodefeil
Hvis vi lager feil i koden får vi feilmeldinger fra Python. Vi kan for eksempel skrive `printt` istedetfor `print`. `printt` er ikke en instruksjon Python kjenner til og derfor vil vi få en feilmelding:
Når vi skriver ut tekst som vi gjør her bruker vi en tekststreng, `"Hei Verden!"`. En tekststreng må alltid ha et anførselstegn på hver side. Prøv å ta bort det ene og se hva som skjer da.
## Løkker
La oss prøve å gjøre noen endringer på programmet vi har skrevet. Hvordan kan vi f.eks skrive ut teksten "Hei verden!" flere ganger? Den aller enkleste løsningen er å endre programmet slik at vi skriver samme `print`-kommando flere ganger:
Men det finnes mer elegante måter å gjøre dette på. Vi kan heller lage en **løkke**:
```python
foriinrange(0,3):
print("Hei verden!")
```
Dette gir akkurat samme resultat som før.
I dette eksempelet introduserte vi to nye konsepter, *variabler* og *løkker*. Vi går ikke i dybden på dette nå, men kommer tilbake til det i senere leksjoner. Likevel, med pseudokode kan vi si det på denne måten:
```{python, eval = FALSE}
utfør 3 ganger:
print("Hei verden!")
```
Men vi introduserte også variabelen `i` som inneholder et tall. En litt mer nøyaktig beskrivelse av hva som skjer kan være slik:
```{python, eval = FALSE}
utfør 3 ganger, først med i=0, så med i=1, så med i=2:
print("Hei verden!")
```
For å se at verdien på `i` endrer seg kan vi også skrive ut verdien av variabelen i koden. Legg til kommandoen `print(i)` på denne måten:
```python
foriinrange(0,3):
print("Hei verden!")
print(i)
```
Siden begge `print`-kommandoene er har samme innrykk, dvs at det er samme antall mellomrom foran kommandoen, vil begge `print`-kommandoene bli utført som en del av løkka.
Når vi kjører programmet ser vi dette:
Første gang teksten skrives ut er `i` 0, så 1, så 2. Merk at den blir aldri 3. Når vi lager løkken sier vi at `i` først skal være 0, så skal den økes med **en** for hver gang, så lenge den **er mindre** enn 3.
Vi kan endre innrykket slik at den andre `print`-kommandoen ikke er en del av løkka. Her utføres den andre kommandoen etter at løkka er ferdig:
## Variabler
Vi brukte variabelen `i` for å lage en løkke, men vi kan bruke variabler på flere måter, for eksempel til å utføre enkel regning:
Her setter vi først variabelen `a` til 5, så setter vi variabelen `b` til 6. Deretter setter vi variabelen `c` lik `a + b` som da i praksis blir `11`. På neste linje setter vi `c` lik `c + 2`. Vi skal altså øke verdien av `c` med 2. Siden `c` er 11 før denne kommandoen, blir `c` 13 etter kommandoen er utført. På siste linje skriver vi ut verdien av `c` som nå er 13.
Merk innholdet i ruten til høyre. Denne viser nå verdien av alle variablene slik de var på slutten av eksekveringen (kjøring) av koden. Vi kan også bruke denne ruten til å vise verdien av variablene mens vi kjører. Dette kaller vi "debugging".
## Input
For å lage et interaktivt program kan vi spørre brukeren om input:
Kommandoen på den første linjen sier at vi skal skrive ut teksten `"Skriv inn et tall: "` og deretter vente på at brukeren skriver inn et tall. Når brukeren har skrevet tallet og trykket på "Enter" vil variabelen `a` ha verdien som brukeren skrev inn.
## Oppgaver
Nå skal dere prøve å løse noen konkrete oppgaver. Bruk kodeeksemplene i leksjonen som utgangspunkt.
### Oppgave 1
Lag et program som starter slik:
```python
a=3
b=2
```
Deretter skal det gjøre følgende:
* La `c` bli `a` ganger `2`
* La `d` bli `b` pluss `c`
* Gjør verdien av `d` til det dobbelte av hva den er
* Skriv ut verdien av `d`
Er verdien av `d``16`?
Hvis ikke må du bruke debuggeren til å finne ut hvorfor.
### Oppgave 2
Nå skal du utvide programmet fra oppgave 1.
Legg til denne linjen på slutten:
```python
e=input("Skriv inn enn tekst: ")
```
Deretter skal programmet skrive ut verdien av `e` like mange ganger som verdien av `d`.
Kjør programmet med debuggeren og observer hvordan løkketelleren øker underveis.
