A complete, annotated walkthrough of a real Python program simulating a Philippine fruit retail market. Every design decision — from dictionary lookups to exception handling — is explained in plain language so you understand not just what the code does, but why it was written that way.
Programming becomes meaningful when it solves real problems. The Philippine Fruit Retail Business simulation is a perfect beginner-to-intermediate Python project because it touches nearly every core concept you'll use in production code: data structures for storing inventory, functions for organizing logic, loops for user interaction, exception handling for crash prevention, and arithmetic for business calculations.
This guide assumes you are a student, self-taught programmer, or coding bootcamp participant who has seen Python syntax before but wants a deeper understanding of why professional developers make the choices they do. Each of the 8 steps below dissects one key concept — its purpose, its implementation, how it operates at runtime, and why it matters in the real world.
By the end of this guide you will understand how a dictionary enables O(1) price lookups,
why while True with break is the correct pattern for user-driven loops,
how try/except prevents crashes from bad input, and why if __name__ == "__main__"
is considered mandatory in professional Python development.
Python dictionaries, functions, while loops, try/except error handling, list of tuples, f-string formatting, discount arithmetic, and the entry guard pattern — all through one coherent program.
A command-line fruit market simulation. Users browse Philippine fruit prices, add items to a cart, apply discount codes, and receive a formatted receipt — all built with core Python, no external libraries.
20–30 minutes to read through all 8 steps thoroughly. For best results, keep a Python terminal open alongside and type the snippets yourself to build muscle memory.
Basic Python syntax familiarity: variables, print statements, and if/else conditions. No prior knowledge of data structures, error handling, or functions is required to follow this guide.
# Philippine Fruit Retail Business Simulation # Core Python — no external libraries required fruits = { "mangoes": 180.00, "papayas": 75.00, "rambutan": 180.00, "coconuts": 50.00, "lanzones": 120.00, "mangosteen": 135.00, "bananas": 60.00, "pineapples": 75.00, "guavas": 50.00, "guyavanos": 130.00, "avocados": 120.00 } def display_fruits(): print("Available Fruits and Prices (per kg in PHP):") for fruit, price in fruits.items(): print(f"{fruit.capitalize()}: {price:.2f}") def get_discount(): codes = {"SALE10": 10, "FRESH15": 15, "FRUIT20": 20} while True: ans = input("Do you have a discount code? (yes/no): ").lower() if ans == 'yes': code = input("Enter your discount code: ").upper() if code in codes: discount = codes[code] print(f"Discount code accepted! {discount}% off applied.") return discount else: print("Invalid discount code. No discount applied.") return 0.0 elif ans == 'no': return 0.0 else: print("Please enter 'yes' or 'no'.") def calculate_total(): total_cost = 0.0 shopping_cart = [] while True: display_fruits() choice = input("\nEnter the fruit you want to buy (or 'done' to finish): ").lower() if choice == 'done': break if choice not in fruits: print("Invalid fruit selection.") continue try: quantity = float(input(f"Enter quantity in kg for {choice}: ")) if quantity <= 0: raise ValueError except ValueError: print("Invalid quantity. Please enter a positive number.") continue cost = fruits[choice] * quantity shopping_cart.append((choice, quantity, cost)) total_cost += cost print(f"Added {quantity} kg of {choice} for {cost:.2f} PHP.") if shopping_cart: print("\nShopping Cart Summary:") for item in shopping_cart: print(f"{item[0].capitalize()}: {item[1]} kg = {item[2]:.2f} PHP") discount_percent = get_discount() discount_amount = total_cost * (discount_percent / 100) final_total = total_cost - discount_amount print(f"\nSubtotal: {total_cost:.2f} PHP") if discount_percent > 0: print(f"Discount ({discount_percent}%): -{discount_amount:.2f} PHP") print(f"Total Cost: {final_total:.2f} PHP") else: print(f"\nTotal Cost: {total_cost:.2f} PHP") if __name__ == "__main__": print("Welcome to the Philippine Fruit Retail Business!") calculate_total() print("Thank you for shopping with us!")
Each section covers: Why · Snippet · How it operates · Significance
A dictionary (dict) is chosen because the program needs to link each fruit name to a price. Instead of maintaining two separate lists and manually keeping them in sync, a dictionary binds the name and price together as a single key-value pair, making the data self-contained and readable.
fruits = { "mangoes": 180.00, "papayas": 75.00, "rambutan": 180.00, "coconuts": 50.00, "lanzones": 120.00, "mangosteen": 135.00, "bananas": 60.00, "pineapples": 75.00, "guavas": 50.00, "guyavanos": 130.00, "avocados": 120.00 }
Python stores this as a hash table internally. When you write fruits["mangoes"], Python hashes the key "mangoes" and retrieves the value 180.00 in O(1) constant time — no looping required. You can add a new fruit with one line: fruits["guava"] = 90.00.
Speed and simplicity. Lookup is instant regardless of how many fruits exist. If we used a list instead, we'd have to loop through every item to find a match — an O(n) operation. The dictionary also makes the code self-documenting: anyone reading it immediately understands that "rambutan costs 180 PHP per kg."
The display logic is isolated into its own function so it can be called at the start of every shopping loop without duplicating code. .items() is used instead of looping through keys alone because we need both the name and price simultaneously. .capitalize() and :.2f ensure the output always looks clean and professional.
def display_fruits(): print("Available Fruits and Prices (per kg in PHP):") for fruit, price in fruits.items(): print(f"{fruit.capitalize()}: {price:.2f}")
fruits.items() returns each key-value pair as a tuple. The for fruit, price in ... line unpacks that tuple into two named variables in one step. fruit.capitalize() converts the first letter to uppercase. The f-string {price:.2f} formats the float to exactly 2 decimal places — so 50.0 prints as 50.00.
Reusability and separation of concerns. Because display is its own function, calculate_total() can call it at the top of every loop iteration with a single line. If the display format ever needs to change, you change it in one place only — not in every location it appears.
A while True loop is used because the number of items a customer wants to buy is unknown in advance. The program should keep asking for input until the user explicitly decides to stop. .lower() is applied so the comparison choice == 'done' works regardless of how the user types it — "Done", "DONE", and "done" all match.
while True: display_fruits() choice = input("\nEnter fruit or 'done' to finish: ").lower() if choice == 'done': break if choice not in fruits: print("Invalid selection.") continue
while True creates an infinite loop — it will never stop on its own. The only exit is the break statement, which fires when the user types "done". continue skips the rest of the current loop iteration and returns to the top immediately, re-displaying the fruit list and asking for input again when an invalid choice is entered.
User-driven flow control. Without this loop, the program would terminate after a single purchase. The while True + break pattern hands control to the user — the program ends only when they say so. continue prevents bad input from crashing or advancing the loop prematurely.
input() always returns a string. Converting it with float() will crash the program with an unhandled exception if the user types anything non-numeric (like "two" or "!"). A try/except block intercepts that crash and handles it gracefully. A manual raise ValueError is added to also catch logically invalid values like zero or negative quantities.
try: quantity = float(input(f"Enter quantity in kg for {choice}: ")) if quantity <= 0: raise ValueError except ValueError: print("Invalid quantity. Please enter a positive number.") continue
Python enters the try block and attempts float(...). If that fails (e.g. input is "abc"), Python raises a ValueError automatically. If float() succeeds but the result is ≤ 0, we manually raise ValueError ourselves. Either way, the except ValueError block catches it, prints an error message, and continue restarts the loop.
Crash prevention and user experience. Without this block, a single bad keystroke would terminate the program entirely — losing all cart data. With it, the program recovers silently and lets the user try again. This is the foundation of robust, production-grade input handling in any interactive Python program.
Each purchase is a fixed 3-part record: fruit name, quantity, and cost. A tuple is used for each entry because tuples are immutable — once created, that record cannot be accidentally changed. A list wraps all of them because lists are ordered and dynamic, allowing unlimited items to be appended.
cost = fruits[choice] * quantity shopping_cart.append((choice, quantity, cost)) total_cost += cost # Later — printing the summary: for item in shopping_cart: print(f"{item[0].capitalize()}: {item[1]} kg = {item[2]:.2f} PHP")
fruits[choice] * quantity computes cost by multiplying the dictionary price by quantity. shopping_cart.append((choice, quantity, cost)) adds the tuple as a new element at the end of the list. total_cost += cost is shorthand for total_cost = total_cost + cost, keeping a running sum. In the summary loop, item[0], item[1], item[2] access each part of the tuple by position.
Data integrity and clarity. Using immutable tuples inside a mutable list gives the best of both worlds: you can grow the cart freely, but individual purchase records stay protected. The running total_cost accumulator avoids re-summing the entire cart on every iteration, which is more efficient.
Discount codes are stored in a dictionary because code validation requires fast, exact key lookups. Using a dictionary instead of a chain of if/elif statements means the logic stays the same whether there are 3 codes or 300. .upper() is applied so codes are case-insensitive from the user's perspective.
codes = {
"SALE10": 10,
"FRESH15": 15,
"FRUIT20": 20
}
code = input("Enter your discount code: ").upper()
if code in codes:
discount = codes[code]
print(f"Discount code accepted! {discount}% off applied.")
return discount
else:
print("Invalid discount code. No discount applied.")
return 0.0
if code in codes checks whether the user's input exists as a key in the dictionary — this is a safe O(1) check that will never raise a KeyError. If it exists, codes[code] retrieves the associated integer discount percentage directly. If not, the else branch runs and returns 0.0, meaning no discount is applied.
Scalability and maintainability. Adding a new discount code only requires one new line in the dictionary — no logic changes needed. A chain of if/elif for each code would become unmanageable at scale. The in check before accessing also prevents KeyError exceptions that would crash the program.
The discount is stored as an integer percentage (e.g. 10) for readability. To apply it, we must convert it to a decimal multiplier by dividing by 100. The calculation is deliberately split into two separate variables — discount_amount and final_total — so each step can be displayed independently in the receipt summary.
discount_percent = get_discount() discount_amount = total_cost * (discount_percent / 100) final_total = total_cost - discount_amount print(f"Subtotal: {total_cost:.2f} PHP") if discount_percent > 0: print(f"Discount ({discount_percent}%): -{discount_amount:.2f} PHP") print(f"Total Cost: {final_total:.2f} PHP")
discount_percent / 100 converts e.g. 15 → 0.15. Multiplying by total_cost gives the peso amount to deduct. Subtracting yields the final price. The if discount_percent > 0 guard ensures the discount line only prints when a code was actually applied — keeping the receipt clean for customers with no discount.
Transparency and auditability. Breaking the calculation into named variables (discount_amount, final_total) makes the math readable and easy to debug. A customer can see exactly how much was deducted and why. This mirrors how real POS (point-of-sale) receipt systems work — showing subtotal, discount, and grand total as separate line items.
This guard is a Python best practice that separates the "runnable script" from the "importable module." Without it, the moment another Python file does import fruit_retail, the program would immediately launch the interactive shopping session — an unintended side effect. The guard prevents this by checking the context in which the file is being executed.
if __name__ == "__main__": print("Welcome to the Philippine Fruit Retail Business!") calculate_total() print("Thank you for shopping with us!")
Python sets the special variable __name__ to "__main__" when a file is run directly (e.g. python fruit_retail.py). When the file is imported by another module, __name__ is instead set to the file's module name ("fruit_retail"). The if check means the welcome message and calculate_total() call only execute in the first case.
Reusability and testability. This single pattern transforms the script into a proper module. Another developer could import display_fruits or get_discount into a larger retail system, or write unit tests for individual functions, without triggering the full program. It is considered mandatory in professional Python development.
The table below summarizes every Python concept featured in this program. Bookmark it as a study reference — each concept maps directly to a step in the guide above.
| Concept | Step | Key Takeaway |
|---|---|---|
| dict | 1 | O(1) key-value lookup; more scalable than parallel lists. |
| .items() | 2 | Iterates key-value pairs simultaneously via tuple unpacking. |
| f-strings | 2 | Embed expressions directly in strings with :.2f for currency formatting. |
| while True + break | 3 | User-driven loop that exits on explicit sentinel input ("done"). |
| continue | 3 | Skips remainder of loop body and restarts from the top immediately. |
| try / except | 4 | Catches runtime errors (e.g. float("abc")) and recovers gracefully. |
| raise ValueError | 4 | Manually triggers an exception for logically invalid values. |
| list of tuples | 5 | Mutable container holding immutable fixed-width records. |
| .append() | 5 | Adds items to the end of a list in O(1) amortized time. |
| in operator | 6 | Safe O(1) key membership check that prevents KeyError. |
| Arithmetic | 7 | Named intermediate variables improve readability and debuggability. |
| __name__ guard | 8 | Enables import without triggering execution; mandatory best practice. |
Save the shopping cart to a JSON file with json.dump() so records survive program restarts. This is the simplest form of data persistence in Python.
Use pytest to test get_discount() and calculate_total() in isolation. The __name__ guard makes this possible without triggering the full program.
Port the logic to Flask or FastAPI to serve a REST API. The functions translate almost 1:1 — calculate_total() becomes a POST endpoint accepting JSON cart data.
Track which fruits sell most with collections.Counter. After 10 transactions, you'll have real data to optimize your inventory stocking decisions.
In a real system, discount codes would be stored as bcrypt hashes, not plaintext. Look into hashlib for a Python-native hashing approach.
Replace the hardcoded fruits dict with a requests.get() call to a price API. This makes the program dynamic and always up to date.
Even experienced developers make these errors when first working with Python data structures and control flow. Recognizing them in your own code is a critical skill — and each mistake below maps directly to a concept covered in this guide.
Many beginners store fruit names and prices in two separate parallel lists and then use list.index() to find a price. This is O(n) for every search and breaks the moment the two lists fall out of sync. A dictionary is always the right choice when you need to map keys to values — its hash table implementation guarantees O(1) average lookups regardless of how many items you store.
except: instead of except ValueError:Writing except: without specifying an exception type will silently swallow every error in your program — including KeyboardInterrupt, SystemExit, and memory errors — making bugs nearly impossible to debug. Always catch the most specific exception type possible. In this program, except ValueError handles only the case where float() receives non-numeric input, leaving all other errors free to propagate and be noticed.
if __name__ == "__main__"Omitting the entry guard means that any test file or other module that imports your functions will immediately trigger the full interactive program. This makes automated testing impossible and confuses other developers consuming your code. Even for small scripts, always wrap top-level execution code in this guard. It costs one line and saves enormous debugging time later.
If you tried to remove items from shopping_cart inside the same for loop that reads it, Python would skip elements unpredictably. The correct pattern is to either iterate over a copy (for item in shopping_cart[:]), collect indices to remove and delete after, or rebuild the list using a list comprehension that filters out unwanted items. This program avoids the problem by only appending inside the loop — a safe operation.
==Floating-point arithmetic in binary can produce tiny rounding errors. Writing if total_cost == 100.00 may fail even when the value appears correct in a print statement. For currency calculations, use Python's decimal.Decimal type when exact precision is required, or compare with a small tolerance using abs(a - b) < 0.001. The program uses :.2f formatting for display, which rounds correctly for human reading but doesn't fix the underlying float representation.
input() without stripping whitespaceA user who accidentally types a space before or after their fruit name — " mangoes" instead of "mangoes" — will get an "Invalid fruit selection" error even though they typed the right word. This program uses .lower() for case normalization, but adding .strip() as well (input(...).strip().lower()) defends against leading and trailing whitespace. In production systems, always sanitize user input before validation.
The concepts in this program have layers of depth that a single tutorial cannot fully cover. Below are the most important things to explore next for each major concept — treat this as a structured learning roadmap beyond this guide.
Python's dict is a hash table. Understanding hash collisions, load factors, and why insertion order is preserved since Python 3.7 will make you a far more confident user of this structure. Read about defaultdict, Counter, and ChainMap from the collections module — they solve 80% of real-world dictionary challenges cleanly.
ValueError is just one node in Python's exception tree. Exception is the parent of all built-in non-system-exiting exceptions. Learning when to raise TypeError vs ValueError vs a custom InvalidQuantityError — and how to use raise ... from ...` for exception chaining — is essential for writing maintainable, debuggable code.
The :.2f in f-strings is part of Python's format specification mini-language. You can also pad strings with :<20, right-align numbers with :>10, display percentages with :.1%, and format large numbers with thousands separators using :,. Mastering this eliminates most manual string manipulation in display code.
The shopping cart in this program stores (fruit, quantity, cost) tuples where fields are accessed by index. Python's collections.namedtuple or typing.NamedTuple lets you access fields by name — item.fruit instead of item[0] — dramatically improving readability in larger codebases at zero memory cost.
When calculating totals from the shopping cart, a generator expression is more memory-efficient than building a full list: total = sum(cost for _, _, cost in cart). For large carts, generators process one item at a time without holding everything in memory — a critical distinction at scale.
The __name__ guard makes this program fully testable. With pytest and unittest.mock.patch('builtins.input'), you can simulate user input and verify that get_discount() returns the correct percentage for known codes — without ever needing a human at a keyboard. This is how production Python code is validated.
Stay up to date with new Python tutorials, code breakdowns, and programming insights by following us on your preferred platform. We post new guides weekly.
When should you choose a tuple over a list? This guide dives deep into mutability, performance, and when immutability is your friend in data modeling.
A complete breakdown of for, while, nested loops, list comprehensions, and when to use each. Includes common pitfalls like off-by-one errors and infinite loops.
Beyond try/except — learn about finally, else clauses, custom exceptions, exception chaining, and the art of catching the right exception at the right level.
From basic variable insertion to format specifiers, nested expressions, and Python 3.12 improvements. Format numbers, dates, and complex objects with precision.
Default arguments, *args, **kwargs, closures, decorators, and lambda functions — everything you need to write reusable, clean Python code.
defaultdict, Counter, dict comprehensions, nested dicts, and merging strategies. Elevate your dictionary skills from beginner to professional.
Join thousands of developers who get our weekly deep-dives on Python, programming concepts, and real-world project breakdowns delivered directly to their inbox. No spam, ever.
🔒 Your email is safe with us. Unsubscribe anytime. No spam.
Congratulations on completing this deep dive into the Philippine Fruit Retail Python program. What began as a simple command-line script turned out to be a comprehensive tour through the most important concepts in beginner-to-intermediate Python programming.
The beauty of this program is that every design decision was made deliberately. Dictionaries weren't chosen arbitrarily — they were chosen because hash tables provide constant-time lookups that lists cannot match. The while True loop wasn't a lazy choice — it was the correct pattern for user-driven indefinite input. The try/except block wasn't defensive paranoia — it was production-grade resilience that separates hobby scripts from real software.
As your next step, we encourage you to extend this program yourself. Add a new fruit, implement a loyalty points system, or port the logic to a web API. The best way to solidify these concepts is to write code that breaks them and then figure out why. Every bug you fix teaches you something a tutorial never could.
Happy coding — and as they say on the islands, salamat for reading. 🇵🇭
This is the clearest explanation of Python dictionaries I've found. The O(1) vs O(n) comparison made it click for me instantly. Thank you!
I love that you used a Philippine market example — it makes the code feel relevant to my experience. The while True + break pattern was something I'd been confused about for months.
The __name__ guard section alone saved my project. I had no idea why importing was triggering execution. Excellent write-up!