Question

Conditional Tests: Write a series of conditional tests. Print a statement describing each test and your prediction for the results of each test. Your code should look something like this: \begin{tabular}{l} \hline car \(=\) 'subaru' \\ print("Is car == 'subaru'? I predict True. ") \\ print(car \(==\) 'subaru') \\ print("\backslashnIs car \(==\) 'audi'? I predict False. ") \\ print(car \(==\) 'audi') \\ \- Look closely at your results, and make sure you understand why each \\ line evaluates to True or False. \\ \- Create at least 10 tests. Have at least 5 tests evaluate to True and \\ another 5 tests evaluate to False. \end{tabular}

Short answer

You can create conditional tests such as checking if a string equals another or if it includes a substring.

Step-by-step solution

Initiate Variable

Firstly, we define a variable `car` with a value that we can use for our conditional tests. Let's set \( \text{car} = \text{'subaru'} \).

Create a Test Case for 'subaru'

Test the variable to check if it is exactly 'subaru'. We expect True:\[\text{print}("\text{Is car == 'subaru'? I predict True.}")\text{print}(\text{car} == \text{'subaru'})\]

Create a Test Case for 'audi'

Test if `car` equals 'audi'. As `car` holds 'subaru', we expect False:\[\text{print}("\text{Is car == 'audi'? I predict False.}")\text{print}(\text{car} == \text{'audi'})\]

Test Case for a Non-equal String

Check if `car` is not equal to 'bmw', expecting True:\[\text{print}("\text{Is car != 'bmw'? I predict True.}")\text{print}(\text{car} != \text{'bmw'})\]

Test Case for Upper Case Comparison

Test using case sensitivity, such as 'SUBARU' compared to 'subaru', expecting False since strings are case-sensitive:\[\text{print}("\text{Is car == 'SUBARU'? I predict False.}")\text{print}(\text{car} == \text{'SUBARU'})\]

Test with Startswith Method

Check if `car` starts with 'sub', expecting True:\[\text{print}("\text{Does car start with 'sub'? I predict True.}")\text{print}(\text{car.startswith('sub')})\]

Test Using Endswith Method

Check if `car` ends with 'aru', expecting True:\[\text{print}("\text{Does car end with 'aru'? I predict True.}")\text{print}(\text{car.endswith('aru')})\]

Includes a Substring

Test if 'ar' is in `car`, expecting True:\[\text{print}("\text{Is 'ar' in car? I predict True.}")\text{print}('ar' in \text{car})\]

Test for Exact Match with Uppercase

Check if `car` is 'SUBARU' in uppercase, expecting False:\[\text{print}("\text{Is car == 'SUBARU'? I predict False.}")\text{print}(\text{car} == \text{'SUBARU'})\]

Additional False Test

Test if `car` is exactly 'toyota', expecting False:\[\text{print}("\text{Is car == 'toyota'? I predict False.}")\text{print}(\text{car} == \text{'toyota'})\]

Key concepts

Boolean Expressions

In Python, Boolean expressions are fundamental to programming as they enable decision-making processes. A Boolean expression is essentially an expression that evaluates to either `True` or `False`. These expressions form the basis of conditional tests, allowing us to determine the flow of a program based on conditions.
For instance, when we write `car == 'subaru'`, the expression checks if the value of `car` is exactly `'subaru'`. Since Boolean expressions evaluate to `True` or `False`, this expression will return `True` when `car` indeed has the value `'subaru'`.
Boolean expressions use operators like:

• Equality (`==`): Checks if two values are the same.
• Inequality (`!=`): Checks if two values are different.
• Greater-than (`>`), less-than (`<`), greater-than-or-equal-to (`>=`), and less-than-or-equal-to (`<=`).

These expressions are integral to loops and conditional statements like `if`, `elif`, and `else`, providing a method for programs to dynamically respond to real-time data and inputs.

String Comparison

String comparison in Python allows us to evaluate whether two strings are equal or have any other relationship based on lexicographical order or content. Unlike numbers, strings are a sequence of characters, and every character is compared based on its ASCII value.
When using the equality operator `==` for strings, Python checks character by character alignment. For example, in our exercise, `car == 'subaru'` returns `True` because `subaru` matches perfectly with the string assigned to `car`. However, `car == 'audi'` returns `False`, as the two strings do not match.
Python also provides other methods and operators to enhance string comparison:

• `startswith()`: Determines if a string begins with specified characters.
• `endswith()`: Checks if a string ends with specific characters.
• Inclusion check `in`: Tests if one string is a substring of another, as seen with `'ar' in car`.

Remember, strings are compared in a case-sensitive manner by default, meaning that `'ABC'` is not equivalent to `'abc'`. This sensitivity can lead to unexpected results if not handled carefully.

Logical Statements

Logical statements in Python are statements that combine Boolean expressions using logical operators. They expand our ability to conduct more complex checks by combining multiple conditions.
The primary logical operators are:

• `and`: True if both operands are true.
• `or`: True if at least one operand is true.
• `not`: Inverts the value of a Boolean expression.

For example, in a logical test combining multiple conditions, such as `(car == 'subaru') and (car != 'audi')`, it evaluates to `True` only if both `car == 'subaru'` is `True` and `car != 'audi'` is `True`.
These tools allow developers to run checks over multiple conditions, making them especially useful in complex decision sequences within programs. Logical statements thus enhance Python's conditional structures, providing flexibility and power to determine how a program reacts to a series of inputs.

Case Sensitivity in Programming

Case sensitivity in programming refers to how programming languages treat uppercase and lowercase letters in identifiers such as variable names, strings, and commands. Python is a case-sensitive language, meaning that `Car`, `car`, and `cAR` would all be interpreted differently.
When performing string comparisons, Python distinguishes between uppercase and lowercase characters, which can lead to potential pitfalls. For instance, `car == 'SUBARU'` evaluates to `False` when `car` is `'subaru'` because Python considers `'SUBARU'` and `'subaru'` to be different strings due to their cases.
Due to this case sensitivity, it is vital to be consistent with variable names and string literals in code. At times, you might want case-insensitive comparisons, which can be achieved using methods like `lower()` or `upper()`, to convert strings to a uniform case before comparison.

• `car.lower() == 'subaru'` will return `True` if `car` is `'SUBARU'`.
• Maintaining consistency in capitalization helps avoid logic errors and makes code more readable.

Understanding Python's case sensitivity is crucial for accurate string manipulations and enhancing the application's reliability.