利用8个参数定义一个汽轮机，然后根据这8个参数生成汽轮机性能试验时的测点清单-pycharm-源代码（适用所有类型汽轮机）

#通过一个字典定义一个汽轮机
import pandas as pd
from CoolProp.CoolProp import PropsSI
from collections import defaultdict
from datetime import datetime
class Turbine:
    def __init__(self, params):
        # 初始化汽轮机的属性
        self.Zr = params.get("汽轮机再热次数")
        self.CN = params.get("汽轮机缸体个数")
        self.is_combined = params.get("汽轮机是否合缸")
        self.HP = params.get("高加个数")
        self.LP = params.get("低加个数")
        self.NCG=params.get("超高压缸抽汽级数")
        self.NG = params.get("高压缸抽汽级数")
        self.NZ = params.get("中压缸抽汽级数")
        self.NL = params.get("低压缸抽汽级数")

    def __str__(self):
        return (f"Turbine:\\n"
                f"再热次数: {self.Zr}\\n"
                f"缸体个数: {self.CN}\\n"
                f"是否合缸: {'是' if self.is_combined else '否'}\\n"
                f"高加个数: {self.HP}\\n"
                f"低加个数: {self.LP}\\n"
                f"超高压缸抽汽级数:{self.NCG}\\n"
                f"高压缸抽汽级数: {self.NG}\\n"
                f"中压缸抽汽级数: {self.NZ}\\n"
                f"低压缸抽汽级数: {self.NL}")



# 示例字典
turbine_data = {
    "汽轮机再热次数": 1,
    "汽轮机缸体个数": 3,
    "汽轮机是否合缸": True,  # 可以是 True 或 False
    "高加个数": 3,
    "低加个数": 4,
    "超高压缸抽汽级数":0,
    "高压缸抽汽级数": 2,
    "中压缸抽汽级数": 2,
    "低压缸抽汽级数": 4,
}

# 创建Turbine实例
turbine = Turbine(turbine_data)

# 打印Turbine的属性
#print(turbine)




class Point:
    def __init__(self, pressure, temperature, flow_rate=None):
        self.pressure = pressure*1000000  # 压力 (MPa)
        self.temperature = temperature+273.15  # 温度 (℃)
        self.flow_rate = flow_rate  # 流量 (t/h)，可选

    def calculate_enthalpy(self):
        # 根据压力和温度计算焓值 kJ/kg
        return PropsSI('H', 'P', self.pressure, 'T', self.temperature, 'Water')/1000

    def calculate_entropy(self):
        # 根据压力和温度计算熵值  kJ/kg.℃
        return PropsSI('S', 'P', self.pressure, 'T', self.temperature, 'Water')/1000

    def calculate_dryness_fraction(self):
        # 根据压力和温度计算干度
        P_sat = PropsSI('P', 'T', self.temperature, 'Q', 1, 'Water')
        # 计算干度（湿度）
        if P_sat > 0:
            quality = 0.91
        else:
            quality = None  # 饱和压力为0的情况，无法计算干度
        #print("干度为：",quality)
        return quality

# 初始化字典用于存储输入数据
qufu_1_measurementpoint = {}

class TurbineCylinder:
    def __init__(self, inlet: Point, outlet: Point):
        self.inlet = inlet  # 进口工质状态点
        self.outlet = outlet  # 出口工质状态点

    def calculate_efficiency(self):
        # 计算出口等熵焓
        outlet_isenthalpic_enthalpy = PropsSI('H', 'P', self.outlet.pressure, 'S', self.inlet.calculate_entropy()*1000,'Water')/1000

        #print(outlet_isenthalpic_enthalpy)
        # 根据公式计算汽轮机缸体内效率
        efficiency = 100*(self.inlet.calculate_enthalpy() - self.outlet.calculate_enthalpy()) /(self.inlet.calculate_enthalpy() - outlet_isenthalpic_enthalpy)


        return efficiency

