Python Basics

Python is the glue on your server

Everything behind your frontend — the app, the tooling, the scripts — is usually Python. You'll read it, judge it, and steer the AI that writes it.

You don't type — you recognize, ask, verify

AI writes the Python. Your skill is the three moves that make AI code trustworthy.

A .py file is just instructions, top to bottom

Variables store values in labelled boxes; print() shows them. That's the entire vocabulary of a beginner script.

# hi.py — a comment: Python ignores it, humans read it
name = "shipper"           # a variable: a labelled box

print("Hello, " + name)    # send text to the screen
print("Ready to build.")

That's a complete program: a variable and two print calls. Nothing else is required to start.

Variables — labelled boxes

A variable is a name pointing at a value. The name is the label; the value (and its type) can change.

Script mode & REPL mode

One command runs a whole file; the same command with no file opens the REPL (Read-Eval-Print Loop) — a live playground for testing one line at a time.

Errors are normal — read the bottom

Every Python error ends in a traceback: a stack of where you were, and the actual problem on the last line.

A traceback, in three moves

You'll paste these into the AI constantly. Knowing the three parts makes you fast at it.

str, int, float, bool — and the big two

You'll meet these in every backend. str/int/float/bool are the atoms; list & dict are how data is actually organized.

List & dict look like JSON — because they are

Every API response, config file and database row arrives as JSON. Python's list and dict read it natively — no translation layer.

# A list: ordered things
tasks = ["design", "code", "test", "ship"]

# A dict: labelled values (a record)
user = {
    "name": "An",
    "role": "designer",
    "active": True,
}

If you've seen JSON, you already know this: dict = the JSON object {…}, list = the JSON array […].

= versus ==

One is a verb, the other is a question. Confusing them is one of the most common things to catch in AI (and human) code.

Strings — text you can actually work with

Strings are the most common data in a web app. A handful of operations cover the daily work.

Reach in: indexes, lengths, comparisons

Data isn't only created — you reach into it. These three moves show up in almost every loop you'll ever read.

tasks = ["design", "code", "ship"]
print(len(tasks))         # 3
print(tasks[0])           # design — counting starts at 0
print("design" in tasks)  # True

age = 29
print(age > 18)           # True  ← a comparison makes a bool
print(age == 30)          # False

Counting starts at 0, so the first item is index 0 and the last is len − 1. Comparisons (>, <, ==) don't change anything — they produce True/False.

None — the honest 'nothing'

Between values and errors, Python has a third state: a legitimate absence.

if / elif / else

Don't memorize syntax — recognize the shape: a condition, a colon, an indented block.

score = 82

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
else:
    grade = "C"

print(grade)   # B

Python checks top to bottom and runs the first branch whose condition holds. else catches everything left. Indentation is the grouping — no braces.

for — walking a collection

The workhorse loop: give it any collection, it hands you the items one at a time.

for task in ["design", "code", "ship"]:
    print(task)

for i in range(3):        # range(3) → 0, 1, 2
    print(i)

for walks any collection, one item at a time — a list, or the range(n) 'count from 0' collection. Most loops in real code are for-loops.

while — repeat while it holds

The loop you must control: it runs as long as the condition stays true.

retries = 3
while retries > 0:
    print("retrying...")
    retries = retries - 1    # runs 3 times

You must move the condition toward false inside the loop. If you forget — infinite loop, and the server stops answering. for handles most jobs; while is the careful one.

and, or, not — combining checks

Real conditions are rarely a single comparison. Three words combine them into English-like tests.

def — the unit of reuse

A function packages a task: name it, give it inputs, get a result back. Call it as often as you like.

def greet(name):              # define: a reusable recipe
    return f"Hello, {name}!"

print(greet("An"))    # Hello, An!   ← call it
print(greet("You"))   # Hello, You!  ← call again

def names the recipe, arguments (name) are the inputs, return hands back the result. The f"…" string inside is the next slide.

f-strings & comments

The two smallest but most visible constructs — you'll spot them on line one of almost every file.

Working with lists & dicts

Three moves cover most of the daily work: grow a list, read a dict safely, loop over things.

tasks = ["design", "code"]
tasks.append("ship")           # grow the list

user = {"name": "An", "role": "designer"}
print(user["name"])            # An
print(user.get("email"))       # None — safe if missing

for t in tasks:                 # loop over items
    print(t)

d["key"] crashes if the key is missing; d.get("key") calmly returns None. Prefer .get() when the key is uncertain — most AI bugs come from missing keys.

The list & dict operations you'll see most

Six operations cover the daily work. All of them are methods: data.method().

Reading a file, at a glance

Files are how a program remembers things between runs — configs, data, logs. The shape below appears in almost every backend you'll touch.

with open("tasks.txt") as f:    # open, and close for you
    for line in f:               # a file is a list of lines
        print(line.strip())      # remove the newline

open() hands you a file handle; with guarantees it's closed. Line by line, a file is just a list of strings.

Writing a file — the mode letter

Same open/with shape as reading; the only difference is one letter: the mode.

with open("out.txt", "w") as f:      # w = write, erases first
    f.write("task: design\n")

with open("out.txt", "a") as f:      # a = append, keeps existing
    f.write("task: ship\n")

w starts fresh, a adds on. This is exactly how apps write logs and save data — the same shape you've just learned for reading.

import — pulling in toolboxes

You don't build everything yourself. One line brings in a whole toolbox — Python ships with a huge standard library.

try / except — fail gracefully

Real data is messy: missing keys, empty files, bad input. Programs that handle it keep running.

try:
    value = user["email"]
except KeyError:
    value = "no email"

print(value)

try: attempt the risky part; except: if it fails, do this instead. Programs degrade gracefully instead of crashing — you'll see this around every data read.

One file, every pattern

Nothing new here — just the deck's pieces in one place. Read it top to bottom; you already know every line's job.

import json

def summary(raw):
    users = json.loads(raw)      # JSON string -> list of dicts
    active = 0
    for u in users:
        if u.get("active"):
            active = active + 1
    return f"{active} of {len(users)} active"

raw = '[{"name": "An", "active": True}]'
print(summary(raw))              # 1 of 1 active

import, def, json.loads, for, if, .get, len, f-string — the whole vocabulary of this deck, doing real work in twelve lines.

Your Flask app is just these pieces

Now look at this course's own app: a .py file with functions, dicts, files and JSON. Every piece on this slide is in that app.

Reading & tweaking code with AI

The daily loop of this course: you and the AI, one code block at a time.

1. 1

   Scan the shapes

   Before asking anything, look for the patterns: def, for, if, dict, open. You already know what each one is for.

2. 2

   Ask line by line

   Paste a block and ask 'explain this in simple words.' Compare the AI's answer with your own read — that gap is where learning happens.

3. 3

   Point, don't dump

   Tweaks work best with a target: 'change this function to also check the email key.' Specifics in, specific changes out.

4. 4

   Run & check the output

   After any change, run it and look at what it prints or serves. Output right → shape right. Output wrong → paste it back and repeat.