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)

- Addition:

a = 10 b = 3 addition_result = a + b 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(addition_result) # Output: 13 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:
`//=`

- Assignment:

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:
`<=`

- 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`

- Logical AND:

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:
`>>`

- Bitwise AND:

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.

**Read More;**

- What is slicing and indexing in Python explain with an example?
- What is lambda function in Python for example?
- What is multilevel inheritance in Python with example?
- How do you use a any () or a all () in Python?
- How to add Qt to Python With Example
- What are type hints in Python With Example?
- Python Script Example for DevOps
- What is enumerate() in Python with an example?
- What is a for else in Python With Example?
- What is the filter() function with an Example?
- What is module and example in Python?
- What is overriding in Python with example?