As Funções map() e filter() do Python (com reduce)

✅ Artigo atualizado em Setembro 2026 (Python 3.x) Nova resposta rápida, seções sobre map(int, input().split()), filter(None, ...), iteradores e reduce(), tabela de decisão, erros comuns com traceback e 8 exercícios resolvidos. Todas as saídas foram conferidas executando o código.

1
2
3
4
5

numeros = [1, 2, 3, 4, 5]
list(map(lambda n: n * 2, numeros))          # [2, 4, 6, 8, 10]
list(filter(lambda n: n % 2 == 0, numeros))  # [2, 4]
[n * 2 for n in numeros]                     # [2, 4, 6, 8, 10]
[n for n in numeros if n % 2 == 0]           # [2, 4]

Olá Pythonista!

map() e filter() são funções de programação funcional que transformam e filtram dados de forma concisa. Porém, list comprehensions são geralmente mais Pythônicas para a maioria dos casos!

Neste guia, você vai aprender:

• ✅ Sintaxe de map() e filter()
• ✅ map(int, input().split()), filter(None, ...) e reduce()
• ✅ map/filter vs list comprehension - Qual usar?
• ✅ Erros comuns e exercícios resolvidos

Ainda não domina Laços de Repetição? Acesse nosso guia de loops for e while!

Agora sem enrolação, vamos ao conteúdo!

Vá direto ao assunto…

• A função map
• Exemplos da função map
• A função map com múltiplos iteráveis
• map(int, input().split()): ler vários números em uma linha
• A função filter
• Exemplos da função filter
• map e filter retornam iteradores, não listas
• A função reduce (functools)
• map/filter vs List Comprehension
• Erros comuns
• Exercícios resolvidos

A função map

Muitas vezes, enfrentamos situações em que precisamos executar a mesma operação em todos os itens de um iterável de entrada (uma lista, um set, uma tupla) para se construir um novo iterável.

A abordagem mais comum para esse tipo de problema é usar loops for ou while do Python.

Contudo, você também pode resolver esse problema sem um loop de repetição, usando a função map() disponível na biblioteca padrão da própria linguagem (sem precisar instalar algo com pip ou importar com import). A referência completa está na documentação oficial da função map().

A sintaxe da função map é a seguinte:

1

map(funcao, iteravel1, iteravel2, ..., iteravelN)

Nela:

• funcao é a função que iremos aplicar a cada elemento dos iteráveis de entrada.
• iteravel1, ..., iteravelN são iteráveis nas quais a função funcao será aplicada, elemento a elemento

Repare que você passa a função sem parênteses (map(soma_5, lista) e não map(soma_5(), lista)): quem chama a função, item a item, é o próprio map.

Para entender melhor, vamos aos exemplos!

Exemplos da função map

Suponha que você tenha uma lista de números e que lhe pedissem para somar 5 a todos os valores da lista.

A forma mais comum seria utilizar um loop for, assim:

1
2
3
4
5
6
7

lista = [1, 2, 3, 4, 5]
resultado = []

for item in lista:
    resultado.append(item + 5)

print(resultado)  # [6, 7, 8, 9, 10]

É possível conseguir o mesmo resultado utilizando a função map!

Veja como o código acima poderia ser reescrito, utilizando esta função:

1
2
3
4
5
6
7

def soma_5(numero):
    return numero + 5

lista = [1, 2, 3, 4, 5]
resultado = list(map(soma_5, lista))

print(resultado)  # [6, 7, 8, 9, 10]

Desta forma, estamos aplicando a função soma_5 a cada elemento da lista lista e o resultado será o mesmo da versão com o loop for.

O map também funciona muito bem com funções e métodos que já existem no Python, sem precisar criar função nenhuma:

1
2
3
4

print(list(map(str.upper, ['python', 'map'])))     # ['PYTHON', 'MAP']
print(list(map(len, ['python', 'map', 'filter'])))  # [6, 3, 6]
print(list(map(int, ['10', '20', '30'])))           # [10, 20, 30]
print(', '.join(map(str, [1, 2, 3])))               # 1, 2, 3

A função map com múltiplos iteráveis

Como vimos na sintaxe da função, map possibilita passarmos múltiplos iteráveis de entrada.

Para isso, é necessária uma função que possua dois ou mais argumentos.

