GCSE Help

Core Python concepts for GCSE - code examples with explanations and a guide to the most common built-in functions.

Examples

Code Examples

📦

Variables

Store and label information

# Variables hold data - use = to assign
name = "Alice"       # text (string)
age = 14             # whole number (integer)
score = 9.5          # decimal (float)
is_playing = True    # true or false (boolean)

print(name)          # Alice
print(age)           # 14
print(type(score))   # <class 'float'>

# You can change a variable at any time
age = age + 1        # age is now 15
age += 1             # shorthand - age is now 16
print(age)

= assigns, == compares Strings use " " or ' ' Names are case-sensitive

🔀

If Statements

Make decisions in your code

score = 85

# if / elif / else - only one block runs
if score >= 90:
    print("Excellent!")
elif score >= 70:
    print("Good job!")
elif score >= 50:
    print("Keep practising!")
else:
    print("See your teacher.")

# Comparing text - use .lower() for safety
name = input("Enter name: ").lower()

if name == "alice":
    print("Welcome back, Alice!")
elif name == "bob":
    print("Hey Bob!")
else:
    print("Hello,", name)

Colon : after condition Indent body 4 spaces elif = else if

🔃

Match / Case

Python's switch statement - match a value against cases

# match/case checks a value against multiple options
# Introduced in Python 3.10

day = input("Enter a day: ").lower()

match day:
    case "monday" | "tuesday" | "wednesday" | "thursday" | "friday":
        print("It's a weekday.")
    case "saturday" | "sunday":
        print("It's the weekend!")
    case _:             # _ is the default - like 'else'
        print("That's not a valid day.")

# Works great for menu selections
choice = input("Menu - choose 1, 2 or 3: ")

match choice:
    case "1":
        print("You chose: Start game")
    case "2":
        print("You chose: View scores")
    case "3":
        print("You chose: Quit")
    case _:
        print("Invalid option - please enter 1, 2 or 3")

| means OR between cases _ is the default case Cleaner than long if/elif chains

🔄

While Loops

Keep repeating until a condition becomes false

# Basic while loop - always update the variable!
count = 1
while count <= 5:
    print(count)
    count += 1        # without this it loops forever!

# Keep asking until the user types something valid
answer = ""
while answer != "quit":
    answer = input("Type 'quit' to stop: ")
    print("You typed:", answer)

# break exits a loop immediately
for i in range(100):
    if i == 5:
        break         # stops the loop at 5
    print(i)          # prints 0 1 2 3 4

# continue skips the rest of the current loop step
for i in range(6):
    if i == 3:
        continue      # skips 3
    print(i)          # prints 0 1 2 4 5

Always update the variable! break exits loop continue skips to next

🔁

For Loops

Repeat code for each item in a sequence

# Loop through a list
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# Loop a fixed number of times with range()
for i in range(5):
    print(i)          # prints 0 1 2 3 4

# range(start, stop, step)
for i in range(2, 11, 2):
    print(i)          # 2 4 6 8 10

# Loop through characters in a string
word = "Python"
for letter in word:
    print(letter)     # P y t h o n

# Use enumerate() to get index AND value
for i, fruit in enumerate(fruits):
    print(i, fruit)   # 0 apple, 1 banana...

range(5) = 0 to 4 Works on lists, strings Indent body 4 spaces

🔤

String Manipulation

Work with and transform text

word = "Hello, World!"

# Indexing and slicing
print(word[0])        # H  (first character)
print(word[-1])       # !  (last character)
print(word[0:5])      # Hello  (chars 0–4)
print(word[7:])       # World!

# Common string methods
print(word.upper())         # HELLO, WORLD!
print(word.lower())         # hello, world!
print(word.replace("World", "Python"))  # Hello, Python!
print(word.find("World"))   # 7  (index where it starts)
print(len(word))            # 13

# Split and join
csv = "Alice,Bob,Charlie"
names = csv.split(",")      # ['Alice', 'Bob', 'Charlie']
print(names[1])             # Bob
print(", ".join(names))     # Alice, Bob, Charlie

# f-strings - easiest way to build strings
name = "Alice"
score = 95
print(f"{name} scored {score}%")   # Alice scored 95%

Index starts at 0 Strings are immutable f"..." for formatting

