antonino, Autor em Área de Trampo

Programação Imperativa e Procedural

22/05/202622/04/2026 Por antonino

Programação imperativa descreve o programa como sequência de comandos. Ela foca em “como fazer” passo a passo. Primeiramente, o código modifica estado através de variáveis. Por exemplo, loops for e while controlam o fluxo. Além disso, condicionais if-else tomam decisões. A voz passiva é usada aqui: “as instruções são executadas em ordem”. Quando utilizar programação imperativa? Em scripts simples e algoritmos. Também em código onde performance e controle são críticos. A programação procedural é uma extensão com funções. Ela organiza o código em blocos reutilizáveis e modulares. Vamos explorar ambos os paradigmas com exemplos. Três subtítulos guiarão você pelo estilo imperativo. Ao final, você entenderá as bases de toda programação.

Imperativo puro: sequência, decisão e repetição

Programação imperativa usa três estruturas fundamentais. Sequência executa comandos um após o outro. Decisão (if) escolhe caminhos diferentes. Repetição (for, while) executa blocos múltiplas vezes. Quando usar imperativo puro? Em algoritmos simples e diretos. Também em código de inicialização e configuração. A voz passiva é aplicada: “as variáveis são atualizadas diretamente”. Exemplo de programação imperativa:

# Exemplo imperativo: cálculo de fatorial
print("=== Programação Imperativa ===")
n = 5
fatorial = 1
i = 1

# Sequência com repetição
while i <= n:
    fatorial = fatorial * i  # Modifica estado
    i = i + 1
print(f"Fatorial de {n} é {fatorial}")

# Exemplo: soma de números pares até um limite
limite = 10
soma_pares = 0
for numero in range(1, limite + 1):
    if numero % 2 == 0:  # Decisão
        soma_pares = soma_pares + numero  # Modifica estado
print(f"Soma dos pares até {limite}: {soma_pares}")

# Exemplo: busca linear em lista
lista = [3, 7, 2, 9, 5, 1, 8]
alvo = 9
encontrado = False
posicao = -1

for i in range(len(lista)):
    if lista[i] == alvo:
        encontrado = True
        posicao = i
        break

if encontrado:
    print(f"Elemento {alvo} encontrado na posição {posicao}")
else:
    print(f"Elemento {alvo} não encontrado")

# Exemplo: contagem de vogais
texto = "Python é incrível"
vogais = "aeiouAEIOU"
contagem = 0

for letra in texto:
    if letra in vogais:
        contagem += 1

print(f"Vogais em '{texto}': {contagem}")

# Exemplo imperativo: cálculo de fatorial

print("=== Programação Imperativa ===")

n = 5

fatorial = 1

i = 1

# Sequência com repetição

while i <= n:

fatorial = fatorial * i # Modifica estado

i = i + 1

print(f"Fatorial de {n} é {fatorial}")

# Exemplo: soma de números pares até um limite

limite = 10

soma_pares = 0

for numero in range(1, limite + 1):

if numero % 2 == 0: # Decisão

soma_pares = soma_pares + numero # Modifica estado

print(f"Soma dos pares até {limite}: {soma_pares}")

# Exemplo: busca linear em lista

lista = [3, 7, 2, 9, 5, 1, 8]

alvo = 9

encontrado = False

posicao = -1

for i in range(len(lista)):

if lista[i] == alvo:

encontrado = True

posicao = i

break

if encontrado:

print(f"Elemento {alvo} encontrado na posição {posicao}")

else:

print(f"Elemento {alvo} não encontrado")

# Exemplo: contagem de vogais

texto = "Python é incrível"

vogais = "aeiouAEIOU"

contagem = 0

for letra in texto:

if letra in vogais:

contagem += 1

print(f"Vogais em '{texto}': {contagem}")

Imperativo puro é simples e de fácil entendimento. Ele reflete diretamente como o computador executa.

Procedural: organizando código com funções

Programação procedural adiciona funções ao imperativo. Ela evita repetição e melhora a legibilidade. Quando usar procedural? Em projetos de médio porte. Também quando a lógica pode ser dividida em etapas. A voz passiva é aplicada: “os dados são passados entre funções”. Exemplo de programação procedural:

