Python Basics

terminal# 1. run a file
python first_call.py

# 2. a quick one-liner
python -c "print('hello agents')"

A .py file is just a list of instructions run top to bottom. Comments start with # and are ignored.

pythonmodel = "claude-opus-4-8"     # str  (text)
max_tokens = 1024             # int  (whole number)
temperature = 0.7            # float (decimal)
streaming = True              # bool (True / False)
result = None                 # None (absence of a value)

print(type(model))            # <class 'str'>

class _Any:
    '''stands in for any undefined demo value; supports call/attr/index/
    iteration and basic arithmetic (as 0.7) so demo snippets run.'''
    def __call__(self, *a, **k): return _Any()
    def __getattr__(self, k): return _Any()
    def __getitem__(self, k): return _Any()
    def __iter__(self): return iter([])
    def __len__(self): return 0
    def __contains__(self, o): return True
    def __enter__(self, *a): return _Any()
    def __exit__(self, *a): return False
    def __float__(self): return 0.7
    def __int__(self): return 1
    def __lt__(self, o): return True
    def __gt__(self, o): return False
    def __le__(self, o): return True
    def __ge__(self, o): return False
    def __add__(self, o): return o
    def __radd__(self, o): return o
    def __bool__(self): return True
    def __repr__(self): return 'demo'
    def __str__(self): return 'demo'
logs = _Any()

pythonpod = "checkout-api"
ns = "staging"

# f-string: prefix the quote with f, put variables in {curly braces}
msg = f"Pod {pod} in {ns} is crash-looping"
print(msg)          # Pod checkout-api in staging is crash-looping

# multi-line strings use triple quotes — used for system prompts
system = """You are a careful SRE.
Diagnose using read-only tools first."""

# handy string methods
"HELLO".lower()               # 'hello'
"  hi  ".strip()             # 'hi'  (trim whitespace)
"a,b,c".split(",")          # ['a', 'b', 'c']
"\n".join(["a", "b"])         # 'a\nb'  (glue a list into text)
"error" in logs             # True/False — substring check

pythonrestarts = 7
restarts > 5            # True
restarts == 0           # False  (== is "equals", = is "assign")
restarts != 0           # True   (!= is "not equal")

risk = "irreversible"
risk == "irreversible" and rung == "observe"   # combine with and / or / not
confidence < 0.6                                # route low-confidence to a human

MAX_STEPS = 5           # demo constant (a hard cap)
confidence = 0.7          # demo threshold value
done = False       # demo flag
pods = [
    {"id": "x1", "text": "demo one", "name": "api-7f9c", "status": "Running"},
    {"id": "x2", "text": "demo two", "name": "worker-2d", "status": "CrashLoopBackOff"},
]

python# if / elif / else — decisions
if confidence > 0.8:
    print("trust it")
elif confidence > 0.5:
    print("double-check")
else:
    print("send to human")

# for — do something for each item
for pod in pods:
    if pod["status"] == "CrashLoopBackOff":
        print(pod["name"])

# while — repeat until a condition changes (the agent loop!)
step = 0
while step < MAX_STEPS:      # a hard cap so it always ends
    step += 1
    if done:
        break                 # exit the loop early

pythondef get_logs(pod, namespace="staging", lines=20):
    # pod is required; namespace & lines have defaults
    return f"last {lines} log lines for {namespace}/{pod}"

get_logs("checkout-api")                    # uses the defaults
get_logs("checkout-api", "prod")            # positional args
get_logs("checkout-api", lines=50)         # keyword arg (clearer)

pythonin_tokens, out_tokens = 1240, 380

# operators
7 / 2          # 3.5   true division (always float)
7 // 2         # 3     floor division (drops the remainder)
7 % 2          # 1     modulo (remainder) — "every Nth item"
2 ** 10        # 1024  power

# the real API-cost formula (Opus: $5/1M in, $25/1M out)
cost = (in_tokens * 5 + out_tokens * 25) / 1_000_000   # underscores = readable numbers

