Project: Tested Calculator Application in Python0%

Project: Tested Calculator Application in Python

Advanced9 min read•Updated: 2026-10-01

Project: Fully Tested Mathematical Expression Engine

Constructing a reliable expression evaluation engine requires rigorous parsing, strict operator precedence, support for variables, and complete test coverage against syntax anomalies, floating-point edge cases, and division-by-zero errors.

In this project, we will construct a production-ready Mathematical Expression Evaluator using a Recursive Tokenizer and Postfix (Shunting-Yard) Engine. The entire codebase is backed by a comprehensive Pytest test suite demonstrating fixtures, parametrization, exception verification, and edge-case testing.

1. Calculator Engine Architecture

The calculator uses Dijkstra's Shunting-Yard Algorithm to parse infix mathematical expressions (e.g. 3 + 4 * 2 / ( 1 - 5 ) ^ 2) into Reverse Polish Notation (RPN), followed by a stack-based evaluator:

Infix Expression: "10 + 2 * (5 - 1)"
               │
               ▼
       Lexical Tokenizer
['10', '+', '2', '*', '(', '5', '-', '1', ')']
               │
               ▼
    Shunting-Yard Parser (Operator Precedence Stack)
               │
               ▼
Reverse Polish Notation (RPN): ['10', '2', '5', '1', '-', '*', '+']
               │
               ▼
         Stack Evaluator ──► Result: 18.0

2. Production Engine Implementation

1import math
2import re
3from typing import Dict, List, Optional, Union
4 
5class CalculatorSyntaxError(ValueError):
  """Raised when an expression contains invalid tokens or mismatched parentheses."""
  pass
8 
9class MathEvaluationError(ZeroDivisionError):
  """Raised when a mathematical operation is undefined (e.g. division by zero)."""
  pass
12 
13class ExpressionCalculator:
  """A thread-safe mathematical expression evaluator supporting precedence and variables."""
15 
  # Operator precedence and associativity (True = left-associative, False = right)
  OPERATORS = {
      "+": (1, True),
      "-": (1, True),
      "*": (2, True),
      "/": (2, True),
      "^": (3, False),  # Exponentiation is right-associative
  }
24 
  CONSTANTS = {
      "PI": math.pi,
      "E": math.e
  }
29 
  def __init__(self, variables: Optional[Dict[str, float]] = None) -> None:
      self.variables = self.CONSTANTS.copy()
      if variables:
          self.variables.update(variables)
34 
  def tokenize(self, expression: str) -> List[str]:
      """Converts raw string into a list of mathematical tokens."""
      # Match numbers, operators, parentheses, or variable words
      token_pattern = re.compile(r"\d+(?:\.\d+)?|[a-zA-Z_]\w*|[+\-*/^()]")
      tokens = token_pattern.findall(expression)
      
      # Verify no illegal characters were ignored
      reconstructed = "".join(tokens)
      stripped_expr = re.sub(r"\s+", "", expression)
      if len(reconstructed) != len(stripped_expr):
          raise CalculatorSyntaxError(f"Expression contains unrecognized characters: '{expression}'")
      return tokens
47 
  def _to_rpn(self, tokens: List[str]) -> List[str]:
      """Converts infix tokens to Reverse Polish Notation (RPN) via Shunting-Yard."""
      output_queue: List[str] = []
      op_stack: List[str] = []
52 
      for token in tokens:
          if re.match(r"^\d+(?:\.\d+)?$", token):
              output_queue.append(token)
          elif token.upper() in self.variables:
              output_queue.append(str(self.variables[token.upper()]))
          elif token in self.OPERATORS:
              prec, left_assoc = self.OPERATORS[token]
              while (
                  op_stack
                  and op_stack[-1] in self.OPERATORS
                  and (
                      (left_assoc and prec <= self.OPERATORS[op_stack[-1]][0])
                      or (not left_assoc and prec < self.OPERATORS[op_stack[-1]][0])
                  )
              ):
                  output_queue.append(op_stack.pop())
              op_stack.append(token)
          elif token == "(":
              op_stack.append(token)
          elif token == ")":
              while op_stack and op_stack[-1] != "(":
                  output_queue.append(op_stack.pop())
              if not op_stack or op_stack[-1] != "(":
                  raise CalculatorSyntaxError("Mismatched parentheses detected.")
              op_stack.pop()  # Pop "("
          else:
              raise CalculatorSyntaxError(f"Undefined identifier or variable: '{token}'")