Vamos entender no exemplo a seguir!

1
2
3
4
5
6
7

from math import pow

numeros = [1, 2, 3]
expoentes = [4, 5, 6, 7]

resultado = list(map(pow, numeros, expoentes))
print(resultado)  # [1.0, 32.0, 729.0]

Agora acompanhe a execução de cada iteração de map:

Na primeira iteração, map vai aplicar a função pow, utilizando numeros[0] e expoentes[0] como argumentos, assim: pow(1,4) = 1.0

Em seguida, map vai aplicar a função pow, utilizando numeros[1] e expoentes[1], assim: pow(2,5) = 32.0

Por último, map vai aplicar a função pow, utilizando numeros[2] e expoentes[2], assim: pow(3,6) = 729.0

A iteração termina na menor sequência, portanto o número 7, em expoentes[3], não será utilizado pois a lista numeros não possui o elemento numeros[3].

Os resultados saem como float (1.0, 32.0…) porque math.pow sempre devolve float. Se quiser inteiros, use o pow embutido do Python (sem o import): list(map(pow, numeros, expoentes)) resulta em [1, 32, 729].

Com uma função lambda de dois parâmetros, você combina duas listas item a item sem criar uma função com def:

1
2
3
4
5
6
7
8

precos = [10.0, 2.5, 4.0]
quantidades = [2, 4, 1]

subtotais = list(map(lambda p, q: p * q, precos, quantidades))
print(subtotais)  # [20.0, 10.0, 4.0]

# O mesmo com zip + list comprehension
print([p * q for p, q in zip(precos, quantidades)])  # [20.0, 10.0, 4.0]

A regra é simples: a função precisa receber um argumento para cada iterável. Com três listas, a função precisa de três parâmetros.

map(int, input().split()): ler vários números em uma linha

Este é, de longe, o uso de map mais buscado por quem está começando (e o que mais aparece em exercícios de faculdade e juízes online). O input() sempre devolve texto, então, quando o usuário digita 10 20 30, você precisa separar e converter cada pedaço:

1
2
3

numeros = list(map(int, input().split()))
print(numeros)
print(sum(numeros))

Digitando 10 20 30, a saída é:

1
2

[10, 20, 30]
60

Passo a passo:

1. input() lê a linha inteira como string: '10 20 30'.
2. .split() quebra nos espaços: ['10', '20', '30'] (espaços extras são ignorados).
3. map(int, ...) aplica int a cada pedaço, gerando 10, 20 e 30.
4. list(...) materializa o resultado em uma lista.

Quando você sabe exatamente quantos valores virão, pode desempacotar direto, sem list():

1
2

a, b = map(int, input('Digite dois números: ').split())
print(f'Soma: {a + b}')

Digitando 7 5:

1
2

Digite dois números: 7 5
Soma: 12

Para números com casas decimais use float, e se a entrada vier separada por vírgula passe o separador para o split:

1
2

notas = list(map(float, input().split(',')))
print(notas)  # digitando 7.5,8,9.25 -> [7.5, 8.0, 9.25]

Se o usuário digitar uma quantidade diferente de valores (3 4 5 com a, b = ...) ou usar outro separador (1,2,3 com .split()), você recebe um ValueError. Veja os dois casos em Erros comuns.

Estou construindo o Ebookr.ai, uma plataforma onde você cria ebooks profissionais com IA sobre qualquer assunto - do zero ao PDF pronto, com capas e infográficos gerados automaticamente. Dá uma olhada!

A função filter

A função filter do Python serve para filtrar elementos de iteráveis que satisfaçam determinadas condições.

Essas condições são calculadas através de uma função que deve retornar True ou False para determinado argumento de entrada.

A abordagem mais comum, assim como a função map, seria a utilização de loops para iterar sobre os elementos verificando elemento a elemento se a condição foi satisfeita ou não.

Contudo, com a função filter é possível fazer isso sem ter que se preocupar com as estruturas de repetição for ou while!

A sintaxe da função filter é:

1

filter(funcao, iteravel)

Nela:

• funcao é a função de filtragem dos elementos, que deve retornar True ou False; e
• iteravel é a estrutura na qual a função funcao será aplicada.

