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.