📋

Lists/Arrays

Store multiple items in a single variable

colours = ["red", "green", "blue"]

# Access items by index - counting starts at 0
print(colours[0])     # red
print(colours[1])     # green
print(colours[-1])    # blue  (last item)

# Change, add, and remove items
colours[0] = "orange"         # change
colours.append("purple")      # add to end
colours.remove("green")       # remove by value
colours.insert(1, "yellow")   # insert at position

# Useful list operations
print(len(colours))           # number of items
print("blue" in colours)      # True or False
colours.sort()                # sort alphabetically

# Loop through every item
for colour in colours:
    print(colour)

Index starts at 0 -1 = last item Square brackets [ ]

🗃️

2D Lists/Arrays

A list of lists - like a grid or table

# A 2D list is a list where each item is also a list
grid = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Access with [row][column] - both start at 0
print(grid[0][0])   # 1  (row 0, col 0)
print(grid[1][2])   # 6  (row 1, col 2)
print(grid[2][1])   # 8  (row 2, col 1)

# Change a value
grid[0][0] = 99
print(grid[0])      # [99, 2, 3]

# Loop through every row and column
for row in grid:
    for item in row:
        print(item, end=" ")
    print()         # new line after each row

# Useful for things like: seating plans, game boards,
# exam mark grids, pixel colours in images

[row][col] to access Both indexes start at 0 Nested for loops to iterate

⚙️

Methods - Procedures

A named block of code that does something but returns nothing

# A procedure does a job - it has NO return value
# Define with def, call by name

def greet(name):
    print("Hello,", name + "!")

def print_line(char="-", length=20):
    print(char * length)

def display_score(player, score):
    print_line()
    print(f"Player: {player}")
    print(f"Score:  {score}")
    print_line()

# Call each procedure
greet("Alice")           # Hello, Alice!
greet("Bob")             # Hello, Bob!
display_score("Alice", 95)

# Procedures are great for repetitive output tasks
# They change things (print, modify lists) but return None

No return statement def to define Call with ()

🔧

Methods - Functions

A named block of code that calculates and returns a value

# A function computes something and returns the result
# The caller stores or uses the returned value

def add(a, b):
    return a + b

def is_even(n):
    return n % 2 == 0

def clamp(value, low, high):
    return max(low, min(value, high))

# Parameters can have default values
def power(base, exponent=2):
    return base ** exponent

# Use the returned values
result = add(3, 4)
print(result)             # 7
print(is_even(9))         # False
print(clamp(150, 0, 100)) # 100  (capped at maximum)
print(power(3))           # 9
print(power(2, 10))       # 1024

return sends value back Store result in a variable Default params use =

📁

File Handling

Read from and write to files

# Write to a file (creates it if it doesn't exist)
with open("scores.txt", "w") as f:
    f.write("Alice: 95\n")
    f.write("Bob: 82\n")

# Read the whole file
with open("scores.txt", "r") as f:
    contents = f.read()
    print(contents)

# Read line by line
with open("scores.txt", "r") as f:
    for line in f:
        print(line.strip())   # strip removes \n

# Append to an existing file
with open("scores.txt", "a") as f:
    f.write("Charlie: 91\n")

"w" write (overwrites) "r" read "a" append

Reference

Common Functions

print()

Displays values to the console.

Use whenever you want to show output - text, numbers, or variable values.

print("Hello, world!") print("Score:", 95) print("Name:", name, "Age:", age)

input()

Pauses and asks the user to type something. Always returns text.

Use when your program needs information from the user. Wrap in int() or float() if you need a number.

name = input("What is your name? ") age = int(input("How old are you? ")) print("Hello,", name, "- you are", age)

int()

Converts a value to a whole number (integer).

Use after input() when you need to do maths with the result - input() always gives text.

age = int(input("Enter your age: ")) score = int("42") # 42 print(age + 1)

float()

Converts a value to a decimal number.

Use when you need decimal precision - e.g. prices, temperatures, averages.

price = float(input("Price: ")) print(price * 1.2) # add 20% tax pi = float("3.14159")

str()

Converts a value to text (a string).