Diferente do map, o filter aceita apenas um iterável (passar dois gera TypeError: filter expected 2 arguments, got 3). Detalhes na documentação oficial da função filter().

Vamos entender melhor com exemplos!

Exemplos da função filter

Suponha que você tenha que desenvolver uma função que filtra elementos maiores que zero de uma lista.

O código abaixo, utilizando o loop de repetição for seria uma possível solução:

1
2
3
4
5
6
7
8
9
10
11

def numeros_positivos(numeros):
    numeros_positivos = []

    for num in numeros:
        # Condição de filtragem
        if num > 0:
            numeros_positivos.append(num)

    return numeros_positivos

print(numeros_positivos([-2, -1, 0, 1, 2]))

E a saída seria:

1

[1, 2]

Veja como seria possível chegar ao mesmo resultado utilizando a função filter:

1
2
3
4
5
6

numeros = [-2, -1, 0, 1, 2]

def verifica_numero_positivo(numero):
    return numero > 0

print(list(filter(verifica_numero_positivo, numeros)))

E a saída seria exatamente a mesma ([1, 2]): com menos linhas de código e com um código muito mais pythônico!

filter(None, ...): removendo valores vazios

Se você passar None no lugar da função, o filter mantém só os itens verdadeiros (truthy) e descarta os falsos: 0, '', None, False, listas e dicionários vazios. É ótimo para limpar dados:

1
2
3
4
5

dados = [0, 1, '', 'python', None, [], [3], False, True]
print(list(filter(None, dados)))  # [1, 'python', [3], True]

nomes = ['Ana', '', 'Bia', None, 'Caio', '']
print(list(filter(None, nomes)))  # ['Ana', 'Bia', 'Caio']

Cuidado: o 0 também é descartado. Se zero for um valor válido nos seus dados, use uma condição explícita, como filter(lambda x: x is not None, dados).

Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Dica EXTRA: Funções Lambda

Quer deixar seu código ainda mais pythônico?

Utilize funções lambda em conjunto com as funções map e filter e tenha os mesmos resultados dos exemplos anteriores com ainda menos linhas de código!

Ainda não domina o conceito de Funções Lambda?! Não tem problema, acesse nosso artigo sobre Funções Lambda antes de continuar

Exemplo “soma + 5” do map utilizando funções lambda:

1
2
3
4

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

resultado = list(map(lambda x: x+5, lista))
print(resultado)  # [6, 7, 8, 9, 10]

Exemplo de filtragem de números positivos do filter utilizando funções lambda:

1
2
3
4

numeros = [-2, -1, 0, 1, 2]

numeros_positivos = list(filter(lambda x: x > 0, numeros))
print(numeros_positivos)  # [1, 2]

map e filter retornam iteradores, não listas

No Python 3, map() e filter() não devolvem uma lista: devolvem um iterador preguiçoso (lazy), que só calcula cada valor quando alguém pede. Por isso o print direto mostra o objeto, e não os valores:

1
2
3
4

dobros = map(lambda x: x * 2, [1, 2, 3])

print(dobros)        # <map object at 0x7f98792aec80> (o endereço muda a cada execução)
print(type(dobros))  # <class 'map'>

Três consequências práticas:

1. Para ver os valores, converta: list(dobros), tuple(dobros), set(dobros), ou percorra com for.
2. Ele só pode ser consumido uma vez. Depois de percorrido, fica vazio:

1
2
3
4
5
6

dobros = map(lambda x: x * 2, [1, 2, 3])

print(next(dobros))  # 2
print(next(dobros))  # 4
print(list(dobros))  # [6]  (só sobrou o último)
print(list(dobros))  # []   (já foi consumido)

3. Não tem len() nem índice. len(dobros) gera TypeError: object of type 'map' has no len() e dobros[0] gera TypeError: 'map' object is not subscriptable. Se precisar disso, guarde o resultado em uma lista.

A vantagem é a economia de memória: map(lambda x: x * 2, range(10**9)) é criado na hora, porque nenhum dos um bilhão de valores é calculado até você pedir. É o mesmo mecanismo dos generators, explicado em detalhes no post sobre iterators e generators em Python.

A função reduce (functools)

A terceira peça do trio “map, filter, reduce” é a reduce(). Ela combina todos os itens em um único valor, aplicando a função de dois em dois: o resultado acumulado e o próximo item.

