How to make a multiplication table in Python

A multiplication table is a classic beginner project in Python. It helps you practice loops and output format. You can create one with just a few lines of code.

In this article, you'll learn different techniques to build your table. We'll cover practical tips, explore real world applications, and offer advice to debug your code so you can write clean, efficient programs.

Using nested for loops for a basic multiplication table

for i in range(1, 11):
   for j in range(1, 11):
       print(f"{i * j:4}", end="")
   print()--OUTPUT--1   2   3   4   5   6   7   8   9  10
  2   4   6   8  10  12  14  16  18  20
  3   6   9  12  15  18  21  24  27  30
  4   8  12  16  20  24  28  32  36  40
  5  10  15  20  25  30  35  40  45  50
  6  12  18  24  30  36  42  48  54  60
  7  14  21  28  35  42  49  56  63  70
  8  16  24  32  40  48  56  64  72  80
  9  18  27  36  45  54  63  72  81  90
 10  20  30  40  50  60  70  80  90 100

This approach uses two nested for loops to build the table. The outer loop iterates from 1 to 10 to establish each row, while the inner loop handles the columns. This structure systematically calculates each product in the grid.

The clean alignment comes from a couple of formatting tricks. The f-string f"{i * j:4}" pads each result with spaces to a consistent width of four characters. At the same time, the end="" argument in the inner print() call suppresses the default newline, keeping all products on a single line. A final print() call then moves the cursor down to start the next row.

Alternative looping techniques

While nested for loops are a solid starting point, Python also provides more concise and powerful tools for handling grid-like data structures.

Creating a table with list comprehensions

table = [[i * j for j in range(1, 11)] for i in range(1, 11)]
for row in table:
   print(" ".join(f"{cell:3}" for cell in row))--OUTPUT--1   2   3   4   5   6   7   8   9  10
 2   4   6   8  10  12  14  16  18  20
 3   6   9  12  15  18  21  24  27  30
 4   8  12  16  20  24  28  32  36  40
 5  10  15  20  25  30  35  40  45  50
 6  12  18  24  30  36  42  48  54  60
 7  14  21  28  35  42  49  56  63  70
 8  16  24  32  40  48  56  64  72  80
 9  18  27  36  45  54  63  72  81  90
10  20  30  40  50  60  70  80  90 100

List comprehensions offer a more compact way to generate your table. This single line of code builds a nested list—a list of lists—where each inner list represents a row. The entire table is constructed and stored in the table variable before anything is printed.

• To display it, you loop through each row in the table.
• The join() method then assembles all numbers in a row into a single string, which is a clean and efficient way to handle the output.

Vectorized multiplication with numpy

import numpy as np
table = np.outer(np.arange(1, 11), np.arange(1, 11))
print(table)--OUTPUT--[[ 1  2  3  4  5  6  7  8  9 10]
[ 2  4  6  8 10 12 14 16 18 20]
[ 3  6  9 12 15 18 21 24 27 30]
[ 4  8 12 16 20 24 28 32 36 40]
[ 5 10 15 20 25 30 35 40 45 50]
[ 6 12 18 24 30 36 42 48 54 60]
[ 7 14 21 28 35 42 49 56 63 70]
[ 8 16 24 32 40 48 56 64 72 80]
[ 9 18 27 36 45 54 63 72 81 90]
[10 20 30 40 50 60 70 80 90 100]]

For a more mathematical approach, you can use the numpy library. It's built for high performance numerical computing. This method avoids explicit Python loops by using vectorization—a technique that applies operations to entire arrays at once.

• The np.arange(1, 11) function first creates two identical arrays of numbers from 1 to 10.
• Then, np.outer() calculates the outer product of these arrays, generating the entire multiplication table in a single, efficient operation.

The result is a numpy array, a powerful grid like data structure optimized for speed.

Building a table as a pandas.DataFrame

