RugvAI Labs

Mini-Project: Tip Calculator

You'll build a tip calculator in 20 minutes — the kind you actually use at restaurants. By the end, you'll have written your first functions with parameters, default values, and return values, all wrapped into a tiny but real utility.

Prerequisites

Before You Start

#What you'll build

A function-based tip calculator. The user enters a bill amount, a tip percent, and the number of people splitting the bill, and the program prints how much each person owes. The logic lives in clean, testable functions you can reuse from any other script.

Sample interaction

text

Bill amount: 84.50
Tip percent (default 15): 18
Number of people (default 1): 3

Subtotal:    $84.50
Tip (18%):   $15.21
Total:       $99.71
Per person:  $33.24

#What you'll learn

Learning Objectives

After this lesson, you will be able to:

Define a function with def and pass it parameters
Return a value with return instead of printing it, so the caller decides what to do with it
Give a parameter a default value, so the common case needs no argument

#Step 1: A bare tip function

Start with the simplest possible version: a function that takes a bill amount and a tip percent, and returns the tip amount in dollars.

pythonrunnable cell

def calculate_tip(bill, tip_percent):
    return bill * tip_percent / 100

print(calculate_tip(100, 15))   # 15.0
print(calculate_tip(84.50, 18)) # 15.21

Two things to notice. First, the function uses return, not print. That means the caller decides what to do with the result. Second, the function is "pure" — given the same inputs, you get the same output, every time.

What Do You Think?

What does this print? def tip(bill): bill * 0.15 result = tip(100) print(result)

Quick check

What's the difference between `return x` and `print(x)` inside a function?

#Step 2: Default the tip percent

Most people tip somewhere around 15%. Make that the default so callers don't have to specify it every time.

pythonrunnable cell

def calculate_tip(bill, tip_percent=15):
    return bill * tip_percent / 100

print(calculate_tip(100))      # 15.0 -- used the default
print(calculate_tip(100, 20))  # 20.0 -- overrode the default

Default parameters have to come AFTER required ones in the function signature. Try writing def f(x=1, y) — Python will complain.

What Do You Think?

Which call computes the tip on a $50 bill at 20%? def tip(bill, percent=15): return bill * percent / 100

#Step 3: Return the total, not just the tip

A real tip calculator answers "how much do I owe?", not "what's the tip?". Update the function to return both — as a tuple.

pythonrunnable cell

def calculate_check(bill, tip_percent=15):
    tip = bill * tip_percent / 100
    total = bill + tip
    return tip, total

tip, total = calculate_check(84.50, 18)
print(f"Tip:   ${tip:.2f}")
print(f"Total: ${total:.2f}")

return a, b packs both values into a tuple. The caller unpacks them with tip, total = .... The :.2f format spec rounds to two decimal places — perfect for currency.

What Do You Think?

What gets printed? def stats(): return 10, 20, 30 result = stats() print(type(result))

When you write return 10, 20, 30, the comma syntax implicitly creates a TUPLE (not a list). If you assign to one variable, you get the whole tuple. If you assign to three variables (a, b, c = stats()), Python "unpacks" it. The parentheses around (10, 20, 30) are optional — it's the commas that make a tuple. This is why you can write a, b = b, a to swap two variables: the right side becomes a tuple, then the left side unpacks it.

Quick check

What does `return tip, total` actually return?

#Step 4: Split among N people

Add a third parameter for the number of people splitting the bill. Default it to 1 so non-split callers don't have to think about it.

pythonrunnable cell

def calculate_check(bill, tip_percent=15, people=1):
    tip = bill * tip_percent / 100
    total = bill + tip
    per_person = total / people
    return tip, total, per_person

tip, total, per_person = calculate_check(84.50, 18, 3)
print(f"Tip:        ${tip:.2f}")
print(f"Total:      ${total:.2f}")
print(f"Per person: ${per_person:.2f}")

That's a real, useful function — a single line of input, three values back. Three callers can reuse it for solo dinners, dates, and group outings without changing anything.

#Now build it yourself

Mini project

Tip + tax + split calculator

~20 min

Write a function `calculate_total(bill, tip_percent=15, tax_percent=8, people=1)` that returns (tip, tax, total, per_person). Then write a small driver that asks the user for bill, tip_percent, and people (use the defaults if they press Enter on the latter two), and prints the receipt.

Expected output

Bill amount: 84.50
Tip percent (default 15): 18
Number of people (default 1): 3

Subtotal:    $84.50
Tax (8%):    $6.76
Tip (18%):   $15.21
Total:       $106.47
Per person:  $35.49

Your code

pythonrunnable cell

Input for this program

This code calls input(). Python here can't pause to ask you, so type the answers below before running — one value per line, in the order the program asks for them.

def calculate_total(bill, tip_percent=15, tax_percent=8, people=1):
  # TODO: compute tax, tip, total, per_person
  # TODO: return them as a tuple
  pass

def main():
  bill = float(input("Bill amount: "))
  # TODO: read tip_percent with a default of 15 if user presses Enter
  # TODO: read people with a default of 1 if user presses Enter
  # TODO: call calculate_total and print the receipt
  pass

main()

#Now make it your own

Try one of these variations:

Service-quality presets — ask the user to rate service (bad/ok/good) and map those to tip percents (10/15/20). Then call the function with the mapped value.
Tip rounding. Round each person's share UP to the nearest dollar so the total never falls short. Use math.ceil().
Currency toggle. Accept a currency code (USD, EUR, INR) and print the right symbol. Use a dict to map code to symbol.

#What's next

You've just written your first multi-function program — one where logic and presentation are separate. That separation is the foundation of every real Python project. Next up: lists, tuples, dicts, and sets — the four containers you'll reach for every day to organize data before passing it to your functions.