Operators

Level: 2 | Version: v1.0 | Author: Meptrasoft

Operators let us calculate, compare, and combine values. This module uses a Student Placement Eligibility System as the running example.

What is an Operator?

An operator is a symbol or keyword used to perform an operation on values. Variable names can be used in expressions because they refer to values.

cgpa = 8.5
bonus = 0.5
final_cgpa = cgpa + bonus
print(final_cgpa)

Output:

9.0

Here, + is an operator. It performs addition.

What are Operands?

The values on which an operator performs an operation are called operands.

cgpa = 8.5
bonus = 0.5
print(cgpa + bonus)

Here:

• cgpa → Operand
• + → Operator
• bonus → Operand

Output:

9.0

Why Do We Use Operators?

Operators are used to:

• Perform calculations
• Compare values
• Check conditions
• Combine multiple conditions
• Assign values
• Check membership
• Compare objects

Example:

cgpa = 8.5
print(cgpa >= 7.0)

Output:

True

This can be used to check whether a student meets a company's CGPA requirement.

Types of Operators in Python

We will use this data throughout the topic.

cgpa = 8.5
age = 21
backlogs = 0
skills = ["Python", "SQL", "Java"]
is_placed = False

Arithmetic Operators

Arithmetic operators perform mathematical calculations.

Addition +

Adds two values.

cgpa = 8.0
bonus = 0.5
final_cgpa = cgpa + bonus
print(final_cgpa)

Output:

8.5

Subtraction -

Subtracts one value from another.

required_cgpa = 7.0
student_cgpa = 8.5
difference = student_cgpa - required_cgpa
print(difference)

Output:

1.5

Multiplication *

Multiplies values.

monthly_stipend = 15000
months = 6
total_stipend = monthly_stipend * months
print(total_stipend)

Output:

90000

Division /

Divides one value by another.

total_marks = 450
subjects = 5
total_marks = 450
total_marks = 450
average = total_marks / subjects
print(average)

Output:

90.0

Important

The / operator returns a float.

print(10 / 2)

Output:

5.0

Floor Division //

Returns the floor of the division result.

questions = 10
students = 3
questions_per_student = questions // students
print(questions_per_student)

Output:

3

10 / 3  → 3.333...
10 // 3 → 3

Important

Floor division rounds the result down toward negative infinity.

