Question

More Conditional Tests: You don't have to limit the number of tests you create to 10 . If you want to try more comparisons, write more tests and add them to conditional_tests.py. Have at least one True and one False result for each of the following: \- Tests for equality and inequality with strings \- Tests using the lower () function \- Numerical tests involving equality and inequality, greater than and less than, greater than or equal to, and less than or equal to \- Tests using the and keyword and the or keyword \- Test whether an item is in a list \- Test whether an item is not in a list

Short answer

Create various conditional tests in Python using strings, numbers, logical operators, and lists, and ensure both True and False results for each test type.

Step-by-step solution

Set up the Python Environment

Start by creating a Python file named `conditional_tests.py` where you will write all your conditional tests. Make sure to open this file in a text editor.

String Equality and Inequality Tests

Write tests to check for equality and inequality with strings. Include both a condition that evaluates to True and one that evaluates to False. For example: ```python string_one = "apple" string_two = "banana" # Equality test (False) print(string_one == string_two) # False # Inequality test (True) print(string_one != string_two) # True ```

Using the lower() Function

Test string cases using the `lower()` function. Create checks that return both True and False. Example: ```python base_string = "Hello" # Lowercase comparison (True) print(base_string.lower() == "hello") # True # Exact string comparison (False) print(base_string.lower() == "HELLO") # False ```

Numerical Comparisons

Write tests for numerical comparisons involving various inequalities. Ensure to have both True and False results. Example: ```python num1 = 10 num2 = 20 # Check equality (False) print(num1 == num2) # False # Check inequality (True) print(num1 != num2) # True # Greater than test (False) print(num1 > num2) # False # Less than test (True) print(num1 < num2) # True # Greater than or equal test (True) print(num2 >= num1) # True # Less than or equal test (False) print(num1 <= 5) # False ```

Using 'and' and 'or' Keywords

Perform logical tests using `and` and `or` keywords. Ensure they have both True and False results. Example: ```python x = 5 y = 10 # Using 'and' (True) print(x < 10 and y > 5) # Using 'or' (True) print(x < 10 or y < 5) # Using 'and' (False) print(x > 10 and y > 5) # Using 'or' (False) print(x > 10 or y < 0) ```

Item Presence in a List

Test whether specific items are present or absent in a list to achieve both True and False outcomes. Example: ```python fruits = ["apple", "banana", "cherry"] # Item in list test (True) print("apple" in fruits) # True # Item not in list test (False) print("orange" in fruits) # False ```

Item Absence from a List

Check for items that are not present in a list, ensuring both True and False outcomes. Example: ```python cities = ["New York", "Los Angeles", "Chicago"] # Item not in list test (True) print("Miami" not in cities) # True # Incorrect item not in list test (False) print("Chicago" not in cities) # False ```

Verify Test Output

Run `conditional_tests.py` and verify the console output matches expected True/False results for each test case. Each output should show a logical True or False based on the test defined.

Key concepts

string comparison

In Python, string comparison allows you to determine whether two strings are equivalent or different. It involves checking strings for exact equality or inequality. The `==` operator is used to test for equality while the `!=` operator is used for inequality.
For instance, if you have two strings, `string_one = "apple"` and `string_two = "banana"`, you can test their equality or inequality as follows:

• print(string_one == string_two): This will output `False` because 'apple' and 'banana' are not the same.
• print(string_one != string_two): This will output `True` because 'apple' is indeed different from 'banana'.

String comparisons are sensitive to case, meaning `"Apple"` and `"apple"` would be considered different.

lower() function in Python

The `lower()` function in Python is used to convert all characters in a string to lowercase, which is particularly useful in string comparison operations where case insensitivity is desired.
For example, let’s say you have a string `base_string = "Hello"`. You can normalize the case as follows:

• print(base_string.lower() == "hello"): This will return `True` because 'hello' is the lowercase version of 'Hello'.
• print(base_string.lower() == "HELLO"): This will return `False` since 'hello' was compared against 'HELLO'.

The `lower()` method does not change the original string but returns a new string where all the characters are in lowercase. Thus, it's useful for comparing user-inputted strings in a consistent format.

numerical comparisons

Numerical comparisons are used to evaluate mathematical relations between numbers, and Python provides straightforward operators for this purpose. These operators are `==`, `!=`, `<`, `>`, `<=`, and `>=`.
Consider two numbers: `num1 = 10` and `num2 = 20`. You can perform the following tests:

• print(num1 == num2): Tests for equality and returns `False` since 10 is not equal to 20.
• print(num1 != num2): Tests for inequality and returns `True`.
• print(num1 > num2): Checks if 10 is greater than 20; expected output is `False`.
• print(num1 < num2): Compares if 10 is less than 20; outputs `True`.
• print(num2 >= num1): Evaluates if 20 is greater than or equal to 10; results in `True`.
• print(num1 <= 5): Tests if 10 is less than or equal to 5; gives `False`.

Using these operators, Python makes it easy to execute conditional logic based on numerical values.

logical operators in Python

Logical operators such as `and` and `or` are powerful tools in Python for combining multiple conditions in a single statement. These operators make evaluations more versatile and precise.
Imagine using two variables: `x = 5` and `y = 10`. Here’s how logical operators can be applied:

• print(x < 10 and y > 5): Returns `True` as both conditions are satisfied (5 < 10 and 10 > 5).
• print(x < 10 or y < 5): Returns `True` because at least one condition (5 < 10) is true.
• print(x > 10 and y > 5): Outputs `False` since the first condition (5 > 10) is not true.
• print(x > 10 or y < 0): Outputs `False` because neither condition is met.

The `and` operator needs all conditions to be true for the overall result to be true, whereas `or` only needs one condition to be true.

list membership testing

List membership testing in Python is done using the `in` and `not in` operators to verify if an element exists within a list.
For instance, with a list `fruits = ["apple", "banana", "cherry"]`, you can perform the following tests:

• print("apple" in fruits): Checks if 'apple' is in the list, which results in `True`.
• print("orange" in fruits): Tests for 'orange'; outputs `False` as it isn't in the list.

To check if an item is absent from a list, use `not in`:

• print("Miami" not in cities): With `cities = ["New York", "Los Angeles", "Chicago"]`, this result is `True`.
• print("Chicago" not in cities): Returns `False` since 'Chicago' is in `cities`.

List membership testing is concise and intuitive, making it easy to validate data presence.