How to repeat something in Python

Python offers multiple ways to repeat code execution through loops and iteration. Whether you need to process data collections, implement recursive algorithms, or automate repetitive tasks, Python's repetition structures provide elegant solutions.

This guide covers essential repetition techniques, practical tips, and real-world applications, complete with code examples created with Claude, an AI assistant built by Anthropic. You'll learn debugging strategies to write efficient, reliable code.

Using a simple for loop for repetition

for i in range(5):
    print(f"This is repetition {i+1}")

This is repetition 1
This is repetition 2
This is repetition 3
This is repetition 4
This is repetition 5

The for loop demonstrates Python's straightforward approach to repetition by leveraging the range() function. This combination creates a simple counter that executes the code block a specified number of times—in this case, five iterations.

The loop variable i serves two purposes in this example:

• Tracks the current iteration number automatically
• Enables dynamic content creation through string formatting with f-strings

While this example uses basic print statements, the same pattern applies to more complex operations like data processing, file operations, or API calls where you need predictable repetition with a known number of iterations.

Basic repetition techniques

Beyond the basic for loop pattern, Python provides several powerful repetition tools including while loops, customizable range() parameters, and the multiplication operator for sequence repetition.

Using while loops for conditional repetition

count = 0
while count < 5:
    print(f"Repeating with while: {count}")
    count += 1

Repeating with while: 0
Repeating with while: 1
Repeating with while: 2
Repeating with while: 3
Repeating with while: 4

The while loop creates a flexible repetition structure that continues as long as a condition remains true. In this example, the loop runs while count stays below 5, printing the current value and incrementing it with each iteration.

• The counter initialization (count = 0) happens before the loop begins
• The condition (count < 5) checks at the start of each iteration
• The increment (count += 1) prevents an infinite loop by moving toward the exit condition

Unlike for loops which typically handle a predefined sequence, while loops excel when you need to repeat based on dynamic conditions that might change during execution. This makes them particularly useful for user input validation or processing data streams.

Customizing range() for flexible repetition

for num in range(2, 11, 2):
    print(f"Even number: {num}")

Even number: 2
Even number: 4
Even number: 6
Even number: 8
Even number: 10

The range() function accepts three parameters to control iteration behavior: start value, stop value, and step size. In this example, range(2, 11, 2) generates a sequence starting at 2, stopping before 11, and incrementing by 2 each time.

• Start value (2) defines where the sequence begins
• Stop value (11) sets the upper boundary. Python stops before reaching this number
• Step size (2) determines the increment between numbers. Using 2 generates only even numbers

This flexibility makes range() ideal for scenarios where you need precise control over sequence generation. The code efficiently prints even numbers from 2 to 10 without manual calculations or complex logic.

Repeating sequences with the * operator

repeated_list = [1, 2, 3] * 3
print(repeated_list)

repeated_string = "abc" * 5
print(repeated_string)

[1, 2, 3, 1, 2, 3, 1, 2, 3]
abcabcabcabcabc

Python's multiplication operator (*) provides a concise way to repeat sequences like lists and strings. When applied to a list, it creates a new list containing the original elements repeated the specified number of times. When used with strings, it concatenates multiple copies of that string.

• The expression [1, 2, 3] * 3 creates a new list containing three copies of the original sequence. Each element maintains its original order
• String multiplication with "abc" * 5 generates a new string with five repetitions of the original characters

This operator significantly reduces the code needed compared to traditional loops. It's particularly useful when you need quick sequence duplication for testing, data generation, or string formatting tasks.

Advanced repetition techniques

Building on Python's basic repetition tools, advanced techniques like itertools, list comprehensions, and recursion unlock powerful ways to write more elegant and efficient code.

Efficient repetition with itertools

import itertools

for item in itertools.repeat("Python", 4):
    print(item)

for item in itertools.islice(itertools.cycle([1, 2, 3]), 6):
    print(item, end=" ")