print(-10 // 3)

Output:

-4

It does not simply remove the decimal part.

Modulus %

Returns the remainder.

students = 10
team_size = 3
remaining_students = students % team_size
print(remaining_students)

Output:

1

Common Use — Even or Odd

student_id = 102
print(student_id % 2)

Output:

0

If:

number = 10
number = 10
number % 2 == 0 → Even
number % 2 != 0 → Odd

Exponentiation **

Raises a value to a power.

print(2 ** 3)

Output:

8

2³ = 2 × 2 × 2 = 8

Arithmetic Operator Quick Comparison

students = 10
team_size = 3

students = 10
team_size = 3
result = students / team_size
print(result)

3.3333333333333335

10 ÷ 3 = 3.333...

total_marks = 450
subjects = 5
average = total_marks / subjects
print(average)

90.0

Need the division result?
        ↓
       Use /

students = 10
team_size = 3
complete_teams = students // team_size
print(complete_teams)

3

Team 1 → 3 students
Team 2 → 3 students
Team 3 → 3 students
Used students → 9
Remaining     → 1

total_records = 95
records_per_page = 10
total_records = 95
total_records = 95
full_pages = total_records // records_per_page
print(full_pages)

9

print(total_seconds = 130)
print(total_seconds)
total_seconds = 130
total_seconds = 130
minutes = total_seconds // 60
print(minutes)

130
2

print(10 // 3)   # 3
print(-10 // 3)  # -4

3
-4

// gives the floor of the division result

Need complete groups or whole units?
              ↓
             Use //

students = 10
team_size = 3
remaining_students = students % team_size
print(remaining_students)

1

10 students
↓
3 complete teams × 3 students = 9 students
↓
1 student remaining

number = 10
print(number % 2)

0

number % 2 == 0

The number is even.

number = 10
if number % 2 == 0:
    print("Even")
else:
    print("Odd")

total_seconds = 130
remaining_total_seconds = 130
total_seconds = 130
seconds = total_seconds % 60
print(remaining_seconds)

10

130 seconds
↓
2 complete minutes = 120 seconds
↓
10 seconds remaining

Need to know what is left?
           ↓
          Use %

students = 10
team_size = 3

team_size = 3
students = 10
print(students / team_size)
print(students // team_size)
print(students % team_size)

3.3333333333333335
3
1

10 students ÷ 3 students per team
/  → Mathematical division result = 3.333...
// → Complete teams             = 3
%  → Students left             = 1

print(total_seconds = 130)

2 minutes 10 seconds

total_seconds = 130
minutes = total_seconds // 60
seconds = total_seconds % 60
print(minutes, "minutes")
print(seconds, "seconds")

2 minutes
10 seconds

130 // 60 → 2 complete minutes
130 % 60  → 10 remaining seconds

// → Complete units
%  → Remaining units

total_records = 95
records_per_page = 10

full_pages = total_records // records_per_page
print(full_pages)

9

records_per_page = 10
total_records = 95
remaining_records = total_records % records_per_page
print(remaining_records)

5

9 full pages
5 records remaining

records_per_page = 10
total_records = 95
total_pages = (total_records + records_per_page - 1) // records_per_page
print(total_pages)

10

// → Complete pages
%  → Remaining records

total_minutes = 135
hours = total_minutes // 60
minutes = total_minutes % 60
print(hours, "hours")
print(minutes, "minutes")

2 hours
15 minutes

135 // 60 → 2 complete hours
135 % 60  → 15 remaining minutes

Yes → /

average = total_marks / subjects

Yes → //

minutes = total_seconds // 60

Yes → %

seconds = total_seconds % 60

/  → DIVISION RESULT
// → FLOOR / COMPLETE UNITS
%  → REMAINDER / LEFTOVER

10 Students
3 Students Per Team
10 / 3  → 3.333...  → Division result
10 // 3 → 3         → Complete teams
10 % 3  → 1         → Student left

Comparison Operators

Comparison operators compare two values. The result is always a Boolean value (True or False).

Let's check placement eligibility.

cgpa = 8.5
required_cgpa = 7.0

Equal To ==

required_cgpa = 7.0
cgpa = 8.5
print(cgpa == required_cgpa)

Output:

False

Not Equal To !=

required_cgpa = 7.0
cgpa = 8.5
print(cgpa != required_cgpa)

Output:

True

Greater Than >

required_cgpa = 7.0
cgpa = 8.5
print(cgpa > required_cgpa)

Output:

True

Less Than <

required_cgpa = 7.0
cgpa = 8.5
print(cgpa < required_cgpa)

Output:

False

Greater Than or Equal To >=

required_cgpa = 7.0
cgpa = 8.5
print(cgpa >= required_cgpa)

Output:

True

Less Than or Equal To <=

backlogs = 0
print(backlogs <= 0)

Output:

True

= vs ==

This is one of the most common fresher mistakes.

cgpa = 8.5

Assigns 8.5 to cgpa.

cgpa = 8.5
cgpa == 8.5

Checks whether cgpa is equal to 8.5.

Placement Favorite: Difference between = and ==.

Assignment Operators

Assignment operators assign or update values.

Assignment =

cgpa = 8.5

Addition Assignment +=

cgpa = 8.0
cgpa += 0.5
print(cgpa)

Output:

8.5

This is the same as:

cgpa = 8.0
cgpa = cgpa + 0.5

Subtraction Assignment -=

backlogs = 2
backlogs -= 1
print(backlogs)

Output:

1

Multiplication Assignment *=

stipend = 15000
stipend *= 2
print(stipend)

Output:

30000

Compound assignment operators make code shorter and cleaner.

Logical Operators

Logical operators combine or modify conditions.

Let's use placement eligibility.

cgpa = 8.5
backlogs = 0
skills = ["Python", "SQL", "Java"]

and

Returns True when both conditions are True.

backlogs = 0
cgpa = 8.5
print(cgpa >= 7.0 and backlogs == 0)

Output:

True

Visual understanding:

Placement Example

backlogs = 0
cgpa = 8.5
eligible = cgpa >= 7.0 and backlogs == 0
print(eligible)

The student is eligible only when both requirements are satisfied.

or

Returns True when at least one condition is True.

skills = ["Python", "SQL", "Java"]
print("Python" in skills or "Java" in skills)

Output:

True

Visual understanding:

Placement Example

A company accepts Python or Java developers.

skills = ["Python", "SQL", "Java"]
has_skill = "Python" in skills or "Java" in skills
print(has_skill)

At least one required skill is enough.

not

Reverses the truth value.

is_placed = False
print(not is_placed)

Output:

True

not True  → False
not False → True

Placement Example

is_placed = False
if not is_placed:
    print("Student is available for placement")

Logical Operator Quick Understanding

Output:

Student is available for placement

Membership Operators

Membership operators check whether a value exists in a collection.

Let's use student skills.

skills = ["Python", "SQL", "Java"]

in

skills = ["Python", "SQL", "Java"]
print("Python" in skills)

Output:

True

not in

skills = ["Python", "SQL", "Java"]
print("Git" not in skills)

Output:

True

Real-Time Placement Example

skills = ["Python", "SQL", "Java"]
required_skill = "Python"
eligible = required_skill in skills
print(eligible)

Membership operators are commonly used with strings, lists, tuples, sets, and dictionaries.

Membership with Dictionary

student = {
    "name": "Arun",
    "cgpa": 8.5
}
print("name" in student)

Output:

True

Important

For dictionaries, in checks keys by default.

student = {
print("Arun" in student)

Output:

False

To check values:

student = {
print("Arun" in student.values())

Output:

True

Identity Operators

Identity operators check whether two names refer to the same object.

Consider:

skills = ["Python", "SQL"]
student_skills = skills

Both names refer to the same list.

student_skills = skills
skills = ["Python", "SQL"]
print(skills is student_skills)

Output:

True

Now create another list:

skills = ["Python", "SQL"]
required_skills = ["Python", "SQL"]
print(skills == required_skills)
print(skills is required_skills)

Output:

True
False

Why?

== → Same value?
is → Same object?

The lists contain the same values but are different objects.

== vs is

a = ["Python", "SQL"]
b = ["Python", "SQL"]
print(a == b)  # True
print(a is b)  # False

Placement Favorite: Difference between == and is.

Correct Use of is

is is commonly used with None.

result = None
print(result is None)

Recommended:

result = None
if result is None:
    print("No result available")

Avoid using is for normal value comparison.

age = 21
age is 21  # Avoid

Use:

age = 21
age == 21

Bitwise Operators

Bitwise operators perform operations on the binary representation of integers.

Consider:

a = 5
b = 3
print(b)

Binary values:

Output:

3

Bitwise AND &

print(5 & 3)

Binary:

Output:

1

Output:

1

Bitwise OR |

print(5 | 3)

Binary:

Output:

7

Output:

7

Bitwise XOR ^

Returns 1 when the bits are different.

print(5 ^ 3)

Binary:

Output:

6

Output:

6

Bitwise NOT ~

In Python:

~x = -(x + 1)

Example:

print(~5)

Output:

-6

Left Shift <<

Shifts bits to the left.

print(5 << 1)

Output:

10

For non-negative integers, shifting left by one position is equivalent to multiplying by 2.

5 << 1 → 10

Right Shift >>

Shifts bits to the right.

print(5 >> 1)

Output:

2

For non-negative integers, shifting right by one position behaves like floor division by 2.

5 >> 1 → 2

Real-Time Usage of Bitwise Operators

Bitwise operators are commonly seen in permission flags, low-level programming, networking, embedded systems, image processing, and binary data handling. For fresher placement preparation, understand the basic operation and output.

Operator Precedence

When multiple operators are used in one expression, Python follows an order of evaluation.

result = 10 + 5 * 2
print(result)

Output:

20

Why not 30? Multiplication happens before addition.

10 + 5 * 2
10 + 10
20

Using parentheses:

result = (10 + 5) * 2
print(result)

Output:

30

Simplified Precedence Order

Beginner Rule

When an expression is difficult to understand, use parentheses.

backlogs = 0
cgpa = 8.5
eligible = (cgpa >= 7.0) and (backlogs == 0)

This makes the code easier to read.

Complete Placement Eligibility Example

cgpa = 8.5
age = 21
backlogs = 0
skills = ["Python", "SQL", "Java"]
is_placed = False

has_required_cgpa = cgpa >= 7.0
has_no_backlogs = backlogs == 0
has_required_skill = "Python" in skills
is_available = not is_placed

eligible = (
    has_required_cgpa
    and has_no_backlogs
    and has_required_skill
    and is_available
)

print("Placement Eligible:", eligible)

Output:

Placement Eligible: True

How it works:

cgpa >= 7.0        → True
backlogs == 0      → True
"Python" in skills → True
not is_placed      → True
True and True and True and True
                ↓
              True

This is how operators work together in real application logic.

Common Fresher Mistakes

Placement Quick Points

• Operators perform operations on values; values used with operators are called operands.
• Arithmetic operators perform calculations.
• / performs division and returns a float.
• // performs floor division.
• % returns the remainder.
• ** performs exponentiation.
• Comparison operators return Boolean results.
• = assigns a value; == compares values.
• and requires all conditions to be True.
• or requires at least one condition to be True.
• not reverses a Boolean condition.
• in and not in are membership operators.
• is checks object identity; == checks value equality.
• Bitwise operators work with binary representations of integers.
• Parentheses improve expression clarity.

Interview Questions

What is an operator?

An operator is a symbol or keyword used to perform an operation on values.

What is an operand?

A value on which an operator performs an operation.

What is the difference between / and //?

/ performs division. // performs floor division.

What does % return?

The remainder.

What is the difference between = and ==?

= assigns a value. == compares values.

What is the difference between and and or?

and requires all conditions to be True. or requires at least one condition to be True.

What does not do?

It reverses a Boolean condition.

What is the difference between in and not in?

in checks whether a value exists. not in checks whether it does not exist.

What is the difference between == and is?

== compares values. is compares object identity.

What does 10 % 3 return?

1.

What does 2 ** 3 return?

8.

What does 10 // 3 return?

3.

What does -10 // 3 return?

-4.

What does in check in a dictionary?

Dictionary keys by default.

What is operator precedence?

The order in which Python evaluates operators in an expression.

Practice

Use:

cgpa = 8.5
age = 21
backlogs = 0
skills = ["Python", "SQL", "Java"]
is_placed = False

1. Check whether cgpa is greater than or equal to 7.0.
2. Check whether the student has zero backlogs.
3. Check whether "Python" exists in skills.
4. Check whether "Git" does not exist in skills.
5. Check whether the student is not placed.
6. Combine CGPA and backlog conditions using and.
7. Check whether the student knows "Python" or "Java".
8. Increase cgpa by 0.5 using an assignment operator.
9. Find the remainder when 10 is divided by 3 (use the % operator).
10. Find the result of 2 ** 5.
11. Explain the difference between / and //.
12. Explain the difference between == and is.
13. Predict the output:

print(10 + 5 * 2)

39. Predict the output:

print((10 + 5) * 2)

40. Predict the output:

print(-10 // 3)

41. Find the mistake:

age is 21

42. Create a placement eligibility condition using CGPA >= 7.0, zero backlogs, "Python" in skills, and student not already placed.

End of Level 2