Python 如何在循环中更改条件，但仅在第一次迭代之后？

我正在创建一个简单的模型，计算12个月内还清信用卡余额所需的最低每月固定付款额

我的代码：

balance = 3329             # starting balance
annualInterestRate = 0.2   # yearly interest rate
minFixedPayment = 0        # initiate a minimum monthly payment of 0

while balance > 0:
    minFixedPayment = minFixedPayment + 10
    for i in range(1,13,1):
        unpaidBalance = balance - minFixedPayment
        balance = unpaidBalance + ((annualInterestRate/12) * unpaidBalance)
        i=i+1
print(round(minFixedPayment,2))

---

我在for循环中添加了“minFixedPayment”增量，这样它会一直递增，直到找到余额为的值为止。添加一个标志变量来控制余额是否更改。另一种方法是检查余额是否发生变化。（

如果余额！=原始余额：…

） e、 g

---

添加一个标志变量以控制余额是否发生变化。另一种方法是检查余额是否发生变化。（

如果余额！=原始余额：…

） e、 g

一些问题：

• 由于您打算尝试使用不同的付款金额，每次尝试时应将余额重置为其原始值。没有它，你就可以进入一个无限循环，平衡不断增加。为了能够重置余额，您还需要将其存储在另一个名称中
• 您不应使用

  i=i+1

  增加

  i

  。这已经通过

  for

  循环得到了解决

以下是建议的代码：

loan = balance = 3329      # starting balance, use two names so you can restart
annualInterestRate = 0.2   # yearly interest rate
minFixedPayment = -10      # initiate a minimum monthly payment

monthlyInterestRate = annualInterestRate/12 # avoid doing this repeatedly

while balance > 0:
    minFixedPayment = minFixedPayment + 10
    balance = loan # start from scratch
    for i in range(1,13):
        unpaidBalance = balance - minFixedPayment
        balance = unpaidBalance + monthlyInterestRate * unpaidBalance

print(round(minFixedPayment,2))

一些问题：

• 由于您打算尝试使用不同的付款金额，每次尝试时应将余额重置为其原始值。没有它，你就可以进入一个无限循环，平衡不断增加。为了能够重置余额，您还需要将其存储在另一个名称中
• 您不应使用

  i=i+1

  增加

  i

  。这已经通过

  for

  循环得到了解决

以下是建议的代码：

loan = balance = 3329      # starting balance, use two names so you can restart
annualInterestRate = 0.2   # yearly interest rate
minFixedPayment = -10      # initiate a minimum monthly payment

monthlyInterestRate = annualInterestRate/12 # avoid doing this repeatedly

while balance > 0:
    minFixedPayment = minFixedPayment + 10
    balance = loan # start from scratch
    for i in range(1,13):
        unpaidBalance = balance - minFixedPayment
        balance = unpaidBalance + monthlyInterestRate * unpaidBalance

print(round(minFixedPayment,2))

---

出于您的兴趣，这里有一个更复杂的解决方案：

from functools import partial
from math import ceil

def diff(fn, x, h=0.001):
    """
    Numerically differentiate fn at x
    """
    return (fn(x + h) - fn(x)) / h

def newton_solver(fn, target_y, initial_x, max_reps=100, max_err=0.01):
    """
    Find a value for x such that fn(x) == target_y (+/- max_err)
    """
    x = initial_x
    for _ in range(max_reps):
        err = fn(x) - target_y
        if abs(err) <= max_err:
            # found a good enough solution
            return x
        else:
            # first-order correction to reduce error
            x -= err / diff(fn, x)
    raise ValueError("solver failed to converge")

def final_balance(fixed_payment, initial_balance, period_rate, num_periods):
    """
    Calculate the final balance on a fixed payment plan
    """
    balance = initial_balance
    for _ in range(num_periods):
        balance = (balance - fixed_payment) * (1. + period_rate)
    return balance

def round_up_to_next_cent(amt):
    return ceil(amt * 100.) / 100.

def main():
    initial_balance = 3329.
    annual_interest = 0.2

    # bind arguments to create a single-argument function to pass to newton_solver
    my_final_balance = partial(final_balance, initial_balance = initial_balance, period_rate = annual_interest / 12, num_periods = 12)

    # initial guess - in total you will pay about half a year's interest
    monthly_payment_guess = initial_balance * (1. + annual_interest * 0.5) / 12

    # solve to find accurate value
    monthly_payment = newton_solver(my_final_balance, 0., monthly_payment_guess)
    monthly_payment = round_up_to_next_cent(monthly_payment)

    # and report the result
    print("A fixed monthly payment of ${:0.2f} results in a final balance of ${:0.2f}".format(monthly_payment, my_final_balance(monthly_payment)))

if __name__ == "__main__":
    main()

---

出于您的兴趣，这里有一个更复杂的解决方案：

from functools import partial
from math import ceil

def diff(fn, x, h=0.001):
    """
    Numerically differentiate fn at x
    """
    return (fn(x + h) - fn(x)) / h

