Python Brasil —...

Perguntas de Entrevista Python: 30 Questoes Mais Cobradas

8 min de leitura Atualizado em 27 Apr 2026

Guia Completo de Entrevistas para Programadores Python

Preparar-se para uma entrevista tecnica de Python pode ser a diferenca entre conseguir a vaga dos sonhos ou perder uma oportunidade. Em 2026, as empresas brasileiras estao cada vez mais rigorosas nos processos seletivos, exigindo tanto conhecimento teorico quanto habilidade pratica.

Neste guia, reunimos as 30 perguntas mais cobradas em entrevistas de Python no Brasil, com respostas detalhadas e exemplos de codigo. Se voce esta comecando sua carreira, confira tambem nosso guia de como conseguir seu primeiro emprego Python.

Perguntas Basicas (Nivel Junior)

Estas perguntas sao frequentes em processos para vagas junior e estagio. Domina-las e obrigatorio.

1. Qual a diferenca entre lista e tupla em Python?

Listas sao mutaveis — voce pode adicionar, remover e alterar elementos apos a criacao. Tuplas sao imutaveis — uma vez criadas, nao podem ser modificadas.

# Lista - mutavel
frutas = ["maca", "banana", "laranja"]
frutas.append("uva")  # OK
frutas[0] = "morango"  # OK

# Tupla - imutavel
coordenadas = (10, 20)
# coordenadas[0] = 30  # TypeError!

Tuplas sao mais rapidas e usam menos memoria. Use-as quando os dados nao devem mudar (coordenadas, configuracoes fixas, chaves de dicionario).

2. O que sao list comprehensions e quando usa-las?

List comprehensions sao uma forma concisa e pythonica de criar listas. Sao mais legiveise geralmente mais rapidas que loops tradicionais.

# Sem comprehension
quadrados = []
for n in range(10):
    quadrados.append(n ** 2)

# Com comprehension
quadrados = [n ** 2 for n in range(10)]

# Com filtro
pares = [n for n in range(20) if n % 2 == 0]

Veja nosso artigo completo sobre compreensao de listas para dominar esse conceito.

3. Como funciona o tratamento de excecoes em Python?

Python usa blocos try/except/else/finally para tratar erros. Veja nosso guia detalhado de tratamento de erros.

try:
    resultado = 10 / 0
except ZeroDivisionError as e:
    print(f"Erro: {e}")
except Exception as e:
    print(f"Erro inesperado: {e}")
else:
    print("Sucesso!")  # Executa se nao houve excecao
finally:
    print("Sempre executa")  # Limpeza de recursos

4. Explique a diferenca entre == e is

O operador == compara valores, enquanto is compara identidade (se sao o mesmo objeto na memoria).

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)  # True (mesmo valor)
print(a is b)  # False (objetos diferentes)
print(a is c)  # True (mesmo objeto)

5. O que sao *args e **kwargs?

*args permite passar um numero variavel de argumentos posicionais, e **kwargs permite argumentos nomeados.

def minha_funcao(*args, **kwargs):
    print(f"Posicionais: {args}")
    print(f"Nomeados: {kwargs}")

minha_funcao(1, 2, 3, nome="Python", versao=3.14)
# Posicionais: (1, 2, 3)
# Nomeados: {'nome': 'Python', 'versao': 3.14}

Perguntas Intermediarias (Nivel Pleno)

Estas perguntas sao comuns em processos para vagas pleno e diferenciam candidatos com conhecimento mais profundo.

6. O que sao decoradores e como funcionam?

Decoradores sao funcoes que modificam o comportamento de outras funcoes. Sao amplamente usados em frameworks como Django e FastAPI.

import time

def medir_tempo(func):
    def wrapper(*args, **kwargs):
        inicio = time.time()
        resultado = func(*args, **kwargs)
        fim = time.time()
        print(f"{func.__name__} executou em {fim - inicio:.4f}s")
        return resultado
    return wrapper

@medir_tempo
def processar_dados(n):
    return sum(range(n))

processar_dados(1_000_000)

Para um estudo aprofundado, confira nosso guia pratico de decoradores.

7. Explique geradores e a palavra-chave yield

