题目要求：

python代码实现如下：

# -*- coding: utf-8 -*-
"""
Python 作业：利润表函数设计与类的应用

题目要求对应关系：
1. 函数设计：
   - 编写计算主营业务利润、营业利润、净利润等指标的函数；
   - 实现利润表各项目之间勾稽关系校验的函数。
2. 类的应用：
   - 设计利润表类 ProfitStatement，包含数据属性和方法；
   - 实现类的初始化方法，能加载利润表原始数据；
   - 封装利润表自动生成、数据更新、指标计算等方法。

说明：题目给出的原始数据只有“收入、办公费、差旅费、招待费、预算”。
因此本程序默认将：
- 办公费 视为 管理费用；
- 差旅费 + 招待费 视为 销售费用；
- 主营业务成本、税金及附加、财务费用等在原始数据缺失时默认为 0；
- 所得税率默认为 25%，但只有利润总额大于 0 时才计算所得税。

如果后续数据中包含“主营业务成本”“税金及附加”“财务费用”等字段，程序也可以自动读取并参与计算。
"""

from __future__ import annotations

import csv
from copy import deepcopy
from typing import Dict, List, Any, Tuple


Number = float
FinanceRow = Dict[str, Any]


# ============================================================
# 一、函数设计部分
# ============================================================

def to_number(value: Any, default: Number = 0.0) -> Number:
    """将输入值安全转换为数字；无法转换时返回默认值。"""
    try:
        return float(value)
    except (TypeError, ValueError):
        return default


def calc_main_business_profit(
    revenue: Number,
    main_business_cost: Number = 0.0,
    tax_and_surcharge: Number = 0.0,
) -> Number:
    """
    计算主营业务利润。

    主营业务利润 = 主营业务收入 - 主营业务成本 - 税金及附加
    """
    return revenue - main_business_cost - tax_and_surcharge


def calc_operating_profit(
    main_business_profit: Number,
    selling_expense: Number = 0.0,
    management_expense: Number = 0.0,
    financial_expense: Number = 0.0,
    other_business_profit: Number = 0.0,
    investment_income: Number = 0.0,
) -> Number:
    """
    计算营业利润。

    简化公式：
    营业利润 = 主营业务利润 + 其他业务利润 + 投资收益
             - 销售费用 - 管理费用 - 财务费用
    """
    return (
        main_business_profit
        + other_business_profit
        + investment_income
        - selling_expense
        - management_expense
        - financial_expense
    )


def calc_total_profit(
    operating_profit: Number,
    non_operating_income: Number = 0.0,
    non_operating_expense: Number = 0.0,
) -> Number:
    """
    计算利润总额。

    利润总额 = 营业利润 + 营业外收入 - 营业外支出
    """
    return operating_profit + non_operating_income - non_operating_expense


def calc_net_profit(total_profit: Number, income_tax_expense: Number = 0.0) -> Number:
    """
    计算净利润。

    净利润 = 利润总额 - 所得税费用
    """
    return total_profit - income_tax_expense


def check_profit_relations(statement: FinanceRow, tolerance: Number = 1e-6) -> Tuple[bool, List[str]]:
    """
    校验利润表主要项目之间的勾稽关系。

    返回：
    - True/False：是否全部通过；
    - messages：校验说明。
    """
    messages: List[str] = []

    department = statement.get("部门", "未知部门")

    revenue = to_number(statement.get("收入"))
    main_business_cost = to_number(statement.get("主营业务成本"))
    tax_and_surcharge = to_number(statement.get("税金及附加"))
    selling_expense = to_number(statement.get("销售费用"))
    management_expense = to_number(statement.get("管理费用"))
    financial_expense = to_number(statement.get("财务费用"))
    other_business_profit = to_number(statement.get("其他业务利润"))
    investment_income = to_number(statement.get("投资收益"))
    non_operating_income = to_number(statement.get("营业外收入"))
    non_operating_expense = to_number(statement.get("营业外支出"))
    income_tax_expense = to_number(statement.get("所得税费用"))

    expected_main_profit = calc_main_business_profit(
        revenue, main_business_cost, tax_and_surcharge
    )
    expected_operating_profit = calc_operating_profit(
        expected_main_profit,
        selling_expense,
        management_expense,
        financial_expense,
        other_business_profit,
        investment_income,
    )
    expected_total_profit = calc_total_profit(
        expected_operating_profit, non_operating_income, non_operating_expense
    )
    expected_net_profit = calc_net_profit(expected_total_profit, income_tax_expense)

    checks = [
        ("主营业务利润", expected_main_profit),
        ("营业利润", expected_operating_profit),
        ("利润总额", expected_total_profit),
        ("净利润", expected_net_profit),
    ]

    passed = True
    for key, expected_value in checks:
        actual_value = to_number(statement.get(key))
        if abs(actual_value - expected_value) <= tolerance:
            messages.append(f"[{department}] {key} 勾稽关系校验通过。")
        else:
            passed = False
            messages.append(
                f"[{department}] {key} 勾稽关系校验失败："
                f"表中数值={actual_value:.2f}，按公式计算={expected_value:.2f}。"
            )

    return passed, messages


