How to print a right angle triangle in Python

A classic Python exercise for new programmers is to print a right-angle triangle. This task helps you practice fundamental concepts like loops and nested structures to control program flow.

Here, you'll find several techniques to create these patterns. We'll cover practical tips, explore real-world applications, and offer advice to debug your code, so you can master this common programming challenge.

Using nested loops for a basic right angle triangle

rows = 5
for i in range(rows):
for j in range(i + 1):
print("*", end=" ")
print()--OUTPUT--*
* *
* * *
* * * *
* * * * *

This classic method uses a nested loop. The outer loop is responsible for creating the rows, while the inner loop prints the asterisks for each row.

• The outer loop, for i in range(rows), sets the triangle's height.
• The inner loop's range, range(i + 1), is the key. It links the number of asterisks in a row to the row number itself, which creates the triangle's slanted shape.

Using end=" " within the inner loop's print() function places the asterisks side by side. The final print() call then moves the cursor to a new line, starting the next row.

Loop and string based approaches

For more concise code, you can move beyond nested loops and leverage Python's string features, including the * operator, list comprehensions, and the join() method.

Using the * operator for string repetition

rows = 5
for i in range(1, rows + 1):
print("* " * i)--OUTPUT--*
* *
* * *
* * * *
* * * * *

This approach simplifies the code by using Python's string multiplication feature. Instead of a second loop to print characters, you can repeat the "* " string directly, making the solution more concise.

• The loop iterates using range(1, rows + 1), so the counter i starts at 1 and goes up to the value of rows.
• In each iteration, the expression "* " * i creates a new string by repeating "* " a number of times equal to the current row number, i.

Creating a triangle with list comprehension

rows = 5
triangle = [' '.join(['*'] * (i + 1)) for i in range(rows)]
for line in triangle:
print(line)--OUTPUT--*
* *
* * *
* * * *
* * * * *

This approach uses a list comprehension to build all the rows of the triangle at once, storing them in a list before printing. It’s a more compact and often more efficient way to handle sequence generation.

• The expression ['*'] * (i + 1) creates a list of individual asterisk strings for each row.
• The ' '.join() method then combines the items in that list into a single string, inserting a space between each one.

After the list comprehension constructs the full list of rows, a final for loop iterates through it to print each line.

Building each row with join() method

rows = 5
for i in range(1, rows + 1):
stars = ' '.join('*' for _ in range(i))
print(stars)--OUTPUT--*
* *
* * *
* * * *
* * * * *

This technique also uses the join() method but combines it with a generator expression. It’s a memory-efficient choice because it generates and joins the asterisks for each row on the fly, rather than building a full list first.

• The expression ('*' for _ in range(i)) is a generator that yields one asterisk at a time for the current row number i.
• The ' '.join() method then takes each asterisk from the generator and combines them into a single string, separated by spaces.

Advanced techniques and customizations

Beyond these foundational methods, you can write more powerful and reusable code by creating functions, using recursion, or aligning patterns with methods like ljust().

Creating a parameterized triangle function

def print_triangle(rows, symbol='*'):
for i in range(1, rows + 1):
print(f"{symbol} " * i)

print_triangle(5, '#')--OUTPUT--#
# #
# # #
# # # #
# # # # #

Encapsulating the logic in a function like print_triangle makes your code reusable and clean. This function is more flexible because it accepts parameters for both the number of rows and the symbol used for printing.

• The symbol parameter has a default value of '*', which means you don't have to provide it unless you want to use a different character.
• You can now create different triangles by simply calling the function with new arguments, like print_triangle(5, '#'), without rewriting the core logic.

Generating a triangle with recursion

def recursive_triangle(n, i=1):
if i > n:
return
print('* ' * i)
recursive_triangle(n, i + 1)

recursive_triangle(5)--OUTPUT--*
* *
* * *
* * * *
* * * * *

