Arquivo de Funcional - Página 4 de 5

Imutabilidade em Python

25/04/202622/04/2026 Por antonino

– Python
– Funcional
1 – Funcoes puras
2 – Imutabilidade (tuplas, frozenset, namedtuple)
3 – Funcoes de alta ordem (map, filter, reduce)
4 – Comprehensions (list, dict, set)
5 – Geradores (yield, generator expressions)
6 – Decorators (@)
7 – Closures
8 – Funcoes lambda

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Imutabilidade significa que um objeto não pode ser alterado após criado. Qualquer modificação gera um novo objeto na memória. Primeiramente, isso evita efeitos colaterais indesejados em funções. Por exemplo, tuplas são imutáveis, enquanto listas são mutáveis. Além disso, frozenset e namedtuple também seguem esse princípio. A voz passiva é usada aqui: “os dados originais são preservados para sempre”. Quando utilizar imutabilidade? Em chaves de dicionários e conjuntos. Também em programação funcional e dados compartilhados entre threads. Python oferece estruturas imutáveis nativas para esses casos. Vamos explorar tuplas, frozenset e namedtuple em detalhes. Três subtítulos guiarão você pelo mundo da imutabilidade. Ao final, você escolherá a estrutura certa para cada situação.

Tuplas: listas imutáveis

Tuplas são sequências imutáveis de elementos em Python. Você cria uma tupla com parênteses: (1, 2, 3). Quando usar tuplas? Em dados que não devem mudar. Por exemplo, coordenadas geográficas ou cores RGB. A voz passiva é aplicada: “os elementos são acessados por índice”. Exemplo de tuplas e suas características:

# Criando tuplas
vazia = ()
um_elemento = (42,)  # Vírgula é obrigatória!
coordenadas = (10, 20)
cores = ("vermelho", "verde", "azul")
misturada = (1, "texto", 3.14, True)

# Acesso e operações
print("=== Tuplas ===\n")
print(f"coordenadas[0]: {coordenadas[0]}")
print(f"coordenadas[1]: {coordenadas[1]}")

# Fatiamento (slicing)
print(f"cores[1:3]: {cores[1:3]}")
print(f"cores[-1]: {cores[-1]}")

# Imutabilidade (não pode alterar)
try:
    coordenadas[0] = 99
except TypeError as e:
    print(f"Erro ao modificar: {e}")

# Tupla como chave de dicionário (listas não podem!)
pontos = {}
pontos[(10, 20)] = "Ponto A"
pontos[(30, 40)] = "Ponto B"
print(f"Dicionário com chaves tuplas: {pontos}")

# Desempacotamento
x, y = coordenadas
print(f"Desempacotado: x={x}, y={y}")

