# Arithmetic, Logical & Boolean Operators ## Arithmetic Operators ### What are arithmetic operators? - Arithmetic operators are **symbols or keywords** used to carry out mathematical calculations on numerical values - They enable computers to perform operations like addition, subtraction, multiplication, division, and others - Essential for any program that needs to process numerical data or perform calculations ### Addition operator (+) - The addition operator (+) adds numerical values together - Can also be used to **concatenate** (join) strings ```python total = 8 + 7 full_name = 'Sarah' + ' ' + 'Smith' ``` - In this example, the addition operator adds 8 and 7, giving 15 - It also joins the strings 'Sarah', ' ', and 'Smith' to create 'Sarah Smith' ### Subtraction operator (-) - The subtraction operator (-) subtracts one numerical value from another ```python difference = 15 - 6 ``` - In this example, 6 is subtracted from 15, resulting in 9 ### Multiplication operator (*) - The multiplication operator (*) multiplies numerical values together ```python result = 4 * 7 ``` - In this example, 4 and 7 are multiplied, resulting in 28 ### Exponentiation operator (^) - The exponentiation operator (^) raises a number to the power of another number - Multiplies a value by itself a specified number of times ```python result = 2 ^ 4 ``` - In this example, 2 is raised to the power of 4 (2*2*2*2), resulting in 16 ### Division operator (/) - The division operator (/) divides one numerical value by another ```python quotient = 20 / 4 ``` - In this example, 20 is divided by 4, resulting in 5 ### Modulus operator (MOD) - The modulus operator (MOD) returns the **remainder** after division - Useful for determining if numbers are divisible or for cycling through ranges ```python remainder = 17 MOD 5 ``` - In this example, 17 divided by 5 equals 3 with a remainder of 2 - 5 goes into 17 three complete times (15), leaving a remainder of 2

The modulus operator returns the remainder when one number is divided by another

### Operator precedence (BIDMAS/BODMAS) - Arithmetic operators follow **rules of precedence** determining evaluation order - Parentheses () can control the order of operations - BIDMAS/BODMAS stands for: Brackets, Indices/Orders, Division, Multiplication, Addition, Subtraction ```python result = 3 + 4 * 5 adjusted_result = (3 + 4) * 5 ``` - In the first example, multiplication is performed before addition: 4 * 5 = 20, then 3 + 20 = 23 - In the second example, parentheses force addition first: 3 + 4 = 7, then 7 * 5 = 35

Use parentheses to make your intended order of operations explicit, even when not strictly necessary

## Logical Operators ### What are logical operators? - Logical operators (also called **comparison operators**) compare values and return a boolean result - They enable comparison of variables or expressions to determine relationships, equality, or inequality - Always evaluate to either **true** or **false** ### Equal to (==) operator - The equal to operator (==) checks if two values are identical - Returns **true** if values match, **false** otherwise ```python a = 8 b = 9 print(a == b) ``` - In this example, 8 and 9 are compared - Since they are different numbers, **false** is printed ### Not equal to (!=) operator - The not equal to operator (!=) checks if two values are different - Returns **true** if values don't match, **false** if they do match ```python a = 8 b = 12 print(a != b) ``` - In this example, 8 and 12 are compared - Since they are not equal, **true** is printed ### Greater than (>) and less than (<) operators - The greater than operator (>) returns **true** if the left value exceeds the right value - The less than operator (<) returns **true** if the left value is smaller than the right value ```python a = 8 b = 15 print(a > b) print(a < b) ``` - The greater than comparison checks if 8 exceeds 15, resulting in **false** - The less than comparison checks if 8 is smaller than 15, resulting in **true** ### Greater than or equal to (>=) and less than or equal to (<=) operators - The greater than or equal to operator (>=) returns **true** if the left value is greater than **or equal to** the right value - The less than or equal to operator (<=) returns **true** if the left value is less than **or equal to** the right value ```python a = 8 b = 15 print(a >= b) print(a <= b) ``` - The >= comparison checks if 8 is greater than or equal to 15, resulting in **false** - The <= comparison checks if 8 is less than or equal to 15, resulting in **true**

Don't confuse = (assignment) with == (comparison) - they have completely different purposes

## Boolean Operators ### What are boolean operators? - Boolean operators combine and manipulate **boolean values** - They allow computers to perform logical operations, such as combining conditions, negating values, and determining truth - Used extensively in decision-making structures like if statements ### AND operator - The AND operator returns **true** only if **both** operands are true - Otherwise returns **false** ```python x = 8 y = 15 z = 20 result = (x < y) AND (y < z) ``` - The expression (x < y) AND (y < z) evaluates to **true** because both conditions are true - If either condition were false, the entire result would be **false** | Operand 1 | Operand 2 | Result | |-----------|-----------|--------| | True | True | True | | True | False | False | | False | True | False | | False | False | False | ### OR operator - The OR operator returns **true** if **at least one** operand is true - Returns **false** only if both operands are false ```python a = 8 b = 15 c = 20 result = (a > b) OR (b < c) ``` - The expression (a > b) OR (b < c) evaluates to **true** because the second condition is true - Even though the first condition is false, only one needs to be true for OR to return true | Operand 1 | Operand 2 | Result | |-----------|-----------|--------| | True | True | True | | True | False | True | | False | True | True | | False | False | False | ### NOT operator - The NOT operator **reverses** a boolean value - Returns **true** if the operand is false, and **false** if the operand is true ```python value = true result = NOT value ``` - In this example, the NOT operator negates **true**, resulting in **false** | Operand | Result | |---------|--------| | True | False | | False | True |

Boolean operators can be combined to create complex conditions - understand precedence: NOT, then AND, then OR

### Practical example combining operators ```python age = 17 has_permission = true is_member = false can_enter = (age >= 18 OR has_permission) AND NOT is_member ``` - First, NOT is_member evaluates to **true** (because is_member is false) - Then, (age >= 18 OR has_permission) evaluates to **true** (because has_permission is true) - Finally, **true** AND **true** evaluates to **true** - Therefore, can_enter is **true**