---
title: "Perguntas de Entrevista Python: 30 Questoes Mais Cobradas"
url: "https://python.dev.br/carreira/entrevistas-python/"
markdown_url: "https://python.dev.br/carreira/entrevistas-python.MD"
description: "Prepare-se para entrevistas de Python com as 30 perguntas mais cobradas em 2026. Respostas detalhadas, exemplos de codigo e dicas de recrutadores brasileiros."
date: "2026-04-27"
author: "Equipe Python Brasil"
---

# Perguntas de Entrevista Python: 30 Questoes Mais Cobradas

Prepare-se para entrevistas de Python com as 30 perguntas mais cobradas em 2026. Respostas detalhadas, exemplos de codigo e dicas de recrutadores brasileiros.


## 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](/carreira/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](/glossario/lista/) sao mutaveis — voce pode adicionar, remover e alterar elementos apos a criacao. [Tuplas](/glossario/tupla/) sao imutaveis — uma vez criadas, nao podem ser modificadas.

```python
# 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](/glossario/list-comprehension/) sao uma forma concisa e pythonica de criar listas. Sao mais legiveise geralmente mais rapidas que loops tradicionais.

```python
# 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](/blog/compreensao-de-listas-python/) 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](/blog/tratamento-de-erros-python/).

```python
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).

```python
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.

```python
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](/glossario/decorators/) sao funcoes que modificam o comportamento de outras funcoes. Sao amplamente usados em frameworks como Django e FastAPI.

```python
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](/blog/decoradores-python-guia-pratico/).

### 7. Explique geradores e a palavra-chave yield

[Geradores](/glossario/generators/) sao funcoes que produzem valores sob demanda usando `yield`, economizando memoria ao nao carregar tudo de uma vez.

```python
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](/blog/geradores-iteradores-python/).

### 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.

```python
# 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)](/blog/python-3-13-free-threaded-sem-gil/) como recurso experimental. Veja tambem nosso guia de [multiprocessing](/blog/python-multiprocessing/).

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

```python
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](/blog/programacao-orientada-objetos-python/).

### 10. Como funciona o context manager (with)?

[Context managers](/glossario/context-manager/) garantem que recursos sejam liberados corretamente, mesmo em caso de erros.

```python
# 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](/blog/context-managers-python-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`.

```python
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__`.

```python
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](/glossario/async-await/) permite executar operacoes I/O-bound de forma concorrente sem threads.

```python
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](/blog/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.

```python
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__`.

```python
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](/comparacoes/fastapi-vs-django/) e [Django vs Flask](/comparacoes/django-vs-flask/).

### 21-25: Banco de Dados e Infra

- **SQL vs NoSQL**: Quando usar cada um — veja [PostgreSQL](/blog/python-e-postgresql/) e [MongoDB](/blog/python-e-mongodb/)
- **ORMs em Python**: [SQLAlchemy](/glossario/sqlalchemy/) e Django ORM — trade-offs
- **Docker e containers**: Como containerizar aplicacoes Python — [Python e Docker](/blog/python-e-docker/)
- **CI/CD**: Como configurar pipelines de testes e deploy automatizados
- **Caching com Redis**: Estrategias de cache — veja [Python e Redis](/blog/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](/blog/polars-alternativa-pandas-python/)
- **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](/blog/python-para-ciencia-de-dados/) e [introducao ao Pandas](/blog/introducao-ao-pandas/).

---

## Dicas Praticas para o Dia da Entrevista

### Antes da Entrevista

1. **Revise os fundamentos**: [Estruturas de dados](/blog/estruturas-de-dados-python/), 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:

- [Python para Iniciantes: Guia Completo](/blog/python-para-iniciantes-guia-completo/) — fundamentos essenciais
- [Boas Praticas Python 2026](/blog/boas-praticas-python-2026/) — codigo limpo e profissional
- [Teste Tecnico Python](/carreira/teste-tecnico-python/) — checklist para entregar cases reproduziveis em processos brasileiros
- [Design Patterns em Python](/blog/design-patterns-python/) — padroes de projeto cobrados em entrevistas
- [Tipagem Estatica com mypy](/blog/tipagem-estatica-python-mypy/) — type hints que impressionam
- [Salarios Python no Brasil](/carreira/salarios-python-brasil/) — saiba quanto pedir na negociacao

Se voce esta em transicao de outra linguagem, confira nosso guia de [transicao de carreira para Python](/carreira/transicao-para-python/) para entender as diferencas mais importantes.

Considere tambem explorar linguagens complementares como <a href="https://golang.com.br" target="_blank" rel="noopener" onclick="umami.track('portfolio-site-click', {destination: 'golang.com.br'})">Go</a> para sistemas distribuidos ou <a href="https://kotlin.dev.br" target="_blank" rel="noopener" onclick="umami.track('portfolio-site-click', {destination: 'kotlin.dev.br'})">Kotlin</a> para desenvolvimento Android — ser poliglota e um diferencial em entrevistas senior.