Diferente de map e filter, ela não é embutida no Python 3. Você precisa importá-la do módulo functools (veja a documentação de functools.reduce):

1
2
3
4
5

from functools import reduce

print(reduce(lambda acc, x: acc + x, [1, 2, 3, 4]))       # 10
print(reduce(lambda acc, x: acc * x, [1, 2, 3, 4], 1))    # 24
print(reduce(lambda a, b: a if a > b else b, [3, 9, 2, 7]))  # 9

No primeiro exemplo, o reduce calcula ((1 + 2) + 3) + 4 = 10. O terceiro argumento (o 1 do segundo exemplo) é o valor inicial, e é o que evita erro quando a lista está vazia: reduce(lambda acc, x: acc + x, [], 0) devolve 0.

Os três juntos formam um pipeline: transformar, filtrar e agregar.

1
2
3
4
5
6
7
8
9

from functools import reduce

precos = [100, 250, 40, 80]

com_desconto = map(lambda p: p * 0.9, precos)          # 10% de desconto
acima_de_50 = filter(lambda p: p > 50, com_desconto)   # só os que ainda passam de 50
total = reduce(lambda acc, p: acc + p, acima_de_50, 0)

print(total)  # 387.0

Para soma, máximo e mínimo, prefira as embutidas sum(), max() e min(), que são mais legíveis. O mesmo pipeline cabe em uma linha: sum(p * 0.9 for p in precos if p * 0.9 > 50) também dá 387.0. Guarde o reduce para agregações que não têm função pronta.

Escolher bem entre map, filter e list comprehension vem da prática, não da teoria. Na Jornada Python você treina esse tipo de decisão em projetos reais, com suporte de professor:

Domine Python: A Linguagem da Inteligência Artificial, do Desenvolvimento Web e das Carreiras do Futuro.

A mais completa formação para você se tornar um especialista em Python, pronto para construir desde aplicações web robustas com Django até projetos de Inteligência Artificial e Ciência de Dados .

Quero conhecer!

Nota 4,9 de 5 na Hotmart O curso de Python mais bem avaliado da Hotmart!

map/filter vs List Comprehension

Comparação Prática

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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

# Transformar: elevar ao quadrado
# map()
result_map = list(map(lambda x: x**2, numbers))

# List comprehension (⚡ Mais Pythônico!)
result_comp = [x**2 for x in numbers]

# Filtrar: apenas pares
# filter()
evens_filter = list(filter(lambda x: x % 2 == 0, numbers))

# List comprehension (⚡ Mais Pythônico!)
evens_comp = [x for x in numbers if x % 2 == 0]

# Transformar + Filtrar: pares ao quadrado
# map() + filter()
result_functional = list(map(lambda x: x**2, filter(lambda x: x % 2 == 0, numbers)))

# List comprehension (⚡ MUITO mais legível!)
result_pythonic = [x**2 for x in numbers if x % 2 == 0]

print(result_map, evens_filter, result_functional)  # [1, 4, 9, 16, 25] [2, 4] [4, 16]

Se quiser se aprofundar na sintaxe com if e if/else, veja o guia completo de list comprehensions no Python.

Quando Usar map/filter?

✅ Use map() quando:

• Já tem a função pronta (não precisa de lambda)
• Quer reutilizar a transformação
• Programação funcional é o estilo do projeto

1
2
3
4
5
6
7
8
9

# ✅ BOM: Função pronta
import math
numbers = [1, 4, 9, 16]
sqrt_numbers = list(map(math.sqrt, numbers))  # Limpo!

# vs list comprehension (mais verboso)
sqrt_numbers = [math.sqrt(x) for x in numbers]

print(sqrt_numbers)  # [1.0, 2.0, 3.0, 4.0]

✅ Use filter() quando:

• Filtro complexo já existe como função
• Combinar com outros iteradores

1
2
3
4
5
6
7

def is_valid_email(email):
    return '@' in email and '.' in email.split('@')[1]

emails = ['[email protected]', 'invalid', '[email protected]']
valid = list(filter(is_valid_email, emails))  # ✅ Claro!

print(valid)  # ['[email protected]', '[email protected]']

⚡ Use list comprehension quando:

• Maioria dos casos (mais Pythônico!)
• Precisa de legibilidade
• Lógica é inline