80 
      while op_stack:
          op = op_stack.pop()
          if op in ("(", ")"):
              raise CalculatorSyntaxError("Mismatched parentheses detected.")
          output_queue.append(op)
86 
      return output_queue
88 
  def evaluate(self, expression: str) -> float:
      """Evaluates an infix mathematical expression string to a floating point number."""
      if not expression or not expression.strip():
          raise CalculatorSyntaxError("Cannot evaluate empty expression.")
93 
      tokens = self.tokenize(expression)
      rpn_queue = self._to_rpn(tokens)
      stack: List[float] = []
97 
      for token in rpn_queue:
          if token in self.OPERATORS:
              if len(stack) < 2:
                  raise CalculatorSyntaxError("Malformed expression: insufficient operands.")
              b = stack.pop()
              a = stack.pop()
104 
              if token == "+": stack.append(a + b)
              elif token == "-": stack.append(a - b)
              elif token == "*": stack.append(a * b)
              elif token == "/":
                  if b == 0:
                      raise MathEvaluationError("Division by zero encountered.")
                  stack.append(a / b)
              elif token == "^":
                  stack.append(a ** b)
          else:
              stack.append(float(token))
116 
      if len(stack) != 1:
          raise CalculatorSyntaxError("Malformed expression: extraneous operands.")
      return stack[0]

3. Comprehensive Pytest Test Suite

1import math
2import pytest
3 
4# Fixture providing a standard calculator instance
5@pytest.fixture
6def calc() -> ExpressionCalculator:
7    return ExpressionCalculator(variables={"X": 10.0, "Y": 2.5})
8 
9# 1. Parametrized Arithmetic Tests
10@pytest.mark.parametrize("expr, expected", [
11    ("2 + 3", 5.0),
12    ("10 - 4", 6.0),
13    ("3 * 7", 21.0),
14    ("15 / 3", 5.0),
15    ("2 ^ 3", 8.0),
16    ("2 ^ 3 ^ 2", 512.0),           # Right-associativity test: 2^(3^2) = 2^9 = 512
17    ("2 + 3 * 4", 14.0),            # Precedence: multiplication before addition
18    ("(2 + 3) * 4", 20.0),          # Parentheses precedence
19    ("((10 - 2) * (3 + 1)) / 4", 8.0),
20])
21def test_standard_arithmetic(calc: ExpressionCalculator, expr: str, expected: float) -> None:
22    assert calc.evaluate(expr) == pytest.approx(expected)
23 
24# 2. Variable and Constant Interpolation Tests
25@pytest.mark.parametrize("expr, expected", [
26    ("X + 5", 15.0),
27    ("X * Y", 25.0),
28    ("PI * 2", math.pi * 2),
29    ("(X - Y) * 2", 15.0),
30])
31def test_variables_and_constants(calc: ExpressionCalculator, expr: str, expected: float) -> None:
32    assert calc.evaluate(expr) == pytest.approx(expected)
33 
34# 3. Exception & Error Boundary Tests
35def test_division_by_zero(calc: ExpressionCalculator):
36    with pytest.raises(MathEvaluationError) as exc_info:
37        calc.evaluate("10 / 0")
38    assert "Division by zero" in str(exc_info.value)
39 
40def test_mismatched_parentheses(calc: ExpressionCalculator):
41    with pytest.raises(CalculatorSyntaxError):
42        calc.evaluate("(10 + 5 * 2")  # Unclosed parenthesis
43 
44def test_unrecognized_characters(calc: ExpressionCalculator):
45    with pytest.raises(CalculatorSyntaxError):
46        calc.evaluate("10 + $5")  # Illegal character $
47 
48def test_empty_expression(calc: ExpressionCalculator):
49    with pytest.raises(CalculatorSyntaxError):
50        calc.evaluate("   ")

