Table of Contents | |

## Python Operators

**Python operators** are special symbols that let you perform different actions on values within your code. You have operators for doing math (like **+**, **–**, *****), comparing things (like **==**, **<**, **>**), checking logic (like **and**, **or**, **not**), and even changing the values themselves. Understanding these operators is key to writing Python code that can calculate, solve problems, and make decisions based on the data you give it.

### Python Operators Example

Here’s a comprehensive example that shows the most common **Python operators**, along with clear comments for explanations:

```
# Arithmetic Operators
result = 10 + 5 # Addition
result = 20 - 3 # Subtraction
result = 2 * 5 # Multiplication
result = 10 / 2 # True division
result = 15 // 4 # Floor division (rounds down to whole number)
result = 17 % 3 # Modulo (remainder)
result = 2 ** 3 # Exponentiation (2 to the power of 3)
# Comparison Operators
is_equal = 5 == 5 # Equality
is_not_equal = 4 != 2 # Not equal
is_greater = 10 > 8 # Greater than
is_less = 3 < 5 # Less than
is_greater_equal = 6 >= 6 # Greater than or equal to
is_less_equal = 4 <= 4 # Less than or equal to
# Logical Operators
is_true = True and False # Logical AND
is_true = True or False # Logical OR
is_true = not False # Logical NOT
# Bitwise Operators
result = 5 & 3 # Bitwise AND
result = 5 | 2 # Bitwise OR
result = ~4 # Bitwise NOT (inverts the bits)
result = 4 ^ 3 # Bitwise XOR (exclusive OR)
result = 12 << 1 # Bitwise left shift (multiplies by 2)
result = 6 >> 1 # Bitwise right shift (divides by 2)
# Assignment Operators
value = 10
value += 5 # Equivalent to value = value + 5
value -= 2 # Equivalent to value = value - 2
value *= 3 # Equivalent to value = value * 3
# ... and others like /=, //=, %=, **=, &=, |=, ^=, <<=, >>=
# Identity Operators
x = 5
y = 5
is_same = x is y # Checks if objects refer to the same memory location
is_not_same = x is not y # Checks if objects refer to different memory locations
# Membership Operators
list_data = [1, 2, 3]
is_member = 2 in list_data # Checks if a value is present in a sequence
is_not_member = 5 not in list_data # Checks if a value is not in a sequence
```

## Understanding Operands

In Python, **operands** are the elements you use with operators to perform actions. Operands can be variables, numbers, strings, or even calculations.

- Variables store values and are referenced by their names (e.g.,
**x**,**name**). - Numbers can be integers (whole numbers) or floats (decimals).
- Strings are text enclosed in quotes (single

or double**''**

quotes).**""**

**Example**

```
age = 30 # Assign the value 30 (integer) to the variable `age`
message = "Hello, world!" # Assign the string "Hello, world!" to the variable `message`
total_days = age * 365 # Calculate total days (multiplication)
print(f"{message}. You've lived for {total_days} days.")
```

**Code Explanation**

**Line 1:**Assigns the integer value`30`

to the variable`age`

.**Line 2:**Assigns the string “**Hello, world!**” to the variable`message`

.**Line 3:**Calculates`total_days`

`age`

`365`

(integer). Notice the operands involved in the calculation.**Line 4:**Uses an f-string to print a message that combines the string from`message`

`total_days`

.

**Output**

Hello, world!. You’ve lived for 10950 days.

## Understanding Expressions

In Python, **expressions** are combinations of operands (values) and operators that create a single result. These expressions involve variables, numbers, strings, and even function calls. Parentheses can be used to group parts of the expression and control the order of operations.

**Example**

```
# Calculate the area of a rectangle (length x width)
length = 5 # Assign length as 5
width = 3 # Assign width as 3
area = length * width # Calculate area using multiplication
# Calculate the volume of a box (length x width x height)
height = 2 # Assign height as 2
volume = length * width * height # Notice parentheses around length * width
print(f"The area of the rectangle is: {area}")
print(f"The volume of the box is: {volume}")
```

**Code Explanation**

**Lines 2-3:**Assign values to`length`

`width`

.**Line 4:**Calculates the area by multiplying`length`

`width`

.**Lines 7-8:**Assign a height and calculate the volume using parentheses to ensure the multiplication of`length`

`width`

`height`

.**Lines 10-11:**Print the calculated area and volume using f-strings.

**Output**

The area of the rectangle is: 15

The volume of the box is: 30

## Arithmetic Operators in Python

