Logical operators

This task teaches how to evaluate two separate conditions using the and operator and control flow using if/else. You'll understand how logical operators enforce multiple constraints and how user input affects outcomes.

• Using the and operator to combine requirements
• Understanding Boolean evaluation of input
• Basic decision-making with if/else
• Controlling output based on combined conditions

Convert the age to an integer and check that it is 18 or more. Then check if the ticket input is exactly "yes". Use and to combine both checks in one condition.

• Use input() to collect age and ticket status
• Convert the age to int before comparison
• Use ticket == "yes" to check ticket validity
• Use and to combine both checks

Many beginners forget to convert the age from a string to an integer, which causes comparison errors. Others may type "Yes" with a capital letter and expect it to match "yes". It’s also common to confuse and with or, which changes the logic entirely and leads to incorrect access permissions.

1. String comparison without type conversion: Trying to compare a string number to an integer without using int() will cause logic errors.
2. Case sensitivity in text inputs: "Yes" and "yes" are not the same in Python.
3. Incorrect use of or instead of and: This may allow people to pass even if one condition fails.
4. Reversed logic in output messages: Be careful which block your print() belongs to.
5. No validation for input format: Failing to prompt the user correctly may result in unexpected inputs like "maybe".

Think about access like a security guard. The person must be old enough and have a valid ticket. You must evaluate both conditions and only allow access if both are satisfied.

• Ask the user for their age and convert it to an integer
• Ask if the user has a valid ticket
• Check if the age is at least 18 and the ticket input is "yes"
• If both are true, print "Access granted"
• Otherwise, print "Access denied"

You can expand this program by adding more checks such as membership status, time of day, or even introducing a guest list. This allows you to experiment with more complex logic structures.

• Add a check for VIP status and allow access even if the ticket is missing
• Ask for the current hour and restrict entry after midnight
• Add a guest list and verify that the entered name is present in it
• Print different messages based on which condition failed

This task helps you understand how to use the or operator to evaluate alternate eligibility criteria. You’ll learn to check numeric and string values together, and apply flexible logic that lets the user qualify by meeting either of two conditions. It also encourages precise conditional structuring and good user messaging practices.

• Working with mixed condition types (numeric and string)
• Using the or operator to allow multiple valid paths
• Branching logic with if/else
• Clean output formatting for user-friendly results

Ask the user for two inputs: total order amount (as a float or integer) and membership status. Use or to check whether either condition is met, and remember to handle case sensitivity for user input.

• Use float(input()) or int(input()) for price
• Use lower() to simplify membership check
• Check if total is ≥ 50 or membership is "yes"
• Print "Free shipping!" if either condition is true

A frequent mistake is confusing or with and, which can cause the user to be unfairly denied free shipping. Another error is failing to convert the total price to a numeric type before comparison. Also, beginners often forget to normalize user input (like upper/lowercase), causing logic to fail when checking text.

1. Wrong operator used: Using and instead of or means both conditions must be met, which changes the intended logic completely.
2. Missing input conversion: Comparing strings like "40" to 50 without converting to float or int will always fail.
3. Input case sensitivity: Checking membership == "yes" fails if the user types "Yes" or "YES".
4. Not validating both inputs: Failing to gather both conditions could lead to incomplete logic and wrong outcomes.
5. Hardcoding logic: Relying only on one condition or hardcoding results breaks flexibility and real-life applicability.

You want your store to offer free shipping when either of two things is true. The customer can qualify by spending enough or by being a premium member. Your program should clearly check both and act accordingly.

• Ask the user for the order total
• Ask if they are a premium member ("yes" or "no")
• Convert the order total to a number
• Normalize membership input with .lower()
• Check if total is ≥ 50 or membership is "yes"
• If yes, print "Free shipping!"
• Else, print "Shipping fee applies."

You can improve this task by adding tiered benefits, such as discount thresholds or combining shipping and promo code logic. This helps you simulate a real-world shopping platform more accurately.

