Constants

This task teaches how to define constants using all-uppercase naming, how to use those constants in conditional logic, and how to compare user input with a fixed reference value. It builds good habits around using constants for configuration-like values.

• Define SPEED_LIMIT = 60 or any value at the top of the script.
• Use input() to get the user’s speed and convert it to an integer.
• Compare the current speed to the constant using an if statement.
• Use clear messages for both outcomes.

1. Using lowercase for constants: Constants should be written in uppercase to clearly indicate they shouldn’t be changed.
2. Hardcoding the limit instead of using a constant: Always use the constant in your condition - don’t type 60 again.
3. Forgetting to convert input: Without using int(), comparing a string to a number will cause errors.
4. Reassigning the constant: Don’t modify a constant’s value later in the program - treat it as locked.
5. Unclear output: Messages should clearly inform the user whether they’re over the limit or not.

This is a simple check using a fixed reference value. Think of it like a speed radar.

1. Define a constant SPEED_LIMIT and assign it a number (e.g., 60)
2. Ask the user to input their current speed
3. Convert the input to an integer
4. Use if to compare the speed to the constant
5. Print the appropriate message based on the comparison

• Include how many km/h over the limit the driver is.
• Add a warning if the user exceeds the limit by more than 20 km/h.
• Let the user choose between different zones with different speed limits (use multiple constants).

This task shows how to use constants in real-world health or fitness-related logic. You’ll practice subtraction, conditionals, and clean variable naming - all using a fixed constant for comparison.

• Define DAILY_CALORIE_LIMIT = 2000 at the top of the script.
• Get user input and convert it to a number using int().
• Use if/else to check whether they’re over or under the limit.
• Calculate and display the difference clearly.

1. Incorrect subtraction: Be clear about whether you’re calculating “calories left” or “extra calories”.
2. Hardcoding the limit again: Use the constant in every calculation - don’t retype the number.
3. Unclear or vague messages: Make sure the user knows exactly how much they’ve gone over or how much room they have left.
4. Reusing constant names as variables: Never reassign a constant - always treat it as fixed.
5. Ignoring formatting: Don’t print raw numbers without context. Always say “calories left” or “calories over”.

This is a budget tracker for calories. Think of it as checking your nutritional spending.

1. Define the constant DAILY_CALORIE_LIMIT
2. Ask the user to input how many calories they’ve consumed
3. Convert the input to an integer
4. Compare the input to the calorie limit
5. Calculate the difference depending on whether they’re over or under
6. Display a message with the result

• Let the user enter calories from multiple meals and sum them up.
• Add constants for protein, fat, and carb limits and track them too.
• Store the remaining/over amount in a variable and use it in other messages.

This task shows how constants can be used in both base calculations and discount logic. You’ll also practice multiplication, conditional discounting, and formatting output clearly using fixed values.

• Define BASE_TICKET_PRICE = 12 and DISCOUNT_RATE = 0.1 at the top.
• Use int() to get the number of tickets from the user.
• Multiply to get the total price, and apply the discount if needed.
• Use round() to clean up the final price.

1. Not using the constants in all places: Always use BASE_TICKET_PRICE and DISCOUNT_RATE - don’t hardcode 12 or 0.1 again later.
2. Forgetting to apply the discount: Check the ticket count before applying any calculation logic.
3. Wrong discount formula: You must subtract the discount from the total, not just multiply by the discount rate.
4. Messy output: Make sure your total is rounded and clearly labeled with the dollar sign.
5. Reassigning constants: Never change the values of BASE_TICKET_PRICE or DISCOUNT_RATE mid-program.

This is a classic ticket checkout simulation with optional discounts. Think of it like a small ticket machine.

1. Define BASE_TICKET_PRICE and DISCOUNT_RATE as constants
2. Ask the user how many tickets they want
3. Multiply ticket count by base price to get the total
4. Check if the user bought more than 5 tickets
5. If so, apply discount: total = total - total × DISCOUNT_RATE
6. Display the final amount owed, rounded to 2 decimal places

