Python Closure

In these days of high inflation and high interest rates, I am sharing if you a simple Python Closure to calculate compound interest. According to Wikipedia, "a closure, also lexical closure or function closure, is a technique for implementing lexically scoped name binding in a language with first-class functions". Closure is an elegant style that takes the global namespace of your code clean. It behaves like a class/object instantiation, but in a much simpler way. I will use the class/object language to refer to the closure itself and its elements always in quotes, even if I know that it is not syntactically correct, just for the sake of ease of understanding.

Compound Interest

Our closure will calculate the compound interest for an initial value (principal) during a period of time and a fixed interest rate that you can set, based on the market conditions.

To create a closure the following criterias have to be met:

  • Outer function and an inner function (nested functions).
  • The inner function refers to some variable from the enclosing function.
  • The outer function returns the inner function.

Find the criterias in the code below.

The closure behaves like a simple class, where you "instantiate" an "object" which points to the inner function returned by the closure.
You can "instantiate" any "objects" as you want, and the "objects" will hold the "instance variables".

Our closure has a parameter that receives the principal invested value as an argument. We "instantiate" two "objects" with different principal values.
Now we call the "instances" with the inner function arguments and each "instance" will remember the enclosing function principal value and calculate the values.
For this first version of the closure, the inner function receives arguments for interest rate and the invested period in years. 

def compound_interest(principal):
    def calculate(interest_rate=None, years_invested=None):
        if not interest_rate or not years_invested:
            raise ValueError("Missing arguments")

        interest_rate /=  1200
        months_invested = years_invested * 12
        total = principal * (1 + interest_rate) ** months_invested
        return total
    return calculate

compound_interest_10k = compound_interest(10000)
print(compound_interest_10k(interest_rate=6, years_invested=10))
print(compound_interest_10k(interest_rate=5, years_invested=10))

compound_interest_50k = compound_interest(50000)
print(compound_interest_50k(interest_rate=6, years_invested=10))
print(compound_interest_50k(interest_rate=5, years_invested=10))


  Output:
  ------
  18193.9673403229
  16470.0949769028
  90969.8367016145
  82350.474884514

From here on, we will only add one more feature to calculate the compound interest, and we will also enrich the code with some Python best practices, and tests.

Add monthly deposits

Now the inner function of the closure will accept regular deposits and increse the total value.

The enclosing function is the same, only the inner function receives a new argument for the monthly deposits parameter, and sums it up to the principal value.

We are also using function type hints and enforcing the named parameters with the use of the * character before the keyword arguments.

def compound_interest(principal):
    def calculate(*, monthly_deposit: float=None, interest_rate: float=None, years_invested: float=None) -> str:
        if not interest_rate or not years_invested:
            raise ValueError("Missing arguments")

        interest_rate /=  1200
        months_invested = years_invested * 12

        total = principal * (1 + interest_rate) ** months_invested
        if monthly_deposit:
            total += monthly_deposit * ((((1 + interest_rate) ** months_invested) -1) / interest_rate)
        return round(total, 2)
    return calculate


compound_interest_10k = compound_interest(10000)
print(compound_interest_10k(monthly_deposit=1000, interest_rate=6, years_invested=10))
print(compound_interest_10k(monthly_deposit=500, interest_rate=5, years_invested=10))

compound_interest_50k = compound_interest(50000)
print(compound_interest_50k(monthly_deposit=1000, interest_rate=6, years_invested=10))
print(compound_interest_50k(monthly_deposit=500, interest_rate=5, years_invested=10))


  Output:
  ------
  182073.31
  94111.23
  254849.18
  159991.61

First class function

To take advantage of the Python first class function, we will add a feature to generate an output report using a function callback.
We create the function "output_format_cb", which is passed as one of the default kwargs of the inner function of our closure. This callback function can be overriden, or you can create another function to generate report as you need. 

from typing import Callable

def output_format_cb(principal: float, total_monthly_deposit: float, interest_rate: float,
                     years_invested: float,total: float) -> str:
    report = """
                Pricipal:                      ${:0,.2f}
                Total Deposits:                ${:0,.2f}
                Interest Rate:                 {}%
                Years Invested:                {} Years
                Total:                         ${:0,.2f}
            """
    report = report.format(principal, total_monthly_deposit, interest_rate, years_invested, total)
    return report

def compound_interest(principal: float) -> Callable[[float, float, float, float], str]:
    def calculate(*, monthly_deposit: float=None,
                            interest_rate: float=None,
                            years_invested: float=None,
                            format: Callable[[float, float, float, float, float], str]=output_format_cb) -> str:
        if not interest_rate or not years_invested:
            raise ValueError("Missing arguments")

        interest_rate /=  1200
        months_invested = years_invested * 12

        total = principal * (1 + interest_rate) ** months_invested
        if monthly_deposit:
            total += monthly_deposit * ((((1 + interest_rate) ** months_invested) -1) / interest_rate)

        return format(principal, monthly_deposit * months_invested, interest_rate * 1200, years_invested, round(total, 2))
    return calculate


compound_interest_10k = compound_interest(10000)
print(compound_interest_10k(monthly_deposit=1000, interest_rate=6, years_invested=10))
print(compound_interest_10k(monthly_deposit=500, interest_rate=5, years_invested=10))

