Python 递归函数的有趣行为

它应该是一个接受数字列表的程序，对于列表中的每一个数字，它都从中减去最小值（list）。它在最初的几次迭代中运行良好，但在接近尾声时不起作用。我在这里和那里添加了打印语句以帮助解决问题

编辑：

t = 8
string = "1 2 3 4 3 3 2 1"
string.replace(" ","")
string2 = [x for x in string]
print string2

for n in range(t-1):
    string2.remove(' ')

print string2

def remover(ca):
    newca = []
    print len(ca)

    if len(ca) == 1:
        return ca
    else:
        for i in ca:
            newca.append(int(i) - int(min(ca)))

    for x in newca:
        if x == 0:
            newca.remove(0)

    print newca
    return remover(newca)

print (remover(string2))

迭代列表并同时从列表中删除内容可能会导致奇怪和意外的behvaior。尝试改用

while

循环

for x in newca:
    if x == 0:
        newca.remove(0)

或列表：

while 0 in newca:
    newca.remove(0)

def aboveMin(items):
  min_value = min(items) # only calculate it once
  return differenceWith(min_value, items)

def differenceWith(min_value, items):
  result = []
  for value in items:
    result.append(value - min_value)
  return result

或者创建另一个临时列表：

newca = [item for item in newca if item != 0]

迭代列表并同时从列表中删除内容可能会导致奇怪和意外的behvaior。尝试改用

while

循环

for x in newca:
    if x == 0:
        newca.remove(0)

或列表：

while 0 in newca:
    newca.remove(0)

def aboveMin(items):
  min_value = min(items) # only calculate it once
  return differenceWith(min_value, items)

def differenceWith(min_value, items):
  result = []
  for value in items:
    result.append(value - min_value)
  return result

或者创建另一个临时列表：

newca = [item for item in newca if item != 0]

迭代列表并同时从列表中删除内容可能会导致奇怪和意外的behvaior。尝试改用

while

循环

for x in newca:
    if x == 0:
        newca.remove(0)

或列表：

while 0 in newca:
    newca.remove(0)

def aboveMin(items):
  min_value = min(items) # only calculate it once
  return differenceWith(min_value, items)

def differenceWith(min_value, items):
  result = []
  for value in items:
    result.append(value - min_value)
  return result

或者创建另一个临时列表：

newca = [item for item in newca if item != 0]

迭代列表并同时从列表中删除内容可能会导致奇怪和意外的behvaior。尝试改用

while

循环

for x in newca:
    if x == 0:
        newca.remove(0)

或列表：

while 0 in newca:
    newca.remove(0)

def aboveMin(items):
  min_value = min(items) # only calculate it once
  return differenceWith(min_value, items)

def differenceWith(min_value, items):
  result = []
  for value in items:
    result.append(value - min_value)
  return result

或者创建另一个临时列表：

newca = [item for item in newca if item != 0]

（不是真正的答案，JFYI:）

如果你把程序分解成适当的部分，你的程序可能会更短

newnewca = []
for x in newca:
    if x != 0:
        newnewca.append(x)

print newnewca

return remover(newnewca)

与往常一样，上述模式可以替换为理解：

while 0 in newca:
    newca.remove(0)

def aboveMin(items):
  min_value = min(items) # only calculate it once
  return differenceWith(min_value, items)

def differenceWith(min_value, items):
  result = []
  for value in items:
    result.append(value - min_value)
  return result

试试看：

def differenceWith(min_value, items):
  return [value - min_value for value in items]

请注意，任何项目都不会被删除，而且数据通常不会发生任何变化。这种方法有助于对程序进行大量推理；试试看。

（这不是真正的答案，JFYI:）

如果你把程序分解成适当的部分，你的程序可能会更短

newnewca = []
for x in newca:
    if x != 0:
        newnewca.append(x)

print newnewca

return remover(newnewca)

与往常一样，上述模式可以替换为理解：

while 0 in newca:
    newca.remove(0)

def aboveMin(items):
  min_value = min(items) # only calculate it once
  return differenceWith(min_value, items)

def differenceWith(min_value, items):
  result = []
  for value in items:
    result.append(value - min_value)
  return result

