Conteúdo do curso Lição 19 de 246 · Módulo 1: Python para este curso
Módulo 1: Python para este curso

Objetos que lembram (classes e closures)

Por que isso importa No Módulo 4 você vai construir um motor de autograd. É uma classe cujos objetos somam e multiplicam com + e @ comuns, e cada resultado mantém uma pequena function que lembra como foi feito. Esta lição é o Python por trás disso.

A classe

A é uma receita para 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

Fazendo + e @ funcionarem

Quando o Python vê a + b nos seus objetos, ele chama a.__add__(b). Para a @ b ele chama a.__matmul__(b). Escreva esses métodos e seus objetos funcionam com os símbolos normais. Os nomes com dois underscores em cada lado são chamados de métodos dunder.

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

valor que é computado quando você pede (@property)

Coloque @property acima de um método e você o lê como um valor armazenado, sem colchetes: b.size em vez de b.size(). Ele é calculado do zero cada vez.

Funções pequenas: lambda

square = lambda x: x * x é uma função de uma linha sem nome próprio. É o mesmo que def square(x): return x * x.

Funções que lembram (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

Ler uma variável lembrada simplesmente funciona. Mudar uma precisa de cuidado: count += 1 dentro da função interna faz o Python tratar count como uma variável local novinha, e você recebe UnboundLocalError. Duas correções: escreva nonlocal count como a primeira linha da função interna, que diz "a contagem de fora", ou mantenha o número dentro de uma list, count = [0], e mude count[0], que edita a list em vez de reatribuir o nome.

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

A função interna mantém as variáveis que usou da função que a criou, mesmo depois que essa função terminou. Autograd usa exatamente isso: cada resultado de + ou * armazena uma pequena closure que lembra suas entradas, pronta para enviar gradientes de volta para elas depois.

Class: uma receita para objetos. Method: uma função que pertence a um objeto e o recebe como self. Closure: uma função interna que lembra variáveis de onde foi criada.

Resumo __init__ define um objeto, __add__ e __matmul__ dão a ele + e @, @property parece um valor, e uma closure carrega sua própria memória.

Palavras e símbolos nesta lição
a @ b
multiplicação de matriz (também o produto escalar para duas listas de números)
Sua vez

Termine a classe Vec, uma lista de números que faz matemática. Vec([1, 2]) + Vec([3, 4]) deve dar uma nova Vec segurando [4, 6] (somar item por item); Vec([1, 2]) @ Vec([3, 4]) deve dar o número 11 (multiplicar item por item e somar); Vec([3, 4]).size deve ser 5.0 (o comprimento, a raiz quadrada da soma dos quadrados), lido como uma propriedade. Nenhum input pode mudar. Depois escreva make_counter(): ela retorna uma função que, cada vez que é chamada, retorna 1, depois 2, depois 3 e assim por diante, com cada contador contando por si só.

Viu um problema nesta lição? Reporte-o · Pergunte sobre esta lição

Este exercício abre em breve

Termine a lição anterior para que esta seja desbloqueada. O curso inteiro é gratuito, não precisa de conta, e você pode ler esta lição agora mesmo.