class LowPressureTurbineCylinder(TurbineCylinder):
    def calculate_efficiency(self):
        # 计算进口蒸汽的焓
        inlet_enthalpy = self.inlet.calculate_enthalpy()

        # 计算出口蒸汽的焓
        outlet_enthalpy = self.outlet.calculate_enthalpy()

        # 计算出口蒸汽的干度
        dryness_fraction = self.outlet.calculate_dryness_fraction()

        # 计算出口等熵焓
        outlet_isenthalpic_enthalpy = PropsSI(
            'H', 'P', self.outlet.pressure, 'S', self.inlet.calculate_entropy() * 1000, 'Water'
        ) / 1000
        #print("出口等熵焓",outlet_isenthalpic_enthalpy)
        # 计算低压缸的缸效率
        efficiency = 100 * (inlet_enthalpy - outlet_enthalpy * dryness_fraction) / (
                    inlet_enthalpy - outlet_isenthalpic_enthalpy)

        return efficiency










class Heater:
    def __init__(self, n, water_inlet: Point, water_outlet: Point,
                 steam_inlet: Point, steam_drain: Point,
                 n_minus_1_steam_drain: Point, N3):
        self.n = n  # 加热器编号
        self.water_inlet = water_inlet  # 水侧进口
        self.water_outlet = water_outlet  # 水侧出口

        self.steam_inlet = steam_inlet  # 汽侧进口
        self.steam_drain = steam_drain  # 汽侧疏水
        self.n_minus_1_steam_drain = n_minus_1_steam_drain  # n-1级加热器汽侧疏水
        self.N3 = N3  # 参考的N3

    def is_first_heater(self):
        # 判断是否为首级加热器
        return self.n == 1 or self.n == self.N3 + 1+1



    def upper_difference(self):
        # 加热器上端差
        saturation_temp = PropsSI('T', 'P', self.steam_inlet.pressure, 'Q', 1, 'Water')
        return saturation_temp - self.water_outlet.temperature

    def lower_difference(self):
        # 加热器下端差
        return self.steam_drain.temperature - self.water_inlet.temperature

    def temperature_rise(self):
        # 加热器温升
        return self.water_outlet.temperature - self.water_inlet.temperature


class Pump:
    def __init__(self, inlet: Point, outlet1: Point, outlet2=None):
        self.inlet = inlet  # 水泵入口
        self.outlet1 = outlet1  # 水泵出口1
        self.outlet2 = outlet2  # 水泵出口2（可选）

    def calculate_enthalpy_rise(self):
        # 水泵焓升计算
        return (self.outlet1.calculate_enthalpy() - self.inlet.calculate_enthalpy())

    def calculate_efficiency(self, power_input, flow_rate):
        # 水泵效率计算
        # 效率 = 输出功 / 输入功
        # 输出功 = 焓升 * 流量
        # 输入功 = 电机功率
        enthalpy_rise = self.calculate_enthalpy_rise()
        output_power = enthalpy_rise * flow_rate/3.6
        return output_power / power_input*100 if power_input > 0 else 0

"""
以曲阜热电厂1号机为例，进行演示

"""

# 以曲阜热电厂1号机为实例进行实例演示，三缸合缸机组
if __name__ == "__main__":
    turbine_params = {
        "汽轮机再热次数": 1,
        "汽轮机缸体个数": 3,
        "高加个数": 3,
        "低加个数": 4,
        "汽轮机是否合缸": True,
        "超高压缸抽汽级数":0,
        "高压缸抽汽级数": 2,
        "中压缸抽汽级数": 2,
        "低压缸抽汽级数": 4

    }

qufu_1_turbine = Turbine(turbine_params)

