Estruturas Condicionais no Python: if, elif e else

✅ Artigo atualizado em Setembro 2026 Novas seções sobre indentação, elif vs vários if e condições compostas com and/or/not, tabela de decisão (if/elif, match/case, dicionário ou ternário), erros comuns com traceback e 8 exercícios resolvidos. Código testado no Python 3.10+.

1
2
3
4
5
6
7

nota = 7.5
if nota >= 7:
    print("Aprovado")      # <- é este que roda
elif nota >= 5:
    print("Recuperação")
else:
    print("Reprovado")

Salve, salve Pythonista!

Nesse post vamos falar sobre as estruturas que controlam o fluxo de execução de programas Python: if, elif, else, o ternário, o match/case e as condições compostas. Vai ser difícil você abrir um código Python e não encontrar um if, então vale dominar os detalhes - inclusive os que mais caem em prova.

Bora pro conteúdo!

Vá Direto ao Assunto…

• Introdução
• Estrutura Condicional if
• Sintaxe do if em Python: dois pontos e indentação
• Estrutura Condicional if/else
• Estrutura Condicional if-elif-else
• Diferença entre elif e vários if
• Estrutura Condicional Ternária (if em uma linha)
• if Aninhado (nested if)
• Condições compostas com and, or e not
• Comparações Encadeadas
• Truthiness: o que o if considera “verdadeiro”
• match/case: Structural Pattern Matching (Python 3.10+)
• Estruturas de Repetição com Estruturas Condicionais
• List Comprehensions com if
• Erros comuns
• Exercícios resolvidos

Introdução

O que são estruturas condicionais (if/elif/else) em Python? São comandos que executam um bloco de código apenas se uma condição for verdadeira. O if testa a condição principal, o elif testa condições alternativas e o else cobre o caso em que nenhuma das anteriores foi atendida - é assim que o programa toma decisões e controla seu fluxo.

É muito comum na programação, precisarmos que determinado bloco de código seja executado apenas se determinada condição for satisfeita.

Para esses casos, Python disponibiliza formas de se controlar o fluxo de execução de programas: são as chamadas Estruturas Condicionais IF/ELIF/ELSE.

Um conceito muito importante para se trabalhar com condições em Python é entender o conceito dos Operadores: is, not, %=, ==, in entre outros.

Falando nisso, nós temos um post completo sobre Operadores que você pode conferir clicando aqui!

Agora, vamos começar com uma das estruturas condicionais mais utilizadas no Python: o if!

Estrutura Condicional if

O if executa um bloco de código somente quando sua condição é verdadeira; se a condição for falsa, o bloco é ignorado.

Agora que já está craque com os Operadores do Python, vamos aprender sobre nossa primeira estrutura condicional.

Antes de escrever condições, vale ter à mão os principais operadores de comparação e operadores lógicos que usamos dentro de um if:

Sua sintaxe é bem simples, bastando utilizarmos if seguido pela condicao seguido por dois pontos:

Veja o exemplo a seguir:

1
2
3
4

valor = 10

if valor > 5:
    print('O valor é maior que 5.')

Neste caso, a condição está testando se o valor presente na variável valor é maior que 5.

Caso isso aconteça, a linha de código abaixo será executada (nesse exemplo, a chamada à função print()).

A documentação oficial descreve essa estrutura na seção Comandos if do tutorial do Python.

Como 10 é maior que 5 o bloco de código resulta em:

1

O valor é maior que 5.

Caso você precise que um bloco de código seja sempre executado, basta adicionar True à condição:

1
2

if True:
    print("Este bloco sempre irá ser executado.")

Resultado do código acima:

1

Este bloco sempre irá ser executado.

Sintaxe do if em Python: dois pontos e indentação

Em Python não há chaves { } nem end if: quem diz onde o bloco do if começa e termina é a indentação. As regras são poucas:

• A linha do if (e de cada elif/else) termina com dois pontos :.
• Tudo que pertence ao bloco fica indentado com o mesmo recuo - o padrão da PEP 8 é 4 espaços.
• A primeira linha que volta ao recuo do if já está fora do bloco e roda sempre.
• elif e else ficam alinhados com o if a que pertencem.

