PCAP: Prüfungsaufbau, häufigste Fallen und Weg zu PCPP1

Track Python · PCAP-Prüfungsvorbereitung · ca. 60 Min.

Worum es geht

Du kannst Python inzwischen lesen und schreiben. Für die PCAP (Certified Associate in Python Programming) reicht das nicht ganz: Die Prüfung stellt Fragen, die absichtlich auf bekannte Stolperstellen zielen. Diese Lektion fasst den Prüfungsaufbau zusammen, gibt dir eine Zeitstrategie und lässt dich die 18 häufigsten Fallen aus dem Glossar selbst vorhersagen. Am Ende weißt du auch, wie die Zertifikate PCAP, PCPP1 und PCPP2 zusammenhängen und was PCPP1 neu verlangt.

Ablauf: erst die Prüfungsdaten, dann die 18 Fallen im Überblick, dann sechs Übungen. Fünf davon sind Code-Vorhersagen (der Check führt den Code selbst aus), eine ist eine Strategiefrage.

Die wirksamste Methode laut Quelle: Code erst vorhersagen, dann ausführen. Falsche Vorhersagen schreibst du mit einem Satz Erklärung in eine Fehlerliste und wiederholst sie nach einer Woche.

Von JS/TS her gedacht

Viele Fallen sind für dich nur deshalb Fallen, weil JS/TS anders reagiert:

Falle	JS/TS-Erwartung	Python
Default-Wert l=[]	wird bei jedem Aufruf neu ausgewertet	wird einmal beim def erzeugt
Closure in der Schleife	let i gibt jedem Durchlauf einen eigenen Wert	Lambdas teilen sich eine Variable i
sort()	arr.sort() gibt das Array zurück	gibt None zurück
-2 ** 2	Syntaxfehler (unäres Minus vor ** verboten)	-4
Math.round(2.5)	3	round(2.5) ist 2 (zur geraden Zahl)
"10" < "9"	true (String-Vergleich)	True, ebenfalls zeichenweise
[[0]*3]*3	gibt es so nicht	drei Verweise auf eine innere Liste
arr[99]	undefined	IndexError (aber ein Slice [1:99] ist still)
"abc".indexOf("z")	-1	find gibt -1, index wirft ValueError

Konzept in kleinen Schritten

Schritt 1: Prüfungsaufbau und Gewichte

Die Zahlen stammen laut Glossar aus dem offiziellen PCAP-Syllabus und der PCAP-Seite (Stand der Abfrage dort: 1. Oktober 2026), Version PCAP-31-03:

Block	Thema	Fragen	Gewicht
1	Module und Pakete	6	12 %
2	Exceptions	5	14 %
3	Strings	8	18 %
4	OOP	12	34 %
5	Sonstiges (Comprehensions, Lambdas, Closures, Datei-I/O, bytearray)	9	22 %

OOP, Strings und Sonstiges ergeben zusammen 74 %. Dort investierst du die meiste Zeit.

Punkt	Angabe laut Glossar
Dauer	65 Minuten, dazu 10 Minuten für Geheimhaltungserklärung und Tutorial
Fragen	40 (Einfachauswahl, Mehrfachauswahl, Codeaufgaben, Szenarien, interaktive Aufgaben)
Bestehen	mindestens 70 % im Durchschnitt über alle Blöcke
Kosten	ab 295 USD (mit Wiederholung ab 345, mit Wiederholung und Übungstest ab 359, Übungstest einzeln 49)
Ablegen	Pearson VUE (Testcenter oder OnVUE von zu Hause) oder TestNow (OpenEDG)
Wiederholung	frühestens nach 15 Tagen
Vorbereitung	kostenloser Kurs “Python Essentials 2”

Zwei Warnungen aus dem Glossar: Eine neue Version PCAP-31-04 war für das dritte Quartal 2026 angekündigt, also vor dem Buchen auf der PCAP-Seite nachsehen, welche Version geprüft wird. Und zur Gültigkeit der Zertifikate widersprechen sich die Quellen (offiziell 5 Jahre, ein Drittanbieter nennt für neue Versionen 7 Jahre), auch das vorher prüfen.