# helpers you'll reach for
round(cost, 6)                 # round to 6 dp
sum([0.8, 0.9, 1.0]) / 3   # 0.9  — an average (eval pass rate)
min(30, retries * 2)        # cap a backoff delay
max(0.0, score)             # clamp a score to be non-negative
abs(a - b)                  # distance between two numbers

pythoncost = 0.0123456
score = 0.847
name = "checkout-api"

f"${cost:.4f}"          # '$0.0123'   — 4 decimal places
f"{score:.0%}"          # '85%'       — as a percentage
f"{name:20}"            # 'checkout-api        ' — pad to width 20 (left-align)
f"{name:>20}"           # right-align in width 20
f"{1240:,}"             # '1,240'     — thousands separator
f"{'PASS' if ok else 'FAIL'}"   # inline conditional inside an f-string

Illustrative fragment — defines demo values / files are needed before this runs standalone.

python# falsy: None, False, 0, 0.0, "" (empty str), [] (empty list), {} (empty dict)
# everything else is truthy

if not hits:                 # True when hits is [] — "no results"
    return "I don't have that information."

if results:                  # True only when the list is non-empty
    process(results)

# the None-safe pattern used all over the course:
text = next((b.text for b in resp.content if b.type == "text"), "")
#     ^ generator                                              ^ default if none found

# check for None explicitly with 'is' (not ==)
if runbook_ref is None:
    runbook_ref = "(none)"

# the "or default" shortcut
name = pod.get("name") or "unknown"   # falls back if None/empty

Illustrative fragment — defines demo values / files are needed before this runs standalone.

rag_store.pydef embed(texts):
    ...                       # importable by other files

class VectorStore:
    ...

if __name__ == "__main__":      # only runs on: python rag_store.py
    # a quick self-test / demo
    store = VectorStore(); store.add(load_corpus())
    for chunk, score in store.search("reset password", k=3):
        print(f"[{score:.3f}] {chunk['source']}")

Run directly → the demo runs. from rag_store import VectorStore in another file → only the function/class are imported, the demo does not run.

cost_tracker.py# in/out token prices per 1M tokens, by model
PRICES = {
    "claude-opus-4-8":  (5, 25),
    "claude-haiku-4-5": (1, 5),
}

def call_cost(model, in_tokens, out_tokens):
    in_price, out_price = PRICES[model]           # tuple unpack
    return (in_tokens * in_price + out_tokens * out_price) / 1_000_000

# pretend these came back from resp.usage on several calls
calls = [
    ("claude-opus-4-8", 1240, 380),
    ("claude-haiku-4-5", 600, 40),
    ("claude-opus-4-8", 8000, 1200),
]

def main():
    total = 0.0
    for model, tin, tout in calls:
        c = call_cost(model, tin, tout)
        total += c
        print(f"{model:18} in={tin:6,} out={tout:5,}  ${c:.5f}")
    print(f"{'TOTAL':18} {'':17}  ${total:.5f}")

if __name__ == "__main__":
    main()

claude-opus-4-8    in= 1,240 out=  380  $0.01570
claude-haiku-4-5   in=   600 out=   40  $0.00080
claude-opus-4-8    in= 8,000 out=1,200  $0.07000
TOTAL                                   $0.08650

Print 1..n, but multiples of 3 → "Fizz", of 5 → "Buzz", of both → "FizzBuzz". Tests clean control flow and operator precedence.

pythondef fizzbuzz(n):
    for i in range(1, n + 1):
        out = ""
        if i % 3 == 0: out += "Fizz"
        if i % 5 == 0: out += "Buzz"
        print(out or i)   # empty string is falsy -> print the number

Pop digits with %10 and build the reverse with *10. Tests number sense, not string tricks.

pythondef reverse_int(x):
    sign = -1 if x < 0 else 1
    x, out = abs(x), 0
    while x:
        out = out * 10 + x % 10   # append last digit
        x //= 10
    return sign * out