import pandas as pd
rows = columns = range(1, 11)
table = pd.DataFrame({j: [i*j for i in rows] for j in columns}, index=rows)
print(table)--OUTPUT--1   2   3   4   5   6   7   8   9   10
1   1   2   3   4   5   6   7   8   9   10
2   2   4   6   8  10  12  14  16  18   20
3   3   6   9  12  15  18  21  24  27   30
4   4   8  12  16  20  24  28  32  36   40
5   5  10  15  20  25  30  35  40  45   50
6   6  12  18  24  30  36  42  48  54   60
7   7  14  21  28  35  42  49  56  63   70
8   8  16  24  32  40  48  56  64  72   80
9   9  18  27  36  45  54  63  72  81   90
10  10  20  30  40  50  60  70  80  90  100

The pandas library is a go-to for data analysis, and its DataFrame object is essentially a powerful, labeled table. This approach uses a dictionary comprehension to construct the data column by column, which is a very common pattern when working with this library.

• Each number from 1 to 10 becomes a dictionary key, which pandas then uses as a column header.
• The corresponding value is a list of products, creating the data for that entire column.

Finally, the pd.DataFrame() constructor assembles this dictionary into a grid, and the index=rows argument adds the row labels for a clean, readable output.

Advanced multiplication table techniques

With the core logic established, you can now refine your table’s appearance, add user-defined dimensions, and explore functional approaches using tools like map and lambda.

Improving readability with string formatting

for i in range(1, 11):
   row = " | ".join(f"{i * j:2d}" for j in range(1, 11))
   print(row)
   if i == 1:
       print("-" * len(row))--OUTPUT--1 |  2 |  3 |  4 |  5 |  6 |  7 |  8 |  9 | 10
------------------------------------------
2 |  4 |  6 |  8 | 10 | 12 | 14 | 16 | 18 | 20
3 |  6 |  9 | 12 | 15 | 18 | 21 | 24 | 27 | 30
4 |  8 | 12 | 16 | 20 | 24 | 28 | 32 | 36 | 40
5 | 10 | 15 | 20 | 25 | 30 | 35 | 40 | 45 | 50
6 | 12 | 18 | 24 | 30 | 36 | 42 | 48 | 54 | 60
7 | 14 | 21 | 28 | 35 | 42 | 49 | 56 | 63 | 70
8 | 16 | 24 | 32 | 40 | 48 | 56 | 64 | 72 | 80
9 | 18 | 27 | 36 | 45 | 54 | 63 | 72 | 81 | 90
10 | 20 | 30 | 40 | 50 | 60 | 70 | 80 | 90 |100

You can significantly improve the table's layout with a few string formatting tricks. This version focuses on creating clear visual boundaries for easier reading.

• The " | ".join() method inserts a vertical bar between each number, which neatly separates the columns.
• Inside the f-string, :2d pads each number to a width of two characters. This keeps all the columns perfectly aligned.
• A horizontal line is printed only after the first row. The code calculates its length with len(row), so it automatically matches the table's width.

Creating a table with user-defined dimensions

n = int(input("Enter the size of the multiplication table: "))
for i in range(1, n + 1):
   for j in range(1, n + 1):
       print(f"{i * j:4}", end="")
   print()--OUTPUT--Enter the size of the multiplication table: 5
  1   2   3   4   5
  2   4   6   8  10
  3   6   9  12  15
  4   8  12  16  20
  5  10  15  20  25

This code makes the table dynamic by prompting for user input. The input() function captures your entry, and int() converts it into a number stored in the variable n. This value then defines the table's dimensions, making it flexible instead of fixed.

• Both loops now use range(1, n + 1) to iterate up to your specified size.
• Adding + 1 is essential because the range() function excludes the upper limit, ensuring the loop runs correctly up to n.

Using functional programming with map and lambda

multipliers = range(1, 11)
rows = list(map(lambda i: list(map(lambda j: i*j, multipliers)), multipliers))
for row in rows:
   print(" ".join(f"{cell:3}" for cell in row))--OUTPUT--1   2   3   4   5   6   7   8   9  10
 2   4   6   8  10  12  14  16  18  20
 3   6   9  12  15  18  21  24  27  30
 4   8  12  16  20  24  28  32  36  40
 5  10  15  20  25  30  35  40  45  50
 6  12  18  24  30  36  42  48  54  60
 7  14  21  28  35  42  49  56  63  70
 8  16  24  32  40  48  56  64  72  80
 9  18  27  36  45  54  63  72  81  90
