Lesson 10: The Assembly Line in Your Head

Part 1

Everything Is a Pipeline

Think about how a sandwich shop works. One person takes your order. Another slices the bread. Another adds the fillings. Another wraps it up. Each person does one job, then passes the result to the next person.

No single person makes the whole sandwich. Instead, the sandwich flows through a pipeline — a series of steps where each step transforms it a little and passes it along.

You think like this all the time. When someone asks "Is this a good day for a bike ride?" your brain runs a pipeline:

Check weather → Check energy level → Check if bike has air → Check schedule → Combine into a decision

Each step produces a result, and that result feeds into the next step. In code, this means the output of one function becomes the input of another. Today, we're going to master this technique — and use it to build a Friendship Score Calculator.

Part 2

Connecting Functions Together

We already know how to make functions that return values. The key insight is: you can use a function's return value anywhere you'd use a normal value.

# Step 1: A function that cleans up text
def clean(text):
    return text.strip().lower()

# Step 2: A function that scores text length
def score_length(text):
    if len(text) > 20:
        return 3
    elif len(text) > 10:
        return 2
    else:
        return 1

# Chain them: clean FIRST, then score the RESULT
raw_input = "  HELLO THERE FRIEND  "
cleaned = clean(raw_input)
score = score_length(cleaned)

print(f"Raw:     '{raw_input}'")
print(f"Cleaned: '{cleaned}'")
print(f"Score:   {score}")

The Chain

Raw text → clean() → cleaned text → score_length() → score

Each function does one small job. The output of clean() becomes the input of score_length().

You can even write it in one line: score = score_length(clean(raw_input)). Python reads from the inside out — it runs clean() first, then passes the result to score_length().

def clean(text):
    return text.strip().lower()

def score_length(text):
    return 3 if len(text) > 20 else 2 if len(text) > 10 else 1

# Chained in one line!
print(score_length(clean("  HELLO THERE FRIEND  ")))

Part 3

Breaking a Complex Problem Into Steps

Let's think about the Friendship Score Calculator. How do you rate a friendship? It's complex — there's no single number. But we can decompose it into measurable parts:

Friendship Score Components

Responsiveness — how quickly do they text back?

Generosity — do they share snacks, help with homework?

Fun Factor — how much fun do you have together?

Reliability — can you count on them?

Each component gets its own function. Then we chain them together into a final score. Let's build each one:

def score_responsiveness(reply_speed):
    """Score based on typical reply time."""
    if reply_speed == "instant":
        return 10
    elif reply_speed == "minutes":
        return 8
    elif reply_speed == "hours":
        return 5
    elif reply_speed == "days":
        return 2
    else:
        return 0

def score_generosity(shares_snacks, helps_homework):
    """Score based on sharing behavior."""
    score = 0
    if shares_snacks == "yes":
        score = score + 5
    if helps_homework == "yes":
        score = score + 5
    return score

def score_fun(fun_rating):
    """Convert 1-5 fun rating to 0-10 scale."""
    return fun_rating * 2

def score_reliability(keeps_promises):
    """Score based on reliability."""
    if keeps_promises == "always":
        return 10
    elif keeps_promises == "usually":
        return 7
    elif keeps_promises == "sometimes":
        return 4
    else:
        return 1

# Test each one individually
print("Responsiveness (instant):", score_responsiveness("instant"))
print("Generosity (yes, yes):", score_generosity("yes", "yes"))
print("Fun (4 out of 5):", score_fun(4))
print("Reliability (usually):", score_reliability("usually"))

Each function handles one piece of the puzzle. They're simple on their own — the power comes from combining them.

Part 4

The Combining Function

Now we need a function that takes all the individual scores and combines them into one final rating. This is the end of the pipeline:

def calculate_total(responsiveness, generosity, fun, reliability):
    """Combine four scores into a final friendship rating."""
    total = responsiveness + generosity + fun + reliability
    max_possible = 40  # each category maxes at 10
    percentage = int((total / max_possible) * 100)
    return percentage

def get_title(percentage):
    """Turn a percentage into a friendship title."""
    if percentage >= 90:
        return "🏆 Legendary Best Friend"
    elif percentage >= 75:
        return "⭐ Solid Gold Friend"
    elif percentage >= 60:
        return "👍 Good Buddy"
    elif percentage >= 40:
        return "🤝 Casual Friend"
    else:
        return "👋 Acquaintance"

# Test the pipeline
score = calculate_total(10, 8, 6, 7)
title = get_title(score)
print(f"Score: {score}%")
print(f"Title: {title}")