Geradores sao funcoes que produzem valores sob demanda usando yield, economizando memoria ao nao carregar tudo de uma vez.

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

# Uso eficiente de memoria - um valor por vez
for num in fibonacci(10):
    print(num)

Veja nosso artigo completo sobre geradores e iteradores.

8. O que e o GIL (Global Interpreter Lock)?

O GIL e um mecanismo do CPython que permite que apenas uma thread execute bytecode Python por vez. Isso afeta a performance de programas CPU-bound com threading, mas nao afeta I/O-bound.

# Para CPU-bound, use multiprocessing
from multiprocessing import Pool

def calcular(n):
    return sum(range(n))

with Pool(4) as pool:
    resultados = pool.map(calcular, [10**7] * 4)

O Python 3.13 introduziu o modo free-threaded (sem GIL) como recurso experimental. Veja tambem nosso guia de multiprocessing.

9. Qual a diferenca entre metodo de classe, metodo estatico e metodo de instancia?

class MinhaClasse:
    atributo_classe = "compartilhado"

    def metodo_instancia(self):
        # Acessa self (instancia)
        return self.atributo_classe

    @classmethod
    def metodo_classe(cls):
        # Acessa cls (classe)
        return cls.atributo_classe

    @staticmethod
    def metodo_estatico():
        # Nao acessa nem self nem cls
        return "funcao comum dentro da classe"

Para mais sobre POO, confira nosso artigo de programacao orientada a objetos.

10. Como funciona o context manager (with)?

Context managers garantem que recursos sejam liberados corretamente, mesmo em caso de erros.

# Uso basico com arquivos
with open("dados.txt", "r") as f:
    conteudo = f.read()
# Arquivo fechado automaticamente

# Criando um context manager customizado
from contextlib import contextmanager

@contextmanager
def conexao_banco():
    conn = criar_conexao()
    try:
        yield conn
    finally:
        conn.close()

Aprofunde-se no nosso artigo sobre context managers e o with.

Perguntas Avancadas (Nivel Senior)

Estas perguntas aparecem em processos para vagas senior e staff, testando conhecimento profundo da linguagem.

11. Explique metaclasses em Python

Metaclasses sao “classes de classes” — elas definem como classes sao criadas. A metaclasse padrao e type.

class MinhaMetaclasse(type):
    def __new__(mcs, name, bases, namespace):
        # Adiciona validacao automatica
        for key, value in namespace.items():
            if callable(value) and not key.startswith("_"):
                namespace[key] = validar(value)
        return super().__new__(mcs, name, bases, namespace)

class MinhaClasse(metaclass=MinhaMetaclasse):
    def meu_metodo(self):
        pass

12. O que sao descriptors?

Descriptors sao objetos que definem comportamento customizado ao acessar atributos de uma classe, implementando __get__, __set__, ou __delete__.

class Validador:
    def __init__(self, minimo, maximo):
        self.minimo = minimo
        self.maximo = maximo

    def __set_name__(self, owner, name):
        self.name = name

    def __set__(self, obj, value):
        if not self.minimo <= value <= self.maximo:
            raise ValueError(f"{self.name} deve estar entre {self.minimo} e {self.maximo}")
        obj.__dict__[self.name] = value

    def __get__(self, obj, objtype=None):
        return obj.__dict__.get(self.name)

class Produto:
    preco = Validador(0, 10000)
    quantidade = Validador(0, 1000)

13. Como funciona async/await em Python?

Programacao assincrona permite executar operacoes I/O-bound de forma concorrente sem threads.

import asyncio
import httpx

async def buscar_dados(url: str) -> dict:
    async with httpx.AsyncClient() as client:
        response = await client.get(url)
        return response.json()

async def main():
    urls = ["https://api.example.com/1", "https://api.example.com/2"]
    tarefas = [buscar_dados(url) for url in urls]
    resultados = await asyncio.gather(*tarefas)
    return resultados

asyncio.run(main())

Confira nosso artigo completo sobre Python async/await.

14. Explique o padrao MRO (Method Resolution Order)

O MRO determina a ordem em que Python busca metodos em hierarquias de heranca multipla, usando o algoritmo C3 Linearization.

class A:
    def metodo(self):
        return "A"