1
2
3
4
5
6
7

saldo = 50
valor = 80

if valor > saldo:
    print('Saldo insuficiente')   # dentro do if
    print('Operação cancelada')   # dentro do if
print('Fim do programa')          # fora do if: roda sempre

Resultado do código acima:

1
2
3

Saldo insuficiente
Operação cancelada
Fim do programa

Se o saldo fosse 100, só a última linha seria impressa. Quando a indentação está errada, o Python nem começa a executar o programa: ele acusa IndentationError (veja exemplos reais na seção Erros comuns).

Dica: um bloco não pode ficar vazio. Se você ainda não sabe o que colocar dentro do if, use pass como marcador provisório.

Estrutura Condicional if/else

O else define um bloco que roda quando a condição do if é falsa, garantindo um caminho alternativo para o seu código.

Vimos na seção acima que o if executa um bloco de código se sua condição for atendida, mas e se ela não for atendida e você deseja realizar outra ação?

Bom, basta utilizarmos a estrutura condicional else!

Com ela, toda vez que uma condição não for atendida, o Python executará o bloco de código definido abaixo da cláusula else.

Vamos esclarecer no exemplo abaixo:

1
2
3
4
5
6

idade = 20

if idade < 17:
    print('A idade é MENOR que 17')
else:
    print('A idade é MAIOR que 17')

Neste caso, a condição testa se o valor da variável idade é menor que 17.

Porém, como 17 é menor que 20, o bloco else é então executado, resultando em:

1

A idade é MAIOR que 17

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

Estrutura Condicional if-elif-else

O elif (abreviação de else if) permite testar várias condições em sequência: o Python avalia cada elif na ordem e executa o primeiro cujo teste for verdadeiro.

O elif é utilizado quando mais de uma condição if precisa ser testada. Exemplo:

1
2
3
4
5
6
7
8
9
10

linguagem = "Python"

if linguagem == "C++":
    print('C++ é uma linguagem de programação compilada.')
elif linguagem == "Python":
    print("Python é uma linguagem de programação de alto nível")
elif linguagem == "Java":
    print("Java é uma linguagem de programação amplamente utilizada no mercado")
else:
    print('Não é nenhuma das três opções')

Neste exemplo, estamos verificando o valor da variável linguagem em diversos testes.

Note que a saída abaixo é exatamente o resultado da execução do elif, já que o valor da variável linguagem é igual à “Python”:

1

Python é uma linguagem de programação de alto nível

Três regras do elif que costumam cair em prova:

• Ele é opcional e pode aparecer quantas vezes você quiser, sempre depois do if e antes do else.
• O else também é opcional, mas se existir é único e vem por último.
• Não existe else if em Python: a palavra é elif (escrever else if gera SyntaxError).

Diferença entre elif e vários if

Essa é a dúvida mais comum sobre o elif. Numa cadeia if/elif/else, o Python para no primeiro teste verdadeiro e pula todo o resto. Já vários if seguidos são independentes: todos são testados, e mais de um bloco pode rodar.

Veja a mesma nota com vários if:

1
2
3
4
5
6
7
8

nota = 9

if nota >= 5:
    print("Recuperação ou melhor")
if nota >= 7:
    print("Aprovado")
if nota >= 9:
    print("Excelente")

Resultado do código acima (os três testes são verdadeiros, então os três blocos rodam):

1
2
3

Recuperação ou melhor
Aprovado
Excelente

Agora com elif, testando da faixa mais alta para a mais baixa:

1
2
3
4
5
6
7
8

nota = 9

if nota >= 9:
    print("Excelente")
elif nota >= 7:
    print("Aprovado")
elif nota >= 5:
    print("Recuperação")

Resultado do código acima:

1

Excelente

Resumindo:

• Use if/elif/else quando as opções são mutuamente exclusivas (faixas de nota, menu de opções). Além de evitar saídas duplicadas, o Python deixa de avaliar os testes restantes.
• Use vários if quando as verificações são independentes e mais de uma pode valer ao mesmo tempo (ex.: validar vários campos de um formulário e mostrar todos os erros).
• Com elif, a ordem importa: se o teste nota >= 5 viesse primeiro, uma nota 9 cairia nele e nunca chegaria em “Excelente”.

