Codex Technomanticus

Capstone — simulado comentado PCEP + PCAP

Leitura de 23 min

Capstone — simulado comentado PCEP + PCAP

TL;DR

Esta é a última nota do Galho 19 (Certificação PCEP/PCAP) — e a última nota da trilha Python inteira, 19/19 galhos. O capstone é um simulado de 18 questões no estilo real da Python Institute — trecho curto de código, quatro alternativas, gabarito comentado em callout colapsável — distribuído proporcionalmente aos pesos oficiais do PCAP-31-03 (mais peso em Orientação a Objetos, 34% da prova) com uma amostra dos quatro blocos do PCEP-30-02 no início, e um bloco final dedicado só a armadilhas transversais. Cada questão linka de volta à nota-fonte exata do conceito — deste galho ou dos Galhos 1-6 do núcleo da linguagem. Depois do simulado, a nota fecha com uma recapitulação da jornada completa: seis galhos de núcleo da linguagem, dois de concorrência, cinco de backend e arquitetura, cinco de plataforma distribuída e produção, e este último de certificação — dezenove galhos que começaram em “o que é Python” e terminam aqui, numa prova de múltipla escolha que testa uma fração pequena, mas real, de tudo que foi construído no caminho.

Como usar este simulado

Resolva cada questão mentalmente antes de abrir o gabarito — a prova real não dá acesso a um interpretador, e o valor do exercício está exatamente em prever a saída (ou identificar a exceção, ou escolher a alternativa correta) sem rodar nada. As 18 questões estão organizadas em quatro blocos: um aquecimento de PCEP (4 questões, uma por bloco oficial), o corpo principal de PCAP na proporção dos pesos do syllabus (11 questões: Modules, Exceptions, Strings, OOP com peso extra, Miscellaneous), e um bloco final de armadilhas transversais (3 questões) que combina padrões de mais de um tópico ao mesmo tempo — exatamente como a prova real costuma fazer nas questões mais difíceis.

flowchart LR
    SIM["Simulado — 18 questões"] --> PCEP["Aquecimento PCEP<br/>4 questões<br/>1 por bloco"]
    SIM --> PCAP["Corpo PCAP<br/>11 questões<br/>peso proporcional"]
    SIM --> ARM["Armadilhas transversais<br/>3 questões<br/>combinam tópicos"]

    PCAP --> M["Modules 1"]
    PCAP --> E["Exceptions 1"]
    PCAP --> S["Strings 2"]
    PCAP --> O["OOP 5<br/>MAIOR PESO"]
    PCAP --> MI["Miscellaneous 2"]

    style SIM fill:#4A90D9,color:#fff
    style O fill:#D0021B,color:#fff
    style PCEP fill:#7ED321,color:#000
    style ARM fill:#F5A623,color:#000

A nota de corte real é 70% cumulativo — no PCAP-31-03, isso significa acertar pelo menos 28 de 40 itens (documentado na nota 01). Aplicando a mesma régua a este simulado de 18 questões: 13 acertos ou mais é o sinal de prontidão equivalente. Errar uma questão aqui não é motivo de alarme — é o roteiro exato de qual nota-fonte reabrir antes da prova real.

Bloco 1 — Aquecimento PCEP (4 questões, uma por bloco oficial)

Questão 1 (PCEP Bloco 1 — Fundamentals, 18%). O que este trecho imprime?

x = 9
y = 4
print(x / y)
print(x // y)
print(2 ** 10)

A) 2.25, 2, 1024 B) 2, 2.25, 1024 C) 2.25, 2.0, 1024 D) 2.25, 2, 100

Questão 2 (PCEP Bloco 2 — Control Flow, 29%, maior peso do PCEP). O que este trecho imprime?

for i in range(1, 10, 3):
    if i > 8:
        break
else:
    print("loop completo")
print(i)

A) loop completo seguido de 10 B) apenas 7 C) loop completo seguido de 7 D) nada é impresso, NameError

Questão 3 (PCEP Bloco 3 — Data Collections, 25%). O que este trecho imprime?

dados = ("a", "b", "c", "d", "e")
print(dados[1:4])
print(dados[-2:])
print(dados[::2])

A) ('b', 'c', 'd'), ('d', 'e'), ('a', 'c', 'e') B) ('a', 'b', 'c'), ('d', 'e'), ('a', 'c', 'e') C) ('b', 'c', 'd'), ('e',), ('a', 'c') D) ('b', 'c', 'd', 'e'), ('d', 'e'), ('a', 'c', 'e')

Questão 4 (PCEP Bloco 4 — Functions and Exceptions, 28%). Qual exceção, se alguma, este código levanta?

