PCEP-30-02 — Python Institute PCEP - Certified Entry-Level Python Programmer Quick Reference

Use this independent Quick Reference for the Python Institute PCEP - Certified Entry-Level Python Programmer (PCEP-30-02) to refresh Python fundamentals and trace short code snippets quickly. Focus on exact output, exact exception behavior, type conversions, mutability, and control-flow paths.

Rapid Scope Map

Python Program Basics

Syntax Essentials

Identifiers and Keywords

Valid identifiers:

• May contain letters, digits, and underscores.
• Cannot start with a digit.
• Cannot be a reserved keyword.
• Are case-sensitive.

Core Python 3 reserved words include:

False None True and as assert async await break class continue def del elif else
except finally for from global if import in is lambda nonlocal not or pass raise
return try while with yield

Input, Output, and Basic Built-ins

print()

print("A", "B", sep="-", end="!")
print("C")
## A-B!C

input()

Trap:

x = input()
print(x + 1)      # TypeError if x is str
print(int(x) + 1) # Correct if x contains an integer literal

High-Use Built-ins

Data Types, Literals, and Conversions

Truthiness

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

String Escapes

Operators and Precedence

Operator Groups

Precedence: High to Low

Arithmetic Traps

print(2 ** 3 ** 2)      # 512, because 2 ** (3 ** 2)
print(-2 ** 2)          # -4, because -(2 ** 2)
print((-2) ** 2)        # 4

