Arquivo de Funcional - Página 3 de 5

Comprehensions 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

Comprehensions são sintaxes concisas para criar coleções em Python. Elas substituem loops tradicionais por expressões declarativas. Primeiramente, list comprehension é a mais comum entre elas. Por exemplo, [x*2 for x in range(5)] gera [0,2,4,6,8]. Além disso, dict comprehension e set comprehension também existem. Assim, você escreve menos código e com mais clareza. Consequentemente, a manutenção se torna muito mais fácil. Quando utilizar comprehensions? Em transformações simples de coleções. Também para filtrar e mapear dados de forma legível. Por outro lado, para lógica muito complexa, loops são melhores. Elas são mais rápidas e pythonicas que loops manuais. Então, vamos explorar cada tipo com exemplos práticos. Três subtítulos guiarão você pelas comprehensions. Portanto, ao final, você escreverá código mais limpo e eficiente.

List comprehension: gerando listas de forma concisa

List comprehension cria uma nova lista a partir de um iterável. A sintaxe básica é [expressão for item in iterável]. Você pode adicionar condicionais com if no final. Quando usar list comprehension? Para mapeamentos e filtros simples. Elas são mais rápidas que loops for tradicionais. Além disso, você pode aninhar múltiplos for e if. Exemplo de list comprehension:

# List comprehension básica
numeros = [1, 2, 3, 4, 5]
quadrados = [x ** 2 for x in numeros]
print("=== List Comprehension ===")
print(f"Original: {numeros}")
print(f"Quadrados: {quadrados}")

# Com condicional (filter)
pares = [x for x in numeros if x % 2 == 0]
print(f"Apenas pares: {pares}")

# Com condicional e transformação
pares_quadrados = [x ** 2 for x in numeros if x % 2 == 0]
print(f"Quadrados dos pares: {pares_quadrados}")

# Com else (expressão condicional)
par_ou_impar = ["par" if x % 2 == 0 else "ímpar" for x in numeros]
print(f"Classificação: {par_ou_impar}")

# Com string
palavras = ["Python", "comprehension", "é", "poderoso"]
tamanhos = [len(palavra) for palavra in palavras]
print(f"Tamanhos: {tamanhos}")

# Com múltiplos for (produto cartesiano)
coordenadas = [(x, y) for x in range(3) for y in range(2)]
print(f"Produto cartesiano: {coordenadas}")

# Com aninhamento (matriz)
matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
achatada = [elemento for linha in matriz for elemento in linha]
print(f"Matriz achatada: {achatada}")

# Comparação com loop tradicional
# Loop tradicional
resultado_loop = []
for x in range(10):
    if x % 2 == 0:
        resultado_loop.append(x ** 2)

# List comprehension (mais limpo)
resultado_comp = [x ** 2 for x in range(10) if x % 2 == 0]
print(f"Loop: {resultado_loop}")
print(f"Comprehension: {resultado_comp}")

# List comprehension básica

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

quadrados = [x ** 2 for x in numeros]

print("=== List Comprehension ===")

print(f"Original: {numeros}")

print(f"Quadrados: {quadrados}")

# Com condicional (filter)

pares = [x for x in numeros if x % 2 == 0]

print(f"Apenas pares: {pares}")

# Com condicional e transformação

pares_quadrados = [x ** 2 for x in numeros if x % 2 == 0]

print(f"Quadrados dos pares: {pares_quadrados}")

# Com else (expressão condicional)

par_ou_impar = ["par" if x % 2 == 0 else "ímpar" for x in numeros]

print(f"Classificação: {par_ou_impar}")

# Com string

palavras = ["Python", "comprehension", "é", "poderoso"]

tamanhos = [len(palavra) for palavra in palavras]

print(f"Tamanhos: {tamanhos}")

# Com múltiplos for (produto cartesiano)

coordenadas = [(x, y) for x in range(3) for y in range(2)]

print(f"Produto cartesiano: {coordenadas}")

# Com aninhamento (matriz)

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

achatada = [elemento for linha in matriz for elemento in linha]

print(f"Matriz achatada: {achatada}")

# Comparação com loop tradicional

# Loop tradicional

resultado_loop = []

for x in range(10):

if x % 2 == 0:

resultado_loop.append(x ** 2)

# List comprehension (mais limpo)

