TCX1002 | Python Midterm Cheatsheet (Weeks 1-4)

1import datetime
2import functools    # reduce, partial, lru_cache
3import itertools    # combinations, permutations, chain, product
4import math         # ceil, floor, sqrt, log, gcd
5import numpy as np  # full numpy
6import random       # randint, choice, shuffle
7import re           # findall, match, search, sub

 1# ❌ BANNED: defaultdict(int)
 2counts[key] += 1  # KeyError if key doesn't exist
 3
 4# ✅ Regular dict counting
 5counts[key] = counts.get(key, 0) + 1
 6
 7# ❌ BANNED: defaultdict(list)
 8groups[key].append(val)
 9
10# ✅ setdefault
11groups.setdefault(key, []).append(val)
12
13# ❌ BANNED: defaultdict(set)
14groups[key].add(val)
15
16# ✅ setdefault with set
17groups.setdefault(key, set()).add(val)

1counts = {}
2for item in items:
3    counts[item] = counts.get(item, 0) + 1

1groups = {}
2for item in items:
3    key = item[0]  # or whatever grouping logic
4    groups.setdefault(key, []).append(item)

1a = {1, 2, 3, 4}
2b = {3, 4, 5, 6}
3a & b   # {3, 4}             — common
4a | b   # {1, 2, 3, 4, 5, 6} — all
5a - b   # {1, 2}             — only in a
6a ^ b   # {1, 2, 5, 6}       — not shared

1# Lambda = anonymous function
2lambda x: x[1]           # get index 1
3lambda x: -x[1]          # sort descending
4lambda x: (x[0], -x[1])  # multi-key: first asc, second desc
5
6# ⚠️ sorted uses key=, map does NOT
7sorted(data, key=lambda x: -x[1])    # ✅
8map(lambda x: x**2, data)            # ✅ NO key=

1sorted_rows = sorted(rows, key=lambda x: (-x[1], -x[2], x[0]))
2rank, prev = 1, None
3result = []
4for row in sorted_rows:
5    curr = (row[1], row[2])
6    if prev is not None and prev != curr:
7        rank += 1
8    result.append((rank, *row))
9    prev = curr

1for i, val in enumerate(lst):          # i=0,1,2...
2for i, val in enumerate(lst, start=1): # i=1,2,3...

1for a, b in zip(list1, list2):    # stops at SHORTER list
2    print(a, b)
3
4# Unzip:
5pairs = [(1,'a'), (2,'b')]
6nums, letters = zip(*pairs)  # (1,2), ('a','b')
7
8# Element-wise sum:
9[x + y for x, y in zip(a, b)]

 1# List
 2[x**2 for x in range(5)]                    # [0, 1, 4, 9, 16]
 3[x for x in data if x > 0]                  # filter
 4[x**2 for x in data if x % 2 == 0]          # filter + transform
 5
 6# Dict
 7{k: v for k, v in pairs}
 8{word: len(word) for word in words}
 9
10# Set
11{x for x in data if x > 0}
12
13# Nested (2D matrix)
14[[i*3+j for j in range(3)] for i in range(3)]

1filter(lambda x: abs(x) > threshold, changes)  # keep matching
2map(lambda x: x**2, values)                     # transform each
3sum(map(lambda x: x**2, filter(lambda x: x > 0, data)))  # chain
4
5# ⚠️ map() and filter() return iterators, wrap in list() to see contents
6list(map(lambda x: x*2, [1,2,3]))  # [2, 4, 6]

1from functools import reduce

 1from functools import reduce
 2
 3# Sum (same as sum())
 4reduce(lambda acc, x: acc + x, [1, 2, 3, 4])  # 10
 5
 6# Product
 7reduce(lambda acc, x: acc * x, [1, 2, 3, 4])  # 24
 8
 9# Max (same as max())
10reduce(lambda acc, x: acc if acc > x else x, [3, 1, 4, 1, 5])  # 5
11
12# With initial value
13reduce(lambda acc, x: acc + x, [1, 2, 3], 100)  # 106

 1from functools import partial, lru_cache
 2
 3# partial — pre-fill some arguments
 4add10 = partial(lambda x, y: x + y, 10)
 5add10(5)  # 15
 6
 7# lru_cache — memoization (cache results)
 8@lru_cache(maxsize=None)
 9def fib(n):