Estrutura Condicional Ternária (if em uma linha)

O operador ternário condensa um if/else em uma única linha no formato valor_se_verdadeiro if condição else valor_se_falso, ideal para escolher entre dois valores rapidamente.

Python provê uma forma concisa de se testar valores com apenas uma linha de código

São os chamados if-ternários, ou condições ternárias, ou operadores ternários: os nomes são diversos!

Veja um exemplo:

1
2
3
4
5

velocidade = 75

resultado = 'Multado' if velocidade > 60 else 'Dentro do limite'

print(resultado)

Nesse caso, está sendo verificado se o valor da variável velocidade é maior que 60 e:

• Caso a condição seja verdadeira a variável resultado receberá o valor Multado;
• Caso a condição seja falsa, a variável resultado receberá o valor Dentro do limite.

Bem, pelo resultado abaixo parece que alguém foi multado

1

Multado

O ternário serve para escolher entre dois valores, não para executar blocos com várias linhas. Dá para aninhar (a if x else b if y else c), mas a leitura piora rápido: com três ou mais caminhos, volte para o if/elif/else. Para ordem de avaliação, a armadilha do or com valores falsy e as formas antigas, veja o guia completo do operador ternário.

if Aninhado (nested if)

Um if aninhado é simplesmente um if dentro de outro if, usado quando uma decisão só faz sentido depois que outra já foi tomada.

Imagine que, para alguém poder dirigir, primeiro ela precisa ser maior de idade e, só então, verificamos se possui carteira:

1
2
3
4
5
6
7
8
9
10

idade = 25
possui_carteira = True

if idade >= 18:
    if possui_carteira:
        print('Pode dirigir')
    else:
        print('Precisa tirar a carteira')
else:
    print('Menor de idade')

Resultado do código acima:

1

Pode dirigir

Repare que o else interno pertence ao if possui_carteira, enquanto o else externo pertence ao if idade >= 18. A indentação é o que define a qual if cada else está ligado.

Condições compostas com and, or e not

Quando uma decisão depende de mais de um teste, você combina as condições com os operadores lógicos, em vez de aninhar vários if:

• and: verdadeiro só se as duas condições forem verdadeiras;
• or: verdadeiro se pelo menos uma for verdadeira;
• not: inverte o resultado (not True é False).

1
2
3
4
5
6
7
8
9
10
11
12
13
14

idade = 20
tem_ingresso = True
acompanhado = False

if idade >= 18 and tem_ingresso:
    print("Pode entrar")

if idade < 12 or acompanhado:
    print("Precisa de responsável")
else:
    print("Não precisa de responsável")

if not acompanhado:
    print("Está sozinho")

Resultado do código acima:

1
2
3

Pode entrar
Não precisa de responsável
Está sozinho

Dois detalhes que fazem diferença:

1. Precedência: not é avaliado primeiro, depois and, depois or. Na dúvida, use parênteses - eles também deixam a intenção clara para quem lê:

1
2

print(True or False and False)    # and primeiro: True or (False and False)
print((True or False) and False)  # parênteses mudam a ordem

1
2

True
False

2. Curto-circuito: o Python para de avaliar assim que sabe o resultado. Num and, se o primeiro teste for falso, o segundo nem é executado. Isso permite escrever testes seguros como este, que não quebra com a lista vazia:

1
2
3
4
5
6

lista = []

if lista and lista[0] > 10:
    print("primeiro maior que 10")
else:
    print("lista vazia ou primeiro <= 10")

1

lista vazia ou primeiro <= 10

Sem o lista and na frente, lista[0] levantaria IndexError: list index out of range. Para ver todos os operadores com mais exemplos, confira o guia de operadores aritméticos, de comparação e lógicos em Python.

Comparações Encadeadas

O Python permite encadear comparações de forma matemática e legível, como if 0 < x < 10:, em vez de escrever if x > 0 and x < 10:.

Veja na prática:

1
2
3
4

x = 7

if 0 < x < 10:
    print('x está entre 0 e 10')

Resultado do código acima:

1

x está entre 0 e 10