# Retornando múltiplos valores (comum em funções)
def dividir_com_resto(a, b):
    return (a // b, a % b)  # Retorna tupla

quociente, resto = dividir_com_resto(17, 5)
print(f"17/5: quociente={quociente}, resto={resto}")

# Comparação com listas (performance)
import timeit
lista_teste = [1, 2, 3]
tupla_teste = (1, 2, 3)

tempo_lista = timeit.timeit(lambda: lista_teste[1], number=10_000_000)
tempo_tupla = timeit.timeit(lambda: tupla_teste[1], number=10_000_000)
print(f"\nAcesso: lista={tempo_lista:.4f}s, tupla={tempo_tupla:.4f}s")

# Criando tuplas

vazia = ()

um_elemento = (42,) # Vírgula é obrigatória!

coordenadas = (10, 20)

cores = ("vermelho", "verde", "azul")

misturada = (1, "texto", 3.14, True)

# Acesso e operações

print("=== Tuplas ===\n")

print(f"coordenadas[0]: {coordenadas[0]}")

print(f"coordenadas[1]: {coordenadas[1]}")

# Fatiamento (slicing)

print(f"cores[1:3]: {cores[1:3]}")

print(f"cores[-1]: {cores[-1]}")

# Imutabilidade (não pode alterar)

try:

coordenadas[0] = 99

except TypeError as e:

print(f"Erro ao modificar: {e}")

# Tupla como chave de dicionário (listas não podem!)

pontos = {}

pontos[(10, 20)] = "Ponto A"

pontos[(30, 40)] = "Ponto B"

print(f"Dicionário com chaves tuplas: {pontos}")

# Desempacotamento

x, y = coordenadas

print(f"Desempacotado: x={x}, y={y}")

# Retornando múltiplos valores (comum em funções)

def dividir_com_resto(a, b):

return (a // b, a % b) # Retorna tupla

quociente, resto = dividir_com_resto(17, 5)

print(f"17/5: quociente={quociente}, resto={resto}")

# Comparação com listas (performance)

import timeit

lista_teste = [1, 2, 3]

tupla_teste = (1, 2, 3)

tempo_lista = timeit.timeit(lambda: lista_teste[1], number=10_000_000)

tempo_tupla = timeit.timeit(lambda: tupla_teste[1], number=10_000_000)

print(f"\nAcesso: lista={tempo_lista:.4f}s, tupla={tempo_tupla:.4f}s")

Tuplas são mais rápidas e consomem menos memória que listas. Use tuplas sempre que os dados forem fixos e imutáveis.

Frozenset: conjuntos imutáveis

Frozenset é a versão imutável de um set (conjunto). Ele suporta operações de conjunto sem alterar os dados. Quando usar frozenset? Como chave de dicionário. Também para armazenar dados únicos que não devem mudar. A voz passiva é aplicada: “os elementos são únicos e imutáveis”. Exemplo de frozenset:

# Criando frozensets
set_normal = {1, 2, 3, 3, 4}  # Set mutável
frozen = frozenset([1, 2, 3, 3, 4, 5])
print("=== Frozenset ===\n")
print(f"set_normal: {set_normal}")
print(f"frozenset: {frozen}")

# Operações de conjunto (retornam novos frozensets)
a = frozenset([1, 2, 3, 4])
b = frozenset([3, 4, 5, 6])

print(f"a: {a}")
print(f"b: {b}")
print(f"União: {a | b}")
print(f"Interseção: {a & b}")
print(f"Diferença: {a - b}")
print(f"Diferença simétrica: {a ^ b}")

# Imutabilidade (não pode adicionar)
try:
    frozen.add(10)
except AttributeError as e:
    print(f"Erro ao adicionar: {e}")

# Frozenset como chave de dicionário
categorias = {}
categorias[frozenset(["ativo", "premium"])] = "VIP"
categorias[frozenset(["inativo"])] = "Regular"
print(f"\nDicionário com chaves frozenset: {categorias}")

# Verificação de subconjunto
print(f"a é subconjunto de a|b? {a.issubset(a | b)}")
print(f"a é subconjunto de b? {a.issubset(b)}")

# Frozenset como chave para cache
cache_resultados = {}

def calcular_chave(*args):
    return frozenset(args)

def fibonacci_com_cache(n):
    chave = calcular_chave(n)
    if chave in cache_resultados:
        return cache_resultados[chave]
    
    if n < 2:
        resultado = n
    else:
        resultado = fibonacci_com_cache(n-1) + fibonacci_com_cache(n-2)
    
    cache_resultados[chave] = resultado
    return resultado

print(f"\nFibonacci(10) com cache: {fibonacci_com_cache(10)}")
print(f"Chaves no cache: {list(cache_resultados.keys())}")

# Criando frozensets

set_normal = {1, 2, 3, 3, 4} # Set mutável

frozen = frozenset([1, 2, 3, 3, 4, 5])

print("=== Frozenset ===\n")

print(f"set_normal: {set_normal}")

print(f"frozenset: {frozen}")

# Operações de conjunto (retornam novos frozensets)

a = frozenset([1, 2, 3, 4])

b = frozenset([3, 4, 5, 6])

print(f"a: {a}")

print(f"b: {b}")

print(f"União: {a | b}")

print(f"Interseção: {a & b}")

print(f"Diferença: {a - b}")

print(f"Diferença simétrica: {a ^ b}")

# Imutabilidade (não pode adicionar)

try:

frozen.add(10)

except AttributeError as e:

print(f"Erro ao adicionar: {e}")

# Frozenset como chave de dicionário

categorias = {}

categorias[frozenset(["ativo", "premium"])] = "VIP"

categorias[frozenset(["inativo"])] = "Regular"

print(f"\nDicionário com chaves frozenset: {categorias}")

# Verificação de subconjunto

print(f"a é subconjunto de a|b? {a.issubset(a | b)}")

print(f"a é subconjunto de b? {a.issubset(b)}")

# Frozenset como chave para cache

cache_resultados = {}

def calcular_chave(*args):

return frozenset(args)

def fibonacci_com_cache(n):

chave = calcular_chave(n)

if chave in cache_resultados:

return cache_resultados[chave]

if n < 2:

resultado = n

else:

resultado = fibonacci_com_cache(n-1) + fibonacci_com_cache(n-2)

cache_resultados[chave] = resultado

return resultado

print(f"\nFibonacci(10) com cache: {fibonacci_com_cache(10)}")

print(f"Chaves no cache: {list(cache_resultados.keys())}")

Frozenset é ideal para conjuntos constantes e chaves de dicionário. Ele mantém todas as operações úteis dos sets sem a mutabilidade.

NamedTuple: tuplas com nomes de campos

NamedTuple combina imutabilidade de tupla com nomes de campos. Ela funciona como uma classe leve e imutável. Quando usar NamedTuple? Em estruturas de dados simples. Por exemplo, pontos, pessoas ou produtos imutáveis. A voz passiva é aplicada: “os campos são acessados por nome ou índice”. Exemplo de NamedTuple:

from collections import namedtuple
from typing import NamedTuple  # Python 3.6+

# Forma clássica (collections.namedtuple)
Ponto = namedtuple('Ponto', ['x', 'y'])
Pessoa = namedtuple('Pessoa', 'nome idade cidade')  # String com espaços

print("=== NamedTuple (clássico) ===\n")
p = Ponto(10, 20)
pessoa = Pessoa("Ana", 30, "São Paulo")

print(f"Ponto: {p}")
print(f"Ponto.x: {p.x}, Ponto.y: {p.y}")
print(f"Ponto[0]: {p[0]}, Ponto[1]: {p[1]}")

print(f"\nPessoa: {pessoa}")
print(f"Nome: {pessoa.nome}, Idade: {pessoa.idade}, Cidade: {pessoa.cidade}")

# Imutabilidade
try:
    p.x = 99
except AttributeError as e:
    print(f"Erro ao modificar: {e}")

# Métodos úteis
print(f"\n_replace (cria novo): {p._replace(x=99)}")
print(f"Original permanece: {p}")
print(f"_asdict: {pessoa._asdict()}")
print(f"Campos: {pessoa._fields}")

# NamedTuple com valores padrão (Python 3.6+)
class Config(NamedTuple):
    host: str = "localhost"
    porta: int = 8080
    debug: bool = False

config1 = Config()
config2 = Config(porta=9090, debug=True)
print(f"\n=== NamedTuple (moderno) ===")
print(f"Config padrão: {config1}")
print(f"Config custom: {config2}")

# NamedTuple com docstring e validação (Python 3.6+)
class Produto(NamedTuple):
    nome: str
    preco: float
    estoque: int
    
    def __repr__(self):
        return f"Produto('{self.nome}', R${self.preco:.2f}, {self.estoque})"

produto = Produto("Notebook", 2500.00, 10)
print(f"\nProduto: {produto}")
print(f"Preço: R${produto.preco:.2f}")

# Exemplo prático: dados de sensores
Sensor = namedtuple('Sensor', ['id', 'temperatura', 'umidade', 'timestamp'])

def ler_sensor(id_sensor):
    """Simula leitura de sensor (retorna NamedTuple imutável)."""
    import time
    return Sensor(
        id=id_sensor,
        temperatura=22.5,
        umidade=65,
        timestamp=time.time()
    )

sensor_data = ler_sensor(1)
print(f"\n=== Dados do Sensor ===")
print(f"ID: {sensor_data.id}")
print(f"Temperatura: {sensor_data.temperatura}°C")
print(f"Umidade: {sensor_data.umidade}%")
print(f"Timestamp: {sensor_data.timestamp:.2f}")

# Comparação com dataclasses (mutáveis por padrão)
from dataclasses import dataclass

@dataclass
class ProdutoMutavel:
    nome: str
    preco: float

mutavel = ProdutoMutavel("Mouse", 50)
imutavel = Produto("Teclado", 120, 5)

mutavel.preco = 45  # Permite modificação
print(f"\n=== Mutável vs Imutável ===")
print(f"Produto mutável (preço alterado): {mutavel.preco}")
print(f"Produto imutável: {imutavel}")

from collections import namedtuple

from typing import NamedTuple # Python 3.6+

# Forma clássica (collections.namedtuple)

Ponto = namedtuple('Ponto', ['x', 'y'])

Pessoa = namedtuple('Pessoa', 'nome idade cidade') # String com espaços

print("=== NamedTuple (clássico) ===\n")

p = Ponto(10, 20)

pessoa = Pessoa("Ana", 30, "São Paulo")

print(f"Ponto: {p}")

print(f"Ponto.x: {p.x}, Ponto.y: {p.y}")

print(f"Ponto[0]: {p[0]}, Ponto[1]: {p[1]}")

print(f"\nPessoa: {pessoa}")

print(f"Nome: {pessoa.nome}, Idade: {pessoa.idade}, Cidade: {pessoa.cidade}")

# Imutabilidade

try:

p.x = 99

except AttributeError as e:

print(f"Erro ao modificar: {e}")

# Métodos úteis

print(f"\n_replace (cria novo): {p._replace(x=99)}")

print(f"Original permanece: {p}")

print(f"_asdict: {pessoa._asdict()}")

print(f"Campos: {pessoa._fields}")

# NamedTuple com valores padrão (Python 3.6+)

class Config(NamedTuple):

host: str = "localhost"

porta: int = 8080

debug: bool = False

config1 = Config()

config2 = Config(porta=9090, debug=True)

print(f"\n=== NamedTuple (moderno) ===")

print(f"Config padrão: {config1}")

print(f"Config custom: {config2}")

# NamedTuple com docstring e validação (Python 3.6+)

class Produto(NamedTuple):

nome: str

preco: float

estoque: int

def __repr__(self):

return f"Produto('{self.nome}', R${self.preco:.2f}, {self.estoque})"

produto = Produto("Notebook", 2500.00, 10)

print(f"\nProduto: {produto}")

print(f"Preço: R${produto.preco:.2f}")

# Exemplo prático: dados de sensores

Sensor = namedtuple('Sensor', ['id', 'temperatura', 'umidade', 'timestamp'])

def ler_sensor(id_sensor):

"""Simula leitura de sensor (retorna NamedTuple imutável)."""

import time

return Sensor(

id=id_sensor,

temperatura=22.5,

umidade=65,

timestamp=time.time()

)

sensor_data = ler_sensor(1)

print(f"\n=== Dados do Sensor ===")

print(f"ID: {sensor_data.id}")

print(f"Temperatura: {sensor_data.temperatura}°C")

print(f"Umidade: {sensor_data.umidade}%")

print(f"Timestamp: {sensor_data.timestamp:.2f}")

# Comparação com dataclasses (mutáveis por padrão)

from dataclasses import dataclass

@dataclass

class ProdutoMutavel:

nome: str

preco: float

mutavel = ProdutoMutavel("Mouse", 50)

imutavel = Produto("Teclado", 120, 5)

mutavel.preco = 45 # Permite modificação

print(f"\n=== Mutável vs Imutável ===")

print(f"Produto mutável (preço alterado): {mutavel.preco}")

print(f"Produto imutável: {imutavel}")

NamedTuple oferece a melhor experiência para dados imutáveis. A fórmula da escolha entre estruturas imutáveis: $E = \begin{cases} \text{tupla} & \text{simples e sem nomes} \\ \text{frozenset} & \text{operações de conjunto} \\ \text{namedtuple} & \text{acesso por nome} \end{cases}$ Imutabilidade não é apenas uma restrição, é uma garantia. Use-a para tornar seu código mais seguro e previsível. Tuplas para sequências simples e rápidas. Frozenset para conjuntos únicos que servem como chaves. NamedTuple para objetos leves com campos nomeados. Seu código será mais robusto e fácil de entender.

Funções Puras em Python

25/04/202622/04/2026 Por antonino

– Python
– Funcional
1 – Funcoes puras
2 – Imutabilidade (tuplas, frozenset, namedtuple)
3 – Funcoes de alta ordem (map, filter, reduce)
4 – Comprehensions (list, dict, set)
5 – Geradores (yield, generator expressions)
6 – Decorators (@)
7 – Closures
8 – Funcoes lambda

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Função pura é aquela que sempre produz a mesma saída para uma mesma entrada. Ela não modifica variáveis externas nem causa efeitos colaterais. Primeiramente, funções puras são previsíveis e fáceis de testar. Por exemplo, def soma(a, b): return a + b é pura. Além disso, elas não dependem de estado global ou I/O. A voz passiva é usada aqui: “os dados são transformados sem alteração externa”. Quando utilizar funções puras? Em operações matemáticas e transformações de dados. Também em funções de validação e cálculos repetitivos. Python permite escrever código funcional de forma natural. Vamos explorar características, vantagens e exemplos práticos. Três subtítulos guiarão você pelas funções puras. Ao final, você identificará e criará funções puras com confiança.

Características essenciais das funções puras

Função pura não tem efeitos colaterais observáveis. Ela não altera variáveis globais, arquivos ou bancos de dados. Também não modifica seus argumentos de entrada (imutabilidade). Quando usar essas características? Em código que precisa de confiabilidade. Por exemplo, sistemas financeiros ou de processamento crítico. A voz passiva é aplicada: “os argumentos são tratados como somente leitura”. Exemplo comparando funções puras e impuras:

# FUNÇÕES PURAS

def soma_pura(a, b):
    """Sempre retorna a+b. Sem efeitos colaterais."""
    return a + b

def desconto_puro(preco, percentual):
    """Calcula desconto sem modificar o preço original."""
    return preco * (1 - percentual / 100)

def media_pura(numeros):
    """Calcula média sem modificar a lista original."""
    return sum(numeros) / len(numeros)

def fatorial_puro(n):
    """Fatorial recursivo (puro)."""
    if n <= 1:
        return 1
    return n * fatorial_puro(n - 1)

# FUNÇÕES IMPURAS

saldo_global = 1000

def sacar_impuro(valor):
    """Modifica variável global (efeito colateral)."""
    global saldo_global
    saldo_global -= valor
    return saldo_global

def adicionar_item_impuro(lista, item):
    """Modifica a lista original (efeito colateral)."""
    lista.append(item)
    return lista

def log_impuro(mensagem):
    """Escreve em arquivo (I/O)."""
    with open("log.txt", "a") as f:
        f.write(mensagem + "\n")
    return True

# Demonstração
print("=== Funções Puras ===\n")
print(f"soma_pura(5, 3): {soma_pura(5, 3)}")
print(f"desconto_puro(100, 10): R${desconto_puro(100, 10):.2f}")

numeros = [1, 2, 3, 4, 5]
print(f"media_pura({numeros}): {media_pura(numeros)}")
print(f"fatorial_puro(5): {fatorial_puro(5)}")

print("\n=== Funções Impuras ===")
print(f"Saldo inicial: {saldo_global}")
sacar_impuro(200)
print(f"Após saque: {saldo_global}")

lista_original = [1, 2, 3]
adicionar_item_impuro(lista_original, 4)
print(f"Lista original foi modificada: {lista_original}")

# FUNÇÕES PURAS

def soma_pura(a, b):

"""Sempre retorna a+b. Sem efeitos colaterais."""

return a + b

def desconto_puro(preco, percentual):

"""Calcula desconto sem modificar o preço original."""

return preco * (1 - percentual / 100)

def media_pura(numeros):

"""Calcula média sem modificar a lista original."""

return sum(numeros) / len(numeros)

def fatorial_puro(n):

"""Fatorial recursivo (puro)."""

if n <= 1:

return 1

return n * fatorial_puro(n - 1)

# FUNÇÕES IMPURAS

saldo_global = 1000

def sacar_impuro(valor):

"""Modifica variável global (efeito colateral)."""

global saldo_global

saldo_global -= valor

return saldo_global

def adicionar_item_impuro(lista, item):

"""Modifica a lista original (efeito colateral)."""

lista.append(item)

return lista

def log_impuro(mensagem):

"""Escreve em arquivo (I/O)."""

with open("log.txt", "a") as f:

f.write(mensagem + "\n")

return True

# Demonstração

print("=== Funções Puras ===\n")

print(f"soma_pura(5, 3): {soma_pura(5, 3)}")

print(f"desconto_puro(100, 10): R${desconto_puro(100, 10):.2f}")

numeros = [1, 2, 3, 4, 5]

print(f"media_pura({numeros}): {media_pura(numeros)}")

print(f"fatorial_puro(5): {fatorial_puro(5)}")

print("\n=== Funções Impuras ===")

print(f"Saldo inicial: {saldo_global}")

sacar_impuro(200)

print(f"Após saque: {saldo_global}")

lista_original = [1, 2, 3]

adicionar_item_impuro(lista_original, 4)

print(f"Lista original foi modificada: {lista_original}")

Funções puras são transparentes e previsíveis. Funções impuras podem causar bugs difíceis de rastrear.

Vantagens e benefícios das funções puras

Funções puras são extremamente fáceis de testar unitariamente. Elas não dependem de contexto ou estado externo. Além disso, são seguras para execução paralela (sem locks). Quando usar essas vantagens? Em sistemas concorrentes e testes. Também em código que precisa ser reutilizado em diferentes contextos. A voz passiva é aplicada: “os testes podem ser escritos sem preparação complexa”. Exemplo demonstrando vantagens:

from functools import lru_cache
import time
import threading

# Função pura com cache (memoization)
@lru_cache(maxsize=128)
def fibonacci_puro(n):
    """Fibonacci puro com cache automático."""
    if n < 2:
        return n
    return fibonacci_puro(n - 1) + fibonacci_puro(n - 2)

# Função pura para processamento paralelo
def processar_elemento_puro(x):
    """Processa um elemento sem dependências externas."""
    return x * x - 2 * x + 1

# Demonstração de testabilidade
def testar_funcao_pura():
    """Teste simples sem necessidade de mocks."""
    assert soma_pura(2, 2) == 4
    assert soma_pura(-1, 1) == 0
    assert soma_pura(0, 0) == 0
    print("Todos os testes de soma_pura passaram!")

print("=== Vantagens das Funções Puras ===\n")

# 1. Testabilidade
print("1. Testabilidade:")
testar_funcao_pura()

# 2. Memoization (cache)
print("\n2. Memoization (cache):")
inicio = time.time()
print(f"fibonacci_puro(35): {fibonacci_puro(35)}")
tempo1 = time.time() - inicio

inicio2 = time.time()
print(f"fibonacci_puro(35) (segunda vez): {fibonacci_puro(35)}")
tempo2 = time.time() - inicio2
print(f"Primeira chamada: {tempo1:.4f}s, Segunda: {tempo2:.4f}s (cache)")

# 3. Paralelismo seguro
print("\n3. Paralelismo seguro (sem locks):")
dados = list(range(1000))

def processar_em_paralelo(func, lista):
    """Executa função pura em paralelo (seguro)."""
    from concurrent.futures import ThreadPoolExecutor
    with ThreadPoolExecutor(max_workers=4) as executor:
        resultados = list(executor.map(func, lista))
    return resultados

resultados = processar_em_paralelo(processar_elemento_puro, dados[:10])
print(f"Processamento paralelo dos primeiros 10: {resultados}")

# 4. Composição previsível
print("\n4. Composição previsível:")
def compor(f, g):
    return lambda x: f(g(x))

def mais_um(x):
    return x + 1

def vezes_dois(x):
    return x * 2

f1 = compor(mais_um, vezes_dois)
f2 = compor(vezes_dois, mais_um)
print(f"(mais_um ∘ vezes_dois)(5) = {f1(5)}")
print(f"(vezes_dois ∘ mais_um)(5) = {f2(5)}")

# 5. Referencial transparência
print("\n5. Referencial transparência:")
# Expressão: (soma_pura(3,4) * 2) == (7 * 2)
# Podemos substituir a chamada pelo resultado
print(f"soma_pura(3,4) * 2 = {soma_pura(3,4) * 2}")
print(f"7 * 2 = {7 * 2}")

from functools import lru_cache

import time

import threading

# Função pura com cache (memoization)

@lru_cache(maxsize=128)

def fibonacci_puro(n):

"""Fibonacci puro com cache automático."""

if n < 2:

return n

return fibonacci_puro(n - 1) + fibonacci_puro(n - 2)

# Função pura para processamento paralelo

def processar_elemento_puro(x):

"""Processa um elemento sem dependências externas."""

return x * x - 2 * x + 1

# Demonstração de testabilidade

def testar_funcao_pura():

"""Teste simples sem necessidade de mocks."""

assert soma_pura(2, 2) == 4

assert soma_pura(-1, 1) == 0

assert soma_pura(0, 0) == 0

print("Todos os testes de soma_pura passaram!")

print("=== Vantagens das Funções Puras ===\n")

# 1. Testabilidade

print("1. Testabilidade:")

testar_funcao_pura()

# 2. Memoization (cache)

print("\n2. Memoization (cache):")

inicio = time.time()

print(f"fibonacci_puro(35): {fibonacci_puro(35)}")

tempo1 = time.time() - inicio

inicio2 = time.time()

print(f"fibonacci_puro(35) (segunda vez): {fibonacci_puro(35)}")

tempo2 = time.time() - inicio2

print(f"Primeira chamada: {tempo1:.4f}s, Segunda: {tempo2:.4f}s (cache)")

# 3. Paralelismo seguro

print("\n3. Paralelismo seguro (sem locks):")

dados = list(range(1000))

def processar_em_paralelo(func, lista):

"""Executa função pura em paralelo (seguro)."""

from concurrent.futures import ThreadPoolExecutor

with ThreadPoolExecutor(max_workers=4) as executor:

resultados = list(executor.map(func, lista))

return resultados

resultados = processar_em_paralelo(processar_elemento_puro, dados[:10])

print(f"Processamento paralelo dos primeiros 10: {resultados}")

# 4. Composição previsível

print("\n4. Composição previsível:")

def compor(f, g):

return lambda x: f(g(x))

def mais_um(x):

return x + 1

def vezes_dois(x):

return x * 2

f1 = compor(mais_um, vezes_dois)

f2 = compor(vezes_dois, mais_um)

print(f"(mais_um ∘ vezes_dois)(5) = {f1(5)}")

print(f"(vezes_dois ∘ mais_um)(5) = {f2(5)}")

# 5. Referencial transparência

print("\n5. Referencial transparência:")

# Expressão: (soma_pura(3,4) * 2) == (7 * 2)

# Podemos substituir a chamada pelo resultado

print(f"soma_pura(3,4) * 2 = {soma_pura(3,4) * 2}")

print(f"7 * 2 = {7 * 2}")

Funções puras simplificam testes, cache e paralelismo. Elas são a base para código robusto e escalável.

Identificando e transformando funções impuras

Nem toda função precisa ou deve ser pura. I/O, rede, banco de dados e aleatoriedade exigem impureza. Quando identificar uma função impura? Quando ela lê arquivos ou gera números. Também quando modifica estado global ou argumentos mutáveis. A voz passiva é aplicada: “a impureza é isolada nas bordas do sistema”. Exemplo de como transformar funções impuras em puras:

import random
import datetime

# === FUNÇÃO IMPURA ORIGINAL ===
def gerar_saudacao_impura(nome):
    """Usa data/hora atual (impuro)."""
    hora = datetime.datetime.now().hour
    if hora < 12:
        periodo = "bom dia"
    elif hora < 18:
        periodo = "boa tarde"
    else:
        periodo = "boa noite"
    return f"Olá {nome}, {periodo}!"

# === VERSÃO PURA (recebe a hora como parâmetro) ===
def gerar_saudacao_pura(nome, hora):
    """Versão pura: depende apenas dos argumentos."""
    if hora < 12:
        periodo = "bom dia"
    elif hora < 18:
        periodo = "boa tarde"
    else:
        periodo = "boa noite"
    return f"Olá {nome}, {periodo}!"

# === FUNÇÃO IMPURA ORIGINAL ===
def sorteio_impura():
    """Depende de random (impuro)."""
    return random.randint(1, 100)

# === VERSÃO PURA (recebe semente ou valor) ===
def sorteio_pura(semente):
    """Versão pura: usa a semente para gerar número."""
    import hashlib
    hash_valor = int(hashlib.md5(str(semente).encode()).hexdigest()[:8], 16)
    return (hash_valor % 100) + 1

# === FUNÇÃO IMPURA ORIGINAL ===
contador_global = 0
def contador_impuro():
    """Modifica estado global (impuro)."""
    global contador_global
    contador_global += 1
    return contador_global

# === VERSÃO PURA ===
def contador_pura(estado):
    """Recebe estado atual, retorna novo estado e valor."""
    novo_estado = estado + 1
    return novo_estado, novo_estado

# Demonstração
print("=== Transformando Funções Impuras em Puras ===\n")

print("Saudação original (impura):")
print(gerar_saudacao_impura("Ana"))
print(gerar_saudacao_impura("Ana"))  # Pode mudar

print("\nSaudação pura (com hora fixa):")
print(gerar_saudacao_pura("Ana", 8))
print(gerar_saudacao_pura("Ana", 15))
print(gerar_saudacao_pura("Ana", 20))

print(f"\nSorteio impuro: {sorteio_impura()}, {sorteio_impura()}")
print(f"Sorteio puro (semente 42): {sorteio_pura(42)}")
print(f"Sorteio puro (semente 42): {sorteio_pura(42)} (mesmo resultado)")

print(f"\nContador impuro: {contador_impuro()}, {contador_impuro()}")
estado = 0
estado, valor1 = contador_pura(estado)
estado, valor2 = contador_pura(estado)
print(f"Contador puro: {valor1}, {valor2}")

# Estratégia de isolamento (bordas impuras)
def processar_dados(linhas):
    """Função pura que processa linhas."""
    return [linha.strip().upper() for linha in linhas if linha.strip()]

def ler_arquivo_impuro(caminho):
    """Função impura na borda (I/O)."""
    with open(caminho, 'r') as f:
        return f.readlines()

# Exemplo com arquivo (cria para demonstração)
with open("teste_puro.txt", "w") as f:
    f.write("linha 1\n")
    f.write("\n")
    f.write("linha 2\n")
    f.write("  linha com espaços  \n")

# Borda impura + núcleo puro
linhas_impuras = ler_arquivo_impuro("teste_puro.txt")
resultado_puro = processar_dados(linhas_impuras)
print(f"\nArquivo processado: {resultado_puro}")

import random

import datetime

# === FUNÇÃO IMPURA ORIGINAL ===

def gerar_saudacao_impura(nome):

"""Usa data/hora atual (impuro)."""

hora = datetime.datetime.now().hour

if hora < 12:

periodo = "bom dia"

elif hora < 18:

periodo = "boa tarde"

else:

periodo = "boa noite"

return f"Olá {nome}, {periodo}!"

# === VERSÃO PURA (recebe a hora como parâmetro) ===

def gerar_saudacao_pura(nome, hora):

"""Versão pura: depende apenas dos argumentos."""

if hora < 12:

periodo = "bom dia"

elif hora < 18:

periodo = "boa tarde"

else:

periodo = "boa noite"

return f"Olá {nome}, {periodo}!"

# === FUNÇÃO IMPURA ORIGINAL ===

def sorteio_impura():

"""Depende de random (impuro)."""

return random.randint(1, 100)

# === VERSÃO PURA (recebe semente ou valor) ===

def sorteio_pura(semente):

"""Versão pura: usa a semente para gerar número."""

import hashlib

hash_valor = int(hashlib.md5(str(semente).encode()).hexdigest()[:8], 16)

return (hash_valor % 100) + 1

# === FUNÇÃO IMPURA ORIGINAL ===

contador_global = 0

def contador_impuro():

"""Modifica estado global (impuro)."""

global contador_global

contador_global += 1

return contador_global

# === VERSÃO PURA ===

def contador_pura(estado):

"""Recebe estado atual, retorna novo estado e valor."""

novo_estado = estado + 1

return novo_estado, novo_estado

# Demonstração

print("=== Transformando Funções Impuras em Puras ===\n")

print("Saudação original (impura):")

print(gerar_saudacao_impura("Ana"))

print(gerar_saudacao_impura("Ana")) # Pode mudar

print("\nSaudação pura (com hora fixa):")

print(gerar_saudacao_pura("Ana", 8))

print(gerar_saudacao_pura("Ana", 15))

print(gerar_saudacao_pura("Ana", 20))

print(f"\nSorteio impuro: {sorteio_impura()}, {sorteio_impura()}")

print(f"Sorteio puro (semente 42): {sorteio_pura(42)}")

print(f"Sorteio puro (semente 42): {sorteio_pura(42)} (mesmo resultado)")

print(f"\nContador impuro: {contador_impuro()}, {contador_impuro()}")

estado = 0

estado, valor1 = contador_pura(estado)

estado, valor2 = contador_pura(estado)

print(f"Contador puro: {valor1}, {valor2}")

# Estratégia de isolamento (bordas impuras)

def processar_dados(linhas):

"""Função pura que processa linhas."""

return [linha.strip().upper() for linha in linhas if linha.strip()]

def ler_arquivo_impuro(caminho):

"""Função impura na borda (I/O)."""

with open(caminho, 'r') as f:

return f.readlines()

# Exemplo com arquivo (cria para demonstração)

with open("teste_puro.txt", "w") as f:

f.write("linha 1\n")

f.write("\n")

f.write("linha 2\n")

f.write(" linha com espaços \n")

# Borda impura + núcleo puro

linhas_impuras = ler_arquivo_impuro("teste_puro.txt")

resultado_puro = processar_dados(linhas_impuras)

print(f"\nArquivo processado: {resultado_puro}")

Isolando impurezas nas bordas do sistema, o núcleo fica puro. A fórmula da pureza de uma função pode ser expressa: $P = \frac{\text{mesma saída para mesma entrada}}{\text{sem efeitos colaterais}}$ Funções puras não são bala de prata para tudo. Para I/O e interação com usuário, impureza é necessária. Porém, maximize funções puras no núcleo da sua lógica. Seu código será mais fácil de entender, testar e manter.