Closures

3.1 Introdução aos closures

Closure é uma função que captura variáveis do seu escopo ao redor, mesmo depois que esse escopo terminou a sua execução. Isso significa que um closure pode "lembrar" valores de variáveis do seu escopo externo e continuar a trabalhar com elas, mesmo quando esse escopo não está mais ativo.

Pra entender como os closures funcionam, vamos dar uma olhada no exemplo a seguir:

def outer_function(x):
    def inner_function(y):
        return x + y

    return inner_function
    
closure = outer_function(10)
print(closure(5))  # Saída: 15

Vamos nos aprofundar no que tá rolando aqui:

Função externa (outer_function): Esta função recebe um argumento x e define a função interna inner_function, que aceita um argumento y e retorna a soma de x e y. A função inner_function não é chamada dentro de outer_function, apenas declarada.

Função interna (inner_function): Esta função é retornada de outer_function e guarda internamente uma referência ao valor de x, que foi passado para outer_function.

Closure: A variável closure se torna um closure que "lembra" o valor de x (neste caso, 10) e pode usá-lo quando chamado.

Geralmente, ninguém acerta de primeira ao trabalhar com closures. Então bora tentar aprimorar seu entendimento sobre closures com alguns exemplos.

3.2 Exemplos de uso de closures

Criando uma função geradora

Closures podem ser usados para criar funções geradoras que geram sequências de valores.

def make_counter():
    count = 0

    def counter():
        nonlocal count
        count += 1
        return count

    return counter
    
counter = make_counter()
print(counter())  # Saída: 1
print(counter())  # Saída: 2
print(counter())  # Saída: 3

Explicação:

Função geradora (make_counter): Esta função cria uma variável count e retorna a função interna counter, que incrementa o valor de count e o retorna.

Closure: A função counter guarda o estado da variável count e pode alterá-lo a cada chamada.

Criando uma função com configuração

Closures podem ser usados para criar funções com configuração pré-definida.

def make_multiplier(factor):
    def multiplier(x):
        return x * factor

    return multiplier
    
double = make_multiplier(2)
triple = make_multiplier(3)
    
print(double(5))  # Saída: 10
print(triple(5))  # Saída: 15

Explicação:

Função configuradora (make_multiplier): Esta função recebe um multiplicador factor e retorna a função interna multiplier, que multiplica o valor de entrada por factor.

Closures: As funções double e triple são closures, que guardam seus próprios valores de factor e os usam para multiplicação.

Filtragem de dados com parâmetros

Closures podem ser úteis para criar funções de filtragem com parâmetros.

def make_filter(threshold):
    def filter_func(value):
        return value > threshold
        
    return filter_func
    
filter_above_10 = make_filter(10)
data = [5, 10, 15, 20]
filtered_data = list(filter(filter_above_10, data))
print(filtered_data)  # Saída: [15, 20]

Explicação:

Função de filtro (make_filter): Esta função recebe um valor de limiar threshold e retorna a função interna filter_func, que verifica se o valor excede o limiar.

Closure: A função filter_func guarda o valor de threshold e o usa para filtrar dados.

3.3 Vantagens e desvantagens dos closures

Vantagens do uso de closures

Encapsulamento de estado: Closures permitem encapsular o estado dentro de uma função, evitando variáveis globais e melhorando a legibilidade e manutenção do código.

Flexibilidade: Closures podem ser usados para criar funções com configuração ou comportamento específico, tornando o código mais flexível e adaptável.

Programação funcional: Closures são uma parte importante da programação funcional, permitindo a criação de funções de ordem superior e outras construções funcionais.

Limitações e problemas potenciais

Apesar de muitas vantagens, os closures têm algumas limitações:

Uso de memória: Closures podem manter referências a objetos que não são mais usados, o que pode levar a vazamentos de memória.

Dificuldade de depuração: Closures podem complicar a depuração de código, pois os estados das variáveis podem não ser óbvios.