resultado_comp = [x ** 2 for x in range(10) if x % 2 == 0]

print(f"Loop: {resultado_loop}")

print(f"Comprehension: {resultado_comp}")

List comprehensions são rápidas e expressivas. Use-as sempre que possível para código mais limpo. Portanto, prefira comprehension a loops simples.

Dict comprehension: criando dicionários dinâmicos

Dict comprehension cria dicionários com sintaxe semelhante. A forma é {chave: valor for item in iterável}. Você também pode adicionar condicionais e múltiplos for. Quando usar dict comprehension? Em transformações chave-valor. Por exemplo, inverter dicionários ou criar mapeamentos. Além disso, você pode combinar duas listas facilmente. Exemplo de dict comprehension:

# Dict comprehension básica
nomes = ["Ana", "Carlos", "Beatriz", "Daniel"]
dicionario = {nome: len(nome) for nome in nomes}
print("=== Dict Comprehension ===")
print(f"Lista: {nomes}")
print(f"Dicionário nome -> tamanho: {dicionario}")

# Com condicional
nomes_longos = {nome: len(nome) for nome in nomes if len(nome) > 5}
print(f"Nomes com mais de 5 letras: {nomes_longos}")

# Invertendo dicionário
original = {"a": 1, "b": 2, "c": 3}
invertido = {valor: chave for chave, valor in original.items()}
print(f"Original: {original}")
print(f"Invertido: {invertido}")

# Criando dicionário a partir de duas listas
chaves = ["nome", "idade", "cidade"]
valores = ["Ana", 25, "São Paulo"]
pessoa = {chaves[i]: valores[i] for i in range(len(chaves))}
print(f"De duas listas: {pessoa}")

# Com zip (mais pythonico)
pessoa_zip = {chave: valor for chave, valor in zip(chaves, valores)}
print(f"Com zip: {pessoa_zip}")

# Mapeamento com transformação
numeros = [1, 2, 3, 4, 5]
quadrados_dict = {n: n ** 2 for n in numeros}
print(f"Números -> quadrados: {quadrados_dict}")

# Filtrando dicionário existente
pontuacoes = {"Ana": 85, "Carlos": 92, "Beatriz": 78, "Daniel": 88}
aprovados = {nome: nota for nome, nota in pontuacoes.items() if nota >= 80}
print(f"Aprovados (nota >= 80): {aprovados}")

# Com condicional no valor
status = {nome: "aprovado" if nota >= 80 else "reprovado" 
          for nome, nota in pontuacoes.items()}
print(f"Status: {status}")

# Dict comprehension básica

nomes = ["Ana", "Carlos", "Beatriz", "Daniel"]

dicionario = {nome: len(nome) for nome in nomes}

print("=== Dict Comprehension ===")

print(f"Lista: {nomes}")

print(f"Dicionário nome -> tamanho: {dicionario}")

# Com condicional

nomes_longos = {nome: len(nome) for nome in nomes if len(nome) > 5}

print(f"Nomes com mais de 5 letras: {nomes_longos}")

# Invertendo dicionário

original = {"a": 1, "b": 2, "c": 3}

invertido = {valor: chave for chave, valor in original.items()}

print(f"Original: {original}")

print(f"Invertido: {invertido}")

# Criando dicionário a partir de duas listas

chaves = ["nome", "idade", "cidade"]

valores = ["Ana", 25, "São Paulo"]

pessoa = {chaves[i]: valores[i] for i in range(len(chaves))}

print(f"De duas listas: {pessoa}")

# Com zip (mais pythonico)

pessoa_zip = {chave: valor for chave, valor in zip(chaves, valores)}

print(f"Com zip: {pessoa_zip}")

# Mapeamento com transformação

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

quadrados_dict = {n: n ** 2 for n in numeros}

print(f"Números -> quadrados: {quadrados_dict}")

# Filtrando dicionário existente

pontuacoes = {"Ana": 85, "Carlos": 92, "Beatriz": 78, "Daniel": 88}

aprovados = {nome: nota for nome, nota in pontuacoes.items() if nota >= 80}

print(f"Aprovados (nota >= 80): {aprovados}")

# Com condicional no valor

status = {nome: "aprovado" if nota >= 80 else "reprovado"

for nome, nota in pontuacoes.items()}

print(f"Status: {status}")