#1 缸体参数
Case_inlet={}
Case_outlet={}
qufu_case={}
for i in range(1,qufu_1_turbine.CN+1):
    Case_inlet[i]=Point(
        pressure=float(input(f"请输入{i}号缸体进口压力，单位MPa:")),
        temperature=float(input(f"请输入{i}号缸体进口温度，单位℃:"))
    )
    Case_outlet[i]=Point(
        pressure=float(input(f"请输入{i}号缸体出口压力，单位MPa:")),
        temperature=float(input(f"请输入{i}号缸体出口温度，单位℃:"))
    )
    qufu_case[i]=TurbineCylinder(Case_inlet[i], Case_outlet[i])
    # 将数据存入字典
    qufu_1_measurementpoint[f"{i}号缸体进口压力"] = Case_inlet[i].pressure
    qufu_1_measurementpoint[f"{i}号缸体进口温度"] = Case_inlet[i].temperature
    qufu_1_measurementpoint[f"{i}号缸体出口压力"] = Case_outlet[i].pressure
    qufu_1_measurementpoint[f"{i}号缸体出口温度"] = Case_outlet[i].temperature



    if i==qufu_1_turbine.CN:
        qufu_case[3]=LowPressureTurbineCylinder(Case_inlet[i], Case_outlet[i])



# print(f"曲阜热电厂1号机高压缸的效率为{qufu_case[1].calculate_efficiency()}%")
# print(f"曲阜热电厂1号机中压缸的效率为{qufu_case[2].calculate_efficiency()}%")
# print(f"曲阜热电厂1号机低压缸的效率为{qufu_case[3].calculate_efficiency()}%")
#2抽汽
Extraction={}
for i in range(1,qufu_1_turbine.NCG+qufu_1_turbine.NG+qufu_1_turbine.NZ+qufu_1_turbine.NL+1):
    Extraction[i]=Point(
        pressure=float(input(f"请输入{i}段抽汽压力，单位MPa: ")),
        temperature=float(input(f"请输入{i}段抽汽温度，单位℃: "))
    )
    qufu_1_measurementpoint[f"{i}段抽汽压力"] = Extraction[i].pressure
    qufu_1_measurementpoint[f"{i}段抽汽温度"] = Extraction[i].temperature






from collections import defaultdict

# 初始化字典
HP_water_inlet = {}
HP_water_outlet = {}
HP_steam_inlet = {}
HP_steam_drain = defaultdict(lambda: Point(pressure=0, temperature=0))  # 使用 defaultdict
HP_heater = {}

 #3高压加热器输入数据并初始化加热器