• Introduce promo codes for free shipping regardless of order total
• Add an elif branch that gives half-price shipping if total is between $30 and $49
• Track the number of orders a user places and give free shipping after 3 purchases
• Build a reusable function for shipping checks

This task teaches how to work with multiple Boolean inputs and apply logic to evaluate combined conditions. You’ll use and, or, and simple math to determine how many “healthy habits” were achieved. It helps you reason about thresholds and build multi-condition evaluations.

• Using multiple if conditions with or logic
• Combining Boolean flags and simple counters
• Applying thresholds to decide outcomes
• Thinking logically across several related conditions

Store the answers to each question as Boolean values (like True or False) and then count how many are True. If the total is 2 or more, print that the user earns a Wellness Star.

• Normalize user input like "yes"/"no" using .lower()
• Use variables to store True/False values
• Sum up the True values using simple arithmetic
• Use if total >= 2 to decide the result

A common issue is trying to write one giant if statement with complex and/or logic, which often leads to incorrect grouping or precedence errors. Beginners may also forget to convert text answers into Boolean values before performing calculations, which results in faulty logic.

1. Misusing operator precedence: Not using parentheses correctly leads to unexpected outcomes when mixing and and or.
2. Improper Boolean conversion: Using string values directly in conditions without converting to True/False.
3. Counting logic errors: Forgetting to increment the count only when a condition is True.
4. Hardcoding responses: Skipping dynamic input and assuming fixed values reduces flexibility.
5. Unclear user messages: Not informing the user what each input means can lead to confusion.

Think of this like a checklist. If the user did at least 2 good habits, they’re doing well. You need to gather responses, evaluate each one, and count how many are True.

• Ask the user three yes/no questions: exercise, healthy eating, and sleep
• Convert each answer into a Boolean value
• Add the number of True values
• If the count is 2 or more, print a positive message
• Otherwise, offer encouragement for tomorrow

Add more habits or different reward levels based on how many positive habits were done. You can also turn this into a full report with a rating system or feedback for each habit.

• Track 5–7 habits instead of 3
• Assign a score to each habit and calculate a total wellness score
• Provide personalized feedback based on which habits were skipped
• Use elif chains to create tiered results (bronze, silver, gold)

This task introduces how to use not in combination with and and equality checks to enforce multiple login conditions. You'll learn to verify secure access, combine Boolean conditions, and add logic that excludes users based on a flag (blocked status).

• Matching user credentials using equality operators
• Using not to filter blocked users
• Combining logic into one readable conditional
• Providing clear conditional feedback

Use three separate inputs: username, password, and block status. Convert block status to lowercase and use not (blocked == "yes") as part of the condition to ensure only unblocked users are allowed access.

• Use input() to get credentials and block status
• Check that username and password both match
• Use not to ensure blocked users are denied access
• Display an appropriate message based on result

It’s common to reverse the blocked logic and mistakenly grant access to blocked users. Also, many beginners forget to use parentheses around complex and/not expressions, resulting in incorrect outcomes.

1. Incorrect use of not: Placing not in the wrong place can completely reverse your logic.
2. Skipping parentheses: Mixing and and not without clear grouping leads to operator precedence issues.
3. Case sensitivity in credentials: Usernames like "Admin" vs "admin" can fail due to exact match requirements.
4. Insecure hardcoded logic: Not verifying all three conditions can leave the system vulnerable.
5. Feedback not clear: Not explaining why login was denied confuses users.

Think of the system like a bouncer at a club: the guest must be on the list (username/password) and not banned (blocked). If all checks pass, they’re in.

• Ask the user to input a username and password
• Ask if the user is blocked ("yes" or "no")
• Check if username and password match expected values
• Use not blocked to deny access if needed
• Print “Login successful” or “Access denied”

Extend the task into a real login flow with multiple users, password validation, and limited login attempts. You can also turn blocked status into a separate list.

• Read allowed users from a dictionary or list
• Simulate 3 login attempts before blocking the user
• Store blocked users in a list and check membership
• Track login attempts and time-based access rules