Python’s arithmetic operators are used for calculations. You have addition (**+**), subtraction (**–**), multiplication (*****), and division (**/**). Additionally, the floor division operator (**//**) rounds down the result to a whole number, and the modulo operator (**%**) gives you the remainder after a division. These handy operators are essential for writing Python programs that crunch numbers, compute values, and make decisions based on calculations.

### Addition ( `+`

)

The addition operator (**+**) in Python is for combining numbers or strings. When adding numbers, it behaves as you’d expect for regular addition. However, if you add strings, Python concatenates (joins) them together.

**Example**

```
num1 = 15
num2 = 4
result = num1 + num2 # Add num1 and num2
print(f"Addition: {num1} + {num2} = {result}")
```

**Code Explanation**

**Line 1:**Assigns the value**15**to the variable`num1`

.**Line 2:**Assigns the value**4**to the variable`num2`

.**Line 3:**Calculates the sum of`num1`

`num2`

, storing the result in the`result`

**Line 4:**Prints a user-friendly message to the console using an f-string. It displays the values of`num1`

,**num2**, and the calculated`result`

.

**Output**

Addition: 15 + 4 = 19

### Subtraction ( `-`

)

The subtraction operator (**–**) in Python lets you remove one number from another. It’s straightforward for calculations, subtracting the second operand from the first.

**Example**

```
num1 = 15
num2 = 4
result = num1 - num2 # Subtract num2 from num1
print(f"Subtraction: {num1} - {num2} = {result}")
```

**Line 3:** Calculates the difference between `num1`

** **and `num2`

, storing the result in the `result`

** **variable.

**Output**

Subtraction: 15 – 4 = 11

### Multiplication ( `*`

)

The multiplication operator (*****) in Python is handy when you need to multiply numbers.

**Example**

```
num1 = 15
num2 = 4
result = num1 * num2 # Multiply num1 and num2
print(f"Multiplication: {num1} * {num2} = {result}")
```

**Line 3:** Multiplies the values in `num1`

** **and `num2`

** **using the asterisk (** ***) operator, and assigns the calculation’s result to the variable

`result`

.**Output**

Multiplication: 15 * 4 = 60

### Division ( `/`

)

The division operator (**/**) in Python divides one number by another. However, the result is always a floating-point number (a decimal value), even if both operands are integers.

**Example**

```
num1 = 15
num2 = 4
result = num1 / num2 # Divide num1 by num2
print(f"True Division: {num1} / {num2} = {result}")
```

**Line 3:** Performs true division. It divides `num1`

** **by `num2`

