Start learning free

LESSON 19 OF 410 · CALCULATIONS WITH NUMBERS

Operator Precedence in Python

Lesson Read the full explanation

TL ; DR:

  • When we string operations together, Python must know which one to do first. This is called operator precedence.


  • * and / are performed before + and -:

    • print(1 + 2 * 3) # Prints 7
print(6 - 4 / 2) # Prints 4
print(5 * 4 - 2 / 2) # Prints 19

  • We can add () to force an operation to be performed first:

    print((1 + 2) * 3) # Prints 9
print((6 - 4) / 2) # Prints 1
print(5 * (4 - 2) / 2) # Prints 5

Full lesson:

When we string operations together, Python must know which one to do first. This is called operator precedence.

This is the hierarchy from highest precedence to lowest precedence:

  • Parentheses are always respected
  • Exponentiation (raise to a power)
  • Multiplication, Division and Remainder
  • Addition and Subtraction
  • Left to right

First example:

print(1 + 2 * 3) # Output: 7

Multiplication is executed before addition, so:

1 + 2 * 3 = 1 + 6 = 7

Second example:

print((1 + 2) * 3) # Output: 9

What's inside parentheses is executed before multiplication, so:

(1 + 2) * 3 = 3 * 3 = 9

Third example:

print(6 / 4 * 3 + 5) # Output: 9.5

Multiplication and division come before addition. Also, multiplication and division have the same priorty so they are executed from left to right:

6 / 4 * 3 + 5 = 1.5 * 3 + 5 = 4.5 + 5 = 9.5

Forth example:

print(6 / ((4 + 2) / 3)) # Output: 3

Computer sees parentheses so it looks at it like this:

6 / ((4 + 2) / 3) = 6 / x, where x = (4 + 2) / 3

I have to compute x first. Parantheses are executed before division:
(4 + 2) / 3 = 6 / 3 = 2

I can replace x with 2:
6 / ((4 + 2) / 3) = 6 / 2 = 3

Assignment
Follow the Coding Tutorial and let's practice with operator precedence!

Hint
Look at the examples above if you get stuck.

STEP 1 OF 1
    Ctrl + Enter to check

    PYTHON · CALCULATIONS WITH NUMBERS

    Operator Precedence in Python, explained

    Introduction

    In Python, when we string multiple operations together, the order in which these operations are executed is determined by operator precedence. Understanding operator precedence is crucial for writing correct and efficient code. It ensures that expressions are evaluated in the intended order, avoiding unexpected results.

    Operator precedence is particularly useful in scenarios involving complex mathematical calculations, logical operations, and when combining multiple operators in a single expression.

    Understanding the Basics

    Operator precedence defines the rules that govern the order in which different operations are performed in an expression. For example, in the expression 1 + 2 * 3, the multiplication is performed before the addition due to higher precedence of the multiplication operator.

    Here are some basic rules of operator precedence in Python:

    • Operations enclosed in parentheses () are performed first.
    • Exponentiation ** has higher precedence than multiplication *, division /, and remainder %.
    • Multiplication *, division /, and remainder % have higher precedence than addition + and subtraction -.
    • Operators with the same precedence are evaluated from left to right.

    Main Concepts

    Let's delve deeper into the key concepts of operator precedence with examples:

    Example 1: Basic Precedence

    print(1 + 2 * 3) # Output: 7

    In this example, multiplication is performed before addition:

    1 + 2 * 3 = 1 + 6 = 7

    Example 2: Using Parentheses

    print((1 + 2) * 3) # Output: 9

    Parentheses change the order of operations, so addition is performed before multiplication:

    (1 + 2) * 3 = 3 * 3 = 9

    Example 3: Multiple Operations

    print(6 / 4 * 3 + 5) # Output: 9.5

    Multiplication and division are performed before addition, and they are evaluated from left to right:

    6 / 4 * 3 + 5 = 1.5 * 3 + 5 = 4.5 + 5 = 9.5

    Example 4: Nested Parentheses

    print(6 / ((4 + 2) / 3)) # Output: 3

    Parentheses are evaluated first, followed by division:

    6 / ((4 + 2) / 3) = 6 / 2 = 3

    Examples and Use Cases

    Let's explore more examples and real-world use cases:

    Example 5: Complex Expression

    print(2 + 3 * 4 ** 2 / (1 + 1)) # Output: 26.0

    Exponentiation is performed first, followed by multiplication, division, and addition:

    2 + 3 * 4 ** 2 / (1 + 1) = 2 + 3 * 16 / 2 = 2 + 48 / 2 = 2 + 24 = 26.0

    Example 6: Logical Operations

    print(True or False and False) # Output: True

    Logical AND has higher precedence than logical OR:

    True or False and False = True or (False and False) = True or False = True

    Common Pitfalls and Best Practices

    Here are some common mistakes to avoid and best practices to follow:

    • Misunderstanding Precedence: Always remember the precedence rules to avoid unexpected results.
    • Using Parentheses: Use parentheses to make the order of operations explicit and improve code readability.
    • Testing: Test complex expressions to ensure they produce the expected results.

    Advanced Techniques

    Let's explore some advanced techniques related to operator precedence:

    Example 7: Combining Logical and Arithmetic Operations

    print((2 + 3) * 4 > 10 and 5 < 10) # Output: True

    Combining logical and arithmetic operations requires careful attention to precedence:

    (2 + 3) * 4 > 10 and 5 < 10 = 20 > 10 and 5 < 10 = True and True = True

    Code Implementation

    Here are some well-commented code snippets demonstrating the correct use of operator precedence:

    # Example 1: Basic Precedence
print(1 + 2 * 3) # Output: 7

# Example 2: Using Parentheses
print((1 + 2) * 3) # Output: 9

# Example 3: Multiple Operations
print(6 / 4 * 3 + 5) # Output: 9.5

# Example 4: Nested Parentheses
print(6 / ((4 + 2) / 3)) # Output: 3

# Example 5: Complex Expression
print(2 + 3 * 4 ** 2 / (1 + 1)) # Output: 26.0

# Example 6: Logical Operations
print(True or False and False) # Output: True

# Example 7: Combining Logical and Arithmetic Operations
print((2 + 3) * 4 > 10 and 5 < 10) # Output: True

    Debugging and Testing

    Here are some tips for debugging and testing code related to operator precedence:

    • Print Statements: Use print statements to check intermediate results in complex expressions.
    • Unit Tests: Write unit tests to verify the correctness of expressions involving multiple operators.
    • Debugging Tools: Use debugging tools to step through the code and inspect variable values.

    Thinking and Problem-Solving Tips

    Here are some strategies for approaching problems related to operator precedence:

    • Break Down Problems: Break down complex expressions into smaller parts and solve them step-by-step.
    • Practice: Practice with different expressions to become familiar with operator precedence rules.
    • Review: Regularly review the precedence rules to reinforce your understanding.

    Conclusion

    In this lesson, we covered the importance of operator precedence in Python and how it affects the evaluation of expressions. By understanding and applying the rules of operator precedence, you can write more accurate and efficient code. Remember to use parentheses to make the order of operations explicit and always test your expressions to ensure they produce the expected results.

    Mastering operator precedence is a fundamental skill that will help you in various programming scenarios, from simple calculations to complex logical operations. Keep practicing and exploring further applications to deepen your understanding.

    Additional Resources

    Here are some additional resources for further reading and practice:

    Keep going with PythonAbout 340 step-by-step lessons, from your first line of code to coding interviews. Free to start.
    Start learning free