for i in range(1, qufu_1_turbine.HP + 1):
# 输入水侧进口参数
    HP_water_inlet[i] = Point(
        pressure=float(input(f"请输入{i}号高加水侧进口压力，单位MPa: ")),
        temperature=float(input(f"请输入{i}号高加水侧进口温度，单位℃: "))
    )

    # 输入水侧出口参数
    HP_water_outlet[i] = Point(
        pressure=float(input(f"请输入{i}号高加水侧出口压力，单位MPa: ")),
        temperature=float(input(f"请输入{i}号高加水侧出口温度，单位℃: "))
    )

    # 输入汽侧进口参数
    HP_steam_inlet[i] = Point(
        pressure=float(input(f"请输入{i}号高加汽侧进口压力，单位MPa: ")),
        temperature=float(input(f"请输入{i}号高加汽侧进口温度，单位℃: "))
    )

    # 输入汽侧疏水参数
    HP_steam_drain[i] = Point(
        pressure=float(input(f"请输入{i}号高加汽侧疏水压力，单位MPa: ")),
        temperature=float(input(f"请输入{i}号高加汽侧疏水温度，单位℃: "))
    )
    # 将数据存入字典
    qufu_1_measurementpoint[f"{i}号高加水侧进口压力"] = HP_water_inlet[i].pressure
    qufu_1_measurementpoint[f"{i}号高加水侧进口温度"] = HP_water_inlet[i].temperature
    qufu_1_measurementpoint[f"{i}号高加水侧出口压力"] = HP_water_outlet[i].pressure
    qufu_1_measurementpoint[f"{i}号高加水侧出口温度"] = HP_water_outlet[i].temperature
    qufu_1_measurementpoint[f"{i}号高加汽侧进口压力"] = HP_steam_inlet[i].pressure
    qufu_1_measurementpoint[f"{i}号高加汽侧进口温度"] = HP_steam_inlet[i].temperature
    qufu_1_measurementpoint[f"{i}号高加汽侧疏水压力"] = HP_steam_drain[i].pressure
    qufu_1_measurementpoint[f"{i}号高加汽侧疏水温度"] = HP_steam_drain[i].temperature


    # 创建加热器实例
    if i == 1:
        # 首级加热器没有上一级疏水点
        HP_heater[i] = Heater(
            n=i,
            water_inlet=HP_water_inlet[i],
            water_outlet=HP_water_outlet[i],
            steam_inlet=HP_steam_inlet[i],
            steam_drain=HP_steam_drain[i],
            n_minus_1_steam_drain=None,  # 首级加热器没有上一级疏水点
            N3=qufu_1_turbine.HP
        )
    elif i >= 2:
        # 非首级加热器，使用上一级疏水点
        HP_heater[i] = Heater(
            n=i,
            water_inlet=HP_water_inlet[i],
            water_outlet=HP_water_outlet[i],
            steam_inlet=HP_steam_inlet[i],
            steam_drain=HP_steam_drain[i],
            n_minus_1_steam_drain=HP_steam_drain[i - 1],  # 使用上一级疏水点
            N3=qufu_1_turbine.HP
        )

    # print(f"{i}号高加是否为首级加热器:", HP_heater[i].is_first_heater())
    #
    # print(f"{i}号高加上端差:", HP_heater[i].upper_difference(), "K")
    # print(f"{i}号高加下端差:", HP_heater[i].lower_difference(), "K")
    # print(f"{i}号高加温升:", HP_heater[i].temperature_rise(), "K")

# 3低压加热器输入数据并初始化加热器
# 初始化字典
LP_water_inlet = {}
LP_water_outlet = {}
LP_steam_inlet = {}
LP_steam_drain = defaultdict(lambda: Point(pressure=0, temperature=0))  # 使用 defaultdict
LP_heater = {}


