Python, mathematical operators are symbols that perform arithmetic operations on numerical values. Here’s a breakdown of the key operators:

Basic Arithmetic Operators:

• Addition (+):
  • Adds two operands.
  • Example: 5 + 3 results in 8
• Subtraction (-):
  • Subtracts the second operand from the first.
  • Example: 10 - 4 results in 6
• Multiplication (*):
  • Multiplies two operands.
  • Example: 6 * 7 results in 42
• Division (/):
  • Divides the first operand by the second.
  • Always returns a floating-point number (float).
  • Example: 15 / 4 results in 3.5

Other Important Operators:

• Modulus (%):
  • Returns the remainder of a division.
  • Example: 17 % 5 results in 2
• Floor Division (//):
  • Divides the first operand by the second and returns the integer part of the quotient.
  • Example: 17 // 5 results in 3
• Exponentiation ():**
  • Raises the first operand to the power of the second.
  • Example: 2 ** 3 results in 8

Operator Precedence:

Python follows the standard mathematical order of operations (often remembered by the acronym PEMDAS or BODMAS):

1. Parentheses ( )
2. **Exponents **
3. Multiplication *, Division /, Floor Division //, Modulus % (from left to right)
4. Addition +, Subtraction – (from left to right)

Understanding these operators and their precedence is essential for performing calculations in Python.

Mathematical Operations in Python with BODMAS Rules

Python follows the BODMAS (Brackets, Orders, Division/Multiplication, Addition/Subtraction) rule for evaluating mathematical expressions. This ensures operations are performed in a specific order to avoid ambiguity. Below is a breakdown with examples:

BODMAS Hierarchy in Python

1. B – Brackets ()

• Parentheses are evaluated first.
• Nested parentheses are solved from the innermost to outermost.

   print((3 + 2) * 4)  # (5) * 4 = 20

2. O – Orders (Exponents/Roots) **

• Exponents (powers) are calculated next.

   print(2 ** 3 * 2)  # 8 * 2 = 16 (Exponent first)

3. D/M – Division / and Multiplication *

• Division and multiplication have equal precedence and are evaluated left to right.

   print(10 / 2 * 3)  # 5 * 3 = 15 (Left to right)

4. A/S – Addition + and Subtraction -

• Addition and subtraction have equal precedence and are evaluated left to right.

   print(10 - 3 + 2)  # 7 + 2 = 9 (Left to right)

Examples with BODMAS

Example 1

result = 5 + 3 * 2 ** 2  
# Step 1: 2 ** 2 = 4  
# Step 2: 3 * 4 = 12  
# Step 3: 5 + 12 = 17  
print(result)  # Output: 17

Example 2

result = (10 - 2) * (3 + 1) / 2  
# Step 1: (10 - 2) = 8  
# Step 2: (3 + 1) = 4  
# Step 3: 8 * 4 = 32  
# Step 4: 32 / 2 = 16.0  
print(result)  # Output: 16.0

Example 3

result = 4 ** 3 ** 2  
# Step 1: 3 ** 2 = 9 (Exponents are right-associative)  
# Step 2: 4 ** 9 = 262144  
print(result)  # Output: 262144

Operator Precedence Table

Operator	Description	Example
()	Brackets	(3 + 2) * 4
**	Exponent	2 ** 3
*, /, //, %	Multiplication, Division	5 * 3 / 2
+, -	Addition, Subtraction	10 - 3 + 2

Common Mistakes

1. Ignoring Left-to-Right Rule:

   print(10 / 2 * 3)  # 15 (Correct: 10/2=5 → 5*3=15)
   print(10 * 3 / 2)  # 15 (Same result)

2. Forgetting Parentheses:

   # Intended: (5 + 3) * 2 = 16
   print(5 + 3 * 2)  # 11 (Wrong!)

3. Exponent Associativity:

   print(2 ** 3 ** 2)  # 512 (Right-associative: 2^(3^2) = 2^9)
   print((2 ** 3) ** 2) # 64 (With parentheses)

Best Practices

1. Use Parentheses to clarify complex expressions:

   # Clearer version of Example 1:
   result = 5 + (3 * (2 ** 2))

2. Break Down Calculations for readability:

   base = 2 ** 3
   total = 5 + base
   print(total)  # 13

3. Test Edge Cases:

   print(10 / 3)      # 3.333...
   print(10 // 3)     # 3 (Floor division)

Summary

Python strictly follows BODMAS rules for evaluating mathematical expressions. Always:

• Use parentheses to override default precedence.
• Remember that exponents are right-associative.
• Apply left-to-right evaluation for operations with equal precedence.

Here’s a detailed explanation of Number Manipulation and F-Strings in Python, with examples:

1. Number Manipulation

Number manipulation involves performing operations on numeric data types (int, float) to modify or format their values.

Common Operations

1. Arithmetic Operations:

   a = 10
   b = 3
   print(a + b)  # 13 (Addition)
   print(a - b)  # 7 (Subtraction)
   print(a * b)  # 30 (Multiplication)
   print(a / b)  # 3.333... (Division)
   print(a % b)  # 1 (Modulus)
   print(a ** b) # 1000 (Exponentiation)
   print(a // b) # 3 (Floor Division)

2. Rounding Numbers:

   num = 3.14159
   print(round(num, 2))  # 3.14 (Round to 2 decimal places)

3. Absolute Value:

   print(abs(-7.5))  # 7.5

F-Strings in Python: Formatted String Literals

F-strings (formatted string literals) are a feature introduced in Python 3.6 that allow you to embed expressions inside string literals using curly braces {}. They are prefixed with f or F and provide a concise, readable way to format strings. Below are examples illustrating their usage:

---

1. Basic Variable Substitution

Embed variables directly into strings:

name = "Alice"
age = 30
print(f"Hello, {name}! You are {age} years old.")
# Output: Hello, Alice! You are 30 years old.

---

2. Arithmetic Operations

Evaluate expressions directly within the string:

a = 5
b = 3
print(f"{a} + {b} = {a + b}")
# Output: 5 + 3 = 8

---

3. Number Formatting

Control decimal precision, commas, percentages, etc.:

pi = 3.14159
price = 49.99
population = 1_000_000
ratio = 0.75

print(f"Pi ≈ {pi:.2f}")                # Pi ≈ 3.14
print(f"Price: ${price:.2f}")          # Price: $49.99
print(f"Population: {population:,}")   # Population: 1,000,000
print(f"Completion: {ratio:.1%}")      # Completion: 75.0%

---

4. Date and Time Formatting

Format dates using datetime:

from datetime import datetime
today = datetime.now()
print(f"Today: {today:%B %d, %Y}")     # Today: October 05, 2023

---

5. Alignment and Padding

Align text with <, >, or ^:

text = "Python"
print(f"{text:>10}")   # Output: "    Python" (right-aligned)
print(f"{text:^10}")   # Output: "  Python  " (centered)

---

6. Dictionary Values

Access dictionary elements directly:

person = {"name": "Bob", "age": 25}
print(f"{person['name']} is {person['age']} years old.")
# Output: Bob is 25 years old.

---

7. Function/Method Calls

Call functions or methods inside f-strings:

name = "alice"
print(f"Name: {name.upper()}")  # Name: ALICE

---

8. Handling None Values

Use conditional expressions for fallback values:

value = None
print(f"Value: {value if value is not None else 'N/A'}")
# Output: Value: N/A

---

9. Debugging with = (Python 3.8+)

Print variable names and values for debugging:

name = "Alice"
print(f"{name=}")  # Output: name='Alice'

---

10. Multiline F-Strings

Use triple quotes for multiline formatting:

name = "Alice"
age = 30
salary = 85000.5

message = f"""
Name: {name}
Age: {age}
Salary: ${salary:,.2f}
"""
print(message)
# Output:
# Name: Alice
# Age: 30
# Salary: $85,000.50

---

11. Escaping Curly Braces

Include literal curly braces by doubling them:

print(f"{{Hello}}")  # Output: {Hello}

---

Key Advantages of F-Strings

• Readability: Clear and concise syntax.
• Performance: Faster than % formatting or str.format().
• Flexibility: Supports expressions, formatting, and even debugging.

Common Pitfalls

• Syntax Errors: Avoid backslashes \ inside {}.
• Version Compatibility: Requires Python 3.6+.

---

F-strings simplify string formatting in Python, making code cleaner and more efficient. Use them for dynamic text generation, data formatting, and debugging! 🚀

Here’s a set of interview questions and answers focused on Number Manipulation and F-Strings in Python, based on the previous explanation:

1. Number Manipulation

Q1. How do you perform arithmetic operations in Python?

Answer:
Python supports standard arithmetic operations using operators like +, -, *, /, % (modulus), ** (exponentiation), and // (floor division).
Example:

x = 10
y = 3
print(x + y)   # 13 (Addition)
print(x // y)  # 3 (Floor Division)

Q2. What is the difference between / and // operators?

Answer:

• / performs true division and returns a float.
• // performs floor division and returns an integer (rounded down).
  Example:

print(10 / 3)   # 3.333...
print(10 // 3)  # 3

Q3. How would you round a number to 2 decimal places?

Answer:
Use the round() function.
Example:

pi = 3.14159
print(round(pi, 2))  # 3.14

Q4. How do you format a number with commas as thousand separators?

Answer:
Use f-strings with the :, format specifier.
Example:

population = 1_000_000
print(f"Population: {population:,}")  # Population: 1,000,000

2. F-Strings

Q5. What are f-strings, and how do they work?

Answer:
F-strings (formatted string literals) allow embedding expressions inside strings using {}. They start with f or F before the string.
Example:

name = "Alice"
print(f"Hello, {name}!")  # Hello, Alice!

Q6. How do f-strings differ from str.format()?

Answer:

• F-strings are more concise and readable. Expressions are written directly inside {}.
• str.format() requires placeholders and separate arguments.
  Example:

# str.format()
print("Value: {:.2f}".format(3.14159))  # Value: 3.14

# F-strings
print(f"Value: {3.14159:.2f}")          # Same result, simpler syntax

Q7. How do you format a float to 2 decimal places using f-strings?

Answer:
Use the :.2f format specifier.
Example:

price = 49.99
print(f"Price: ${price:.2f}")  # Price: $49.99

Q8. How would you align text to the right using f-strings?

Answer:
Use the > operator with a width specifier.
Example:

text = "Python"
print(f"{text:>10}")  # "    Python" (Right-aligned in 10 spaces)

Q9. How do you display a percentage using f-strings?

Answer:
Use the :.0% or :.2% format specifier.
Example:

ratio = 0.75
print(f"Completion: {ratio:.0%}")  # Completion: 75%
print(f"Completion: {ratio:.2%}")  # Completion: 75.00%

Q10. How do you format dates in f-strings?

Answer:
Use the % specifier for date formatting.
Example:

from datetime import datetime
now = datetime.now()
print(f"Today: {now:%B %d, %Y}")  # Today: October 25, 2023

3. Combined Concepts

Q11. Write code to calculate the total price of 5 items costing $29.99 each and format the output using f-strings.

Answer:

quantity = 5
price = 29.99
total = quantity * price
print(f"Total: ${total:.2f}")  # Total: $149.95

Q12. What is the output of print(f"{5 + 3}")?

Answer:
8 (F-strings evaluate expressions inside {}).

4. Best Practices

Q13. Why are f-strings preferred over older formatting methods?

Answer:

• Readability: Expressions are inline.
• Performance: Faster execution.
• Flexibility: Supports complex expressions and formatting.

Q14. How would you handle large numbers with commas and decimal precision?

Answer:
Combine :, and :.2f in f-strings.
Example:

big_num = 1234567.8912
print(f"Value: {big_num:,.2f}")  # Value: 1,234,567.89

Summary

These questions cover arithmetic operations, number formatting, and f-string syntax. Use code examples to demonstrate clarity and practical understanding. Let me know if you need further elaboration! 😊