# ============================================================
# 二、类的应用部分
# ============================================================

class ProfitStatement:
    """利润表类：负责加载数据、生成利润表、更新数据、计算指标和校验勾稽关系。"""

    def __init__(
        self,
        raw_data: List[FinanceRow],
        income_tax_rate: Number = 0.25,
        default_main_business_cost_rate: Number = 0.0,
        default_tax_and_surcharge_rate: Number = 0.0,
    ) -> None:
        """
        初始化利润表对象。

        参数：
        - raw_data：原始财务数据，格式为“列表嵌套字典”；
        - income_tax_rate：所得税率，默认 25%；
        - default_main_business_cost_rate：当原始数据没有主营业务成本时，按收入估算成本的比例；
        - default_tax_and_surcharge_rate：当原始数据没有税金及附加时，按收入估算税金及附加的比例。
        """
        self.raw_data = deepcopy(raw_data)
        self.income_tax_rate = income_tax_rate
        self.default_main_business_cost_rate = default_main_business_cost_rate
        self.default_tax_and_surcharge_rate = default_tax_and_surcharge_rate
        self.statement_data: List[FinanceRow] = []

    def update_data(self, department: str, **kwargs: Any) -> None:
        """
        更新某个部门的原始数据；若部门不存在，则新增一条记录。

        示例：
        ps.update_data("销售部", 收入=100000, 办公费=9000)
        """
        for row in self.raw_data:
            if row.get("部门") == department:
                row.update(kwargs)
                return

        new_row: FinanceRow = {"部门": department}
        new_row.update(kwargs)
        self.raw_data.append(new_row)

    def _build_one_statement(self, row: FinanceRow) -> FinanceRow:
        """根据单个部门原始数据生成单个部门利润表。"""
        department = row.get("部门", "未知部门")

        revenue = to_number(row.get("收入"))
        budget = to_number(row.get("预算"))

        office_expense = to_number(row.get("办公费"))
        travel_expense = to_number(row.get("差旅费"))
        entertainment_expense = to_number(row.get("招待费"))

        # 题目数据没有给出销售费用、管理费用、财务费用等标准项目，
        # 这里按照常见管理口径做简化映射。
        selling_expense = to_number(row.get("销售费用"), travel_expense + entertainment_expense)
        management_expense = to_number(row.get("管理费用"), office_expense)
        financial_expense = to_number(row.get("财务费用"), 0.0)

        main_business_cost = to_number(
            row.get("主营业务成本"),
            revenue * self.default_main_business_cost_rate,
        )
        tax_and_surcharge = to_number(
            row.get("税金及附加"),
            revenue * self.default_tax_and_surcharge_rate,
        )
        other_business_profit = to_number(row.get("其他业务利润"), 0.0)
        investment_income = to_number(row.get("投资收益"), 0.0)
        non_operating_income = to_number(row.get("营业外收入"), 0.0)
        non_operating_expense = to_number(row.get("营业外支出"), 0.0)

        main_profit = calc_main_business_profit(
            revenue, main_business_cost, tax_and_surcharge
        )
        operating_profit = calc_operating_profit(
            main_profit,
            selling_expense,
            management_expense,
            financial_expense,
            other_business_profit,
            investment_income,
        )
        total_profit = calc_total_profit(
            operating_profit, non_operating_income, non_operating_expense
        )

        # 若利润总额为负，通常不计所得税费用；这里按简化口径处理。
        income_tax_expense = max(total_profit, 0.0) * self.income_tax_rate
        net_profit = calc_net_profit(total_profit, income_tax_expense)

        total_expense = office_expense + travel_expense + entertainment_expense
        budget_difference = budget - total_expense
        budget_usage_rate = total_expense / budget if budget else 0.0
        net_profit_margin = net_profit / revenue if revenue else 0.0

        return {
            "部门": department,
            "收入": revenue,
            "预算": budget,
            "办公费": office_expense,
            "差旅费": travel_expense,
            "招待费": entertainment_expense,
            "费用合计": total_expense,
            "预算差异": budget_difference,
            "预算使用率": budget_usage_rate,
            "主营业务成本": main_business_cost,
            "税金及附加": tax_and_surcharge,
            "主营业务利润": main_profit,
            "销售费用": selling_expense,
            "管理费用": management_expense,
            "财务费用": financial_expense,
            "其他业务利润": other_business_profit,
            "投资收益": investment_income,
            "营业利润": operating_profit,
            "营业外收入": non_operating_income,
            "营业外支出": non_operating_expense,
            "利润总额": total_profit,
            "所得税费用": income_tax_expense,
            "净利润": net_profit,
            "净利率": net_profit_margin,
        }

    def generate_statement(self) -> List[FinanceRow]:
        """自动生成各部门利润表。"""
        self.statement_data = [self._build_one_statement(row) for row in self.raw_data]
        return self.statement_data

    def calculate_summary(self) -> FinanceRow:
        """计算企业整体汇总指标。"""
        if not self.statement_data:
            self.generate_statement()

        numeric_keys = [
            "收入", "预算", "办公费", "差旅费", "招待费", "费用合计", "预算差异",
            "主营业务成本", "税金及附加", "主营业务利润", "销售费用", "管理费用",
            "财务费用", "其他业务利润", "投资收益", "营业利润", "营业外收入",
            "营业外支出", "利润总额", "所得税费用", "净利润",
        ]

        summary: FinanceRow = {"部门": "合计"}
        for key in numeric_keys:
            summary[key] = sum(to_number(row.get(key)) for row in self.statement_data)

        summary["预算使用率"] = (
            summary["费用合计"] / summary["预算"] if summary["预算"] else 0.0
        )
        summary["净利率"] = summary["净利润"] / summary["收入"] if summary["收入"] else 0.0
        return summary

    def check_all_relations(self) -> Tuple[bool, List[str]]:
        """校验全部部门利润表的勾稽关系。"""
        if not self.statement_data:
            self.generate_statement()

        all_passed = True
        all_messages: List[str] = []
        for statement in self.statement_data:
            passed, messages = check_profit_relations(statement)
            all_passed = all_passed and passed
            all_messages.extend(messages)

        summary = self.calculate_summary()
        passed, messages = check_profit_relations(summary)
        all_passed = all_passed and passed
        all_messages.extend(messages)

        return all_passed, all_messages

    def print_statement(self) -> None:
        """在控制台打印利润表主要结果。"""
        if not self.statement_data:
            self.generate_statement()

        rows = self.statement_data + [self.calculate_summary()]
        columns = [
            "部门", "收入", "费用合计", "预算", "预算差异", "主营业务利润",
            "营业利润", "所得税费用", "净利润", "净利率",
        ]

        print_table(rows, columns)

    def export_csv(self, file_path: str) -> None:
        """将利润表结果导出为 CSV 文件。"""
        if not self.statement_data:
            self.generate_statement()

        rows = self.statement_data + [self.calculate_summary()]
        if not rows:
            return

        fieldnames = list(rows[0].keys())
        with open(file_path, "w", newline="", encoding="utf-8-sig") as f:
            writer = csv.DictWriter(f, fieldnames=fieldnames)
            writer.writeheader()
            writer.writerows(rows)


