# Vyper For Loops (Guide + Code Examples)

Whiteboard Crypto
on

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

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

ingredients: address[5] = [A, B, C, D, E]
for ingredient in ingredients:

# 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}")

```
Contents

## 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.

```@external
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.

```@external
def make_sandwich():
# Part 1: Preparing the ingredients
LETTUCE,
TOMATO,
CHEESE,
HAM
]

# 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.

```@external
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.

```@external
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

```

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.

```@external
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

```

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.

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.