Tabela de decisão: map/filter, list comprehension ou for

Caso de Uso Prático

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# Processar dados de API
users_raw = [
    {'name': 'Alice', 'age': 30, 'active': True},
    {'name': 'Bob', 'age': 17, 'active': True},
    {'name': 'Charlie', 'age': 25, 'active': False},
]

# Abordagem 1: Programação Funcional
active_adults = list(
    map(lambda u: u['name'],
        filter(lambda u: u['active'] and u['age'] >= 18, users_raw)
    )
)

# Abordagem 2: List Comprehension (⚡ Mais legível!)
active_adults = [
    u['name']
    for u in users_raw
    if u['active'] and u['age'] >= 18
]

print(active_adults)  # ['Alice']

:suitcase: Use map, filter em funções lambda na sua próxima entrevista de emprego e impressione o recrutador! Mas lembre-se: list comprehensions são mais Pythônicas!

Erros comuns

1. Imprimir o map e ver <map object at 0x...>

1
2

dobros = map(lambda x: x * 2, [1, 2, 3])
print(dobros)

1

<map object at 0x7f98792aec80>

Não é erro de sintaxe, mas é a dúvida número 1. O map (e o filter) é um iterador; para ver os valores, converta: print(list(dobros)) mostra [2, 4, 6].

2. Percorrer o mesmo map/filter duas vezes (a segunda vem vazia)

1
2
3
4
5

nums = [1, 2, 3, 4, 5, 6]
pares = filter(lambda n: n % 2 == 0, nums)

print(list(pares))  # [2, 4, 6]
print(list(pares))  # []

O primeiro list() consumiu o iterador. Se você vai usar o resultado mais de uma vez (ou chamar len()), guarde em uma lista logo de cara: pares = list(filter(lambda n: n % 2 == 0, nums)).

3. TypeError por função com número errado de argumentos

1
2
3
4

def soma(a, b):
    return a + b

print(list(map(soma, [1, 2, 3])))

1
2
3
4

Traceback (most recent call last):
  File "main.py", line 4, in <module>
    print(list(map(soma, [1, 2, 3])))
TypeError: soma() missing 1 required positional argument: 'b'

O map passa um item de cada iterável para a função. Com uma lista só, soma recebe um argumento, mas espera dois. Passe uma segunda lista (map(soma, [1, 2, 3], [10, 20, 30]) resulta em [11, 22, 33]) ou use uma função de um parâmetro.

4. NameError: name 'reduce' is not defined

1
2

numeros = [1, 2, 3, 4]
total = reduce(lambda acc, x: acc + x, numeros)

1
2
3
4

Traceback (most recent call last):
  File "main.py", line 2, in <module>
    total = reduce(lambda acc, x: acc + x, numeros)
NameError: name 'reduce' is not defined

No Python 3, reduce saiu das funções embutidas e foi para o módulo functools. Adicione from functools import reduce no topo do arquivo (ou, para somar, use simplesmente sum(numeros)).

5. ValueError no map(int, input().split())

1

numeros = list(map(int, input().split()))  # usuário digita: 1,2,3

1
2
3
4

Traceback (most recent call last):
  File "main.py", line 1, in <module>
    numeros = list(map(int, input().split()))
ValueError: invalid literal for int() with base 10: '1,2,3'

O .split() sem argumento separa por espaços, então '1,2,3' continua sendo um pedaço só, que o int não consegue converter. Use input().split(',') quando a entrada vier com vírgulas. Outro ValueError parecido é too many values to unpack (expected 2), que acontece em a, b = map(int, input().split()) quando o usuário digita três números.

Exercícios resolvidos

Tente resolver antes de abrir a solução. Todas as saídas abaixo foram obtidas executando o código.

Exercício 1. Você recebeu a lista ['10', '25', '7'] (números como texto). Use map para convertê-la em inteiros e mostre a lista convertida e a soma.

1
2
3
4

textos = ['10', '25', '7']
numeros = list(map(int, textos))
print(numeros)
print(sum(numeros))

Exercício 2. Usando map e uma função embutida, gere a lista com a quantidade de letras de cada palavra de ['python', 'map', 'filter', 'lambda'].

1
2

palavras = ['python', 'map', 'filter', 'lambda']
print(list(map(len, palavras)))

