Javascript 在循环外保持Python条件？

因此，我在Python中学习了这个双截搜索算法，并将其应用于查找一个数字的近似值平方根。至于算法，它可以很好地发挥其局限性，但是，我在JavaScript中经常做的一件事是将条件封装在变量中，以便更易于阅读，例如：

var isGreaterThanFive = num > 5;
if(isGreaterThanFive && otherConditions...)

虽然在JavaScript中这样做效果绝对不错，但在Python中尝试这样做时，我的程序似乎进入了一个无限循环。这是我的JavaScript代码：

function sqrtOf (x) {
  var min = 0
  var max = x
  var epsylon = 0.001
  var guess = (max + min) / 2 
  var guessNumber = 0;

  //I created these two so it is easier to understand
  var notCloseEnough = Math.abs(Math.pow(guess, 2) - x) >= epsylon;
  var stillPlausible = guess <= x;

  while (notCloseEnough && stillPlausible) {
    guessNumber += 1

    if(Math.abs(Math.pow(guess, 2)) > x) {
      max = guess;
    } else {
      min = guess;
    }

    guess = (max + min) / 2;
  }

  return guess;
}

console.log(sqrtOf(25)); // 5

函数sqrtOf（x）{
var最小值=0
var max=x
变量epsylon=0.001
变量猜测=（最大+最小）/2
var guessNumber=0；
//我创建了这两个，因此更容易理解
var notcloseough=Math.abs（Math.pow（guess，2）-x）>=epsylon；
var仍然合理=猜测x）{
最大值=猜测；
}否则{
min=猜测；
}
猜测=（最大+最小）/2；
}
返回猜测；
}
console.log（sqrtOf（25））；//5.

现在在Python中：

def sqrtOf (x)
  minVal = 0
  maxVal = x
  epsylon = 0.001
  guess = (maxVal + minVal) / 2.0 
  guessNumber = 0;

  notCloseEnough = abs(guess ** 2 - x) >= epsylon
  stillPlausible = guess <= x

  while notCloseEnough and stillPlausible:
    guessNumber += 1

    if abs(guess ** 2) > x:
        maxVal = guess
    else:
        minVal = guess

    guess = (maxVal + minVal) / 2.0

  return guess

print sqrtOf(25)

def sqrtOf（x）
最小值=0
maxVal=x
epsylon=0.001
猜测=（最大值+最小值）/2.0
猜数=0；
不够接近=绝对值（猜测**2-x）>=epsylon
仍然合理=猜测x：
maxVal=猜测
其他：
猜
猜测=（最大值+最小值）/2.0
返回猜测
打印sqrtOf（25）

当您编写

notCloseEnough = abs(guess ** 2 - x) >= epsylon

您计算了语句

abs（guess**2-x）>=epsylon

，并将其结果分配给

notcloseough

。不会再次进行该计算，因为您稍后在代码中碰巧引用了它的结果

如果你想重新评估，你需要一个函数对象。可以定义对外部函数的局部变量具有可见性的内部函数

def sqrtOf (x):
  minVal = 0
  maxVal = x
  epsylon = 0.001
  guess = (maxVal + minVal) / 2.0 
  guessNumber = 0

  def notCloseEnough():
    return abs(guess ** 2 - x) >= epsylon

  def stillPlausible():
    return guess <= x

  while notCloseEnough() and stillPlausible():
    guessNumber += 1

    if abs(guess ** 2) > x:
        maxVal = guess
    else:
        minVal = guess

    guess = (maxVal + minVal) / 2.0

  return guess

print sqrtOf(25)

def sqrtOf（x）：
最小值=0
maxVal=x
epsylon=0.001
猜测=（最大值+最小值）/2.0
猜数=0
def notcloseough（）：
返回abs（猜测**2-x）>=epsylon
def仍然合理（）：
返回猜测x：
maxVal=猜测
其他：
猜
猜测=（最大值+最小值）/2.0
返回猜测
打印sqrtOf（25）

