Vyper For Loops (Guide + Code Examples)

whiteboard crypto logo
Published by:
Whiteboard Crypto

So you’re learning Vyper and want to start using a “For Loop” to be able to repeat similar tasks. Here’s a quick example, if you just need the code syntax:

# @version ^0.3.9
# A Vyper contract example that performs a simple task five times

def repeat_task():
    for i in range(5):
        print(f"Performing task iteration: {i + 1}")

    ingredients: address[5] = [A, B, C, D, E]
    for ingredient in ingredients:
        print(f"Looking at task: {ingredient}")

    # Loop with a nested loop
    for x in range(3):
        print(f"Outer loop (Nested loop example) - iteration: {x + 1}")
        for y in range(2):
            print(f"  Inner loop - iteration: {y + 1}")

What are Vyper For Loops used for?

For Loops in the Vyper programming language are used to repeat or cycle through computations many times.

Imagine you’re planning a party where you need to make sandwiches for five friends. Making one sandwich is simple, but making five requires repeating the same steps several times. A ‘for loop’ in programming works similarly, helping to efficiently handle tasks that are repetitive.

Let’s use this exact sandwich example to create our first for loop in Vyper.

Example 1: Looping over a range

Preparing the Data for the Loop: Before starting the loop, set up what you’ll be looping through. In this case, imagine you’re planning a party and need to calculate the total cost of ingredients for the dishes. You decide to buy five different types of ingredients. Think of this as listing out the cost of each ingredient on your shopping list.

Initializing the Loop: This step involves starting the loop. In Vyper, you can use range(5) to create a loop that runs five times, which corresponds to the five ingredients. It’s like deciding to check the price of each item on your list one by one.

Iterating over Each Item: The core of the loop is where you perform the calculations. You’ll go through each item’s cost and add it to the total. In programming, iterating means going through each number (from 0 to 4 in this case) and performing a computation with it. Here, the task is to add each item’s cost to a running total.

