Programação funcional

Funções livres de efeitos

Uma função pura devolve o mesmo resultado para os mesmos argumentos e não tem efeitos observáveis fora do cálculo. Ler a hora, pedir entrada, imprimir, alterar uma lista recebida ou atualizar estado global quebra essa condição.

sorted(notas) cria outra lista, enquanto notas.sort() altera a existente. Uma solução livre de efeitos devolve os dados transformados e deixa a apresentação para outra parte do programa.

def com_bonus(notas, bonus):
    resultado = []
    for nota in notas:
        resultado.append(nota + bonus)
    return resultado

notas = [10, 14]
print(com_bonus(notas, 2))
print(notas)

A saída é [12, 16] e [10, 14]; o ciclo calcula nota + bonus para cada entrada e constrói outra lista, como a compreensão equivalente da lição de compreensões.

Observa o contrato: cada resultado depende dos argumentos e as notas originais permanecem iguais.

Python permite misturar estilos. Se um exercício exige um estilo sem atribuições nem mutação, esse requisito é mais restrito do que a pureza. Nesse caso, usa operações sobre valores e funções de ordem superior em vez de atualizar uma coleção.

Funções são valores

O nome de uma função pode ser guardado, passado ou devolvido. quadrado é o objeto função; quadrado(3) é o resultado da chamada. Passar quadrado(3) onde se espera uma função passa o número 9 e impede a chamada posterior.

def quadrado(x):
    return x * x

def aplicar_duas_vezes(funcao, x):
    return funcao(funcao(x))

print(aplicar_duas_vezes(quadrado, 2))

O resultado é 16, pois 2 passa primeiro a 4 e depois a 16. Uma função que recebe ou devolve outras funções é uma função de ordem superior, e um predicado é uma função usada para decidir se um valor satisfaz uma condição, como x > 0.

Funções de ordem superior e lambda

lambda x: x * x cria uma função com uma expressão como corpo. Não é uma instrução para executar já. Usa def quando precisas de vários passos ou quando dar um nome à operação ajuda a ler.

alunos = [("Ana", 15), ("Bruno", 12), ("Carla", 15)]
ordenados = sorted(alunos, key=lambda aluno: (-aluno[1], aluno[0]))
print(ordenados)
print(alunos)

A chave é um tuplo: Python compara primeiro o primeiro campo, só usando o segundo em caso de empate.

Como -15 é menor que -12, o negativo da nota põe as notas maiores primeiro e o nome desempata por ordem crescente; a entrada permanece igual. sorted é estável: elementos com chaves iguais conservam a ordem relativa que tinham na entrada.

Map, filter e reduce

map(f, xs) aplica f a cada elemento, enquanto filter(p, xs) conserva os elementos para os quais o predicado p dá um valor verdadeiro. Em Python 3, ambos devolvem iteradores, como os da lição de compreensões, e list materializa os resultados, por isso depois de converteres um filter em lista uma segunda conversão dá [].

reduce, de functools, combina os elementos da esquerda para a direita com um acumulador: com valor inicial z e elementos a, b, c, calcula f(f(f(z, a), b), c). Esse percurso também se chama fold à esquerda; sem valor inicial, a primeira entrada torna-se o acumulador e a sequência vazia causa TypeError.

from functools import reduce

valores = [1, 2, 3, 4, 5]
impares = filter(lambda x: x % 2 != 0, valores)
quadrados = map(lambda x: x * x, impares)
soma = reduce(lambda acumulado, x: acumulado + x, quadrados, 0)
print(soma)
print(valores)
print(reduce(lambda a, x: a + x, [], 0))

Segue o exemplo com valores = [1, 2, 3, 4, 5]:

Os iteradores não guardam estas listas intermédias: quando reduce pede o próximo quadrado, map pede o próximo ímpar a filter, que avança na entrada até o encontrar.

A tabela separa as etapas para mostrar os valores, mas uma chamada a list(impares) antes do cálculo consumiria o filtro e deixaria a redução sem termos.

O valor inicial também define a resposta para a entrada vazia. Para somar, sum é uma alternativa direta; aqui usamos reduce para seguir o acumulador.

A ordem importa se a operação não for associativa. reduce(lambda a, x: a - x, [2, 3], 10) calcula (10 - 2) - 3, que vale 5. Não calcula 10 - (2 - 3).

Any, all e condições sobre coleções

any decide se existe pelo menos um valor verdadeiro num iterável; all decide se todos os valores são verdadeiros. Ambas param logo que a resposta fica determinada: any no primeiro verdadeiro, all no primeiro falso. any([]) é False, pois não há testemunho; all([]) é True, pois não há um elemento que viole a condição. Uma regra que também exige pelo menos um elemento precisa de verificar essa existência separadamente.

Suponhamos que cada caixa guarda um conjunto de peças. Queremos saber se cada peça pedida existe em alguma caixa, podendo usar caixas diferentes:

caixas = [{"parafuso"}, {"porca", "anilha"}]
pedidas = ["parafuso", "porca"]
print(all(any(peca in caixa for caixa in caixas) for peca in pedidas))

A saída é True. Para parafuso há uma caixa que o contém; para porca também, ainda que seja outra. Trocar a ordem para any(all(peca in caixa for peca in pedidas) for caixa in caixas) pede uma caixa que contenha todas as peças e dá False neste exemplo. A ordem dos percursos exprime duas condições diferentes.

Se não há peças pedidas, a primeira condição é verdadeira mesmo sem caixas. Com peças pedidas e nenhuma caixa, é falsa. Usámos listas e conjuntos que permitem novos percursos; reutilizar um único iterador de caixas já consumido poderia perder candidatos na segunda peça.

Devolver funções e âmbito léxico

Uma função interior pode conservar acesso ao contexto onde foi criada. Chamamos closure a essa combinação de função e contexto.

def multiplicador(fator):
    def multiplicar(x):
        return fator * x
    return multiplicar

dobro = multiplicador(2)
triplo = multiplicador(3)
print(dobro(5), triplo(5))

As duas funções conservam fatores diferentes. return multiplicar devolve a função, sem a chamar. Depois de multiplicador regressar, o fator de cada contexto continua acessível.

A closure consulta as associações dos nomes conservados. Não faz uma cópia automática dos seus valores. Este contraexemplo cria três funções que consultam o mesmo nome fator:

funcoes = [lambda x: fator * x for fator in range(1, 4)]
print([f(10) for f in funcoes])

A saída é [30, 30, 30]. Quando chamamos as funções, o percurso já acabou e fator vale 3. Com [multiplicador(fator) for fator in range(1, 4)], cada chamada cria um contexto próprio e a saída passa a [10, 20, 30].

Compor sem perder o contrato

Para compor f e g, calculamos primeiro g(x) e passamos esse resultado a f, e a função devolvida conserva ambas:

def compor(f, g):
    return lambda x: f(g(x))

quadrado_depois = compor(lambda x: x * x, lambda x: x + 1)
incremento_depois = compor(lambda x: x + 1, lambda x: x * x)
print(quadrado_depois(3), incremento_depois(3))

A saída é 16 10: $(3+1)^2$ difere de $3^2+1$, por isso o resultado de g tem de ser uma entrada válida para f.

Transformar, filtrar e acumular são decisões diferentes. A ordem pode mudar o resultado: elevar ao quadrado antes de filtrar os positivos conserva quadrados de valores originalmente negativos. Escreve primeiro a condição sobre os dados de entrada, depois escolhe a sequência de operações. Uma função chamada por map ou filter também deve respeitar a ausência de efeitos quando esse é o contrato do programa.