compound_interest_50k = compound_interest(50000)
print(compound_interest_50k(monthly_deposit=1000, interest_rate=6, years_invested=10))
print(compound_interest_50k(monthly_deposit=500, interest_rate=5, years_invested=10))


  Output:
  ------
                Pricipal:                      $10,000.00
                Total Deposits:                $120,000.00
                Interest Rate:                 6.0%
                Years Invested:                10 Years
                Total:                         $182,073.31            

                Pricipal:                      $10,000.00
                Total Deposits:                $60,000.00
                Interest Rate:                 5.0%
                Years Invested:                10 Years
                Total:                         $94,111.23            

                Pricipal:                      $50,000.00
                Total Deposits:                $120,000.00
                Interest Rate:                 6.0%
                Years Invested:                10 Years
                Total:                         $254,849.18            

                Pricipal:                      $50,000.00
                Total Deposits:                $60,000.00
                Interest Rate:                 5.0%
                Years Invested:                10 Years
                Total:                         $159,991.61

Add some tests

Some simple tests for the calculate function, before output formating. 

def compound_interest(principal):
    def calculate(*, monthly_deposit: float=None, interest_rate: float=None, years_invested: float=None) -> str:
        if not interest_rate or not years_invested:
            raise ValueError("Missing arguments")

        interest_rate /=  1200
        months_invested = years_invested * 12

        total = principal * (1 + interest_rate) ** months_invested
        if monthly_deposit:
            total += monthly_deposit * ((((1 + interest_rate) ** months_invested) -1) / interest_rate)
        return round(total, 2)
    return calculate


import unittest
class TestCompoundInterest(unittest.TestCase):
    def setUp(self) -> None:
        self.compound_interest_10k = compound_interest(10000)
        self.compound_interest_50k = compound_interest(50000)

    def test_compound_interest_10k(self):
        self.assertEqual(self.compound_interest_10k(monthly_deposit=1000, interest_rate=6, years_invested=10),
                         182073.31)
        self.assertEqual(self.compound_interest_10k(monthly_deposit=500, interest_rate=5, years_invested=10),
                         94111.23)

    def test_compound_interest_50k(self):
        self.assertEqual(self.compound_interest_50k(monthly_deposit=1000, interest_rate=6, years_invested=10),
                         254849.18)
        self.assertEqual(self.compound_interest_50k(monthly_deposit=500, interest_rate=5, years_invested=10),
                         159991.61)


if __name__ == '__main__':
    unittest.main()



  Output:
  ------
  
  ..
  ----------------------------------------------------------------------


  Ran 2 tests in 0.000s

  OK

Popular posts from this blog

Atom - Jupyter / Hydrogen

Image
I will show you how to use the Atom editor with Jupyter Notebook to debug Python/Django views using Hydrogen plugin. On the Internet you can find some examples using this setup to debug Python but I found nothing related to Django, so I decided to publish this notes. This is not a high performance setup, because it involves many technologies at several layers. This is more a proof of concept of nowadays technologies which are available to the programmer's toolbox. This notes has been written during the development and improvement of the automated tests of the Virtual Library of FAPESP ( http://www.bv.fapesp.br ). The environment The diagram below shows an actual infrastructure to use this setup in a development environment. Technologies It is not expected that you know all of the technologies in detail, but there are some trick points. This paper is oriented for Python programmer who already use Atom and Jupyter and enjoy explore the edges of these tools. ...
Read more

Metodologias em ação

Image
O objetivo desse artigo é apresentar algumas metodologias atuais relacionadas à TI, na perspectiva das suas aplicações dentro de uma empresa. A estrutura de cada empresa pode variar muito, dessa maneira irei adotar uma estrutura clássica em formato de pirâmide, representada na figura abaixo para efeitos da nossa análise. As metodologias apresentadas, dificilmente serão utilizadas exatamente como estão sendo estudadas aqui pois não é comum a necessidade de utilizá-las em uma empresa todas ao mesmo tempo, apesar de ser possível. Isso dependerá do tipo de empresa, da estrutura que a mesma possui e como a empresa aplica a TI nos seus negócios. Também será feita uma breve análise do relacionamento entre as diversas metodologias quando adotadas em conjunto. A pirâmide representa a hierarquia em uma empresa tradicional, com o board of directors ficando no topo, abaixo a gerência senior com os CEO, CIO, CSO, CFO etc, abaixo a gerência operacional e abaixo os departamentos operacionais. Qual o ...
Read more

Design Patterns - Observer

Design Patterns - Observer A simple Python code example to illustrate the Observer Pattern for an ETL-like scenario. The "Extract Microservice" observes changes in a data source and notifies its registered observers (data extractors) to perform data extraction. We'll use a basic Publisher-Subscriber pattern to demonstrate the concept of the Observer Pattern. Observer interface class Observer: def update(self, data): pass Extract Microservice (Subject) class ExtractMicroservice: def __init__(self): self.observers = [] def register_observer(self, observer): self.observers.append(observer) def unregister_observer(self, observer): self.observers.remove(observer) def notify_observers(self, data): for observer in self.observers: observer.update(data) def start_extraction(self): # Simulate data extraction process data = ["Data 1", "Data 2", "Data 3",...
Read more