Lesson 12: Everything Connected to Everything

Part 1

The Problem With Lists

Lists are great for ordered collections — a playlist, a to-do list, a series of scores. But what happens when you need to look something up by name?

Imagine storing info about a game character:

# Storing character info in lists... it works but it's clunky
names = ["health", "attack", "defense", "speed"]
values = [100, 25, 15, 30]

# To find health, I need to know it's at position 0
print("Health:", values[0])

# What if I forget the order? What if I add more stats?
# Was defense at position 2 or 3? 😰

# This gets confusing fast with 20+ properties

Remembering that health is at position 0, attack at position 1... that's fragile and confusing. What we really want is to look things up by name: "give me the health value." Python has the perfect tool for this.

Part 2

Dictionaries: Names → Values

A dictionary connects keys (names) to values. Instead of looking things up by position number, you look them up by name:

# A dictionary: keys connected to values
character = {
    "name": "Shadow",
    "health": 100,
    "attack": 25,
    "defense": 15,
    "speed": 30
}

# Look things up by name — so much clearer!
print("Character:", character["name"])
print("Health:", character["health"])
print("Attack:", character["attack"])

How Dictionaries Work

Curly braces {} create a dictionary. Inside: "key": value pairs, separated by commas.

character["health"] looks up the value connected to the key "health" — gives us 100.

Unlike lists, there are no position numbers. You access things by name. "health" could be the first item or the last — it doesn't matter.

Think of it like a real dictionary: you look up the word (key) and find its definition (value).

Part 3

Adding, Changing, and Removing

character = {"name": "Shadow", "health": 100, "attack": 25}

print("Before:", character)
print()

# Change a value
character["health"] = 80
print("After taking damage:", character["health"])

# Add a new key-value pair
character["magic"] = 50
print("Added magic:", character)

# Remove a key-value pair
del character["attack"]
print("Removed attack:", character)

# Check if a key exists
if "magic" in character:
    print("This character has magic!")

if "defense" not in character:
    print("No defense stat found.")

Dictionary Operations

character["health"] = 80 — change an existing value

character["magic"] = 50 — add a new key-value pair (if the key doesn't exist, it's created)

del character["attack"] — remove a key and its value

"magic" in character — check if a key exists (True/False)

Part 4

Looping Through a Dictionary

character = {
    "name": "Shadow",
    "health": 100,
    "attack": 25,
    "defense": 15,
    "speed": 30
}

# Loop through keys only
print("Stats available:")
for key in character:
    print(f"  - {key}")

print()

# Loop through keys AND values
print("Full character sheet:")
print("═" * 25)
for key, value in character.items():
    print(f"  {key:10s} → {value}")
print("═" * 25)

Looping Options

for key in character: — loops through just the keys

for key, value in character.items(): — loops through both keys and values at the same time

character.keys() — all the keys as a list

character.values() — all the values as a list

Part 5

Nesting Dictionaries

Here's where dictionaries get really powerful: a value inside a dictionary can be another dictionary. This lets you model complex, real-world relationships:

# A dictionary of friends, each with their own details
friends = {
    "Lena": {
        "age": 11,
        "hobby": "soccer",
        "level": 9
    },
    "Sam": {
        "age": 12,
        "hobby": "robotics",
        "level": 7
    },
    "Zoe": {
        "age": 11,
        "hobby": "coding",
        "level": 8
    }
}

# Access nested data
print(f"Lena's hobby: {friends['Lena']['hobby']}")
print(f"Sam's age: {friends['Sam']['age']}")
print()

# Loop through all friends
for name, info in friends.items():
    bar = "█" * info["level"] + "░" * (10 - info["level"])
    print(f"  {name:8s} Age {info['age']} | {info['hobby']:8s} | {bar} {info['level']}/10")

Reading Nested Dictionaries

friends["Lena"] gives us Lena's whole dictionary: {"age": 11, "hobby": "soccer", "level": 9}

friends["Lena"]["hobby"] goes one level deeper: "soccer"

Think of it as drilling down: "In the friends dictionary, find Lena. In Lena's dictionary, find hobby." Each pair of square brackets goes one level deeper.

Part 6

Modeling the Game Data

Now let's use dictionaries to build a "Would You Rather?" game. First, we need to model the data — each question has two options, a category, and a difficulty:

# Each question is a dictionary with structured data
questions = [
    {
        "option_a": "Be able to fly",
        "option_b": "Be able to read minds",
        "category": "superpowers",
        "difficulty": "easy"
    },
    {
        "option_a": "Live in the future",
        "option_b": "Live in the past",
        "category": "deep",
        "difficulty": "medium"
    },
    {
        "option_a": "Never eat pizza again",
        "option_b": "Never eat ice cream again",
        "category": "food",
        "difficulty": "hard"
    },
    {
        "option_a": "Be the funniest person alive",
        "option_b": "Be the smartest person alive",
        "category": "deep",
        "difficulty": "medium"
    }
]