# Programação procedural com funções
def calcular_media(numeros):
    """Calcula média de uma lista de números."""
    if not numeros:
        return 0
    soma = 0
    for n in numeros:
        soma += n
    return soma / len(numeros)

def filtrar_maiores_que(lista, limite):
    """Retorna apenas números maiores que o limite."""
    resultado = []
    for item in lista:
        if item > limite:
            resultado.append(item)
    return resultado

def dobrar_valores(lista):
    """Dobra cada valor da lista."""
    resultado = []
    for item in lista:
        resultado.append(item * 2)
    return resultado

def main():
    """Função principal que orquestra as operações."""
    dados = [1, 5, 3, 8, 2, 9, 4, 7]
    print(f"Dados originais: {dados}")
    
    # Passo 1: Filtrar maiores que 3
    filtrados = filtrar_maiores_que(dados, 3)
    print(f"Maiores que 3: {filtrados}")
    
    # Passo 2: Dobrar os valores
    dobrados = dobrar_valores(filtrados)
    print(f"Dobrados: {dobrados}")
    
    # Passo 3: Calcular média
    media = calcular_media(dobrados)
    print(f"Média dos dobrados: {media:.2f}")
    
    return media

# Execução principal
print("=== Programação Procedural ===")
resultado = main()
print(f"Resultado final: {resultado:.2f}")

# Outro exemplo: sistema de notas
def ler_notas():
    """Lê notas até que o usuário digite -1."""
    notas = []
    while True:
        nota = float(input("Digite uma nota (-1 para sair): "))
        if nota == -1:
            break
        if 0 <= nota <= 10:
            notas.append(nota)
        else:
            print("Nota inválida! Use valores entre 0 e 10.")
    return notas

def calcular_estatisticas(notas):
    """Calcula média, maior e menor nota."""
    if not notas:
        return (0, 0, 0)
    media = sum(notas) / len(notas)
    maior = max(notas)
    menor = min(notas)
    return (media, maior, menor)

def exibir_resultados(estatisticas):
    """Exibe as estatísticas formatadas."""
    media, maior, menor = estatisticas
    print(f"\n--- Resultados ---")
    print(f"Média: {media:.2f}")
    print(f"Maior nota: {maior}")
    print(f"Menor nota: {menor}")
    print(f"Total de notas: {len(notas)}")

# Simulação sem input automático para demonstração
print("\n=== Sistema de Notas (Simulado) ===")
notas = [7.5, 8.0, 6.5, 9.0, 5.5]
print(f"Notas simuladas: {notas}")
estatisticas = calcular_estatisticas(notas)
exibir_resultados(estatisticas)

# Programação procedural com funções

def calcular_media(numeros):

"""Calcula média de uma lista de números."""

if not numeros:

return 0

soma = 0

for n in numeros:

soma += n

return soma / len(numeros)

def filtrar_maiores_que(lista, limite):

"""Retorna apenas números maiores que o limite."""

resultado = []

for item in lista:

if item > limite:

resultado.append(item)

return resultado

def dobrar_valores(lista):

"""Dobra cada valor da lista."""

resultado = []

for item in lista:

resultado.append(item * 2)

return resultado

def main():

"""Função principal que orquestra as operações."""

dados = [1, 5, 3, 8, 2, 9, 4, 7]

print(f"Dados originais: {dados}")

# Passo 1: Filtrar maiores que 3

filtrados = filtrar_maiores_que(dados, 3)

print(f"Maiores que 3: {filtrados}")

# Passo 2: Dobrar os valores

dobrados = dobrar_valores(filtrados)

print(f"Dobrados: {dobrados}")

# Passo 3: Calcular média

media = calcular_media(dobrados)

print(f"Média dos dobrados: {media:.2f}")

return media

# Execução principal

print("=== Programação Procedural ===")

resultado = main()

print(f"Resultado final: {resultado:.2f}")

# Outro exemplo: sistema de notas

def ler_notas():

"""Lê notas até que o usuário digite -1."""

notas = []

while True:

nota = float(input("Digite uma nota (-1 para sair): "))

if nota == -1:

break

if 0 <= nota <= 10:

notas.append(nota)

else:

print("Nota inválida! Use valores entre 0 e 10.")

return notas

def calcular_estatisticas(notas):

"""Calcula média, maior e menor nota."""

if not notas:

return (0, 0, 0)

media = sum(notas) / len(notas)

maior = max(notas)

menor = min(notas)

return (media, maior, menor)

def exibir_resultados(estatisticas):

"""Exibe as estatísticas formatadas."""

media, maior, menor = estatisticas

print(f"\n--- Resultados ---")

print(f"Média: {media:.2f}")

print(f"Maior nota: {maior}")

print(f"Menor nota: {menor}")

print(f"Total de notas: {len(notas)}")

# Simulação sem input automático para demonstração

print("\n=== Sistema de Notas (Simulado) ===")

notas = [7.5, 8.0, 6.5, 9.0, 5.5]

print(f"Notas simuladas: {notas}")

estatisticas = calcular_estatisticas(notas)

exibir_resultados(estatisticas)

Funções tornam o código modular e reutilizável. Cada função tem uma responsabilidade única e clara.

Quando usar imperativo vs outros paradigmas

Imperativo é ótimo para scripts pequenos e algoritmos. Procedural é melhor para programas de tamanho médio. Quando evitar imperativo? Em sistemas muito complexos. Também quando o código precisa de alta reutilização. A voz passiva é aplicada: “decisões são baseadas no problema”. Exemplo comparativo entre estilos:

# ========== ESTILO IMPERATIVO PURO ==========
def estilo_imperativo():
    """Cálculo de soma de quadrados estilo imperativo."""
    numeros = [1, 2, 3, 4, 5]
    soma = 0
    for i in range(len(numeros)):
        quadrado = numeros[i] * numeros[i]
        soma = soma + quadrado
    return soma

# ========== ESTILO PROCEDURAL ==========
def quadrado(x):
    return x * x

def estilo_procedural():
    """Cálculo de soma de quadrados estilo procedural."""
    numeros = [1, 2, 3, 4, 5]
    soma = 0
    for n in numeros:
        soma = soma + quadrado(n)
    return soma

# ========== ESTILO FUNCIONAL (para comparação) ==========
def estilo_funcional():
    """Cálculo de soma de quadrados estilo funcional."""
    return sum(map(lambda x: x * x, [1, 2, 3, 4, 5]))

print("=== Comparação de Estilos ===")
print(f"Imperativo: {estilo_imperativo()}")
print(f"Procedural: {estilo_procedural()}")
print(f"Funcional: {estilo_funcional()}")

# Quando o imperativo brilha: algoritmos com estado complexo
def ordenar_bolha(lista):
    """Ordenação por bolha (imperativo puro)."""
    n = len(lista)
    for i in range(n - 1):
        for j in range(0, n - i - 1):
            if lista[j] > lista[j + 1]:
                # Troca manual
                temp = lista[j]
                lista[j] = lista[j + 1]
                lista[j + 1] = temp
    return lista

lista_desordenada = [64, 34, 25, 12, 22, 11, 90]
print(f"\nOrdenação por bolha:")
print(f"Original: {lista_desordenada}")
print(f"Ordenada: {ordenar_bolha(lista_desordenada.copy())}")

# Exemplo de jogo simples (imperativo)
def jogo_adivinhacao():
    """Jogo de adivinhar número (imperativo)."""
    import random
    secreto = random.randint(1, 20)
    tentativas = 0
    acertou = False
    
    print("Adivinhe o número entre 1 e 20!")
    
    while not acertou and tentativas < 5:
        palpite = int(input(f"Tentativa {tentativas + 1}: "))
        tentativas += 1
        
        if palpite == secreto:
            acertou = True
            print(f"Parabéns! Você acertou em {tentativas} tentativas!")
        elif palpite < secreto:
            print("Muito baixo!")
        else:
            print("Muito alto!")
    
    if not acertou:
        print(f"Fim de jogo! O número era {secreto}")

# Demonstração sem input para não travar
print("\n=== Jogo de Adivinhação (Simulado) ===")
print("(Em um programa real, você digitaria os palpites)")
print("O imperativo é ideal para este tipo de lógica com estado")

