how to make a calculator 10

I have a solid calculator from chapters 1–8 and a Flask website from chapter 9. Now I want to make it beautiful and ridiculously easy to use by turning it into a modern web app with Streamlit.

Streamlit lets me build professional-looking web apps with almost no extra code.

preview

These are the tests I have by the end of the chapter

import unittest

import streamlit as st


class TestCalculatorStreamlit(unittest.TestCase):

    def test_streamlit_can_be_imported(self):
        """Make sure Streamlit is installed and importable"""
        self.assertIsNotNone(st)

    def test_streamlit_calculator_app(self):
        """The main function in our Streamlit app exists and is callable"""
        from src.streamlit_app import main
        self.assertTrue(callable(main))

    def test_calculator_error_messages_still_work(self):
        """Our original calculator error messages are still working"""
        import src.calculator

        self.assertEqual(
            src.calculator.divide(10, 0),
            'brmph?! I cannot divide by 0. Try again...'
        )

        self.assertEqual(
            src.calculator.add(None, 5),
            'brmph?! Numbers only. Try again...'
        )

        self.assertEqual(
            src.calculator.multiply('hello', 3),
            'brmph?! Numbers only. Try again...'
        )


# Exceptions seen
# (none new - we reuse everything from chapters 1-8)

open the project

I change directory to the calculator folder
```
cd calculator
```
I install Streamlit
```
uv add streamlit
```
I use pytest-watcher to run the tests
```
uv run pytest-watcher . --now
```
I create a new test file for the Streamlit version
```
touch tests/test_calculator_streamlit.py
```

test_streamlit_installed

RED: make it fail

I open tests/test_calculator_streamlit.py and write

import unittest
import streamlit as st

class TestCalculatorStreamlit(unittest.TestCase):

    def test_streamlit_can_be_imported(self):
        self.assertIsNotNone(st)

the terminal shows ModuleNotFoundError

GREEN: make it pass

I already ran uv add streamlit, so the test passes.

test_streamlit_calculator_app

RED: make it fail

I add a test for the app itself

    def test_streamlit_can_be_imported(self):
        ...

    def test_streamlit_calculator_app(self):
        from src.streamlit_app import main
        self.assertTrue(callable(main))

the terminal shows ModuleNotFoundError

GREEN: make it pass

I create the file
```
touch src/streamlit_app.py
```

I open it and add the basic app

import streamlit as st
import src.calculator as calc

def main():
    st.title("🧮 My TDD Calculator")
    st.write("Built step-by-step with Test-Driven Development!")

if __name__ == "__main__":
    main()

The test passes.

REFACTOR: make it better

Now I build the full interactive calculator.

I update the test to also check core behavior (we already know it works from earlier chapters, but it feels good to see it here).

I expand src/streamlit_app.py:

  def main():
      st.title("🧮 My TDD Calculator")
      st.write("Built step-by-step with Test-Driven Development!")

      col1, col2, col3 = st.columns([3, 1, 3])

      with col1:
          first = st.number_input("First number", value=0.0, step=0.1)

      with col2:
          operation = st.selectbox(
              "Operation",
              ["+", "-", "×", "÷"]
          )

      with col3:
          second = st.number_input("Second number", value=0.0, step=0.1)

      if st.button("Calculate", type="primary"):
          try:
              ops = {
                  "+": calc.add,
                  "-": calc.subtract,
                  "×": calc.multiply,
                  "÷": calc.divide
              }
              result = ops[operation](first, second)
              st.success(f"**Result:** {result}")

          except ZeroDivisionError:
              st.error("brmph?! I cannot divide by 0. Try again...")
          except Exception:
              st.error("brmph?! Numbers only. Try again...")

      # Bonus: show history
      if "history" not in st.session_state:
          st.session_state.history = []

      if st.button("Clear history"):
          st.session_state.history = []

      if st.session_state.history:
          st.subheader("Recent calculations")
          for item in reversed(st.session_state.history[-5:]):
              st.write(item)

  if __name__ == "__main__":
      main()

The app now looks and works beautifully.

test_error_messages_in_streamlit

RED: make it fail

I add

    def test_error_messages_in_streamlit(self):
        self.assertEqual(
            src.calculator.divide(10, 0),
            'brmph?! I cannot divide by 0. Try again...'
        )

the test already passes (thanks to chapters 3–4).

how to run the app

In the terminal I type:

uv run streamlit run src/streamlit_app.py

A browser window opens automatically with my beautiful calculator!

close the project

I close all files
I click in the terminal, then use q to leave the tests
I change directory to the parent
```
cd ..
```

review

I now have three different versions of the same calculator:

Pure Python (chapters 1–8)
Flask website (chapter 9)
Streamlit web app (chapter 10) — the fastest and most beautiful version

The core calculator code never changed. All my tests still protect it. This is the real power of Test-Driven Development.

code from the chapter

Do you want to see all the CODE I typed in this chapter?

what is next?

You have completed an amazing journey from pure functions to real web applications!

You now know how to:

Build programs with Test-Driven Development
Turn them into Flask websites
Turn them into beautiful Streamlit apps

rate pumping python

If this has been a 7 star experience for you, please CLICK HERE to leave a 5 star review of pumping python. It helps other people get into the book too