** **using the forward-slash (** /**) operator and stores the result (a floating-point number) in the

`result`

**variable.**

**Output**

True Division: 15 / 4 = 3.75

### Modulus ( `%`

)

Python’s modulo operator (**%**) is a bit trickier but useful! It gives you the remainder after performing a division.

Imagine you have a certain number of candies (dividend) and want to share them equally among friends (divisor). The remainder you get using the modulo operator tells you how many candies are leftover after everyone gets a share.

**Example**

```
num1 = 15
num2 = 4
result = num1 % num2 # Calculate remainder after dividing num1 by num2
print(f"Modulo: {num1} % {num2} = {result}")
```

**Line 3:** Calculates the remainder after the division of `num1`

** **by `num2`

** **using the modulo operator (** %**) and assigns the result to the variable

`result`

.**Output**

Modulo: 15 % 4 = 3

### Exponentiation ( `**`

)

The exponentiation operator (******) in Python raises a number (base) to a certain power (exponent). It’s a shorthand way of writing out repeated multiplication of the base number.

**Example**

```
num1 = 15
num2 = 4
result = num1 ** 2 # Raise num1 to the power of 2 (num1 * num1)
print(f"Exponentiation: {num1} ** 2 = {result}")
```

**Line 3:** Calculates the square of `num1`

** **(raises `num1`

** **to the power of** **2) using the exponentiation operator (** ****) and stores the result in the

`result`

**variable.**

**Output**

Exponentiation: 15 ** 2 = 225

### Floor Division ( `//`

)

The floor division operator (**//**) is handy when you need to divide numbers and discard any remainder, rounding down to the nearest whole number.

**Example**

```
num1 = 15
num2 = 4
result = num1 // num2 # Divide num1 by num2 (disregard remainder)
print(f"Floor Division: {num1} // {num2} = {result}")
```

**Line 3:** Performs floor division. It divides `num1`

** **by `num2`

** **using the double forward-slash (** //**) operator, discards any remainder and stores the integer quotient in the

`result`

**variable.**

**Output**

Floor Division: 15 // 4 = 3

## Comparison Operators in Python

**Python’s comparison operators** allow you to compare values and determine their relationship. You can use them to check if one value is equal to another (**==**), greater than (**>**), less than (**<**), greater than or equal to (**>=**), less than or equal to (**<=**), or not equal (**!=**). These operators are either **True **or **False**, making them essential for conditional logic in your programs.

### Equal ( `==`

)

Python’s equal operator (**==**) checks whether two values are identical. It returns **True **if the values are equal and **False **otherwise.

**Example**

```
value1 = 20
value2 = 10
is_equal = value1 == value2 # Check if value1 is equal to value2
print(f"{value1} == {value2}: {is_equal}")
```

**Code Explanation**

**Line 1:**Assigns the value**20**to the variable`value1`

.**Line 2:**Assigns the value**10**to the variable`value2`

.**Line 3:**Tests if`value1`

`value2`

operator, storing the Boolean result (True or False) in`==`

`is_equal`

.**Line 4:**Prints the values compared (`value1`

and`value2`

), the comparison symbol (), and the comparison result (`==`

`is_equal`

).

**Output**

20 == 10: False

### Not Equal ( `!=`

)

The not equal operator (**!=**) in Python does the opposite of the equal operator. It checks if two values are different. It returns **True **if the values are not equal and **False **otherwise. This can be useful for identifying unequal values or making decisions based on differences.

**Example**

```
value1 = 20
value2 = 10
is_not_equal = value1 != value2 # Check if value1 is not equal to value2
print(f"{value1} != {value2}: {is_not_equal}")
```

**Line 3:** Compares if `value1`

** **is not equal to `value2`

** **using the not equal to operator (** !=**). The result (True or False) is stored in the variable

`is_not_equal`

.**Output**

20 != 10: True

### Greater Than ( `>`

)

The greater than operator (**>**) in Python helps you determine if one value is larger than another.

**Example**

```
value1 = 20
value2 = 10
is_greater = value1 > value2 # Check if value1 is greater than value2
print(f"{value1} > {value2}: {is_greater}")
```

**Line 3:** Uses the greater than operator (** >**) to check if

`value1`

**is greater than**

`value2`

. The comparison result (True or False) is stored in the `is_greater`

**variable.**

**Output**

20 > 10: True

### Less Than ( `<`

)

The less than operator (**<**) in Python works the other way around than the greater than operator. It checks if one value is smaller than another.

**Example**

```
value1 = 20
value2 = 10
is_less = value1 < value2 # Check if value1 is less than value2
print(f"{value1} < {value2}: {is_less}")
```

**Line 3:** Uses the less than operator (** <**) to compare if

`value1`

**is less than**

`value2`

. The result of this comparison (True or False) is stored in the `is_less`

**variable.**

**Output**

20 < 10: False

### Greater Than or Equal To ( `>=`

)

The greater than or equal to operator (**>=**) in Python lets you check if one value is strictly greater than or equal to another.

**Example**

```
value1 = 20
value2 = 10
is_greater_or_equal = value1 >= value2 # Check if value1 is greater than or equal to value2
print(f"{value1} >= {value2}: {is_greater_or_equal}")
```

**Line 3:** Uses the greater than or equal to operator (**>=**) to check if `value1`

** **is either greater than or equal to **value2**. The result of this comparison (True or False) is stored in the variable `is_greater_or_equal`

.

**Output**

20 >= 10: True

### Less Than or Equal To ( `<=`

)

The less than or equal to operator (**<=**) in Python comes in handy when you need to check if a value is strictly less than another value or equal to it.

**Example**

```
value1 = 20
value2 = 10
is_less_or_equal = value1 <= value2 # Check if value1 is less than or equal to value2
print(f"{value1} <= {value2}: {is_less_or_equal}")
```

**Line 3:** Uses the less than or equal to operator (** <=**) to determine if

`value1`

**is less than or equal to**

`value2`

. The Boolean result (True or False) is stored in the variable `is_less_or_equal`

.**Output**

20 <= 10: False

## Logical Operators in Python

**Logical operators in Python** allow you to combine and manipulate conditions to make more complex decisions within your code. The three main ones are **and**, **or**, and **not**. These operators evaluate statements that result in True or False. The **and** operator requires both conditions to be True for the overall result to be True. The **or** operator is more flexible, requiring at least one condition to be True for a True result. Lastly, the **not** operator flips things around, reversing the True/False value of a condition.

### The `and`

Operator

The **and** operator checks if two conditions are both True. It returns True only if both conditions are True, otherwise it returns False.

**Example**

```
is_sunny = True
is_warm = False
feels_like_summer = True
perfect_weather = is_sunny and is_warm # Sunny and warm
print(f"Is it perfect weather? {perfect_weather}")
```

**Code Explanation**

**Line 1:**Assigns**True**to`is_sunny`

, indicating a sunny day.**Line 2:**Assigns**False**to`is_warm`

, indicating it's not warm outside.**Line 3:**Assigns**True**to`feels_like_summer`

, representing a general feeling.**Line 4:**Uses theoperator to check for perfect weather (both sunny and warm). The result is`and`

**False**(since`is_warm`

`perfect_weather`

.**Line 5:**Prints a message asking if it's perfect weather, displaying the outcome from`perfect_weather`

.

**Output**

Is it perfect weather? False

### The `or`

Operator

The **or** operator checks if at least one of two conditions is True. It returns True if either or both conditions are True. Otherwise, it returns False.

**Example**

```
is_sunny = True
is_warm = False
feels_like_summer = True
enjoyable_outside = is_sunny or is_warm # Either sunny or warm
print(f"Is it enjoyable outside? {enjoyable_outside}")
```

**Line 4:** Uses the ** or **operator to check if it's enjoyable outside based on whether it's sunny or warm. The result (True in this case) is stored in the

`enjoyable_outside`

**variable.**

**Output**

Is it enjoyable outside? True

### The `not`

Operator

The **not** operator in Python flips the truth value of a condition. If the condition is True, `not`

makes it False, and if it's False, `not`

makes it True.

**Example**

```
is_sunny = True
is_warm = False
feels_like_summer = True
going_swimming = not feels_like_summer # If it doesn't feel like summer
print(f"Going swimming? {going_swimming}")
```

**Line 4:** Uses the ** not **operator to reverse the value of

`feels_like_summer`

. Since it currently holds **True**, the result is

**False**and is stored in

`going_swimming`

.**Output**

Going swimming? False

## Bitwise Operators in Python

Python's bitwise operators directly manipulate the individual bits (0s and 1s) that represent them at the lowest level. These operators include bitwise **AND **(**&**), bitwise **OR** (**|**), bitwise **XOR **(**^**), bitwise **NOT **(**~**), and shifts (**<<**, **>>**). They often find use in fields like computer networking, low-level programming, and encryption, where bit-level control is necessary.

### Bitwise AND (`&`

)

The bitwise **AND **operator (**&**) compares corresponding bits within two numbers. Think of each operand (number) as having a row of lightbulbs representing its bits (0s and 1s). The operator checks pairs of bulbs from both rows. If both bulbs in a pair are lit (both bits are 1), the resulting bit in the answer will also be a **1**. Otherwise, it becomes **0**.

**Example**

```
# Example numbers (represented in binary)
num1 = 10 # 00001010
num2 = 5 # 00000101
result = num1 & num2
print(f"Bitwise AND ({num1} & {num2}): {result}") # Output: 0
```

**Code Explanation**

**Line 1:**Comment explaining that the following numbers are represented in binary.**Line 2:**Assigns the decimal**10**(binary 00001010) to`num1`

.**Line 3:**Assigns the decimal**5**(binary 00000101) to`num2`

.**Line 4:**Performs a bitwiseon`AND`

and`num1`

, storing the result (0) in`num2`

.`result`

**Line 5:**Prints the bitwiseoperation, the original numbers (`AND`

**num1**,**num2**), and the.`result`

**Output**

Bitwise AND (10 & 5): 0

### Bitwise OR ( `|`

)

Imagine two flashlights signaling messages in a dark room, one with a beam (**1**) and one with an off beam (**0**). Python's bitwise **OR** operator (**|**) combines bits from two numbers like those flashlights. Here's the syntax:

**Syntax**

operand1 **|** operand2

It checks each bit position in the operands. If at least one bit in a position is **1** (flashlight beam on), the corresponding bit in the result is also **1**. If both bits are **0** (both flashlights off), only then is the result bit a **0**.

**Example**

```
num1 = 10 # 00001010
num2 = 5 # 00000101
result = num1 | num2
print(f"Bitwise OR ({num1} | {num2}): {result}") # Output: 15
```

**Line 3:** Performs a bitwise ** OR **operation between

`num1`

**and**

`num2`

. The result (decimal 15) is stored in the variable `result`

.**Output**

Bitwise OR (10 | 5): 15

### Bitwise XOR ( `^`

)

The bitwise **XOR **operator (**^**) acts like a guard for bits, checking IDs (0s and 1s) at the bitwise door. Here's the syntax:

**Syntax**

operand1 **^** operand2

For each bit position in the operands, the ** XOR **operator lets only one bit through:

- If
**only one**of the bits in a position is 1 (one has ID, the other doesn't), the result bit is also 1. - If
**both bits are 0 or both are 1**(both lack ID or both have ID), the result bit becomes 0.

**Example**

```
num1 = 10 # 00001010
num2 = 5 # 00000101
result = num1 ^ num2
print(f"Bitwise XOR ({num1} ^ {num2}): {result}") # Output: 15
```

**Line 3:** Performs a bitwise ** XOR **operation on

`num1`

**and**

`num2`

. The result (decimal value 15) is stored in the `result`

**variable.**

**Output**

Bitwise XOR (10 ^ 5): 15

### Bitwise NOT ( `~`

)

The **bitwise NOT operator** (**~**) works like a bitwise inverter, flipping the individual bits (0s and 1s) of a single number. Imagine a row of switches representing the number's bits (on for 1, off for 0). The **NOT **operator flips the state of each switch. If a switch is currently on (1), it becomes off (0), and vice versa.

**Syntax**

**~**operand

**Example**

```
num1 = 10 # 00001010
num2 = 5 # 00000101
result = ~num1
print(f"Bitwise NOT (~{num1}): {result}") # Output: -11 (using two's complement)
```

**Line 3:** Applies the bitwise ** NOT **operator (

**) to the value in**

`~`

`num1`

. This inverts each bit (turning 0s to 1s and vice versa) and stores the result in the variable `result`

.**Output**

Bitwise NOT (~10): -11

### Bitwise Left Shift ( `<<`

)

In Python, the **bitwise left shift operator** (**<<**) acts like a bit-shifter, moving the bits in a number to the left by a certain number of positions. Imagine a row of dominoes representing the number's bits (0 or 1 on the domino face). Shifting left moves all the dominoes to the left, and depending on how many positions are specified:

- Zeros are filled in on the newly vacant rightmost positions.
- Any bits that fall off the left end are discarded.

**Example**

```
num1 = 10 # 00001010
num2 = 5 # 00000101
result = num1 << 1
print(f"Bitwise Left Shift ({num1} << 1): {result}") # Output: 20
```

**Line 3:** Performs a bitwise left shift operation on `num1`

** **by **1** position. This shifts the bits one place to the left, adding a zero in the rightmost position, and the result is stored in `result`

.

**Output**

Bitwise Left Shift (10 << 1): 20

### Bitwise Right Shift ( `>>`

)

**Python's bitwise right shift operator** (**>>**) acts like a bit mover, nudging the bits in a number to the right by a specified amount. Picture a row of marbles representing the number's bits (0 or 1). Shifting right moves the marbles to the right, and here's what happens:

- Bits on the far right that fall off are discarded.
- For positive numbers, zeros are filled in on the newly vacated leftmost positions.

**Note:** *For negative numbers (represented in two's complement), the sign bit (leftmost bit) is replicated to fill the empty left positions during the shift.*

**Example**

```
num1 = 10 # 00001010
num2 = 5 # 00000101
result = num2 >> 1
print(f"Bitwise Right Shift ({num2} >> 1): {result}") # Output: 2
```

**Line 3:** Performs a bitwise right shift operation on `num2`

** **by one position. This shifts the bits in `num2`

** **one place to the right, filling in a zero on the leftmost side, and storing the outcome in `result`

.

**Output**

Bitwise Right Shift (5 >> 1): 2

## Assignment Operators in Python

The most common one is the equals sign (**=**), which takes a value on the right side and assigns it to a variable on the left. Python also has a bunch of other handy assignment operators that combine arithmetic operations with assignment to save on code space. Examples include adding and assigning (**+=**), subtracting and assigning (**-=**), and more!

### Basic Assignment Operator (`=`

)

Python's basic assignment operator (**=**) acts like a label maker in your code. It's used to assign values to variables. Here's an example:

**Example**

```
age = 30
name = "Alice"
is_raining = True
```

**Code Explanation**

**Line 1:**Assigns the value**30**(an integer) to the variable`age`

.**Line 2:**Assigns the string "**Alice**" to the variable`name`

.**Line 3:**Assigns the Boolean value`True`

`is_raining`

.

### Add and Assign Operator (`+=`

)

The add and assign operator (**+=**) combines adding and assigning in one step. Imagine you have a variable with a value, and you want to add something to it. Here's the syntax:

**Syntax**

variable_name **+=** value

This is the same as writing** **`variable_name = variable_name + value`

, but it's shorter. It adds the value to what's already in the variable and stores the result back in the same variable, effectively updating its value.

**Example**

```
value = 10
# Add and assign (value becomes value + 5)
value += 5
print(f"After += 5: {value}") # Output: 15
```

**Code Explanation**

**Line 1:**Assigns the initial value**10**to the variable`value`

.**Line 2:**Comment (ignored by the computer) explaining the next line.**Line 3:**Uses theoperator to add`+=`

**5**to`value`

`value = value + 5`

).**Line 4:**Prints the updated`value`

**Output**

After += 5: 15

### Subtract and Assign Operator (`-=`

)

In Python, the subtract and assign operator (**-=**) acts like a shortcut for updating a variable's value by subtracting something from it. Here's an example:

**Example**

```
value = 10
# Subtract and assign (value becomes value - 2)
value -= 2
print(f"After -= 2: {value}") # Output: 13
```

**Line 3:** Uses the ** -=** operator to subtract

**2**from the current value stored in

`value`

**and then updates the variable with the result (equivalent to writing**

`value = value - 2`

).**Output**

After -= 2: 13

### Multiply and Assign Operator (`*=`

)

The multiply and assign operator (***=**) in Python is a time-saver that combines multiplication and assignment into a single step.

**Example**

```
value = 10
# Multiply and assign (value becomes value * 3)
value *= 3
print(f"After *= 3: {value}") # Output: 39
```

**Line 3:** Uses the ** *=** operator to multiply

`value`

**by**

**3**and assigns the result (30) back to

`value`

.**Output**

After *= 3: 39

### Divide and Assign Operator (`/=`

)

Python's divide and assign operator (**/=**) is used for division and assignment calculations. Imagine you have a variable storing a value and** **want to divide it by another number and update the variable with the result. Here's the syntax:

**Syntax**

variable_name **/=** value

It's important to remember that this operator works with both whole numbers (integers) and floating-point numbers (decimals).

**Example**

```
value = 10
# Divide and assign (value becomes value / 2)
value /= 2
print(f"After /= 2: {value:.1f}") # Output: 19.5 (float division)
```

**Line 3:** Uses the ** /=** operator to divide

`value`

**by**

**2**. This performs float division and updates the

`value`

**variable with the result (**

**5.0**).

**Output**

After /= 2: 19.5

### Modulus and Assign Operator (`%=`

)

Python's modulus and assign operator (**%= ) **is handy for keeping track of remainders after division. Imagine you have a variable storing several items and** **want to know how many would be leftover after dividing by a certain amount. Here's the syntax:

**Syntax**

variable_name **%=** value

**Example**

```
value = 10
# Modulo and assign (value becomes value % 3)
value %= 3
print(f"After %= 3: {value}") # Output: 1 (remainder)
```

**Line 3:** Uses the modulo and assign operator (** %=**). This calculates the remainder when

`value`

**is divided by**

**3**(which is 1) and stores that remainder back into the

`value`

**variable.**

**Output**

After %= 3: 1.0

### Exponent and Assign Operator (`**=`

)

The exponent and assign operator (****=**) in Python streamlines raising a variable's value to power and reassigning it. Imagine you have a variable storing a number and want to repeatedly multiply it by a specific number of times. Here's the syntax:

