PCAP-31-03 — Python Institute PCAP - Certified Associate Python Programmer Cheat Sheet

This page is IT Mastery exam-prep support. It is not affiliated with Python Institute and does not replace the official exam syllabus or policies. Always verify registration rules, exam format, and current requirements with the official provider.

1. Scan the tables first. They summarize the rules most likely to cause mistakes.
2. Mark weak areas. Do not reread everything equally; target the rules you cannot explain quickly.
3. Practice output prediction. Many Python exam questions reward exact reasoning about values, types, scope, mutation, and control flow.
4. Use original practice questions immediately after review. The fastest improvement usually comes from topic drills with detailed explanations, not passive reading.
5. Revisit mistakes by category. Track whether you missed syntax, object behavior, mutability, inheritance, exceptions, or standard-library behavior.

print(bool("0"))     # True
print(bool([]))      # False
print(True + True)   # 2

Operators most likely to matter

print(2 ** 3 ** 2)   # 512, because 2 ** (3 ** 2)
print(-7 // 3)       # -3
print(-7 % 3)        # 2
print("x" or 5)      # x
print("" or 5)       # 5

Operator precedence checkpoints

print(1 < 2 < 3)       # True
print(1 < 2 > 3)       # False
print(not 1 == 1)      # False, parsed as not (1 == 1)

Arithmetic and comparison rules

Boolean logic and truthiness

Important rules:

• and and or short-circuit.
• and returns the first falsy operand or the last operand.
• or returns the first truthy operand or the last operand.
• not returns a Boolean value.
• Chained comparisons such as a < b < c are valid and do not mean (a < b) < c.

Operator precedence review

High-level order to remember:

1. Parentheses and indexing/calls
2. Exponentiation
3. Unary +, -, not where applicable
4. Multiplication, division, floor division, modulo
5. Addition and subtraction
6. Comparisons and membership/identity tests
7. Boolean and
8. Boolean or

When in doubt, add parentheses mentally and test with small values in practice questions.

for x in [1, 2, 3]:
    if x == 4:
        break
else:
    print("not found")     # prints

range() behavior

Key rules:

• Stop value is excluded.
• Step cannot be zero.
• range is iterable and lazy-like; convert to list() only if needed.

if, elif, and else

Common trap: if x == 1 or 2: is almost always wrong because 2 is truthy. Use if x == 1 or x == 2: or if x in (1, 2):.

Loops

Loop else decision rule

Use this rule:

• If the loop finishes normally, the else block runs.
• If the loop exits by break, the else block does not run.
• continue does not prevent the loop else from running.

This is frequently misunderstood because loop else does not mean “the loop condition was false in the same way as an if statement.”

Mutability and aliasing

a = [1, 2]
b = a
b.append(3)
print(a)        # [1, 2, 3]

c = a[:]
c.append(4)
print(a)        # [1, 2, 3]
print(c)        # [1, 2, 3, 4]

Trap: shallow copies still share nested mutable objects.

x = [[1], [2]]
y = x[:]
y[0].append(99)
print(x)        # [[1, 99], [2]]

nums = [3, 1, 2]
print(nums.sort())    # None
print(nums)           # [1, 2, 3]

Slicing reference

s = [0, 1, 2, 3, 4]
print(s[1:4])     # [1, 2, 3]
print(s[-1])      # 4
print(s[::-1])    # [4, 3, 2, 1, 0]

List comprehension pattern

squares = [x * x for x in range(5)]
evens = [x for x in range(10) if x % 2 == 0]
pairs = [(x, y) for x in [1, 2] for y in [3, 4]]

Evaluation order for nested comprehension:

result = []
for x in [1, 2]:
    for y in [3, 4]:
        result.append((x, y))

Lists

Lists are ordered, mutable sequences.

List slicing traps

Remember: slicing tolerates out-of-range bounds more gracefully than direct indexing.

Tuples

Tuples are ordered and immutable, but they can contain mutable objects.

Trap: tuple immutability means the tuple’s references cannot be changed, but a mutable object inside a tuple may still be mutated.

d = {"a": 1, "b": 2}
print("a" in d)        # True
print(1 in d)          # False

Dictionary traps

d = {"x": 1, "x": 2}
print(d)        # {'x': 2}

Dictionaries

Dictionaries store key-value pairs and preserve insertion order in modern Python versions.

Dictionary traps:

• Keys must be hashable.
• Lists cannot be dictionary keys.
• Tuples can be keys only if all their elements are hashable.
• in checks keys by default.
• Updating an existing key does not create a duplicate key.

Sets

Sets are unordered collections of unique hashable elements.

Trap: {} creates an empty dictionary, not an empty set. Use set() for an empty set.

s = "Python"
print(s[0])       # P
print(s[-1])      # n
print(s[1:4])     # yth

High-yield string methods

print("www.example.com".strip("w.com"))  # example
print("a,b,c".split(","))                # ['a', 'b', 'c']
print("-".join(["a", "b", "c"]))         # a-b-c

Character codes

print(ord("A"))    # 65
print(chr(65))     # A
print("A" < "a")   # True

Strings

Strings are immutable sequences of characters.

String method review

String formatting basics

Know the difference between:

• Concatenation with +
• Conversion with str()
• Format strings and placeholders
• f-string expression evaluation

Common trap: join() is called on the separator, not on the list. The pattern is ", ".join(items).

def f(a, b=2, *args, **kwargs):
    print(a, b, args, kwargs)

f(1, 3, 4, 5, x=9)    # 1 3 (4, 5) {'x': 9}

Argument passing

Python uses object references. Mutating a passed mutable object affects the caller’s object; rebinding the local name does not.

def change(a, b):
    a.append(3)
    b = [9]

x = [1, 2]
y = [4]
change(x, y)
print(x)     # [1, 2, 3]
print(y)     # [4]

Mutable default argument trap

def add_item(x, bucket=[]):
    bucket.append(x)
    return bucket

print(add_item(1))    # [1]
print(add_item(2))    # [1, 2]

Safer pattern:

def add_item(x, bucket=None):
    if bucket is None:
        bucket = []
    bucket.append(x)
    return bucket

Scope: LEGB

x = 10

def f():
    x = 20
    print(x)

f()             # 20
print(x)        # 10

global and nonlocal

x = 1

def set_global():
    global x
    x = 2

def outer():
    y = 10
    def inner():
        nonlocal y
        y = 20
    inner()
    return y

set_global()
print(x)          # 2
print(outer())    # 20

Lambda, map, filter, sorted

nums = [3, 1, 2]

print(list(map(lambda x: x * 2, nums)))        # [6, 2, 4]
print(list(filter(lambda x: x > 1, nums)))     # [3, 2]
print(sorted(nums, key=lambda x: -x))          # [3, 2, 1]

Default argument trap

Default argument expressions are evaluated once when the function is defined, not each time it is called.

This is a classic exam and interview trap because the code may appear to “remember” values between calls.

Iteration, iterators, and generators

Generator traps

• A generator does not execute its body until iteration begins.
• Values are produced one at a time.
• Once exhausted, a generator does not restart automatically.
• return inside a generator ends iteration.
• yield pauses function state between values.

import math
from random import randint

print(math.pi)
print(randint(1, 6))

Trap:

import math
print(sqrt(9))       # NameError

Correct:

import math
print(math.sqrt(9))

Module execution and __name__

def main():
    print("run directly")

if __name__ == "__main__":
    main()

Use this pattern to prevent script-only code from running on import.

Module search and packages

import sys
print(sys.path)

Common standard modules

Avoid assuming exact platform output in exam questions unless it is explicitly given.

Package management concepts

Exam emphasis is usually conceptual: know what package installation and isolation are for.

Import forms

Import traps

Packages

A package organizes modules in directories. Review:

• Absolute vs relative import concepts.
• Why namespaces prevent name collisions.
• How package structure affects import paths.
• The role of module search paths at a conceptual level.

Do not spend all your review time memorizing obscure package mechanics. For PCAP-style readiness, prioritize understanding what names are available after imports and how module code executes.

Exception matching rules

try:
    int("x")
except Exception:
    print("general")
except ValueError:
    print("value")       # unreachable

Common built-in exceptions

Raising and re-raising

raise ValueError("bad input")

Inside an except block:

try:
    int("x")
except ValueError:
    print("logging")
    raise

assert

assert x > 0, "x must be positive"

Custom exceptions

class InvalidScoreError(Exception):
    pass

def check(score):
    if score < 0:
        raise InvalidScoreError("negative score")

Best exam answer: custom exceptions usually inherit from Exception, not directly from BaseException.

Common built-in exceptions

with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()

File method reference

with statement

Use context managers to guarantee cleanup.

with open("out.txt", "w", encoding="utf-8") as f:
    f.write("hello\n")

Exam trap: writelines(["a", "b"]) writes ab, not a\nb\n.

Instance vs class attributes

class C:
    x = 1

a = C()
b = C()

a.x = 2
print(a.x)    # 2
print(b.x)    # 1
print(C.x)    # 1

Mutable class attribute trap:

class Bag:
    items = []

a = Bag()
b = Bag()
a.items.append("x")
print(b.items)       # ['x']

Methods

class Example:
    count = 0

    def inst(self):
        return self

    @classmethod
    def cls_method(cls):
        return cls.count

    @staticmethod
    def util(x):
        return x * 2

Encapsulation and name mangling

class A:
    def __init__(self):
        self.__x = 1

a = A()
## a.__x        # AttributeError
print(a._A__x) # 1, name-mangled form

PCAP-style trap: double underscores do not make true private attributes; they trigger name mangling.

Inheritance and overriding

class Animal:
    def speak(self):
        return "sound"

class Dog(Animal):
    def speak(self):
        return "woof"

print(Dog().speak())       # woof

class Parent:
    def __init__(self, x):
        self.x = x

class Child(Parent):
    def __init__(self, x, y):
        super().__init__(x)
        self.y = y

Multiple inheritance and MRO

class A:
    def f(self): return "A"

class B(A):
    def f(self): return "B"

class C(A):
    def f(self): return "C"

class D(B, C):
    pass

print(D().f())      # B
print(D.__mro__)

Method Resolution Order searches classes in a deterministic order. For class D(B, C), B is searched before C.

Special methods

class Point:
    def __init__(self, x):
        self.x = x

    def __str__(self):
        return f"Point({self.x})"

print(Point(3))     # Point(3)

Methods and binding

Inheritance and overriding

Inheritance decision points

Ask these questions when reading OOP code:

1. Which class is used to create the object?
2. Does the instance have the attribute directly?
3. If not, does the class have it?
4. If not, is it inherited from a superclass?
5. If a method is called, which override is found first?
6. Does the method call super() and continue the chain?

Special methods

Know the pattern: Python syntax and built-in functions often call special methods behind the scenes.

Mini review: output-prediction checklist

Before choosing an answer, walk through the code in this order:

1. Parse the structure. Check indentation, blocks, and function/class definitions.
2. Identify object creation. Lists, dictionaries, objects, iterators, and generators may carry state.
3. Track name binding. Assignment changes what a name refers to.
4. Track mutation. In-place operations affect all references to the same mutable object.
5. Resolve scope. Apply LEGB for every non-obvious name.
6. Follow control flow. Include break, continue, return, exceptions, and finally.
7. Check return values. Many methods return None even though they changed an object.
8. Confirm final type. A correct-looking value with the wrong type may still be wrong.

Exception flow

Exception-order rule

Put specific exception handlers before general ones.

try / except / else / finally decision table

Important: finally is for cleanup logic. It runs even when control flow is leaving the block.

Practice priorities before the real exam

After this Cheat Sheet, use a question bank with original practice questions, topic drills, and detailed explanations. Prioritize practice in this order if time is short:

Identity, equality, and mutation traps

Quick check: if an operation mutates an object in place, be suspicious of assigning its return value. For example, x = my_list.sort() makes x become None.

Use context managers when possible: with open(...) as f: ensures the file is closed after the block.

File method review

Common traps:

• Opening with "w" can erase existing content.
• read() consumes from the current file position.
• Newline characters may remain when reading lines.
• Text mode expects strings; binary mode expects bytes-like objects.
• writelines() does not insert separators or newline characters for you.

Type and conversion mistakes

Mutability mistakes

Scope mistakes

Exception mistakes