Operator Precedence

This task introduces the basics of arithmetic operator precedence and how adding parentheses changes the evaluation of expressions. You’ll learn that multiplication takes precedence over addition, and how to make that order explicit using parentheses for clarity and safety in financial or numerical code.

Remember that * has higher precedence than +. Compare two expressions — one with and one without parentheses — and print both results to see the difference.

• Use input() and int() for user data
• Calculate hours * rate + 50
• Then calculate (hours * rate) + 50 explicitly

1. Not using parentheses when needed: Beginners often forget how default order affects the final result.
2. Confusing which operator comes first: Some assume addition is evaluated before multiplication.
3. Assigning incorrect values: Placing the bonus outside the parentheses may lead to unintended results.
4. Forgetting to cast input: Using strings in arithmetic will cause type errors.
5. Comparing values incorrectly: Comparing string representations can also cause misleading outcomes.

Always break your expression into parts and check which operators apply first. If unsure, add parentheses for clarity.

• Ask for hours and rate as integers
• Calculate the first version: hours * rate + 50
• Then add parentheses: (hours * rate) + 50
• Print both results and explain the difference
• Use comments to describe what happens in each case

• Allow the user to enter a custom bonus and apply it conditionally
• Use float values instead of integers for rate
• Add tax calculation with * and - operators

This task explores the interaction between logical operators like and, not, and in within compound boolean expressions. You’ll learn how Python evaluates combined conditions and how parentheses can shift logical grouping — especially in decisions that involve more than two criteria.

Pay attention to the order in which not and and apply. Use parentheses to test variations in logic.

• Use input() for age and coffee status
• Check if age is over 16
• Check if coffee input is "no"
• Use and and not in in one line
• Add parentheses to modify evaluation flow

1. Not converting age to integer: All comparisons will fail if age is treated as a string.
2. Misplacing not: not in has different precedence than expected — test carefully.
3. Skipping parentheses: Without grouping, the logic may return the opposite result.
4. Incorrect boolean logic: not age > 16 behaves differently than age <= 16.
5. String comparison typos: Comparing “No” instead of “no” can break your condition.

When multiple conditions must be met, evaluate them one at a time, then group them logically.

• Get user inputs for age and coffee
• Convert age to integer and normalize text
• Check age > 16
• Check if coffee status is “no”
• Combine conditions with and and use not properly
• Test with and without parentheses

• Ask how many cups of coffee were consumed and limit the number
• Support multiple conditions using or
• Allow checking caffeine tolerance with an extra question

This task teaches how logical operators interact when combined with comparison expressions, especially in multi-part conditional checks. You'll learn how to group boolean expressions meaningfully and avoid incorrect logic that can result from misunderstood operator precedence. Parentheses are essential here for structuring readable, correct conditions in real-world validations.

Think about how or and and behave together: and has higher precedence than or. To ensure the correct logic, always use parentheses where needed.

• Use input() and float() for exam scores
• Calculate average score
• Apply the pass/fail logic with nested conditions
• Group average > 70 or score > 90 together
• Ensure all scores are >= 50

1. Misplacing parentheses: Without parentheses, and and or may not behave as expected, leading to students being marked incorrectly.
2. Wrong operator grouping: Checking only the average or one score without properly nesting conditions can break the logic.
3. Forgetting float conversion: Using input() without float() leads to string comparison errors.
4. Hardcoding only one pass condition: Forgetting to apply the “no score under 50” check may falsely approve poor results.
5. Incorrect logical logic: Using and instead of or in pass conditions gives overly strict evaluations.

In tasks involving multiple conditions, break down your logic into small decisions, then structure them with grouping to reflect correct evaluation order.

• Ask the user to enter 3 scores
• Convert scores to floats and store them
• Calculate the average
• Check if average > 70 or any score > 90
• Also check that all scores are ≥ 50
• Use parentheses to group conditions logically
• Print pass/fail based on the final condition

• Support 5 exams instead of 3 using a loop
• Include grade categories (A, B, C, Fail)
• Track which condition triggered pass/fail

This task reinforces how operator precedence impacts boolean logic involving not and and. You will practice grouping expressions and clearly separating conditional branches, avoiding mistakes caused by assuming wrong evaluation order. The task mimics real-life billing or access control scenarios.