Schritt 2: Prüfungsstrategie

• Zeit pro Frage: 65 Minuten für 40 Fragen sind rechnerisch gut 1,6 Minuten pro Frage (eigene Rechnung: 65 / 40). Codefragen mit Fallen brauchen mehr, einfache Begriffsfragen weniger. Plane Zeit zum Zurückkehren ein (ob die Prüfungsoberfläche markierte Fragen zulässt: bitte prüfen, steht nicht im Glossar).
• Code mental ausführen: Lies zuerst, was am Ende ausgegeben oder zurückgegeben wird, dann den Code von oben nach unten. Genau das übst du hier.
• Gewichten: 74 % der Punkte liegen in OOP, Strings und Sonstigem. Ein schwacher Block mit 12 % kostet weniger als ein schwacher OOP-Block.
• Bestehen heißt 70 % im Durchschnitt: Du darfst Blöcke verlieren, solange der Schnitt stimmt.
• Wann buchen: Laut Lernplan erst, wenn du in Probetests konstant über 85 % liegst. Einen Übungstest gibt es beim Python Institute als Zusatz für 49 USD einzeln.

Der sechswöchige Lernplan aus dem Glossar (Annahme: etwa 5 Stunden pro Woche):

Woche	Fokus
1	JS-zu-Python-Übersetzung, Syntax, Datentypen, Funktionen (Fallen 1, 3, 7, 8, 10 selbst ausprobieren)
2	Strings, Module, Pakete, math, random, platform (eigenes Paket mit __init__.py bauen)
3	OOP: Klassen, Vererbung, super(), MRO, Introspektion, Name Mangling
4	Exceptions, Comprehensions, Lambdas, Closures, Generatoren (eigene Exception-Hierarchie, drei Generatoren, ein Dekorator)
5	Datei-I/O, bytearray, errno, Gesamtwiederholung
6	Übungstests und Schwächen schließen

Schritt 3: Die 18 häufigsten Fallen

Die Liste stammt aus dem Glossar, die Kurzbeispiele darunter sind mit Python ausgeführt.

Nr.	Falle	Merkhilfe
1	Veränderbarer Default-Wert	def f(x, l=[]) teilt die Liste über alle Aufrufe
2	Closure in der Schleife	[lambda: i for i in range(3)] liefert dreimal denselben Wert
3	sort() liefert None	x = lst.sort() setzt x auf None
4	super().__init__() vergessen	Attribute der Basisklasse fehlen
5	Klassenvariable mit veränderbarem Wert	wird von allen Instanzen geteilt
6	Generator erschöpft	ein zweiter Durchlauf liefert nichts
7	Rangfolge bei **	-2 ** 2 ist -4, 2 ** 3 ** 2 ist 512
8	round	round(2.5) ist 2 (zur geraden Zahl)
9	is statt ==	is prüft Identität, nicht Gleichheit
10	Alias statt Kopie	b = a und [[0] * 3] * 3 teilen sich Objekte
11	finally mit return	überschreibt den Rückgabewert des try
12	Reihenfolge der except-Blöcke	der erste passende gewinnt
13	Slicing vs. Index	Slice außerhalb ist still, Index wirft IndexError
14	find vs. index	find liefert -1, index wirft ValueError
15	Strings vergleichen	"10" < "9" ist True, "a" > "B" ist True
16	bool("False")	ist True, nichtleere Strings sind wahr
17	writelines / readline	writelines fügt keine Umbrüche ein, readline behält sie
18	Name Mangling	__x wird zu _Klasse__x

Einige Beispiele mit anderen Werten als in den Übungen:

Bei Fall 15: Großbuchstaben haben kleinere Zeichencodes als Kleinbuchstaben, deshalb ist "b" > "A" wahr.

Schritt 4: Der Weg über die PCAP hinaus

