# PEMDAS in Python

When it comes to solving mathematical expressions, we often rely on the rules of arithmetic to ensure that we arrive at the correct answer. One of the most fundamental rules of arithmetic is the order of operations, which dictates the sequence in which operations should be performed to achieve the correct result. PEMDAS, which stands for Parentheses, Exponents, Multiplication and Division, and Addition and Subtraction, is the acronym for this mathematical rule. In Python, these rules are also observed, and it is essential for programmers to have a firm understanding of how Python evaluates expressions.

In this article, we will take a deep dive into operator precedence in Python and how it relates to PEMDAS. We will cover the basics of operator precedence and show you how to use it in your code. We will also discuss the order of operations in Python and how to use parentheses to override it. Finally, we will provide examples of how to use operator precedence in real-world scenarios.

### Operator Precedence in Python

Operator precedence describes the sequence in which an expression's operations are evaluated. In Python, the term "operator precedence" refers to a set of guidelines that establish the sequence in which operators are evaluated. Operators are evaluated in order of decreasing precedence following the operator with the highest precedence.

In Python, the following table lists the operators and their corresponding precedence, starting with the highest precedence:

### Operator Description

As you can see from the table, the operators at the top of the list have the highest precedence, and the operators at the bottom have the lowest precedence.Operators are compared left to right when they have the same precedence .This indicates that if two operators have the same priority, the operator on the left will be examined before the operator on the right.

For example, consider the following expression:

`3 + 4 * 5`

The equation is evaluated as follows because multiplication has a higher precedence than addition under the operator precedence rules:

`3 + (4 * 5) = 23`

This is because the multiplication operation is evaluated first, and then the addition operation is evaluated.

### Parentheses in Python

Parentheses can be used in Python to change the language's default order of operations. Before performing an operation outside of parenthesis, any expression inside in parentheses is first evaluated. This allows you to control the order of operations in your code and ensure that the expression is evaluated in the way you want it to be.

For example, consider the following expression:

`(3 + 4) * 5`

Because the equation is enclosed in parenthesis, the evaluation of the addition operation comes first, then the assessment of the multiplication operation.The output of this is as follows:

`35`

Without the parentheses, the expression would be evaluated as follows:

`3 + 4 * 5 = 23`

In this case, the multiplication operation has a higher precedence than the addition operation, so it is evaluated first.

### Using Parentheses to Improve Readability

In addition to overriding the default order of operations, parentheses can also be used to improve the readability of your code. By using parentheses, you can make it clearer to other programmers what you intended for the expression to evaluate.

Take this sentence as an illustration:

`a + b * c / d - e`

While the operator precedence rules dictate that the multiplication and division operations should be performed before the addition and subtraction operations, it can still be difficult to read and understand the expression at a glance. By using parentheses to group the operations, you can make the expression easier to understand:

`(a + (b * c) / d) - e`

In this revised expression, it is clear that the multiplication and division operations are performed before the addition and subtraction operations.

### Real-World Examples of Operator Precedence in Python

Now that we have covered the basics of operator precedence in Python and how to use parentheses to override it, let's take a look at some real-world examples of how it can be used in practice.

### Example 1: Calculating a Discounted Price

Suppose you want to calculate the discounted price of an item that is on sale for 25% off its original price. To calculate the discounted price, you need to multiply the original price by 0.75.

The Python code for doing this is as follows:

Example:

``````original_price = 100
discount = 0.25
discounted_price = original_price * (1 - discount)
print(discounted_price)
``````

Output:

`75.0`

In this code, we use parentheses to ensure that the subtraction operation is performed before the multiplication operation.

The expression would be evaluated as follows without the parentheses:

`original_price * 1 - discount * original_price = 75.0`

This is so that addition and subtraction come after multiplication and division.By using parentheses, we ensure that the expression is evaluated in the way we intended.

### Example 2: Calculating the Area of a Triangle

Take into account a scenario in which you must calculate the area of a triangle with base b and height h. The following formula is used to determine a triangle's area:

`area = 0.5 * b * h`

The following describes how to use this formula in Python:

Example:

``````b = 10
h = 5
area = 0.5 * b * h
print(area)``````

Output:

`25.0`

In this code, we use multiplication and division to perform the necessary calculations. In this situation, parentheses are not necessary since multiplication takes precedence over division.

### Example 3: Converting Celsius to Fahrenheit

A temperature in Celsius can be converted to a Fahrenheit value. The following formula converts from Celsius to Fahrenheit:

`F = (C * 1.8) + 32`

Here's how you can implement this formula in Python:

Example:

``````C = 25
F = (C * 1.8) + 32
print(F)``````

Output:

`77.0`

In this code, we use multiplication, addition, and parentheses to perform the necessary calculations. Because multiplication has a higher priority than addition, we use parenthesis to make sure that it is performed before the addition operation.

### Conclusion

Understanding how operator precedence operates in Python is crucial because it is a fundamental idea in programming. By understanding the operator precedence rules and using parentheses to override them when necessary, you can write code that performs the correct calculations and is easy to read and understand. In this article, we have covered the basics of operator precedence in Python and how to use parentheses to override it. We have also given illustrations of how operator precedence might be applied in actual circumstances. With this knowledge, you should be able to write Python code that performs the calculations you need and is easy to understand and maintain.