Use when you want to join a number to a string using + (you can't mix types directly).

score = 95 message = "Your score: " + str(score) print(message) # Your score: 95

ord() / chr()

ord() converts a character to its ASCII number; chr() does the reverse.

Use for encryption/cipher tasks, checking if a character is a letter, or shifting characters (e.g. Caesar cipher).

print(ord("A")) # 65 print(ord("a")) # 97 print(chr(65)) # A print(chr(66)) # B # Caesar cipher - shift each letter by 1 letter = "H" shifted = chr(ord(letter) + 1) print(shifted) # I

.upper() / .lower()

Returns a copy of the string in ALL CAPS or all lowercase.

Use .lower() when comparing user input so "YES", "Yes", and "yes" all match.

answer = input("Continue? ").lower() if answer == "yes": print("Great!") print("LOUD".lower()) # loud

type()

Returns the data type of a value.

Use when debugging - it tells you whether something is a string, int, float, list, etc.

print(type(42)) # <class 'int'> print(type("hi")) # <class 'str'> print(type([1,2])) # <class 'list'>

len()

Returns how many items are in a string or list.

Use to count characters, check if a list is empty, or loop a dynamic number of times.

print(len("hello")) # 5 names = ["Alice", "Bob", "Charlie"] print(len(names)) # 3

range()

Generates a sequence of numbers.

Use with for loops to repeat code a set number of times, or to generate number sequences.

range(5) # 0 1 2 3 4 range(1, 6) # 1 2 3 4 5 range(0, 10, 2) # 0 2 4 6 8

round()

Rounds a decimal to the nearest whole number or to a given number of decimal places.

Use when displaying money, percentages, or any decimal that needs tidying up.

round(3.7) # 4 round(3.14159, 2) # 3.14 round(9.005, 2) # 9.0

.append()

Adds one item to the end of a list.

Use to build up a list gradually - e.g. collecting answers or scores during a loop.

scores = [] scores.append(85) scores.append(92) print(scores) # [85, 92]

.split()

Splits a string into a list of words (or parts split by a chosen character).

Use to break up text input - e.g. first and last name entered in one go.

full = "Alice Smith" parts = full.split() # split on spaces print(parts[0]) # Alice print(parts[1]) # Smith csv = "a,b,c".split(",") # ['a','b','c']

min()

Returns the smallest value from a sequence or from several arguments.

Use to find the lowest score, shortest word, or minimum number - the mirror image of max().

print(min(3, 7, 2, 9, 1)) # 1 scores = [45, 82, 67, 91, 58] print(min(scores)) # 45 words = ["cat", "elephant", "dog"] print(min(words, key=len)) # cat

max()

Returns the largest value from a sequence or from several arguments.

Use to find the highest score, the longest word, or the biggest number without writing a loop.

print(max(3, 7, 2, 9, 1)) # 9 scores = [45, 82, 67, 91, 58] print(max(scores)) # 91 words = ["cat", "elephant", "dog"] print(max(words, key=len)) # elephant

import

Loads a module (a library of extra functions) so you can use it in your program.

Use at the very top of your file whenever you need something not built in - e.g. random numbers, maths functions, or time.

import random import math print(random.randint(1, 10)) # random int 1–10 print(random.choice(["a","b"])) # random item print(math.sqrt(16)) # 4.0 print(math.pi) # 3.14159...

open() - read

Opens a file for reading; f.read() gets all the contents as a string. Always close the file when done.

Use to load saved data - scores, names, settings. Remember to call f.close() or the file stays locked.

f = open("scores.txt", "r") contents = f.read() print(contents) f.close() # Read line by line instead f = open("scores.txt", "r") for line in f: print(line.strip()) # strip removes \n f.close()

open() - write

Opens a file for writing ("w") or appending ("a"). "w" overwrites; "a" adds to the end. Always close when done.

Use "w" to save fresh results; use "a" to add new entries without losing existing ones. Call f.close() when finished.

f = open("scores.txt", "w") f.write("Alice: 95\n") f.write("Bob: 82\n") f.close() # Append - adds to existing file without erasing it f = open("scores.txt", "a") f.write("Charlie: 91\n") f.close()

A Level Help

Advanced Python concepts for A Level - object-oriented programming, algorithms, file handling, and more.

Examples

Code Examples

📦

3D Lists

A list of lists of lists - three dimensions indexed as [layer][row][col]

# 3D list - a list where each item is a 2D list
cube = [
    [[1, 2, 3], [4, 5, 6]],      # layer 0
    [[7, 8, 9], [10, 11, 12]]    # layer 1
]

# Access with [layer][row][col]
print(cube[0][0][0])   # 1
print(cube[0][1][2])   # 6
print(cube[1][0][1])   # 8

# Change a value
cube[1][1][2] = 99
print(cube[1][1][2])   # 99

# Loop through all elements
for layer in cube:
    for row in layer:
        for item in row:
            print(item, end=" ")
        print()

# Create a 2×3×4 block of zeros
empty = [[[0]*4 for _ in range(3)] for _ in range(2)]

[layer][row][col] Three nested loops to iterate List comprehension to create empty

🔗

Tuples

Immutable sequences - values that cannot change after creation

# Tuples use () and cannot be changed after creation
person = ("Alice", 14)
print(person[0])    # Alice
print(person[1])    # 14
# person[0] = "Bob"  # TypeError - tuples are immutable!

# Unpacking - assign each item to a variable
name, age = ("Bob", 16)
print(name, age)    # Bob 16

# Returning multiple values from a function
def get_range(lst):
    return min(lst), max(lst)  # returns a tuple

lo, hi = get_range([5, 3, 8, 1, 9])
print(f"Min={lo}  Max={hi}")  # Min=1  Max=9

# Named tuples - give fields descriptive names
from collections import namedtuple
Point = namedtuple("Point", ["x", "y"])
p = Point(3, 5)
print(p.x, p.y)     # 3 5

# Tuples in lists - useful for coordinate or record data
coords = [(1, 2), (3, 4), (5, 6)]
for x, y in coords:
    print(f"x={x}, y={y}")

( ) not [ ] Immutable - can't be changed Unpack with a, b = tuple

📋

Lists - Advanced

Slicing, sorting, comprehensions, and common operations

nums = [3, 1, 4, 1, 5, 9, 2, 6, 5]

# Slicing - [start:stop:step]
print(nums[1:4])       # [1, 4, 1]
print(nums[::2])       # [3, 4, 5, 2, 5]  every other
print(nums[::-1])      # reversed list

# Sorting
nums.sort()                  # sort in place (ascending)
nums.sort(reverse=True)      # descending
copy = sorted(nums)          # returns new list, original unchanged

# Searching
print(nums.count(5))         # count occurrences
print(nums.index(9))         # first index of value

# Adding and removing
nums.append(7)               # add to end
nums.insert(0, 0)            # insert at index
nums.remove(1)               # remove first occurrence of value
nums.pop()                   # remove and return last item
nums.pop(2)                  # remove at index 2

# Always copy properly - = just copies the reference!
original = [1, 2, 3]
safe_copy = original.copy()  # or list(original) or original[:]

[start:stop:step] slicing .sort() modifies in place .copy() to avoid aliasing

🏗️

Classes & Objects

Object-oriented programming - blueprints and instances

class Dog:
    # __init__ runs when you create a new Dog
    def __init__(self, name, breed):
        self.name  = name    # instance attribute
        self.breed = breed

    def bark(self):
        print(f"{self.name} says: Woof!")

    def __str__(self):
        return f"{self.name} ({self.breed})"

# Create instances (objects) from the class
dog1 = Dog("Rex", "Labrador")
dog2 = Dog("Bella", "Poodle")

dog1.bark()          # Rex says: Woof!
print(dog2)          # Bella (Poodle)
print(dog1.name)     # Rex

self = this object __init__ is the constructor __str__ controls print()

🧬

Inheritance

A subclass inherits from a parent class

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound.")

# Cat inherits everything from Animal
class Cat(Animal):
    def speak(self):          # override parent method
        print(f"{self.name} says: Meow!")

class Dog(Animal):
    def speak(self):
        print(f"{self.name} says: Woof!")

    def fetch(self):          # new method only for Dog
        print(f"{self.name} fetches the ball!")

cat = Cat("Whiskers")
dog = Dog("Rex")

cat.speak()    # Whiskers says: Meow!
dog.speak()    # Rex says: Woof!
dog.fetch()    # Rex fetches the ball!

class Child(Parent): Override by redefining method super() calls parent

🛡️

Exception Handling

Handle errors gracefully so the program doesn't crash

try:
    age = int(input("Enter your age: "))
    print("You are", age, "years old.")
except ValueError:
    print("Error: please enter a whole number.")
except ZeroDivisionError:
    print("Error: cannot divide by zero.")
finally:
    print("This always runs.")

# Raise your own exceptions
def set_age(age):
    if age < 0 or age > 150:
        raise ValueError("Age must be between 0 and 150")
    return age

try:
    set_age(-5)
except ValueError as e:
    print("Caught:", e)

try: risky code except: handle the error finally: always runs

🌀

Recursion

A function that calls itself

# Factorial: 5! = 5 × 4 × 3 × 2 × 1
def factorial(n):
    if n == 0 or n == 1:   # base case - stops recursion
        return 1
    return n * factorial(n - 1)  # recursive call

print(factorial(5))   # 120
print(factorial(10))  # 3628800

# Fibonacci sequence
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

for i in range(8):
    print(fibonacci(i), end=" ")  # 0 1 1 2 3 5 8 13

Must have a base case! Each call reduces the problem Stack builds up then unwinds

⚡

List Comprehensions

Build lists concisely in one line

# Basic: [expression for item in iterable]
squares = [x**2 for x in range(1, 6)]
print(squares)    # [1, 4, 9, 16, 25]

# With condition: [expr for item in iterable if condition]
evens = [x for x in range(20) if x % 2 == 0]
print(evens)      # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# Transform strings
words  = ["hello", "world", "python"]
upper  = [w.upper() for w in words]
print(upper)      # ['HELLO', 'WORLD', 'PYTHON']

# Equivalent for loop (longer way):
result = []
for x in range(1, 6):
    result.append(x**2)

[ ] with for inside Optional if filter Faster than a for loop

Reference

Key Concepts

__init__(self, ...)

The constructor method - runs automatically when a new object is created.

Use to set up the initial state (attributes) of every new object.

class Car: def __init__(self, make, speed): self.make = make self.speed = speed

super()

Calls a method from the parent class.

Use in a child class when you want to extend (not replace) the parent's __init__ or other method.

class ElectricCar(Car): def __init__(self, make, speed, battery): super().__init__(make, speed) self.battery = battery

try / except / finally

Catches and handles runtime errors without crashing the program.

Use around any code that might fail - file I/O, type conversion, network calls.

try: n = int(input("Number: ")) except ValueError: print("Not a number!") finally: print("Done.")

lambda

A small, anonymous (unnamed) function written in one line.

Use as a quick function argument - e.g. for sorting or mapping a list.

double = lambda x: x * 2 print(double(5)) # 10 names = ["Charlie", "Alice", "Bob"] names.sort(key=lambda n: len(n)) print(names) # ['Bob', 'Alice', 'Charlie']

Dictionary methods

Dictionaries store key-value pairs with fast lookup.

Use instead of parallel lists when data has a clear key - e.g. name → score.

scores = {"Alice": 95, "Bob": 82} scores["Charlie"] = 91 # add print(scores.get("Dave", 0)) # safe lookup → 0 for name, score in scores.items(): print(name, score)

Bubble Sort

A simple sorting algorithm that repeatedly swaps adjacent items that are in the wrong order.

A Level exam favourite - understand it conceptually and be able to trace through it.

def bubble_sort(lst): n = len(lst) for i in range(n): for j in range(0, n - i - 1): if lst[j] > lst[j + 1]: lst[j], lst[j+1] = lst[j+1], lst[j] return lst print(bubble_sort([64, 34, 25, 12]))

Binary Search

Efficiently finds a value in a sorted list by halving the search space each step.

Use on sorted data - O(log n) vs linear search O(n). Key algorithm for A Level.

Sorting

Sorting Algorithms

Insertion Sort

Builds the sorted list one item at a time by inserting each element into its correct position among those already sorted.

O(n²) worst case but very efficient on nearly-sorted data. Stable sort - equal elements keep their original order.

def insertion_sort(lst): for i in range(1, len(lst)): key = lst[i] j = i - 1 while j >= 0 and lst[j] > key: lst[j + 1] = lst[j] j -= 1 lst[j + 1] = key return lst print(insertion_sort([5, 3, 8, 1, 9, 2])) # [1, 2, 3, 5, 8, 9]

Bubble Sort

Repeatedly compares adjacent items and swaps them if they are in the wrong order; the largest values bubble to the end each pass.

O(n²) - simple to understand and trace but slow on large lists. A Level exam favourite for manual tracing questions.

def bubble_sort(lst): n = len(lst) for i in range(n): for j in range(0, n - i - 1): if lst[j] > lst[j + 1]: lst[j], lst[j+1] = lst[j+1], lst[j] return lst print(bubble_sort([64, 34, 25, 12, 22])) # [12, 22, 25, 34, 64]

Merge Sort

Divides the list in half, recursively sorts each half, then merges the two sorted halves back into one.

O(n log n) - efficient and stable. Good for large datasets. Uses extra memory for the temporary lists (divide-and-conquer).

def merge_sort(lst): if len(lst) <= 1: return lst mid = len(lst) // 2 left = merge_sort(lst[:mid]) right = merge_sort(lst[mid:]) return merge(left, right) def merge(l, r): result, i, j = [], 0, 0 while i < len(l) and j < len(r): if l[i] <= r[j]: result.append(l[i]); i += 1 else: result.append(r[j]); j += 1 return result + l[i:] + r[j:]

Quick Sort

Picks a pivot, partitions items into less-than and greater-than groups, then recursively sorts each partition.

O(n log n) average, O(n²) worst case. Very fast in practice. Not stable. Pivot choice heavily affects performance.

def quick_sort(lst): if len(lst) <= 1: return lst pivot = lst[len(lst) // 2] left = [x for x in lst if x < pivot] mid = [x for x in lst if x == pivot] right = [x for x in lst if x > pivot] return quick_sort(left) + mid + quick_sort(right) print(quick_sort([3, 6, 8, 10, 1, 2])) # [1, 2, 3, 6, 8, 10]

Searching

Searching Algorithms

Linear Search

Checks every item from start to end until the target is found or the list is exhausted.

O(n) - works on unsorted data. Simple but slow for large lists. Use when data is unsorted or changes frequently.

def linear_search(lst, target): for i in range(len(lst)): if lst[i] == target: return i # found at index i return -1 # not found data = [5, 3, 8, 1, 9] print(linear_search(data, 8)) # 2 print(linear_search(data, 7)) # -1

Binary Search

Halves the search space at each step by comparing the target with the middle element of a sorted list.

O(log n) - far faster than linear search on large datasets. The list MUST be sorted first or it will give wrong answers.

def binary_search(lst, target): low, high = 0, len(lst) - 1 while low <= high: mid = (low + high) // 2 if lst[mid] == target: return mid elif lst[mid] < target: low = mid + 1 else: high = mid - 1 return -1 data = [1, 3, 5, 7, 9, 11, 13] # must be sorted! print(binary_search(data, 7)) # 3 print(binary_search(data, 4)) # -1

Data Structures & Algorithms

Algorithms & Data Structures

Stack

A LIFO (Last In, First Out) structure - the most recently added item is always removed first. Like a stack of plates.

Use for: undo history, bracket matching, depth-first search, tracking function call order.

stack = [] # a list works as a stack stack.append("A") # push stack.append("B") stack.append("C") print(stack.pop()) # C - last in, first out print(stack.pop()) # B print(stack) # ['A']

Queue

A FIFO (First In, First Out) structure - the first item added is the first removed. Like a queue at a checkout.

Use for: task scheduling, print queues, breadth-first search. Use deque for efficient popleft().

from collections import deque queue = deque() queue.append("first") # enqueue queue.append("second") queue.append("third") print(queue.popleft()) # first - FIFO print(queue.popleft()) # second print(queue) # deque(['third'])

Linked List

A sequence of nodes where each node stores a value and a pointer to the next node. Not stored contiguously in memory.

Efficient O(1) insertion and deletion. No random access by index - must traverse from the head each time.

class Node: def __init__(self, value): self.value = value self.next = None head = Node(1) head.next = Node(2) head.next.next = Node(3) current = head while current: print(current.value, end=" -> ") current = current.next print("None") # 1 -> 2 -> 3 -> None

Trees

A hierarchical structure with a root node; each node has zero or more child nodes. There are no cycles.

Use for: file systems, HTML DOM, decision trees, binary search trees, expression parsing.

class Node: def __init__(self, val): self.val = val self.children = [] root = Node("A") b, c = Node("B"), Node("C") root.children = [b, c] b.children = [Node("D"), Node("E")] def print_tree(node, depth=0): print(" " * depth + node.val) for child in node.children: print_tree(child, depth + 1) print_tree(root) # A, then B/D/E, then C

Depth-First Search

Explores a graph by going as deep as possible down each branch before backtracking to try the next branch.

Use for: maze solving, cycle detection, topological sort. Naturally implemented with recursion (uses the call stack).

graph = {"A":["B","C"],"B":["D","E"], "C":["F"],"D":[],"E":[],"F":[]} def dfs(graph, node, visited=None): if visited is None: visited = set() visited.add(node) print(node, end=" ") for n in graph[node]: if n not in visited: dfs(graph, n, visited) dfs(graph, "A") # A B D E C F

Breadth-First Search

Explores a graph level by level - visits all immediate neighbours before moving to their neighbours.

Use for: shortest path in unweighted graphs, social network distance, web crawling. Uses a queue.

from collections import deque graph = {"A":["B","C"],"B":["D","E"], "C":["F"],"D":[],"E":[],"F":[]} def bfs(graph, start): visited = {start} queue = deque([start]) while queue: node = queue.popleft() print(node, end=" ") for n in graph[node]: if n not in visited: visited.add(n); queue.append(n) bfs(graph, "A") # A B C D E F

Dijkstra's Algorithm

Finds the shortest path from a source to all other nodes in a weighted graph. All edge weights must be non-negative.

Use when edges have different costs (distances, times, fares). Greedy - always extends the cheapest known path first.

import heapq def dijkstra(graph, start): dist = {n: float("inf") for n in graph} dist[start] = 0 heap = [(0, start)] while heap: d, node = heapq.heappop(heap) for neighbour, w in graph[node]: if d + w < dist[neighbour]: dist[neighbour] = d + w heapq.heappush(heap, (d + w, neighbour)) return dist graph = {"A":[("B",4),("C",2)],"B":[("D",5)], "C":[("B",1),("D",8)],"D":[]} print(dijkstra(graph, "A")) # {'A':0, 'B':3, 'C':2, 'D':8}

A* Algorithm

Finds the shortest path using a heuristic to guide the search - combines actual cost so far (g) with an estimated cost to goal (h).

Use for grid/map pathfinding (games, navigation). Faster than Dijkstra when a good heuristic is available.

import heapq def h(a, b): # Manhattan distance heuristic return abs(a[0]-b[0]) + abs(a[1]-b[1]) def a_star(grid, start, goal): open_set = [(h(start,goal), 0, start, [start])] visited = set() while open_set: _, g, pos, path = heapq.heappop(open_set) if pos == goal: return path if pos in visited: continue visited.add(pos) for dr,dc in [(-1,0),(1,0),(0,-1),(0,1)]: r, c = pos[0]+dr, pos[1]+dc if 0<=r<len(grid) and 0<=c<len(grid[0]): if grid[r][c]==0 and (r,c) not in visited: new_g = g + 1 open_set.append((new_g+h((r,c),goal),new_g,(r,c),path+[(r,c)])) heapq.heapify(open_set) return [] grid = [[0,0,0],[0,1,0],[0,0,0]] print(a_star(grid, (0,0), (2,2)))

Graphs

A set of nodes (vertices) connected by edges. Can be directed or undirected, weighted or unweighted.

Use for: networks, maps, social connections, routing. Represented as an adjacency list using a dictionary of lists.

graph = { "A": ["B", "C"], "B": ["A", "D"], "C": ["A"], "D": ["B"] } # Add a node graph["E"] = [] # Add an undirected edge graph["A"].append("E") graph["E"].append("A") # Print all neighbours of A for neighbour in graph["A"]: print("A ->", neighbour) # A -> B, A -> C, A -> E

Hash Tables (Dictionaries)

Stores key-value pairs with O(1) average lookup. Python's dict is a built-in hash table.

Use when you need fast lookup by a key (name, ID, word) rather than by index. Keys must be unique and immutable.

scores = {} scores["Alice"] = 95 scores["Bob"] = 82 scores["Charlie"] = 91 print(scores["Alice"]) # 95 print(len(scores)) # 3 print("Bob" in scores) # True # Iterate over key-value pairs for name, score in scores.items(): print(f"{name}: {score}") # Safe lookup - won't crash if key missing val = scores.get("Alice", 0) print("Found:", val) # Found: 95 del scores["Bob"] print(len(scores)) # 2

Object-Oriented Programming

OOP Concepts

Public & Private Variables

Python uses naming conventions to signal access level. _ prefix = protected (internal use); __ prefix = private (name-mangled, harder to access from outside).

Use _ to signal "don't use this directly" and __ when you want Python to actively prevent easy external access to a field.

class Person: def __init__(self, name, age): self.name = name # public - accessible anywhere self._age = age # protected - convention only self.__id = 99 # private - name-mangled def show(self): print(self.name, self._age, self.__id) p = Person("Alice", 14) print(p.name) # Alice - OK print(p._age) # 14 - works but discouraged # print(p.__id) # AttributeError! print(p._Person__id) # 99 - mangled name (not recommended)

Encapsulation

Hiding internal data behind controlled access using private attributes and public methods (getters/setters). Protects data from invalid changes.

Use when a field has validation rules or should only change in a controlled way. Properties (@property) are the Pythonic way to do this.

class BankAccount: def __init__(self, opening): self.__balance = max(0, opening) # validated @property def balance(self): # getter - read-only return self.__balance def deposit(self, amount): if amount > 0: self.__balance += amount def withdraw(self, amount): if 0 < amount <= self.__balance: self.__balance -= amount acc = BankAccount(100) acc.deposit(50) print(acc.balance) # 150 # acc.__balance = -999 # AttributeError - protected!

Inheritance

A child class inherits all methods and attributes from a parent class. Use class Child(Parent) to inherit. Use super() to call the parent constructor.

Use when two classes share common behaviour - put shared code in the parent, put specialised behaviour in the child.

class Animal: def __init__(self, name): self.name = name def eat(self): print(f"{self.name} is eating.") # Dog inherits everything from Animal class Dog(Animal): def __init__(self, name, breed): super().__init__(name) # call parent __init__ self.breed = breed def bark(self): print(f"{self.name} says Woof!") d = Dog("Rex", "Labrador") d.eat() # inherited → Rex is eating. d.bark() # Dog's own → Rex says Woof! print(d.breed) # Labrador

Abstract Methods

An abstract method has no body in the parent class - every child class MUST provide its own implementation. Requires importing ABC.

Use when the parent defines WHAT should happen but each child decides HOW. Enforces that all subclasses implement a required method.

from abc import ABC, abstractmethod class Shape(ABC): # ABC = Abstract Base Class def __init__(self, colour): self.colour = colour @abstractmethod # child MUST implement this def area(self): pass def describe(self): # shared - not abstract print(f"{self.colour} shape, area = {self.area():.2f}") class Circle(Shape): def __init__(self, c, r): super().__init__(c); self.r = r def area(self): return 3.14159 * self.r ** 2 class Rectangle(Shape): def __init__(self, c, w, h): super().__init__(c); self.w=w; self.h=h def area(self): return self.w * self.h Circle("Red", 5).describe() # Red shape, area = 78.54 Rectangle("Blue", 4, 6).describe() # Blue shape, area = 24.00

Polymorphism

The same method call behaves differently depending on the actual type of the object. Python supports this naturally - no keywords needed.

Use when you want to treat different objects through a shared interface and have each one respond in its own way - essential for flexible, extensible code.

class Animal: def __init__(self, name): self.name = name def speak(self): print(f"{self.name} makes a sound.") class Dog(Animal): def speak(self): # overrides parent method print(f"{self.name} says: Woof!") class Cat(Animal): def speak(self): print(f"{self.name} says: Meow!") # Polymorphism - same call, different behaviour animals = [Dog("Rex"), Cat("Whiskers"), Dog("Buddy")] for animal in animals: animal.speak() # Rex says: Woof! # Whiskers says: Meow! # Buddy says: Woof!