# Show all questions
for i, q in enumerate(questions):
    print(f"Q{i + 1} [{q['category']}] ({q['difficulty']})")
    print(f"   A: {q['option_a']}")
    print(f"   B: {q['option_b']}")
    print()

Lists of Dictionaries

questions is a list where each item is a dictionary. This is a very common pattern — it's how most real data is organized.

enumerate(questions) gives both the index number and the item, so we can number them.

Each question has the same structure (option_a, option_b, category, difficulty) but different content. That's data modeling — choosing what properties matter and keeping them consistent.

Part 7

Tracking Choices

A game is more fun when it tracks what people pick. Let's use a dictionary to count votes:

question = {
    "option_a": "Be able to fly",
    "option_b": "Be able to read minds"
}

# Track votes using a dictionary
votes = {"A": 0, "B": 0}

print("WOULD YOU RATHER...")
print(f"  A: {question['option_a']}")
print(f"  B: {question['option_b']}")
print()

# Simulate collecting votes from multiple players
num_players = int(input("How many players? "))

for i in range(num_players):
    choice = input(f"Player {i + 1}, choose A or B: ").upper()
    if choice in votes:
        votes[choice] = votes[choice] + 1
    else:
        print("  (Invalid, skipping)")

# Show results
total = votes["A"] + votes["B"]
if total > 0:
    pct_a = int(votes["A"] / total * 100)
    pct_b = int(votes["B"] / total * 100)
    
    print()
    print("RESULTS:")
    print(f"  A: {'█' * (pct_a // 5)}{'░' * (20 - pct_a // 5)} {pct_a}% ({votes['A']} votes)")
    print(f"  B: {'█' * (pct_b // 5)}{'░' * (20 - pct_b // 5)} {pct_b}% ({votes['B']} votes)")

Part 8

The Complete "Would You Rather?" Game

import random

# === QUESTION DATABASE ===

questions = [
    {"a": "Be able to fly", "b": "Be invisible", "cat": "superpowers", "diff": "easy"},
    {"a": "Be able to read minds", "b": "Be able to teleport", "cat": "superpowers", "diff": "easy"},
    {"a": "Live in the future", "b": "Live in the past", "cat": "deep", "diff": "medium"},
    {"a": "Be the funniest person", "b": "Be the smartest person", "cat": "deep", "diff": "medium"},
    {"a": "Never eat pizza again", "b": "Never eat ice cream again", "cat": "food", "diff": "hard"},
    {"a": "Only eat sweet food", "b": "Only eat salty food", "cat": "food", "diff": "hard"},
    {"a": "Have a pet dragon", "b": "Have a pet unicorn", "cat": "funny", "diff": "easy"},
    {"a": "Always speak in rhymes", "b": "Always speak in questions", "cat": "funny", "diff": "medium"},
    {"a": "Know every language", "b": "Play every instrument", "cat": "deep", "diff": "medium"},
    {"a": "Live without music", "b": "Live without movies", "cat": "hard", "diff": "hard"},
]

# === DISPLAY FUNCTIONS ===

def header(text, char="═", width=40):
    print(char * width)
    print(f"  {text}")
    print(char * width)

def show_bar(label, count, total, width=15):
    if total == 0:
        pct = 0
    else:
        pct = int(count / total * 100)
    fill = int(pct / 100 * width)
    bar = "█" * fill + "░" * (width - fill)
    print(f"  {label}: {bar} {pct}% ({count})")

# === MAIN GAME ===

header("🤔 WOULD YOU RATHER?")
print()

player_name = input("Your name: ")
print()

# Game settings
print("How many questions?")
num_q = int(input("(1-" + str(len(questions)) + "): "))
num_q = min(num_q, len(questions))

# Pick random questions
random.shuffle(questions)
game_questions = questions[:num_q]

# Track player stats
stats = {
    "total": 0,
    "chose_a": 0,
    "chose_b": 0,
    "categories": {}
}

# Play!
print()
for i, q in enumerate(game_questions):
    print(f"─── Question {i + 1} of {num_q} [{q['cat']}] ───")
    print()
    print(f"  Would you rather...")
    print(f"  A: {q['a']}")
    print(f"  B: {q['b']}")
    print()
    
    choice = input("  Your choice (A/B): ").upper()
    while choice not in ["A", "B"]:
        choice = input("  Please pick A or B: ").upper()
    
    stats["total"] = stats["total"] + 1
    
    if choice == "A":
        stats["chose_a"] = stats["chose_a"] + 1
        print(f"  → You chose: {q['a']}")
    else:
        stats["chose_b"] = stats["chose_b"] + 1
        print(f"  → You chose: {q['b']}")
    
    # Track category picks
    cat = q["cat"]
    if cat not in stats["categories"]:
        stats["categories"][cat] = 0
    stats["categories"][cat] = stats["categories"][cat] + 1
    
    print()

# === RESULTS ===

