Conditionals and Loops: Solving Logic Problems

The Core Pattern: Making Decisions Inside Loops

The most common and powerful pattern you'll use is placing an if statement inside a loop. This allows your program to perform a check on every single item in a sequence and act accordingly.

Think of it like sorting mail. The loop is the act of going through each letter in the pile (for letter in mail_pile). The conditional is how you decide what to do with each one (if letter is a bill, put it in the 'to pay' stack; else, put it in the 'personal' stack).

Let's start with a practical exercise that demonstrates this. In the previous lesson, you were introduced to an exercise about finding even numbers. Let's revisit it, focusing on how the for loop and the if statement work in concert.

Hands-On Practice 1: Finding and Counting Even Numbers

Your task is to write a program that iterates through the numbers from 1 to 9, identifies which ones are even, prints them, and finally prints a count of how many even numbers were found.

Open a new Jupyter Notebook and try to write this code. Remember, you'll need:

1. A for loop with range() to go through the numbers.
2. An if statement to check if a number is even (the modulo operator % is key here).
3. A counter variable that you initialize before the loop and increment inside the if block.

If you need guidance, the following video segment provides a complete walkthrough of this exact problem.

A Classic Logic Puzzle: FizzBuzz

Now that you're comfortable with the basic pattern, let's tackle a classic programming puzzle called "FizzBuzz." It's a favorite in coding interviews because it elegantly tests your understanding of loops and conditionals.

The task is as follows:
Write a program that prints numbers from 1 to 100. However:

• For multiples of three, print "Fizz" instead of the number.
• For multiples of five, print "Buzz" instead of the number.
• For numbers which are multiples of both three and five, print "FizzBuzz".

The key to solving this is the order of your if/elif/else checks. You must check for the most specific condition first (multiples of both 3 and 5).

The following article provides a clear explanation and solution.

Conditional Repetition with while Loops

The same principle applies to while loops. You can use a while loop to repeat an action until a condition is met, while using if statements inside to control the flow or check for a reason to exit.

A very common use case is validating user input. Imagine a program that needs a user to enter their age. You can't accept a negative number. A while loop can continuously re-prompt the user until they provide valid input.

The following video from Bro Code demonstrates this perfectly.

Hands-On Practice 2: A Simple Guessing Game

Let's apply this concept. Write a simple guessing game:

1. Create a variable secret_word and assign it a string value (e.g., "python").
2. Use a while True: loop to create an infinite loop.
3. Inside the loop, ask the user to guess the word using the input() function.
4. Use an if statement to check if their guess matches the secret_word.
5. If they guess correctly, print "You got it!" and use the break statement to exit the loop.
6. If they guess incorrectly, print "Wrong, try again."

This exercise combines a while loop, an if/else conditional, and the break statement to control the loop's execution based on user input.

Putting It All Together: An Inventory Check

Your background in administration and inventory management provides an excellent real-world context for applying these skills. Let's design a simple script to monitor product stock levels.

Imagine you have your inventory data represented as a list of lists, where each inner list contains a product name and its current stock quantity.

# Product, Quantity
inventory = [
    ["stapler", 20],
    ["pen", 5],
    ["paper_ream", 0],
    ["tape", 35],
    ["highlighter", 3]
]

Your task: Write a program that iterates through the inventory list and prints a status report.

1. Create a for loop to iterate through each product in the inventory list.
2. Inside the loop, use an if/elif/else block to check the stock quantity (product[1]).
   • If the quantity is 0, print "[Product Name] - OUT OF STOCK".
   • If the quantity is greater than 0 but less than or equal to 5, print "[Product Name] - Low stock, re-order soon.".
   • Otherwise (if the stock is more than 5), print "[Product Name] - Stock is sufficient.".

This problem requires you to loop through a data structure and apply a set of rules to each item—a task fundamental to data processing and analysis.

Solution Code:

Try to write the code yourself first. Once you're ready, you can compare your solution with the one below.

inventory = [
    ["stapler", 20],
    ["pen", 5],
    ["paper_ream", 0],
    ["tape", 35],
    ["highlighter", 3]
]

for product in inventory:
    product_name = product[0]
    stock_level = product[1]

    if stock_level == 0:
        print(f"{product_name} - OUT OF STOCK")
    elif stock_level > 0 and stock_level <= 5:
        print(f"{product_name} - Low stock, re-order soon.")
    else:
        print(f"{product_name} - Stock is sufficient.")

Conclusion

In this lesson, you've bridged the gap between knowing individual programming concepts and combining them to create functional logic. This is a significant milestone in your journey towards building complex applications.

Here are the key patterns we covered:

• Filtering and Categorizing: Using an if statement inside a for loop allows you to examine each item in a sequence and handle it differently based on its properties.
• Conditional Repetition: Using an if statement inside a while loop allows you to repeat a process until a specific condition is met, often using break to exit once the goal is achieved.
• Algorithmic Thinking: The process of breaking down problems like FizzBuzz or the inventory check into loops and conditional steps is the essence of writing algorithms.

You have now completed the first module and have a solid grasp of Python's fundamental building blocks. In our next lesson, we will begin a new module by exploring functions. Functions will allow us to package the logic we've learned to write into clean, reusable blocks, making our code more organized, efficient, and powerful—a crucial step towards building sophisticated AI models.