Über der PCAP liegen die Professional-Stufen PCPP1 und PCPP2 des Python Institute. Angaben laut Glossar (Stand 1. Oktober 2026):

Zertifikat	Stufe	Prüfung	Status	Fragen	Preis ab (USD)
PCEP	Einstieg	PCEP-30-0x	aktiv	siehe PCEP-Seite	siehe PCEP-Seite
PCAP	Associate	PCAP-31-03 (31-04 angekündigt)	aktiv	40	295
PCPP1	Professional 1	PCPP-32-101 (32-102 in Entwicklung)	32-101 aktiv	45	325
PCPP2	Professional 2	PCPP-32-201	in Entwicklung	45	295 (geplant)

• PCAP, PCPP1 und PCPP2 dauern laut den Seiten 65 Minuten und sind mit 70 % bestanden.
• Formale Voraussetzungen gibt es keine, empfohlen wird jeweils die Stufe darunter.
• Drittanbieter nennen teils andere Preise (z. B. 195 USD für PCPP1). Maßgeblich ist der offizielle Voucher-Store.
• PCPP2 war am 1. Oktober 2026 noch “in Entwicklung” und ist damit vermutlich noch nicht ablegbar.
• Gültigkeit: PCPP-32-101 gilt lebenslang. Für PCPP-32-102 und PCPP2 nennt die offizielle Seite 5 Jahre.

Weitere Spezialzertifikate laut Glossar: Data Science (PCED, PCAD), Testing (PCET, PCAT), Security (PCES), Automation (PCEA), Künstliche Intelligenz (PCEI).

Schritt 5: Was PCPP1 neu verlangt

PCPP1 (Exam PCPP-32-101) hat 45 Fragen in fünf Blöcken, 65 Minuten (plus 10 Minuten Tutorial), 70 % zum Bestehen. Das sind etwa 1,4 Minuten pro Frage. Kosten laut offizieller Seite ab 325 USD, nur Einzelvoucher ohne Wiederholungsoption. Einen offiziellen Übungstest gibt es laut Seite nicht, du testest dich selbst.

Block	Thema	Fragen	Gewicht
1	Fortgeschrittene OOP	15	35 %
2	Coding-Konventionen, Best Practices, Standardisierung	7	12 %
3	GUI-Programmierung	8	20 %
4	Netzwerkprogrammierung	8	18 %
5	Dateiverarbeitung und Umgebung	7	15 %

Gegenüber der PCAP gilt: Tiefe statt Breite. Die OOP-Themen kehren wieder, aber mit Dekoratoren, Spezialmethoden, abstrakten Klassen, Serialisierung und Metaklassen. Neue Bibliotheken: tkinter, socket, json, xml, sqlite3, csv, logging, configparser, copy, pickle, shelve und das Drittpaket requests. Kostenlose Kurse: “Python Advanced 1 bis 5” auf edube.org, ein Kurs pro Block. GUI und Netzwerk zusammen sind 38 % der PCPP1.

Was PCPP2 abdecken soll (laut Glossar): Tests (unittest, pytest), Entwurfsmuster (Singleton, Factory, Facade, Proxy, Observer, Command, Template Method, State), Parallelität (Multiprocessing, Threading, Subprozesse, Synchronisation), Netzwerk, Datenbanken (SQL, NoSQL, ORM), Clean Code und Optimierung.

Einordnung aus dem Glossar: Zertifikate belegen Wissen, sie ersetzen keine Projekterfahrung. Für Entwickler mit Berufserfahrung zählt gebauter Code meist mehr als eine Prüfung. Die PCAP ist sinnvoll, wenn du Python systematisch lernen und einen Nachweis haben willst. PCPP1 lohnt sich vor allem, wenn du Python beruflich tief einsetzen willst.

Falle: die Fallen selbst

Die größte Falle beim Üben ist Wiedererkennen statt Nachdenken. Wer “Default-Liste, ah, das kenne ich” denkt, rechnet nicht mehr durch. In der Prüfung sind die Fallen verpackt: ein Default in einer Methode, eine Klassenvariable in einer Vererbungskette, ein finally in einer Schleife. Rechne jeden Schritt, auch wenn du die Falle erkennst.