Python
Python
Python
Python
1 2 3 1 2 3

The itertools module provides specialized tools for efficient iteration. The repeat() function creates an iterator that outputs the same value a specified number of times, while cycle() continuously loops through a sequence indefinitely.

• itertools.repeat("Python", 4) generates "Python" exactly four times without storing the repeated values in memory
• itertools.cycle([1, 2, 3]) creates an infinite loop of the sequence 1, 2, 3
• itertools.islice() limits the infinite cycle to a specific number of iterations. In this case, it takes the first 6 elements

These functions excel at memory efficiency compared to traditional sequence multiplication. They're particularly valuable when working with large datasets or when you need precise control over iteration patterns.

Repeated operations using list comprehensions

repeated = [num for num in range(1, 5) for _ in range(num)]
print(repeated)

modifications = [f"Item-{i}" for i in range(3) for _ in range(2)]
print(modifications)

[1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
['Item-0', 'Item-0', 'Item-1', 'Item-1', 'Item-2', 'Item-2']

List comprehensions enable powerful nested repetition patterns in a single line of code. The first example creates a list where each number appears as many times as its value. For instance, 2 appears twice and 3 appears three times.

• The outer loop num for num in range(1, 5) generates numbers 1 through 4
• The inner loop for _ in range(num) repeats each number based on its value
• The underscore _ indicates we don't need the inner loop's counter variable

The second example demonstrates a simpler pattern that creates formatted strings with consistent repetition. Each Item-{i} appears exactly twice in the output list because the inner loop uses range(2).

This approach offers a concise alternative to nested for loops when you need to generate repeated elements in lists. It's particularly useful for creating test data or formatting sequences with predictable patterns.

Using recursion for controlled repetition

def repeat_action(times, current=0):
    if current >= times:
        return
    print(f"Recursion level: {current}")
    repeat_action(times, current + 1)

repeat_action(4)

Recursion level: 0
Recursion level: 1
Recursion level: 2
Recursion level: 3

Recursion creates repetition by having a function call itself with updated parameters. The repeat_action function demonstrates this through two key components: a base case that stops recursion when current reaches times, and a recursive case that prints the current level before making another call.

• The current parameter tracks progress through each recursive call
• Each function call creates a new stack frame, maintaining its own version of current
• The base case prevents infinite recursion by checking if current >= times

When called with repeat_action(4), the function creates four levels of recursion. Each level prints its value before calling the next level. This creates a controlled sequence of repetitions that automatically unwinds once the base case triggers.

Processing text data with for loops

The splitlines() method combined with Python's enumerate() function enables efficient line-by-line text processing while automatically tracking line numbers for structured data analysis.

sample_text = "Python\nRepetition\nTechniques"
for line_number, line in enumerate(sample_text.splitlines(), 1):
    print(f"Line {line_number}: {line}")

This code demonstrates a powerful combination of three Python features working together. The splitlines() method breaks the multi-line string into separate lines at each newline character (\n). The enumerate() function then creates pairs of numbers and lines, with the optional parameter 1 telling it to start counting from 1 instead of 0.

When executed, the code produces formatted output that displays each line prefixed with its line number. The f-string handles the string formatting elegantly by embedding the variables directly in the output template.

• Creates a clean, numbered list from multi-line text
• Automatically handles line breaks and numbering
• Uses modern Python string formatting for readable output

Simulating web scraping with repetition

Python's repetition structures enable efficient web scraping by systematically collecting data from multiple pages while managing the complexity of network requests and data storage.

pages = [f"page{i}.html" for i in range(1, 5)]
scraped_data = []

for page in pages:
    print(f"Scraping {page}...")
    # Simulate extracting data from each page
    data = f"Content from {page}"
    scraped_data.append(data)

print(f"Collected {len(scraped_data)} items:")
for item in scraped_data:
    print(item)

This code demonstrates a practical approach to batch data collection using list comprehension and loops. The first line creates a list of HTML page names using an f-string inside a list comprehension. Each name follows the pattern page1.html through page4.html.

The main loop processes each page name sequentially. It prints a status message and simulates data extraction by creating a simple string. The extracted content gets stored in the scraped_data list using append().

• Creates structured filenames dynamically
• Tracks progress with status messages
• Stores results in a central list

The final section reports the total number of items collected and displays each piece of data. This pattern forms the foundation for real-world data collection tasks.

Common errors and challenges

Python's repetition structures can trigger subtle bugs that impact program behavior when developers overlook critical implementation details.

Avoiding infinite loops in while statements

Infinite loops occur when a while loop's condition never evaluates to False. The most common cause is forgetting to update the control variable that determines when the loop should end. The code below demonstrates this classic pitfall.

counter = 0
while counter < 5:
    print(f"Current count: {counter}")

The code lacks the crucial counter += 1 increment statement inside the loop. This oversight prevents counter from ever reaching 5, trapping the program in endless repetition. Let's examine the corrected version below.

counter = 0
while counter < 5:
    print(f"Current count: {counter}")
    counter += 1

The corrected code adds counter += 1 inside the loop, which increments the counter variable after each iteration. This ensures the loop eventually reaches its termination condition when counter equals 5.

• Always update control variables inside while loops
• Place the update statement where it logically affects the loop condition
• Consider using a for loop instead when working with a known number of iterations

Watch for infinite loops in scenarios with complex conditions or multiple exit points. They commonly occur when processing user input or waiting for external events. A well-structured loop should always make progress toward its termination condition.

Fixing off-by-one errors with range()

Off-by-one errors frequently occur when developers misunderstand how Python's range() function handles start and stop values. These subtle bugs can cause loops to process one too many or too few items. The code below demonstrates a common mistake where the sequence ends earlier than intended.

for i in range(1, 5):
    print(f"Number: {i}")

The range(1, 5) function stops at 4 instead of 5 because Python excludes the stop value. This creates a sequence that doesn't match many real-world counting scenarios. The code below demonstrates the proper implementation.

for i in range(1, 6):
    print(f"Number: {i}")

The corrected code uses range(1, 6) to generate numbers from 1 through 5, ensuring the sequence includes the intended final value. Python's range() function creates sequences that include the start value but exclude the stop value. This behavior often surprises developers who expect inclusive bounds.

• When counting items or creating sequences with specific start and end values, add 1 to the stop value
• Pay special attention when working with array indices or mathematical sequences
• Consider using explicit bounds checking for critical calculations

This pattern appears frequently in data processing and numerical computations. Watch for it when porting algorithms from other languages that handle ranges differently.

Safely modifying lists during iteration

Modifying a list while iterating through it can lead to unexpected results and skipped elements. Python's iteration mechanism tracks list indices during the loop. When you remove items mid-iteration, the index tracking becomes misaligned with the modified list structure.

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num % 2 == 0:
        numbers.remove(num)
print(numbers)

When the loop removes even numbers, it shifts remaining elements left. This causes the loop to skip checking some numbers since the iteration index keeps advancing. The code below demonstrates a safer approach to list modification during iteration.

numbers = [1, 2, 3, 4, 5]
numbers_to_keep = [num for num in numbers if num % 2 != 0]
print(numbers_to_keep)

The list comprehension approach creates a new list containing only the elements we want to keep. This avoids the pitfalls of modifying a list during iteration. The expression [num for num in numbers if num % 2 != 0] efficiently filters out even numbers while preserving the original list structure.

• Watch for this issue when filtering, removing, or modifying list elements based on conditions
• Consider using list comprehensions or creating a new list for cleaner, more predictable results
• Remember that modifying collection size during iteration can lead to skipped elements or incorrect processing

This pattern appears frequently in data cleaning and filtering operations. The list comprehension solution provides better readability and reduces the chance of introducing subtle bugs.