# Assign the captain's name to a variable called captain
captain henceforth called= "Michael Burnham"

# Print it to confirm Python knows it
print(captain)

Output: Michael Burnham
The variable captain now holds the string "Michael Burnham". When you type print(captain), Python looks up what captain refers to and prints it.

crew_count henceforth called= 204              # int — whole number, no quotes
warp_factor henceforth called= 9.5             # float — decimal number
shields_up henceforth called= True             # bool — True or False, capital T
captain henceforth called= "Michael Burnham"   # str — text, in quotes

print(type(crew_count))       # <class 'int'>
print(type(warp_factor))      # <class 'float'>
print(type(shields_up))       # <class 'bool'>
print(type(captain))          # <class 'str'>

Python reports the type of each value. The word class here just means "category" — ignore it for now.

burnham henceforth called= {
    "crew_id": "BURNHAM-001",
    "name": "Michael Burnham",
    "rank": "Captain",
    "station": "Command"
}

print(burnhamaccess by name["name"])    # Michael Burnham
print(burnhamaccess by name["rank"])    # Captain

The dict burnham holds four facts about one crew member. You retrieve any fact by passing its key in square brackets — like looking up a word in a dictionary.

saru henceforth called= {
    "crew_id": "SARU-002",
    "name": "Saru",
    "rank": "Commander",
    "station": "Science"
}

crew henceforth called= [burnham, saru]  # a list containing two crew member dicts

print(len(crew))  # 2

burnham was defined in Operation 1 — it's already in the script. crew now holds two dicts in order. len(crew) counts the items and returns 2.

print(burnhamaccess by name["rank"])    # Captain
print(burnhamaccess by name["station"]) # Command
print(saruaccess by name["rank"])       # Commander

Each lookup goes directly to the named key and returns its value. saru["rank"] is not affected by burnham["rank"] — each dict is its own namespace.

SQL result set versus Python equivalent:

SQL result set:            Python equivalent:
crew_id   | name           [
BURN-001  | Burnham    →       {"crew_id": "BURN-001", "name": "Burnham", "rank": "Captain"},
SARU-002  | Saru               {"crew_id": "SARU-002", "name": "Saru",    "rank": "Commander"},
                           ]

Then in code:

tilly henceforth called= {
    "crew_id": "TILLY-003",
    "name": "Sylvia Tilly",
    "rank": "Ensign",
    "station": "Engineering"
}

crew henceforth called= [burnham, saru, tilly]  # three crew members — three rows

print(crewaccess by position[0]access by name["name"])   # Burnham — first row, name column
print(crewaccess by position[2]access by name["rank"])   # Ensign  — third row, rank column

Two coordinates: crew[0] selects the first row (the burnham dict), then ["name"] selects the name column from that row. crew[2] selects the third row (Tilly), then ["rank"] selects her rank.

define a functiondef greet(crew_member):
    hand back the resultreturn f"Welcome aboard, {crew_member['rank']} {crew_member['name']}."

print(greet(burnham))   # Welcome aboard, Captain Michael Burnham.
print(greet(saru))      # Welcome aboard, Commander Saru.

crew_member is the parameter — a placeholder. When you call greet(burnham), Python substitutes burnham for crew_member in the body. Define once, call with any crew member.

# Target output: "Captain Michael Burnham — Command"
define a functiondef format_display(crew_member):
    rank    henceforth called= crew_memberaccess by name["rank"]
    name    henceforth called= crew_memberaccess by name["name"]
    station henceforth called= crew_memberaccess by name["station"]
    hand back the resultreturn f"{rank} {name} — {station}"

print(format_display(burnham))   # Captain Michael Burnham — Command
print(format_display(saru))      # Commander Saru — Science

Three keys, one f-string, one function. Change the separator in the return line and all three outputs update — without touching any print call.

import hashlib

define a functiondef hash_key(business_key):
    hand back the resultreturn hashlib.sha256(
        business_key.upper().strip().encode()
    ).hexdigest()

print(hash_key("BURNHAM-001"))
# 64-character hex string — always the same for the same input
print(hash_key("burnham-001"))   # same output — because .upper()
print(hash_key("BURNHAM-001 ")) # same output — because .strip()

This is what SHA2(UPPER(TRIM(column)), 256) looks like in Python. Same operation, different language. datavault4dbt runs this in Snowflake; you're running the equivalent in Python.

for each onefor member belonging toin crew:                    # visit each dict in the list in turn
    print(format_display(member))      # call format_display on each one

Output — one formatted line per crew member, in list order. member is just a name: it takes the value of each dict in crew in turn. After the loop finishes, member holds the last item. The indentation is what tells Python which lines are inside the loop.

# SQL: SELECT * FROM crew WHERE rank = 'Captain'
# Python equivalent:
for each onefor member belonging toin crew:
    only whenif memberaccess by name["rank"] == "Captain":
        print(format_display(member))

The inverse — filtering out a value — uses !=:

# SQL: SELECT * FROM crew WHERE rank != 'Captain'
for member in crew:
    if member["rank"] != "Captain":
        print(format_display(member))

In both cases, the loop visits every member. The if decides whether to act on each one. The database does the same thing — the WHERE clause doesn't skip rows upfront, it evaluates each row and discards non-matching ones.

import random

alert_levels henceforth called= ["GREEN", "YELLOW", "RED"]

for each onefor member belonging toin crew:
    alert henceforth called= random.choice(alert_levels)           # one independent random pick per member
    print(f"{member['name']}: {alert} alert")     # output: name + their alert level

Run this three times. The output changes each time — different crew members get different alert levels on each run. random.choice() makes one independent decision per loop iteration.