10    if n < 2: return n
11    return fib(n-1) + fib(n-2)

1import itertools

 1from itertools import combinations, permutations, chain, product, accumulate
 2
 3# combinations — choose k from n (order doesn't matter)
 4list(combinations([1,2,3], 2))
 5# [(1,2), (1,3), (2,3)]
 6
 7# permutations — arrange k from n (order matters)
 8list(permutations([1,2,3], 2))
 9# [(1,2), (1,3), (2,1), (2,3), (3,1), (3,2)]
10
11# chain — flatten multiple iterables into one
12list(chain([1,2], [3,4], [5]))
13# [1, 2, 3, 4, 5]
14
15# product — cartesian product (all combinations)
16list(product([1,2], ['a','b']))
17# [(1,'a'), (1,'b'), (2,'a'), (2,'b')]
18
19# accumulate — running totals (like prefix sum)
20list(accumulate([1, 2, 3, 4]))
21# [1, 3, 6, 10]
22
23# accumulate with custom function
24list(accumulate([3, 1, 4, 1, 5], max))
25# [3, 3, 4, 4, 5]  — running max!

 1def merge(l1, l2, comp=lambda x, y: x - y):
 2    i, j, out = 0, 0, []
 3    while i < len(l1) and j < len(l2):
 4        if comp(l1[i], l2[j]) <= 0:
 5            out.append(l1[i]); i += 1
 6        else:
 7            out.append(l2[j]); j += 1
 8    out.extend(l1[i:])
 9    out.extend(l2[j:])
10    return out

1L, R = 0, window - 1
2while R < len(data):
3    window_slice = data[L:R+1]
4    # process window
5    L += 1; R += 1

 1seen = set()
 2added = set()
 3duplicates = []
 4for x in lst:
 5    if x in seen:
 6        if x not in added:
 7            duplicates.append(x)
 8            added.add(x)
 9    else:
10        seen.add(x)

1counts = {}
2for word in text.lower().split():
3    counts[word] = counts.get(word, 0) + 1

1groups = {}
2for i, (x, y) in enumerate(points):
3    groups.setdefault(('row', y), []).append((i, x))

1import numpy as np

1np.array([1, 2, 3])              # from list
2np.zeros((3, 4))                 # 3x4 of zeros
3np.ones((2, 3))                  # 2x3 of ones
4np.arange(0, 10, 2)              # [0, 2, 4, 6, 8]
5np.linspace(0, 1, 5)             # [0, 0.25, 0.5, 0.75, 1.0]
6data.reshape(-1, 4)              # reshape, -1 = auto

1a[1:-1]            # exclude first and last
2a[:, np.newaxis]   # add dimension (for broadcasting)
3a[np.newaxis, :]   # add dimension at front
4a[a > 5]           # boolean indexing (filter)

1# Make (n,1,d) and (1,n,d) for pairwise comparison
2R = a[:, np.newaxis, :]   # shape (n, 1, d)
3C = a[np.newaxis, :, :]   # shape (1, n, d)
4diff = R - C               # shape (n, n, d) pairwise differences

 1np.abs(x)                  # element-wise absolute value
 2np.square(x)               # element-wise square
 3np.sqrt(x)                 # element-wise square root
 4np.sum(x, axis=0)          # sum along axis (0=rows, 1=cols, 2=depth)
 5np.mean(x, axis=0)         # mean along axis
 6np.dot(a, b.T)             # matrix multiplication
 7np.linalg.norm(a, axis=1)  # vector norms (per row)
 8np.outer(a, b)             # outer product
 9np.where(condition)        # indices where True
10np.argsort(a)              # indices that would sort the array
11np.argmax(a)               # index of max value

 1# ❌ For loop (slow)
 2result = []
 3for x in data:
 4    if x > threshold:
 5        result.append(x ** 2)
 6
 7# ✅ NumPy (fast, vectorized)
 8a = np.array(data)
 9mask = a > threshold