Übungen

Übung 1: Funktionen und Generatoren (Fallen 1, 2, 6)

Fallen 1, 2 und 6 in einem Stück. Der Code steht fest. Trage das Tupel (a, b, c, d) ein.

def sammle(x, l=[]):
    l.append(x)
    return l

sammle(1)
sammle(2)
a = sammle(3)

funcs = [lambda: i for i in range(3)]
b = [f() for f in funcs]

gen = (n * n for n in range(4))
c = list(gen)
d = list(gen)

Frage dich bei a: Wie oft wird der Default-Wert erzeugt, und wer hält danach eine Referenz darauf? Bei b: Wann wird i in den Lambdas nachgeschlagen, beim Erzeugen oder beim Aufruf? Bei d: Was ist mit dem Generator nach dem ersten list(gen) passiert?

antwort = ([1, 2, 3], [2, 2, 2], [0, 1, 4, 9], [])
antwort

Übung 2: Ausdrücke (Fallen 3, 7, 8, 15, 16)

Fallen 3, 7, 8, 15 und 16. Dieser Code läuft zuerst:

zahlen = [3, 1, 2]
x = zahlen.sort()

Danach trägst du das Tupel (x, zahlen, -2 ** 2, 2 ** 3 ** 2, round(2.5), round(3.5), "10" < "9", bool("False")) ein. Die letzten sechs Werte sind Ausdrücke, die du im Kopf auswertest.

Was liefert eine Methode, die eine Liste an Ort und Stelle verändert? Bei **: Bindet es stärker als das unäre Minus, und in welche Richtung wird gruppiert? Bei round: Auf welche Seite fällt genau die Hälfte? Strings werden Zeichen für Zeichen verglichen, nicht als Zahlen.

antwort = (None, [1, 2, 3], -4, 512, 2, 4, True, True)
antwort

Übung 3: Identität, Kopien, Indizes (Fallen 9, 10, 13, 14)

Fallen 9, 10, 13 und 14. Trage das Tupel ((x == y, x is y), a, c, raster, teil, fehler_index, fehler_index_methode, fund) ein. Exception-Namen als String, z. B. "KeyError".

x = [1, 2]
y = [1, 2]

a = [1, 2]
b = a
c = a[:]
b.append(3)

raster = [[0] * 2] * 2
raster[0][0] = 1

text = "abc"
teil = text[1:99]
try:
    text[99]
    fehler_index = None
except Exception as e:
    fehler_index = type(e).__name__
try:
    text.index("z")
    fehler_index_methode = None
except Exception as e:
    fehler_index_methode = type(e).__name__
fund = text.find("z")

Gleichheit und Identität sind zwei Fragen. Bei b = a entsteht kein neues Objekt. Bei [[0] * 2] * 2: Wie viele innere Listen gibt es wirklich? Ein Slice ist nachsichtig, ein einzelner Index nicht. Und find und index unterscheiden sich im Verhalten bei Misserfolg.

antwort = ((True, False), [1, 2, 3], [1, 2], [[1, 0], [1, 0]], "bc", "IndexError", "ValueError", -1)
antwort

Übung 4: OOP (Fallen 4, 5, 18)

Fallen 4, 5 und 18. Trage das Tupel (hasattr(k, "name"), Basis.tags, sorted(vars(k2)), hasattr(k2, "__id"), k2._Basis__id) ein.

class Basis:
    tags = []
    def __init__(self, name):
        self.name = name
        self.__id = 7

class Kind(Basis):
    def __init__(self, name):
        self.extra = True

class Kind2(Basis):
    def __init__(self, name):
        super().__init__(name)
        self.tags.append(name)

k = Kind("a")
k2 = Kind2("b")
k3 = Kind2("c")

