PCEP-30-02 — Python Institute PCEP - Certified Entry-Level Python Programmer Cheat Sheet

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

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

print()

print() displays values. It does not return the displayed value; its return value is None.

High-yield options:

• print(a, b) separates values with a space by default.
• sep= changes the separator.
• end= changes what is printed after the output, defaulting to a newline.

Common examples:

• print("A", "B") displays A B.
• print("A", "B", sep="-") displays A-B.
• print("A", end="") does not move to a new line after A.

input()

input() reads text and returns a string.

Common mistake: input() does not automatically parse numbers.

Truthiness

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

String Escapes

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

Arithmetic operators

Operator precedence to remember

Common traps:

• 2 + 3 * 4 is 14, not 20.
• (2 + 3) * 4 is 20.
• 5 / 2 is 2.5, not 2.
• 5 // 2 is 2.
• -5 // 2 floors downward to -3, not toward zero.
• 2 ** 3 ** 2 is evaluated right-associatively: 2 ** (3 ** 2).

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

while loops

A while loop repeats while its condition is true.

Review points:

• If the condition is false initially, the body does not run.
• A loop variable must usually be updated inside the loop.
• A missing update can create an infinite loop.
• break exits the nearest loop.
• continue skips to the next iteration check.

Common trace method:

1. Write the initial variable values.
2. Check the loop condition.
3. Execute the body line by line.
4. Record updates.
5. Repeat until the condition fails or break runs.

for loops

A for loop iterates over an iterable such as a string, list, tuple, dictionary, or range().

range() traps

The stop value is excluded.

Loop else

Python loops can have an else block. It runs if the loop finishes normally. It does not run if the loop exits with break.

This is a frequent candidate mistake because loop else is not the same as if / else.

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.

Strings

Strings are immutable sequences.

Indexing and slicing

If s = "Python":

Common traps:

• Indexing outside the string raises an error.
• Slicing outside the string usually does not raise an error; it adjusts to valid boundaries.
• Strings cannot be changed in place: s[0] = "J" is invalid.
• s.upper() returns a new string; it does not modify s.

String operators and methods

Trap: "10" + "5" gives "105", not 15.

Lists

Lists are mutable ordered collections.

List basics

Mutability and aliasing

If two variables refer to the same list, changing through one name affects the other.

Common trap: methods such as append(), sort(), and reverse() modify the list and return None.

Sorting

Candidate mistake: assigning lst = lst.sort() makes lst become None.

Tuples

Tuples are immutable ordered collections.

Common trap: parentheses alone do not make a tuple; the comma matters for a single-element tuple.

Dictionaries

Dictionaries store key-value pairs and are mutable.

Common traps:

• in checks keys, not values.
• Keys must be hashable; lists cannot be dictionary keys.
• Accessing a missing key with d[key] raises an error.
• Assigning to an existing key overwrites the old value.

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.

Function definition and call

A function definition creates a callable object. The body runs only when the function is called.

Key rules:

• Parameters are names used inside the function.
• Arguments are values passed during the call.
• return sends a value back to the caller and exits the function.
• If no return runs, the function returns None.

Common mistake: confusing displayed output with returned value.

Parameters and arguments

Common traps:

• A required parameter without a default must receive an argument.
• Do not place a non-default parameter after a default parameter in a function definition.
• Mutable default arguments can preserve changes between calls; for entry-level review, recognize this as risky behavior.

Scope

Candidate mistake: assuming assignment inside a function automatically changes a global variable.

Common Exceptions

Exception Matching Traps

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

## value

Basic exception handling

try / except lets code handle runtime errors.

Review points:

• Code in try runs first.
• If a matching exception occurs, the matching except block runs.
• If no exception occurs, except blocks are skipped.
• Code after the whole structure continues unless the exception is unhandled or the program exits.

Common exception types to recognize:

Exception trap patterns

For the exam, focus on identifying whether an error occurs, where it occurs, and whether the provided handler catches it.

Mutate or Return?

High-yield tracing checklist

When a question asks “What is the output?” or “What is the result?”, use this order:

1. Check for syntax or indentation problems. If code cannot parse, execution never starts.
2. Record initial assignments. Track variable values carefully.
3. Apply type rules. Decide whether operations are numeric, string, list, or invalid.
4. Apply precedence. Parentheses first, then operators.
5. Trace branches. In an if / elif chain, only the first true branch runs.
6. Trace loops one iteration at a time. Update loop variables after each body execution.
7. Watch mutation. Lists and dictionaries may change in place.
8. Separate print() from return. Output and return values are not the same.
9. Check exception location. Determine whether the error is inside a matching try.
10. Confirm final output formatting. Spaces, newlines, separators, and end= matter.

Type conversion traps

High-yield rule: input() always returns a string. Convert before numeric comparison or arithmetic.

Example decision:

• age = input() gives a string.
• age + 1 is an error unless age is converted.
• int(age) + 1 performs numeric addition if the input is valid.

For entry-level questions, prefer == for value comparison. Do not use is to compare ordinary numbers or strings unless the question is specifically about identity.

Truthiness

Trap: "0" is a non-empty string, so it is True in Boolean context.

Boolean short-circuiting

This matters when the skipped expression would call a function, modify a variable, or raise an exception.

“Will this raise an error?”

“Which branch runs?”