如何更改类中使用的变量（常量）并更新该类以使用 python 中的新值？

Question

我一直试图解决这个问题几个小时，但无法找到解决方案。

我使用我在类中定义的方程。 这些方程取决于常量，我将其定义为变量。 我的最终目标是能够更改和迭代其中一个常量，从而更新依赖于这些常量（变量）的方程。

举个例子：

constant_1 = 10
constant_2 = 20

class(object):
    first_eq = constant_1 * constant_2

# I now want to update constant_2 to 40 and thus first_eq should change its value

我尝试过的事情：

• 使用字典列表来存储我的常量并更新文件末尾的假装值
• 对常量和方程使用不同的文件，然后将它们导入一个新文件，然后尝试从该文件中更改常量
• 定义要更新的函数（如果需要，我可以包含已定义的函数）常量文件上的值和它们在新文件中的值，当我导入常量时，我​​使用该函数更新文件（我已经尝试了在 a 中定义的两个常量）字典或类内）
• 还有一些我已经不记得的事情

所有这些方法都可以改变我想要的常数（变量），但是方程的值始终保持不变。

有什么帮助吗？

感谢您的时间。

编辑：按照建议，我将在此处插入与本次讨论相关的代码部分。 我的目标是能够改变一个或多个方程中可能存在的给定常数（变量），并相应地更新这些方程的值。

我的常量文件是：

from PySpice.Unit import *
from PySpice.Physics.PhysicalConstants import *
import numpy as np
import math

constants = {
    "conv" : 1.0e3,
    "T" : 25+273.15,
    "k" : 1.380650e-23,
    "PI" : np.pi,
    "PI2" : np.pi*2.0,
    "q" : 1.602176e-19,
    "NAv" : 6.0221415e23,
    "dWaals" : 0.34e-9,
    "eps0" : 8.854187e-12,
    "epsw" : 78.5,
    "epslys" : 3.0,
    "epsglyco" : 81,
    "ros" : 0.7,
    "roAu" : 2.27e-8,
    "roglyco" : 1.6e6,
    "Cbulk" : 150.0e-3
}
constants["ET"] = constants["q"]/(constants["k"]*constants["T"])

constants["epsmed"] = constants["eps0"]*constants["epsw"]

constants_neuron = {
    "Ncomp" : 5.0,
    "dsomat" : 100.0e-6,
    "daxont" : 10.0e-6,
    "laxont" : 500.0e-6,
    "Rax" : 0.1
}

constants_gme = {
    "phstalk" : 1.0,
    "dmstalk" : 1.0e-6,  # MUDAR PARA d_stalk : 2um
    "hstalk" : 1.0e-6,
    "dmhead" : 2.0e-6,
    "tinsM" : 1.2,
}
constants_cleft = {
    "dsealjGME" : 2e-9,
    "alphahead" : 0.4294*np.pi,
    "Etawm" : 1.0,
    "deltawm" : 1.0,
    "deltawm" : 1.0,
}

我的方程文件是：

from PySpice.Unit import *
from PySpice.Physics.PhysicalConstants import *
import numpy as np
import math
from constants_spice import *
class parameters(object):




