Python for AI work

Lesson preparation and outcomes

Prerequisites: Basic file editing; no API account.

By the end, you can: Trace a function, validate its inputs and return a typed error before any optional provider call.

Worked scenario and practice feedback

The offline greeter accepts a nonempty string. A new 101-character input must fail a declared 100-character cap. Check length after the blank-input guard; do not catch every exception and turn it into an apparently successful message.

Guided and independent practice: Predict outcomes for 0/1/100/101 characters, run the assertions, then independently add a non-string input.

Answer criteria: No invalid input produces normal output; exact run command and interpreter version recorded. If the local pack or interpreter is unavailable, trace the synthetic input, expected output and failure guard on paper; label execution unverified. Required practice uses no paid API calls, accounts, purchase, operational data or actual deployment.

Foundations made you AI-literate. Intermediate makes you AI-capable. The split between the two is a programming language, a testable application contract, and the willingness to read a stack trace. We start with Python.

Three honest disclaimers up front:

• You will not become a software engineer from this lesson. You will learn enough Python to make AI do useful work for you.
• We will skip a lot of “real CS.” No object-oriented theory. No data structures lecture. No Big-O. You can come back to those later if you decide to.
• The first time you write code, things will break. That is the work. Reading error messages and fixing them is half the skill of programming.

Part 1 Set up a clean Python environment.

If you already have Python and a virtual environment habit, skip this point. If you don’t, do this exactly.

Install Python

Go to python.org/downloads. Install the latest stable version (3.12 or newer is fine). On Windows, check the “Add Python to PATH” box during install. On macOS, the python.org installer is preferred over Homebrew for a clean default.

Verify in a terminal:

python --version
# Python 3.12.x

If you see python: command not found, your PATH isn’t set. Fix that before continuing.

Make a project folder + venv

A virtual environment provides a project-specific interpreter/package environment; it is not an operating-system security sandbox. It isolates installed packages but does not automatically pin versions, trust dependencies or block network access.

mkdir sd-tier02
cd sd-tier02
python -m venv .venv

# Activate (Mac/Linux):
source .venv/bin/activate

# Activate (Windows PowerShell):
.venv\Scripts\Activate.ps1

You’ll see (.venv) prepended to your shell prompt. That’s the signal that the venv is active. Every time you open a new terminal in this project, activate the venv again.

Part 2 The Python you'll actually use.

These are the constructs that show up in 90% of AI code. Burn them in.

Variables and types

name = "operator"          # string
score = 42                 # integer
pi = 3.14159               # float
done = True                # boolean
empty = None               # nothing

Python figures out the type from the value. No declarations.

Strings (and f-strings, the most useful syntax in the language)

who = "Operator"
greeting = f"Welcome back, {who}. You have {3} reps left."
# 'Welcome back, Operator. You have 3 reps left.'

The f prefix lets you embed expressions in { }. Every prompt-template you build will use this.

Lists, dicts, and how to access them

roles = ["medic", "comms", "logistics"]
roles[0]              # 'medic'
roles.append("intel") # adds to end

config = {"model": "claude-haiku-4-5", "max_tokens": 1024}
config["model"]       # 'claude-haiku-4-5'
config["temperature"] = 0.2

A list is ordered, accessed by index. A dict is a key→value map. Parsed JSON object payloads commonly become dictionaries. An SDK may instead return a typed response object accessed through attributes or its documented serialization method; inspect the actual interface before indexing it.

Loops

for r in roles:
    print(r)

for key, value in config.items():
    print(f"{key} = {value}")

Conditionals

if score >= 90:
    print("strong")
elif score >= 70:
    print("ok")
else:
    print("rework")

Functions

def summarize(text: str, max_words: int = 100) -> str:
    """Return a one-paragraph summary of the input."""
    # ... call AI here ...
    return "..."

result = summarize("Long text here.", max_words=50)

Type hints (str, int, -> str) are optional but encouraged. They’re documentation that the editor reads.

Try / except (read errors, don’t fear them)

try:
    response = call_the_api(prompt)
except TimeoutError:
    response = "API timed out. Try again."
except Exception as e:
    response = f"Something else went wrong: {e}"

You will see exceptions constantly. Reading them is the skill. The last line of a Python error message tells you what broke.

That’s the Python you need. Bookmark this section, come back to it.

Part 3 Packages: pip, requirements, dotenv.

Python’s standard library is rich, but the AI stack you’ll use lives in third-party packages. Installing them is one command.

Install with pip

pip install anthropic openai python-dotenv

pip is the package manager. You install once per venv. The packages drop into .venv/lib/....

Pin your dependencies

Write a requirements.txt:

anthropic==0.40.0
openai==1.55.0
python-dotenv==1.0.1

Anyone who clones your project runs pip install -r requirements.txt and requests the specified package versions; runtime, platform and transitive dependency resolution still affect reproducibility. Those version numbers are illustrative — they’ll be stale by the time you read this, so after you pip install, run pip freeze and pin whatever it actually shows. Version drift is a real source of bugs in AI work. Pin your versions.

Keep your API key out of code

Never paste your API key into a file you commit. Use a .env file at the project root:

ANTHROPIC_API_KEY=sk-ant-...your-key-here...
OPENAI_API_KEY=sk-...your-key-here...

Add .env to your .gitignore immediately. Then load it in code:

from dotenv import load_dotenv
import os

load_dotenv()
api_key = os.getenv("ANTHROPIC_API_KEY")

This pattern shows up in every AI codebase. It’s worth burning in.

Part 4 Run a complete offline input/result boundary.

Start with a standard-library script that returns a synthetic result. This teaches the same input/function/result boundary without a credential, network request, account, or charge. Save as hello.py and run python hello.py.

import json

def generate(prompt):
    if not isinstance(prompt, str) or not prompt.strip():
        return {"status": "error", "text": None, "error": "empty_input"}
    return {"status": "complete", "text": "Hello, learner.",
            "error": None, "usage": None, "request_id": "synthetic-01"}

result = generate("Greet the learner.")
assert result["status"] == "complete"
assert generate(" ")["error"] == "empty_input"
print(json.dumps(result))

A mock proves that your Python wiring works. It does not measure a model’s quality, latency, billing or availability. Lesson 02 explains the optional provider boundary, including complete, incomplete, refusal and error responses. Keep secrets out of source, printed exceptions and logs. A .env exclusion is useful but does not remove secrets from earlier Git history.

The earlier package and key patterns are reference instruction. The required drill uses no external packages or real API. If later authorized to use a provider, verify the exact SDK, model ID, supported parameters, account access and data policy in its official documentation; do not silently replace a missing model with another.

Interface/reference limits

Use the workflow reference to distinguish model capability, deployment and harness controls. Provider snippets in this lesson are illustrative, have not been executed against an actual provider in this revision, and require current SDK/model capability verification before separately authorized use.