See the pipeline? Individual scores → calculate_total() → percentage → get_title() → label. Each function does one transformation.

Part 5

Visualizing the Flow

Let's add a display function and trace how data flows through the entire system:

def score_responsiveness(speed):
    scores = {"instant": 10, "minutes": 8, "hours": 5, "days": 2}
    return scores.get(speed, 0)

def score_generosity(snacks, homework):
    return (5 if snacks == "yes" else 0) + (5 if homework == "yes" else 0)

def score_fun(rating):
    return rating * 2

def score_reliability(keeps_promises):
    scores = {"always": 10, "usually": 7, "sometimes": 4}
    return scores.get(keeps_promises, 1)

def combine(r, g, f, rel):
    return int(((r + g + f + rel) / 40) * 100)

def get_title(pct):
    if pct >= 90: return "🏆 Legendary Best Friend"
    elif pct >= 75: return "⭐ Solid Gold Friend"
    elif pct >= 60: return "👍 Good Buddy"
    elif pct >= 40: return "🤝 Casual Friend"
    else: return "👋 Acquaintance"

def make_bar(val, max_val=10, width=10):
    fill = int((val / max_val) * width)
    return "█" * fill + "░" * (width - fill)

# TRACE THE PIPELINE
print("PIPELINE TRACE")
print("═" * 40)
r = score_responsiveness("minutes")
print(f"  1. Responsiveness: 'minutes' → {r}/10 {make_bar(r)}")
g = score_generosity("yes", "no")
print(f"  2. Generosity:     yes/no    → {g}/10 {make_bar(g)}")
f = score_fun(4)
print(f"  3. Fun factor:     4/5       → {f}/10 {make_bar(f)}")
rel = score_reliability("usually")
print(f"  4. Reliability:    'usually' → {rel}/10 {make_bar(rel)}")
print()
pct = combine(r, g, f, rel)
print(f"  5. Combined score: {pct}%")
title = get_title(pct)
print(f"  6. Final title:    {title}")

The Pipeline

Raw answers → 4 scoring functions → 4 individual scores → combine function → percentage → title function → label

Each step is simple. But chained together, they create something sophisticated — a system that takes messy human input and produces a clear, meaningful output.

This is systems thinking — understanding how independent parts work together in sequence, where each part transforms information before passing it on.

Part 6

The Master Function

We can wrap the entire pipeline in one "master" function that orchestrates everything:

def score_responsiveness(speed):
    return {"instant": 10, "minutes": 8, "hours": 5, "days": 2}.get(speed, 0)

def score_generosity(snacks, homework):
    return (5 if snacks == "yes" else 0) + (5 if homework == "yes" else 0)

def score_fun(rating):
    return min(rating * 2, 10)

def score_reliability(promises):
    return {"always": 10, "usually": 7, "sometimes": 4}.get(promises, 1)

def combine(scores):
    return int((sum(scores) / (len(scores) * 10)) * 100)

def get_title(pct):
    if pct >= 90: return "🏆 Legendary Best Friend"
    elif pct >= 75: return "⭐ Solid Gold Friend"
    elif pct >= 60: return "👍 Good Buddy"
    elif pct >= 40: return "🤝 Casual Friend"
    else: return "👋 Acquaintance"

# THE MASTER FUNCTION — orchestrates the whole pipeline
def rate_friendship(speed, snacks, homework, fun, promises):
    """Run the complete friendship scoring pipeline."""
    scores = [
        score_responsiveness(speed),
        score_generosity(snacks, homework),
        score_fun(fun),
        score_reliability(promises)
    ]
    percentage = combine(scores)
    title = get_title(percentage)
    return scores, percentage, title

# Use it — one call does everything!
scores, pct, title = rate_friendship("minutes", "yes", "yes", 4, "usually")
print(f"Scores: {scores}")
print(f"Overall: {pct}%")
print(f"Rating: {title}")

New Things

sum(scores) adds up all the numbers in a list. So sum([8, 10, 8, 7]) gives 33.

min(value, 10) caps a value at 10 — if someone rates fun as 6, 6 * 2 = 12, but min(12, 10) keeps it at 10.

scores, pct, title = rate_friendship(...) — a function can return multiple values! Python unpacks them into separate variables.

The master function rate_friendship() doesn't do any scoring itself — it just calls the right functions in the right order. It's the conductor of the orchestra.

Part 7

Comparing Friends

Now that the pipeline is wrapped in one function, we can easily run it for multiple friends and compare:

def score_responsiveness(speed):
    return {"instant": 10, "minutes": 8, "hours": 5, "days": 2}.get(speed, 0)

def score_generosity(snacks, homework):
    return (5 if snacks == "yes" else 0) + (5 if homework == "yes" else 0)

def score_fun(rating):
    return min(rating * 2, 10)

def score_reliability(promises):
    return {"always": 10, "usually": 7, "sometimes": 4}.get(promises, 1)

def combine(scores):
    return int((sum(scores) / (len(scores) * 10)) * 100)

def get_title(pct):
    if pct >= 90: return "🏆 Legendary"
    elif pct >= 75: return "⭐ Solid Gold"
    elif pct >= 60: return "👍 Good Buddy"
    elif pct >= 40: return "🤝 Casual"
    else: return "👋 Acquaintance"

def make_bar(pct, width=15):
    fill = int((pct / 100) * width)
    return "█" * fill + "░" * (width - fill)

def rate_friendship(speed, snacks, homework, fun, promises):
    scores = [score_responsiveness(speed), score_generosity(snacks, homework),
              score_fun(fun), score_reliability(promises)]
    pct = combine(scores)
    return pct, get_title(pct)

# Rate several friends
friends = {
    "Lena":   ("instant", "yes", "yes", 5, "always"),
    "Sam":    ("hours", "yes", "no", 4, "usually"),
    "Zoe": ("minutes", "no", "yes", 3, "sometimes"),
    "Arielle": ("minutes", "yes", "yes", 4, "usually"),
}

print("FRIENDSHIP SCOREBOARD")
print("═" * 45)
print()

results = []
for name, data in friends.items():
    pct, title = rate_friendship(*data)
    results.append((name, pct, title))

# Sort by score (highest first)
results.sort(key=lambda x: x[1], reverse=True)

for rank, (name, pct, title) in enumerate(results, 1):
    bar = make_bar(pct)
    print(f"  {rank}. {name:8s} {bar} {pct}% {title}")

print()
print("═" * 45)

New Things

friends.items() loops through a dictionary giving you both the key (name) and value (data) each time.

rate_friendship(*data) — the * "unpacks" a tuple so each item becomes a separate argument. ("instant", "yes", "yes", 5, "always") becomes five separate values.

results.sort(key=lambda x: x[1], reverse=True) sorts the results by the score (position 1) from highest to lowest. Don't worry about the lambda syntax yet — just know it tells Python which value to sort by.

Part 8

The Complete Friendship Score Calculator

import random

# === SCORING FUNCTIONS (the pipeline pieces) ===

def score_responsiveness(speed):
    return {"instant": 10, "minutes": 8, "hours": 5, "days": 2}.get(speed, 0)

def score_generosity(snacks, homework):
    return (5 if snacks == "yes" else 0) + (5 if homework == "yes" else 0)

def score_fun(rating):
    return min(rating * 2, 10)

def score_reliability(promises):
    return {"always": 10, "usually": 7, "sometimes": 4}.get(promises, 1)

# === COMBINING FUNCTIONS ===

def combine(scores):
    return int((sum(scores) / (len(scores) * 10)) * 100)

def get_title(pct):
    if pct >= 90: return "🏆 Legendary Best Friend"
    elif pct >= 75: return "⭐ Solid Gold Friend"
    elif pct >= 60: return "👍 Good Buddy"
    elif pct >= 40: return "🤝 Casual Friend"
    else: return "👋 Acquaintance"

# === DISPLAY FUNCTIONS ===

def make_bar(val, max_val=10, width=12):
    fill = int((val / max_val) * width)
    return "█" * fill + "░" * (width - fill)

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

# === MASTER FUNCTION ===

def rate_friendship(speed, snacks, homework, fun, promises):
    scores = {
        "Responsiveness": score_responsiveness(speed),
        "Generosity": score_generosity(snacks, homework),
        "Fun Factor": score_fun(fun),
        "Reliability": score_reliability(promises)
    }
    pct = combine(list(scores.values()))
    title = get_title(pct)
    return scores, pct, title

# === MAIN PROGRAM ===

header("📊 FRIENDSHIP SCORE CALCULATOR")
print()

# Collect data
name = input("Friend's name: ")

print()
print("Answer these about " + name + ":")
print()

speed = input("Reply speed (instant/minutes/hours/days): ").lower()
snacks = input("Shares snacks? (yes/no): ").lower()
homework = input("Helps with homework? (yes/no): ").lower()
fun = int(input("Fun level 1-5: "))
promises = input("Keeps promises (always/usually/sometimes): ").lower()

