Programma Les 19 van 246 · Module 1: Python voor deze cursus
Module 1: Python voor deze cursus

Objecten die onthouden (classes en closures)

Waarom dit ertoe doet In Module 4 bouw je een autograd engine. Het is een class waarvan de objecten optellen en vermenigvuldigen met gewone + en @, en elk resultaat houdt een kleine functie die onthoudt hoe het gemaakt is. Deze les is de Python achter dat.

A class is een recept voor objecten

class Box:
    def __init__(self, value):      # runs when you write Box(3)
        self.value = value          # self is the object being made

    def doubled(self):              # a method: a function that belongs to the object
        return Box(self.value * 2)


b = Box(3)
b.value          # 3
b.doubled().value   # 6

Het werken van + en @ maken

Wanneer Python a + b op je objecten ziet, roept het a.__add__(b) aan. Voor a @ b roept het a.__matmul__(b) aan. Schrijf die methoden en je objecten werken met de normale symbolen. De namen met twee underscores aan elke kant worden dunder methoden genoemd.

    def __add__(self, other):
        return Box(self.value + other.value)

een waarde die wordt berekend wanneer je vraagt (@property)

@property boven een methode en je leest het als een opgeslagen waarde, zonder haakjes: b.size in plaats van b.size(). Het wordt elke keer opnieuw berekend.

Kleine functies: lambda

square = lambda x: x * x is een eenregelige functie zonder eigen naam. Het is hetzelfde als def square(x): return x * x.

Functies die onthouden (closures)

def make_scaler(k):
    def scale(x):
        return k * x       # k comes from the call to make_scaler
    return scale


triple = make_scaler(3)
triple(5)        # 15: scale still remembers k = 3

Het lezen van een onthoudene variabele werkt gewoon. Het aanpassen ervan vereist zorg: count += 1 binnen de innerlijke functie zorgt ervoor dat Python count behandelt als een gloednieuwe lokale variabele, en je krijgt UnboundLocalError. Twee oplossingen: schrijf nonlocal count als de eerste regel van de innerlijke functie, wat zegt "de telling van buiten", of houd het getal binnen een lijst, count = [0], en verander count[0], wat de lijst aanpast in plaats van de naam opnieuw aanwijst.

def make_total():
    total = 0
    def add(x):
        nonlocal total     # without this line: UnboundLocalError
        total += x
        return total
    return add

De inner functie behoudt de variabelen die het gebruikte van de functie die het maakte, zelfs nadat die functie is afgerond. Autograd gebruikt precies dit: elk resultaat van + of * slaat een kleine closure op die zijn inputs onthoudt, klaar om later gradiënten naar hen terug te sturen.

Class: een recept voor objecten. Method: een functie die bij een object hoort en het als self ontvangt. Closure: een innerlijke functie die variabelen onthoudt van waar het is gemaakt.

Samenvatting __init__ stelt een object in, __add__ en __matmul__ geven het + en @, @property leest als een waarde, en een closure draagt zijn eigen geheugen.

Woorden en symbolen in deze les
a @ b
matrix multiply (ook het dot product voor twee lijsten van getallen)
Jij bent aan de beurt

Maak de klasse Vec, een lijst van getallen die wiskunde doet. Vec([1, 2]) + Vec([3, 4]) moet een nieuwe Vec geven die [4, 6] bevat (tel item voor item); Vec([1, 2]) @ Vec([3, 4]) moet het getal 11 geven (vermenigvuldig item voor item en tel op); Vec([3, 4]).size moet 5.0 zijn (de lengte, de wortel van de som van de kwadraten), gelezen als een property. Geen van de inputs mag veranderen. Schrijf dan make_counter(): het geeft een functie terug die, elke keer dat het wordt aangeroepen, 1 teruggeeft, dan 2, dan 3 enzovoort, waarbij elke teller op zijn eigen manier telt.

Een probleem ontdekt in deze les? Meld het · Vraag naar deze les

Deze oefening opent binnenkort

Maak de les ervoor af voordat deze wordt ontgrendeld. De hele cursus is gratis, geen account nodig, en je kunt deze les nu lezen.