📝 🤖🔧 Programming an Assembly Line: Nested Loops in Action

🔧 Context: Automating an Assembly Line

Imagine you’re programming the AutoAssembly 5000, a robot responsible for assembling parts into finished products. This robot needs to:

• Process multiple product types.

• Add specific components to each product.

• Perform quality checks on each assembly step.

Nested loops help automate these tasks by iterating over multiple levels of data.

🧐 What Are Nested Loops?

Nested loops are loops inside other loops. They allow you to process multi-dimensional data or perform repetitive tasks at multiple levels.

Syntax Breakdown

for outer_element in outer_sequence:
    for inner_element in inner_sequence:
        # Code block for each combination of outer and inner elements

  Cell In[1], line 3
    # Code block for each combination of outer and inner elements
                                                                 ^
SyntaxError: incomplete input

• Outer loop: Iterates over the main sequence (e.g., product types).

• Inner loop: Iterates within each outer element (e.g., components for a product).

🛠 Basic Example: Adding Components to Products

Let’s start by adding components to multiple product types.

products = ["Smartphone", "Laptop", "Tablet"]
components = ["Screen", "Battery", "Processor"]

for product in products:
    print(f"Assembling {product}:")
    for component in components:
        print(f" - Adding {component}")

Explanation of the Code

• The outer loop iterates over the list of products.

• The inner loop iterates over the list of components.

• Each combination of product and component is processed.

🔄 Adding Components to Multiple Units

Now, let’s make it more granular by adding components to each unit of a product.

products = ["Smartphone", "Laptop"]
components = ["Screen", "Battery", "Processor"]
units = range(1, 4)  # Each product has 3 units to assemble

for product in products:
    print(f"Assembling {product}:")
    for unit in units:
        for component in components:
            print(f" - Adding {component} to Unit {unit}")

Key Points

• The innermost loop applies each component to each unit of a product.

• Three nested loops are used:

  1. Outer loop: Iterates over products.

  2. Middle loop: Iterates over units.

  3. Inner loop: Iterates over components.

🌍 Tracking the Assembly Process with Dictionaries

To ensure no unit is missed, track the process in a dictionary.

products = ["Smartphone", "Laptop"]
components = ["Screen", "Battery"]
units = range(1, 4)  # Each product has 3 units

progress = {}

for product in products:
    progress[product] = {}
    for unit in units:
        progress[product][unit] = []
        for component in components:
            progress[product][unit].append(component)

# Display progress
for product, units_data in progress.items():
    print(f"{product} progress:")
    for unit, applied_components in units_data.items():
        print(f"  Unit {unit}: {', '.join(applied_components)}")

🤔 Nested Loops vs. List Comprehensions

Nested loops can sometimes be replaced by list comprehensions for compactness.

Example:

components_per_unit = [[component for component in components] for unit in units]

🛠 Practical Application: Custom Assembly Requests

Some products might require specific components for certain units. Use conditional statements inside nested loops to handle these requests.

products = ["Smartphone", "Laptop"]
custom_requests = {
    "Smartphone": {1: ["Screen", "Camera"], 2: ["Screen", "Battery"]},
    "Laptop": {1: ["Keyboard"], 3: ["Processor", "RAM"]},
}

default_components = ["Battery"]
units = range(1, 4)

for product in products:
    print(f"Assembling {product}:")
    for unit in units:
        components = custom_requests.get(product, {}).get(unit, default_components)
        print(f" - Unit {unit}: {', '.join(components)}")

🎉 Key Takeaways

• Nested loops are essential for handling multi-level tasks, like products, units, and components.

• Use dictionaries to track and organize progress.

• Combine nested loops with conditional logic for custom processing.

• List comprehensions can simplify nested loop logic when compactness is preferred.

🚀 With nested loops, you can automate complex assembly tasks for the AutoAssembly 5000!