# Fórmula da complexidade ciclomática (medida de complexidade)
# [latex]M = E - N + 2P[/latex]
# Onde E = arestas, N = nós, P = componentes conexos
print("\nProgramação imperativa é a base de tudo.")
print("Domine-a antes de partir para outros paradigmas.")

# ========== ESTILO IMPERATIVO PURO ==========

def estilo_imperativo():

"""Cálculo de soma de quadrados estilo imperativo."""

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

soma = 0

for i in range(len(numeros)):

quadrado = numeros[i] * numeros[i]

soma = soma + quadrado

return soma

# ========== ESTILO PROCEDURAL ==========

def quadrado(x):

return x * x

def estilo_procedural():

"""Cálculo de soma de quadrados estilo procedural."""

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

soma = 0

for n in numeros:

soma = soma + quadrado(n)

return soma

# ========== ESTILO FUNCIONAL (para comparação) ==========

def estilo_funcional():

"""Cálculo de soma de quadrados estilo funcional."""

return sum(map(lambda x: x * x, [1, 2, 3, 4, 5]))

print("=== Comparação de Estilos ===")

print(f"Imperativo: {estilo_imperativo()}")

print(f"Procedural: {estilo_procedural()}")

print(f"Funcional: {estilo_funcional()}")

# Quando o imperativo brilha: algoritmos com estado complexo

def ordenar_bolha(lista):

"""Ordenação por bolha (imperativo puro)."""

n = len(lista)

for i in range(n - 1):

for j in range(0, n - i - 1):

if lista[j] > lista[j + 1]:

# Troca manual

temp = lista[j]

lista[j] = lista[j + 1]

lista[j + 1] = temp

return lista

lista_desordenada = [64, 34, 25, 12, 22, 11, 90]

print(f"\nOrdenação por bolha:")

print(f"Original: {lista_desordenada}")

print(f"Ordenada: {ordenar_bolha(lista_desordenada.copy())}")

# Exemplo de jogo simples (imperativo)

def jogo_adivinhacao():

"""Jogo de adivinhar número (imperativo)."""

import random

secreto = random.randint(1, 20)

tentativas = 0

acertou = False

print("Adivinhe o número entre 1 e 20!")

while not acertou and tentativas < 5:

palpite = int(input(f"Tentativa {tentativas + 1}: "))

tentativas += 1

if palpite == secreto:

acertou = True

print(f"Parabéns! Você acertou em {tentativas} tentativas!")

elif palpite < secreto:

print("Muito baixo!")

else:

print("Muito alto!")

if not acertou:

print(f"Fim de jogo! O número era {secreto}")

# Demonstração sem input para não travar

print("\n=== Jogo de Adivinhação (Simulado) ===")

print("(Em um programa real, você digitaria os palpites)")

print("O imperativo é ideal para este tipo de lógica com estado")

# Fórmula da complexidade ciclomática (medida de complexidade)

# [latex]M = E - N + 2P[/latex]

# Onde E = arestas, N = nós, P = componentes conexos

print("\nProgramação imperativa é a base de tudo.")

print("Domine-a antes de partir para outros paradigmas.")

Programação imperativa é fundamental para qualquer programador. A fórmula da complexidade imperativa pode ser expressa: $C = \text{sequência} + \text{decisão} + \text{repetição}$ Comece com imperativo para algoritmos simples. Evolua para procedural quando o código crescer. Use outros paradigmas quando apropriado. A base sólida em imperativo nunca será substituída.

Funções Lambda em Python

22/05/202622/04/2026 Por antonino

Lambda é uma função anônima de única expressão em Python. Ela usa a palavra-chave lambda em vez de def. Primeiramente, lambdas são ideais para operações curtas e simples. Por exemplo, lambda x: x * 2 dobra um número. Além disso, lambdas podem receber múltiplos argumentos. A voz passiva é usada aqui: “a expressão é avaliada e retornada automaticamente”. Quando utilizar funções lambda? Em funções de alta ordem. Também para operações descartáveis que não precisam de nome. Lambda é comum com map, filter e sorted. Evite lambdas complexos que prejudicam a legibilidade. Vamos explorar sintaxe, usos e limitações práticas. Três subtítulos guiarão você pelo mundo das lambdas. Ao final, você usará lambdas de forma elegante e eficiente.