for i in range(qufu_1_turbine.HP+2, qufu_1_turbine.HP + 1+qufu_1_turbine.LP+1):
# 输入水侧进口参数
    LP_water_inlet[i] = Point(
        pressure=float(input(f"请输入{i}号低加水侧进口压力，单位MPa: ")),
        temperature=float(input(f"请输入{i}号低加水侧进口温度，单位℃: "))
    )

    # 输入水侧出口参数
    LP_water_outlet[i] = Point(
        pressure=float(input(f"请输入{i}号低加水侧出口压力，单位MPa: ")),
        temperature=float(input(f"请输入{i}号低加水侧出口温度，单位℃: "))
    )
    if i==qufu_1_turbine.HP+2:
        LP_water_outlet[i] = Point(
            pressure=float(input(f"请输入{i}号低加水侧出口压力，单位MPa: ")),
            temperature=float(input(f"请输入{i}号低加水侧出口温度，单位℃: ")),
            flow_rate=float(input(f"请输入{i}号低加水侧出口流量，单位t/h: "))
        )


    # 输入汽侧进口参数
    LP_steam_inlet[i] = Point(
        pressure=float(input(f"请输入{i}号低加汽侧进口压力，单位MPa: ")),
        temperature=float(input(f"请输入{i}号低加汽侧进口温度，单位℃: "))
    )

    # 输入汽侧疏水参数
    LP_steam_drain[i] = Point(
        pressure=float(input(f"请输入{i}号低加汽侧疏水压力，单位MPa: ")),
        temperature=float(input(f"请输入{i}号低加汽侧疏水温度，单位℃: "))
    )

    # 将数据存入字典
    qufu_1_measurementpoint[f"{i}号低加水侧进口压力"] = LP_water_inlet[i].pressure
    qufu_1_measurementpoint[f"{i}号低加水侧进口温度"] = LP_water_inlet[i].temperature
    qufu_1_measurementpoint[f"{i}号低加水侧出口压力"] = LP_water_outlet[i].pressure
    qufu_1_measurementpoint[f"{i}号低加水侧出口温度"] = LP_water_outlet[i].temperature
    qufu_1_measurementpoint[f"{i}号低加汽侧进口压力"] = LP_steam_inlet[i].pressure
    qufu_1_measurementpoint[f"{i}号低加汽侧进口温度"] = LP_steam_inlet[i].temperature
    qufu_1_measurementpoint[f"{i}号低加汽侧疏水压力"] = LP_steam_drain[i].pressure
    qufu_1_measurementpoint[f"{i}号低加汽侧疏水温度"] = LP_steam_drain[i].temperature

    # 创建加热器实例
    if i == qufu_1_turbine.HP+2:
        # 首级加热器没有上一级疏水点
        LP_heater[i] = Heater(
            n=i,
            water_inlet=LP_water_inlet[i],
            water_outlet=LP_water_outlet[i],
            steam_inlet=LP_steam_inlet[i],
            steam_drain=LP_steam_drain[i],
            n_minus_1_steam_drain=None,  # 首级加热器没有上一级疏水点
            N3=qufu_1_turbine.HP
        )
    elif i >= qufu_1_turbine.HP+3:
        # 非首级加热器，使用上一级疏水点
        LP_heater[i] = Heater(
            n=i,
            water_inlet=LP_water_inlet[i],
            water_outlet=LP_water_outlet[i],
            steam_inlet=LP_steam_inlet[i],
            steam_drain=LP_steam_drain[i],
            n_minus_1_steam_drain=LP_steam_drain[i - 1],  # 使用上一级疏水点
            N3=qufu_1_turbine.HP
        )

    # print(f"{i}号低加是否为首级加热器:", LP_heater[i].is_first_heater())
    #
    # print(f"{i}号低加上端差:", LP_heater[i].upper_difference(), "K")
    # print(f"{i}号低加下端差:", LP_heater[i].lower_difference(), "K")
    # print(f"{i}号低加温升:", LP_heater[i].temperature_rise(), "K")

Deae_water_outlet =Point(
    pressure=float(input(f"除氧器出口压力，单位MPa: ")),
    temperature=float(input(f"除氧器出口温度，单位℃: "))

)
Deae_steam_inlet = Point(
    pressure=float(input(f"除氧器进汽压力，单位MPa: ")),
    temperature=float(input(f"除氧器进汽温度，单位℃: "))

)
qufu_1_measurementpoint[f"除氧器出口压力"] = Deae_water_outlet.pressure
qufu_1_measurementpoint[f"除氧器出口温度"] = Deae_water_outlet.temperature
qufu_1_measurementpoint[f"除氧器进汽压力"] = Deae_steam_inlet.pressure
qufu_1_measurementpoint[f"除氧器进汽温度"] = Deae_steam_inlet.temperature

#5除氧器
Deae = Heater(
    n=qufu_1_turbine.HP+1,
    water_inlet=LP_heater[qufu_1_turbine.HP+2].water_outlet,
    water_outlet=Deae_water_outlet,
    steam_inlet=Deae_steam_inlet,
    steam_drain=Deae_water_outlet,
    n_minus_1_steam_drain=HP_heater[qufu_1_turbine.HP].steam_drain,  # 首级加热器没有上一级疏水点
    N3=qufu_1_turbine.HP+2
)






#6凝汽器
Cond_water_inlet = Point(
    pressure=float(input(f"凝汽器水侧循环水进口压力，单位MPa: ")),
    temperature=float(input(f"凝汽器水侧循环水进口温度，单位℃: "))

)