def dividir_lista(numeros, divisor):
    resultado = []
    for n in numeros:
        resultado.append(n / divisor)
    return resultado
 
print(dividir_lista([10, 20, 30], 0))

A) Nenhuma — imprime [inf, inf, inf] B) ZeroDivisionError C) TypeError D) ValueError

Bloco 2 — Corpo PCAP: Modules and Packages (12%)

Questão 5. Sabendo que utils.py contém apenas def dobrar(x): return x * 2, o que este trecho imprime?

from utils import dobrar
 
print(dobrar(21))
print(utils.dobrar(21))

A) 42 seguido de 42 B) 42 seguido de NameError C) NameError na primeira linha D) 42 seguido de AttributeError

Bloco 3 — Corpo PCAP: Exceptions (14%)

Questão 6. O que este código imprime?

def processa(valor):
    try:
        if valor < 0:
            raise ValueError("negativo")
        resultado = 100 / valor
    except ZeroDivisionError:
        return "erro: zero"
    except ValueError as e:
        return f"erro: {e}"
    else:
        return f"ok: {resultado}"
    finally:
        print("processamento finalizado")
 
print(processa(0))
print(processa(-5))
print(processa(10))

A) três linhas de "processamento finalizado", seguidas de erro: zero, erro: negativo, ok: 10.0 B) erro: zero, processamento finalizado, erro: negativo, processamento finalizado, ok: 10.0, processamento finalizado C) processamento finalizado, erro: zero, processamento finalizado, erro: negativo, processamento finalizado, ok: 10.0 D) erro: zero, erro: negativo, ok: 10.0, sem nenhum processamento finalizado

Bloco 4 — Corpo PCAP: Strings (18%)

Questão 7. O que este trecho imprime?

s = "Python Institute"
print(s.find("z"))
print(s.count("t"))
print(s[7:].lower().startswith("in"))

A) -1, 4, True B) -1, 2, True C) ValueError, 4, True D) -1, 4, False

Questão 8. O que estas três expressões devolvem, em ordem?

print("".isdigit())
print("3.14".isdigit())
print(ord("a") - ord("A"))

A) False, True, 32 B) True, False, 32 C) False, False, 32 D) False, False, 26

Bloco 5 — Corpo PCAP: Object-Oriented Programming (34%, maior peso — 5 questões)

Questão 9 (Encapsulamento / name mangling). O que este código imprime?

class Configuracao:
    def __init__(self):
        self.__valor = 42
 
class ConfiguracaoEstendida(Configuracao):
    def __init__(self):
        super().__init__()
        self.__valor = 100
 
    def mostrar_proprio(self):
        return self.__valor
 
c = ConfiguracaoEstendida()
print(c.mostrar_proprio())
print(c._Configuracao__valor)

A) 100, 100 B) 100, 42 C) 42, 100 D) AttributeError na primeira linha

Questão 10 (Herança múltipla / MRO). Qual é a MRO de Z?

class Base: pass
class Esquerda(Base): pass
class Direita(Base): pass
class Meio(Esquerda, Direita): pass
class Z(Meio, Base): pass

A) Z → Meio → Esquerda → Direita → Base → object B) Z → Base → Meio → Esquerda → Direita → object C) Z → Meio → Base → Esquerda → Direita → object D) Erro: TypeError: Cannot create a consistent MRO

Questão 11 (Atributos de instância vs. classe). O que este código imprime?

class Equipe:
    membros = []
 
    def __init__(self, nome):
        self.nome = nome
        self.membros = self.membros + [nome]
 
e1 = Equipe("Ana")
e2 = Equipe("Bia")
 
print(e1.membros)
print(e2.membros)
print(Equipe.membros)

A) ['Ana', 'Bia'], ['Ana', 'Bia'], ['Ana', 'Bia'] B) ['Ana'], ['Bia'], [] C) ['Ana'], ['Ana', 'Bia'], [] D) ['Ana'], ['Bia'], ['Ana', 'Bia']

Questão 12 (Polimorfismo via Data Model). O que este código imprime?

class Caixa:
    def __init__(self, itens):
        self._itens = itens
 
    def __len__(self):
        return len(self._itens)
 
    def __eq__(self, outra):
        return len(self) == len(outra)
 
c1 = Caixa([1, 2, 3])
c2 = Caixa(["a", "b", "c"])
c3 = Caixa([1, 2])
 
print(len(c1))
print(c1 == c2)
print(c1 == c3)

A) 3, True, False B) 3, False, False C) 3, True, True D) AttributeError na segunda linha

Questão 13 (Construtores e herança). Que exceção, se alguma, este código levanta?

