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)

Addition result: 50

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)

200 500 1000

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)

Sum: 24 Difference: 12 Product: 108 Quotient: 3.0 Remainder: 0 Power: 34012224 Floor Result: 3

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)

Standard division result: 4.666666666666667

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)

Floor division result: 4

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)

After addition: 30 After subtraction: 25 After multiplication: 50 After floor division: 16

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)

Total items: 5

Example: With the Walrus Operator

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

Total items: 5

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)

Equal: False Not Equal: True Greater Than: False Less Than: True Greater or Equal: False Less or Equal: True

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)

True

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

Equivalent Logical Expression

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

True

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)

Within range: True

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)

Outside range: False

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)

Reversed result: False

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)

True False True

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)

True

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)

Value comparison: True Identity comparison: False

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)

True

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)

True

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)

True False True

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)

0

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)

14

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)

14

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)

-6

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)

32 4

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)

0

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)

70

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)

10

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

« Previous Next »

AI Code Explanation Python

Powered by Gocourse AI