Compound interest is a **powerful concept in finance**, representing the process where interest is added to the principal, so that from that moment on, the interest that has been added also earns interest. This effect can significantly increase savings or investments over time, making it a key tool for understanding **personal finance, loans, and investments**. The formula to calculate compound interest is:

`A = P * (1 + r/n)^(n*t)`

where `A` is the final amount, `P` is the principal (initial amount), `r` is the annual interest rate (as a decimal), `n` is the number of times the interest is compounded per year, and `t` is the number of years. Knowing how to compute this in Python allows you to model real-world scenarios, such as projecting the growth of a savings account or investment.

# Simple compound interest calculation using annual compounding only
# Formula: A = P * (1 + r) ** t

def simple_annual_compound(principal, rate, years):
    return principal * (1 + rate) ** years

# Example usage:
final_amount = simple_annual_compound(1000, 0.05, 5)
print(final_amount)  # Output: 1276.2815625000003


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_correct_final_amount(self):
        import user_code
        importlib.reload(user_code)
        fn = getattr(user_code, 'calculate_compound_interest', None)
        _dynamic_test(
            self,
            callable(fn),
            "Function calculate_compound_interest is defined",
            "Function calculate_compound_interest is not defined"
        )
        result = fn(1500, 0.043, 4, 6) if fn else None
        expected = 1500 * (1 + 0.043 / 4) ** (4 * 6)
        _dynamic_test(
            self,
            result is not None and abs(result - expected) < 1e-6,
            "Returns correct final amount for standard input",
            f"Expected {expected}, got {result}"
        )

    def test_zero_years_returns_principal(self):
        import user_code
        importlib.reload(user_code)
        fn = getattr(user_code, 'calculate_compound_interest', None)
        _dynamic_test(
            self,
            callable(fn),
            "Function calculate_compound_interest is defined",
            "Function calculate_compound_interest is not defined"
        )
        principal = 2000
        result = fn(principal, 0.05, 4, 0) if fn else None
        _dynamic_test(
            self,
            result is not None and abs(result - principal) < 1e-6,
            "Returns principal when years is zero",
            f"Expected {principal}, got {result}"
        )

    def test_single_compounding(self):
        import user_code
        importlib.reload(user_code)
        fn = getattr(user_code, 'calculate_compound_interest', None)
        _dynamic_test(
            self,
            callable(fn),
            "Function calculate_compound_interest is defined",
            "Function calculate_compound_interest is not defined"
        )
        result = fn(1000, 0.10, 1, 2) if fn else None
        expected = 1000 * (1 + 0.10/1) ** (1*2)
        _dynamic_test(
            self,
            result is not None and abs(result - expected) < 1e-6,
            "Correct result for single compounding per year",
            f"Expected {expected}, got {result}"
        )

    def test_fractional_rate_and_times(self):
        import user_code
        importlib.reload(user_code)
        fn = getattr(user_code, 'calculate_compound_interest', None)
        _dynamic_test(
            self,
            callable(fn),
            "Function calculate_compound_interest is defined",
            "Function calculate_compound_interest is not defined"
        )
        result = fn(500, 0.0275, 2.5, 3) if fn else None
        expected = 500 * (1 + 0.0275 / 2.5) ** (2.5 * 3)
        _dynamic_test(
            self,
            result is not None and abs(result - expected) < 1e-6,
            "Works for fractional rates and times compounded",
            f"Expected {expected}, got {result}"
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

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


test_main.py

A practical course designed for math students to harness the power of Python for solving mathematical problems, visualizing data, and applying computational thinking to real-world scenarios. Each section blends engaging theory with hands-on challenges, focusing on mathematical applications and problem-solving. 

Explore how Python can be used to perform numerical calculations, solve algebraic equations, and automate mathematical processes.

Learn how to visualize mathematical data and functions using Python, and apply these skills to real-world mathematical problems.

Apply Python to probability, statistics, and simulation, enabling students to model uncertainty and analyze data in mathematical contexts.

Challenge: Calculate Compound Interest

Lösung