Dict comprehension é ideal para transformar listas em dicionários. Ela torna o código mais legível que loops com dict.update(). Assim, você evita código verboso e repetitivo.

Set comprehension: conjuntos únicos e eficientes

Set comprehension cria conjuntos (sets) com elementos únicos. A sintaxe é {expressão for item in iterável}. Ela remove duplicatas automaticamente por definição. Quando usar set comprehension? Em operações com elementos únicos. Por exemplo, extrair valores distintos de uma lista. Além disso, set comprehension é muito eficiente em performance. Exemplo de set comprehension:

# Set comprehension básica
numeros = [1, 2, 2, 3, 3, 3, 4, 5, 5]
unicos = {x for x in numeros}
print("=== Set Comprehension ===")
print(f"Lista com duplicatas: {numeros}")
print(f"Set de únicos: {unicos}")

# Com transformação
quadrados_unicos = {x ** 2 for x in numeros}
print(f"Quadrados únicos: {quadrados_unicos}")

# Com condicional
pares_unicos = {x for x in numeros if x % 2 == 0}
print(f"Pares únicos: {pares_unicos}")

# Com string (caracteres únicos)
texto = "abracadabra"
caracteres = {letra for letra in texto}
print(f"Caracteres únicos em '{texto}': {caracteres}")

# Com range
pares_ate_20 = {x for x in range(20) if x % 2 == 0}
print(f"Pares únicos até 20: {pares_ate_20}")

# Produto cartesiano em set
produto = {(x, y) for x in range(3) for y in range(3)}
print(f"Produto cartesiano (set): {produto}")

# Extraindo palavras únicas de um texto
frase = "o rato roeu a roupa do rei de roma"
palavras_unicas = {palavra for palavra in frase.split()}
print(f"Palavras únicas na frase: {palavras_unicas}")

# Comparação de performance
import timeit
lista_grande = [i % 10 for i in range(10000)]

# Set comprehension
tempo_comp = timeit.timeit(
    '{x for x in lista_grande}', 
    globals=globals(), 
    number=1000
)

# Loop tradicional
def set_com_loop():
    resultado = set()
    for x in lista_grande:
        resultado.add(x)
    return resultado

tempo_loop = timeit.timeit(set_com_loop, globals=globals(), number=1000)
print(f"\nSet comprehension: {tempo_comp:.4f}s")
print(f"Loop tradicional: {tempo_loop:.4f}s")

# Set comprehension básica

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

unicos = {x for x in numeros}

print("=== Set Comprehension ===")

print(f"Lista com duplicatas: {numeros}")

print(f"Set de únicos: {unicos}")

# Com transformação

quadrados_unicos = {x ** 2 for x in numeros}

print(f"Quadrados únicos: {quadrados_unicos}")

# Com condicional

pares_unicos = {x for x in numeros if x % 2 == 0}

print(f"Pares únicos: {pares_unicos}")

# Com string (caracteres únicos)

texto = "abracadabra"

caracteres = {letra for letra in texto}

print(f"Caracteres únicos em '{texto}': {caracteres}")

# Com range

pares_ate_20 = {x for x in range(20) if x % 2 == 0}

print(f"Pares únicos até 20: {pares_ate_20}")

# Produto cartesiano em set

produto = {(x, y) for x in range(3) for y in range(3)}

print(f"Produto cartesiano (set): {produto}")

# Extraindo palavras únicas de um texto

frase = "o rato roeu a roupa do rei de roma"

palavras_unicas = {palavra for palavra in frase.split()}

print(f"Palavras únicas na frase: {palavras_unicas}")

# Comparação de performance

import timeit

lista_grande = [i % 10 for i in range(10000)]

# Set comprehension

tempo_comp = timeit.timeit(

'{x for x in lista_grande}',

globals=globals(),

number=1000

)

# Loop tradicional

def set_com_loop():

resultado = set()

for x in lista_grande:

resultado.add(x)

return resultado

tempo_loop = timeit.timeit(set_com_loop, globals=globals(), number=1000)

print(f"\nSet comprehension: {tempo_comp:.4f}s")

print(f"Loop tradicional: {tempo_loop:.4f}s")