4. Verification Execution

1def run_verification():
  print("=====================================================")
  print("      TESTING EXPRESSION CALCULATOR ENGINE           ")
  print("=====================================================")
5 
  calc = ExpressionCalculator(variables={"tax_rate": 0.15, "subtotal": 200.0})
7 
  expressions = [
      "10 + 2 * 6",
      "(10 + 2) * 6",
      "2 ^ 3 ^ 2",
      "subtotal * (1 + tax_rate)",
      "PI * 10 ^ 2"
  ]
15 
  for expr in expressions:
      res = calc.evaluate(expr)
      print(f"Expression: {expr:<26} => Result: {res:.4f}")
19 
  print("=====================================================")
  print("       ALL ENGINE FORMULAS EVALUATED CLEANLY         ")
  print("=====================================================")
23 
24if __name__ == "__main__":
  run_verification()

5. Architectural Key Takeaways

1
Precedence via Shunting-Yard: Parsing infix into RPN cleanly decouples syntax parsing from evaluation mechanics while honoring operator associativity.
2
Parametrized Validation Matrix: Using @pytest.mark.parametrize allows testing dozens of arithmetic expressions with zero repetitive code.
3
Domain Exception Boundaries: Distinguishing CalculatorSyntaxError from MathEvaluationError allows callers to differentiate between user typos and runtime mathematical exceptions.

⚠️ Common Advanced Mistakes & Gotchas

1. Missing Boundary Edge Cases

Failing to test division by zero, negative exponents, overflow numbers, and empty expression strings leaves catastrophic crash paths unverified.

2. Incomplete Fixture Cleanup

Ensure test database instances and temporary test files are destroyed after test suites complete using fixture finalizers or yield fixtures.

💻 Try It Yourself: Extension Challenge - Division by Zero Test Coverage

Challenge

Add automated test cases validating that the Calculator application raises a custom MathDomainError whenever division by zero is attempted.

Complete Solution

1class MathDomainError(Exception):
2    pass
3 
4def safe_divide(a: float, b: float) -> float:
5    if b == 0:
6        raise MathDomainError("Cannot divide by zero!")
7    return a / b
8 
9# Unit test assertion
10try:
11    safe_divide(100, 0)
12except MathDomainError as e:
13    print(f"✓ Test passed: {e}")

Expected Output

1✓ Test passed: Cannot divide by zero!

Interactive Quiz• Knowledge Check

Practice Quiz

1.

What algorithm is utilized by the ExpressionCalculator to convert human-readable infix notation into Reverse Polish Notation (RPN)? A. Dijkstra's Shunting-Yard Algorithm B. Prim's Minimum Spanning Tree Algorithm C. A* Pathfinding Algorithm D. QuickSort Algorithm

Answer: A

Explanation:The Shunting-Yard algorithm (developed by Edsger Dijkstra) uses an operator stack to convert infix expressions into postfix / Reverse Polish Notation (RPN) based on operator precedence and associativity.

2.

Why is the exponentiation operator ^ marked with right-associativity (left_assoc = False) in the calculator? A. Because mathematical convention dictates that $2^{3^2}$ evaluates as $2^{(3^2)} = 2^9 = 512$ rather than $(2^3)^2 = 8^2 = 64$. B. Python does not support left-to-right math. C. Right-associative operators run faster on 64-bit CPUs. D. To prevent division by zero.

Answer: A

Explanation:Exponentiation is mathematically right-associative: chained powers are evaluated from right to left ($a^{b^c} = a^{(b^c)}$).

3.

What Pytest feature allows testing multiple expression-and-result combinations inside a single test function definition? A. @pytest.fixture B. @pytest.mark.parametrize C. pytest.raises D. pytest.approx

Answer: B

Explanation:@pytest.mark.parametrize enables declarative data-driven testing by running the same test function across an array of parameters.

4.