# **********************************************************************
# *               NEURON PARAMETERS
# **********************************************************************
# * laxont    Neuron axon length              [m]
# * daxont    Neuron axon diameter                [m]
# * dsomat    Neuron soma diameter                [m]
# * Rax       axoplasmatic resistance per unit length     [ohm*cm]
# * Ncomp     compartments number

    Asomat = (2.0*constants["PI2"]*(constants_neuron["dsomat"]/2.0)*(constants_neuron["dsomat"]/2.0))
    Aaxont = (constants["PI2"]*(constants_neuron["daxont"]/2.0)*constants_neuron["laxont"])
    ANEURt = (Asomat+Aaxont)
    dsoma = (constants_neuron["dsomat"]/constants_neuron["Ncomp"])
    daxon = constants_neuron["daxont"]
    laxon = (constants_neuron["laxont"]/constants_neuron["Ncomp"])
    Asoma = (2.0*constants["PI2"]*(dsoma/2.0)*(dsoma/2.0))
    Aaxon = (constants["PI2"]*(daxon/2.0)*laxon)
    ANEUR = (Asoma+Aaxon)

    # **********************************************************************
    # *               GME PARAMETERS
    # **********************************************************************
    # * phstalk   percentage of engulfed stalk height
    # * hstalk    GME stalk height                [m]
    # * htstalk   GME engulfed stalk height           [m]
    # * dmstalk   GME stalk diameter              [m]
    # * dmhead    GME head diameter               [m]
    # * Astalk    GME stalk area                  [m**2]
    # * Ahead     GME half head area              [m**2]
    # * Arim      GME rim area                    [m**2]
    # * AGME      GME total area                  [m**2]
    # * tinsM     thickness of the insulation coating     [m]

    htstalk = (constants_gme["hstalk"]*constants_gme["phstalk"])
    cirhead = (constants["PI2"]*((constants_gme["dmhead"])/2.0))
    Abstalk = (constants["PI"]*(constants_gme["dmstalk"]/2.0)*(constants_gme["dmstalk"]/2.0))
    Astalk = (constants["PI2"]*(constants_gme["dmstalk"]/2.0)*htstalk)
    Aheadt = (2.0*constants["PI2"]*(constants_gme["dmhead"]/2.0)*(constants_gme["dmhead"]/2.0))
    Ahead = (Aheadt/2.0)
    Arim = (constants["PI"]*((constants_gme["dmhead"]/2.0)*(constants_gme["dmhead"]/2.0)-(constants_gme["dmstalk"]/2.0)*(constants_gme["dmstalk"]/2.0)))
    AGME = (Astalk+Ahead+Arim)

    # *-----------------------Rmicro---------------------------------------
    Rstalk = (constants["roAu"]*((htstalk) / (Abstalk)))
    Rhead = (constants["roAu"]) / (cirhead)
    RGME = (Rstalk+Rhead)
    RGME = RGME@u_Ω
    # * RGME = 20Meg
    # *-------------------------Shunt Capacitance--------------------------------------------
    PHIM = (constants["PI"]/2.0)
    CshGME = (((constants["PI2"]*constants["eps0"]*constants["epslys"])/np.log(constants_gme["tinsM"]))*(htstalk+(constants_gme["dmhead"]/2.0)*np.sin(PHIM)))
    CshGME = CshGME*10**12
    CshGME = CshGME@u_pF
    # print("CshGME = "+str(CshGME))
    # * + CshGME = 1.37e2p The shunt capacitance affects the recording! The Vpeak/
    # is saturated for the value of the article!
    # **********************************************************************
    # *               NUMBER of GMEs
    # **********************************************************************
    # * shxn      minimum distance between two GMEs head centers      [m]
    # * xGME      extra distance between two GMEs head centers        [m]
    # * shn       effective inter-GMEs head distance          [m]
    # * lambdaGME Debye length                        [m]
    # * nGME      number of vertically arranged GMEs in the soma compartment
    # *-----------------------------

    lambdaGME = (np.sqrt((constants["epsmed"]/(constants["q"]*constants["ET"]))*(1.0/(2.0*constants["NAv"]*constants["Cbulk"]*constants["conv"]))))
    lambdaGME = lambdaGME
    shxn = (constants_gme["dmhead"]+constants["dWaals"]+2.0*lambdaGME)
    xGME = 6.0e-6
    shn = (shxn+xGME)
    AmGME = (constants["PI"]*shn*shn)
    AmSOMA = (constants["PI"]*(dsoma/2.0)*(dsoma/2.0))
    nGME = (int(AmSOMA/AmGME))
    # **********************************************************************

    # **********************************************************************
    # *               GME CLEFT PARAMETERS
    # **********************************************************************
    # * dsealjGME cleft width at the neuron-GME junction          [m]
    # * alphahead head starting angle for resistor concentric rings model
    # * etawm     covering factor of the cross-sectional area of the solution.
    # * deltawm   surface overlapping coefficient: percentage of microel.
    # *               sensitive area covered by the neuron
    # *-----------------------------

    Rspreadhead = (((constants["ros"]/constants["PI2"])*(constants_cleft["dsealjGME"]/((constants_gme["dmhead"]/2.0)*((constants_gme["dmhead"]/2.0)+
    constants_cleft["dsealjGME"]))))*constants_cleft["Etawm"])
    H = (htstalk+(constants_gme["dmstalk"]/2.0)+constants_cleft["dsealjGME"])
    Rspreadstalk = (((constants["ros"]/(constants["PI"]*H))*np.log((4.0*H)/(constants["PI2"]*(constants_gme["dmstalk"]/2.0))))*constants_cleft["Etawm"])
    RspreadGME = (Rspreadhead+Rspreadstalk)
    RspreadGME = RspreadGME@u_Ohm
    rodj = (constants["ros"]/(constants["PI2"]*constants_cleft["dsealjGME"]))
    Rsealhead = (rodj*(np.log(np.tan(constants["PI"]/4.0))-np.log(np.tan(constants_cleft["alphahead"]/2.0))))
    Rsealrim = (rodj*(np.log((constants_gme["dmhead"]/2.0)/(constants_gme["dmstalk"]/2.0))))
    Rsealstalk = (rodj*(htstalk/(constants_gme["dmstalk"]/2.0)))
    RsealGME = ((Rsealhead+Rsealrim+Rsealstalk)*constants_cleft["deltawm"])
    RsealGME = RsealGME@u_Ohm
    # print("Rseal="+str(RsealGME))
    # RsealGME = 100@u_GΩ
    # **********************************************************************
    # *
    # **********************************************************************
    # *       GME & GPE ELECTROLYTE INTERFACE PARAMETERS
    # **********************************************************************
    # * Chg       capacitance of EDL at the interface microel-solution    [F]
    # * Rhg       leakage resistance                  [ohm]
    # *-----------------------------
    # PEDOT:PSS PARAMETERS:
    ChgGME = 1.2@u_nF
    RhgGME = 10@u_MΩ

    # ChgGME = 5@u_pF
    # RhgGME = 1500@u_GΩ
    # *---------Amplifier input impedance------------------------
    # *artigo_ventura
    Ra = 450@u_MΩ
    # * + Ca = 10p
    # *input impedance dos artigos do \Spira
    # Ra = 20@u_MΩ
    # *----------------------------------------------------------

    # **********************************************************************
    # *       GME & GPE PROTEIN-GLYCOCALYX EDL PARAMETERS
    # **********************************************************************
    # * Chd       capacitance of EDL at interface of glycocalyx-solution  [F]
    # * Rhd       resistance of the EDL                   [ohm]
    # * tglyco    glycocalyx thickness                    [m]
    # * gammaw    correction factor
    # * fscale    scale factor
    # *-----------------------------
    tglyco = 100.0e-9
    gammawm = 1
    ChdGME = ((constants["epsglyco"]*constants["eps0"])*(AGME/tglyco)*gammawm)
    ChdGME= ChdGME*10**12
    ChdGME = ChdGME@u_pF
    RhdGME = (constants["roglyco"]*(tglyco/AGME)*gammawm)
    RhdGME = RhdGME@u_Ω
    # RhdGME = 100Meg
    fscale = 2.5