Cond_water_outlet = Point(
    pressure=float(input(f"凝汽器热井出口压力，单位MPa: ")),
    temperature=float(input(f"凝汽器热井出口温度，单位℃: "))

)
qufu_1_measurementpoint[f"凝汽器水侧循环水进口压力"] = Cond_water_inlet.pressure
qufu_1_measurementpoint[f"凝汽器水侧循环水进口温度"] = Cond_water_inlet.temperature
qufu_1_measurementpoint[f"凝汽器热井出口压力"] = Cond_water_outlet.pressure
qufu_1_measurementpoint[f"凝汽器热井出口温度"] = Cond_water_outlet.temperature



Cond = Heater(
    n=qufu_1_turbine.HP + qufu_1_turbine.LP+2,
    water_inlet=Cond_water_inlet,
    water_outlet=Cond_water_outlet,
    steam_inlet=qufu_case[qufu_1_turbine.CN].outlet,
    steam_drain=Cond_water_outlet,
    n_minus_1_steam_drain=None,  # 首级加热器没有上一级疏水点
    N3=qufu_1_turbine.HP + qufu_1_turbine.LP+4
)



#7轴封漏汽
HP_back_gland=Point(
    pressure=float(input(f"高压缸后轴封漏汽压力，单位MPa: ")),
    temperature=float(input(f"高压缸后轴封漏汽温度，单位℃: ")),
    flow_rate=float(input(f"高压缸后轴封漏汽流量，单位t/h: "))
)

qufu_1_measurementpoint[f"高压缸后轴封漏汽压力"] = HP_back_gland.pressure
qufu_1_measurementpoint[f"高压缸后轴封漏汽温度"] = HP_back_gland.temperature
qufu_1_measurementpoint[f"高压缸后轴封漏汽流量"] = HP_back_gland.flow_rate


if qufu_1_turbine.is_combined is False:
    HP_front_gland = Point(
    pressure=float(input(f"高压缸前轴封漏汽压力，单位MPa: ")),
    temperature=float(input(f"高压缸前轴封漏汽温度，单位℃: ")),
    flow_rate=float(input(f"高压缸前轴封漏汽流量，单位t/h: "))
    )
    IP_front_gland = Point(
    pressure=float(input(f"中压缸前轴封漏汽压力，单位MPa: ")),
    temperature=float(input(f"中压缸前轴封漏汽温度，单位℃: ")),
    flow_rate=float(input(f"中压缸前轴封漏汽流量，单位t/h: "))
    )
    qufu_1_measurementpoint[f"高压缸前轴封漏汽压力"] = HP_front_gland.pressure
    qufu_1_measurementpoint[f"高压缸前轴封漏汽温度"] = HP_front_gland.temperature
    qufu_1_measurementpoint[f"高压缸前轴封漏汽流量"] = HP_front_gland.flow_rate
    qufu_1_measurementpoint[f"中压缸前轴封漏汽压力"] = IP_front_gland.pressure
    qufu_1_measurementpoint[f"中压缸前轴封漏汽温度"] = IP_front_gland.temperature
    qufu_1_measurementpoint[f"中压缸前轴封漏汽流量"] = IP_front_gland.flow_rate


IP_back_gland=Point(
    pressure=float(input(f"中压缸后轴封漏汽压力，单位MPa: ")),
    temperature=float(input(f"中压缸后轴封漏汽温度，单位℃: ")),
    flow_rate=float(input(f"中压缸后轴封漏汽流量，单位t/h: "))
)
qufu_1_measurementpoint[f"中压缸后轴封漏汽压力"] = IP_back_gland.pressure
qufu_1_measurementpoint[f"中压缸后轴封漏汽温度"] = IP_back_gland.temperature
qufu_1_measurementpoint[f"中压缸后轴封漏汽流量"] = IP_back_gland.flow_rate


