用Python中的条件定义函数

我目前正在从事博士论文编码工作。本文以阿雷亚诺（2008）为基础，研究选择性违约。从@quantecon笔记本中获得灵感

我正在尝试使用Numba在Python中创建一个函数，该函数迭代一组变量，但其中一个是条件变量。也就是说，根据自然状态的概率，迭代必须不同。我曾尝试使用if/else语句，但Python指出语法错误。该代码是我博士论文的一个值函数迭代。下面是我写的：

    @jit(nopython=True)
def solve(model, tol=1e-8, maxiter=10_000):
    """
    Given an Selective_Economy type, this function computes the optimal
    policy and value functions
    """
    # Unpack certain parameters for simplification
    β, σ, r, θ_d, θ_f = model.β, model.σ, model.r, model.θ_d, model.θ_f
    b_d = np.ascontiguousarray(model.b_d)
    b_f = np.ascontiguousarray(model.b_f)
    A, y = np.ascontiguousarray(model.A), np.ascontiguousarray(model.y)
    nb_d, nb_f, ny = b_d.size, b_f.size, y.size

    # Allocate space
    ib_d_star = np.zeros((ny, nb_d), int64)
    ib_f_star = np.zeros((ny, nb_f), int64)
    dom_default_prob = np.zeros((ny, nb_d))
    ext_default_prob = np.zeros((ny, nb_f))
    dom_default_states = np.zeros((ny, nb_d))
    ext_default_states = np.zeros((ny, nb_f))
    tot_default_states = np.zeros((ny, nb_d, nb_f))
    q_f = np.ones((ny, nb_f)) * 0.95
    q_d = np.ones((ny, nb_d)) * 0.95
    Vfd = np.zeros(ny, nb_d)
    Vdd = np.zeros(ny, nb_f)
    Vtd = np.zeros(ny)
    Vc, V, Vupd = np.zeros((ny, nb_d,nb_f)), np.zeros((ny, nb_d,nb_f)), np.zeros((ny, nb_d,nb_f))

    it = 0
    dist = 10.0
    while (it < maxiter) and (dist > tol):

        # Compute expectations used for this iteration
        EV = A@V
        EVfd = A@Vfd
        EVdd = A@Vdd
        EVtd = A@Vtd

        for iy in range(ny):
            # Update value function for default state
            Vfd[iy] = model.bellman_ext_default(iy, EVfd, EV)
            Vdd[iy] = model.bellman_dom_default(iy, EVdd, EV)
            Vtd[iy] = model.bellman_tot_default(iy, EVtd, EV)

            for ib_d, ib_f in range(nb_d), range(nb_f):
                # Update value function for non-default state
                ib_d_star[iy, ib_d] = model.compute_savings_policy(iy, ib_d, q_d, EV)
                ib_f_star[iy, ib_f] = model.compute_savings_policy(iy, ib_f, q_d, EV)
                Vc[iy, ib_d,ib_f] = model.bellman_nondefault(iy, ib_d, ib_f, q_d, q_f, EV, ib_d_star[iy, ib_d], ib_f_star[iy,ib_f])

        # Once value functions are updated, can combine them to get
        # the full value function
        Vfd_compat = np.reshape(np.repeat(Vfd, nb_f), (ny, nb_f))
        Vdd_compat = np.reshape(np.repeat(Vdd, nb_d), (ny, nb_d))
        Vtd_compat = np.reshape(np.repeat(Vtd, nb_d, nb_f), (ny, nb_d, nb_f))
        Vupd[:, :] = np.maximum(Vc, Vfd_compat, Vdd_compat, Vtd_compat)

        # Can also compute default states and update prices
        ext_default_states[:, :] = 1.0 * (Vfd_compat > max(Vc, Vdd, Vtd))
        dom_default_states[:, :] = 1.0 * (Vdd_compat > max(Vc, Vfd, Vtd))
        tot_default_states[:, :] = 1.0 * (Vtd_compat > max(Vc, Vfd, Vdd))
        ext_default_prob[:, :] = A @ ext_default_states
        dom_default_prob[:, :] = A @ dom_default_states

        if dom_default_prob = 0:

            q_f[:, :] = (1 - ext_default_prob) / (1 + r)
        else:
            q_f[:, :] = θ_f * (1 - ext_default_prob) / (1 + r) + (1 - θ_f) (1 - ext_default_prob) / (1 + r)

        if ext_default_prob = 0:

            q_d[:, :] = β * (1 - ext_default_prob) * (1 - dom_default_prob) * u_prime(y[iy]) + ext_default_prob * (1 - dom_default_prob) * u_prime(ext_y[iy]) / u_prime(y[iy])
        else:
            q_d[:, :] = β * θ_f * (1 - dom_default_prob) * u_prime(y[iy]) + (1 - θ_f) * (1 - dom_default_prob) * u_prime(ext_y[iy]) / u_prime(ext_y[iy])

        # Check tolerance etc...
        dist = np.max(np.abs(Vupd - V))
        V[:, :] = Vupd[:, :]
        it += 1

    return V, Vc, Vfd, Vdd, Vtd, ib_d_star, ib_f_star, ext_default_prob, dom_default_prob, ext_default_states, dom_default_states, tot_default_states, q_f, q_d

