Python Academy · Lektion

Closures og frie variabler

Indfang tilstand i indre funktioner

Lektion 2 af 413 trin

Closures og frie variabler er en gratis Python Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Python Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Python Academy-kurset indeholder 4 lektioner i alt.

Indlejrede funktioner

Python lader dig definere en funktion inde i en anden funktion. Den indre funktion oprettes på ny, hver gang den ydre funktion kører.

def outer():
    def inner():
        return 'from inner'
    return inner()
print(outer())

Indre funktioner kan se ydre variabler

En indre funktion kan læse variabler, der er defineret i den omsluttende funktion. De kaldes frie variabler, fordi de ikke er lokale for den indre funktion.

def outer():
    message = 'hello'
    def inner():
        return message
    return inner()
print(outer())

Hvad er en lukning?

En lukning opstår, når en indre funktion returneres og stadig husker de frie variabler fra sit omsluttende område, selv efter at dette område er afsluttet.

def make_greeter(name):
    def greet():
        return 'Hi ' + name
    return greet
g = make_greeter('Ada')
print(g())

Indfanget tilstand overlever

Den ydre funktion er allerede returneret, men lukningen holder stadig fast i name. Værdien lever videre inde i den returnerede funktion.

def make_greeter(name):
    def greet():
        return 'Hi ' + name
    return greet
a = make_greeter('Ada')
b = make_greeter('Bob')
print(a())
print(b())

En multiplikatorfabrik

Lukninger er særligt nyttige som fabrikker, der producerer tilpassede funktioner. Her multiplicerer hver returneret funktion med en indfanget faktor.

def multiplier(factor):
    def multiply(n):
        return n * factor
    return multiply
double = multiplier(2)
triple = multiplier(3)
print(double(10))
print(triple(10))

Hver lukning er uafhængig

Hvert kald til fabrikken opretter en separat lukning med sin egen indfangede værdi. De påvirker ikke hinanden.

def adder(amount):
    def add(n):
        return n + amount
    return add
add5 = adder(5)
add100 = adder(100)
print(add5(1), add100(1))

Undersøgelse af indfangede værdier

De indfangede navne står i __code__.co_freevars, og deres værdier findes i cellerne i __closure__.

def make(x):
    def f():
        return x
    return f
fn = make(42)
print(fn.__code__.co_freevars)
print(fn.__closure__[0].cell_contents)

Lukninger indfanger variabler, ikke værdier

En lukning indfanger selve variablen, så den ser variablens endelige værdi. Det er vigtigt, når variablen ændres, efter at lukningen er oprettet.

def build():
    x = 1
    def show():
        return x
    x = 99
    return show
print(build()())

Fælden med sen binding i løkker

En klassisk faldgrube: Lukninger, der oprettes i en løkke, deler alle den samme løkkevariabel og indfanger derfor dens sidste værdi.

funcs = []
for i in range(3):
    funcs.append(lambda: i)
print([f() for f in funcs])

Rettelse af sen binding

Bind den aktuelle værdi med et standardargument, så hver lukning indfanger sin egen kopi på definitionstidspunktet.

funcs = []
for i in range(3):
    funcs.append(lambda i=i: i)
print([f() for f in funcs])

Lukninger som letvægtsobjekter

En lukning samler data og adfærd, omtrent som et lille objekt – ofte mere enkelt end en hel klasse i simple tilfælde.

def counter_start(start):
    def value():
        return start
    return value
c = counter_start(10)
print(c())

Hurtigt tjek

Hvad er en lukning i Python?

Besvar den i den interaktive lektion

Opsummering: Lukninger og frie variabler

Vigtige idéer:

Indre funktioner kan læse variabler fra det omsluttende område (frie variabler).
En lukning er en returneret indre funktion, der husker disse variabler.
Hvert kald til fabrikken opretter en uafhængig lukning.
Lukninger indfanger variabler, ikke værdier, hvilket forårsager fælden med sen binding i løkker – ret den med et standardargument.

def power_of(exp):
    return lambda base: base ** exp
square = power_of(2)
print(square(9))

Gratis at komme i gang

Lær Python med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 76
Lektioner: 320

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Closures og frie variabler” gratis?

Ja — hele teksten til “Closures og frie variabler” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Python Academy-kurset, skal du opgradere til CoddyKit PRO. Python Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Closures og frie variabler”?

Indfang tilstand i indre funktioner Du øver dig i Python Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Python Academy?

Der kræves ingen tidligere erfaring. Python Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Closures og frie variabler”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Python Academy-lektion?

Ja. Alle Python Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Python Academy