Building Answers with Loops | CodeSignal Learn

Building Answers with Loops | CodeSignal Learn

Introduction: A Loop That Answers a Question

Welcome back to Writing Complex Python Functions! In the first unit, our functions chose one answer out of several by testing conditions. In this second unit, they will do something different: build an answer out of many pieces of data, one item at a time. Our program includes two functions for this lesson. sum_to(limit) adds up a range of integers, and count_long_words(text, min_length=5) counts how many words in a sentence are long enough. Later, the standalone countdown_text(start) example will show that the same accumulator pattern can build a string instead of a number; it is not part of the two-function program below. Running the program prints exactly this: text 553 Everything in this lesson turns on one idea: when a loop lives inside a function, where we place return relative to that loop decides whether the function sees all the data or only the first item. We will meet the accumulator pattern, the post-loop return, and the deliberate early return .

The Accumulator Pattern: Initialize, Update, Return

Simple accumulator functions like the ones in this unit follow the same three-part shape. Searches, mutations, and side-effect loops can look different; here we focus on building one answer. Let's read sum_to with those three parts in mind. Python def sum_to(limit): """Return the sum of every integer from 1 through limit.""" total = 0 # accumulator lives in local scope for number in range(1, limit + 1): total += number return total # returned only after the loop finishes total = 0 initializes the accumulator before the loop, so a place to collect results already exists when the first iteration starts. total += number updates it inside the loop, once per item. return total hands the finished value back after the loop. As we may recall from the previous course, total is a local variable: it is created fresh on every call and disappears when the call ends. Nothing outside the function can read it, so return is the only way its value escapes.

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Rather than trusting that sum_to(10) produces 55, we can watch the accumulator grow. The loop walks range(1, 11), which yields the integers 1 through 10, and each pass adds number to total . number total after update 112336410 ... ... 1055 After the pass where number is 10, the range is exhausted, so control leaves the loop and finally reaches return total, which hands back 55 . Notice how often that return runs: exactly once per call, no matter how many iterations occur. This hand trace is the mechanical way to verify any loop-based function, and we will lean on it repeatedly.

Indentation Is the Whole Rule

What actually keeps return total out of the loop is its indentation. total += number sits at eight spaces, making it part of the loop body; return total sits at four spaces, making it part of the function body. Move it one level deeper, and the function breaks: Python for number in range(1, limit + 1): total += number return total # BUG: ends the function during iteration one Now return belongs to the loop body, so it runs at the end of the first iteration. As we learned in the previous course, return ends the function immediately, so the loop never gets a second pass, and sum_to(10) reports 1 . The empty-loop case is just as revealing: if the loop body never runs at all, a trapped return is never reached, and the call quietly produces None, while a properly dedented return still hands back the initial accumulator value.

Filtering Inside the Loop with `if`

Accumulators do not have to accept every item they visit. Our second shipped function counts words, but only the long ones, by combining the loop with a condition from the last unit. Python def count_long_words(text, min_length=5): """Return how many words in text have at least min_length characters.""" count = 0 for word in text.split(): if len(word) >= min_length: count += 1 return count There are three indentation levels in play now: the loop body, the if body, and the function body, where return count still sits at the shallowest of them. The loop visits every word, but only words passing the test change the accumulator. Tracing "functions make python code reusable" : functions (9) ✓, make (4) ✗, python (6) ✓, code (4) ✗, reusable (8) ✓. Three words qualify, so the two shipped calls print: text 553

When an Early Return Is Exactly Right

A return inside a loop is not always a bug. Consider a search: once we find what we are looking for, the answer is final, and the remaining items cannot change it. Python def first_negative(numbers): """Return the first negative value in numbers, or None if there is none.""" for number in numbers: if number < 0: return number # the answer is final; stop looking return None # loop finished with no match This function has no accumulator, because it is not building a result; it is looking for one. The return number sits at exactly the depth that was a bug in sum_to, and here it is correct: first_negative([3, 8, -2, -9]) returns -2 and never inspects -9 . The second return None, dedented after the loop, covers the case where nothing matched. The decision rule fits in one question: does this function still have work left to do after this item? If the result depends on every item, return after the loop; if the answer is already complete, return inside it.

Accumulators Are Not Only Numbers

The three-part shape has nothing to do with numbers. Any value we can build up piece by piece works, including a string. Python def countdown_text(start): """Return a countdown string from start down to 1, ending with 'Liftoff!'.""" text = "" for number in range(start, 0, -1): text += str(number) + "... " return text + "Liftoff!" Three details deserve attention: text = "" is the string equivalent of total = 0 : an empty starting value that later updates extend. str(number) is required, since Python cannot join a string to an integer. countdown_text(0) returns "Liftoff!" alone because range(0, 0, -1) is empty; the loop body never runs, yet the post-loop return still fires with text at its initial value. That last point is the same lesson as the empty-loop case earlier, seen from a friendlier angle: a dedented return runs after the loop finishes normally. It does not run if an earlier return or an exception already exited the function.