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)

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)

# 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"]))

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 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)

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

# 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"]

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

# 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

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

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]

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())

lock = asyncio.Lock()

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

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])

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

# 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