10  20  30  40  50  60  70  80  90 100

This functional approach swaps traditional loops for nested map functions. It’s a more declarative way to build the table, focusing on what to do rather than how to do it. The code processes data in streams, which can be very efficient.

• The outer map function iterates through the multipliers to generate each row.
• For each row number, an inner map applies a lambda function—a small, anonymous function—to calculate the product for every column.

Move faster with Replit

Replit is an AI-powered development platform that transforms natural language into working applications. You can describe what you want to build, and Replit Agent creates it—complete with databases, APIs, and deployment.

The table-generation techniques in this article are just the start. Replit Agent can take these core concepts and build them into production-ready tools.

• Build an interactive math quiz app that lets students practice with tables of a user-defined size.
• Create a currency conversion dashboard that generates a real-time grid of exchange rates, similar to a pandas.DataFrame.
• Deploy a pricing calculator that generates a cost table based on different product quantities and options.

Bring your idea to life by describing it in plain English. Replit Agent handles the coding, testing, and deployment, turning your concept into a working app right in your browser.

Common errors and challenges

Even simple projects have their pitfalls; here’s how to navigate common errors when building your multiplication table.

Fixing off-by-one errors with range()

A frequent trip-up is the off-by-one error, which often happens because of how Python's range() function works. It generates numbers up to but not including its stop value. If you want a table that goes up to 10, you need to write range(1, 11), not range(1, 10).

Forgetting that extra + 1 will cause your loops to stop one number short, leaving your table incomplete. It’s a classic beginner mistake, so always double-check your range() arguments to make sure they cover the full scope you intend.

Troubleshooting table alignment issues

When your table looks messy, the culprit is usually inconsistent spacing. Numbers with different digit counts—like 8, 16, and 120—take up different amounts of horizontal space, throwing off your columns. You can fix this by padding each number with spaces so they all occupy the same width.

F-strings make this easy. A format specifier like f"{value:4}" tells Python to reserve four character spaces for the number, right-aligning it by default. If your table grows and the products get larger, you may need to increase the padding to keep everything aligned.

Handling incorrect indexing when accessing table values

If you store your table in a list of lists or a similar structure, you might get an IndexError or pull the wrong value. This happens because Python uses zero-based indexing, where the first element is at index 0, the second at 1, and so on.

This creates a mismatch with our human-readable table that starts at 1. To access the data correctly, you'll need to adjust for this offset.

• To find the product of row i and column j (e.g., 3 * 4).
• You must access the element at index [i-1] and [j-1] (e.g., table[2][3]).

Always remember to subtract one from your row and column numbers when you're retrieving a value from the data structure.

Fixing off-by-one errors with range()

This error is easy to make. You might instinctively use range(10) for a 10x10 table, but this will actually generate a table from 0 to 9. The following code demonstrates this common mistake, resulting in an incomplete table.

for i in range(10):
   for j in range(10):
       print(f"{i * j:4}", end="")
   print()

The range(10) function iterates from 0 through 9. This results in a table that incorrectly includes a row of zeros and leaves out the multiples of 10. The following code demonstrates the correct approach.

for i in range(1, 11):
   for j in range(1, 11):
       print(f"{i * j:4}", end="")
   print()

The correct approach uses range(1, 11). This tells Python to start counting at 1 and stop just before 11, generating the exact sequence from 1 to 10. Using two arguments with range() is key whenever your sequence doesn't start at zero.

This ensures your table includes the multiples of 10 and omits the zero-based row and column. Always double check your range() arguments to make sure they cover the full scope you intend.

Troubleshooting table alignment issues

