Temario Lección 19 de 246 · Módulo 1: Python para este curso
Módulo 1: Python para este curso

Objetos que recuerdan (clases y closures)

Por qué importa En el Módulo 4 construirás un motor de autograd. Es una clase cuyos objetos se suman y se multiplican con los + y @ de siempre, y cada resultado guarda una pequeña función que recuerda cómo se hizo. Esta lección es el Python que hay detrás.

Una clase es una receta de objetos

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

Hacer que funcionen + y @

Cuando Python ve a + b sobre tus objetos, llama a a.__add__(b). Para a @ b llama a a.__matmul__(b). Escribe esos métodos y tus objetos funcionan con los símbolos normales. Los nombres con dos guiones bajos a cada lado se llaman métodos dunder.

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

Un valor que se calcula cuando lo pides (@property)

Pon @property encima de un método y lo lees como un valor guardado, sin paréntesis: b.size en vez de b.size(). Se calcula de nuevo cada vez.

Funciones pequeñas: lambda

square = lambda x: x * x es una función de una línea sin nombre propio. Es lo mismo que def square(x): return x * x.

Funciones que recuerdan (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

Leer una variable recordada funciona sin más. Cambiarla requiere cuidado: count += 1 dentro de la función interior hace que Python trate count como una variable local nueva, y obtienes UnboundLocalError. Dos arreglos: escribir nonlocal count como primera línea de la función interior, que dice "el count de fuera", o guardar el número dentro de una lista, count = [0], y cambiar count[0], que edita la lista en vez de reasignar el nombre.

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

La función interior conserva las variables que usó de la función que la creó, incluso después de que esa función haya terminado. El autograd usa exactamente esto: cada resultado de + o * guarda una closure diminuta que recuerda sus entradas, lista para enviarles los gradientes más tarde.

Clase: una receta de objetos. Método: una función que pertenece a un objeto y lo recibe como self. Closure: una función interior que recuerda variables del sitio donde se creó.

Resumen __init__ prepara un objeto, __add__ y __matmul__ le dan + y @, @property se lee como un valor, y una closure lleva su propia memoria.

Palabras y símbolos de esta lección
a @ b
multiplicación de matrices (también el producto escalar de dos listas de números)
Tu turno

Termina la clase Vec, una lista de números que hace cuentas. Vec([1, 2]) + Vec([3, 4]) debe dar un Vec nuevo con [4, 6] (sumando elemento a elemento); Vec([1, 2]) @ Vec([3, 4]) debe dar el número 11 (multiplicando elemento a elemento y sumando); Vec([3, 4]).size debe ser 5.0 (la longitud, la raíz cuadrada de la suma de los cuadrados), leída como propiedad. Ninguna entrada puede cambiar. Luego escribe make_counter(): devuelve una función que, cada vez que se llama, devuelve 1, luego 2, luego 3 y así sucesivamente, con cada contador contando por su cuenta.

¿Has visto un problema en esta lección? Avísanos · Preguntar sobre esta lección

Este ejercicio se abre pronto

Termina la lección anterior y esta se desbloquea. Todo el curso es gratis, no hace falta cuenta, y puedes leer esta lección ahora mismo.