Sintaxe básica e usos simples

Lambda tem a forma lambda args: expressão. Ela não usa return explicitamente na expressão. Pode receber zero, um ou vários argumentos. Quando usar lambdas simples? Em transformações rápidas. Por exemplo, ordenar listas ou mapear valores. A voz passiva é aplicada: “os argumentos são separados por vírgulas”. Exemplo de sintaxe básica:

# Lambda básica
dobro = lambda x: x * 2
soma = lambda a, b: a + b
quadrado = lambda x: x ** 2

print("=== Lambda Básica ===")
print(f"dobro(5): {dobro(5)}")
print(f"soma(3, 7): {soma(3, 7)}")
print(f"quadrado(4): {quadrado(4)}")

# Lambda sem argumentos
saudacao = lambda: "Olá, mundo!"
print(f"saudacao(): {saudacao()}")

# Lambda com valor padrão
potencia = lambda base, exp=2: base ** exp
print(f"potencia(3): {potencia(3)}")
print(f"potencia(3, 4): {potencia(3, 4)}")

# Lambda imediata (invocação direta)
resultado = (lambda x, y: x * y)(4, 5)
print(f"(lambda x,y: x*y)(4,5): {resultado}")

# Comparação com função normal
def funcao_normal(x):
    return x * 2

lambda_eq = lambda x: x * 2
print(f"\nFunção normal: {funcao_normal(10)}")
print(f"Lambda: {lambda_eq(10)}")
print(f"São iguais? {funcao_normal(10) == lambda_eq(10)}")

# Lambda básica

dobro = lambda x: x * 2

soma = lambda a, b: a + b

quadrado = lambda x: x ** 2

print("=== Lambda Básica ===")

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

print(f"soma(3, 7): {soma(3, 7)}")

print(f"quadrado(4): {quadrado(4)}")

# Lambda sem argumentos

saudacao = lambda: "Olá, mundo!"

print(f"saudacao(): {saudacao()}")

# Lambda com valor padrão

potencia = lambda base, exp=2: base ** exp

print(f"potencia(3): {potencia(3)}")

print(f"potencia(3, 4): {potencia(3, 4)}")

# Lambda imediata (invocação direta)

resultado = (lambda x, y: x * y)(4, 5)

print(f"(lambda x,y: x*y)(4,5): {resultado}")

# Comparação com função normal

def funcao_normal(x):

return x * 2

lambda_eq = lambda x: x * 2

print(f"\nFunção normal: {funcao_normal(10)}")

print(f"Lambda: {lambda_eq(10)}")

print(f"São iguais? {funcao_normal(10) == lambda_eq(10)}")

Lambdas são concisas, mas não substituem funções complexas. Use-as apenas quando a expressão for realmente simples.

Lambda com map, filter e sorted

Lambda brilha em combinação com funções de alta ordem. map aplica lambda a cada elemento da sequência. filter usa lambda para selecionar elementos. sorted usa lambda como chave de ordenação. Quando usar essas combinações? Em pipelines de dados. Elas são mais declarativas que loops tradicionais. A voz passiva é aplicada: “os elementos são processados um a um”. Exemplo prático:

# Map com lambda
numeros = [1, 2, 3, 4, 5]
quadrados = list(map(lambda x: x ** 2, numeros))
cubos = list(map(lambda x: x ** 3, numeros))

print("=== Map com Lambda ===")
print(f"Original: {numeros}")
print(f"Quadrados: {quadrados}")
print(f"Cubos: {cubos}")

# Filter com lambda
pares = list(filter(lambda x: x % 2 == 0, numeros))
maiores_que_3 = list(filter(lambda x: x > 3, numeros))
print(f"\n=== Filter com Lambda ===")
print(f"Pares: {pares}")
print(f"Maiores que 3: {maiores_que_3}")

# Sorted com lambda
pessoas = [
    ("Ana", 25),
    ("Carlos", 35),
    ("Beatriz", 28),
    ("Daniel", 22)
]