header(f"📊 {player_name.upper()}'S RESULTS")
print()

print(f"  Questions answered: {stats['total']}")
print()

show_bar("Chose A", stats["chose_a"], stats["total"])
show_bar("Chose B", stats["chose_b"], stats["total"])

print()
print("  Categories played:")
for cat, count in stats["categories"].items():
    print(f"    {cat}: {count} question{'s' if count != 1 else ''}")

print()

# Fun analysis
if stats["chose_a"] > stats["chose_b"]:
    print(f"  💡 {player_name} tends to pick Option A!")
    print("     You might be drawn to the first thing you hear.")
elif stats["chose_b"] > stats["chose_a"]:
    print(f"  💡 {player_name} tends to pick Option B!")
    print("     You take time to consider alternatives.")
else:
    print(f"  💡 {player_name} is perfectly balanced!")
    print("     You weigh both options equally.")

print()
header("Thanks for playing!", char="─")

Part 9

The Art of Data Modeling

What you just did — deciding how to structure the question data, the vote tracking, the player stats — is called data modeling. It's one of the most important skills in programming.

Data modeling means asking: "What are the things in my problem? What properties do they have? How do they connect?"

Data Modeling Decisions We Made

A question has: two options, a category, a difficulty → dictionary with 4 keys

A collection of questions → list of dictionaries

Player stats has: total answers, A-count, B-count, categories → nested dictionary

Vote results for a question → dictionary {"A": count, "B": count}

Different problems need different models. A contact list might be a dictionary of names → phone numbers. A game inventory might be a dictionary of item names → quantities. A social network might be a dictionary of people → lists of their friends.

# Model 1: Contact list (name → number)
contacts = {
    "Mom": "555-0101",
    "Lena": "555-0202",
    "Pizza Place": "555-0303"
}
print("Mom's number:", contacts["Mom"])

# Model 2: Inventory (item → count)
inventory = {
    "health_potion": 3,
    "sword": 1,
    "gold_coin": 47
}
inventory["health_potion"] = inventory["health_potion"] - 1
print(f"Potions left: {inventory['health_potion']}")

# Model 3: Social network (person → list of friends)
network = {
    "Lena": ["Sam", "Zoe", "Arielle"],
    "Sam": ["Lena", "Aidan"],
    "Zoe": ["Lena", "Arielle"]
}
print(f"Lena's friends: {network['Lena']}")
print(f"Lena has {len(network['Lena'])} friends")

# Check if two people are friends
if "Sam" in network["Lena"]:
    print("Lena and Sam are connected!")

Each model captures different relationships. Contacts connect names to numbers. Inventory connects items to quantities. A social network connects people to lists of other people. The dictionary is flexible enough to model all of them.

Part 10

What You Just Did

You learned to model real-world relationships using dictionaries — connecting names to values, objects to properties, and ideas to details. You built a game where data is structured, tracked, and analyzed.

That's data modeling.

Every app you use relies on data modeling. Instagram models posts (image + caption + likes + comments). Spotify models songs (title + artist + duration + album). Games model characters (stats + inventory + position). The model determines what the app can do — because you can only work with data you've structured.

The Big Idea

Before you write code, ask: "What are the things in my problem? What properties do they have? How are they connected?" Choose the right structure — lists for ordered collections, dictionaries for named lookups, nested combinations for complex relationships — and the code almost writes itself.

Thinking Questions

When would you use a list vs. a dictionary? What's the key difference in how you access items?
If you were building a library system, what would you model? What would the dictionaries look like?
Why is choosing the right data model important before you start coding?

Challenges

Level Up

Challenge 1 · Pokédex

Create a dictionary of at least 5 creatures, each with name, type, health, and attack power. Let the user search by name and display the creature's stats. Add a "battle" feature that compares two creatures' attack power.

Challenge 2 · Multi-Player Voting

Expand the "Would You Rather?" game to support multiple players. Track each player's choices in a dictionary: {"Lena": ["A", "B", "A"], "Sam": ["B", "B", "A"]}. At the end, show where players agreed and disagreed.

Challenge 3 · Inventory System

Build a game inventory where the player can: view items, add items, use items (decrease count), and drop items (remove entirely). Use a dictionary to store item names and counts. Add item categories (weapon, food, tool) using nested dictionaries.

Summary

What You Learned

Thinking Skill

Data Modeling — representing real-world things and relationships in code by asking: "What are the essential properties, and how do they connect?"

Python Concepts

Dictionaries — {"key": value} for named lookups

Access — dict["key"] to get a value

Modify — dict["key"] = new_value

Add — dict["new_key"] = value

Delete — del dict["key"]

Check existence — "key" in dict

Loop — for key, value in dict.items():

Nested dictionaries — dictionaries inside dictionaries

Lists of dictionaries — a common pattern for structured data

enumerate() — loop with both index and item

.get(key, default) — safe lookup with a fallback value

Everything Connected to Everything: Mapping Relationships Like a Detective