Chapter 15: Operators

Part 1: What Are Operators?

An operator is a symbol that represents a specific action or operation to be performed on one or more values, which we call operands.

• Operand: The values or variables that the operator acts upon. (e.g., in 5 + 3, 5 and 3 are operands).

• Operator: The symbol that defines the action (e.g., + is the operator).

The combination of operands and operators forms an expression, which evaluates to a single value.

Part 2: The Main Families of Operators

We can group operators into several key families based on what they do. Let’s explore each one with examples in Python.

Family 1: Arithmetic Operators – The Mathematicians

These are the operators you’re most familiar with from math class. They perform basic mathematical calculations on numeric operands.

Instructor’s Note: Pay special attention to // and %. They are incredibly useful. Modulo (%) is perfect for checking if a number is even (number % 2 == 0), cycling through a range, or many other tasks.

Family 2: Assignment Operators – The Store Keepers

These operators are used to assign values to variables. The most basic is the = sign, but it’s often combined with arithmetic operators to create shortcuts.

Family 3: Comparison Operators – The Judges

These operators compare two values and always return a boolean result: True or False. They are the foundation of decision-making in programs.

Family 4: Logical Operators – The Decision Makers

These operators combine or invert boolean values. They allow you to build complex conditions from simpler ones.

Family 5: Identity Operators – The Twin Finders

These operators are special to Python. They don’t compare if two variables have the same value (use == for that). They compare if two variables refer to the exact same object in memory.

This is subtle but very important. Two lists can have the exact same contents (== would be True), but if they were created separately, they are different objects in memory (is would be False).

When to use is: Primarily for comparing with the single value None.

Family 6: Membership Operators – The Search Party

These operators test whether a value exists within a sequence, like a string, list, or tuple.

Part 3: Operator Precedence (The Order of Operations)

Just like in mathematics, operators have a defined precedence that determines the order in which they are evaluated in a complex expression. You probably remember “Please Excuse My Dear Aunt Sally” (Parentheses, Exponents, Multiplication/Division, Addition/Subtraction). Programming is similar, but with more operators.

The general rule of thumb: When in doubt, use parentheses () to make your intention clear to both the computer and anyone reading your code.

Part 4: Putting It All Together – A Practical Example

Let’s build a small program that checks if a user is eligible for a special discount. This combines assignment, arithmetic, comparison, and logical operators.

This example shows how operators are not just isolated symbols but the glue that holds the logic of our programs together.

Summary: The Operator Philosophy

• Operators are the action symbols of programming. They perform operations on data.

• Arithmetic Operators (+, -, *, /, //, %, **) do math.

• Assignment Operators (=, +=, -=, etc.) store values.

• Comparison Operators (==, !=, >, <, etc.) create logic by producing True/False.

• Logical Operators (and, or, not) combine these boolean values for complex decisions.

• Identity Operators (is, is not) check if two things are the exact same object.

• Membership Operators (in, not in) check for existence in a sequence.

• Operator Precedence determines the order of evaluation. Use parentheses () to be clear and safe.

Mastering operators is like learning the verbs of a language. Without them, you can have all the nouns (data) you want, but you can’t make a sentence (a program). Practice using them in different combinations, and they will soon become second nature.