# Run the pipeline!
scores, pct, title = rate_friendship(speed, snacks, homework, fun, promises)

# Display results
print()
header(f"RESULTS FOR {name.upper()}")
print()

print("  Category Breakdown:")
print("  ─" * 20)
for category, score in scores.items():
    print(f"  {category:16s} {make_bar(score)} {score}/10")

print()
pct_bar = make_bar(pct, 100, 20)
print(f"  OVERALL: {pct_bar} {pct}%")
print(f"  STATUS:  {title}")
print()

# Fun commentary
comments = {
    90: [f"{name} is basically family at this point.", f"Protect {name} at all costs."],
    75: [f"{name} is a keeper!", f"You and {name} have something solid."],
    60: [f"{name} is good people.", f"Your friendship with {name} has potential!"],
    40: [f"You and {name} are getting there!", f"Give it time with {name}."],
    0: [f"Maybe invite {name} to hang out more?", f"Every friendship starts somewhere!"]
}

for threshold in sorted(comments.keys(), reverse=True):
    if pct >= threshold:
        print(f"  💬 {random.choice(comments[threshold])}")
        break

print()
header("Pipeline: answers → scores → combine → rate → display", char="─")

Part 9

Pipelines Are Everywhere

What you built is exactly how real software works:

Real-World Pipelines

Instagram filters: take photo → adjust brightness → add color tint → apply blur → add frame → output

Spell check: take text → split into words → check each word → mark misspelled → suggest corrections → display

Grade calculator: take assignment scores → weight each one → calculate average → convert to letter grade → display

Video game damage: base attack → multiply by weapon → subtract armor → check for critical hit → apply to health → display

In every case, data flows through a series of transformations. Each step is a function. Each function does one thing well. Together, they create something complex and useful.

Part 10

What You Just Did

You learned to chain functions together — where the output of one becomes the input of the next. This is systems thinking: understanding how simple parts connect to create complex behavior.

The friendship calculator isn't one big, complicated function. It's a pipeline of small, simple functions that each do one job. Any single function is easy to understand, test, and change. But connected together, they solve a complex problem.

The Big Idea

Complex problems become manageable when you think of them as pipelines: "What are the steps, and how does information flow from one step to the next?" Each step is a function. Each function transforms the data and passes it along. Simple parts, complex results.

Thinking Questions

Why is it better to have many small functions than one giant function? (Hint: think about changing, testing, and reusing.)
If you wanted to add a "Humor" category to the friendship score, what would you need to change? How many functions would you need to touch?
Can you think of a process in your life that works like a pipeline? What are the steps, and what flows through them?

Challenges

Level Up

Challenge 1 · Movie Rating Pipeline

Build a movie rating system with functions for: score_acting(), score_story(), score_visuals(), score_music(). Combine them into an overall rating with a title like "Masterpiece", "Worth Watching", "Skip It". Rate 3 movies and display a ranked list.

Challenge 2 · Text Transformer Pipeline

Build a text processing pipeline: clean(text) → censor(text, banned_words) → emphasize(text, keyword) → format_output(text). Each function transforms the text and passes it to the next. Test it with a sentence that has bad words and important keywords.

Challenge 3 · Day Planner Pipeline

Build functions: check_weather() returns a weather score, check_energy() returns an energy score, check_schedule() returns a free-time score. Chain them into plan_day() that recommends activities based on the combined scores. Different combinations should give different recommendations.

Summary

What You Learned

Thinking Skill

Systems Thinking — understanding how independent parts work together in sequence, each transforming data before passing it on. Ask: "What are the steps, and how does information flow between them?"

Python Concepts

Function chaining — output of one function becomes input of next

Nested calls — f(g(x)) runs g first, then passes result to f

Master/orchestrator functions — functions that call other functions in order

Returning multiple values — return a, b, c

sum() — add up all items in a list

min() — cap a value at a maximum

*data — unpack a tuple into separate arguments

.items() — loop through dictionary keys and values

.sort() with key — sort by a specific value

Lessons 1–10: The Complete Toolkit

Decomposition — break big problems into small steps

Abstraction — decide what details matter

Deductive Reasoning — rules + facts = conclusions

Categorization — organize items into groups

Pattern Recognition — spot what repeats and changes

Automation — templates for repetitive tasks

Inductive Reasoning — observations → conclusions

Encapsulation — package complexity into functions

Generalization — build solutions that adapt to any input

Systems Thinking — connect simple parts into complex pipelines

The Assembly Line in Your Head: Chaining Ideas Together