Remember that not has higher precedence than and. If your logic isn’t giving the right result, add parentheses to clarify the grouping.

• Take user input for hours and VIP status
• Convert hours to int
• Check if hours > 5 and VIP is “no”
• Use not and comparison carefully
• Add parentheses and compare different outcomes

1. Not grouping not VIP correctly: This may cause logic to apply to the wrong condition.
2. Using not on the wrong part: not hours > 5 flips logic in an unintended way.
3. Ignoring string comparison: Comparing with "Yes"/"No" case-sensitively may lead to mismatches.
4. Skipping parentheses: Incorrect grouping can result in the wrong fee being charged.
5. Inverting logic accidentally: Using or instead of and may allow incorrect discounts.

Treat the two parts of the condition separately, then decide whether grouping with and or using not first changes the logic.

• Get the number of hours and VIP status
• Convert hours to integer
• Check if hours > 5 and not VIP
• Use parentheses to ensure correct logic
• Decide fee based on result and print it

• Handle more user types: VIP, guest, staff
• Apply hourly rates with tiered logic
• Print billing summary with tax and receipt

This task teaches advanced conditional logic involving boolean flags and numerical thresholds. You will combine and, or, and not operators, while being mindful of their precedence. You'll also learn how to clearly group and prioritize logic using parentheses to prevent logical errors when evaluating customer eligibility.

Break the rules into separate logical blocks and group them using parentheses. Prioritize clarity and correct short-circuiting in your conditional expression.

• Use and inside discount conditions
• Use or to evaluate multiple eligibility paths
• Watch out for not changing the meaning of a check
• Consider using intermediate variables for readability

1. Ignoring precedence of not: Applying not without parentheses can flip the wrong part of the condition, resulting in faulty discount logic.
2. Overlooking grouping: Writing is_member and total_spent > 200 or coupon_applied and total_spent > 100 without parentheses gives incorrect results.
3. Forgetting type conversion: If you take user input as string, comparisons like total_spent > 200 will silently fail.
4. Wrong logical combinations: Using or where and is needed may allow unintended discounts.
5. Incorrect final amount calculation: Always base your total calculation on the correctly chosen discount rate.

To design multi-branch logic, first map out each rule separately, then combine them using the right grouping strategy to ensure Python interprets them correctly.

• Input: is_member (bool), total_spent (float), coupon_applied (bool)
• Define three conditions for discount eligibility
• Group each logical rule using parentheses
• Evaluate the discount rate based on matched condition
• Apply the discount to total and print final amount

• Introduce a loyalty tier system with tier-specific discount percentages
• Add dynamic pricing where discount rate scales with amount spent
• Include an audit log showing which condition was triggered

This task enhances your ability to combine comparison and boolean logic with clear grouping using parentheses. You’ll see how logical flow and operator priority impact access control logic in a security context. Proper use of short-circuit logic also becomes essential to avoid redundant evaluation and ensure clarity in branching.

Consider breaking the access conditions into two separate blocks and then combining them using or. Always use parentheses to control evaluation order.

• Check if the user is an admin and has 2FA
• Or: check if the user is not an admin, has 2FA, and login_attempts < 3
• Use parentheses around each condition block
• Ensure the logic does not allow unauthorized access due to missing grouping

1. Incorrect grouping of conditions: Not using parentheses may lead to or overriding an intended and, granting access when it shouldn't.
2. Misunderstanding short-circuit behavior: Python may skip checking a second condition, which can be problematic if logic relies on it.
3. Hardcoding role logic: Trying to use one large flat expression without separating admin and user rules leads to unreadable and error-prone code.
4. Mixing strings with booleans: Comparing input like "True" with boolean True fails silently — always convert properly.
5. Redundant checks: Repeating the same condition more than once makes the logic inefficient and harder to debug.

Think like a security system: define roles and requirements, then encode them using grouped logic that prioritizes clarity and correctness.

• Take in three inputs: is_admin (bool), has_2fa (bool), login_attempts (int)
• Define admin rule: is_admin and has_2fa
• Define regular user rule: not is_admin and has_2fa and login_attempts < 3
• Combine both rules using or with parentheses
• Print access granted or denied accordingly

• Add access levels: read, write, admin, with different rules
• Use a function that takes multiple conditions and logs each check
• Track failed access attempts with a counter and lockout feature