Python Operators

« Previous Next »

Python Operators

In Python, operators are symbols that enable you to perform different kinds of operations on data, such as calculations, comparisons, and logical evaluations. They work on values, variables, or a combination of both to produce a result.

The addition operator (+) is one of the most commonly used operators. It allows you to combine numerical values efficiently.

Example: Adding Two Numbers

result = 20 + 30 print("Addition result:", result)

Try it Yourself

Here, the + operator adds two integer values and stores the outcome in the variable result.

Example: Adding Variables and Values

The addition operator can also be applied when working with variables, making calculations more flexible and dynamic.

base_value = 120 increment = 80 total_one = base_value + increment total_two = total_one + 300 total_three = total_two + total_two print(total_one) print(total_two) print(total_three)

Try it Yourself

Explanation:

base_value and increment store numeric data.
total_one adds two values.
total_two uses a variable and a constant.
total_three adds two variables together.
This method improves code clarity and allows values to be reused across multiple calculations.

Categories of Python Operators

Python classifies operators into several groups based on their functionality:

• Arithmetic Operators – Perform mathematical calculations (e.g., +, -, *, /)
• Assignment Operators – Assign values to variables (e.g., =, +=, -=)
• Comparison Operators – Compare two values (e.g., ==, !=, >, <)
• Logical Operators – Combine conditional statements (e.g., and, or, not)
• Identity Operators – Check if two variables reference the same object (e.g., is, is not)
• Membership Operators – Test for presence in a sequence (e.g., in, not in)
• Bitwise Operators – Operate at the binary level (e.g., &, |, ^)

Arithmetic Operators in Python

Arithmetic operators in Python are used with numerical data types to carry out basic and advanced mathematical calculations. These operators allow programs to perform operations such as addition, subtraction, multiplication, and different types of division.

Types of Arithmetic Operators

Operator	Operation Name	Description
+	Addition	Adds two numbers
-	Subtraction	Subtracts one value from another
*	Multiplication	Multiplies values
/	Division	Divides and returns a decimal value
%	Modulus	Returns the remainder
**	Exponentiation	Raises a number to a power
//	Floor Division	Returns the quotient without decimals

Example: Using Arithmetic Operators

