# **Operators in Python** This section details the various operators available in Python for performing arithmetic, bitwise, comparison, and logical operations, as well as the conditional statements used to control program flow based on these operations. ## **3.8.1 Arithmetic Operators** Arithmetic operators are used to perform mathematical calculations. - **Standard Operators:** - `+` : *Addition* - `-` : *Subtraction* - `*` : *Multiplication* - `/` : *Division* (results in a float) - **Specialized Python Operators:** - `%` (*Modulo*): Returns the remainder of a division. For example, `5 % 4` results in `1`. - `//` (*Integer/Floor Division*): Performs division and discards the decimal portion, returning only the whole number. For example, `5 // 4` results in `1`. - `**` (*Exponentiation*): Raises the first operand to the power of the second. For example, `2 ** 3` results in `8`. - **Operator Precedence:** The order in which Python evaluates arithmetic expressions is: 1. Parentheses `()` 2. Exponentiation `**` 3. Multiplication `*`, Division `/`, Floor Division `//`, Modulo `%` (evaluated left-to-right) 4. Addition `+`, Subtraction `-` (evaluated left-to-right) - **Augmented Assignment Operators:** These operators combine an arithmetic operation with an assignment. - `+=` (e.g., `i += 1` is shorthand for `i = i + 1`) - `-=` (e.g., `i -= 2` is shorthand for `i = i - 2`) - `*=` (e.g., `i *= 3` is shorthand for `i = i * 3`) ## **3.8.2 Bitwise Operators** Bitwise operators perform operations on binary numbers (bits). For more on how data is represented in bits, see . - `&` (*AND*): Sets each bit to 1 if *both* corresponding bits are 1. - `|` (*OR*): Sets each bit to 1 if *at least one* of the corresponding bits is 1. - `^` (*XOR* - Exclusive OR): Sets each bit to 1 if *only one* of the corresponding bits is 1. - `~` (*NOT*): Inverts all the bits (0s become 1s and 1s become 0s). - `<<` (*Left Shift*): Shifts all bits one place to the left. The leftmost bit is discarded and a 0 is added to the right. - `>>` (*Right Shift*): Shifts all bits one place to the right. The rightmost bit is discarded and a 0 is added to the left. ## **3.8.3 Membership Operators** These operators test for membership in a sequence (like strings, lists, or tuples). - `in`: Returns `True` if a specified value is found in the sequence. - `not in`: Returns `True` if a specified value is *not* found in the sequence. ## **3.8.4 Comparison Operators** Comparison operators are used to compare two values and return a Boolean result (`True` or `False`). They are essential for decision-making in programs. | Operator | Name | Example | | :------: | -------------------------- | :---------: | | `==` | Is equal to | `x == y` | | `!=` | Is not equal to | `x != y` | | `>` | Greater than | `x > y` | | `<` | Less than | `x < y` | | `>=` | Greater than or equal to | `x >= y` | | `<=` | Less than or equal to | `x <= y` | ## **3.8.5 Logical Operators** Logical operators are used to combine multiple conditional statements. These function similarly to . - `and`: Returns `True` only if *all* conditions are true. - `or`: Returns `True` if *at least one* condition is true. - `not`: Reverses the result; returns `False` if the result is true, and `True` if the result is false. ## **3.8.6 Conditional Statements** Conditional statements control the flow of a program based on certain conditions. ### **`if` Statement** - The `if` statement executes a block of code *only if* its condition evaluates to `True`. If the condition is false, the block is skipped. ### **`if-else` Statement** - This structure provides an alternative path. - The `if` block is executed if the condition is `True`. - The `else` block is executed if the condition is `False`. ### **`if-elif-else` Statement** - This is used to check multiple, sequential conditions. `elif` is short for "else if". - Python checks the `if` condition first. If it's `True`, its block is executed, and the rest of the statement is skipped. - If the `if` condition is `False`, it checks the first `elif` condition. If that is `True`, its block is executed. - This continues for any subsequent `elif` blocks. - The `else` block at the end is a catch-all; it executes only if *all* preceding `if` and `elif` conditions were `False`. - *The order of conditions is crucial*, as the first true condition found will be the only one to execute. For example, when checking if a number is zero, even, or odd, you should check for zero first (`if num == 0:`), as `0 % 2 == 0` would otherwise incorrectly classify it as even.