print(7 / 2)            # 3.5
print(7 // 2)           # 3
print(7 % 2)            # 1

print(-7 // 3)          # -3, floor division
print(-7 % 3)           # 2

Remember:

• // is floor division, not simple truncation for negative values.
• % is the remainder consistent with floor division.
• + concatenates sequences only when types are compatible, such as str + str or list + list.
• "3" + "4" is "34", not 7.
• "ha" * 3 is "hahaha".

Logical Operators

print(0 and 5)      # 0
print(3 and 5)      # 5
print("" or "x")    # x
print("a" or "x")   # a

Equality vs Identity

a = [1, 2]
b = [1, 2]
c = a

print(a == b)   # True
print(a is b)   # False
print(a is c)   # True

Control Flow

Conditional Statements

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
else:
    grade = "C"

Trap:

x = 5
if x > 0:
    print("positive")
if x > 3:
    print("large")
else:
    print("small")

## positive
## large

The else belongs only to the second if.

while Loops

n = 3
while n > 0:
    print(n)
    n -= 1

Use while when the number of iterations depends on a condition, sentinel value, or state change.

for Loops and range()

Rules:

• Start is included.
• Stop is excluded.
• Step cannot be zero.
• Negative step counts down.

for i in range(3):
    print(i)
## 0
## 1
## 2

break, continue, and Loop else

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

## not found

i = 0
while i < 5:
    i += 1
    if i == 3:
        continue
    print(i)

## 1
## 2
## 4
## 5

Choosing a Control Structure

Collections Quick Reference

Sequence Indexing and Slicing

Applies to strings, lists, and tuples.

s = "Python"

print(s[0])        # P
print(s[-1])       # n
print(s[1:5:2])    # yh
print(s[::-1])     # nohtyP

Traps:

• s[99] raises IndexError.
• s[2:99] is allowed and stops at the end.
• Slice stop is excluded.
• A slice step of 0 raises ValueError.

Strings

String immutability trap:

s = "cat"
## s[0] = "b"       # TypeError
s = "b" + s[1:]    # Rebinds s to "bat"

Lists

Mutation trap:

nums = [3, 1, 2]
result = nums.sort()

print(nums)    # [1, 2, 3]
print(result)  # None

Aliasing trap:

a = [1, 2]
b = a
c = a[:]

b.append(3)

print(a)  # [1, 2, 3]
print(c)  # [1, 2]

Tuples

Tuple rules:

• Tuples are immutable.
• You can index, slice, iterate, use len(), in, .count(), and .index().
• A tuple can contain mutable objects, but the tuple’s element bindings cannot be reassigned.

t = ([1, 2], 3)
t[0].append(4)

print(t)  # ([1, 2, 4], 3)

Dictionaries

Dictionary traps:

d = {"a": 1, "b": 2}

print("a" in d)       # True
print(1 in d)         # False, values are not tested
print(d.get("x"))     # None
## print(d["x"])       # KeyError

Keys must be hashable, so common safe key types include strings, numbers, and tuples of hashable elements. Lists cannot be dictionary keys.

Functions and Scope

Defining and Calling Functions

def area(width, height):
    return width * height

print(area(3, 4))  # 12

Parameters and Arguments

def power(base, exponent=2):
    return base ** exponent

print(power(3))       # 9
print(power(3, 3))    # 27
print(power(exponent=3, base=2))  # 8

Scope Rules

x = 10

def show():
    print(x)

show()  # 10

Scope trap:

x = 10

def bad():
    # print(x)  # UnboundLocalError if executed before local assignment
    x = 5
    print(x)

bad()      # 5
print(x)   # 10

Global rebinding:

count = 0

def inc():
    global count
    count += 1

inc()
print(count)  # 1

Mutable Argument Side Effects

def add_item(items):
    items.append("x")

data = []
add_item(data)

print(data)  # ['x']

A function can mutate a mutable object passed to it even without returning that object.

Exceptions

Basic Structure

try:
    number = int(input())
    result = 10 / number
except ValueError:
    print("not an integer")
except ZeroDivisionError:
    print("division by zero")
else:
    print(result)
finally:
    print("done")

Common Exceptions

Exception Matching Traps

try:
    x = int("abc")
except ZeroDivisionError:
    print("zero")
except ValueError:
    print("value")

## value

Modules and Namespaces

Import Forms

import math

print(math.pi)
print(math.sqrt(16))

from math import sqrt

print(sqrt(16))

Trap:

import math
## print(sqrt(16))      # NameError
print(math.sqrt(16))   # Correct

Module Execution Guard

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

if __name__ == "__main__":
    main()

High-Yield Code-Tracing Patterns

Evaluate in This Order

1. Identify types of each variable.
2. Apply parentheses, indexing, slicing, and function calls first.
3. Apply operator precedence.
4. Track assignments and mutations separately.
5. For loops, write each iteration value.
6. For break/continue, mark skipped statements.
7. For functions, create a local scope and track return value.
8. For exceptions, stop normal flow at the failing statement and jump to matching handler.

Frequent Output Traps

Mutate or Return?

Mini Drill Snippets

Trace these until the result is automatic.

x = [1, 2, 3]
y = x
z = x[:]

x.append(4)
y[0] = 9

print(x)
print(z)

## [9, 2, 3, 4]
## [1, 2, 3]

total = 0

for i in range(1, 5):
    if i % 2 == 0:
        continue
    total += i

print(total)

## 4

def f(x):
    if x > 0:
        return x
    return -x

print(f(-3))
print(f(0))
print(f(3))

## 3
## 0
## 3

try:
    print("A")
    print(1 / 0)
    print("B")
except ZeroDivisionError:
    print("C")
finally:
    print("D")

## A
## C
## D

Final Review Checklist

Before test day, make sure you can:

• Predict output for short Python snippets without running them.
• Explain why /, //, and % produce different results.
• Convert safely between str, int, float, and bool.
• Trace if/elif/else chains exactly.
• Use range(start, stop, step) without including the stop value.
• Distinguish break, continue, and loop else.
• Slice strings/lists/tuples using positive and negative indices.
• Identify which list methods mutate and return None.
• Distinguish list aliasing from list copying.
• Recognize tuple singleton syntax: (x,).
• Remember that dictionary membership tests keys.
• Trace function calls, local variables, defaults, and return values.
• Match common exceptions to likely causes.
• Use import module versus from module import name correctly.

Next step: complete a timed mixed set of original PCEP-30-02 practice questions, then review every missed item by rewriting the code path, variable values, and final output or exception.