Set comprehension é eficiente e elimina duplicatas. A fórmula geral das comprehensions é clara: \(C = [f(x) \text{ for } x \text{ in } S \text{ if } p(x)]\) Comprehensions são mais pythonicas que loops tradicionais. Elas são mais rápidas, mais curtas e mais legíveis. Use list comprehension para transformar sequências. Use dict comprehension para mapeamentos chave-valor. Use set comprehension para conjuntos únicos. Portanto, seu código será mais expressivo e profissional. Finalmente, pratique comprehensions em todos os seus projetos.

Funções de Alta Ordem

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ções de alta ordem recebem outras funções como argumentos. Elas transformam dados de forma declarativa e elegante. Primeiramente, map aplica uma função a cada elemento. Por exemplo, map(lambda x: x*2, [1,2,3]) dobra os valores. Além disso, filter seleciona elementos que atendem a uma condição. Assim, você evita loops manuais e código repetitivo. Consequentemente, o programa fica mais legível e conciso. Quando utilizar essas funções? Em transformações de coleções. Também em pipelines de processamento de dados. Por outro lado, para lógica muito complexa, loops são melhores. Python suporta essas funções de forma nativa. Então, vamos explorar cada uma com exemplos práticos. Três subtítulos guiarão você por essas funções essenciais. Portanto, ao final, você substituirá loops verbosos por código funcional.

Map: transformando cada elemento

map aplica uma função a todos os itens de um iterável. O resultado é um iterador com os valores transformados. Quando usar map? Em conversões e mapeamentos simples. Por exemplo, converter strings para números ou aplicar fórmulas. Além disso, map aceita múltiplos iteráveis simultaneamente. Exemplo de map:

# Map básico
numeros = [1, 2, 3, 4, 5]
quadrados = list(map(lambda x: x ** 2, numeros))
print("=== Map ===")
print(f"Original: {numeros}")
print(f"Quadrados: {quadrados}")

# Map com função nomeada
def dobrar(x):
    return x * 2

dobrados = list(map(dobrar, numeros))
print(f"Dobrados: {dobrados}")

# Map com múltiplos iteráveis
lista1 = [1, 2, 3]
lista2 = [10, 20, 30]
somas = list(map(lambda a, b: a + b, lista1, lista2))
print(f"Somas elemento a elemento: {somas}")

# Map com strings
nomes = ["ana", "carlos", "beatriz"]
maiusculas = list(map(str.upper, nomes))
print(f"Nomes em maiúsculo: {maiusculas}")

# Map com tipos diferentes
strings = ["1", "2", "3", "4", "5"]
inteiros = list(map(int, strings))
print(f"Strings para inteiros: {inteiros}")

# Map com dicionários
pessoas = [{"nome": "Ana", "idade": 25}, {"nome": "Carlos", "idade": 30}]
nomes_idades = list(map(lambda p: f"{p['nome']} tem {p['idade']} anos", pessoas))
print(f"Descrições: {nomes_idades}")

# Map lazy (economia de memória)
valores = range(1000000)
quadrados_lazy = map(lambda x: x ** 2, valores)
print(f"Primeiros 5 quadrados lazy: {list(quadrados_lazy)[:5]}")

# Map básico

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

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

print("=== Map ===")

print(f"Original: {numeros}")

print(f"Quadrados: {quadrados}")

# Map com função nomeada

def dobrar(x):

return x * 2

dobrados = list(map(dobrar, numeros))

print(f"Dobrados: {dobrados}")

# Map com múltiplos iteráveis

lista1 = [1, 2, 3]

lista2 = [10, 20, 30]

somas = list(map(lambda a, b: a + b, lista1, lista2))

print(f"Somas elemento a elemento: {somas}")

# Map com strings

nomes = ["ana", "carlos", "beatriz"]

maiusculas = list(map(str.upper, nomes))

print(f"Nomes em maiúsculo: {maiusculas}")

# Map com tipos diferentes

strings = ["1", "2", "3", "4", "5"]

inteiros = list(map(int, strings))

print(f"Strings para inteiros: {inteiros}")

# Map com dicionários

pessoas = [{"nome": "Ana", "idade": 25}, {"nome": "Carlos", "idade": 30}]

nomes_idades = list(map(lambda p: f"{p['nome']} tem {p['idade']} anos", pessoas))

print(f"Descrições: {nomes_idades}")

# Map lazy (economia de memória)

valores = range(1000000)

quadrados_lazy = map(lambda x: x ** 2, valores)