Why is pytest.approx(expected) used when asserting floating-point arithmetic results in Pytest? A. It rounds all numbers to the nearest integer. B. It accounts for minor binary floating-point representation inaccuracies (e.g. 0.1 + 0.2 == 0.30000000000000004), preventing false test failures. C. It converts floats to strings. D. It disables test timeouts.

Answer: B

Explanation:Standard floating-point arithmetic in computers introduces tiny binary representation errors. pytest.approx compares floating-point numbers within a relative tolerance.

5.

What exception type is raised by our calculator when an expression contains an unclosed parenthesis like "(10 + 2"? A. ZeroDivisionError B. CalculatorSyntaxError C. IndexError D. KeyError

Answer: B

Explanation:An unclosed opening parenthesis is detected during Shunting-Yard parsing, triggering a CalculatorSyntaxError("Mismatched parentheses detected.").

🚀 What's Next?

In the next lesson, we will continue your advanced Python journey with Tkinter Basics (14: GUI Development with Tkinter).

👉 Continue to Next Lesson: Tkinter Basics →

Next Lesson

Tkinter Basics

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Test-Driven Development	Tkinter Basics

Practice Quiz

Test your understanding of this lesson with 5 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

Tkinter Basics

Project: Tested Calculator Application in Python

Advanced9 min read•Updated: 2026-10-01

Study Materials Cheatsheet

Project: Fully Tested Mathematical Expression Engine

1. Calculator Engine Architecture

Infix Expression: "10 + 2 * (5 - 1)"
               │
               ▼
       Lexical Tokenizer
['10', '+', '2', '*', '(', '5', '-', '1', ')']
               │
               ▼
    Shunting-Yard Parser (Operator Precedence Stack)
               │
               ▼
Reverse Polish Notation (RPN): ['10', '2', '5', '1', '-', '*', '+']
               │
               ▼
         Stack Evaluator ──► Result: 18.0

2. Production Engine Implementation

1import math
2import re
3from typing import Dict, List, Optional, Union
4 
5class CalculatorSyntaxError(ValueError):
  """Raised when an expression contains invalid tokens or mismatched parentheses."""
  pass
8 
9class MathEvaluationError(ZeroDivisionError):
  """Raised when a mathematical operation is undefined (e.g. division by zero)."""
  pass
12 
13class ExpressionCalculator:
  """A thread-safe mathematical expression evaluator supporting precedence and variables."""
15 
  # Operator precedence and associativity (True = left-associative, False = right)
  OPERATORS = {
      "+": (1, True),
      "-": (1, True),
      "*": (2, True),
      "/": (2, True),
      "^": (3, False),  # Exponentiation is right-associative
  }
24 
  CONSTANTS = {
      "PI": math.pi,
      "E": math.e
  }
29 
  def __init__(self, variables: Optional[Dict[str, float]] = None) -> None:
      self.variables = self.CONSTANTS.copy()
      if variables:
          self.variables.update(variables)
34 
  def tokenize(self, expression: str) -> List[str]:
      """Converts raw string into a list of mathematical tokens."""
      # Match numbers, operators, parentheses, or variable words
      token_pattern = re.compile(r"\d+(?:\.\d+)?|[a-zA-Z_]\w*|[+\-*/^()]")
      tokens = token_pattern.findall(expression)
      
      # Verify no illegal characters were ignored
      reconstructed = "".join(tokens)
      stripped_expr = re.sub(r"\s+", "", expression)
      if len(reconstructed) != len(stripped_expr):
          raise CalculatorSyntaxError(f"Expression contains unrecognized characters: '{expression}'")
      return tokens
47 
  def _to_rpn(self, tokens: List[str]) -> List[str]:
      """Converts infix tokens to Reverse Polish Notation (RPN) via Shunting-Yard."""
      output_queue: List[str] = []
      op_stack: List[str] = []