@jit（nopython=True）
def solve（型号，tol=1e-8，maxiter=10_000）：
"""
给定一种选择性的经济类型，此函数计算最优
政策和价值职能
"""
#解包某些参数以进行简化
β、 σ，r，θd，θf=模型β，模型σ，模型r，模型θd，模型θf
b_d=np.ASCONTIGOUUSARRAY（模型b_d）
b_f=np.ASCONTIGOUUSARRAY（模型b_f）
A、 y=np.ASCONTIGOUUSARRAY（模型A），np.ASCONTIGOUUSARRAY（模型y）
nb_d，nb_f，ny=b_d.尺寸，b_f.尺寸，y.尺寸
#分配空间
ib_d_star=np.zero（（纽约，nb_d），int64）
ib_f_star=np.zero（（纽约，nb_f），int64）
dom_default_prob=np.zeros（（纽约，nb_d））
ext_default_prob=np.零（（纽约，nb_f））
dom_default_states=np.zeros（（纽约，nb_d））
ext_default_states=np.zeros（（纽约，纽约）
tot_default_states=np.zero（（纽约州，纽约州，纽约州）
q_f=np.ones（（纽约，nb_f））*0.95
q_d=np.ones（（纽约，nb_d））*0.95
Vfd=np.零（ny，nb_d）
Vdd=np.零（ny，nb\u f）
Vtd=np.零（纽约）
Vc，V，Vupd=np.零（（ny，nb_d，nb_f）），np.零（（ny，nb_d，nb_f）），np.零（（ny，nb_d，nb_f））
它=0
距离=10.0
而（ittol）：
#计算用于此迭代的期望值
EV=A@V
EVfd=A@Vfd
EVdd=A@Vdd
EVtd=A@Vtd
对于范围内的iy（纽约）：
#更新默认状态的值函数
Vfd[iy]=模型.行李员外部默认值（iy，EVfd，EV）
Vdd[iy]=模型.行李员默认值（iy，EVdd，EV）
Vtd[iy]=模型.行李员总默认值（iy，EVtd，EV）
对于ib_d，ib_f在范围内（nb_d），范围内（nb_f）：
#非默认状态的更新值函数
ib_d_star[iy，ib_d]=模型。计算储蓄政策（iy，ib_d，q_d，EV）
ib_f_star[iy，ib_f]=模型。计算储蓄政策（iy，ib_f，q_d，EV）
Vc[iy，ib_d，ib_f]=模型.行李员非默认值（iy，ib_d，ib_f，q_d，q_f，EV，ib_d_星[iy，ib_d]，ib_f星[iy，ib_f]）
#值函数更新后，可以将其组合以获得
#全值函数
Vfd\u compat=np.重塑（np.重复（Vfd，nb\u f），（纽约，nb\u f））
Vdd_compat=np.重塑（np.重复（Vdd，nb_d），（纽约，nb_d））
Vtd_compat=np.重塑（np.重复（Vtd，nb_d，nb_f），（纽约，nb_d，nb_f））
Vupd[：，：]=np.最大值（Vc、Vfd兼容、Vdd兼容、Vtd兼容）
#还可以计算默认状态并更新价格
外部默认状态[：，：]=1.0*（Vfd\u compat>max（Vc、Vdd、Vtd））
dom_default_states[：，：]=1.0*（Vdd_compat>max（Vc、Vfd、Vtd））
tot_默认值_状态[：，：]=1.0*（Vtd_compat>max（Vc、Vfd、Vdd））
ext_default_prob[：，：]=A@ext_default_states
dom_default_prob[：，：]=A@dom_default_states
如果dom\u default\u prob=0：
q_f[：，：]=（1-ext_default_prob）/（1+r）
其他：
q_f[：，：]=θ_f*（1-ext_default_prob）/（1+r）+（1-θ_f）（1-ext_default_prob）/（1+r）
如果ext\u default\u prob=0：
q_d[：，：]=β*（1-外部违约概率）*（1-外部违约概率）*u素数（y[iy]）+外部违约概率*（1-外部违约概率）*u素数（外部违约概率）/u素数（y[iy]）
其他：
q_d[：，：]=β*θ_f*（1-dom_default_prob）*素数（y[iy]）+（1-θ_f）*（1-dom_default_prob）*素数（ext_y[iy]）/u素数（ext_y[iy]）
#检查公差等。。。
距离=净最大值（净绝对值（Vupd-V））
V[：，：]=Vupd[：，：]
it+=1
返回V、Vc、Vfd、Vdd、Vtd、ib_d_星、ib_f_星、ext_default_prob、dom_default_prob、ext_default_states、dom_default_states、tot_default_states、q_f、q_d

错误在最后一部分，我收到以下消息：

  File "<ipython-input-3-cf2f65d62110>", line 65
if dom_default_prob = 0:
                    SyntaxError: invalid syntax

文件“”，第65行
如果dom\u default\u prob=0：
SyntaxError:无效语法

如果有人帮忙，我会很感激的

谢谢：）

您应该使用

==

检验是否平等。单个equals

=

告诉python将右侧的值分配给左侧变量

因此，代码应该是

if dom_default_prob == 0:

---

（重温Python对

=

，

！=

，

=

的解释）