print(f"Primeiros 5 quadrados lazy: {list(quadrados_lazy)[:5]}")

Map é ideal para transformações uniformes em sequências. Ele é mais expressivo que loops tradicionais. Portanto, prefira map para operações simples de mapeamento.

Filter: selecionando elementos

filter retorna apenas elementos que satisfazem uma condição. A função de filtro deve retornar True ou False. Quando usar filter? Em operações de seleção e limpeza. Por exemplo, remover valores nulos ou selecionar maiores que um limite. Assim, você elimina condicionais espalhadas pelo código. Exemplo de filter:

# Filter básico
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
pares = list(filter(lambda x: x % 2 == 0, numeros))
print("=== Filter ===")
print(f"Original: {numeros}")
print(f"Números pares: {pares}")

# Filter com função nomeada
def maior_que_cinco(x):
    return x > 5

maiores = list(filter(maior_que_cinco, numeros))
print(f"Maiores que 5: {maiores}")

# Filter com strings
palavras = ["casa", "sol", "python", "programação", "ia"]
longas = list(filter(lambda p: len(p) > 4, palavras))
print(f"Palavras com mais de 4 letras: {longas}")

# Filter com None (remove valores falsy)
dados = [0, 1, False, 2, "", "texto", None, [], 5]
truthy = list(filter(None, dados))
print(f"Valores truthy: {truthy}")

# Filter com dicionários
pessoas = [
    {"nome": "Ana", "idade": 17},
    {"nome": "Carlos", "idade": 25},
    {"nome": "Beatriz", "idade": 16},
    {"nome": "Daniel", "idade": 30}
]
maiores_de_idade = list(filter(lambda p: p["idade"] >= 18, pessoas))
print(f"Maiores de idade: {maiores_de_idade}")

# Combinando map e filter
resultado = list(
    map(lambda x: x ** 2,
        filter(lambda x: x % 2 == 0, numeros))
)
print(f"Quadrados dos números pares: {resultado}")

# Filter básico

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

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

print("=== Filter ===")

print(f"Original: {numeros}")

print(f"Números pares: {pares}")

# Filter com função nomeada

def maior_que_cinco(x):

return x > 5

maiores = list(filter(maior_que_cinco, numeros))

print(f"Maiores que 5: {maiores}")

# Filter com strings

palavras = ["casa", "sol", "python", "programação", "ia"]

longas = list(filter(lambda p: len(p) > 4, palavras))

print(f"Palavras com mais de 4 letras: {longas}")

# Filter com None (remove valores falsy)

dados = [0, 1, False, 2, "", "texto", None, [], 5]

truthy = list(filter(None, dados))

print(f"Valores truthy: {truthy}")

# Filter com dicionários

pessoas = [

{"nome": "Ana", "idade": 17},

{"nome": "Carlos", "idade": 25},

{"nome": "Beatriz", "idade": 16},

{"nome": "Daniel", "idade": 30}

]

maiores_de_idade = list(filter(lambda p: p["idade"] >= 18, pessoas))

print(f"Maiores de idade: {maiores_de_idade}")

# Combinando map e filter

