When you need to compare companies or evaluate their financial health, calculating financial ratios such as **Price-to-Earnings (P/E)**, **Return on Equity (ROE)**, and **Debt-to-Equity** is essential. Automating these calculations for multiple companies saves time and reduces errors. Python allows you to process structured financial data efficiently, even when some data points are missing. By handling incomplete data gracefully, you ensure your analysis remains robust and useful.


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

class TestTask(unittest.TestCase):
    def test_returns_dict_structure(self):
        import user_code
        importlib.reload(user_code)
        companies = [
            {"name": "TestCo", "price": 10, "earnings": 2, "net_income": 4, "equity": 8, "debt": 2}
        ]
        result = user_code.calculate_financial_ratios(companies)
        _dynamic_test(
            self,
            isinstance(result, dict) and "TestCo" in result and isinstance(result["TestCo"], dict),
            "Function returns dictionary per company.",
            f"Expected dictionary with company name as key, got {result}.",
        )

    def test_pe_ratio_calculation(self):
        import user_code
        importlib.reload(user_code)
        companies = [
            {"name": "PECo", "price": 50, "earnings": 10, "net_income": 1, "equity": 2, "debt": 3}
        ]
        result = user_code.calculate_financial_ratios(companies)
        pe = result["PECo"].get("P/E") if result and "PECo" in result else None
        _dynamic_test(
            self,
            pe == 5.0,
            "P/E ratio correctly calculated.",
            f"Expected P/E 5.0, got {pe}.",
        )

    def test_pe_ratio_zero_or_missing(self):
        import user_code
        importlib.reload(user_code)
        companies = [
            {"name": "ZeroEarnings", "price": 30, "earnings": 0},
            {"name": "MissingEarnings", "price": 30}
        ]
        result = user_code.calculate_financial_ratios(companies)
        pe_zero = result["ZeroEarnings"].get("P/E") if result and "ZeroEarnings" in result else None
        pe_missing = result["MissingEarnings"].get("P/E") if result and "MissingEarnings" in result else None
        _dynamic_test(
            self,
            pe_zero is None and pe_missing is None,
            "P/E ratio is None for zero or missing earnings.",
            f"Expected None for zero/missing earnings, got {pe_zero}, {pe_missing}.",
        )

    def test_roe_calculation(self):
        import user_code
        importlib.reload(user_code)
        companies = [
            {"name": "ROECo", "net_income": 10, "equity": 5}
        ]
        result = user_code.calculate_financial_ratios(companies)
        roe = result["ROECo"].get("ROE") if result and "ROECo" in result else None
        _dynamic_test(
            self,
            roe == 2.0,
            "ROE correctly calculated.",
            f"Expected ROE 2.0, got {roe}.",
        )

    def test_roe_missing_or_zero(self):
        import user_code
        importlib.reload(user_code)
        companies = [
            {"name": "ZeroEquity", "net_income": 10, "equity": 0},
            {"name": "MissingNetIncome", "equity": 10},
            {"name": "MissingEquity", "net_income": 10}
        ]
        result = user_code.calculate_financial_ratios(companies)
        roe_zero = result["ZeroEquity"].get("ROE") if result and "ZeroEquity" in result else None
        roe_missing_income = result["MissingNetIncome"].get("ROE") if result and "MissingNetIncome" in result else None
        roe_missing_equity = result["MissingEquity"].get("ROE") if result and "MissingEquity" in result else None
        _dynamic_test(
            self,
            roe_zero is None and roe_missing_income is None and roe_missing_equity is None,
            "ROE is None for zero/missing equity or net income.",
            f"Expected None for zero/missing equity/net_income, got {roe_zero}, {roe_missing_income}, {roe_missing_equity}.",
        )

    def test_debt_to_equity_calculation(self):
        import user_code
        importlib.reload(user_code)
        companies = [
            {"name": "DebtCo", "debt": 25, "equity": 5}
        ]
        result = user_code.calculate_financial_ratios(companies)
        dte = result["DebtCo"].get("Debt-to-Equity") if result and "DebtCo" in result else None
        _dynamic_test(
            self,
            dte == 5.0,
            "Debt-to-Equity ratio correctly calculated.",
            f"Expected Debt-to-Equity 5.0, got {dte}.",
        )

    def test_debt_to_equity_missing_or_zero(self):
        import user_code
        importlib.reload(user_code)
        companies = [
            {"name": "ZeroEquity", "debt": 10, "equity": 0},
            {"name": "MissingDebt", "equity": 10},
            {"name": "MissingEquity", "debt": 10}
        ]
        result = user_code.calculate_financial_ratios(companies)
        dte_zero = result["ZeroEquity"].get("Debt-to-Equity") if result and "ZeroEquity" in result else None
        dte_missing_debt = result["MissingDebt"].get("Debt-to-Equity") if result and "MissingDebt" in result else None
        dte_missing_equity = result["MissingEquity"].get("Debt-to-Equity") if result and "MissingEquity" in result else None
        _dynamic_test(
            self,
            dte_zero is None and dte_missing_debt is None and dte_missing_equity is None,
            "Debt-to-Equity is None for zero/missing equity or debt.",
            f"Expected None for zero/missing equity/debt, got {dte_zero}, {dte_missing_debt}, {dte_missing_equity}.",
        )

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

Explore how Python empowers FinTech solutions by automating financial analysis, modeling, and data-driven decision making. This course blends practical coding with real-world finance scenarios, guiding you through essential FinTech concepts and hands-on challenges.

Learn to analyze, manipulate, and visualize financial data using Python, focusing on core FinTech data workflows.

Apply Python to assess financial risk and optimize investment portfolios using statistical and mathematical techniques.

Apply machine learning techniques to financial data for prediction, classification, and decision support in FinTech applications.

Challenge: Financial Ratio Calculator

解答