def newton_solver(fn, target_y, initial_x, max_reps=100, max_err=0.01):
    """
    Find a value for x such that fn(x) == target_y (+/- max_err)
    """
    x = initial_x
    for _ in range(max_reps):
        err = fn(x) - target_y
        if abs(err) <= max_err:
            # found a good enough solution
            return x
        else:
            # first-order correction to reduce error
            x -= err / diff(fn, x)
    raise ValueError("solver failed to converge")

def final_balance(fixed_payment, initial_balance, period_rate, num_periods):
    """
    Calculate the final balance on a fixed payment plan
    """
    balance = initial_balance
    for _ in range(num_periods):
        balance = (balance - fixed_payment) * (1. + period_rate)
    return balance

def round_up_to_next_cent(amt):
    return ceil(amt * 100.) / 100.

def main():
    initial_balance = 3329.
    annual_interest = 0.2

    # bind arguments to create a single-argument function to pass to newton_solver
    my_final_balance = partial(final_balance, initial_balance = initial_balance, period_rate = annual_interest / 12, num_periods = 12)

    # initial guess - in total you will pay about half a year's interest
    monthly_payment_guess = initial_balance * (1. + annual_interest * 0.5) / 12

    # solve to find accurate value
    monthly_payment = newton_solver(my_final_balance, 0., monthly_payment_guess)
    monthly_payment = round_up_to_next_cent(monthly_payment)

    # and report the result
    print("A fixed monthly payment of ${:0.2f} results in a final balance of ${:0.2f}".format(monthly_payment, my_final_balance(monthly_payment)))

if __name__ == "__main__":
    main()

---

为什么不从

minFixedPayment=-10

开始，然后打印/返回

max（0，round（minFixedPayment，2））

？此外，您正在计算3329的20%利息贷款并支付10美元，很有可能您永远不会还清。一般建议：丢失while循环，并在运行时或迭代中设置上限。下一步，为了保持稳健，您可能需要检查您的余额是否低于一美分，而不是@ChihebNexus所指出的低于零。@trincot聪明！但是仍然使while循环永远运行：（@RYS只是示例值，为类执行此操作：）我将尝试使用循环上的一个设置上限来构建不同的方法，谢谢！为什么不从

minFixedPayment=-10

开始，然后打印/返回

max（0，round（minFixedPayment，2））

？此外，您正在计算3329的20%利息贷款并支付10美元，很有可能您永远不会还清。一般建议：丢失while循环，并在运行时或迭代中设置上限。下一步，为了保持稳健，您可能需要检查您的余额是否低于一美分，而不是@ChihebNexus所指出的低于零。@trincot聪明！但是仍然使while循环永远运行：（@RYS只是示例值，为类执行此操作：）我将尝试使用循环上的一个设置上限来构建不同的方法，谢谢！用较小的天平试一试，例如1000用较小的天平试一试，例如1000有效！！！：）非常感谢。我认为关键是在每次循环后重新启动余额值，以及将初始minFixPayment设置为-10。聪明！谢谢你的清理，我已经盯着它看了一段时间，忘记了一些多余的代码。这很有效！！！：）非常感谢。我认为关键是在每次循环后重新启动余额值，以及将初始minFixPayment设置为-10。聪明！谢谢你的清理，我已经盯着它看了一段时间，忘记了一些多余的代码。

from functools import partial
from math import ceil

def diff(fn, x, h=0.001):
    """
    Numerically differentiate fn at x
    """
    return (fn(x + h) - fn(x)) / h

def newton_solver(fn, target_y, initial_x, max_reps=100, max_err=0.01):
    """
    Find a value for x such that fn(x) == target_y (+/- max_err)
    """
    x = initial_x
    for _ in range(max_reps):
        err = fn(x) - target_y
        if abs(err) <= max_err:
            # found a good enough solution
            return x
        else:
            # first-order correction to reduce error
            x -= err / diff(fn, x)
    raise ValueError("solver failed to converge")

def final_balance(fixed_payment, initial_balance, period_rate, num_periods):
    """
    Calculate the final balance on a fixed payment plan
    """
    balance = initial_balance
    for _ in range(num_periods):
        balance = (balance - fixed_payment) * (1. + period_rate)
    return balance

def round_up_to_next_cent(amt):
    return ceil(amt * 100.) / 100.

def main():
    initial_balance = 3329.
    annual_interest = 0.2

    # bind arguments to create a single-argument function to pass to newton_solver
    my_final_balance = partial(final_balance, initial_balance = initial_balance, period_rate = annual_interest / 12, num_periods = 12)

    # initial guess - in total you will pay about half a year's interest
    monthly_payment_guess = initial_balance * (1. + annual_interest * 0.5) / 12

    # solve to find accurate value
    monthly_payment = newton_solver(my_final_balance, 0., monthly_payment_guess)
    monthly_payment = round_up_to_next_cent(monthly_payment)

    # and report the result
    print("A fixed monthly payment of ${:0.2f} results in a final balance of ${:0.2f}".format(monthly_payment, my_final_balance(monthly_payment)))

if __name__ == "__main__":
    main()

A fixed monthly payment of $303.33 results in a final balance of $-0.07