Python Operators: Arithmetic & Comparison

Understanding Operators and Expressions

At its core, an operator is a symbol that tells the computer to perform a specific mathematical or logical manipulation. The values that an operator acts upon are called operands.

For example, in the expression 5 + 6, the + is the operator, and 5 and 6 are the operands.

Let's begin with a short video that provides a clear, theoretical definition of these terms.

Now that you have the basic terminology, let's explore the first major category of operators.

Arithmetic Operators: The Tools for Calculation

Arithmetic operators allow you to perform mathematical calculations. Since you'll be working towards AI and complex systems, a solid grasp of these is essential for everything from simple data manipulation to implementing the mathematical formulas behind machine learning algorithms.

Python supports the following arithmetic operators:

To get a comprehensive understanding of how each of these works, please read the following section from a detailed article on Real Python.

Comparison Operators: The Basis of Logic

While arithmetic operators are for calculation, comparison (or relational) operators are for decision-making. They compare two values and produce a Boolean result: True or False. This is the foundation of logic in your programs, allowing them to react differently based on conditions.

The main comparison operators are:

Now, let's watch a video that demonstrates these operators in action.

An Important Note on Comparing Floats

A crucial theoretical point: due to the way floating-point numbers are stored in computer memory, using the == operator for exact equality can be unreliable. It is better practice to check if two floats are "close enough" to each other. We will revisit this advanced topic later, but it's an important concept to be aware of. The Real Python article you read earlier touches on this in its section on comparing floating-point values.

Controlling the Flow: Operator Precedence and Augmented Assignment

What happens when you combine multiple operators in one expression, like 10 + 5 * 2? Does Python add first, or multiply? The order is determined by operator precedence.

Additionally, Python offers a convenient shorthand called augmented assignment for modifying a variable's value (e.g., incrementing a counter).

Let's return to the Real Python article to understand these two important concepts.

Your Turn: Applying Operators

Now, let's put theory into practice. Imagine you are working on a simple physics simulation. Your task is to calculate the final velocity of an object and check if it has exceeded a safety limit.

Hands-On Exercise:

In your Python environment, write a script that does the following:

1. Create the following variables:

   • initial_velocity_mps = 10 (velocity in meters per second)
   • acceleration_mps2 = 2.5 (acceleration in m/s²)
   • time_sec = 5 (time in seconds)
   • speed_limit_kph = 50 (speed limit in kilometers per hour)

2. Calculate Final Velocity: Using the formula $v_f=v_i+a\times t$, calculate the final velocity in meters per second and store it in a variable named final_velocity_mps.

3. Convert to KPH: Convert the final velocity from m/s to km/h and store it in a variable named final_velocity_kph.

   • Hint: To convert m/s to km/h, multiply by 3.6.

4. Perform a Safety Check: Use a comparison operator to check if final_velocity_kph is greater than speed_limit_kph. Store the True/False result in a variable called is_overspeeding.

5. Print the results: Use the print() function to display the values of final_velocity_kph and is_overspeeding.

Example Code Structure:

# 1. Define initial variables
initial_velocity_mps = 10



# ... define other variables




# 2. Calculate final velocity in m/s
final_velocity_mps = initial_velocity_mps + acceleration_mps2 * time_sec




# 3. Convert to km/h
# ... your code here




# 4. Perform safety check
# ... your code here




# 5. Print results
print("Final Velocity (km/h):", final_velocity_kph)
print("Exceeded Speed Limit:", is_overspeeding)

After running your code, check if your output matches this:

Final Velocity (km/h): 81.0
Exceeded Speed Limit: True

This exercise validates that you can use arithmetic operators in the correct order of precedence and then use comparison operators to make a logical determination.

Conclusion

In this lesson, you've added the essential "verbs" of programming to your toolkit. You can now not only store data but also perform calculations and make comparisons with it.

Key Takeaways:

• Arithmetic Operators (+, -, *, /, //, %, **) are used for mathematical calculations.
• Comparison Operators (==, !=, >, <, etc.) are used to compare values and result in a True or False boolean value, forming the basis of program logic.
• Operator Precedence dictates the order of operations in complex expressions, which can be overridden with parentheses ().
• Augmented Assignment operators like += provide a concise way to update a variable's value.

Here is a helpful cheat sheet that summarizes the operators we've discussed today.

Preview of the Next Lesson:
So far, you've written code as a linear sequence of commands. To build sophisticated applications, you'll need a way to organize and reuse your code. In the next lesson, we will cover functions. You will learn how to define your own reusable blocks of code that can accept inputs (parameters) and produce outputs (return values), a crucial step towards building modular and powerful programs.