Python Operators

Understand the different types of Python operators, including arithmetic, comparison, logical, and more. Master essential programming concepts.

Python-Operators
Table of Contents

Python Operators

Python operators are special symbols that let you perform different actions on values within your code. You have operators for doing math (like +, , *), comparing things (like ==, <, >), checking logic (like and, or, not), and even changing the values themselves. Understanding these operators is key to writing Python code that can calculate, solve problems, and make decisions based on the data you give it.

Python Operators Example

Here’s a comprehensive example that shows the most common Python operators, along with clear comments for explanations:

# Arithmetic Operators
result = 10 + 5  # Addition
result = 20 - 3  # Subtraction
result = 2 * 5   # Multiplication
result = 10 / 2  # True division
result = 15 // 4 # Floor division (rounds down to whole number)
result = 17 % 3  # Modulo (remainder)
result = 2 ** 3  # Exponentiation (2 to the power of 3)

# Comparison Operators
is_equal = 5 == 5        # Equality
is_not_equal = 4 != 2    # Not equal
is_greater = 10 > 8      # Greater than
is_less = 3 < 5          # Less than
is_greater_equal = 6 >= 6  # Greater than or equal to
is_less_equal = 4 <= 4    # Less than or equal to

# Logical Operators
is_true = True and False # Logical AND
is_true = True or False  # Logical OR
is_true = not False      # Logical NOT

# Bitwise Operators
result = 5 & 3  # Bitwise AND
result = 5 | 2  # Bitwise OR
result = ~4     # Bitwise NOT (inverts the bits)
result = 4 ^ 3  # Bitwise XOR (exclusive OR)
result = 12 << 1 # Bitwise left shift (multiplies by 2)
result = 6 >> 1  # Bitwise right shift (divides by 2)

# Assignment Operators
value = 10
value += 5   # Equivalent to value = value + 5
value -= 2   # Equivalent to value = value - 2
value *= 3   # Equivalent to value = value * 3
# ... and others like /=, //=, %=, **=, &=, |=, ^=, <<=, >>=

# Identity Operators
x = 5
y = 5
is_same = x is y    # Checks if objects refer to the same memory location
is_not_same = x is not y  # Checks if objects refer to different memory locations

# Membership Operators
list_data = [1, 2, 3]
is_member = 2 in list_data     # Checks if a value is present in a sequence
is_not_member = 5 not in list_data  # Checks if a value is not in a sequence

Understanding Operands

In Python, operands are the elements you use with operators to perform actions. Operands can be variables, numbers, strings, or even calculations.

  • Variables store values and are referenced by their names (e.g., x, name).
  • Numbers can be integers (whole numbers) or floats (decimals).
  • Strings are text enclosed in quotes (single '' or double "" quotes).

Example

age = 30  # Assign the value 30 (integer) to the variable `age`
message = "Hello, world!"  # Assign the string "Hello, world!" to the variable `message`
total_days = age * 365  # Calculate total days (multiplication)
print(f"{message}. You've lived for {total_days} days.")

Code Explanation

  • Line 1: Assigns the integer value 30 to the variable age.
  • Line 2: Assigns the string “Hello, world!” to the variable message.
  • Line 3: Calculates total_days by multiplying age (variable) and 365 (integer). Notice the operands involved in the calculation.
  • Line 4: Uses an f-string to print a message that combines the string from message and the calculated total_days.

Output

Hello, world!. You’ve lived for 10950 days.


Understanding Expressions

In Python, expressions are combinations of operands (values) and operators that create a single result. These expressions involve variables, numbers, strings, and even function calls. Parentheses can be used to group parts of the expression and control the order of operations.

Example

# Calculate the area of a rectangle (length x width)
length = 5  # Assign length as 5
width = 3  # Assign width as 3
area = length * width  # Calculate area using multiplication

# Calculate the volume of a box (length x width x height)
height = 2  # Assign height as 2
volume = length * width * height  # Notice parentheses around length * width

print(f"The area of the rectangle is: {area}")
print(f"The volume of the box is: {volume}")

Code Explanation

  • Lines 2-3: Assign values to length and width.
  • Line 4: Calculates the area by multiplying length and width.
  • Lines 7-8: Assign a height and calculate the volume using parentheses to ensure the multiplication of length and width happens before multiplying by height.
  • Lines 10-11: Print the calculated area and volume using f-strings.