class B(A):
    def metodo(self):
        return "B"

class C(A):
    def metodo(self):
        return "C"

class D(B, C):
    pass

print(D.__mro__)
# (D, B, C, A, object)
print(D().metodo())  # "B"

15. O que sao slots e quando usa-los?

__slots__ restringe os atributos de uma classe e economiza memoria ao nao usar __dict__.

class PontoComSlots:
    __slots__ = ('x', 'y')
    def __init__(self, x, y):
        self.x = x
        self.y = y

# Usa ~40% menos memoria que uma classe normal
# Acesso a atributos ~10% mais rapido

Perguntas sobre Frameworks e Ferramentas

16-20: Django e FastAPI

As empresas brasileiras frequentemente perguntam sobre frameworks web. Os temas mais cobrados incluem:

  • Django ORM vs raw SQL: Quando usar cada um, N+1 queries, select_related e prefetch_related
  • Django middleware: Como funciona o pipeline de middleware e quando criar um customizado
  • FastAPI dependency injection: Como funciona e como criar dependencias reutilizaveis
  • Async no FastAPI vs Django: Quando usar async e quais os beneficios para APIs
  • Serializers e Pydantic: Validacao de dados de entrada em APIs

Para mais sobre esses frameworks, veja nossas comparacoes FastAPI vs Django e Django vs Flask.

21-25: Banco de Dados e Infra

  • SQL vs NoSQL: Quando usar cada um — veja PostgreSQL e MongoDB
  • ORMs em Python: SQLAlchemy e Django ORM — trade-offs
  • Docker e containers: Como containerizar aplicacoes Python — Python e Docker
  • CI/CD: Como configurar pipelines de testes e deploy automatizados
  • Caching com Redis: Estrategias de cache — veja Python e Redis

Perguntas sobre Dados e Machine Learning

26-30: Data Science e ML

Para vagas com foco em dados, prepare-se para estas perguntas:

  • Pandas vs Polars: Quando usar cada um para manipulacao de dados — Polars como alternativa ao Pandas
  • NumPy broadcasting: Como funciona e quando e eficiente
  • Pipelines de ML: Como estruturar um projeto de machine learning com scikit-learn
  • Feature engineering: Tecnicas de preparacao de dados para modelos
  • MLOps basico: Deploy de modelos com FastAPI, monitoramento de drift

Para mais sobre dados, veja nosso artigo de Python para ciencia de dados e introducao ao Pandas.

Dicas Praticas para o Dia da Entrevista

Antes da Entrevista

  1. Revise os fundamentos: Estruturas de dados, POO, decoradores, geradores
  2. Pratique coding: Resolva 2-3 problemas por dia em plataformas de exercicios
  3. Estude a empresa: Veja as tecnologias que usam e os projetos em que trabalham
  4. Prepare perguntas: Sobre stack, equipe, processos, cultura e crescimento

Durante a Entrevista

  • Pense em voz alta: Explique seu raciocinio enquanto resolve problemas
  • Comece simples: Resolva da forma mais direta primeiro, depois otimize
  • Trate edge cases: Mostre que pensa em inputs invalidos e situacoes limite
  • Admita o que nao sabe: Honestidade e melhor do que inventar respostas

Apos a Entrevista

  • Envie um email de agradecimento
  • Anote as perguntas que voce nao soube responder e estude-as
  • Nao pare de estudar enquanto espera feedback

Recursos de Estudo Recomendados

Para se preparar de forma completa, confira estes conteudos do Python Brasil:

Se voce esta em transicao de outra linguagem, confira nosso guia de transicao de carreira para Python para entender as diferencas mais importantes.

Considere tambem explorar linguagens complementares como Go para sistemas distribuidos ou Kotlin para desenvolvimento Android — ser poliglota e um diferencial em entrevistas senior.

Tags

carreira entrevista python perguntas tecnicas mercado de trabalho

Artigos Relacionados

Areas de Atuacao com Python: Onde Trabalhar em 2026

8 min de leitura

Primeiro Emprego como Programador Python: Guia Completo 2026

7 min de leitura

Trabalhar como Freelancer Python: Quanto Ganha e Como Comecar

7 min de leitura