You will practice writing complex logical conditions that mix numerical thresholds and string values. This task helps you apply and/or/not in an optimized decision-making context and shows how logical grouping controls program behavior. It also teaches you to convert messy requirements into manageable, well-structured condition blocks.

• Working with multiple input types and values
• Designing nested and combined logical expressions
• Controlling program output based on system conditions
• Building readable condition trees with proper grouping

Break the condition into smaller logical groups. First, compare temperature and humidity. Then separately check if the window is closed and temperature is high. Use parentheses to manage operator precedence clearly.

• Convert temp and humidity to float
• Normalize window input using .lower()
• Use if (temp > 28 and humidity > 60) or (temp > 30 and window == "closed")
• Output recommendation accordingly

Many learners forget to use parentheses in complex logical expressions, which leads to wrong evaluation order. Others mix up string inputs with numeric checks, or forget to normalize text inputs. Improper logic nesting is a common pitfall when multiple or and and are combined.

1. No parentheses: Without parentheses, and binds tighter than or, which often changes the meaning of your condition.
2. Forgetting float conversion: Comparing a string to a number will never work correctly.
3. Unnormalized input: Not lowercasing "Open" or "Closed" leads to mismatches in condition checks.
4. Overly complex condition chains: Writing all in one line without organizing into readable blocks creates bugs and poor maintainability.
5. Inconsistent comparison logic: Switching from > to >= inconsistently changes system thresholds unexpectedly.

Start by identifying the key metrics: temperature, humidity, and window state. Use logic to break down both possible conditions under which AC should turn on.

• Ask the user for temperature (°C), humidity (%), and window status
• Convert numeric values using float()
• Normalize window input with .lower()
• Write one condition: temp > 28 and humidity > 60
• Write second condition: temp > 30 and window == "closed"
• Use or to combine the two logic branches
• Display “Turn on AC” if condition is true; else, say “No need to adjust”

You can enhance this logic by adding dynamic rules based on time of day, room occupancy, or electricity price. These additions simulate real smart home systems.

• Include a check for daytime/nighttime using user input
• Add a condition where price per kWh affects decision
• Introduce an override switch (“manual AC mode”)
• Build a function to encapsulate the logic and reuse it

You’ll build logic for rule validation across multiple simultaneous conditions. The exercise shows how to reject access when one key requirement fails even if the rest are okay. You’ll combine and with not to build exclusion logic.

• Checking required flags for system compliance
• Using not to block based on violations
• Validating a rule engine with multiple dependencies
• Writing a rejection reason that reflects the condition

Normalize all inputs, especially yes/no answers, and handle them consistently. Focus on building one compound condition that includes all three criteria with the proper combination of and and not.

• Use .lower() on all input strings
• Check if both webcam and screen are "yes"
• Ensure that background noise is not detected
• Use one compound if to handle all conditions together

Many beginners forget that not applies to entire conditions, not just variables. Improper input normalization also results in failed condition checks. And logic order matters - especially when prioritizing safety rules like background noise detection.

1. Negating wrong condition: not noise == "yes" may not behave as intended - use parentheses or clear logic.
2. Typos in input: "Yes" vs "yes" fails if not normalized.
3. Wrong use of and vs or: Swapping logic operators leads to letting unqualified students through.
4. Inverted logic: Accidentally allowing exams when not webcam is true.
5. Partial checks: Only verifying webcam or screen and forgetting the rest leaves vulnerabilities.

This system enforces a strict exam environment. All conditions must be satisfied simultaneously, so build one master if expression that reflects that.

• Ask the user for webcam, screen recording, and background noise status
• Normalize all inputs to lowercase
• Use webcam == "yes" and screen == "yes" and noise == "no"
• Display "Session valid" if all pass; else "Session flagged"
• Consider printing which rule failed for bonus clarity

Make the check more robust by tracking time of detection, logging rule violations, or allowing one minor violation with a warning system.

• Allow 1 failed rule before rejection and show a warning
• Log failed input states and show a full audit report
• Assign severity levels to each rule
• Use a loop to repeat checks every 30 seconds