ITECH5104: Fundamentals of Programming

Assignment 2 Mortgage Calculator

Overview

In this assignment you will have the opportunity to test your Python skills in developing classes and using matplotlib library. Throughout the assignment you are expected to apply the principles of problem solving that we have already discussed in this course.

Learning Outcomes Assessed

The following course learning outcomes are assessed by completing this assessment:

Knowledge:

• K1. Identify and use the correct syntax of a common programming language.
• K2. Recall and use typical programming constructs to design and implement simple software solutions.
• K3. Reproduce and adapt commonly used basic algorithms.
• K4. Explain the importance of programming style concepts (documentation, mnemonic names, indentation).

Skills:

• S2. Write and implement a solution algorithm using basic programming constructs.
• S3. Demonstrate debugging and testing skills whilst writing code.

Application of knowledge and skills:

• A1. Develop self-reliance and judgement in adapting algorithms to diverse contexts.
• A2. Design and write program solutions to identified problems using accepted design constructs.

Assessment Details

Introduction

Your assignment is to write a Python program that takes inputs for the Loan Amount, Loan Term and Interest Rate and then calculates and displays values of Weekly (Fortnightly, Monthly) Repayments. Also, the program plots the values of Remaining Principal by years.

Programming Tasks

Task 1.1 Develop a Mortgage class

The class should have the following attributes (instance variables):

• loan – for the loan amount in AUD.
• years – loan term in years.
• interest – interest rate.
• r_frequency – repayment frequency in days.

These attributes should be defined in the constructor, _init_ . Also, the class should define the following methods:

• repayments(self) – calculates the value of repayments using the formula provided in the introduction (for P0) and returns the calculated value.
• balance_after(self,n) – calculates the remaining balance (debt) after n years using the formula provided in the introduction (for Bn) and returns the calculated value.

Task 1.2 Write a main() function

This should be your main program that:

• Prompts and takes inputs for the loan amount, loan term, interest rate and repayment frequency. 
• Creates a Mortgage object using the entered values. 
• Using the Mortgage object’s methods, prints the mortgage information on screen and, and if required, plots the mortgage balances by years.

You are required to use exception handling to make your program robust (foolproof) i.e., if the user enters an incorrect value, the program won’t crash, but instead it will prompt the user to enter a correct value. Use the following constraints for the correct inputs:

• loan – must be a positive float value.
• years – must be a positive int value.
• interest – must be a positive float value.
• r_frequency – must be one of the following values: 7, 14, or 30.

Assessment Requirements  Brief Summary

Assignment Objective:
The assignment aimed to test students’ ability to apply Python programming skills to develop a mortgage calculator that computes repayments and tracks remaining loan balances over time. Students were expected to use object-oriented programming, handle exceptions, and generate visual outputs using the matplotlib library.

Key Pointers to Cover:

1. Mortgage Class Development (Task 1.1)
   • Attributes: loan, years, interest, r_frequency
   • Methods:
     • repayments(self) – Calculate repayment amount based on input parameters
     • balance_after(self, n)– Calculate remaining principal after n years

2. Main Program Function (Task 1.2)

   • Prompt user inputs for loan amount, loan term, interest rate, and repayment frequency
   • Create a Mortgage object
   • Print mortgage details and plot remaining balances over the years
   • Implement exception handling for input validation:
     • Loan: positive float
     • Years: positive integer
     • Interest: positive float
     • Repayment frequency: 7, 14, or 30

Learning Outcomes Assessed:

• Knowledge of Python syntax and programming constructs (K1-K4)
• Practical coding skills, algorithm implementation, debugging, and testing (S2-S3)
• Application of knowledge to develop problem-solving solutions (A1-A2)

Step-by-Step Approach by the Academic Mentor

1. Understanding the Assignment:

   The mentor first reviewed the requirements and clarified the expected outputs – repayment calculations, remaining balance computations, and visual representation.

2. Designing the Class Structure:

   • Guided the student to define the Mortgage class with proper constructor and instance variables.
   • Emphasized code readability, use of mnemonic names, and proper documentation.

3. Implementing Methods:

   • repayments(self) method: Mentor walked through the repayment formula and helped implement it in Python.
   • balance_after(self, n) method: Mentor explained how to calculate remaining principal after n years, integrating it into the class for reuse.

4. Developing the Main Function:

   • Mentor instructed the student to collect user inputs and validate them using exception handling to prevent crashes.
   • Demonstrated how to instantiate the Mortgage class and call its methods to display outputs.
   • Guided the student on using matplotlib to plot remaining balances over the loan period.

5. Testing and Debugging:

   • The student was guided through multiple test cases with valid and invalid inputs to ensure robustness.
   • Mentor reviewed edge cases such as zero or negative values and incorrect repayment frequency entries.

6. Final Review and Output:

   • Mentor ensured that the outputs were correct and aligned with assignment requirements.
   • Checked for proper formatting, readability, and code commenting.

Outcome Achieved

• Functional Mortgage Calculator: Program accurately computes weekly, fortnightly, and monthly repayments and visualizes remaining balances over the loan term.
• Robustness: Exception handling ensures that the program prompts for correct inputs rather than crashing.
• Code Quality: Clear, well-documented Python code following good programming style.
• Learning Objectives Covered:
  • Applied object-oriented programming concepts (K1, S2)
  • Developed algorithmic thinking and debugging skills (S3, A2)
  • Built a self-reliant, functional software solution (A1)
  • Integrated data visualization with matplotlib

Access Your Assignment Reference Today or Get a Fresh, Custom Solution

Looking for guidance on your assignment? You can download our sample solution to understand how a well-structured answer looks and how to approach similar questions.

Remember: this sample is for reference only—submitting it as your own work may lead to plagiarism issues.

If you want a solution that’s fully original, tailored to your requirements, and 100% plagiarism-free, our team of professional academic writers can craft a fresh assignment just for you. Ordering a custom solution ensures:

• Plagiarism-free content written specifically for your topic
• Accurate, well-researched answers aligned with your assessment criteria
• Clear, professional presentation ready for submission
• Time-saving convenience and reduced stress

Take control of your grades and avoid plagiarism risks with confidence!

Choose your option below:

Download Sample Solution               Order Fresh Assignment