Output

The area of the rectangle is: 15
The volume of the box is: 30


Arithmetic Operators in Python

Python’s arithmetic operators are used for calculations. You have addition (+), subtraction (), multiplication (*), and division (/). Additionally, the floor division operator (//) rounds down the result to a whole number, and the modulo operator (%) gives you the remainder after a division. These handy operators are essential for writing Python programs that crunch numbers, compute values, and make decisions based on calculations.

Addition ( + )

The addition operator (+) in Python is for combining numbers or strings. When adding numbers, it behaves as you’d expect for regular addition. However, if you add strings, Python concatenates (joins) them together.

Example

num1 = 15
num2 = 4
result = num1 + num2  # Add num1 and num2
print(f"Addition: {num1} + {num2} = {result}")

Code Explanation

  • Line 1: Assigns the value 15 to the variable num1.
  • Line 2: Assigns the value 4 to the variable num2.
  • Line 3: Calculates the sum of num1 and num2, storing the result in the result variable.
  • Line 4: Prints a user-friendly message to the console using an f-string. It displays the values of num1, num2, and the calculated result.

Output

Addition: 15 + 4 = 19


Subtraction ( - )

The subtraction operator () in Python lets you remove one number from another. It’s straightforward for calculations, subtracting the second operand from the first.

Example

num1 = 15
num2 = 4
result = num1 - num2  # Subtract num2 from num1
print(f"Subtraction: {num1} - {num2} = {result}")

Line 3: Calculates the difference between num1 and num2, storing the result in the result variable.

Output

Subtraction: 15 – 4 = 11


Multiplication ( * )

The multiplication operator (*) in Python is handy when you need to multiply numbers.

Example

num1 = 15
num2 = 4
result = num1 * num2  # Multiply num1 and num2
print(f"Multiplication: {num1} * {num2} = {result}")

Line 3: Multiplies the values in num1 and num2 using the asterisk (*) operator, and assigns the calculation’s result to the variable result.

Output

Multiplication: 15 * 4 = 60


Division ( / )

The division operator (/) in Python divides one number by another. However, the result is always a floating-point number (a decimal value), even if both operands are integers.

Example

num1 = 15
num2 = 4
result = num1 / num2  # Divide num1 by num2
print(f"True Division: {num1} / {num2} = {result}")

Line 3: Performs true division. It divides num1 by num2 using the forward-slash (/) operator and stores the result (a floating-point number) in the result variable.

Output

True Division: 15 / 4 = 3.75


Modulus ( % )

Python’s modulo operator (%) is a bit trickier but useful! It gives you the remainder after performing a division.

Imagine you have a certain number of candies (dividend) and want to share them equally among friends (divisor). The remainder you get using the modulo operator tells you how many candies are leftover after everyone gets a share.

Example

num1 = 15
num2 = 4
result = num1 % num2  # Calculate remainder after dividing num1 by num2
print(f"Modulo: {num1} % {num2} = {result}")

Line 3: Calculates the remainder after the division of num1 by num2 using the modulo operator (%) and assigns the result to the variable result.

Output

Modulo: 15 % 4 = 3


Exponentiation ( ** )

The exponentiation operator (**) in Python raises a number (base) to a certain power (exponent). It’s a shorthand way of writing out repeated multiplication of the base number.

Example

num1 = 15
num2 = 4
result = num1 ** 2    # Raise num1 to the power of 2 (num1 * num1)
print(f"Exponentiation: {num1} ** 2 = {result}")

Line 3: Calculates the square of num1 (raises num1 to the power of 2) using the exponentiation operator (**) and stores the result in the result variable.

Output

Exponentiation: 15 ** 2 = 225


Floor Division ( // )

The floor division operator (//) is handy when you need to divide numbers and discard any remainder, rounding down to the nearest whole number.

Example

num1 = 15
num2 = 4
result = num1 // num2  # Divide num1 by num2 (disregard remainder)
print(f"Floor Division: {num1} // {num2} = {result}")

Line 3: Performs floor division. It divides num1 by num2 using the double forward-slash (//) operator, discards any remainder and stores the integer quotient in the result variable.

Output

Floor Division: 15 // 4 = 3


Comparison Operators in Python

Python’s comparison operators allow you to compare values and determine their relationship. You can use them to check if one value is equal to another (==), greater than (>), less than (<), greater than or equal to (>=), less than or equal to (<=), or not equal (!=). These operators are either True or False, making them essential for conditional logic in your programs.

Equal ( == )

Python’s equal operator (==) checks whether two values are identical. It returns True if the values are equal and False otherwise.

Example

value1 = 20
value2 = 10
is_equal = value1 == value2  # Check if value1 is equal to value2
print(f"{value1} == {value2}: {is_equal}")

Code Explanation

  • Line 1: Assigns the value 20 to the variable value1.
  • Line 2: Assigns the value 10 to the variable value2.
  • Line 3: Tests if value1 is equal to value2 using the == operator, storing the Boolean result (True or False) in is_equal.
  • Line 4: Prints the values compared (value1 and value2), the comparison symbol (==), and the comparison result (is_equal).

Output

20 == 10: False


Not Equal ( != )

The not equal operator (!=) in Python does the opposite of the equal operator. It checks if two values are different. It returns True if the values are not equal and False otherwise. This can be useful for identifying unequal values or making decisions based on differences.

Example

value1 = 20
value2 = 10
is_not_equal = value1 != value2  # Check if value1 is not equal to value2
print(f"{value1} != {value2}: {is_not_equal}")

Line 3: Compares if value1 is not equal to value2 using the not equal to operator (!=). The result (True or False) is stored in the variable is_not_equal.

Output

20 != 10: True


Greater Than ( > )

The greater than operator (>) in Python helps you determine if one value is larger than another.

Example

value1 = 20
value2 = 10
is_greater = value1 > value2  # Check if value1 is greater than value2
print(f"{value1} > {value2}: {is_greater}")

Line 3: Uses the greater than operator (>) to check if value1 is greater than value2. The comparison result (True or False) is stored in the is_greater variable.

Output

20 > 10: True


Less Than ( < )

The less than operator (<) in Python works the other way around than the greater than operator. It checks if one value is smaller than another.

Example

value1 = 20
value2 = 10
is_less = value1 < value2  # Check if value1 is less than value2
print(f"{value1} < {value2}: {is_less}")

Line 3: Uses the less than operator (<) to compare if value1 is less than value2. The result of this comparison (True or False) is stored in the is_less variable.

Output

20 < 10: False


Greater Than or Equal To ( >= )

The greater than or equal to operator (>=) in Python lets you check if one value is strictly greater than or equal to another. 

Example

value1 = 20
value2 = 10
is_greater_or_equal = value1 >= value2  # Check if value1 is greater than or equal to value2
print(f"{value1} >= {value2}: {is_greater_or_equal}")

Line 3: Uses the greater than or equal to operator (>=) to check if value1 is either greater than or equal to value2. The result of this comparison (True or False) is stored in the variable is_greater_or_equal.

Output

20 >= 10: True


Less Than or Equal To ( <= )

The less than or equal to operator (<=) in Python comes in handy when you need to check if a value is strictly less than another value or equal to it.

Example

value1 = 20
value2 = 10
is_less_or_equal = value1 <= value2  # Check if value1 is less than or equal to value2
print(f"{value1} <= {value2}: {is_less_or_equal}")

Line 3: Uses the less than or equal to operator (<=) to determine if value1 is less than or equal to value2. The Boolean result (True or False) is stored in the variable is_less_or_equal.

Output

20 <= 10: False


Logical Operators in Python

Logical operators in Python allow you to combine and manipulate conditions to make more complex decisions within your code. The three main ones are and, or, and not. These operators evaluate statements that result in True or False. The and operator requires both conditions to be True for the overall result to be True. The or operator is more flexible, requiring at least one condition to be True for a True result. Lastly, the not operator flips things around, reversing the True/False value of a condition.

The and Operator

The and operator checks if two conditions are both True. It returns True only if both conditions are True, otherwise it returns False.

Example

is_sunny = True
is_warm = False
feels_like_summer = True
perfect_weather = is_sunny and is_warm  # Sunny and warm
print(f"Is it perfect weather? {perfect_weather}")

Code Explanation

  • Line 1: Assigns True to is_sunny, indicating a sunny day.
  • Line 2: Assigns False to is_warm, indicating it's not warm outside.
  • Line 3: Assigns True to feels_like_summer, representing a general feeling.
  • Line 4: Uses the and operator to check for perfect weather (both sunny and warm). The result is False (since is_warm is False) and is stored in perfect_weather.
  • Line 5: Prints a message asking if it's perfect weather, displaying the outcome from perfect_weather.

Output

Is it perfect weather? False


The or Operator

The or operator checks if at least one of two conditions is True. It returns True if either or both conditions are True. Otherwise, it returns False.

Example

is_sunny = True
is_warm = False
feels_like_summer = True
enjoyable_outside = is_sunny or is_warm  # Either sunny or warm
print(f"Is it enjoyable outside? {enjoyable_outside}")

Line 4: Uses the or operator to check if it's enjoyable outside based on whether it's sunny or warm. The result (True in this case) is stored in the enjoyable_outside variable.

Output

Is it enjoyable outside? True


The not Operator

The not operator in Python flips the truth value of a condition. If the condition is True, not makes it False, and if it's False, not makes it True.

Example

is_sunny = True
is_warm = False
feels_like_summer = True
going_swimming = not feels_like_summer  # If it doesn't feel like summer
print(f"Going swimming? {going_swimming}")

Line 4: Uses the not operator to reverse the value of feels_like_summer. Since it currently holds True, the result is False and is stored in going_swimming.

Output

Going swimming? False


Bitwise Operators in Python

Python's bitwise operators directly manipulate the individual bits (0s and 1s) that represent them at the lowest level. These operators include bitwise AND (&), bitwise OR (|), bitwise XOR (^), bitwise NOT (~), and shifts (<<, >>). They often find use in fields like computer networking, low-level programming, and encryption, where bit-level control is necessary.

Bitwise AND (&)

The bitwise AND operator (&) compares corresponding bits within two numbers. Think of each operand (number) as having a row of lightbulbs representing its bits (0s and 1s). The operator checks pairs of bulbs from both rows. If both bulbs in a pair are lit (both bits are 1), the resulting bit in the answer will also be a 1. Otherwise, it becomes 0.

Example

# Example numbers (represented in binary)
num1 = 10  # 00001010
num2 = 5   # 00000101
result = num1 & num2
print(f"Bitwise AND ({num1} & {num2}): {result}")  # Output: 0

Code Explanation

  • Line 1: Comment explaining that the following numbers are represented in binary.
  • Line 2: Assigns the decimal 10 (binary 00001010) to num1.
  • Line 3: Assigns the decimal 5 (binary 00000101) to num2.
  • Line 4: Performs a bitwise AND on num1 and num2, storing the result (0) in result.
  • Line 5: Prints the bitwise AND operation, the original numbers (num1, num2), and the result.

Output

Bitwise AND (10 & 5): 0


Bitwise OR ( | )

Imagine two flashlights signaling messages in a dark room, one with a beam (1) and one with an off beam (0). Python's bitwise OR operator (|) combines bits from two numbers like those flashlights. Here's the syntax:

Syntax

operand1 | operand2

It checks each bit position in the operands. If at least one bit in a position is 1 (flashlight beam on), the corresponding bit in the result is also 1. If both bits are 0 (both flashlights off), only then is the result bit a 0.

Example

num1 = 10  # 00001010
num2 = 5   # 00000101
result = num1 | num2
print(f"Bitwise OR ({num1} | {num2}): {result}")  # Output: 15

Line 3: Performs a bitwise OR operation between num1 and num2. The result (decimal 15) is stored in the variable result.

Output

Bitwise OR (10 | 5): 15


Bitwise XOR ( ^ )

The bitwise XOR operator (^) acts like a guard for bits, checking IDs (0s and 1s) at the bitwise door. Here's the syntax:

Syntax

operand1 ^ operand2

For each bit position in the operands, the XOR operator lets only one bit through:

  • If only one of the bits in a position is 1 (one has ID, the other doesn't), the result bit is also 1.
  • If both bits are 0 or both are 1 (both lack ID or both have ID), the result bit becomes 0.

Example

num1 = 10  # 00001010
num2 = 5   # 00000101
result = num1 ^ num2
print(f"Bitwise XOR ({num1} ^ {num2}): {result}")  # Output: 15

Line 3: Performs a bitwise XOR operation on num1 and num2. The result (decimal value 15) is stored in the result variable.

Output

Bitwise XOR (10 ^ 5): 15


Bitwise NOT ( ~ )

The bitwise NOT operator (~) works like a bitwise inverter, flipping the individual bits (0s and 1s) of a single number. Imagine a row of switches representing the number's bits (on for 1, off for 0). The NOT operator flips the state of each switch. If a switch is currently on (1), it becomes off (0), and vice versa.

Syntax

~operand

Example

num1 = 10  # 00001010
num2 = 5   # 00000101
result = ~num1
print(f"Bitwise NOT (~{num1}): {result}")  # Output: -11 (using two's complement)

Line 3: Applies the bitwise NOT operator (~) to the value in num1. This inverts each bit (turning 0s to 1s and vice versa) and stores the result in the variable result.

Output

Bitwise NOT (~10): -11


Bitwise Left Shift ( << )

In Python, the bitwise left shift operator (<<) acts like a bit-shifter, moving the bits in a number to the left by a certain number of positions. Imagine a row of dominoes representing the number's bits (0 or 1 on the domino face). Shifting left moves all the dominoes to the left, and depending on how many positions are specified:

  • Zeros are filled in on the newly vacant rightmost positions.
  • Any bits that fall off the left end are discarded.

Example

num1 = 10  # 00001010
num2 = 5   # 00000101
result = num1 << 1
print(f"Bitwise Left Shift ({num1} << 1): {result}")  # Output: 20

Line 3: Performs a bitwise left shift operation on num1 by 1 position. This shifts the bits one place to the left, adding a zero in the rightmost position, and the result is stored in result.

Output

Bitwise Left Shift (10 << 1): 20


Bitwise Right Shift ( >> )

Python's bitwise right shift operator (>>) acts like a bit mover, nudging the bits in a number to the right by a specified amount. Picture a row of marbles representing the number's bits (0 or 1). Shifting right moves the marbles to the right, and here's what happens:

  • Bits on the far right that fall off are discarded.
  • For positive numbers, zeros are filled in on the newly vacated leftmost positions.

Note: For negative numbers (represented in two's complement), the sign bit (leftmost bit) is replicated to fill the empty left positions during the shift.

Example

num1 = 10  # 00001010
num2 = 5   # 00000101
result = num2 >> 1
print(f"Bitwise Right Shift ({num2} >> 1): {result}")  # Output: 2

Line 3: Performs a bitwise right shift operation on num2 by one position. This shifts the bits in num2 one place to the right, filling in a zero on the leftmost side, and storing the outcome in result.

Output

Bitwise Right Shift (5 >> 1): 2


Assignment Operators in Python

The most common one is the equals sign (=), which takes a value on the right side and assigns it to a variable on the left. Python also has a bunch of other handy assignment operators that combine arithmetic operations with assignment to save on code space. Examples include adding and assigning (+=), subtracting and assigning (-=), and more!

Basic Assignment Operator (=)

Python's basic assignment operator (=) acts like a label maker in your code. It's used to assign values to variables. Here's an example:

Example

age = 30
name = "Alice"
is_raining = True

Code Explanation

  • Line 1: Assigns the value 30 (an integer) to the variable age.
  • Line 2: Assigns the string "Alice" to the variable name.
  • Line 3: Assigns the Boolean value True to the variable is_raining.

Add and Assign Operator (+=)

The add and assign operator (+=) combines adding and assigning in one step. Imagine you have a variable with a value, and you want to add something to it. Here's the syntax:

Syntax

variable_name += value

This is the same as writing variable_name = variable_name + value, but it's shorter. It adds the value to what's already in the variable and stores the result back in the same variable, effectively updating its value.

Example

value = 10
# Add and assign (value becomes value + 5)
value += 5  
print(f"After += 5: {value}")  # Output: 15

Code Explanation

  • Line 1: Assigns the initial value 10 to the variable value.
  • Line 2: Comment (ignored by the computer) explaining the next line.
  • Line 3: Uses the += operator to add 5 to value and update its value (equivalent to value = value + 5).
  • Line 4: Prints the updated value (15) along with a descriptive message.

Output

After += 5: 15


Subtract and Assign Operator (-=)

In Python, the subtract and assign operator (-=) acts like a shortcut for updating a variable's value by subtracting something from it. Here's an example:

Example

value = 10
# Subtract and assign (value becomes value - 2)
value -= 2  
print(f"After -= 2: {value}")  # Output: 13

Line 3: Uses the -= operator to subtract 2 from the current value stored in value and then updates the variable with the result (equivalent to writing value = value - 2).

Output

After -= 2: 13


Multiply and Assign Operator (*=)

The multiply and assign operator (*=) in Python is a time-saver that combines multiplication and assignment into a single step.

Example

value = 10
# Multiply and assign (value becomes value * 3)
value *= 3  
print(f"After *= 3: {value}")  # Output: 39

Line 3: Uses the *= operator to multiply value by 3 and assigns the result (30) back to value.

Output

After *= 3: 39


Divide and Assign Operator (/=)

Python's divide and assign operator (/=) is used for division and assignment calculations. Imagine you have a variable storing a value and want to divide it by another number and update the variable with the result. Here's the syntax:

Syntax

variable_name /= value

It's important to remember that this operator works with both whole numbers (integers) and floating-point numbers (decimals).

Example

value = 10
# Divide and assign (value becomes value / 2)
value /= 2  
print(f"After /= 2: {value:.1f}")  # Output: 19.5 (float division)

Line 3: Uses the /= operator to divide value by 2. This performs float division and updates the value variable with the result (5.0).

Output

After /= 2: 19.5


Modulus and Assign Operator (%=)

Python's modulus and assign operator (%= ) is handy for keeping track of remainders after division. Imagine you have a variable storing several items and want to know how many would be leftover after dividing by a certain amount. Here's the syntax:

Syntax

variable_name %= value

Example

value = 10
# Modulo and assign (value becomes value % 3)
value %= 3  
print(f"After %= 3: {value}")  # Output: 1 (remainder)

Line 3: Uses the modulo and assign operator (%=). This calculates the remainder when value is divided by 3 (which is 1) and stores that remainder back into the value variable.

Output

After %= 3: 1.0


Exponent and Assign Operator (**=)

The exponent and assign operator (**=) in Python streamlines raising a variable's value to power and reassigning it. Imagine you have a variable storing a number and want to repeatedly multiply it by a specific number of times. Here's the syntax:

Syntax

variable_name **= value

Example

value = 10
# Raise to a power and assign (value becomes value ** 2)
value **= 2  
print(f"After **= 2: {value}")  # Output: 1 (exponent)

Line 3: Uses the exponent and assign operator (**=). This raises value to the power of 2 (value squared) and stores the result (100) back into the value variable.

Output

After **= 2: 1.0


Floor Divide and Assign Operator (//=)

Python's floor divide and assign operator (//=) is like a shortcut for integer division and updating a variable. It discards any fractional remainders, focusing solely on the whole number result. Here's the syntax:

Syntax

variable_name //= value

Example

value = 10
# Floor divide and assign (value becomes value // 4)
value //= 4  
print(f"After //= 4: {value}")  # Output: 4 (integer division)

Line 3: Uses the floor divide and assign operator (//=). This performs integer division (discards the remainder) when dividing value by 4, and the result (2) is assigned back to value.

Output

After //= 4: 4.0


Identity Operators in Python

Identity operators, specifically is and is not, are used to compare whether two objects or variables refer to the same spot in your computer's memory. This differs from the equality operator (==), which compares if two things have the same contents.

The is Operator

The is operator verifies if two references (variable names) point to the same object in memory. Imagine two boxes; the is operator checks if they're the same box, not just if they contain the same things. Here's the syntax:

Syntax

operand1 is operand2

operand1 and operand2: The variables or expressions you want to compare.

Example

# Create two lists with the same contents
list1 = [1, 2, 3]
list2 = [1, 2, 3]

# Create two integers with the same value
num1 = 5
num2 = 5

# Check identity: same object in memory?
print(list1 is list2)  # False - Different lists despite the same contents
print(num1 is num2)    # True - Integers with the same value often share memory space

Code Explanation

  • Lines 2-3: Creates two separate lists (list1, list2) with identical contents ([1, 2, 3]). Despite looking the same, they occupy different places in memory.
  • Lines 6-7: Assigns the value 5 to both num1 and num2.
  • Line 10: Prints False because list1 is list2 compares object identity (memory location), not just contents.
  • Line 11: Prints True (likely) because Python often reuses memory space for small integers, so num1 is num2 is comparing the same object.

Output

False
True


The is not Operator

The is not operator works like the opposite of the is operator. It verifies if two references (variable names) don't point to the same object in memory. Imagine two boxes; the is not operator checks if they are different boxes, even if they contain the same things. Here's the syntax:

Syntax

operand1 is not operand2

The result is True if the objects are not the same in memory and False otherwise. It focuses on object identity, not value equality.

Example

list1 = [1, 2, 3]
list2 = [1, 2, 3]
num1 = 5
num2 = 5

# Check for non-identity
print(list1 is not list2)  # True 
print(num1 is not num2)    # False

Code Explanation

  • Line 7: Prints True because list1 is not list2 correctly confirms the lists are not the same object in memory (different containers even though the contents are the same).
  • Line 8: Prints False (likely). Since num1 and num2 reference the same integer object in memory, the check for non-identity fails.

Output

True
False


Membership Operators  in Python

Python's membership operators (in and not in) check if a specific value is a member (present) in a sequence like a list, string, or tuple. The in operator gives True if the value is found within the sequence. The not in operator does the opposite, False if the value is absent from the sequence. Think of them as answering the questions: "Is this item on the list?" or "Is this item NOT on the list?"

The in Operator

The in operator acts like a membership checker. Imagine you have a collection of items, like a basket of fruits. You can use in to see if a specific item is present in that collection. Here's the syntax:

Syntax

item in collection

  • item: The value you're searching for (the specific fruit).
  • collection: The collection you're searching within (the basket of fruits).

The result is True if the item is found in the collection and False otherwise.

Example

# A list of fruits
fruits = ["apple", "banana", "orange"]

# Check if a fruit is in the list (membership)
print("mango" in fruits)   # False - not in the list
print("banana" in fruits)  # True -  found in the list

Code Explanation

  • Line 2: Creates a list fruits storing strings: 'apple', 'banana', 'orange'.
  • Line 5: Prints False – 'mango' is not found in the fruits list.
  • Line 6: Prints True – 'banana' is present within the fruits list.

Output

False
True


The not in Operator

The not in operator works alongside the in operator but with the opposite logic. It acts like a "not in the club" checker for collections. Imagine you have a group of members and want to see if someone is not on the list. Here's the syntax:

Syntax

item not in collection

The result is True if the item is not found in the collection and False otherwise. It's useful for finding things excluded from a set or list.

Example

fruits = ["apple", "banana", "orange"]

print(5 not in fruits)     # True - number not in the fruit list
print("apple" not in fruits)  # False - the fruit is in the list

Code Explanation

  • Line 3: Prints True 5 is correctly not found in the fruits list.
  • Line 4: Prints False – "apple" is correctly found in the fruits list (meaning it is not absent).

Output

True
False


Exponentiation and Unary Operators

Python offers several operators that change or analyze a single value. The most common ones include the exponentiation operator (**), which helps you calculate powers (e.g., 3 raised to the power of 4), and the unary operators. Unary operators come in two flavors: the positive operator (+), which mostly just confirms a number as positive, and the negative operator (-), which flips the sign of a number (positive to negative, and vice versa). Unary operators work on only one operand (number) and sit directly in front of it.

Exponent Operator ( ** )

The exponent operator (**) is your shortcut for repeated multiplication. Imagine you have a number and want to multiply it by itself a certain number of times. Here's the syntax:

Syntax

base ** exponent

  • base: The number you want to multiply (like the growth rate).
  • exponent: The number of times to multiply by itself (like how many times it grows).

Calculates base to the power of exponent. For example, 2 ** 3 is the same as 2 * 2 * 2.

Example

# Calculate the square of 5 (5 to the power of 2)
result = 5 ** 2
print(f"5 squared: {result}")  # Output: 25

# Calculate the cube of 3 (3 to the power of 3)
result = 3 ** 3
print(f"3 cubed: {result}")    # Output: 27

Code Explanation

  • Line 1: Comment explaining the upcoming calculations.
  • Line 2: Calculates 5 squared (5 ** 2) and stores the result (25) in the result variable.
  • Line 3: Prints "5 squared: 25" using an f-string.
  • Line 6: Calculates 3 cubed (3 ** 3) and stores the result (27) in the result variable.
  • Line 7: Prints "3 cubed: 27" using an f-string.

Output

5 squared: 25
3 cubed: 27


Caret Operator ( ^ )

The caret operator (^) performs a bitwise exclusive OR (XOR) operation on integers. Imagine having two lights, one representing 1s and the other 0s. The XOR operation turns on a light only if the corresponding bits in the two numbers are different. Here's the syntax:

Syntax

operand1 ^ operand2

operand1 and operand2: The integers you want to perform the bitwise XOR on (like the two sets of lights).

For example, 10 ^ 3 (in binary, 1010 ^ 0011) results in 13 (in binary, 1101) because the bits in positions 1 and 4 are different (1 XOR 0 is 1).

Example

result = 10 ^ 3  # Perform bitwise XOR on 10 and 3
print(result)      # Output: 13

Code Explanation

  • Line 1: Assigns the result of the bitwise XOR operation between 10 and 3 (10 ^ 3) to the result variable.
  • Line 2: Prints the result, which is 13.

Unary Plus and Minus Operators

Python offers two unary operators: the positive (+) and the negative (-) signs. While the negative unary operator changes a number's sign, the positive unary operator has a more subtle effect. It largely confirms that a number is already positive (often leaving it unchanged) but can be used in certain situations to force a non-numeric value to become a number if possible. The negative unary operator works to flip a positive number to a negative and vice versa.

Unary Plus Operator ( + )

Python's unary plus operator (+) acts like a neutral observer for numbers. Unlike mathematical plus for addition, it doesn't change the value of a positive number. It says, "Hey, this is already a positive number." Here's the syntax:

Syntax

+operand

While seemingly redundant for positive numbers, it can be useful in specific situations, like forcing a conversion to a numeric value.

Example

x = +10  # The plus sign has no effect here
y = +"hello"  # Attempt to convert "hello" to a number (causes an error)
print(x)  # Output: 10
# print(y)  # This line will cause an error because "hello" cannot be converted to a number

Code Explanation

  • Line 1: Assigns the value 10 to x. The unary plus has no effect here.
  • Line 2: Tries to convert the string "hello" to a number using the unary plus. This will cause a TypeError because "hello" cannot be converted to a numerical value.
  • Line 3: Prints the value of x, which is 10.

Unary Minus Operator ( - )

The unary minus operator (-) flips the sign of a number. It essentially acts like a minus sign in front of a number without needing another operand. Here's the syntax:

Syntax

-operand

This operator is handy for quickly making positive numbers negative and vice versa.

Example

x = 10
y = -x  # Negate the value of x
print(f"x: {x}, y: {y}")  # Output: x: 10, y: -10

Code Explanation

  • Line 1: Assigns the value 10 to x.
  • Line 2: Assigns the negation of x to y. The unary minus operator flips the sign, so -10 is stored in y.
  • Line 3: Uses an f-string to print the values of x and y.

Unary Tilde Operator ( ~ )

The unary tilde operator (~) handles bitwise operations, acting like a bitwise NOT. Imagine a series of switches (0s and 1s) representing a number in binary. The tilde operator flips all the bits: 0s become 1s, and 1s become 0s. Here's the syntax:

Syntax

~operand

Remember that this operation works on binary representations of integers, so a basic understanding of binary can be helpful.

Example

x = 10  # In binary, 1010
y = ~x  # Flips all the bits (0101)
print(f"x: {x}, y: {y}")  # Output: x: 10, y: -11 (one's complement interpretation)

Code Explanation

  • Line 1: Assigns the value 10 to x. In binary, 10 is represented as 1010.
  • Line 2: Applies the bitwise NOT operation to x using the tilde operator (~). This flips all the bits, resulting in 0101 in binary.
  • Line 3: Prints the values of x and y. While y shows -11, it's due to one's complement interpretation (inverting bits and adding 1). The actual binary value of y is 0101, which is 5 in decimal.