Exercício 3. Um formulário gerou a lista ['Ana', '', 'Bia', None, 'Caio', '']. Remova os valores vazios usando filter sem escrever nenhuma função.

1
2

nomes = ['Ana', '', 'Bia', None, 'Caio', '']
print(list(filter(None, nomes)))

Exercício 4. Dadas as listas precos = [10.0, 2.5, 4.0] e quantidades = [2, 4, 1], use um único map para calcular o subtotal de cada item e depois o total da compra.

1
2
3
4
5
6

precos = [10.0, 2.5, 4.0]
quantidades = [2, 4, 1]

subtotais = list(map(lambda p, q: p * q, precos, quantidades))
print(subtotais)
print(sum(subtotais))

Exercício 5 (questão de prova). Qual é a saída do código abaixo no Python 3?

1

print(map(lambda x: x * 2, [1, 2, 3]))

a) [2, 4, 6]
b) (2, 4, 6)
c) Algo como <map object at 0x7f...>
d) TypeError

Exercício 6 (questão de prova). O que o código abaixo imprime?

1
2
3
4

nums = [1, 2, 3, 4, 5, 6]
pares = filter(lambda n: n % 2 == 0, nums)
print(list(pares))
print(list(pares))

a) [2, 4, 6] e [2, 4, 6]
b) [2, 4, 6] e []
c) [1, 3, 5] e []
d) TypeError na segunda linha de print

Exercício 7. Use reduce para calcular o produto de todos os números de [2, 3, 4].

1
2
3
4
5

from functools import reduce

valores = [2, 3, 4]
produto = reduce(lambda acc, x: acc * x, valores)
print(produto)

Exercício 8. Leia em uma única linha vários números inteiros separados por espaço, mantenha só os pares e mostre a lista dos seus quadrados. Faça com map/filter e depois com list comprehension. Teste com a entrada 4 7 10 3 8.

1
2
3
4
5
6
7
8

# Versão com map e filter
numeros = map(int, input().split())
pares = filter(lambda n: n % 2 == 0, numeros)
quadrados = list(map(lambda n: n ** 2, pares))
print(quadrados)

# Versão com list comprehension (substitui as quatro linhas acima)
# quadrados = [n ** 2 for n in map(int, input().split()) if n % 2 == 0]

Quer praticar isso em projetos de verdade, com suporte de professor? Conheça o nosso curso de Python completo, a Jornada Python.

Conclusão

Neste guia completo sobre map() e filter(), você aprendeu:

✅ Sintaxe - map() transforma, filter() filtra
✅ Iteradores - por que usar list() e por que só dá para percorrer uma vez
✅ reduce() e map(int, input().split()) - os usos que mais aparecem em exercícios
✅ map/filter vs list comprehension - Comprehensions são mais Pythônicas
✅ Quando usar cada um - Funções prontas vs inline
✅ Casos práticos - Processamento de dados

Principais lições:

• List comprehensions são mais Pythônicas na maioria dos casos
• Use map() quando já tem função pronta (sem lambda)
• Use filter() quando filtro é complexo e reutilizável
• Evite lambdas complexas em map/filter
• Legibilidade > pureza funcional

Próximos passos:

• Pratique list comprehensions (mais importante!)
• Explore functools.reduce() para agregações sem função pronta
• Estude a biblioteca itertools para operações avançadas
• Combine com generators para eficiência

Depois de termos nos aprofundado nas funções map, filter, além das funções lambda, você poderá treinar essas habilidades a fim de se tornar um programador cada vez melhor!

Por Vinícius Ramos em 11/01/2023

Engenheiro de Computação pela UnB com especialização em Inteligência Artificial. Sr. Software Engineer com 10+ anos de experiência desenvolvendo sistemas críticos em Python e Django. Atuei no Banco do Brasil liderando equipes para monitoramento de mainframe, trabalhei como desenvolvedor sênior em projetos forenses para a Polícia Federal, e atualmente sou engenheiro de software na Labcorp (Estados Unidos), desenvolvendo soluções escaláveis para testes genéticos. Fundador da Python Academy, compartilhando conhecimento técnico com a comunidade brasileira desde 2018.

Bora se conectar no LinkedIn! vinicius-aramos

Minhas redes:

• 
• 
•