Kodrummet

Centralt innehåll

Grundläggande datastrukturer och algoritmer.
Strukturerat arbetssätt för problemlösning och programmering.
Grundläggande kontrollstrukturer, konstruktioner och datatyper.

Grundläggande programmering i ett textbaserat programspråk.
Programmeringens möjligheter och begränsningar utifrån datorns funktionssätt.
Arbetsmetoder för förebyggande av programmeringsfel, testning, felsökning och rättning av kod.
Gränssnitt för interaktion mellan program och användare.
Normer och värden inom programmering, till exempel läsbarhet, dokumentation, testbarhet, rena gränssnitt och nyttan av standard.

Fakta

1. Lokala & Globala variabler

Funktion print_review som vi sett ska anropas med två argument, en sträng och ett heltal. Det är värden som skickas till parametrarna.

# Funktionen print_review har två parameter, en sträng och ett heltal
def print_review(movie_name, star_count):
    stars = star_count * ('\u2B50' + ' ')
    print(f'The movie "{movie_name}" gets {stars}')

# Fråga efter film och betyg
movie = input('Movie name: ')
stars = int(input('Star count (1-10): '))

# Anropa funktionen print_review med två argument, en sträng och ett heltal
print_review(movie, stars)

ger utskriften
            Movie name: Monty Python
Star count (1-10): 10
The movie "Monty Python" gets ⭐ ⭐ ⭐ ⭐ ⭐ ⭐ ⭐ ⭐ ⭐ ⭐

När det gäller argument är det värden som skickas till parametrarna.

# Funktionen print_review har två parameter, en sträng och ett heltal
def print_review(movie_name, star_count):
    stars = star_count * ('\u2B50' + ' ')
    print(f'The movie "{movie_name}" gets {stars}')

# Fråga efter film och betyg
movie = input('Movie name: ')
stars = int(input('Star count (1-10): '))

# Anropa funktionen print_review med två argument, en sträng och ett heltal
print_review(movie, stars)

# Anropar funktionen två argument, med värdena 'Zombieland' och 5
print_review('Zombieland', 5)

txt = 'Vampyres'
grade = 4
# Anropar funktionen två argument, med värdena 'Vampyres' och 4
print_review(txt, grade)

ger utskriften
            Movie name: Monty Python
Star count (1-10): 10
The movie "Monty Python" gets ⭐ ⭐ ⭐ ⭐ ⭐ ⭐ ⭐ ⭐ ⭐ ⭐ 
The movie "Zombieland" gets ⭐ ⭐ ⭐ ⭐ ⭐ 
The movie "Vampyres" gets ⭐ ⭐ ⭐ ⭐

I nästa exempel har parametrarna variabelnamnen a och b. Argumenten har variabelnamnen x och y och deras värden, dvs 3 och 5, skickas till parametrarna.

def print_sum(a, b):
    val = a + b
    print(val)
    
x = 3
y = 5
print_sum(x, y)

ger utskriften
            8

Argumenten skickar värden till parametrar och kan vara olika variabler eller direkta värden.

def print_sum(a, b):
    val = a + b
    print(val, end=' ')
    
x = 3
y = 5
print_sum(x, y)
print_sum(4, 7)
print_sum(y, y)
c = 4
d = 6
print_sum(d, c)
print_sum(c, x)

ger utskriften
            8 11 10 10 7

Vad gäller för parameter-variablerna a och b? De kan naturligtvis användas i funktionen, men vad händer om man försöker använda dem utanför funktionen?

def print_sum(a, b):
    val = a + b
    print(val)
    
x = 3
y = 5
print_sum(x, y)

# Försök använda parametrarnas variabelnamn utanför funktionen
print(a)
print(b)

ger utskriften
            8Traceback (most recent call last):
  File "main.py", line 10, in <module>
    print(a)
NameError: name 'a' is not defined

Vi ser att de variablerna inte kan användas utanför funktionen, s.k. lokala variabler. Men vad gäller för variabeln val som deklareras i funktionen, kan den användas utanför funktionen?

def print_sum(a, b):
    val = a + b
    print(val)
    
x = 3
y = 5
print_sum(x, y)

# Försök att använda en variabel som deklarerats i en funktionen
print(val)

ger utskriften
            8Traceback (most recent call last):
  File "main.py", line 10, in <module>
    print(val)
NameError: name 'val' is not defined

Vi ser att inte heller variabler som deklareras i en funktion kan användas utanför funktionen. De är också lokala variabler, dvs att de bara existerar i funktionen.

Variabler som definierades inuti en funktionen är inte tillgänglig utanför funktionen. De kallas för lokala variabler och existerar alltså endast inuti funktionen.
Man ska se det som att funktioner är oberoende delar av ett program som ska utföra en uppgift. De värden de behöver för att utföra uppgiften ska skickas in till funktionen.

Nästa fråga är om en variabel som deklareras utanför en funktion i det som brukar kallas för huvudprogrammet kan användas i en funktion?
I nästa exempel deklareras variabeln z utanför funktionen i det som brukar kallas för huvudprogrammet, kan den användas i funktionen?

def print_sum(a, b):
    val = a + b + z
    print(val)
    
x = 3
y = 5
z = 7
print_sum(x, y)

ger utskriften
            15