class Veiculo:
    def __init__(self, rodas):
        self.rodas = rodas
 
class Carro(Veiculo):
    def __init__(self, rodas, portas):
        self.portas = portas
        super().__init__(rodas)
 
c = Carro(4, 2)
print(c.rodas, c.portas)

A) AttributeError: 'Carro' object has no attribute 'rodas' B) Nenhuma — imprime 4 2 C) TypeError: __init__() missing argument D) Nenhuma — imprime 2 4 (ordem trocada)

Bloco 6 — Corpo PCAP: Miscellaneous (22%)

Questão 14 (List comprehension). O que este código imprime?

matriz = [[1, 2, 3], [4, 5, 6]]
resultado = [linha[i] for linha in matriz for i in range(len(linha)) if linha[i] % 2 == 0]
print(resultado)

A) [2, 4, 6] B) [2, 6, 4] C) [4, 6, 2] D) [2, 4]

Questão 15 (Closures e late binding). O que este código imprime?

somadores = []
for i in range(3):
    somadores.append(lambda x, passo=i: x + passo)
 
print([f(10) for f in somadores])

A) [10, 10, 10] B) [10, 11, 12] C) [12, 12, 12] D) TypeError

Questão 16 (File I/O). Assumindo que log.txt não existe antes da execução, o que este código produz como conteúdo final do arquivo?

with open("log.txt", "a") as f:
    f.write("evento 1\n")
 
with open("log.txt", "a") as f:
    f.write("evento 2\n")
 
with open("log.txt", "w") as f:
    f.write("reiniciado\n")

A) evento 1\nevento 2\nreiniciado\n B) evento 1\nevento 2\n C) reiniciado\n D) FileNotFoundError, porque log.txt não existia antes do primeiro open()

Bloco 7 — Armadilhas transversais (3 questões, combinando tópicos)

Questão 17 (Mutação vs. reatribuição + escopo). O que este código imprime?

contador_global = {"total": 0}
 
def incrementar(contador, chave):
    valor_atual = contador.get(chave, 0)
    contador[chave] = valor_atual + 1
    contador = {"outro": 999}   # reatribuição LOCAL — não afeta o chamador
 
incrementar(contador_global, "total")
incrementar(contador_global, "total")
incrementar(contador_global, "novo")
print(contador_global)

A) {'outro': 999} B) {'total': 2, 'novo': 1} C) {'total': 0, 'novo': 0} D) {'total': 2}

Questão 18 (Identidade, precedência e verdade booleana — as três num só código). O que este código imprime?

a = 200
b = 200
resultado = (a is b) and (2 + 3 * 2 == 8) or bool([])
print(resultado)
 
c = 300
d = 300
print(c is d or c == d)

A) True, True B) False, True C) True, False D) False, False

Gabarito consolidado

QuestãoBlocoResposta
1PCEP FundamentalsA
2PCEP Control FlowC
3PCEP Data CollectionsA
4PCEP Functions/ExceptionsB
5PCAP ModulesB
6PCAP ExceptionsC
7PCAP StringsA
8PCAP StringsC
9PCAP OOPB
10PCAP OOPA
11PCAP OOPB
12PCAP OOPA
13PCAP OOPB
14PCAP MiscellaneousA
15PCAP MiscellaneousB
16PCAP MiscellaneousC
17Armadilha transversalB
18Armadilha transversalA

Como interpretar o resultado

13 acertos ou mais (72%) é o equivalente proporcional à nota de corte real de 70% cumulativo. Se o bloco 5 (OOP, questões 9-13) concentrou a maioria dos erros, isso não é coincidência de sorte — é o bloco de maior peso e maior complexidade da prova real também; volte à nota 04 antes de mais uma tentativa. Se os erros se espalharam por vários blocos sem padrão, revisar o catálogo de armadilhas da nota 06 tende a render mais que reler qualquer bloco isolado.

Fechando o Galho 19 — e a trilha Python inteira

Chegar até aqui significa ter percorrido as oito notas deste galho — mas também significa ter terminado os dezenove galhos da trilha Python deste vault, do primeiro print("Hello, World") implícito no Galho 1 até este simulado de certificação. Vale nomear essa jornada por completo antes de fechar, porque é fácil, numa trilha tão longa, perder de vista o tamanho real do que foi construído.