# ============================================================
# 三、辅助输出函数
# ============================================================

def format_value(value: Any) -> str:
    """格式化输出数值，使打印表格更清晰。"""
    if isinstance(value, float):
        return f"{value:.2%}" if -1 <= value <= 1 and value != 0 else f"{value:.2f}"
    return str(value)


def print_table(rows: List[FinanceRow], columns: List[str]) -> None:
    """使用纯 Python 打印简单表格，不依赖第三方库。"""
    table = []
    table.append(columns)

    for row in rows:
        table.append([format_value(row.get(col, "")) for col in columns])

    widths = [max(len(str(line[i])) for line in table) for i in range(len(columns))]

    def print_line(items: List[Any]) -> None:
        print(" | ".join(str(item).ljust(widths[i]) for i, item in enumerate(items)))

    print_line(table[0])
    print("-+-".join("-" * w for w in widths))
    for line in table[1:]:
        print_line(line)


# ============================================================
# 四、主程序：使用题目给出的模拟企业月度财务数据
# ============================================================

if __name__ == "__main__":
    # 模拟企业月度财务数据（列表嵌套字典）
    company_finance_data = [
        {"部门": "销售部", "办公费": 8000, "差旅费": 12000, "招待费": 6000, "收入": 90000, "预算": 25000},
        {"部门": "财务部", "办公费": 3000, "差旅费": 2000, "招待费": 1000, "收入": 12000, "预算": 8000},
        {"部门": "人力资源部", "办公费": 4000, "差旅费": 3000, "招待费": 2000, "收入": 10000, "预算": 10000},
    ]

    # 创建利润表对象
    profit_statement = ProfitStatement(
        company_finance_data,
        income_tax_rate=0.25,
        default_main_business_cost_rate=0.0,
        default_tax_and_surcharge_rate=0.0,
    )

    # 生成利润表
    profit_statement.generate_statement()

    print("\n========== 企业月度利润表 ==========")
    profit_statement.print_statement()

    # 校验勾稽关系
    print("\n========== 利润表勾稽关系校验 ==========")
    passed, check_messages = profit_statement.check_all_relations()
    for message in check_messages:
        print(message)
    print(f"\n最终校验结果：{'全部通过' if passed else '存在错误'}")

    # 演示数据更新功能
    print("\n========== 数据更新示例：将销售部收入更新为 100000 ==========")
    profit_statement.update_data("销售部", 收入=100000)
    profit_statement.generate_statement()
    profit_statement.print_statement()

    # 导出 CSV 文件
    csv_path = "profit_statement_result.csv"
    profit_statement.export_csv(csv_path)
    print(f"\n利润表结果已导出：{csv_path}")