Python Institute PCAP-31-03 Cheat Sheet

May 1, 2026

Review a compact PCAP-31-03 cheat sheet for modules, exceptions, strings, object-oriented programming, comprehensions, lambdas, closures, and file handling before IT Mastery practice.

On this page

Use this cheat sheet before a PCAP-31-03 practice set. The exam moves beyond syntax recall into runtime behavior: imports, exceptions, strings, objects, comprehensions, closures, and files must be traced precisely.

Open PCAP practice when you are ready for the free diagnostic, topic drills, timed mocks, and the full IT Mastery question bank.

Open PCAP practice Try the free diagnostic

Exam snapshot

Item	PCAP cue
Vendor	Python Institute / OpenEDG
Certification	Certified Associate Python Programmer
Exam code / family	PCAP-31-03 / PCAP-31-0x
Main practice behavior	intermediate Python code tracing and object-model reasoning
IT Mastery status	live practice available

Domain checklist

Domain	Weight	What to know	Common trap
Modules and Packages	12%	imports, aliases, module execution, namespace behavior, packages	assuming imported names always land in the same namespace
Exceptions	14%	`try`, `except`, `else`, `finally`, custom exceptions, propagation	catching the wrong exception path
Strings	18%	indexing, slicing, immutability, methods, formatting, parsing	assuming a string method changes the original string
Object-Oriented Programming	34%	classes, instances, inheritance, methods, attributes, overriding, encapsulation	mixing class attributes, instance attributes, and method dispatch
Miscellaneous Python behavior	22%	comprehensions, lambdas, closures, generators, file I/O, context managers	tracing only the expression and missing the surrounding scope or file state

Must-know distinctions

Class attribute versus instance attribute: lookup and mutation can affect different objects.
Overloading versus overriding: Python does not use Java-style overload resolution.
Exception caught versus exception propagated: handler order and exception type matter.
finally behavior versus normal return flow: cleanup logic can still execute.
Module object versus imported name: import x and from x import y create different references.
Comprehension scope versus enclosing scope: do not assume every loop variable leaks.
File object open state versus file contents: context managers affect resource handling, not file data by themselves.

Common traps

Choosing an answer from expected style instead of actual runtime behavior.
Ignoring method resolution and attribute lookup order in class questions.
Forgetting that strings are immutable even when methods return modified strings.
Treating lambdas, closures, and comprehensions as syntax trivia instead of scope questions.
Missing whether a file operation reads, writes, appends, or closes.

Practice strategy

Use the free diagnostic once, then classify misses by runtime rule: namespace, exception path, string operation, object model, or file/comprehension behavior. For OOP misses, draw the class and instance attributes before repeating mixed sets.

Revised on Monday, May 25, 2026

Free Practice Exam