def calculate_total_cost():
    # Part 1: Preparing the data
    ingredient_costs: uint256[5] = [
        10, # Cost of ingredient 1
        20, # Cost of ingredient 2
        15, # Cost of ingredient 3
        5,  # Cost of ingredient 4
        25  # Cost of ingredient 5
    total_cost: uint256 = 0

    # Part 2: Initializing the Loop
    for i in range(5):
        total_cost += ingredient_costs[i]
        # Part 3: Iterating over each item

In this code, ingredient_costs is an array containing the costs of the five ingredients. The for loop uses range(5) to iterate through each index (i) from 0 to 4. For each iteration, it accesses the cost of the ingredient (ingredient_costs[i]) and adds it to total_cost. This process effectively sums up the costs of all ingredients, demonstrating how for loops can be used for computations in Vyper.

Example 2: Looping over an array

Preparing the Data for the Loop: Before starting the loop, you need to set up what you’ll be looping through. In the sandwich example, these are the ingredients: bread, lettuce, tomato, cheese, and ham. Think of this as laying out all your ingredients on the table.

Initializing the Loop: This step involves starting the loop. In programming, there are different ways to initialize a loop, but the key idea is to begin the process of repeating tasks. For your sandwiches, it’s like deciding to start making them one after another.

Iterating over each item: This is the core of the loop. You go through each ingredient and add it to the sandwich. In programming, iterating means going through each item in your data (in this case, the ingredients) and performing a task with it. Here, the task is adding each ingredient to the sandwich.

def make_sandwich():
    # Part 1: Preparing the ingredients
    ingredients: address[5] = [
    # Part 2: Initializing the Loop
    for ingredient in ingredients:
        #Part 3: Iterating over each item

In this code, ingredients is a list of items you need for the sandwich. The for loop then takes each item (ingredient) from this list and performs an action (add_to_sandwich(ingredient)), which in this case is akin to adding the ingredient to a sandwich.

In Vyper, the use of break and continue provides control over loop execution. These statements allow you to manage the flow of your loops more precisely.

Example 3: Using Break

break is used to exit a loop prematurely. Imagine you’re going through a list of numbers, and you want to stop processing as soon as you find a number that meets a certain condition.

In this example, let’s consider a scenario where you want to sum all numbers in a list, as long as all the numbers are odd.

def sum_no_even_numbers(numbers: uint256[10]) -> uint256:
    odds_sum: uint256 = 0
    for number in numbers:
        if number % 2 == 0:
            break  # Exit the loop if an even number is found
        odds_sum += number         
    return odds_sum  # Return sum of numbers if no even number is found

Here, the function sum_no_even_numbers will take an array of 10 numbers, and continue adding them, as long as no even number is found. If a number is even, though… it will hit the break line, and exit the for loop computation. If it never finds an even number, and can perform this task for all 10 numbers, it will return the final number.

continue skips the current iteration and moves to the next one. It’s useful when you want to ignore certain items in a loop under specific conditions.

Example 4: Using Continue

Let’s say you want to sum all numbers in a list, except those that are divisible by 5.

def sum_except_multiples_of_five(numbers: uint256[10]) -> uint256:
    total: uint256 = 0
    for number in numbers:
        if number % 5 == 0:
            continue  # Skip this number
        total += number
    return total

In this code, number % 5 == 0 checks if the number is a multiple of 5. If it is, continue skips to the next iteration, excluding that number from the sum.

Using break and continue, you can manage the flow of loops in Vyper efficiently. These tools are crucial for writing precise and optimized code, enabling you to handle complex logic within your smart contracts.

Example 5: Nested For Loops

Nested for loops are a powerful feature in Vyper that allow you to work with complex data structures. It’s like placing one loop inside another. This concept is particularly useful when dealing with multi-dimensional arrays or when you need to perform operations that require multiple levels of looping.

Imagine you’re organizing a list of attendees for several events. Each event has its own list of attendees. To process all attendees for all events, you’d use a loop within a loop – the outer loop would go through each event, and the inner loop would go through each attendee in that event.

Here’s an example of a nested for loop in Vyper. Suppose you have a 2D array where each sub-array represents an event and contains the IDs of attendees. You want to count the total number of attendees for all events.

def count_total_attendees(events: uint256[5][10]) -> uint256:
    total_attendees: uint256 = 0
    for event in events:
        for attendee in event:
            if attendee != 0:  # Assuming 0 means no attendee
                total_attendees += 1
    return total_attendees

In this code:

  • The outer loop (for event in events) iterates over each event.
  • The inner loop (for attendee in event) iterates over each attendee in the current event.
  • if attendee != 0 checks if the attendee ID is valid (non-zero), and if so, increments the total count.

Nested loops in Vyper are a versatile tool for handling multi-layered data. They enable you to perform intricate operations, especially when dealing with arrays of arrays or needing to perform actions on a grid-like data structure. As with any powerful tool, use them judiciously and always be mindful of the potential impact on your smart contract’s performance.

Common Mistakes To Avoid

When working with for loops in Vyper, certain pitfalls can lead to bugs or inefficient code. Being aware of these common mistakes can help you write better and more reliable smart contracts.

Off-By-One Errors

One of the most common issues in loop programming is the “off-by-one” error. This happens when the loop iterates one time too many or too few.

Example: If you use range(5) thinking it will include the number 5, you’ll end up with an iteration less than expected. Remember, range(5) iterates from 0 to 4, not 1 to 5.

Infinite Loops

Infinite loops occur when the loop’s termination condition is never met. This can drain gas and may lead to unexpected behavior.

Example: If you forget to update your loop control variable, or if the update doesn’t move towards the loop’s exit condition, the loop will run indefinitely.

Unintended Overwriting of Data

Be cautious when manipulating data within loops, as you might unintentionally overwrite values.

Example: If you’re updating an array inside a loop, ensure you’re not accidentally overwriting existing data unless it’s intended.

Ignoring Gas Limitations

In blockchain development, you need to be mindful of gas costs. Loops that perform excessive computation can be very expensive.

Example: A loop that runs a high number of iterations, especially if performing complex calculations or state changes, can consume a significant amount of gas.

Misunderstanding Scope

Variables declared within a loop have a local scope. Misunderstanding this can lead to unexpected errors.

Example: If you declare a variable inside a loop and try to access it outside the loop, you’ll encounter a scope error.

Neglecting Edge Cases

Always test your loops with edge cases. For instance, what happens if the loop processes an empty list or an unusually large dataset?

Example: Ensure your loop handles cases like empty inputs or extreme values correctly without causing errors or excessive gas usage.

Vyper For Loops
whiteboard crypto logo

WhiteboardCrypto is the #1 online resource for crypto education that explains topics of the cryptocurrency world using analogies, stories, and examples so that anyone can easily understand them. Growing to over 870,000 Youtube subscribers, the content has been shared around the world, played in public conferences and universities, and even in Congress.