Essa sintaxe é idiomática em Python (parece até notação de matemática!) e funciona com qualquer operador de comparação, como if 0 <= nota <= 100:.

Truthiness: o que o if considera “verdadeiro”

O if não exige um True ou False explícito: ele avalia a “verdade” (truthiness) do objeto que recebe. Valores considerados falsy (avaliados como False) fazem o bloco não executar.

Os valores falsy em Python são:

Qualquer outro valor é considerado truthy (avaliado como True). Por isso, em vez de escrever if len(lista) > 0:, o jeito idiomático é deixar o próprio if avaliar a lista:

1
2
3
4
5
6

carrinho = []

if carrinho:
    print('Tem itens no carrinho')
else:
    print('O carrinho está vazio')

Resultado do código acima:

1

O carrinho está vazio

Como a lista está vazia ([] é falsy), o bloco else é executado. Esse padrão deixa o código mais limpo e legível.

Cuidado com as pegadinhas: a string '0' e a lista [0] não são vazias, então são truthy. Você pode conferir qualquer valor com bool() (o tipo booleano é explicado no post sobre tipos de variáveis no Python):

1
2

for valor in [0, '', [], None, '0', [0], -1]:
    print(repr(valor), bool(valor))

1
2
3
4
5
6
7

0 False
'' False
[] False
None False
'0' True
[0] True
-1 True

Depois de dominar if, elif e else, o próximo salto é aplicar essa lógica em projetos de verdade, com suporte de professor quando você travar. É exatamente isso que a Jornada Python oferece:

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!

match/case: Structural Pattern Matching (Python 3.10+)

A partir do Python 3.10 (PEP 634), surgiu o match/case, uma alternativa ao if/elif/else para comparar uma mesma variável contra vários valores ou padrões - semelhante ao switch de outras linguagens, porém mais poderoso.

Veja como tratar diferentes códigos de status HTTP:

1
2
3
4
5
6
7
8
9
10
11

status = 404

match status:
    case 200:
        print('OK')
    case 301 | 302:
        print('Redirecionamento')
    case 404:
        print('Não encontrado')
    case _:
        print('Outro status')

Resultado do código acima:

1

Não encontrado

Alguns detalhes importantes:

• O case _: funciona como um “default”, capturando qualquer valor que não casou com os anteriores;
• O | (barra vertical) permite testar vários valores no mesmo case, como em case 301 | 302:.

Quando usar match/case vs if/elif/else? Use match/case quando você compara uma única variável contra valores ou padrões fixos - fica mais legível que uma pilha de elif. Já para condições com intervalos (if 0 < x < 10:), lógica composta (and/or) ou testes de variáveis diferentes, o if/elif/else continua sendo a melhor escolha. A sintaxe completa (com captura de variáveis, sequências e classes) está na seção match do tutorial oficial.

Existe ainda uma terceira alternativa para trocar uma pilha de elif: o dicionário de despacho, que mapeia cada opção para uma função. Funciona em qualquer versão do Python e é fácil de estender (basta adicionar uma chave). Se você ainda não domina dicionários, veja o guia de dicionários no Python.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

def subtrair(a, b):
    return a - b

operacoes = {'+': somar, '-': subtrair}

op = '-'
funcao = operacoes.get(op)

if funcao:
    print(funcao(10, 3))
else:
    print('Operação inválida')

Resultado do código acima:

1

7

Tabela de decisão: qual estrutura condicional usar?

O match/case só funciona no Python 3.10 ou superior. Em versões anteriores, ele causa um SyntaxError.

Estruturas de Repetição com Estruturas Condicionais

Podemos juntar as Estruturas de Repetição com as Estruturas Condicionais, que aliás trabalham muito bem juntas.

Se você quer aprender mais sobre estruturas de repetição, loops, for, while e muito mais acesse nosso post feito especialmente para este tema: Loops e estruturas de repetição no Python.

Veja um exemplo dessas estruturas trabalhando em conjunto:

1
2
3
4
5

for numero in range(1, 5):
    if numero % 2 == 0:
        print(f'O número {numero} é par')
    else:
        print(f'O número {numero} é ímpar')

Resultado do código acima:

1
2
3
4

O número 1 é ímpar
O número 2 é par
O número 3 é ímpar
O número 4 é par

Nota: O operador % retorna o resto da divisão.

Criei o Ebookr.ai, uma plataforma que usa IA para gerar ebooks profissionais sobre qualquer tema - com capa gerada por IA, infográficos automáticos e exportação em PDF. Confere!

List Comprehensions com if

Outro lugar onde podemos utilizar as Estruturas Condicionais são nas chamadas List Comprehensions do Python.

Suponha que te peçam para: escrever um código que retorne apenas os números pares de uma sequência de 0 a 10.

Veja como isto poderia ser feito em apenas 1 linha de código!

1
2

list_comp = [numero for numero in range(0, 11) if numero % 2 == 0]
print(list_comp)

Resultado do código acima:

1

[0, 2, 4, 6, 8, 10]

E se, em vez de filtrar, você quiser transformar cada item com um if/else? Aí o ternário vai antes do for (o if sozinho, sem else, vai depois):

1

print(['par' if n % 2 == 0 else 'ímpar' for n in range(5)])

1

['par', 'ímpar', 'par', 'ímpar', 'par']

Esse é o poder das Estruturas de Repetição em conjunto com as Estruturas Condicionais e ainda List Comprehensions!

Python é demais!

Caso você ainda não conheça as List Comprehensions, vou te recomendar um conteúdo que vale ouro para que possa aprender sobre o assunto: List Comprehensions no Python!

Erros comuns

Estes são os erros com if que mais aparecem em código de iniciante (e em questão de prova). As mensagens abaixo são as reais do Python 3.10+.

1. Usar = no lugar de ==

1
2
3
4

x = 10

if x = 10:
    print("dez")

1

SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?

= guarda um valor numa variável; == compara. Dentro da condição, use if x == 10:.

2. Esquecer a indentação (IndentationError)

1
2
3
4

idade = 20

if idade >= 18:
print("Maior de idade")

1

IndentationError: expected an indented block after 'if' statement on line 3

O bloco do if precisa estar recuado (4 espaços). Misturar recuos dentro do mesmo bloco também quebra: um recuo a mais gera IndentationError: unexpected indent, e um recuo que não bate com nenhum nível anterior gera IndentationError: unindent does not match any outer indentation level. Configure seu editor para inserir 4 espaços ao apertar Tab.

3. Escrever else if (ou esquecer os dois pontos)

1
2
3
4
5

x = 5
if x > 10:
    print("a")
else if x > 3:
    print("b")

1

SyntaxError: expected ':'

Em Python a palavra é elif x > 3:. A mesma mensagem SyntaxError: expected ':' aparece quando você esquece os dois pontos no final de if, elif ou else.

4. Comparar o texto do input() com um número

1
2
3
4

idade = "20"  # input() sempre devolve str

if idade >= 18:
    print("Maior de idade")

1

TypeError: '>=' not supported between instances of 'str' and 'int'

O input() sempre retorna uma string. Converta antes de comparar: idade = int(input("Idade: ")). Veja mais no post sobre input e print: entrada e saída de dados no Python.

5. if x == 1 or 2 (sempre verdadeiro, sem erro nenhum)

1
2
3
4

opcao = 5

if opcao == 1 or 2:
    print("Opção 1 ou 2")

1

Opção 1 ou 2

Esse é o pior tipo de erro: não aparece traceback, mas o resultado está errado. O Python lê (opcao == 1) or 2, e 2 é truthy, então a condição é sempre verdadeira. O correto é repetir a comparação (opcao == 1 or opcao == 2) ou, melhor ainda, usar in: if opcao in (1, 2):.

Exercícios resolvidos

Tente resolver antes de abrir a solução. Todos os códigos foram executados e as saídas conferidas.

Exercício 1. Dado numero = 7, escreva um if/else que imprima se o número é par ou ímpar.

1
2
3
4
5
6

numero = 7

if numero % 2 == 0:
    print(f'{numero} é par')
else:
    print(f'{numero} é ímpar')

Exercício 2. Dados três números a, b, c = 12, 45, 30, descubra o maior usando if/elif/else (sem usar a função max()).