Det går alltså att använda variabler deklarerade i huvudprogrammet (utanför funktioner) i en funktion. Sådana variabler kallas för globala variabler.
Men att använda globala variabler i en funktion är väldigt dåligt och ska undvikas. Därför att många av de fördelar som finns med funktioner förloras då.
Ju större programmen är desto mer märks nackdelarna om globala variabler används i funktioner.

Funktioner ska vara oberoende för att kunna återanvändas i andra program, men om globala variabler används i funktioner blir de beroende av huvudprogrammet och kan inte på ett enkelt sätt återanvändas i andra program.
Testningen blir svårare eftersom funktionen beror på kod utanför funktionen.
Sannolikheten för fel ökar eftersom det finns beroenden till kod utanför funktionen eftersom en ändring i huvudprogrammet kan påverka koden i fuktioner.
Det blir svårare att läsa och förstå koden, läsbarheten minskar.

Använd inte globala variabler i funktioner. Om funktionen behöver värdet för en variabel ska den definieras med en sådan parameter.
Nästa exempel visar det korrekta sättet om värdet för variabeln z behöver användas i funktionen.

def print_sum(a, b, c):
    val = a + b + c
    print(val)
    
x = 3
y = 5
z = 7
print_sum(x, y, z)

ger utskriften
            15

Vad händer om en lokal variabel och en global variabel har samma variabelnamn. Hur fungerar det då?
Det är faktiskt så att de betraktas som olika variabler. Nästa exempel visar hur det fungerar.

def print_x():
    x = 8   # Lokal variabel
    print(f'Värdet på x i funktionen: {x}')
    
x = 3   # Global variabel
print_x()
print(f'Värdet på x utanför funktionen: {x}')

ger utskriften
            Värdet på x i funktionen: 8
Värdet på x utanför funktionen: 3

Den lokala variabeln x i funktionen har ingen påverkan på den globala variabeln x. De betraktas som två helt olika variabler.

Vi har i tidigare exempel sätt att parametrarna och argumenten har haft samma variabelnamn. Hur fungerar det då?
Det är faktiskt så att de också betraktas som olika variabler. Nästa exempel visar hur det fungerar.

def print_value(x):
    x = 5   # parametern x är också en lokal variabel
    print(f'Värdet på x i funktionen: {x}')
    
x = 4   # Global variabel
print_value(x)
print(f'Värdet på x utanför funktionen: {x}')

ger utskriften
            Värdet på x i funktionen: 5
Värdet på x utanför funktionen: 4

Variabler kan ju ses som en låda med ett värde och de här variablerna har en varsin låda och påverkar inte varandra. En låda är ett symboliskt uttryck för att de har ett utrymme i datorns minne.

Lokala variabler kan inte användas utanför en funktion.
Variabler deklarerade utanför en funktion kallas globala variabler.
Det är inte bra att använda globala variabler i en funktion.

2. Scope

Vi har sett i exemplen med lokala och globala variabler att man inte kan komma åt alla variabler hela tiden. En variabels scope (räckvidd på svenska) är den del av programmet inom vilken variabeln kan användas. Scope beskriver alltså en variabels synlighet.

I nästa exempel har den lokala variabeln val och parametrarna a och b räckvidd i funktionen.
Variablerna x och y har global räckvidd, dvs de kan användas överallt i programmet.

def print_sum(a, b):
    val = a + b
    print(val)
    
x = 3
y = 5
print_sum(x, y)

ger utskriften
            8

En variabels scope är den del av programmet inom vilken den är synlig.

Begrepp

Funktion: En del av koden, som utför en uppgift och kan anropas.

Anrop: Att kalla på en funktion så att koden i den utförs.

Parameter: Indata som en funktion ska ha. En variabel som tar emot ett värde från ett funktionsanrop.

Argument: Ett värde som skickas med till en funktion.

Lokal variabel: Variabel som deklareras i en funktion och går bara att komma åt i den funktionen.

Global variabel: Variabel som deklareras utanför en funktion och kan kommas åt från hela programmet.

Scope: Del av programmet inom vilken en variabel är synlig (kan användas).

Räckvidd: Svenska ordet för scope.

Länkar

Film

Fördjupning

Övningar

Du kan inte att lära dig att programmera genom att läsa en bok eller titta på videos. Du måste öva på att skriva kod själv och ju mer du övar desto bättre blir du.

Skriv en funktion print_max som har två heltalsparametrar och skriver ut det största värdet. Testa olika anrop till funktionen så att du är säker att funktionen fungerar korrekt.

Varför blir det exekveringsfel i koden?

def foo(a, b):
    print(a + b)
    
x = 3
foo(x, 5)
print(a)

ger utskriften
            8Traceback (most recent call last):
  File "main.py", line 6, in <module>
    print(a)
NameError: name 'a' is not defined

Varför blir det exekveringsfel i koden?

def foo(a, b):
    val = a * b
    print(val)
    
foo(3, 5)
print(val)

ger utskriften
            15Traceback (most recent call last):
  File "main.py", line 6, in <module>
    print(val)
NameError: name 'val' is not defined

Programmet ger inget exekveringsfel, men anses ändå vara dålig kodning, varför?

def print_product(a, b, c):
    val = a * b * c * d
    print(val)
    
a = 3
b = 5
c = 7
d = 9
print_product(a, b, c)

ger utskriften
            945

*Skriv en funktion print_max som har tre heltalsparametrar och skriver ut det största värdet. Testa olika anrop till funktionen så att du är säker att funktionen fungerar korrekt.

Inlämningsuppgift

Exit tickets