Python operators are special symbols in Python that carry out arithmetic or logical computation. The value that the operator operates on is called the operand.
For example: in the expression 2 + 3 = 5, + is the operator that performs addition. The operands are 2 and 3 and the result is 5.
Python supports the following types of operators:
- Arithmetic Operators
- Comparison (Relational) Operators
- Logical (Boolean) Operators
- Bitwise Operators
- Assignment Operators
- Special Operators
Arithmetic Operators
Arithmetic operators are used to perform mathematical operations like + addition, - subtraction, * multiplication, etc.
| Operator | Description | Example |
|---|---|---|
| + | Addition | 2 + 3 = 5 |
| - | Subtraction | 3 - 2 = 1 |
| * | Multiplication | 2 * 3 = 6 |
| / | Division (float) | 7 / 2 = 3.5 |
| // | Division (floor) | 7 // 2 = 3 |
| % | Modulus (remainder) | 7 % 2 = 1 |
| ** | Exponentiation | 2 ** 3 = 8 |
Example of using Arithmetic Operators:
# Addition
print(2 + 3) # Output: 5
# Subtraction
print(3 - 2) # Output: 1
# Multiplication
print(2 * 3) # Output: 6
# Division (float)
print(7 / 2) # Output: 3.5
# Division (floor)
print(7 // 2) # Output: 3
# Modulus
print(7 % 2) # Output: 1
# Exponentiation
print(2 ** 3) # Output: 8Comparison Operators
Comparison operators are used to compare values and return a Boolean value.
| Operator | Description | Example |
|---|---|---|
| == | Equal to | 2 == 3 returns False |
| != | Not equal to | 2 != 3 returns True |
| > | Greater than | 2 > 3 returns False |
| < | Less than | 2 < 3 returns True |
| >= | Greater than or equal to | 2 >= 3 returns False |
| <= | Less than or equal to | 2 <= 3 returns True |
Example of using Comparison Operators:
# Equal to
print(2 == 3) # Output: False
# Not equal to
print(2 != 3) # Output: True
# Greater than
print(2 > 3) # Output: False
# Less than
print(2 < 3) # Output: True
# Greater than or equal to
print(2 >= 3) # Output: False
# Less than or equal to
print(2 <= 3) # Output: TrueLogical Operators
Logical operators are used to combine conditions using and, or, and not.
| Operator | Description | Example |
|---|---|---|
| and | Logical and | (2 == 2) and (3 > 2) returns True |
| or | Logical or | (2 == 2) or (3 > 2) returns True |
| not | Logical not | not(2 == 2) returns False |
Example of using Logical Operators:
# Logical and
print((2 == 2) and (3 > 2)) # Output: True
# Logical or
print((2 == 2) or (3 > 2)) # Output: True
# Logical not
print(not(2 == 2)) # Output: FalseBitwise Operators
Bitwise operators are used to perform bit-level operations on integers.
| Operator | Description | Example |
|---|---|---|
| & | Bitwise and | 5 & 3 = 1 |
| | | Bitwise or | 5 | 3 = 7 |
| ^ | Bitwise xor | 5 ^ 3 = 6 |
| ~ | Bitwise not | ~5 = -6 |
| << | Left shift | 5 `oaicite:{"index":0,"invalid_reason":"Malformed citation << 2 = 20 |
Example of using Bitwise Operators:
# Bitwise and
print(5 & 3) # Output: 1
# Bitwise or
print(5 | 3) # Output: 7
# Bitwise xor
print(5 ^ 3) # Output: 6
# Bitwise not
print(~5) # Output: -6
# Left shift
print(5 ​`oaicite:{"index":1,"invalid_reason":"Malformed citation << 2) # Output: 20\n\n# Right shift\nprint(5 >>"}`​ 2) # Output: 1Assignment Operators
Assignment operators are used to assign values to variables.
| Operator | Description | Example |
|---|---|---|
| = | Simple assignment | x = 5 |
| += | Add and assignment | x += 5 (same as x = x + 5) |
| -= | Subtract and assignment | x -= 5 (same as x = x - 5) |
| *= | Multiply and assignment | x *= 5 (same as x = x * 5) |
| /= | Divide and assignment | x /= 5 (same as x = x / 5) |
| %= | Modulus and assignment | x %= 5 (same as x = x % 5) |
| //= | Floor division and assignment | x //= 5 (same as x = x // 5) |
| **= | Exponentiation and assignment | x **= 5 (same as x = x ** 5) |
Example of using Assignment Operators:
x = 5
# Simple assignment
x = 5
print(x) # Output: 5
# Add and assignment
x += 5
print(x) # Output: 10
# Subtract and assignment
x -= 5
print(x) # Output: 5
# Multiply and assignment
x *= 5
print(x) # Output: 25
# Divide and assignment
x /= 5
print(x) # Output: 5.0
# Modulus and assignment
x %= 3
print(x) # Output: 2.0
# Floor division and assignment
x //= 2
print(x) # Output: 1.0
# Exponentiation and assignment
x **= 2
print(x) # Output: 1.0Special Operators
Python has a few special operators:
Identity Operators
Identity operators are used to compare the memory locations of two objects.
| Operator | Description | Example |
|---|---|---|
| is | True if the operands point to the same object | x is y (True if x and y point to the same object) |
| is not | True if the operands do not point to the same object | x is not y (True if x and y do not point to the same object) |
Example of using Identity Operators:
x = [1, 2, 3]
y = [1, 2, 3]
z = x
# True if x and y point to the same object
print(x is y) # Output: False
# True if x and z point to the same object
print(x is z) # Output: True
# True if x and y do not point to the same object
print(x is not y) # Output: TrueMembership Operators
Membership operators are used to test whether an item is present in a sequence (i.e. list, tuple, string).
| Operator | Description | Example |
|---|---|---|
| in | True if the item is present in the sequence | 3 in x (True if 3 is present in the list x) |
| not in | True if the item is not present in the sequence | 3 not in x (True if 3 is not present in the list x) |
Example of using Membership Operators:
x = [1, 2, 3]
# True if 3 is present in the list x
print(3 in x) # Output: True
# True if 4 is not present in the list x
print(4 not in x) # Output: TrueOperator Precedence
Operator precedence determines the order in which operations are performed. Python follows the standard mathematical rules for operator precedence, where operators with higher precedence are executed before operators with lower precedence.
For example, in the expression 2 + 3 * 4, the multiplication 3 * 4 is done first because the multiplication operator has higher precedence than the addition operator.
You can use parentheses to change the order of operations. For example, in the expression (2 + 3) * 4, the addition 2 + 3 is done first because it is inside the parentheses.
You can refer to the table of operator precedence in python to know the order of precedence of operators.
In conclusion, Python has a wide variety of operators that can be used to perform various types of operations. These operators include arithmetic, comparison, logical, bitwise, assignment, identity, and membership operators.
It is important to understand the different types of operators and their precedence in order to write efficient and accurate code.