**Syntax**

variable_name ****=** value

**Example**

```
value = 10
# Raise to a power and assign (value becomes value ** 2)
value **= 2
print(f"After **= 2: {value}") # Output: 1 (exponent)
```

**Line 3:** Uses the exponent and assign operator (** **=**). This raises

`value`

**to the power of**

**2**(value squared) and stores the result (100) back into the

`value`

**variable.**

**Output**

After **= 2: 1.0

### Floor Divide and Assign Operator (`//=`

)

Python's floor divide and assign operator (**//=**) is like a shortcut for integer division and updating a variable. It discards any fractional remainders, focusing solely on the whole number result. Here's the syntax:

**Syntax**

variable_name **//=** value

**Example**

```
value = 10
# Floor divide and assign (value becomes value // 4)
value //= 4
print(f"After //= 4: {value}") # Output: 4 (integer division)
```

**Line 3:** Uses the floor divide and assign operator (** //=**). This performs integer division (discards the remainder) when dividing

`value`

**by**

**4,**and the result (2) is assigned back to

`value`

.**Output**

After //= 4: 4.0

## Identity Operators in Python

Identity operators, specifically **is** and **is not**, are used to compare whether two objects or variables refer to the same spot in your computer's memory. This differs from the equality operator (**==**), which compares if two things have the same contents.

### The `is`

Operator

The **is** operator verifies if two references (variable names) point to the same object in memory. Imagine two boxes; the **is** operator checks if they're the same box, not just if they contain the same things. Here's the syntax:

**Syntax**

operand1 **is** operand2

**operand1** and **operand2****:** The variables or expressions you want to compare.

**Example**

```
# Create two lists with the same contents
list1 = [1, 2, 3]
list2 = [1, 2, 3]
# Create two integers with the same value
num1 = 5
num2 = 5
# Check identity: same object in memory?
print(list1 is list2) # False - Different lists despite the same contents
print(num1 is num2) # True - Integers with the same value often share memory space
```

**Code Explanation**

**Lines 2-3:**Creates two separate lists (**list1**,**list2**) with identical contents (**[1, 2, 3]**). Despite looking the same, they occupy different places in memory.**Lines 6-7:**Assigns the value**5**to both`num1`

`num2`

.**Line 10:**Prints**False**because`list1`

compares object identity (memory location), not just contents.**is**list2**Line 11:**Prints**True**(likely) because Python often reuses memory space for small integers, so`num1`

is comparing the same object.**is**num2

**Output**

False

True

### The `is`

`not`

Operator

The **is** **not** operator works like the opposite of the **is **operator. It verifies if two references (variable names) don't point to the same object in memory. Imagine two boxes; the **is** **not** operator checks if they are different boxes, even if they contain the same things. Here's the syntax:

**Syntax**

operand1 **is not** operand2

The result is **True **if the objects are not the same in memory and **False **otherwise. It focuses on object identity, not value equality.

**Example**

```
list1 = [1, 2, 3]
list2 = [1, 2, 3]
num1 = 5
num2 = 5
# Check for non-identity
print(list1 is not list2) # True
print(num1 is not num2) # False
```

**Code Explanation**

**Line 7:**Prints**True**because`list1`

correctly confirms the lists are not the same object in memory (different containers even though the contents are the same).**is**not list2**Line 8:**Prints**False**(likely). Since`num1`

`num2`

**Output**

True

False

## Membership Operators in Python

Python's membership operators (**in** and **not** **in**) check if a specific value is a member (present) in a sequence like a list, string, or tuple. The **in** operator gives **True** if the value is found within the sequence. The **not** **in** operator does the opposite, **False** if the value is absent from the sequence. Think of them as answering the questions: "**Is this item on the list?**" or "**Is this item NOT on the list?**"

### The `in`

Operator

The **in **operator acts like a membership checker. Imagine you have a collection of items, like a basket of fruits. You can use **in **to see if a specific item is present in that collection. Here's the syntax:

**Syntax**

item **in** collection

**item****:**The value you're searching for (the specific fruit).**collection****:**The collection you're searching within (the basket of fruits).

The result is **True **if the item is found in the collection and **False **otherwise.

**Example**

```
# A list of fruits
fruits = ["apple", "banana", "orange"]
# Check if a fruit is in the list (membership)
print("mango" in fruits) # False - not in the list
print("banana" in fruits) # True - found in the list
```

**Code Explanation**

**Line 2:**Creates a list`fruits`

**apple**', '**banana**', '**orange**'.**Line 5:**Prints**False**– '**mango**' is not found in the`fruits`

**Line 6:**Prints**True**– '**banana**' is present within the`fruits`

**Output**

False

True

### The `not`

`in`

Operator

The **not** **in** operator works alongside the **in **operator but with the opposite logic. It acts like a "**not in the club**" checker for collections. Imagine you have a group of members and want to see if someone is not on the list. Here's the syntax:

**Syntax**

item **not in** collection

The result is **True **if the item is not found in the collection and **False** otherwise. It's useful for finding things excluded from a set or list.

**Example**

```
fruits = ["apple", "banana", "orange"]
print(5 not in fruits) # True - number not in the fruit list
print("apple" not in fruits) # False - the fruit is in the list
```

**Code Explanation**

**Line 3:**Prints**True**–**5**is correctly not found in the`fruits`

**Line 4:**Prints**False**– "**apple**" is correctly found in the`fruits`

*not*absent).

