⏱️5 min read · 888 words
As perguntas da entrevista sobre Python em 2026 cobrem tudo, desde sintaxe básica até padrões assíncronos avançados, estruturas de dados e design OOP. Esteja você se preparando para uma função de desenvolvedor júnior ou para uma posição sênior em uma empresa FAANG, este guia cobre as perguntas mais comuns das entrevistas sobre Python com respostas claras e concisas.
📋 Table of Contents
Perguntas básicas sobre Python
1. Qual é a diferença entre uma lista e uma tupla?
Listassão mutáveis – os elementos podem ser adicionados, removidos ou alterados.Tuplassão imutáveis – uma vez criados, eles não podem ser modificados.
# List — mutable
my_list = [1, 2, 3]
my_list.append(4) # OK
my_list[0] = 10 # OK
# Tuple — immutable
my_tuple = (1, 2, 3)
# my_tuple[0] = 10 # TypeError!
# Tuples are faster and use less memory
# Use tuples for heterogeneous data (coordinates, RGB)
# Use lists for homogeneous, modifiable sequences
# Named tuples — readable tuples
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(3, 4)
print(p.x, p.y) # 3 42. Explique o GIL (Global Interpreter Lock) do Python
O GIL é um mutex que permite que apenas um thread execute bytecode Python por vez, mesmo em sistemas multi-core. Isso significa que os threads Python não podem alcançar o verdadeiro paralelismo de CPU para o código Python.
- Threads liberam GIL durante operações de E/S (rede, disco) — portanto, threading funciona para tarefas vinculadas a E/S
- Para paralelismo vinculado à CPU, use
multiprocessing(cada processo tem seu próprio GIL) - Python 3.13+ possui modo experimental de thread livre (GIL pode ser desativado)
3. O que são decoradores? Dê um exemplo.
import functools, time
def timer(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
start = time.perf_counter()
result = func(*args, **kwargs)
elapsed = time.perf_counter() - start
print(f"{func.__name__}: {elapsed*1000:.2f}ms")
return result
return wrapper
@timer
def slow_function():
time.sleep(0.1)
return 42
slow_function() # "slow_function: 100.12ms" 4. Qual é a diferença entre *args e **kwargs?
def func(*args, **kwargs):
print(args) # tuple of positional arguments
print(kwargs) # dict of keyword arguments
func(1, 2, 3, name="Alice", age=30)
# (1, 2, 3)
# {'name': 'Alice', 'age': 30}
# Unpacking
def add(a, b, c): return a + b + c
numbers = [1, 2, 3]
print(add(*numbers)) # 6
settings = {"a": 1, "b": 2, "c": 3}
print(add(**settings)) # 65. O que é um gerador e quando você o usaria?
# Generator — lazy evaluation, memory efficient
def fibonacci():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
# vs list — loads everything into memory
fib = fibonacci()
print([next(fib) for _ in range(10)])
# Use generators when:
# 1. Processing large datasets (files, DB rows)
# 2. Infinite sequences
# 3. Building pipelinesPerguntas OOP
6. Qual é a diferença entre @classmethod e @staticmethod?
class Circle:
pi = 3.14159
def __init__(self, radius):
self.radius = radius
# Regular method — receives instance (self)
def area(self):
return self.pi * self.radius ** 2
# classmethod — receives class (cls), can access class variables
@classmethod
def from_diameter(cls, diameter):
return cls(diameter / 2) # factory method
# staticmethod — receives nothing, utility function
@staticmethod
def is_valid_radius(radius):
return radius > 0
c1 = Circle(5)
c2 = Circle.from_diameter(10)
print(Circle.is_valid_radius(-1)) # False7. Explique MRO (Ordem de Resolução de Método)
class A:
def method(self): return "A"
class B(A):
def method(self): return "B"
class C(A):
def method(self): return "C"
class D(B, C): # Multiple inheritance
pass
d = D()
print(d.method()) # "B" — follows MRO
print(D.__mro__) # (D, B, C, A, object)
# Python uses C3 linearization for MROPerguntas avançadas
8. Como funciona o gerenciamento de memória do Python?
- Contagem de referência— cada objeto rastreia quantas referências apontam para ele
- Quando a contagem chega a 0, o objeto é imediatamente liberado
- Coletor de lixo— lida com referências circulares (a contagem de referências não pode)
gc.collect()– acionar manualmente a coleta de lixo- Estagiário— inteiros pequenos (-5 a 256) e strings curtas são armazenados em cache
9. Qual é a diferença entre cópia superficial e cópia profunda?
import copy
original = [[1, 2, 3], [4, 5, 6]]
# Shallow copy — new list, but nested objects are shared
shallow = copy.copy(original) # or list(original) or original[:]
shallow[0].append(99)
print(original[0]) # [1, 2, 3, 99] — MODIFIED! (shared reference)
# Deep copy — completely independent copy
deep = copy.deepcopy(original)
deep[0].append(88)
print(original[0]) # [1, 2, 3] — unchanged10. Quais são as estruturas de dados integradas do Python e suas complexidades de tempo?
| Operação | lista | ditar | set | deque |
|---|---|---|---|---|
| Acesso | O(1) | O(1) média | N/A | Sobre) |
| Procurar | Sobre) | O(1) média | O(1) média | Sobre) |
| Inserir (final) | O(1) amortização | O(1) média | O(1) média | O(1) |
| Inserir (iniciar) | Sobre) | N/A | N/A | O(1) |
| Excluir | Sobre) | O(1) média | O(1) média | O(1) |
Perguntas assíncronas
11. Qual é a diferença entre asyncio.gather() e asyncio.TaskGroup?
import asyncio
# asyncio.gather — partial failures possible
async def example_gather():
results = await asyncio.gather(
task1(),
task2(),
return_exceptions=True # don't cancel others on failure
)
# Results include exceptions if return_exceptions=True
# asyncio.TaskGroup (Python 3.11+) — all-or-nothing
async def example_task_group():
async with asyncio.TaskGroup() as tg:
t1 = tg.create_task(task1())
t2 = tg.create_task(task2())
# If any task raises, all are cancelled — structured concurrency
asyncio.run(example_task_group())O sucesso da entrevista Python vem do entendimento profundo da linguagem, não apenas da memorização das respostas. Concentre-se no “porquê” de cada conceito – por que o GIL existe, por que os geradores são eficientes em termos de memória, por que a cópia profunda é importante. Explique as compensações e mostre a aplicação de cada conceito no mundo real.
🔗 Share this article
✍️ Leave a Comment