Learn How to Build a Payment Receipt Generator in Python: Absolute Beginners Tutorial

A payment receipt generator is one of the best first Python projects for absolute beginners. It is small enough to finish in one sitting, practical enough to feel real, and it exercises variables, lists, loops, functions, and f-strings all at once.

Python is famous for letting you write useful programs with very little code. This tutorial builds that intuition by walking through a payment receipt generator from scratch. By the end you will have a working Python script that takes a list of purchased items, calculates a subtotal, applies a tax rate, and prints a clean formatted receipt to the terminal. Every line of code is explained before it is written.

What the Program Will Do

Before writing a single line of code it helps to picture the output. The finished program will print something like this to your terminal:

===========================
   Corner Coffee Shop
===========================
Item                  Price
---------------------------
Coffee               $3.50
Blueberry Muffin     $2.75
Orange Juice         $4.00
---------------------------
Subtotal             $10.25
Tax (8%)              $0.82
TOTAL                $11.07
===========================

That output comes from four core ideas: a list holding the items, a loop that walks through the list, an f-string that formats each line, and a function that wraps it all together. Each of those ideas is introduced one at a time below.

Storing Items: Lists and Tuples

A receipt has a variable number of line items. The natural Python way to hold a collection of things is a list. Each element in this list will be a tuple — a pair of values grouped together: the item name and its price.

items = [
    ("Coffee", 3.50),
    ("Blueberry Muffin", 2.75),
    ("Orange Juice", 4.00),
]

The outer square brackets [ ] create a list. The inner parentheses ( ) create each tuple. A tuple with two values is sometimes called a pair. Here each pair holds a string (the item name) and a float (the price in dollars).

You can add as many tuples as you like. The for loop you will write later will handle any number of items automatically — you never have to count them yourself.

Printing with F-Strings

An f-string is a string that can embed variable values directly inside it. You write the letter f before the opening quote, and then put any variable name or expression inside curly braces { }. Python replaces those curly-brace expressions with their actual values when the string is printed.

name = "Coffee"
price = 3.50

print(f"{name:<20} ${price:.2f}")

The output of that single print line is:

Coffee               $3.50

Two format specifiers appear inside the curly braces. The :<20 part tells Python to left-align the name inside a field 20 characters wide — this is what keeps all the prices lined up in a column. The :.2f part tells Python to display the float with exactly two decimal places, which is the standard format for currency.

"f-strings are faster and easier to read than older Python string formatting methods." — Python Software Foundation

The for Loop Over a List

A for loop runs a block of code once for each item in a sequence. When the sequence is a list of tuples, Python can unpack each tuple into separate variables in the same loop line. That is called tuple unpacking.

items = [
    ("Coffee", 3.50),
    ("Blueberry Muffin", 2.75),
    ("Orange Juice", 4.00),
]

subtotal = 0.0

for name, price in items:
    print(f"{name:<20} ${price:.2f}")
    subtotal += price

On each pass through the loop, name gets the first value of the tuple and price gets the second. The line subtotal += price is shorthand for subtotal = subtotal + price. After the loop finishes, subtotal holds the sum of all prices.

The Complete Program

Here is the finished receipt generator with all five steps assembled into one script. Read through it top to bottom and notice how the pieces fit together before running it.

WIDTH = 27
TAX_RATE = 0.08


def generate_receipt(items, store_name, tax_rate=TAX_RATE):
    """Print a formatted payment receipt."""
    sep = "=" * WIDTH
    line = "-" * WIDTH

    # Header
    print(sep)
    print(f"{store_name:^{WIDTH}}")
    print(sep)
    print(f"{'Item':<20} {'Price':>5}")
    print(line)

    # Line items
    subtotal = 0.0
    for name, price in items:
        print(f"{name:<20} ${price:>4.2f}")
        subtotal += price

    # Totals
    tax = subtotal * tax_rate
    total = subtotal + tax
    tax_label = f"Tax ({int(tax_rate * 100)}%)"

    print(line)
    print(f"{'Subtotal':<20} ${subtotal:>4.2f}")
    print(f"{tax_label:<20} ${tax:>4.2f}")
    print(f"{'TOTAL':<20} ${total:>4.2f}")
    print(sep)


# --- Run the generator ---
purchases = [
    ("Coffee", 3.50),
    ("Blueberry Muffin", 2.75),
    ("Orange Juice", 4.00),
]

generate_receipt(purchases, "Corner Coffee Shop")

Save this to a file called receipt.py and run it with python receipt.py. The output should match the example at the top of this tutorial. Try changing the items list or adding new tuples — the totals and formatting will adjust automatically.

Python Learning Summary Points

1. A list of tuples is a clean way to store structured pairs of data such as item names and prices. The for loop can unpack each tuple in a single line using the for name, price in items: pattern.
2. F-strings with format specifiers give you precise control over text alignment and decimal places. The :<20 spec left-aligns text in a 20-character field; :.2f formats a float to two decimal places — both essential for readable receipt output.
3. Wrapping receipt logic in a function with parameters like items, store_name, and tax_rate makes the program reusable. You can generate receipts for different stores and different item sets by calling the same function with different arguments.

This project covers the core building blocks that appear in virtually every Python program you will write going forward. Lists, loops, f-strings, and functions compose together in the same way here as they do in much larger applications — the scale changes but the patterns do not.