• Let the user choose between adult and child tickets using separate constants.
• Use different discounts based on ticket quantity (e.g., 10% for 5+, 20% for 10+).
• Ask if the user has a promo code and apply an extra discount.

This task demonstrates how constants are used for exchange rates and fixed references. You’ll also practice multiplication, numeric formatting, and string composition using monetary values.

• Use float() to allow decimal input.
• Multiply the dollar amount by the constant to get the result.
• Use round() or f-strings to display the result with 2 decimal places.

1. Forgetting type conversion: User input must be converted to float or int before using in calculations.
2. Reversing the formula: Make sure you're multiplying USD by the exchange rate to get EUR - not the other way around.
3. Displaying too many decimals: Round the result to 2 digits for currency accuracy.
4. Hardcoding the rate: Use the constant USD_TO_EUR_RATE for all calculations - don’t retype the number.
5. Missing symbols in output: Add $ and € symbols in your message for clarity.

This is a single-step conversion based on a fixed rate. Think of it like a digital money exchange.

1. Define the constant USD_TO_EUR_RATE (e.g., 0.91)
2. Ask the user how many USD they want to convert
3. Convert the input to a float
4. Multiply the amount by the constant
5. Round the result to 2 decimal places
6. Display a message showing both amounts and their units

• Let the user choose which direction to convert (USD → EUR or EUR → USD).
• Add constants for multiple currencies and allow selection.
• Apply a transaction fee stored in another constant.

This task teaches how to use constants to manage logic branches and pricing rules. You’ll practice working with conditionals, comparison operators, and applying clear naming conventions for business rules.

• Define all constants at the top of your program.
• Use float() for weights since they may include decimals.
• Use if / elif / else to determine the right pricing tier.
• Always use constants in the print() statement - not hardcoded numbers.

1. Not using constants throughout: If you write 5.0 directly into logic, the benefit of using constants is lost.
2. Incorrect range handling: Carefully structure your conditions to avoid overlaps or missed cases.
3. Missing decimal conversion: Always convert input to float() before comparing with thresholds.
4. Inconsistent output: Round all currency outputs and include clear units like “USD”.
5. Skipping the fallback condition: Always have an else block for safety, even if not strictly needed.

Imagine this as an online store’s shipping calculator. The program selects a price tier based on weight.

1. Define BASE_COST, MEDIUM_COST, and HEAVY_COST at the top
2. Ask the user to input the package weight in kilograms
3. Convert input to a float
4. Use if / elif / else to apply correct pricing logic
5. Display the final cost using the constant name, not a hardcoded number

• Include an additional constant for handling fees and add it to all prices.
• Allow the user to choose between standard and express delivery (use constants for both rates).
• Calculate total cost for multiple packages in one session.

This task helps you build rule-based systems using constants and conditionals. It also reinforces the practice of replacing raw values with well-named constants for better readability and scalability.

• Use integer constants for grade boundaries, not strings.
• Make sure your comparisons go from highest to lowest grade.
• Use if / elif blocks to avoid overlapping grade outputs.
• Format output clearly: e.g., “Your grade: B”.

1. Checking grades in the wrong order: If you check for GRADE_D first, it will trigger before reaching higher grades. Always check from highest to lowest.
2. Reusing constant values manually: Don’t type 90 or 70 directly - always reference the constant.
3. Missing an “else” fallback: If the student scores below all thresholds, show a clear failure message.
4. Invalid data input: Always convert input to an integer and consider what happens if it’s over 100 or below 0.
5. Spelling errors in print output: Ensure grade letters are uppercase and messages are consistent.

This task models a grading policy where ranges are clearly defined and enforced. Think like a grading system.

1. Define constants for A, B, C, D thresholds at the top
2. Ask the user to input their exam score
3. Convert input to integer
4. Use if / elif to check score ranges in descending order
5. Display the corresponding grade or a fail message

• Let the user enter scores for multiple subjects and show average + grade.
• Add a GRADE_F constant and support “pass/fail” labeling.
• Support custom thresholds by asking the teacher to input them.