试试看：

def differenceWith(min_value, items):
  return [value - min_value for value in items]

请注意，任何项目都不会被删除，而且数据通常不会发生任何变化。这种方法有助于对程序进行大量推理；试试看。

（这不是真正的答案，JFYI:）

如果你把程序分解成适当的部分，你的程序可能会更短

newnewca = []
for x in newca:
    if x != 0:
        newnewca.append(x)

print newnewca

return remover(newnewca)

与往常一样，上述模式可以替换为理解：

while 0 in newca:
    newca.remove(0)

def aboveMin(items):
  min_value = min(items) # only calculate it once
  return differenceWith(min_value, items)

def differenceWith(min_value, items):
  result = []
  for value in items:
    result.append(value - min_value)
  return result

试试看：

def differenceWith(min_value, items):
  return [value - min_value for value in items]

请注意，任何项目都不会被删除，而且数据通常不会发生任何变化。这种方法有助于对程序进行大量推理；试试看。

（这不是真正的答案，JFYI:）

如果你把程序分解成适当的部分，你的程序可能会更短

newnewca = []
for x in newca:
    if x != 0:
        newnewca.append(x)

print newnewca

return remover(newnewca)

与往常一样，上述模式可以替换为理解：

while 0 in newca:
    newca.remove(0)

def aboveMin(items):
  min_value = min(items) # only calculate it once
  return differenceWith(min_value, items)

def differenceWith(min_value, items):
  result = []
  for value in items:
    result.append(value - min_value)
  return result

试试看：

def differenceWith(min_value, items):
  return [value - min_value for value in items]

---

请注意，任何项目都不会被删除，而且数据通常不会发生任何变化。这种方法有助于对程序进行大量推理；试试看。

所以如果我已经理解了你期望的描述

我相信下面的脚本会更接近你的目标

逻辑：

• split将返回一个由提供给原始输入的每个“数字”组成的数组，而即使使用replace的输出，最终也会得到一个很长的数字（去掉了分隔每个数字的空格），而字符串的实际拆分将其拆分为一位数，这与您描述的意图不符
• 您应该测试提供的每个输入是否为整数
• 由于您已经在函数中进行了打印，因此无需返回任何内容
• 避免向新数组中添加零，只需先进行测试

---

---

所以如果我已经理解了你期望的描述

我相信下面的脚本会更接近你的目标

逻辑：

• split将返回一个由提供给原始输入的每个“数字”组成的数组，而即使使用replace的输出，最终也会得到一个很长的数字（去掉了分隔每个数字的空格），而字符串的实际拆分将其拆分为一位数，这与您描述的意图不符
• 您应该测试提供的每个输入是否为整数
• 由于您已经在函数中进行了打印，因此无需返回任何内容
• 避免向新数组中添加零，只需先进行测试

---

---

所以如果我已经理解了你期望的描述

我相信下面的脚本会更接近你的目标

逻辑：

• split将返回一个由提供给原始输入的每个“数字”组成的数组，而即使使用replace的输出，最终也会得到一个很长的数字（去掉了分隔每个数字的空格），而字符串的实际拆分将其拆分为一位数，这与您描述的意图不符
• 您应该测试提供的每个输入是否为整数
• 由于您已经在函数中进行了打印，因此无需返回任何内容
• 避免向新数组中添加零，只需先进行测试

---

---

所以如果我已经理解了你期望的描述

我相信下面的脚本会更接近你的目标

逻辑：

• split将返回一个由提供给原始输入的每个“数字”组成的数组，而即使使用replace的输出，最终也会得到一个很长的数字（去掉了分隔每个数字的空格），而字符串的实际拆分将其拆分为一位数，这与您描述的意图不符
• 您应该测试提供的每个输入是否为整数
• 由于您已经在函数中进行了打印，因此无需返回任何内容
• 避免向新数组中添加零，只需先进行测试

---

---

请描述用户应该输入什么输入，您希望看到什么类型的输出，以及您将获得什么输出。顺便说一句，我认为这与您的问题无关，但是

string.replace

不会做任何事情，除非您指定结果