The Python Survival Guide I Built the Night Before My Assessment

https://ithiria894.github.io/python-field-manual/

You're staring at a timer counting down and your brain goes blank on how to sort a dict by value. This is for that moment.

Everything here is copy-paste ready. No fluff. Just patterns that show up in timed coding assessments over and over.

Dict

d = {}                            # create
d["key"] = "value"                # set
val = d["key"]                    # get (crashes if missing)
val = d.get("key")                # get (returns None if missing)
val = d.get("key", "default")    # get with default
del d["key"]                      # delete
"key" in d                        # check exists

# nested dict
d["user"] = {"balance": 0, "history": []}
d["user"]["balance"] += 100

# loop
for key, value in d.items():
    print(key, value)

List

lst = []                # create
lst.append(x)           # add to end
lst[0]                  # first element
lst[-1]                 # last element
lst[:n]                 # first n items (safe even if n > len)
len(lst)                # length
del lst[i]              # delete by index

for item in reversed(lst):    # loop backwards
    print(item)

Sorting

# basic
sorted(lst)                          # returns new sorted list
lst.sort()                           # sorts in place

# by custom key
sorted(lst, key=lambda x: x[1])      # sort by second element

# multi-criteria: score DESC, name ASC
sorted(items, key=lambda x: (-x[1], x[0]))

# sort dict items by value desc
sorted(d.items(), key=lambda x: -x[1])

# sort list of dicts
users.sort(key=lambda x: (-x["score"], x["name"]))

String

f"{name}({value})"              # format -> "alice(500)"
", ".join(["a", "b", "c"])      # join -> "a, b, c"
s.startswith("prefix")          # True/False
s.split("/")                    # split -> ["path", "to", "file"]
s.strip()                       # remove whitespace from ends

Class

class MySystem:
    def __init__(self):           # two underscores each side
        self.data = {}            # instance variable
        self.counter = 0

    def add(self, key, value):    # every method needs self
        self.data[key] = value

    def get(self, key):
        return self.data.get(key)

Auto-Increment ID

self.counter += 1
item_id = f"item{self.counter}"    # item1, item2, item3...

TTL / Expiry

# store with expiry
self.data[key] = {"value": val, "expiry": timestamp + ttl}

# check alive
entry = self.data[key]
if timestamp < entry["expiry"]:    # alive (exclusive boundary)
    return entry["value"]

Lazy Processing (Scheduled Events)

def _process_pending(self, timestamp):
    for item_id, item in self.pending.items():
        if not item["done"] and timestamp >= item["deadline"]:
            # do the thing
            item["done"] = True

def any_method(self, timestamp, ...):
    self._process_pending(timestamp)    # always first line
    # then do actual work

History Tracking

# append after every state change
acc["history"].append((timestamp, acc["balance"]))

# query historical value
for ts, val in reversed(acc["history"]):
    if ts <= target_time:
        return val

Deep Copy (Backup/Restore)

import copy
snapshot = copy.deepcopy(self.data)    # full independent copy
# changing snapshot won't affect self.data

Bisect (Binary Search in Sorted List)

import bisect

sorted_list = [10, 20, 30, 40, 50]
idx = bisect.bisect_right(sorted_list, 25)    # 2
bisect.insort(sorted_list, 25)                 # [10, 20, 25, 30, 40, 50]

asyncio

import asyncio

# make a function async
async def process(item):
    await asyncio.sleep(0.01)       # simulate I/O
    return item * 2

# run multiple tasks at once
async def main():
    results = await asyncio.gather(*[process(x) for x in items])

asyncio.run(main())

asyncio Lock (Protect Shared Data)

lock = asyncio.Lock()

async def safe_update(account, amount):
    async with lock:                # only one at a time
        account["balance"] += amount

asyncio Semaphore (Limit Concurrency)

sem = asyncio.Semaphore(3)          # max 3 concurrent

async def limited_task(item):
    async with sem:
        await do_work(item)

# all start but only 3 run at once
await asyncio.gather(*[limited_task(x) for x in items])

defaultdict

from collections import defaultdict

groups = defaultdict(list)       # missing key -> empty list
groups["team_a"].append("alice") # no need to check if key exists

counts = defaultdict(int)        # missing key -> 0
counts["errors"] += 1

Gotchas

# DON'T modify dict while iterating
for key in d:
    del d[key]           # RuntimeError!
# DO this instead
to_delete = [k for k in d if should_delete(k)]
for k in to_delete:
    del d[k]

# DON'T forget self
def method(account_id):          # WRONG, missing self
def method(self, account_id):    # RIGHT

# DON'T use dot on dicts
d.balance                        # WRONG (that's for classes)
d["balance"]                     # RIGHT

# DON'T confuse shallow and deep copy
copy_ref = original              # same object, not a copy!
import copy
real_copy = copy.deepcopy(original)   # independent copy

That's it. Bookmark this page. You'll need it at 3am.