Paradigmas de Linguagens de Programação em Python: Python Funcional (Part. 08)

#Python

A programação funcional é um dos paradigmas mais poderosos e elegantes da computação. Inspirada na matemática e fortemente baseada em funções puras e imutabilidade, essa abordagem permite escrever códigos mais previsíveis, legíveis e fáceis de testar. Neste artigo, vamos mergulhar mais fundo na Programação Funcional com Python, explorando suas principais ideias, recursos nativos da linguagem e exemplos práticos.

⚙️ O que é Programação Funcional?

Na programação funcional, a lógica de um programa é construída usando funções puras, ou seja, funções que não alteram o estado global e sempre retornam o mesmo resultado para os mesmos argumentos. Ao contrário do estilo imperativo, onde o foco está em "como fazer", a abordagem funcional enfatiza "o que deve ser feito".

Essa filosofia é especialmente útil em sistemas paralelos, concorrentes ou distribuídos, onde evitar efeitos colaterais é essencial.

🧱 Princípios Fundamentais

Vamos relembrar os conceitos-chave da programação funcional:

Funções puras: sem efeitos colaterais e dependentes apenas de seus argumentos.
Imutabilidade: variáveis e estruturas de dados não são alteradas após a criação.
Transparência referencial: expressões podem ser substituídas por seus valores sem alterar o comportamento do programa.
Funções de ordem superior: funções que recebem outras funções como parâmetros ou retornam funções.
Recursão: uso da própria função para resolver subproblemas, ao invés de laços de repetição.
Ausência de estado compartilhado: o código evita alterar variáveis globais ou objetos mutáveis.

🧰 Funções Funcionais Nativas em Python

O Python não é uma linguagem puramente funcional, mas possui vários recursos incorporados que facilitam esse estilo:

python

from functools import reduce

valores = [1, 2, 3, 4]

soma = reduce(lambda x, y: x + y, valores)
print(soma)  # Saída: 10

Outras funções úteis:

map(func, iterable)
filter(func, iterable)
reduce(func, iterable) (do módulo functools)
zip()
all(), any(), sorted()

🌀 List Comprehensions e Generator Expressions

As list comprehensions são expressões funcionais poderosas e concisas:

python

quadrados = [x**2 for x in range(5)]

Geradores (generator expressions) permitem trabalhar com grandes volumes de dados sem consumir muita memória:

python

pares = (x for x in range(1000000) if x % 2 == 0)

📌 Decoradores: Funções que Envolvem Funções

Decoradores são funções que recebem outra função e retornam uma versão modificada dela:

python

def logar(func):
  def wrapper(*args, **kwargs):
      print(f"Executando {func.__name__}")
      return func(*args, **kwargs)
  return wrapper

@logar
def somar(a, b):
  return a + b

print(somar(5, 3))

Saída:

nginx

Executando somar
8

🎯 Funções como Cidadãs de Primeira Classe

No Python funcional, funções podem ser armazenadas em variáveis, passadas como argumentos e retornadas como resultados:

python

def cumprimentar(nome):
  return f"Olá, {nome}!"

def executar(funcao, valor):
  return funcao(valor)

print(executar(cumprimentar, "Fernanda"))  # Olá, Fernanda!

🧮 Módulos Funcionais em Python

`functools`

reduce, partial, lru_cache, entre outros.

`itertools`

Geração eficiente de iteradores (infinito, combinatório, filtragem).

`operator`

Operadores como funções (add, mul, itemgetter, etc.)

python

from operator import mul
from functools import reduce

fatorial = reduce(mul, range(1, 6))  # 5! = 120

🔒 Imutabilidade em Python

Embora Python permita mutabilidade, existem maneiras de impor imutabilidade:

python

from collections import namedtuple
from dataclasses import dataclass

# NamedTuple
Pessoa = namedtuple("Pessoa", "nome idade")
p = Pessoa("Alice", 30)

# Dataclass com frozen=True
@dataclass(frozen=True)
class Produto:
  nome: str
  preco: float

🔁 Recursão e Limites em Python

Python suporta recursão, mas com limites (por padrão, ~1000 chamadas). Isso pode ser um desafio ao aplicar soluções recursivas profundas:

python

def fatorial(n):
  if n == 0:
      return 1
  return n * fatorial(n - 1)

print(fatorial(5))  # 120

Python não possui otimização de chamada de cauda (tail call optimization), então loops são geralmente mais eficientes que recursão profunda.

🧪 Exemplo prático: pipeline funcional de transações

python

from functools import reduce

transacoes = [100, -50, 20, -10, 60]

# Filtra valores positivos
positivas = list(filter(lambda x: x > 0, transacoes))

# Soma valores positivos
total = reduce(lambda x, y: x + y, positivas)

print(total)  # 180

✅ Vantagens e Limitações

Vantagens:

Código modular e reutilizável
Fácil de testar e depurar
Ideal para paralelismo e concorrência

Limitações:

Sintaxe pode parecer estranha para iniciantes
Recursão ineficiente em Python
Nem toda biblioteca Python é projetada para estilo funcional

⚡ Funções Parciais e Currying em Python

Explicação do que é currying (aplicação parcial de argumentos).
Uso prático com functools.partial:

python

from functools import partial

def potencia(base, expoente):
  return base ** expoente

quadrado = partial(potencia, expoente=2)
print(quadrado(4))  # 16

🧩 Memoização e Cache com `lru_cache`

Otimização de funções recursivas.
Exemplo prático com cálculo de Fibonacci:

python

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
  if n < 2:
      return n
  return fib(n - 1) + fib(n - 2)

✍️ Composição de Funções (`compose`)

Criação de pipelines de funções.
Implementar sua própria função compose (ou usar de bibliotecas como toolz):

python

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

dobro = lambda x: x * 2
incremento = lambda x: x + 1

nova_funcao = compose(dobro, incremento)
print(nova_funcao(3))  # 8

🧠 Lazy Evaluation com Geradores

Quando e por que usar geradores (yield) em vez de listas.
Diferença entre avaliação imediata e preguiçosa.

💡 Tratamento Funcional de Erros (try-except funcional)

Criar funções seguras que retornam valores padrão em vez de lançar exceções.
Exemplo usando functools.wraps para criar um decorador funcional de segurança.

🧪 Programação Funcional com `toolz` ou `fn.py` (bibliotecas externas)

Recursos funcionais avançados com bibliotecas especializadas.
Exemplo: toolz.curried, compose, pipe, memoize, merge, etc.

🔚 Conclusão

A programação funcional em Python não exige abandonar os outros estilos. Pelo contrário, seu poder está na possibilidade de combinar o melhor dos mundos imperativo, orientado a objetos e funcional. Dominar esse paradigma amplia sua capacidade de escrever código limpo, conciso e robusto — especialmente para tarefas como processamento de dados, manipulação de listas, automação funcional e programação concorrente.

👉 No próximo artigo, vamos explorar Python lógico