注意：文件是这样的，因为我最后一次尝试是使用字典。 正如我在开头所说的，在之前的版本中，我还尝试在同一个类中以及在不同的类中定义所有常量（变量）和方程。 再次感谢你。

Answer 1

如果我正确理解了您遇到的问题， first_eq在运行该行代码时评估first_eq 。 您以后做的事情不会改变first_eq的值，除非您通过重新计算明确更改该值。 所以在你设置了constant_2 = 40 ，你应该能够做到myClass.first_eq = constant_1 * constant_2并且它应该可以正常工作。

constant_1 = 10
constant_2 = 20
class TestClass:
    first_eq = constant_1 * constant_2

print(TestClass.first_eq) # Output: 200
constant_2 = 40
print(TestClass.first_eq) # Output: 200 (no change even though we changed constant_2)

TestClass.first_eq = constant_1 * constant_2 # Now actually recalculate first_eq
print(TestClass.first_eq) # Output: 400 

或者，您可以定义一个函数，将两个常量传递给该函数。 这是一个更好的解决方案，因为您不必记住每次更改“常量”时都更新first_eq的值，因为您将它们的当前值传递给计算first_eq的函数。

constant_1 = 10
constant_2 = 20
class TestClass:
    def first_eq(c1, c2):
        return c1 * c2

print(TestClass.first_eq(constant_1, constant_2)) # Output: 200
constant_2 = 40
print(TestClass.first_eq(constant_1, constant_2)) # Output: 400

关于。 “但是，当给定的常数存在于各种方程中并且我需要在每个方程中更新它时，如何解决这个问题” ：

在这种情况下，将常量定义为类的变量更有意义。 然后，类的函数可以访问它的变量。

class TestClass:
    constant_1 = 10
    constant_2 = 20
    
    @classmethod
    def first_eq(self):
        return self.constant_1 * self.constant_2

print(TestClass.first_eq()) # Output: 200
TestClass.constant_2 = 40
print(TestClass.first_eq()) # Output: 400

---

现在您已经为问题添加了一些代码，下面是我将如何编写代码：

class parameters:
    def __init__(self, constants, constants_neuron, constants_gme, constants_cleft):    
        self.Asomat = (2.0*constants["PI2"]*(constants_neuron["dsomat"]/2.0)*(constants_neuron["dsomat"]/2.0))
        self.Aaxont = (constants["PI2"]*(constants_neuron["daxont"]/2.0)*constants_neuron["laxont"])
        self.ANEURt = (self.Asomat+self.Aaxont)
        self.dsoma = (constants_neuron["dsomat"]/constants_neuron["Ncomp"])
        ...

并使用它：

p = parameters(constants, constants_neuron, constants_gme, constants_cleft)
print(p.Asomat)
print(p.Aaxont)
...

这样，您所有的计算值都封装在parameters类的p实例中。 如果您希望使用不同的常量计算相同的值，只需在构造parameters对象时传递不同的constants_*字典即可。