52 
      for token in tokens:
          if re.match(r"^\d+(?:\.\d+)?$", token):
              output_queue.append(token)
          elif token.upper() in self.variables:
              output_queue.append(str(self.variables[token.upper()]))
          elif token in self.OPERATORS:
              prec, left_assoc = self.OPERATORS[token]
              while (
                  op_stack
                  and op_stack[-1] in self.OPERATORS
                  and (
                      (left_assoc and prec <= self.OPERATORS[op_stack[-1]][0])
                      or (not left_assoc and prec < self.OPERATORS[op_stack[-1]][0])
                  )
              ):
                  output_queue.append(op_stack.pop())
              op_stack.append(token)
          elif token == "(":
              op_stack.append(token)
          elif token == ")":
              while op_stack and op_stack[-1] != "(":
                  output_queue.append(op_stack.pop())
              if not op_stack or op_stack[-1] != "(":
                  raise CalculatorSyntaxError("Mismatched parentheses detected.")
              op_stack.pop()  # Pop "("
          else:
              raise CalculatorSyntaxError(f"Undefined identifier or variable: '{token}'")
80 
      while op_stack:
          op = op_stack.pop()
          if op in ("(", ")"):
              raise CalculatorSyntaxError("Mismatched parentheses detected.")
          output_queue.append(op)
86 
      return output_queue
88 
  def evaluate(self, expression: str) -> float:
      """Evaluates an infix mathematical expression string to a floating point number."""
      if not expression or not expression.strip():
          raise CalculatorSyntaxError("Cannot evaluate empty expression.")
93 
      tokens = self.tokenize(expression)
      rpn_queue = self._to_rpn(tokens)
      stack: List[float] = []
97 
      for token in rpn_queue:
          if token in self.OPERATORS:
              if len(stack) < 2:
                  raise CalculatorSyntaxError("Malformed expression: insufficient operands.")
              b = stack.pop()
              a = stack.pop()
104 
              if token == "+": stack.append(a + b)
              elif token == "-": stack.append(a - b)
              elif token == "*": stack.append(a * b)
              elif token == "/":
                  if b == 0:
                      raise MathEvaluationError("Division by zero encountered.")
                  stack.append(a / b)
              elif token == "^":
                  stack.append(a ** b)
          else:
              stack.append(float(token))
116 
      if len(stack) != 1:
          raise CalculatorSyntaxError("Malformed expression: extraneous operands.")
      return stack[0]

3. Comprehensive Pytest Test Suite

1import math
2import pytest
3 
4# Fixture providing a standard calculator instance
5@pytest.fixture
6def calc() -> ExpressionCalculator:
7    return ExpressionCalculator(variables={"X": 10.0, "Y": 2.5})
8 
9# 1. Parametrized Arithmetic Tests
10@pytest.mark.parametrize("expr, expected", [
11    ("2 + 3", 5.0),
12    ("10 - 4", 6.0),
13    ("3 * 7", 21.0),
14    ("15 / 3", 5.0),
15    ("2 ^ 3", 8.0),
16    ("2 ^ 3 ^ 2", 512.0),           # Right-associativity test: 2^(3^2) = 2^9 = 512
17    ("2 + 3 * 4", 14.0),            # Precedence: multiplication before addition
18    ("(2 + 3) * 4", 20.0),          # Parentheses precedence
19    ("((10 - 2) * (3 + 1)) / 4", 8.0),
20])
21def test_standard_arithmetic(calc: ExpressionCalculator, expr: str, expected: float) -> None:
22    assert calc.evaluate(expr) == pytest.approx(expected)
23 
24# 2. Variable and Constant Interpolation Tests
25@pytest.mark.parametrize("expr, expected", [
26    ("X + 5", 15.0),
27    ("X * Y", 25.0),
28    ("PI * 2", math.pi * 2),
29    ("(X - Y) * 2", 15.0),
30])
31def test_variables_and_constants(calc: ExpressionCalculator, expr: str, expected: float) -> None:
32    assert calc.evaluate(expr) == pytest.approx(expected)
33 
34# 3. Exception & Error Boundary Tests
35def test_division_by_zero(calc: ExpressionCalculator):
36    with pytest.raises(MathEvaluationError) as exc_info:
37        calc.evaluate("10 / 0")
38    assert "Division by zero" in str(exc_info.value)
39 
40def test_mismatched_parentheses(calc: ExpressionCalculator):
41    with pytest.raises(CalculatorSyntaxError):
42        calc.evaluate("(10 + 5 * 2")  # Unclosed parenthesis
43 
44def test_unrecognized_characters(calc: ExpressionCalculator):
45    with pytest.raises(CalculatorSyntaxError):
46        calc.evaluate("10 + $5")  # Illegal character $
47 
48def test_empty_expression(calc: ExpressionCalculator):
49    with pytest.raises(CalculatorSyntaxError):
50        calc.evaluate("   ")

