# What are the 7 operators in Python?

Python has several operators that can be categorized into different groups based on their functionality. Here are the seven main categories of operators in Python:

• Arithmetic Operators: These operators are used for basic arithmetic operations.
• Addition: `+`
• Subtraction: `-`
• Multiplication: `*`
• Division: `/`
• Modulus: `%`
• Exponentiation: `**` (e.g., `2**3` equals 2 raised to the power of 3, which is 8)
• Floor Division: `//` (e.g., `5 // 2` equals 2 as it returns the quotient of the division rounded down)
```a = 10
b = 3

subtraction_result = a - b
multiplication_result = a * b
division_result = a / b
modulus_result = a % b
exponentiation_result = a ** b
floor_division_result = a // b

print(subtraction_result)     # Output: 7
print(multiplication_result)  # Output: 30
print(division_result)        # Output: 3.3333333333333335
print(modulus_result)         # Output: 1
print(exponentiation_result)  # Output: 1000
print(floor_division_result)  # Output: 3
```
• Assignment Operators: These operators are used to assign values to variables.
• Assignment: `=`
• Add and Assign: `+=`
• Subtract and Assign: `-=`
• Multiply and Assign: `*=`
• Divide and Assign: `/=`
• Modulus and Assign: `%=`
• Exponentiation and Assign: `**=`
• Floor Division and Assign: `//=`
```x = 5
x += 3  # Equivalent to x = x + 3
print(x)  # Output: 8

y = 10
y *= 2  # Equivalent to y = y * 2
print(y)  # Output: 20
```
• Comparison Operators: These operators are used to compare two values.
• Equal to: `==`
• Not equal to: `!=`
• Greater than: `>`
• Less than: `<`
• Greater than or equal to: `>=`
• Less than or equal to: `<=`
```p = 5
q = 10

print(p == q)   # Output: False
print(p != q)   # Output: True
print(p > q)    # Output: False
print(p < q)    # Output: True
print(p >= q)   # Output: False
print(p <= q)   # Output: True
```
• Logical Operators: These operators are used to combine or modify logical statements.
• Logical AND: `and`
• Logical OR: `or`
• Logical NOT: `not`
```raining = True
temperature = 25

if raining and temperature < 30:
print("It's raining and not too hot. Bring an umbrella.")
else:
print("The weather is fine.")

if not raining or temperature > 30:
print("It's either not raining or hot. Enjoy the day.")
else:
print("The weather might not be ideal.")
```
• Bitwise Operators: These operators perform operations on individual bits of integer values.
• Bitwise AND: `&`
• Bitwise OR: `|`
• Bitwise XOR: `^`
• Bitwise NOT: `~`
• Left Shift: `<<`
• Right Shift: `>>`
```x = 5  # Binary: 0101
y = 3  # Binary: 0011

bitwise_and_result = x & y  # Binary: 0001 -> Decimal: 1
bitwise_or_result = x | y   # Binary: 0111 -> Decimal: 7
bitwise_xor_result = x ^ y  # Binary: 0110 -> Decimal: 6
bitwise_not_result = ~x     # Binary: 1010 (assuming 4 bits) -> Decimal: -6
left_shift_result = x << 1  # Binary: 1010 -> Decimal: 10
right_shift_result = x >> 1 # Binary: 0010 -> Decimal: 2

print(bitwise_and_result)   # Output: 1
print(bitwise_or_result)    # Output: 7
print(bitwise_xor_result)   # Output: 6
print(bitwise_not_result)   # Output: -6
print(left_shift_result)    # Output: 10
print(right_shift_result)   # Output: 2
```
• Membership Operators: These operators check for membership within a sequence or collection.
• `in`: Returns True if a value is present in a sequence.
• `not in`: Returns True if a value is not present in a sequence.
```list_example = [1, 2, 3, 4, 5]

print(3 in list_example)    # Output: True
print(6 not in list_example)  # Output: True
```
• Identity Operators: These operators check if two variables refer to the same object in memory.
• `is`: Returns True if both variables point to the same object.
• `is not`: Returns True if both variables do not point to the same object.
```x = [1, 2, 3]
y = x
z = [1, 2, 3]

print(x is y)  # Output: True (both x and y refer to the same object)
print(x is z)  # Output: False (x and z are different objects with the same values)
print(x is not z)  # Output: True (x and z are different objects)
```

These are the main categories of operators in Python, and understanding how to use them is fundamental for writing efficient and expressive code.

## What is %= in Python?

the `%=` is a shorthand assignment operator used for the modulus operation. It combines the modulus operator `%` with the assignment operator `=`. The modulus operation calculates the remainder when one number is divided by another.

The syntax for the `%=` operator is as follows:

```x %= y
```

This means take the value of `x`, perform the modulus operation on `x` and `y`, and then assign the result back to `x`.

For example, consider the following code:

```x = 10
y = 3

x %= y  # Equivalent to x = x % y

print(x)  # Output: 1
```

In this example, `x` starts with the value of 10, and after applying the `%=` operator with `y` (which is 3), the value of `x` becomes 1, which is the remainder when 10 is divided by 3.

• 