Wer ruft Basis.__init__ für k auf? Wem gehört tags, und wer hängt etwas an? Unter welchem Namen steht self.__id wirklich im __dict__, und wie kommt man ohne Umweg an ihn heran?

antwort = (False, ['b', 'c'], ['_Basis__id', 'name'], False, 7)
antwort

Übung 5: Kontrollfluss und Datei-I/O (Fallen 11, 12, 17)

Fallen 11, 12 und 17. Trage das Tupel (f(), g(), h(), inhalt, zeile) ein. Zeilenumbrüche schreibst du als \n im String.

import io

def f():
    try:
        return "try"
    finally:
        return "finally"

def g():
    try:
        raise KeyError("k")
    except LookupError:
        return "lookup"
    except KeyError:
        return "key"

def h():
    x = 1
    try:
        return x
    finally:
        x = 2

puffer = io.StringIO()
puffer.writelines(["a", "b"])
puffer.writelines(["c\n", "d\n"])
inhalt = puffer.getvalue()
puffer.seek(0)
zeile = puffer.readline()

(io.StringIO verhält sich bei writelines und readline wie eine echte Textdatei.)

Bei f: Welches return hat das letzte Wort? Bei g: KeyError ist ein Spezialfall von LookupError, aber welcher except-Block wird zuerst geprüft? Bei h: Wann wird der Rückgabewert festgelegt, und ändert eine spätere Zuweisung ihn noch? Bei writelines: Wer fügt Zeilenumbrüche ein?

antwort = ('finally', 'lookup', 1, 'abc\nd\n', 'abc\n')
antwort

Übung 6: Prüfungsstrategie

Du planst deine PCAP-Vorbereitung. Welche Aussage passt zu den Angaben aus dem Glossar? Gib den Buchstaben als String zurück, z. B. "A".

• A: Block 1 (Module und Pakete) ist der größte Block, also zuerst und am längsten lernen.
• B: Bei 70 % im ersten Übungstest ist die Prüfung sicher, sofort Termin buchen.
• C: OOP, Strings und Sonstiges bringen 74 % der Punkte, dort die meiste Zeit einplanen.
• D: Die Version PCAP-31-04 gilt sicher, daher ohne Nachsehen auf der Seite buchen.

Rechne die Gewichte der Blöcke nach, vergleiche die Bestehensgrenze mit der Empfehlung im Lernplan und lies nach, was zur aktuellen Version steht.

antwort = "C"
antwort

Merksatz und Prüfstein

Merksatz: Die meisten PCAP-Fallen drehen sich um geteilte Objekte (Defaults, Klassenvariablen, Aliase), um verzögerte Auswertung (Closures, Generatoren) und um stille Rückgabewerte (None, -1, leerer Slice). Also: nachrechnen, nicht erinnern.

Prüfstein (offene Frage): Wähle drei der 18 Fallen und erkläre jeweils in einem Satz, welches Python-Laufzeitverhalten (Zeitpunkt der Auswertung, Identität, Rückgabewert) dahintersteckt. Welche zwei Blöcke der PCAP bekommen in deinem Lernplan die meiste Zeit und warum?

Quelle: quellen/python-glossar-pcap-pcpp1.md, Abschnitte “Prüfungsaufbau, Fallen und Lernplan”, “Höhere Zertifikate” und “Teil 2: PCPP1 Überblick”. Offen (bitte prüfen): ob die Prüfungsoberfläche das Markieren von Fragen zum späteren Zurückkehren erlaubt (nicht in der Quelle). Die Rechnung “gut 1,6 Minuten pro Frage” ist eine eigene Rechnung aus den Quellzahlen. Die Aussagen zu Preisen, Versionen und Gültigkeit geben den Stand der Quelle vom 1. Oktober 2026 wieder und sind vor dem Buchen auf den offiziellen Seiten zu prüfen. Die Vergleichsspalte JS/TS in der Tabelle (z. B. Math.round(2.5) ergibt 3, -2 ** 2 ist in JS ein Syntaxfehler) stammt nicht aus der Quelle (bitte prüfen).