ordenado_por_idade = sorted(pessoas, key=lambda p: p[1])
ordenado_por_nome = sorted(pessoas, key=lambda p: p[0])

print(f"\n=== Sorted com Lambda ===")
print(f"Original: {pessoas}")
print(f"Por idade: {ordenado_por_idade}")
print(f"Por nome: {ordenado_por_nome}")

# Ordenação reversa
ordenado_idade_decrescente = sorted(pessoas, key=lambda p: p[1], reverse=True)
print(f"Por idade decrescente: {ordenado_idade_decrescente}")

# Pipeline combinado
resultado = list(
    map(lambda x: x ** 2,
        filter(lambda x: x % 2 == 0, numeros))
)
print(f"\nPipeline: quadrados dos pares: {resultado}")

# Map com lambda

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

quadrados = list(map(lambda x: x ** 2, numeros))

cubos = list(map(lambda x: x ** 3, numeros))

print("=== Map com Lambda ===")

print(f"Original: {numeros}")

print(f"Quadrados: {quadrados}")

print(f"Cubos: {cubos}")

# Filter com lambda

pares = list(filter(lambda x: x % 2 == 0, numeros))

maiores_que_3 = list(filter(lambda x: x > 3, numeros))

print(f"\n=== Filter com Lambda ===")

print(f"Pares: {pares}")

print(f"Maiores que 3: {maiores_que_3}")

# Sorted com lambda

pessoas = [

("Ana", 25),

("Carlos", 35),

("Beatriz", 28),

("Daniel", 22)

]

ordenado_por_idade = sorted(pessoas, key=lambda p: p[1])

ordenado_por_nome = sorted(pessoas, key=lambda p: p[0])

print(f"\n=== Sorted com Lambda ===")

print(f"Original: {pessoas}")

print(f"Por idade: {ordenado_por_idade}")

print(f"Por nome: {ordenado_por_nome}")

# Ordenação reversa

ordenado_idade_decrescente = sorted(pessoas, key=lambda p: p[1], reverse=True)

print(f"Por idade decrescente: {ordenado_idade_decrescente}")

# Pipeline combinado

resultado = list(

map(lambda x: x ** 2,

filter(lambda x: x % 2 == 0, numeros))

)

print(f"\nPipeline: quadrados dos pares: {resultado}")

Lambdas tornam essas operações muito mais elegantes. Evite lambdas longos; prefira funções nomeadas nesses casos.

Limitações e boas práticas

Lambda só pode conter uma única expressão. Não pode conter statements como if-else (após Python 3.10). Não pode ter loops, atribuições ou return explícito. Quando evitar lambda? Em lógica com múltiplas linhas. Também quando a expressão fica difícil de ler. A voz passiva é aplicada: “a legibilidade é sacrificada em lambdas longos”. Exemplo de boas e más práticas:

# Lambda com expressão condicional (ok)
par_ou_impar = lambda x: "par" if x % 2 == 0 else "impar"
print("=== Lambda com Condicional ===")
print(f"par_ou_impar(4): {par_ou_impar(4)}")
print(f"par_ou_impar(5): {par_ou_impar(5)}")

# Lambda com múltiplas operações (ainda ok, mas cuidado)
calculo = lambda a, b: (a + b) * (a - b)
print(f"calculo(5, 3): {calculo(5, 3)}")

# Exemplo RUIM: lambda muito complexo (evite!)
# processar = lambda lista: [x for x in lista if x > 0]  # List comprehension é melhor
# Prefira função nomeada para isso

# Comparação de legibilidade
# Ruim (lambda complexo)
valores = [-5, -2, 0, 3, 7, 10]
filtro_ruim = list(filter(lambda x: x > 0 and x % 2 == 0, valores))
print(f"\n=== Boas Práticas ===")
print(f"Lambda complexo (ruim): {filtro_ruim}")

# Bom (função nomeada)
def positivo_e_par(x):
    return x > 0 and x % 2 == 0

filtro_bom = list(filter(positivo_e_par, valores))
print(f"Função nomeada (bom): {filtro_bom}")