**Output**

True

False

## Exponentiation and Unary Operators

Python offers several operators that change or analyze a single value. The most common ones include the **exponentiation operator** (******), which helps you calculate powers (e.g., 3 raised to the power of 4), and the unary operators. **Unary operators** come in two flavors: the positive operator (**+**), which mostly just confirms a number as positive, and the negative operator (**-**), which flips the sign of a number (positive to negative, and vice versa). Unary operators work on only one operand (number) and sit directly in front of it.

### Exponent Operator ( `**`

)

The exponent operator (******) is your shortcut for repeated multiplication. Imagine you have a number and want to multiply it by itself a certain number of times. Here's the syntax:

**Syntax**

base ****** exponent

**base****:**The number you want to multiply (like the growth rate).**exponent****:**The number of times to multiply by itself (like how many times it grows).

Calculates `base`

** **to the power of `exponent`

. For example, `2 ** 3`

is the same as `2 * 2 * 2`

.

**Example**

```
# Calculate the square of 5 (5 to the power of 2)
result = 5 ** 2
print(f"5 squared: {result}") # Output: 25
# Calculate the cube of 3 (3 to the power of 3)
result = 3 ** 3
print(f"3 cubed: {result}") # Output: 27
```

**Code Explanation**

**Line 1:**Comment explaining the upcoming calculations.**Line 2:**Calculates**5**squared (**5 ** 2**) and stores the result (25) in the`result`