If your table's columns are all over the place, it's almost always a spacing problem. A single-digit number takes up less room than a three-digit one, which misaligns your grid. The following code demonstrates the messy output you get without formatting.

for i in range(1, 11):
   for j in range(1, 11):
       print(i * j, end=" ")
   print()

Using print(i * j, end=" ") gives every number an identical single-space separator, regardless of its digit count. This is what causes the jumbled output. The code below shows how to enforce consistent spacing for a clean grid.

for i in range(1, 11):
   for j in range(1, 11):
       print(f"{i * j:4}", end="")
   print()

This code uses an f-string, f"{i * j:4}", to enforce consistent spacing. The format specifier works by ensuring every number occupies the same width.

• The :4 tells Python to create a four-character field for each product.
• Shorter numbers are automatically padded with spaces to fill the field.

This simple trick guarantees your columns will always align, which is crucial for displaying any kind of tabular data in the console.

Handling incorrect indexing when accessing table values

When your table is stored in a list, accessing values can be tricky. Python's zero-based indexing means the first item is at index 0, not 1. This mismatch often leads to pulling the wrong data. The code below demonstrates this common indexing mistake.

table = [[i * j for j in range(1, 11)] for i in range(1, 11)]
value = table[7][8]
print(f"7 × 8 = {value}")

The expression table[7][8] doesn't fetch the product of 7 and 8. It actually accesses the eighth row and ninth column of the data structure, which gives you the wrong answer. Check out the correct indexing approach below.

table = [[i * j for j in range(1, 11)] for i in range(1, 11)]
value = table[7-1][8-1]
print(f"7 × 8 = {value}")

The fix is to subtract one from your desired row and column numbers. Because Python lists start at index 0, you'll need to adjust for the offset when your table is designed to be read starting from 1.

• The expression table[7-1][8-1] correctly translates the human-friendly coordinates (row 7, column 8) into the list's zero-based indices (index 6 and 7).
• This is a common trap to watch for when working with grids or matrices.

Real-world applications

Beyond a simple coding exercise, the techniques for generating tables can be adapted to solve a variety of real-world problems.

Creating a times table quiz with random module

You can turn your multiplication table logic into an interactive quiz by using Python's random module to generate questions on the fly.

import random

for _ in range(5):
   a, b = random.randint(1, 10), random.randint(1, 10)
   answer = int(input(f"What is {a} × {b}? "))
   print("Correct!" if answer == a * b else f"Wrong. {a} × {b} = {a * b}")

This script generates five random multiplication problems. The for loop runs five times, using an underscore _ as a placeholder since the loop counter isn’t needed.

• Inside the loop, random.randint(1, 10) picks two numbers between 1 and 10.
• The input() function poses a question, and your typed answer is converted to a number with int().
• A compact conditional expression checks your answer, printing immediate feedback on whether you were right or wrong.

Generating a sales commission table with zip and formatting

You can use the zip function to create a practical sales commission table by pairing sales figures with their corresponding commission rates. This function is perfect for iterating over multiple lists at once, allowing you to calculate and display the results in a neatly formatted report.

sales_levels = [1000, 5000, 10000, 20000, 50000]
commission_rates = [0.01, 0.02, 0.03, 0.05, 0.07]

print("Sales Level | Commission Rate | Amount")
print("------------|-----------------|-------")
for sale, rate in zip(sales_levels, commission_rates):
   commission = sale * rate
   print(f"${sale:10,} | {rate*100:14.1f}% | ${commission:,.2f}")

This script generates a commission report by processing two lists in tandem. The for loop iterates over pairs of sales figures and rates, which are created by the zip function.

• For each pair, it calculates the commission amount.
• The real magic is in the f-string formatting within the print() function. It aligns each column by setting specific widths and formats the numbers with commas and decimal points, turning raw data into a professional-looking report.

Get started with Replit

Now, turn these concepts into a real tool. Tell Replit Agent to “build a currency converter dashboard” or “create a sales commission calculator that reads from a CSV file.”

The agent writes the code, tests for errors, and deploys your app right in your browser. Start building with Replit.