Funções Avançadas

O que são funções avancadas?

Lambda é uma função anônima que cabe em uma linha. Você usa quando precisa de algo rápido, geralmente como argumento de outra função. Além de lambda, Python permite passar funções como parâmetros (callbacks) e até fazer funções que chamam a si mesmas (recursão).

O conceito mais importante desta aula é o Princípio de Responsabilidade Única: cada função faz uma coisa só. Isso deixa o código mais fácil de testar e manter.

Lambda -- função mini em uma linha

A sintaxe é lambda parâmetros: expressao. Sem def, sem return, sem nome:

dobrar = lambda x: x * 2
print(dobrar(5))  # → 10

Lambda brilha como argumento de outras funções:

números: list[int] = [5, 2, 8, 1, 9, 3]

ordenados: list[int] = sorted(números, key=lambda x: -x)
print(ordenados)  # → [9, 8, 5, 3, 2, 1]

maiores: list[int] = list(filter(lambda x: x > 5, números))
print(maiores)  # → [8, 9]

quadrados: list[int] = list(map(lambda x: x ** 2, números))
print(quadrados)  # → [25, 4, 64, 1, 81, 9]

Lambda com multiplos parâmetros

Dá para usar mais de um parâmetro:

alunos: list[tuple[str, float]] = [("Ana", 8.5), ("Bruno", 7.0), ("Carla", 9.2)]
por_nota: list[tuple[str, float]] = sorted(alunos, key=lambda a: a[1], reverse=True)
print(por_nota)  # → [('Carla', 9.2), ('Ana', 8.5), ('Bruno', 7.0)]

Funções como parâmetros (callbacks)

Em Python, funções são objetos. Você pode passar uma função como argumento de outra:

def aplicar_operacao(a: float, b: float, operação) -> float:
    return operação(a, b)

soma: float = aplicar_operacao(10, 5, lambda a, b: a + b)
print(f"Soma: {soma}")  # → Soma: 15

mult: float = aplicar_operacao(10, 5, lambda a, b: a * b)
print(f"Multiplicação: {mult}")  # → Multiplicação: 50

Callback com Callable tipado

Para tipar corretamente o parâmetro que recebe uma função, use Callable:

from typing import Callable

def processar_lista(
    números: list[float],
    transformar: Callable[[float], float]
) -> list[float]:
    return [transformar(n) for n in números]

valores: list[float] = [10, 20, 30, 40, 50]
dobrados: list[float] = processar_lista(valores, lambda x: x * 2)
print(dobrados)  # → [20, 40, 60, 80, 100]

Recursão -- função que chama a si mesma

Toda recursão precisa de duas coisas: um caso base (quando parar) é um caso recursivo (chamar com dado menor):

def fatorial(n: int) -> int:
    if n == 0 or n == 1:  # caso base
        return 1
    return n * fatorial(n - 1)  # caso recursivo

print(fatorial(5))  # → 120 (5 * 4 * 3 * 2 * 1)

Responsabilidade Única (SRP)

Cada função faz UMA coisa. Compare:

# Ruim - faz tudo junto
def processar_aluno(nome: str, notas: list[float]) -> None:
    média = sum(notas) / len(notas)
    status = "Aprovado" if média >= 7 else "Reprovado"
    print(f"{nome}: {média:.1f} - {status}")

# Bom - cada função tem seu papel
def calcular_media(notas: list[float]) -> float:
    return sum(notas) / len(notas)

def classificar(média: float) -> str:
    return "Aprovado" if média >= 7.0 else "Reprovado"

def exibir_resultado(nome: str, média: float, status: str) -> None:
    print(f"{nome}: {média:.1f} - {status}")

Exercício prático

Crie um mini sistema de calculadora usando callbacks:

1. Uma função calcular(a, b, operação) que recebe dois números é uma função
2. Lambdas para soma, subtração, multiplicação e divisão
3. Use Callable para tipar o parâmetro operação

from typing import Callable

# 1. def calcular(a: float, b: float, operação: Callable[[float, float], float]) -> float:

# 2. Teste com lambdas:
# calcular(10, 3, lambda a, b: a + b)  → 13
# calcular(10, 3, lambda a, b: a - b)  → 7
# calcular(10, 3, lambda a, b: a * b)  → 30
# calcular(10, 3, lambda a, b: a / b)  → 3.33

Referências

• Lambda Expressions -- documentação oficial Python
• Recursion in Python -- guia completo no Real Python
• Curso Python #16 - Funções (Parte 2) -- Curso em Video