**Line 3:**Prints**"5 squared: 25"**using an f-string.**Line 6:**Calculates**3**cubed (**3 ** 3**) and stores the result (27) in the`result`

**Line 7:**Prints**"3 cubed: 27"**using an f-string.

**Output**

5 squared: 25

3 cubed: 27

### Caret Operator ( `^`

)

The caret operator (**^**) performs a bitwise exclusive **OR **(**XOR**) operation on integers. Imagine having two lights, one representing 1s and the other 0s. The **XOR **operation turns on a light only if the corresponding bits in the two numbers are different. Here's the syntax:

**Syntax**

operand1 **^** operand2

**operand1** and **operand2:** The integers you want to perform the bitwise ** XOR **on (like the two sets of lights).

For example, `10 ^ 3`

(in binary, 1010 ^ 0011) results in **13** (in binary, 1101) because the bits in positions **1** and **4** are different (1 XOR 0 is 1).

**Example**

```
result = 10 ^ 3 # Perform bitwise XOR on 10 and 3
print(result) # Output: 13
```

**Code Explanation**

**Line 1:**Assigns the result of the bitwiseoperation between`XOR`

**10**and**3**(**10 ^ 3**) to the`result`

**Line 2:**Prints the result, which is**13**.

### Unary Plus and Minus Operators