This approach uses recursion, where a function calls itself to solve a smaller piece of the problem. The recursive_triangle function prints one row and then calls itself to handle the next, continuing until the triangle is complete.

• The function's base case is if i > n: return. This condition is essential because it tells the function when to stop, preventing an infinite loop.
• In each step, the function prints the current row using string multiplication and then calls itself with an incremented row counter, i + 1, to build the next line.

Aligning triangle patterns with ljust()

rows = 5
width = rows * 2
for i in range(1, rows + 1):
stars = '* ' * i
print(stars.ljust(width))--OUTPUT--*
* *
* * *
* * * *
* * * * *

The ljust() string method offers a simple way to align your triangle's output. It works by left-justifying a string within a specified width, padding the right side with spaces to fill the remaining area. This is useful for creating uniformly formatted text blocks.

• A fixed width is calculated before the loop begins, often based on the triangle's largest row.
• Inside the loop, stars.ljust(width) ensures each line of stars occupies the same total space, resulting in a clean, left-aligned pattern.

Move faster with Replit

Replit is an AI-powered development platform where all Python dependencies come pre-installed, so you can skip setup and start coding instantly. While mastering individual techniques is a great start, Agent 4 helps you leap from practicing concepts to building complete applications.

Instead of piecing together functions and loops, you can describe the app you want to build. The Agent handles the entire process—from writing the code and connecting APIs to deploying a live version. For example, you could build:

• A command-line utility that generates custom loading bars using string repetition, similar to the '*' operator examples.
• A simple data visualizer that creates text-based bar charts from a list of numbers, using the ljust() method for clean alignment.
• A dynamic list formatter that takes raw data and uses the join() method to structure it into a readable, formatted report.

Simply describe your app, and Replit will write the code, test it, and fix issues automatically, all within your browser.

Common errors and challenges

Even simple patterns can trip you up; here’s how to navigate common pitfalls like off-by-one errors, alignment issues, and infinite recursion.

• Off-by-one errors are frequent when using loops, causing them to run one time too many or one time too few. In triangle patterns, this often happens with the range() function. If your triangle's height is off, check your range() arguments to ensure they correctly define the loop's start and end points.
• Alignment can get tricky with centered patterns. While ljust() works well for left-aligned shapes, centered pyramids require calculating the correct number of leading spaces for each row. This padding usually decreases as the number of asterisks increases to keep the pattern symmetrical.
• A recursive function like recursive_triangle() needs a clear exit condition—a base case. Without one, the function calls itself endlessly until the system runs out of memory and raises a RecursionError. Always define a condition that tells the function when to stop.

Fixing off-by-one errors with range() in triangle height

An off-by-one error is a common slip-up, especially with Python's range() function. When printing a triangle, this mistake can easily make your pattern one row too short. See how using range(rows - 1) in the following code causes this exact issue.

rows = 5
for i in range(rows - 1): # Creates only 4 rows
print("* " * (i + 1))

Since range() stops before its endpoint, using rows - 1 causes the loop to run only four times. This truncates the triangle. See the corrected implementation in the following example.

rows = 5
for i in range(rows): # Creates all 5 rows
print("* " * (i + 1))

The fix is to use range(rows) instead of range(rows - 1). Because Python's range() function stops just before its endpoint, range(rows) correctly iterates from 0 to 4, giving you the five rows you need. This kind of off-by-one error is a classic trip-up. It’s a good habit to double-check your range() boundaries whenever you're looping to a specific count, ensuring your code behaves exactly as intended.

Solving alignment issues in centered pyramid patterns

Creating a centered pyramid requires more than just printing stars. You also need to calculate the right number of leading spaces for each row to achieve symmetry. When this spacing logic is off, the pattern loses its shape—a common frustration for new programmers.

Check the code below to see how a simple miscalculation in spacing can result in a skewed, left-leaning pyramid instead of a centered one.

rows = 5
for i in range(rows):
spaces = " " * (rows - i)
stars = "*" * (2 * i + 1) # Stars with no spaces between
print(spaces + stars)