flowchart TB
    subgraph NUCLEO["Núcleo da linguagem — Galhos 1-6"]
        G1["1. Core<br/>sintaxe, tipos, controle de fluxo"]
        G2["2. Collections e Comprehensions"]
        G3["3. OO e Data Model"]
        G4["4. Funcional e idiomas avançados"]
        G5["5. Tipagem moderna"]
        G6["6. CPython internals"]
    end

    subgraph CONC["Concorrência — Galhos 7-8"]
        G7["7. Concorrência e paralelismo"]
        G8["8. Programação Reativa e Assíncrona"]
    end

    subgraph BACK["Backend e arquitetura — Galhos 9-13"]
        G9["9. Persistência de dados"]
        G10["10. Web e APIs REST"]
        G11["11. Segurança"]
        G12["12. Testes"]
        G13["13. Arquitetura e Design Patterns"]
    end

    subgraph PROD["Plataforma distribuída e produção — Galhos 14-18"]
        G14["14. Mensageria"]
        G15["15. Microservices"]
        G16["16. Build e tooling"]
        G17["17. Observabilidade e produção"]
        G18["18. Cloud-native e produção"]
    end

    subgraph CERT["Certificação — Galho 19"]
        G19["19. PCEP/PCAP<br/>ESTE CAPSTONE"]
    end

    NUCLEO --> CONC --> BACK --> PROD --> CERT

    style NUCLEO fill:#4A90D9,color:#fff
    style CONC fill:#7ED321,color:#000
    style BACK fill:#F5A623,color:#000
    style PROD fill:#9013FE,color:#fff
    style CERT fill:#D0021B,color:#fff
    style G19 fill:#D0021B,color:#fff

A jornada, em cinco frases: os Galhos 1-6 construíram o núcleo da linguagem — do if/for mais básico até os internals do CPython (GIL, GC geracional, ceval loop), passando por OO completa, idiomas funcionais (generators, closures, decorators) e tipagem moderna com generics. Os Galhos 7-8 resolveram concorrência e execução assíncrona — threading, multiprocessing, e o mergulho fundo em asyncio/ASGI que a maioria dos devs Python nunca faz por completo. Os Galhos 9-13 viraram a chave para backend e arquitetura — persistência, APIs REST, segurança, testes, e os padrões de design (Repository, Unit of Work, hexagonal) que separam scripts de sistemas. Os Galhos 14-18 elevaram tudo isso a plataforma distribuída e produção — mensageria, microservices, tooling de build, observabilidade e Kubernetes/serverless. E este Galho 19 fecha com certificação: não conteúdo novo, mas a conversão formal de tudo isso — 18 galhos de aprendizado real — num selo verificável por terceiros, com a honestidade documentada logo na primeira nota deste galho de que PCAP-31-03 testa uma fração conservadora do que a trilha inteira ensinou.

Vocabulário PT/EN

Termo PTTermo EN
simuladopractice exam / mock test
gabarito comentadoannotated answer key
questão de múltipla escolhamultiple-choice question
alternativaoption / choice
nota de cortepassing score
distribuição de pesoweight distribution
capítulo de fechamentocapstone
trilha completacomplete track
credencial formalformal credential
legibilidade externaexternal legibility (of skill)

Em entrevista

Se a pergunta em entrevista técnica for algo como “como você valida seu conhecimento de Python”, a resposta mais forte depois de completar este galho e esta trilha não é listar dezenove nomes de galho — é uma frase curta que sinaliza profundidade real com prova formal por trás: “tenho PCAP-31-03 da Python Institute, cobrindo módulos, exceções, strings e OO completa com 70% de corte — mas o estudo de fato foi mais profundo que a prova: cobri concorrência com asyncio, arquitetura hexagonal, mensageria, e deploy em Kubernetes/serverless. A certificação valida o núcleo formal; o resto eu demonstro com código”. Essa resposta nomeia o que a credencial prova e o que ela não chega perto de provar — a mesma honestidade que abriu este galho na nota 01.

How to explain in English

“I closed out a nineteen-branch Python track with the Python Institute’s PCAP-31-03 certification — not as a starting point, but as the formal capstone on top of material that already went well past the exam’s syllabus: core language internals, async concurrency, backend architecture, distributed messaging, and Kubernetes/serverless deployment. The exam itself is a 40-item, multiple-choice test at a 70% cumulative passing score, weighted heavily toward object-oriented programming (34% of the exam). I built a full mock exam covering all five official blocks, proportional to their real weights, plus a batch of cross-cutting gotcha questions — the kind that combine two or three concepts in a single short code snippet, which is exactly how the hardest real exam items are constructed. The honest framing throughout: the certification is portable, third-party-verifiable proof of a conservative slice of the language — not a ceiling on what was actually learned.”

Fontes

Consultado em 2026-07-12. Esta é a última nota da trilha Python — Galho 19/19, nota 8/8.

Visão de gráfico

Backlinks