10result = a[mask] ** 2
11
12# ❌ For loop (pairwise distances)
13for i in range(n):
14    for j in range(n):
15        dist[i][j] = sum(abs(a[i] - a[j]))
16
17# ✅ NumPy (broadcasting)
18diff = a[:, np.newaxis, :] - a[np.newaxis, :, :]
19dist = np.sum(np.abs(diff), axis=2)

 1# Setup: a is (n, d) array
 2R = a[:, np.newaxis, :]
 3C = a[np.newaxis, :, :]
 4D = R - C
 5
 6# Manhattan: sum of |differences|
 7manhattan = np.sum(np.abs(D), axis=2)
 8
 9# Euclidean: sqrt(sum of squared differences)
10euclidean = np.sqrt(np.sum(np.square(D), axis=2))
11
12# Cosine: 1 - (dot / product of norms)
13dot_products = np.dot(a, a.T)
14norms = np.linalg.norm(a, axis=1)
15cosine_dist = 1 - dot_products / np.outer(norms, norms)

1x = np.array(values)
2lefts  = x[:-2]      # all except last 2
3currs  = x[1:-1]     # middle elements
4rights = x[2:]       # all except first 2
5scale = 1 + threshold
6peaks = np.where((currs > lefts * scale) & (currs > rights * scale))[0] + 1

1import re

1re.findall(pattern, text)    # all matches as list of strings
2re.match(pattern, text)      # match at START only → match object or None
3re.search(pattern, text)     # first match ANYWHERE → match object or None
4re.sub(pattern, repl, text)  # replace all matches
5
6match.group(0)               # full match
7match.group(1)               # first capture group (first parentheses)

 1# Extract all numbers
 2re.findall(r'\d+', "abc 123 def 456")  # ['123', '456']
 3
 4# Validate email-like pattern
 5re.match(r'^[\w.]+@[\w.]+\.\w+$', "user@mail.com")
 6
 7# Split on multiple delimiters
 8re.split(r'[,;\s]+', "a, b; c d")  # ['a', 'b', 'c', 'd']
 9
10# Replace with function
11re.sub(r'\d+', lambda m: str(int(m.group()) * 2), "a1b2c3")  # "a2b4c6"
12
13# Overlapping matches (lookahead trick)
14re.findall(r'(?=([A-Z]{2}\d+))', text)

 1# ❌ TRAP: same list reused across calls
 2def add(item, lst=[]):
 3    lst.append(item)
 4    return lst
 5add(1)  # [1]
 6add(2)  # [1, 2]  ← NOT [2]!
 7
 8# ✅ FIX:
 9def add(item, lst=None):
10    if lst is None:
11        lst = []
12    lst.append(item)
13    return lst

1a = [1, 2, 3]
2b = a          # SAME object! b IS a
3b.append(4)
4print(a)       # [1, 2, 3, 4] ← a changed too!
5
6# FIX: b = a[:] or b = a.copy() or b = list(a)

1lst = [10, 20, 30]
2lst[-1]    # 30 (last element) — NOT an error!
3# Always check index BEFORE accessing:
4if pointer == -1:
5    return None
6val = lst[pointer]

1x = 10
2def foo():
3    x = 5       # local x, global unchanged
4foo()
5print(x)        # 10
6
7# To modify global: use `global x` inside function

1a = [1, 2]
2b = [1, 2]
3a == b    # True  (same content)
4a is b    # False (different objects)

1# ❌ TRAP:
2matrix = [[]] * 3      # 3 refs to SAME list
3matrix[0].append(1)    # ALL change: [[1],[1],[1]]
4
5# ✅ FIX:
6matrix = [[] for _ in range(3)]  # 3 SEPARATE lists

1for i in range(5):
2    pass
3print(i)  # 4 ← i survives after the loop! (NOT block-scoped)

1# ❌ TRAP: removing while iterating
2lst = [1, 2, 3, 4, 5]
3for x in lst:
4    if x % 2 == 0:
5        lst.remove(x)  # Skips elements!
6
7# ✅ FIX: iterate over copy, or use comprehension
8lst = [x for x in lst if x % 2 != 0]

1import math