Python, a versatile and powerful programming language, relies on operators to perform various computations and manipulations on data. Operators are special symbols that represent specific operations, such as addition, subtraction, comparison, and logical operations. Let us discover the different types of Python operators and explore their applications.
If you wish to learn Python and other essential data science tools and technologies, enrol in Imarticus Learning’s data science course.
Arithmetic Operators in Python
Arithmetic operators in Python are used to perform basic mathematical calculations:
- Addition (+): For adding two operands.
- Subtraction (-): For subtracting the second operand from the first.
- Multiplication (*): For multiplying two operands.
- Division (/): For dividing the first operand by the second.
- Floor Division (//): For dividing the first operand by the second and rounding down to the nearest integer.
- Modulo (%): For returning the remainder of the division operation.
- Exponentiation (**): For raising the first operand to the power of the second.
Example:
| x = 10
y = 3 print(x + y) # Output: 13 print(x - y) # Output: 7 print(x * y) # Output: 30 print(x / y) # Output: 3.3333333333333335 print(x // y) # Output: 3 print(x % y) # Output: 1 print(x ** y) # Output: 1000 |
Comparison Operators
Comparison operators are used to compare values and return a Boolean result (True or False). Here are the different comparison Python operator types:
- Equal to (==): For checking if two operands are equal.
- Not Equal to (!=): For checking if two operands are not equal.
- Greater Than (>): For checking if the first operands are greater than the second.
- Less Than (<): For checking if the first operands are less than the second.
- Greater Than or Equal To (>=): For checking if the first operands are greater than or equal to the second.
- Less Than or Equal To (<=): For checking if the first operands are less than or equal to the second.
Example:
| x = 10
y = 5 print(x == y) # Output: False print(x != y) # Output: True print(x > y) # Output: True print(x < y) # Output: False print(x >= y) # Output: True print(x <= y) # Output: False |
Logical Operators in Python
Logical operators in Python are used to combine conditional statements.
- And (and): Will return True if both operands are True.
- Or (or): Will return True if at least one operand is True.
- Not (not): Will return the truth value of an operand.
Example:
| x = True
y = False print(x and y) # Output: False print(x or y) # Output: True print(not x) # Output: False |
Assignment Operators
Here are the various assignment Python operator types that are used to assign values to variables.
- Equal to (=): For assigning the value on the right to the variable on the left.
- Add and Assign (+=): For adding the right operands to the left operands and assigning the results to the left operands.
- Subtract and Assign (-=): For subtracting the right operands from the left operands and assigning the results to the left operands.
- Multiply and Assign (*=): For multiplying the right operands with the left operands and assigning the results to the left operands.
- Divide and Assign (/=): For dividing the left operands by the right operands and assigning the results to the left operands.
- Floor Divide and Assign (//=): For performing floor division and assigning the result to the left operand.
- Modulo and Assign (%=): For performing modulo operation and assigning the result to the left operand.
- Exponentiate and Assign (**=): For exponentiating the left operand by the right operand and assigning the result to the left operand.
Example:
| x = 10
x += 5 # x = 15 x -= 3 # x = 12 x *= 2 # x = 24 x /= 4 # x = 6 x //= 2 # x = 3 x %= 2 # x = 1 x **= 3 # x = 1 |
Bitwise Operators
Bitwise Python operators manipulate individual bits of binary numbers. They are often used in low-level programming and data manipulation tasks.
- Bitwise AND (&): For setting each bit to 1 only if both corresponding bits in the operands are 1.
- Bitwise OR (|): For setting each bit to 1 if at least one of the corresponding bits in the operands is 1.
- Bitwise XOR (^): For setting each bit to 1 if the corresponding bits in the operands are different.
- Bitwise NOT (~): For inverting the bits of the operand.
- Left Shift (<<): For shifting the bits of the operand to the left by a specified number of positions, while the rightmost bits are filled with 0s.
- Right Shift (>>): For shifting the bits of the operand to the right by a specified number of positions, while the leftmost bits are filled with 0s or 1s, depending on the sign of the operand.
Identity Operators
Identity operators compare the objects, not if they are equal, but if they are actually the same object, with the same memory location.
- Is (is): Will return True if both operands are referring to the same object.
- Is Not (is not): Will return True if both operands are referring to different objects.
Membership Operators
Membership operators test whether a value or variable is found in a sequence.
- In (in): Will return True if a value is found in a sequence.
- Not In (not in): Will return True if a value is not found in a sequence.
Operator Precedence and Associativity
Operator precedence determines the order in which operations are performed. Python operators having a higher precedence are evaluated first. For instance, multiplication and division have higher precedence than addition and subtraction. Associativity determines the direction in which operations are grouped when they have the same precedence. Most binary operators in Python are left-associative, meaning they are grouped from left to right.
Boolean Operators and Truth Tables
Boolean operators are used to combine logical expressions.
- AND (and): Will return True if both operands are True.
- OR (or): Will return True if at least one operand is True.
- NOT (not): Will return the truth value of an operand.
Truth tables can be used to visualise the behaviour of Boolean operators for all possible combinations of input values.
Short-Circuit Evaluation
Python uses short-circuit evaluation for logical operators and and or. This means that the second operand of a logical expression is only evaluated if the first operand is not sufficient to determine the result. For example, in the expression x and y, if x is False, the expression is immediately evaluated to False without evaluating y.
Type Conversion and Operator Behaviour
Python automatically performs type conversion in certain situations. For example, when adding an integer and a float, the integer is converted to a float before the addition is performed. However, it's important to be aware of implicit and explicit type conversions to avoid unexpected results.
Operator Overloading in Custom Classes
Operator overloading allows you to redefine the behaviour of operators for custom classes. We can customise how objects of your class interact with operators. This can make your code more intuitive and readable by implementing special methods like __add__, __sub__, __mul__, etc.
Wrapping Up
If you wish to become a data scientist or data analyst, enrol in the Postgraduate Program In Data Science And Analytics by Imarticus. This course also offers 100% job assurance so that you can get an immediate boost in your data-driven career.
Frequently Asked Questions
What is operator precedence, and why is it important?
Operator precedence determines the order in which operations are performed in an expression. Understanding operator precedence helps ensure that expressions are evaluated correctly. For example, in the expression 2 + 3 * 4, multiplication has higher precedence than addition, so multiplication is performed first.
How do I use bitwise operators in Python?
Bitwise operators manipulate individual bits of binary numbers. They are often used in low-level programming and data manipulation tasks. For instance, the bitwise AND operator (&) can be used to mask specific bits of a number, while the bitwise OR operator (|) can be used to set specific bits.
What is the difference between is and == operators?
The (is) operator checks if two variables refer to the same object in memory, while the == operator checks if the values of two variables are equal. For example, x is y checks if x and y are the same objects, while x == y checks if the values of x and y are the same.
How can I create custom operators for my classes?
You can create custom operators for your classes by defining special methods like __add__, __sub__, __mul__, etc. These methods allow you to redefine the behaviour of operators for your class objects, making your code more intuitive and readable.