a = 18 b = 6 print("Sum:", a + b) print("Difference:", a - b) print("Product:", a * b) print("Quotient:", a / b) print("Remainder:", a % b) print("Power:", a ** b) print("Floor Result:", a // b)

Try it Yourself

Explanation:

The program applies different arithmetic operators to the same set of numbers.
Each print() statement displays the result of a specific operation.
Division using / produces a decimal value, even when the numbers divide evenly.

Division Operators in Python

Python supports two types of division, each serving a different purpose.

1. Standard Division (/)

Always returns a floating-point value. Useful when precision is required.

value1 = 14 value2 = 3 result = value1 / value2 print("Standard division result:", result)

Try it Yourself

2. Floor Division (//)

Returns the largest integer less than or equal to the result. Decimal values are discarded by rounding downward.

value1 = 14 value2 = 3 result = value1 // value2 print("Floor division result:", result)

Try it Yourself

Key Difference:

/ keeps the decimal part.
// removes the decimal part by rounding down.
This distinction is especially important when working with loops, indexing, or calculations where whole numbers are required.

Assignment Operators in Python

Assignment operators in Python are used to store values in variables. In addition to simple assignment, Python provides compound operators that perform an operation and assign the result back to the same variable in a single step. This helps make code shorter and more readable.

Types of Assignment Operators

Operator	Purpose	Equivalent Expression
=	Assign value	a = 10
+=	Add and assign	a = a + 5
-=	Subtract and assign	a = a - 5
*=	Multiply and assign	a = a * 5
/=	Divide and assign	a = a / 5
%=	Modulus and assign	a = a % 5
//=	Floor divide and assign	a = a // 5
**=	Power and assign	a = a ** 5
&=	Bitwise AND and assign	a = a & 5
|=	Bitwise OR and assign	a = a | 5
^=	Bitwise XOR and assign	a = a ^ 5
>>=	Right shift and assign	a = a >> 2
<<=	Left shift and assign	a = a << 2

Example: Using Assignment Operators

value = 20 value += 10 print("After addition:", value) value -= 5 print("After subtraction:", value) value *= 2 print("After multiplication:", value) value //= 3 print("After floor division:", value)

Try it Yourself

Explanation:

Each operator updates the same variable.
The operation is performed first, and the result is reassigned.
This approach reduces repetitive code.

The Walrus Operator (:=)

Python 3.8 introduced the walrus operator, which allows you to assign a value to a variable while using it within an expression. This is especially helpful in conditions and loops where a value would otherwise be calculated twice.

Example: Without the Walrus Operator

data = [10, 20, 30, 40, 50] length = len(data) if length >= 4: print("Total items:", length)

Try it Yourself

Example: With the Walrus Operator

data = [10, 20, 30, 40, 50] if (size := len(data)) >= 4: print("Total items:", size)

Try it Yourself

Why use the walrus operator?

• Avoids repeated calculations
• Makes code more concise
• Improves readability when used carefully

Assignment operators are widely used in loops, counters, and mathematical updates, making them a core concept in Python programming.

Comparison Operators in Python

Comparison operators in Python are used to evaluate the relationship between two values. These operators compare operands and always return a Boolean result—either True or False. They are commonly used in decision-making statements such as if, while, and conditional expressions.

Types of Comparison Operators

Operator	Description	Usage Example
==	Checks if two values are equal	a == b
!=	Checks if values are different	a != b
>	Checks if left value is greater	a > b
<	Checks if left value is smaller	a < b
>=	Checks if left value is greater than or equal	a >= b
<=	Checks if left value is less than or equal	a <= b

Example: Using Comparison Operators

num_a = 12 num_b = 20 print("Equal:", num_a == num_b) print("Not Equal:", num_a != num_b) print("Greater Than:", num_a > num_b) print("Less Than:", num_a < num_b) print("Greater or Equal:", num_a >= num_b) print("Less or Equal:", num_a <= num_b)

Try it Yourself

Explanation:

Each comparison checks a condition between two values.
The result of every comparison is either True or False.
These Boolean results can be directly used in conditional logic.

Chaining Comparison Operators

Python supports chained comparisons, allowing multiple conditions to be evaluated in a clean and readable way without repeating variables.

Example: Chained Comparison

value = 7 print(3 < value < 15)

Try it Yourself

This single line checks whether value lies between 3 and 15.

Equivalent Logical Expression

value = 7 print(value > 3 and value < 15)

Try it Yourself

Why use chained comparisons?

• More readable and concise
• Reduces repetition
• Commonly used in range validations

Comparison operators play a vital role in controlling program flow and making decisions based on conditions.

Logical Operators in Python

Logical operators in Python are used to combine multiple conditions and evaluate them as a single Boolean expression. They are most commonly applied in decision-making statements such as if, elif, and while.

Types of Logical Operators

Operator	Meaning	Example Usage
and	True when all conditions are true	a > 2 and a < 8
or	True when at least one condition is true	a < 3 or a > 10
not	Reverses the Boolean result	not(a == 5)

Example: Using and Operator

Check whether a number falls within a specific range.

number = 7 result = number > 1 and number < 10 print("Within range:", result)

Try it Yourself

Explanation:

Both conditions must be true. If either condition fails, the result becomes False.

Example: Using or Operator

Check whether a number is outside a given range.

number = 7 result = number < 5 or number > 12 print("Outside range:", result)

Try it Yourself

Explanation:

If at least one condition is true, the result is True.

Example: Using not Operator

Invert the outcome of a logical expression.

number = 7 result = not (number > 4 and number < 9) print("Reversed result:", result)

Try it Yourself

Explanation:

The expression inside parentheses is evaluated first. The not operator flips the Boolean value.
Logical operators are essential for building complex conditions and controlling the flow of Python programs.

Python Identity Operators

Identity operators in Python are used to determine whether two variables reference the same object in memory, rather than just containing equal values. This distinction is important when working with mutable objects like lists, dictionaries, and custom objects.

Types of Identity Operators

Operator	Description	Example
is	Returns True if both variables refer to the same object	a is b
is not	Returns True if variables refer to different objects	a is not b

Example: Using the is Operator

list_one = ["cat", "dog"] list_two = ["cat", "dog"] list_three = list_one print(list_one is list_three) print(list_one is list_two) print(list_one == list_two)

Try it Yourself

Explanation:

list_one and list_three point to the same memory location, so is returns True.
list_two has identical content but is a different object, so is returns False.
The == operator checks only the values, not memory identity.

Example: Using the is not Operator

colors_a = ["red", "blue"] colors_b = ["red", "blue"] print(colors_a is not colors_b)

Try it Yourself

Explanation:

Even though both lists contain the same elements, they are stored separately in memory. Therefore, is not returns True.

Difference Between is and ==

Operator	What it Checks
is	Whether both variables reference the same object in memory
==	Whether the values of the variables are equal

Example: Value vs Identity Comparison

data_x = [10, 20, 30] data_y = [10, 20, 30] print("Value comparison:", data_x == data_y) print("Identity comparison:", data_x is data_y)

Try it Yourself

Key Takeaway:

• Use == to compare values
• Use is to compare object identity

Identity operators are especially useful when checking against singletons like None or when debugging object references.

Membership Operators in Python

Membership operators in Python are used to verify whether a particular value exists within a collection or sequence. These sequences can include lists, tuples, sets, dictionaries, and even strings. The result of a membership check is always a Boolean value: True or False.

Types of Membership Operators

Operator	Meaning	Example
in	Returns True if the value exists in the sequence	item in collection
not in	Returns True if the value does not exist in the sequence	item not in collection

Example: Checking Membership in a List

items = ["pen", "pencil", "eraser"] print("pencil" in items)

Try it Yourself

Explanation:

The expression checks whether "pencil" exists inside the list. Since it is present, the result is True.

Example: Checking Non-Membership in a List

items = ["pen", "pencil", "eraser"] print("marker" not in items)

Try it Yourself

Explanation:

The operator verifies that "marker" is not part of the list. The result is True because the value is absent.

Membership Operators with Strings

Membership operators can also be used to search for characters or substrings within a string.

message = "Python Programming" print("P" in message) print("python" in message) print("x" not in message)

Try it Yourself

Explanation:

Python string comparisons are case-sensitive, so "python" is not the same as "Python". The in operator checks for exact character or substring matches.
Membership operators are commonly used for validation, searching, and filtering data in Python programs.

Bitwise Operators in Python

Bitwise operators in Python work directly on the binary (bit-level) representation of integers. Instead of treating numbers as whole values, these operators manipulate individual bits, making them useful in low-level programming, performance optimization, and certain algorithmic tasks.

Types of Bitwise Operators

Operator	Name	Function
&	AND	Sets a bit to 1 only if both corresponding bits are 1
|	OR	Sets a bit to 1 if the bits are different
^	XOR	Sets a bit to 1 if the bits are different
~	NOT	Flips all bits (bitwise inversion)
<<	Left Shift	Shifts bits left, adding zeros on the right
>>	Right Shift	Shifts bits right, preserving the sign bit

Example: Bitwise AND (&)

a = 10 # Binary: 1010 b = 4 # Binary: 0100 result = a & b print(result)

Try it Yourself

Explanation:

Only the bits that are 1 in both numbers remain 1. Binary result: 0000. Decimal result: 0.

Example: Bitwise OR (|)

a = 10 # Binary: 1010 b = 4 # Binary: 0100 result = a | b print(result)

Try it Yourself

Explanation:

Bits are set to 1 if either value has a 1. Binary result: 1110. Decimal result: 14.

Example: Bitwise XOR (^)

a = 10 # Binary: 1010 b = 4 # Binary: 0100 result = a ^ b print(result)

Try it Yourself

Explanation:

Bits are set to 1 only when they differ. Binary result: 1110. Decimal result: 14.

Example: Bitwise NOT (~)

num = 5 # Binary: 0101 print(~num)

Try it Yourself

Explanation:

The NOT operator flips all bits. The result becomes -6 due to two’s complement representation.

Example: Bit Shifting

value = 8 # Binary: 1000 print(value << 2) print(value >> 1)

Try it Yourself

Explanation:

Left shift multiplies the number by powers of 2.
Right shift divides the number by powers of 2.
Bitwise operators are powerful tools when working with binary data, flags, and optimized computations.

Operator Precedence in Python

Operator precedence determines the sequence in which different operators in an expression are evaluated. When multiple operators appear in a single statement, Python follows a well-defined priority order to decide which operation is performed first. Understanding precedence helps prevent logical errors and ensures expressions behave as expected.

Parentheses Have the Highest Priority

Expressions enclosed in parentheses () are always evaluated before any other operations.

result = (8 + 2) - (8 + 2) print(result)

Try it Yourself

Explanation:

Each parenthesized expression is calculated first. The final result is based on those evaluated values.

Multiplication Before Addition

When parentheses are not used, Python follows its built-in precedence rules. For example, multiplication has higher priority than addition.

output = 50 + 4 * 5 print(output)

Try it Yourself

Explanation:

The multiplication 4 * 5 is evaluated first. The result is then added to 50.

Operator Precedence Order (Highest to Lowest)

Operator	Description
()	Parentheses
**	Exponentiation
+x, -x, ~x	Unary plus, unary minus, bitwise NOT
*, /, //, %	Multiplication, division, floor division, modulus
+, -	Addition and subtraction
<<, >>	Bitwise shifts
&	Bitwise AND
^	Bitwise XOR
==, !=, >, >=, <, <=, is, is not, in, not in	Comparison, identity, membership
not	Logical NOT
and	Logical AND
or	Logical OR

Left-to-Right Evaluation

When operators have the same precedence, Python evaluates the expression from left to right.

value = 10 + 6 - 8 + 2 print(value)

Try it Yourself

Explanation:

Addition and subtraction share the same precedence. The expression is evaluated sequentially from left to right.

Key Tip

To improve readability and avoid confusion:

• Use parentheses when writing complex expressions
• Do not rely only on operator precedence

This completes the rewritten Python Operators section with original explanations and examples. If you want, I can now combine all sections into

« Previous Next »