LP_front_gland=Point(
    pressure=float(input(f"低压缸前轴封漏汽压力，单位MPa: ")),
    temperature=float(input(f"低压缸前轴封漏汽温度，单位℃: ")),
    flow_rate=float(input(f"低压缸前轴封漏汽流量，单位t/h: "))
)
qufu_1_measurementpoint[f"低压缸前轴封漏汽压力"] = LP_front_gland.pressure
qufu_1_measurementpoint[f"低压缸前轴封漏汽温度"] = LP_front_gland.temperature
qufu_1_measurementpoint[f"低压缸前轴封漏汽流量"] = LP_front_gland.flow_rate


LP_back_gland=Point(
    pressure=float(input(f"低压缸后轴封漏汽压力，单位MPa: ")),
    temperature=float(input(f"低压缸后轴封漏汽温度，单位℃: ")),
    flow_rate=float(input(f"低压缸后轴封漏汽流量，单位t/h: "))
)
qufu_1_measurementpoint[f"低压缸后轴封漏汽压力"] = LP_back_gland.pressure
qufu_1_measurementpoint[f"低压缸后轴封漏汽温度"] = LP_back_gland.temperature
qufu_1_measurementpoint[f"低压缸后轴封漏汽流量"] = LP_back_gland.flow_rate



#8其他必须的常规参数
reheat_spray_water=Point(
    pressure=float(input(f"再热器减温水压力，单位MPa: ")),
    temperature=float(input(f"再热器减温水温度，单位℃: ")),
    flow_rate=float(input(f"再热器减温水流量，单位t/h: "))
)
qufu_1_measurementpoint[f"再热器减温水压力"] = reheat_spray_water.pressure
qufu_1_measurementpoint[f"再热器减温水温度"] = reheat_spray_water.temperature
qufu_1_measurementpoint[f"再热器减温水流量"] = reheat_spray_water.flow_rate



superheat_spray_water=Point(
    pressure=float(input(f"过热器减温水压力，单位MPa: ")),
    temperature=float(input(f"过热器减温水温度，单位℃: ")),
    flow_rate=float(input(f"过热器减温水流量，单位t/h: "))
)
qufu_1_measurementpoint[f"过热器减温水压力"] = superheat_spray_water.pressure
qufu_1_measurementpoint[f"过热器减温水温度"] = superheat_spray_water.temperature
qufu_1_measurementpoint[f"过热器减温水流量"] = superheat_spray_water.flow_rate

generator_power=float(input(f"发电机功率，单位kW: "))
generator_xiaolv=float(input(f"发电机效率，单位/ "))
mechanical_loss=float(input(f"机械损失，单位kW: "))
DL_deae_flow=float(input(f"除氧器当量流量，单位t/h: "))
mf_inlet_flow=float(input(f"给水泵密封水进水流量，单位t/h: "))
mf_outlet_flow=float(input(f"给水泵密封水回水流量，单位t/h: "))
cond_water_flow=float(input(f"主凝结水流量，单位t/h: "))


qufu_1_measurementpoint[f"发电机功率"] = generator_power
qufu_1_measurementpoint[f"发电机效率"] = generator_xiaolv
qufu_1_measurementpoint[f"机械损失"] = mechanical_loss
qufu_1_measurementpoint[f"除氧器当量流量"] = DL_deae_flow
qufu_1_measurementpoint[f"给水泵密封水进水流量"] = mf_inlet_flow
qufu_1_measurementpoint[f"给水泵密封水回水流量"] = mf_outlet_flow
qufu_1_measurementpoint[f"主凝结水流量"] = cond_water_flow

current_time = datetime.now().strftime("%Y%m%d_%H%M%S")
filename = f'qufu_1_measurementpoint_{current_time}.csv'

# 将字典转换为DataFrame并保存为CSV文件
df = pd.DataFrame(list(qufu_1_measurementpoint.items()), columns=['参数', '值'])
df.to_csv(filename, index=False, encoding='utf-8-sig')

print(f"数据已成功保存到 {filename} 文件中。")