Split a restaurant bill, including tip

Question

Just looking for a little feedback on the below tip calculator I've coded rounding the output to nearest 2 decimal places.

Just wondered if it was readable and code friendly?

bill = float(input("What was the total bill? $"))
tip = float(input("How much tip would you like to give? 10, 12, or 15  "))
no_of_people = float(input("How many people to split the bill?"))

cost_of_tip = bill / 100 * tip
total_cost = (bill + cost_of_tip) / no_of_people
final_per_person = round(total_cost, 2)
final_amount = "{:.2f}".format(final_per_person)

print(f"Each person should pay: ${final_amount}")

Answer 1

Confusing variable name. Is the tip an amount or percentage? I assumed the former based on variable name, but a commenter has corrected me.

Keep calculation and presentation logically separate. You don't need to create a variable for the rounded amount. Just compute the per person cost in the natural way. When you are ready to display that value in a human-readable form, format it as needed.

# Get user input.
bill = float(input('Bill: '))
tip_pct = float(input('Tip percentage: '))
npeople = int(input('People: '))  # int() seems more appropriate.

# Calculation.
per_person = bill * (1 + tip_pct / 100.0) / npeople

# Presentation.
message = f'Per person: ${per_person:.2f}'
print(message)

Next step: start putting your code in functions. As you try to write programs longer than a few lines, adopt a strict discipline of putting all code in functions and never relying on global variables (constants are fine). There are many reviews on this site emphasizing such points. The logical divisions illustrated above (collecting input, performing calculations, presenting results) will continue to be relevant as you start using functions.

Another next step: validating and generalizing the collection of user input. Currently, you ask the user for 3 numbers, but people make mistakes. There are many reviews on this site illustrating how to write a simple function taking a message (eg, "Enter the bill") and returning a validated value, with the opportunity to recover from user errors.

Answer 2

There's a bug in the logic: If I select 0% tip, it is quite possible that adding the rounded amounts each person pays don't add up to the bill total. You should probably use ceil instead of round, to ensure you round up, never down.

Of course giving a negative tip percentage also makes you not pay the bill total, but that would clearly be user error. It's good to guard against user error, but it is not strictly a bug in the code.

I would suggest though that on input you make it clear that you are looking for a percentage when asking about the tip. "How much tip would you like to give? 10, 12, or 15 " could be interpreted as a dollar amount rather than a percentage.

Answer 3

Get into the habit of localisation instead of hard-coding currency formats and symbols.

There's not much of a point to asking for a tip among a list of options if you aren't going to validate it. Even if you were to validate it, I would enforce "between 0 and (perhaps) 100".

The tip amount itself isn't used; so just get the total cost directly.

Don't round - let locale.currency choose the number of decimal positions.

"number of people" isn't a float; it's an int.

Suggested

from locale import localeconv, setlocale, LC_ALL, currency

setlocale(LC_ALL, '')
symbol = localeconv()['currency_symbol']

bill = float(input(f"What was the total bill? {symbol}"))
tip = float(input("How much tip would you like to give? %"))
no_of_people = int(input("How many people to split the bill? "))

total_cost = bill * (1 + tip/100)
final_per_person = total_cost / no_of_people
final_amount = currency(final_per_person)

print(f"Each person should pay: {final_amount}")

Answer 4

Separate your concerns

Split input parsing from your calculation logic. Read and parse the input in one step and do the calculation in a separate function.

Use fitting data types.

Using float as a data type can have nasty side-effects. Consider using decimal.Decimal instead. Also the three parameters to calculate the bill belong together, since they are only meaningful in their combination for the given use case. Hence, they should be contained in a common data structure.

Use the if __name__ == '__main__': guard

To prevent your script from executing when being imported for re-use in other scripts.

Suggested change

from decimal import Decimal
from typing import NamedTuple


class SplitBill(NamedTuple):
    """A split bill with a tip."""

    bill: Decimal
    tip: int
    people: int

    @classmethod
    def read(cls):
        """Interactively read the parameters."""
        return cls(
            Decimal(input("What was the total bill? $")),
            int(input("How much tip would you like to give? 10, 12, or 15  ")),
            int(input("How many people to split the bill?"))
        )

    @property
    def tip_cost(self) -> Decimal:
        """Return the cost of the tip."""
        return self.bill * self.tip / 100

    @property
    def total_cost(self) -> Decimal:
        """Return the total cost with tip."""
        return self.bill + self.tip_cost

    @property
    def cost_per_person(self) -> Decimal:
        """Return the cost for each person."""
        return round(self.total_cost / self.people, 2)


def main() -> None:
    """Reads the values and calculates a split bill with a tip."""

    split_bill = SplitBill.read()
    print(f"Each person should pay: ${split_bill.cost_per_person}")


if __name__ == '__main__':
    main()