resultado = list(

map(lambda x: x ** 2,

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

)

print(f"Quadrados dos números pares: {resultado}")

Filter é perfeito para limpeza e seleção de dados. Ele torna o código mais legível que condicionais aninhadas. Portanto, use filter para extrair subconjuntos de dados.

Reduce: reduzindo a um único valor

reduce aplica uma função cumulativamente aos elementos. O resultado é um único valor agregado da sequência. Quando usar reduce? Em operações de acumulação. Por exemplo, soma, produto, máximo, mínimo ou concatenação. Além disso, reduce permite agregadores personalizados complexos. Exemplo de reduce:

from functools import reduce

# Reduce básico (soma)
numeros = [1, 2, 3, 4, 5]
soma = reduce(lambda a, b: a + b, numeros)
print("=== Reduce ===")
print(f"Lista: {numeros}")
print(f"Soma: {soma}")

# Produto
produto = reduce(lambda a, b: a * b, numeros)
print(f"Produto: {produto}")

# Reduce com valor inicial
soma_com_inicio = reduce(lambda a, b: a + b, numeros, 100)
print(f"Soma com início 100: {soma_com_inicio}")

# Maior valor
maior = reduce(lambda a, b: a if a > b else b, numeros)
print(f"Maior valor: {maior}")

# Reduce com strings
palavras = ["Python", " ", "é ", "poderoso"]
frase = reduce(lambda a, b: a + b, palavras)
print(f"Concatenação: {frase}")

# Reduce para encontrar o máximo com dicionários
pessoas = [
    {"nome": "Ana", "idade": 25},
    {"nome": "Carlos", "idade": 35},
    {"nome": "Beatriz", "idade": 28}
]
mais_velho = reduce(
    lambda a, b: a if a["idade"] > b["idade"] else b,
    pessoas
)
print(f"Pessoa mais velha: {mais_velho}")

# Reduce para implementar média
def media(lista):
    soma = reduce(lambda a, b: a + b, lista)
    return soma / len(lista)

print(f"Média dos números: {media(numeros):.2f}")

# Reduce com operação personalizada
def fatorial(n):
    return reduce(lambda a, b: a * b, range(1, n + 1))

print(f"Fatorial de 5: {fatorial(5)}")
print(f"Fatorial de 7: {fatorial(7)}")

# Pipeline completo: map, filter, reduce
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
resultado = reduce(
    lambda a, b: a + b,
    map(
        lambda x: x ** 2,
        filter(lambda x: x % 2 == 0, numeros)
    )
)
print(f"\n=== Pipeline Completo ===")
print(f"Soma dos quadrados dos pares: {resultado}")
print(f"Verificação: 2²+4²+6²+8²+10² = {4+16+36+64+100}")

# Comparação com loop tradicional
def soma_quadrados_pares_tradicional(numeros):
    total = 0
    for n in numeros:
        if n % 2 == 0:
            total += n ** 2
    return total

tradicional = soma_quadrados_pares_tradicional(numeros)
print(f"Versão tradicional: {tradicional}")

from functools import reduce

# Reduce básico (soma)

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

soma = reduce(lambda a, b: a + b, numeros)

print("=== Reduce ===")

print(f"Lista: {numeros}")

print(f"Soma: {soma}")

# Produto

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

print(f"Produto: {produto}")

# Reduce com valor inicial

soma_com_inicio = reduce(lambda a, b: a + b, numeros, 100)

print(f"Soma com início 100: {soma_com_inicio}")

# Maior valor

maior = reduce(lambda a, b: a if a > b else b, numeros)

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

# Reduce com strings

palavras = ["Python", " ", "é ", "poderoso"]

frase = reduce(lambda a, b: a + b, palavras)

print(f"Concatenação: {frase}")

# Reduce para encontrar o máximo com dicionários

pessoas = [

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

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

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

]

mais_velho = reduce(

lambda a, b: a if a["idade"] > b["idade"] else b,

pessoas

)

print(f"Pessoa mais velha: {mais_velho}")

# Reduce para implementar média

def media(lista):

soma = reduce(lambda a, b: a + b, lista)

return soma / len(lista)

print(f"Média dos números: {media(numeros):.2f}")

# Reduce com operação personalizada

def fatorial(n):

return reduce(lambda a, b: a * b, range(1, n + 1))

print(f"Fatorial de 5: {fatorial(5)}")

print(f"Fatorial de 7: {fatorial(7)}")

# Pipeline completo: map, filter, reduce

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

resultado = reduce(

lambda a, b: a + b,

map(

lambda x: x ** 2,

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

)

print(f"\n=== Pipeline Completo ===")

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

print(f"Verificação: 2²+4²+6²+8²+10² = {4+16+36+64+100}")

# Comparação com loop tradicional

def soma_quadrados_pares_tradicional(numeros):

total = 0

for n in numeros:

if n % 2 == 0:

total += n ** 2

return total

tradicional = soma_quadrados_pares_tradicional(numeros)

print(f"Versão tradicional: {tradicional}")

Reduce é poderoso para agregações personalizadas. A fórmula do padrão map-filter-reduce é clara: \(R = \text{reduce}(\text{função}, \text{map}(\text{f}, \text{filter}(\text{pred}, \text{dados})))\) Combine map, filter e reduce para pipelines expressivos. Eles tornam seu código mais declarativo e menos propenso a erros. Map transforma, filter seleciona, reduce agrega. Portanto, use essas funções para processar coleções de forma elegante. Finalmente, pratique com exemplos reais do seu dia a dia.