# Lambda com múltiplos argumentos em sorted
dados = [
    {"nome": "Ana", "idade": 25, "salario": 3000},
    {"nome": "Carlos", "idade": 35, "salario": 4500},
    {"nome": "Beatriz", "idade": 28, "salario": 3200}
]

# Ordenação por múltiplas chaves
ordenado = sorted(dados, key=lambda x: (x["idade"], x["salario"]))
print(f"\nOrdenado por idade e salário: {[(d['nome'], d['idade']) for d in ordenado]}")

# Lambda em max e min
pessoa_mais_velha = max(dados, key=lambda p: p["idade"])
pessoa_mais_nova = min(dados, key=lambda p: p["idade"])
print(f"Pessoa mais velha: {pessoa_mais_velha['nome']}")
print(f"Pessoa mais nova: {pessoa_mais_nova['nome']}")

# Lambda com reduce
from functools import reduce
produto = reduce(lambda a, b: a * b, numeros)
print(f"\nProduto com reduce: {produto}")

# Quando NÃO usar lambda - exemplo didático
# Em vez disso:
def calcular_imposto(preco, taxa=0.1):
    return preco * (1 + taxa)

# Não faça: calcular_imposto = lambda preco, taxa=0.1: preco * (1 + taxa)
print(f"Função nomeada: R${calcular_imposto(100):.2f}")

# Lambda com expressão condicional (ok)

par_ou_impar = lambda x: "par" if x % 2 == 0 else "impar"

print("=== Lambda com Condicional ===")

print(f"par_ou_impar(4): {par_ou_impar(4)}")

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

# Lambda com múltiplas operações (ainda ok, mas cuidado)

calculo = lambda a, b: (a + b) * (a - b)

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

# Exemplo RUIM: lambda muito complexo (evite!)

# processar = lambda lista: [x for x in lista if x > 0] # List comprehension é melhor

# Prefira função nomeada para isso

# Comparação de legibilidade

# Ruim (lambda complexo)

valores = [-5, -2, 0, 3, 7, 10]

filtro_ruim = list(filter(lambda x: x > 0 and x % 2 == 0, valores))

print(f"\n=== Boas Práticas ===")

print(f"Lambda complexo (ruim): {filtro_ruim}")

# Bom (função nomeada)

def positivo_e_par(x):

return x > 0 and x % 2 == 0

filtro_bom = list(filter(positivo_e_par, valores))

print(f"Função nomeada (bom): {filtro_bom}")

# Lambda com múltiplos argumentos em sorted

dados = [

{"nome": "Ana", "idade": 25, "salario": 3000},

{"nome": "Carlos", "idade": 35, "salario": 4500},

{"nome": "Beatriz", "idade": 28, "salario": 3200}

]

# Ordenação por múltiplas chaves

ordenado = sorted(dados, key=lambda x: (x["idade"], x["salario"]))

print(f"\nOrdenado por idade e salário: {[(d['nome'], d['idade']) for d in ordenado]}")

# Lambda em max e min

pessoa_mais_velha = max(dados, key=lambda p: p["idade"])

pessoa_mais_nova = min(dados, key=lambda p: p["idade"])

print(f"Pessoa mais velha: {pessoa_mais_velha['nome']}")

print(f"Pessoa mais nova: {pessoa_mais_nova['nome']}")

# Lambda com reduce

from functools import reduce

produto = reduce(lambda a, b: a * b, numeros)

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

# Quando NÃO usar lambda - exemplo didático

# Em vez disso:

def calcular_imposto(preco, taxa=0.1):

return preco * (1 + taxa)

# Não faça: calcular_imposto = lambda preco, taxa=0.1: preco * (1 + taxa)

print(f"Função nomeada: R${calcular_imposto(100):.2f}")

Lambdas são ferramentas para simplicidade, não para tudo. A fórmula da legibilidade de uma lambda: $L = \frac{1}{\text{número de operações}} \quad \text{(quanto menor, melhor)}$ Use lambda para funções de uma linha sem efeitos colaterais. Prefira funções nomeadas para lógica complexa. Lambdas com map, filter e sorted são ideais. Seu código será mais expressivo e funcional.