当您编写

notCloseEnough = abs(guess ** 2 - x) >= epsylon

您计算了语句

abs（guess**2-x）>=epsylon

，并将其结果分配给

notcloseough

。不会再次进行该计算，因为您稍后在代码中碰巧引用了它的结果

如果你想重新评估，你需要一个函数对象。可以定义对外部函数的局部变量具有可见性的内部函数

def sqrtOf (x):
  minVal = 0
  maxVal = x
  epsylon = 0.001
  guess = (maxVal + minVal) / 2.0 
  guessNumber = 0

  def notCloseEnough():
    return abs(guess ** 2 - x) >= epsylon

  def stillPlausible():
    return guess <= x

  while notCloseEnough() and stillPlausible():
    guessNumber += 1

    if abs(guess ** 2) > x:
        maxVal = guess
    else:
        minVal = guess

    guess = (maxVal + minVal) / 2.0

  return guess

print sqrtOf(25)

def sqrtOf（x）：
最小值=0
maxVal=x
epsylon=0.001
猜测=（最大值+最小值）/2.0
猜数=0
def notcloseough（）：
返回abs（猜测**2-x）>=epsylon
def仍然合理（）：
返回猜测x：
maxVal=猜测
其他：
猜
猜测=（最大值+最小值）/2.0
返回猜测
打印sqrtOf（25）
这也很好，
仍然合理
让我困惑。输入应该在循环之前得到验证

def sqrtOf(x):
  minVal = 0
  maxVal = x
  epsylon = 0.001
  guess = (maxVal + minVal) / 2.0
  guessNumber = 0;
  def trytrytry():
    while True:
      yield (abs(guess ** 2 - x) < epsylon, guess - x < epsylon)

  for (closeEnough, stillPlausible) in trytrytry():
    if closeEnough or not stillPlausible:
      break
    guessNumber += 1

    if abs(guess ** 2) > x:
        maxVal = guess
    else:
        minVal = guess

    guess = (maxVal + minVal) / 2.0

  return guess

print sqrtOf(25)

def sqrtOf（x）：
最小值=0
maxVal=x
epsylon=0.001
猜测=（最大值+最小值）/2.0
猜数=0；
def trytrytry（）：
尽管如此：
收益率（abs（猜测**2-x）x：
maxVal=猜测
其他：
猜
猜测=（最大值+最小值）/2.0
返回猜测
打印sqrtOf（25）
这也很好，
仍然合理
让我困惑。输入应该在循环之前得到验证

def sqrtOf(x):
  minVal = 0
  maxVal = x
  epsylon = 0.001
  guess = (maxVal + minVal) / 2.0
  guessNumber = 0;
  def trytrytry():
    while True:
      yield (abs(guess ** 2 - x) < epsylon, guess - x < epsylon)

  for (closeEnough, stillPlausible) in trytrytry():
    if closeEnough or not stillPlausible:
      break
    guessNumber += 1

    if abs(guess ** 2) > x:
        maxVal = guess
    else:
        minVal = guess

    guess = (maxVal + minVal) / 2.0

  return guess

print sqrtOf(25)

def sqrtOf（x）：
最小值=0
maxVal=x
epsylon=0.001
猜测=（最大值+最小值）/2.0
猜数=0；
def trytrytry（）：
尽管如此：
收益率（abs（猜测**2-x）x：
maxVal=猜测
其他：
猜
猜测=（最大值+最小值）/2.0
返回猜测
打印sqrtOf（25）
当您进行and赋值时，
=
右侧的表达式在赋值给变量之前进行求值。因此，循环启动时，
stillassegee
等于
True
或
False
，并且您从未对其进行任何更改。您的javascript代码也有相同的问题……当您进行and赋值时，
=
右侧的表达式在赋值给变量之前进行计算。因此，当循环启动时，
stillalkee
等于
True
或
False
，并且您从未做过任何更改。您的javascript代码也有同样的问题。。。