**Python offers two unary operators: **the positive (**+**) and the negative (**-**) signs. While the negative unary operator changes a number's sign, the positive unary operator has a more subtle effect. It largely confirms that a number is already positive (often leaving it unchanged) but can be used in certain situations to force a non-numeric value to become a number if possible. The negative unary operator works to flip a positive number to a negative and vice versa.

**Unary Plus Operator ( + )**

Python's unary plus operator (**+**) acts like a neutral observer for numbers. Unlike mathematical plus for addition, it doesn't change the value of a positive number. It says, "**Hey, this is already a positive number.**" Here's the syntax:

**Syntax**

**+**operand

While seemingly redundant for positive numbers, it can be useful in specific situations, like forcing a conversion to a numeric value.

**Example**

```
x = +10 # The plus sign has no effect here
y = +"hello" # Attempt to convert "hello" to a number (causes an error)
print(x) # Output: 10
# print(y) # This line will cause an error because "hello" cannot be converted to a number
```

**Code Explanation**

**Line 1:**Assigns the value**10**to`x`

. The unary plus has no effect here.**Line 2:**Tries to convert the string "**hello**" to a number using the unary plus. This will cause a TypeError because "**hello**" cannot be converted to a numerical value.**Line 3:**Prints the value of`x`

, which is**10**.

**Unary Minus Operator ( - )**

The unary minus operator (**-**) flips the sign of a number. It essentially acts like a minus sign in front of a number without needing another operand. Here's the syntax:

**Syntax**

-operand

This operator is handy for quickly making positive numbers negative and vice versa.

**Example**

```
x = 10
y = -x # Negate the value of x
print(f"x: {x}, y: {y}") # Output: x: 10, y: -10
```

**Code Explanation**

**Line 1:**Assigns the value**10**to`x`

.**Line 2:**Assigns the negation of`x`

to`y`

. The unary minus operator flips the sign, so**-10**is stored in`y`

.**Line 3:**Uses an f-string to print the values of`x`

and`y`

.

### Unary Tilde Operator ( `~`

)

`~`

The unary tilde operator (** ~**) handles bitwise operations, acting like a bitwise

**. Imagine a series of switches (0s and 1s) representing a number in binary. The tilde operator flips all the bits: 0s become 1s, and 1s become 0s. Here's the syntax:**

`NOT`

**Syntax**

**~**operand

Remember that this operation works on binary representations of integers, so a basic understanding of binary can be helpful.

**Example**

```
x = 10 # In binary, 1010
y = ~x # Flips all the bits (0101)
print(f"x: {x}, y: {y}") # Output: x: 10, y: -11 (one's complement interpretation)
```

**Code Explanation**

**Line 1:**Assigns the value**10**to`x`

. In binary,**10**is represented as**1010**.**Line 2:**Applies the bitwiseoperation to`NOT`

`x`

using the tilde operator (). This flips all the bits, resulting in`~`

**0101**in binary.**Line 3:**Prints the values of`x`

and`y`

. While y shows**-11**, it's due to one's complement interpretation (inverting bits and adding**1**). The actual binary value of`y`

is**0101**, which is**5**in decimal.