The issue is the spacing logic. The expression " " * (rows - i) fails to balance the leading spaces with the growing number of stars, causing the misalignment. The following code demonstrates the correct approach.

rows = 5
for i in range(rows):
spaces = " " * (rows - i - 1) # Correct space calculation
stars = "* " * i + "*" # Proper spacing between stars
print(spaces + stars)

The fix centers the pyramid by precisely calculating the leading spaces for each row with " " * (rows - i - 1). This formula ensures the padding decreases correctly as the pyramid widens. The star pattern itself is built with "* " * i + "*" to create even spacing between stars without an extra space at the end. This combination of adjusted padding and clean star generation creates the symmetrical shape. Pay close attention to this when patterns require both leading and internal spacing.

Preventing infinite recursion in recursive_triangle() functions

A recursive function needs a base case to know when to stop. Without this exit condition, it will call itself repeatedly until the program crashes with a RecursionError. The following code demonstrates how this happens in a recursive_triangle() function.

def recursive_triangle(n):
print("* " * n)
recursive_triangle(n - 1) # Missing base case

recursive_triangle(5) # Causes RecursionError

The function calls itself with n - 1 but never checks if n has reached zero. It continues into negative numbers, causing endless calls until the program crashes. See how a simple base case fixes this below.

def recursive_triangle(n):
if n <= 0: # Base case added
return
print("* " * n)
recursive_triangle(n - 1)

recursive_triangle(5) # Works correctly

The fix introduces a base case: if n <= 0: return. It’s the function's exit strategy, stopping the recursion once n reaches zero and preventing the chain of calls from continuing indefinitely. Without this check, the function would keep calling itself with negative numbers, eventually causing a RecursionError. You must always define a clear stopping point in any recursive function to avoid this common pitfall.

Real-world applications

Now that you can build and debug these patterns, you can apply the same logic to practical tasks like data visualization and directory displays.

Visualizing data with simple text-based bar charts using * operator

Just as you used the * operator to build rows of a triangle, you can also use it to represent data visually by creating simple, text-based bar charts.

data = [3, 7, 2, 5, 8]
labels = ["A", "B", "C", "D", "E"]

for i in range(len(data)):
bar = "█" * data[i]
print(f"{labels[i]}: {bar}")

This snippet offers a practical way to visualize data directly in your terminal. It works by pairing values from a data list with their corresponding names from a labels list.

• A for loop iterates through the lists by index, processing one data point at a time.
• Inside the loop, the string multiplication operator (*) creates a visual bar by repeating the "█" character. The length of each bar corresponds to a value in the data list.
• An f-string then neatly prints each label alongside its generated bar.

Creating a simple file directory tree with pattern indentation

The same logic you used to control spacing for patterns can be adapted to generate a simple file directory tree, using indentation to show structure.

def print_directory_tree(indent, items):
for i, item in enumerate(items):
prefix = "└── " if i == len(items) - 1 else "├── "
print(" " * indent + prefix + item)

files = ["main.py", "utils.py", "data.json", "README.md"]
print("project/")
print_directory_tree(4, files)

This snippet uses a function called print_directory_tree to generate a text-based file structure. It cleverly determines whether an item is the last in the list to apply the correct tree-branching symbol, making the output look like a real directory listing.

• The enumerate() function provides an index for each file, which is used to check if it's the final item.
• A conditional expression—"└── " if i == len(items) - 1 else "├── "—selects the appropriate prefix for visual structure.
• Each line is then printed with a specified indent, the chosen prefix, and the filename.

Get started with Replit

Now, use these techniques to create a real tool. Describe what you want to build to Replit Agent, like “create a terminal app that visualizes daily stock changes as a bar chart” or “build a script that formats text into a nested to-do list”.

The Agent will write the code, test for errors, and deploy your application. You can focus on the idea, not the setup. Start building with Replit.