4. Verification Execution

1def run_verification():
  print("=====================================================")
  print("      TESTING EXPRESSION CALCULATOR ENGINE           ")
  print("=====================================================")
5 
  calc = ExpressionCalculator(variables={"tax_rate": 0.15, "subtotal": 200.0})
7 
  expressions = [
      "10 + 2 * 6",
      "(10 + 2) * 6",
      "2 ^ 3 ^ 2",
      "subtotal * (1 + tax_rate)",
      "PI * 10 ^ 2"
  ]
15 
  for expr in expressions:
      res = calc.evaluate(expr)
      print(f"Expression: {expr:<26} => Result: {res:.4f}")
19 
  print("=====================================================")
  print("       ALL ENGINE FORMULAS EVALUATED CLEANLY         ")
  print("=====================================================")
23 
24if __name__ == "__main__":
  run_verification()

5. Architectural Key Takeaways

1
Precedence via Shunting-Yard: Parsing infix into RPN cleanly decouples syntax parsing from evaluation mechanics while honoring operator associativity.
2
Parametrized Validation Matrix: Using @pytest.mark.parametrize allows testing dozens of arithmetic expressions with zero repetitive code.
3
Domain Exception Boundaries: Distinguishing CalculatorSyntaxError from MathEvaluationError allows callers to differentiate between user typos and runtime mathematical exceptions.

⚠️ Common Advanced Mistakes & Gotchas

1. Missing Boundary Edge Cases

Failing to test division by zero, negative exponents, overflow numbers, and empty expression strings leaves catastrophic crash paths unverified.

2. Incomplete Fixture Cleanup

Ensure test database instances and temporary test files are destroyed after test suites complete using fixture finalizers or yield fixtures.

💻 Try It Yourself: Extension Challenge - Division by Zero Test Coverage

Challenge

Add automated test cases validating that the Calculator application raises a custom MathDomainError whenever division by zero is attempted.

Complete Solution

1class MathDomainError(Exception):
2    pass
3 
4def safe_divide(a: float, b: float) -> float:
5    if b == 0:
6        raise MathDomainError("Cannot divide by zero!")
7    return a / b
8 
9# Unit test assertion
10try:
11    safe_divide(100, 0)
12except MathDomainError as e:
13    print(f"✓ Test passed: {e}")

Expected Output

1✓ Test passed: Cannot divide by zero!

Interactive Quiz• Knowledge Check

Practice Quiz

1.

Answer: A

2.

Answer: A

Explanation:Exponentiation is mathematically right-associative: chained powers are evaluated from right to left ($a^{b^c} = a^{(b^c)}$).

3.

Answer: B

Explanation:@pytest.mark.parametrize enables declarative data-driven testing by running the same test function across an array of parameters.

4.

Answer: B

Explanation:Standard floating-point arithmetic in computers introduces tiny binary representation errors. pytest.approx compares floating-point numbers within a relative tolerance.

5.

What exception type is raised by our calculator when an expression contains an unclosed parenthesis like "(10 + 2"? A. ZeroDivisionError B. CalculatorSyntaxError C. IndexError D. KeyError

Answer: B

Explanation:An unclosed opening parenthesis is detected during Shunting-Yard parsing, triggering a CalculatorSyntaxError("Mismatched parentheses detected.").

🚀 What's Next?

In the next lesson, we will continue your advanced Python journey with Tkinter Basics (14: GUI Development with Tkinter).

👉 Continue to Next Lesson: Tkinter Basics →

Next Lesson

Tkinter Basics

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Test-Driven Development	Tkinter Basics

Practice Quiz

Test your understanding of this lesson with 5 questions. Each question has one correct answer.

Previous Next