Python Operators Overview – Be on the Right Side of Change (original) (raw)
What Are Python Operators?
Python operators are special syntactical sugar to run basic operations without calling their respective methods. For example, you can use the + operator in a + b instead of the more clunky .add() method in a.add(b). Each operator has a unique symbol that is placed between the two arguments called operands.
A simple example is given next where the + operator is applied to operands 40 and 2 to generate the sum 42:
40 + 2 42
Comparison Operators
Comparison operators are applied to comparable objects and they return a Boolean value (True or False).
| Operator | Name | Description | Example |
|---|---|---|---|
| > | Greater Than | Returns True if the left operand is greater than the right operand | 3 > 2 == True |
| < | Less Than | Returns True if the left operand is smaller than the right operand | 3 < 2 == False |
| == | Equal To | Returns True if the left operand is the same as the right operand | (3 == 2) == False |
| != | Not Equal To | Returns True if the left operand is not the same as the right operand | (3 != 2) == True |
| >= | Greater Than or Equal To | Returns True if the left operand is greater than or equal to the right operand | (3 >= 3) == True |
| <= | Less Than or Equal To | Returns True if the left operand is less than or equal to the right operand | (3 <= 2) == False |
You can check out a full guide on all of those comparison operators in the following blog tutorial on the Finxter blog.
Related Tutorial: Python Comparison Operators
Arithmetic Operators
Arithmetic operators are syntactical shortcuts to perform basic mathematical operations on numbers.
| Operator | Name | Description | Example |
|---|---|---|---|
| + | Addition | Calculating the sum of the two operands | 3 + 4 == 7 |
| – | Subtraction | Subtracting the second operand from the first operand | 4 - 3 == 1 |
| * | Multiplication | Multiplying the first with the second operand | 3 * 4 == 12 |
| / | Division | Dividing the first by the second operand | 3 / 4 == 0.75 |
| % | Modulo | Calculating the remainder when dividing the first by the second operand | 7 % 4 == 3 |
| // | Integer Division, Floor Division | Dividing the first operand by the second operand and rounding the result down to the next integer | 8 // 3 == 2 |
| ** | Exponent | Raising the first operand to the power of the second operand | 2 ** 3 == 8 |
Logical Operators
Logical operators are shortcuts to perform Boolean comparisons, but can be used on integers and other objects as well.
| Operator | Description | Example |
|---|---|---|
| and | Returns True if both operands are True, and False otherwise. | (True and True) == True |
| or | Returns True if at least one of the two operands is True, and False otherwise. | (False or True) == True |
| not | Returns True if the single operand is False, and False otherwise. | (not True) == False |
You can read the full article with video on Python logical operators on the Finxter blog.
Related Tutorial: Python Logical Operators
Bitwise Operators
Bitwise operators perform operations on the binary (bit) representation of integers.
Background: Each integer is first written as a binary number that is a sequence of digits 0 or 1. For example:
- 0 is written as “0”
- 1 is written as “1”
- 2 is written as “10”
- 3 is written as “11”
- 4 is written as “100”
- 5 is written as “101”
The bitwise operators are then applied on those binary representations. The resulting binary number is then converted back to the integer representation (decimal number).
In the following table, we exemplify all bit-wise operators with variables x and y defined as follows:
x = 4 # 100 y = 5 # 101
As a comment, we also provide the binary representation 100 for the decimal integer 4, and 101 for the decimal integer 5.
| Operator | Name | Description | Example | |
|---|---|---|---|---|
| x = 4, y = 5 | ||||
| & | Bitwise AND | Performs logical AND on a bit-by-bit basis | x & y# b100 & b101 == b100 == 4 | |
| | | Bitwise OR | Performs logical OR operation on a bit-by-bit basis | x | y# b100 | b101 == b101 == 5 |
| ~ | Bitwise NOT | Performs logical NOT on a bit-by-bit basis, inverting each bit so that 0 becomes 1 and 1 becomes 0. Same as -x-1. | ~x# -4-1 == -5 | |
| ^ | Bitwise XOR | Performs logical “exclusive or” operation on a bit-by-bit basis | x ^ y# b100 ^ b101 == b001 == 1 | |
| >> | Bitwise right shift | Shifts binary of left operand to the right by the number of positions specified in right operand | x >> 2# b100 == b010 == b001 == 1 | |
| << | Bitwise left shift | Shifts binary of left operand to the left by the number of positions specified in right operand | x << 2# b100 == b1000 == b10000 == 16 |
You can read the full article with video on Python bitwise operators on the Finxter blog.
Related Tutorial: Python Bitwise Operators
In-Place Assignment Operators
In-place assignment operators (also called compound assignment operators) perform an operation in-place on a variable provided as first operand. They overwrite the value of the first operand variable with the result of the operation when performing the operator without assignment. For example, x += 3 is the same as x = x + 3 of first calculating the result of x +3 and then assigning it to the variable x.
| Operator | Name | Short Example | Equivalent Long Example |
|---|---|---|---|
| = | In-place Assignment | x = 3 | |
| += | In-place Addition | x += 3 | x = x + 3 |
| -= | In-place Subtraction | x -= 3 | x = x - 3 |
| *= | In-place Multiplication | x *= 3 | x = x * 3 |
| /= | In-place Division | x /= 3 | x = x / 3 |
| %= | In-place Modulo | x %= 3 | x = x % 3 |
| //= | In-place Integer Division | x //= 3 | x = x // 3 |
| **= | In-place Power | x **= 3 | x = x ** 3 |
| &= | In-place Bitwise And | x &= 3 | x = x & 3 |
| |= | In-place Bitwise Or | x |= 3 | x = x | 3 |
| ^= | In-place Bitwise XOR | x ^= 3 | x = x ^ 3 |
| >>= | In-place Bitwise Shift Right | x >>= 3 | x = x >> 3 |
| <<= | In-place Bitwise Shift Left | x <<= 5 | x = x << 5 |
Identity Operators
Python has two identity operators: is and is not. They are used to check if two values or variables reside at the same memory location, i.e., refer to the same object in memory. However, if two variables are equal, this doesn’t imply that they are identical. For example, two lists [1, 2, 3] and [1, 2, 3] may be different objects (not identical) but they’re equal in value.
| Operator | Meaning | Example |
|---|---|---|
| is | Returns True if both operands refer to the same object in memory and False otherwise. | x is True |
| is not | Returns False if both operands refer to the same object in memory and True otherwise. | x is not True |
Membership Operators
Python has two membership operators in and not in that test whether a value or variable exists in a collection such as string, list, tuple, set, and dictionary.
| Operator | Meaning | Example |
|---|---|---|
| in | True if value/variable is found in the sequence | 5 in x |
| not in | True if value/variable is not found in the sequence | 5 not in x |
Python Operators Precedence
The following table describes Python’s operator precedence relationship, from highest to lowest precedence.
Operators in the same row have the same precedence. For example, comparisons, membership, and identity have the same precedence. In case of a conflict, they have a left-to-right precedence resolution scheme. In other words, the left operator has precedence over the right operator if both have the same theoretical precedence level.
| Name | Operators |
|---|---|
| Parentheses | () |
| Exponentiation | ** |
| Bitwise Not | ~ |
| Multiplication, Division, Modulo, Integer Division | * / % // |
| Addition, Subtraction | + - |
| Bitwise Shift Right and Left | >> << |
| Bitwise AND | & |
| Bitwise XOR and OR | ^ | |
| Comparison | <= < > >= |
| Equality | <> == != |
| In-Place Assignments | = %= /= //= -= += *= **= |
| Identity, Membership | is, is not, in, not in |
| Logical | not, and, or |
Table: Python operator precedence from high to low.
Related Article: Operator Precedence [Blog + Video]