1
2
3
4
5
6
7
8
9
10

a, b, c = 12, 45, 30

if a >= b and a >= c:
    maior = a
elif b >= c:
    maior = b
else:
    maior = c

print(f'O maior é {maior}')

Exercício 3. Classifique a temperatura: abaixo de 15 é “Frio”, de 15 até menos de 25 é “Agradável”, de 25 até menos de 35 é “Quente” e 35 ou mais é “Muito quente”. Teste com temperatura = 28.

1
2
3
4
5
6
7
8
9
10

temperatura = 28

if temperatura < 15:
    print('Frio')
elif temperatura < 25:
    print('Agradável')
elif temperatura < 35:
    print('Quente')
else:
    print('Muito quente')

Exercício 4. Um ano é bissexto se for divisível por 4 e não por 100, ou se for divisível por 400. Escreva a condição e teste com ano = 2024.

1
2
3
4
5
6

ano = 2024

if (ano % 4 == 0 and ano % 100 != 0) or ano % 400 == 0:
    print(f'{ano} é bissexto')
else:
    print(f'{ano} não é bissexto')

Exercício 5 (estilo prova). Qual é a saída do código abaixo?

1
2
3
4
5
6
7
8

x = 15

if x > 10:
    print('A')
if x > 5:
    print('B')
else:
    print('C')

• a) A
• b) A e B
• c) A, B e C
• d) B

1
2

A
B

Exercício 6 (estilo prova). Sobre if, elif e else em Python, analise as afirmativas:

• I. O if executa um bloco quando a condição é verdadeira.
• II. O else executa um bloco quando nenhuma condição anterior foi atendida.
• III. Toda estrutura que tem else precisa ter pelo menos um elif.
• IV. Numa cadeia if/elif/else, mais de um bloco pode ser executado se várias condições forem verdadeiras.

Está correto o que se afirma em:

• a) I e II, apenas.
• b) I, II e III, apenas.
• c) II e IV, apenas.
• d) I, II, III e IV.

1
2
3
4
5
6
7
8
9
10
11

x = 3

if x > 5:
    print('maior que 5')
else:              # else sem nenhum elif: válido (III é falsa)
    print('5 ou menos')

if x > 1:
    print('maior que 1')
elif x > 2:        # também é verdadeiro, mas não roda (IV é falsa)
    print('maior que 2')

1
2

5 ou menos
maior que 1

Exercício 7 (estilo prova). Qual é o valor de mensagem depois do código abaixo?

1
2

estoque = 0
mensagem = 'Disponível' if estoque else 'Esgotado'

• a) 'Disponível'
• b) 'Esgotado'
• c) 0
• d) O código gera SyntaxError.

1
2
3

estoque = 0
mensagem = 'Disponível' if estoque else 'Esgotado'
print(mensagem)

Exercício 8. Usando match/case (Python 3.10+), crie uma função calcular(a, operador, b) que faça +, -, * e /, retorne 'Erro: divisão por zero' quando b for 0 na divisão e 'Operador inválido' para qualquer outro operador.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def calcular(a, operador, b):
    match operador:
        case '+':
            return a + b
        case '-':
            return a - b
        case '*':
            return a * b
        case '/':
            return a / b if b != 0 else 'Erro: divisão por zero'
        case _:
            return 'Operador inválido'

print(calcular(8, '*', 3))
print(calcular(8, '/', 0))
print(calcular(8, '^', 2))

1
2
3

24
Erro: divisão por zero
Operador inválido

Conclusão

Nesse post vimos um dos pilares da programação em Python: as Estruturas Condicionais.

Vimos todos os seus sabores e onde podemos utilizá-las para controlarmos o fluxo de execução dos nossos programas em Python!

Quer praticar condicionais, loops e funções construindo projetos guiados do zero? Esse é o caminho do nosso curso de Python completo, a Jornada Python.

Se ficou com alguma dúvida, fique à vontade para deixar um comentário no box aqui embaixo! Será um prazer te responder!

Por Erickson Lopes em 24/07/2021

O infinito é o limite

Bora se conectar no LinkedIn! ericksonlopes

Minhas redes:

• 
•