Python递归与迭代

我在代码中找不到错误。它在我的cmd上运行良好，但无法通过实验室平台测试。问题是：

您需要分别设计一个名为replicate_iter和replicate_recur的迭代和递归函数，该函数将接收两个参数：times是要重复的次数，data是要重复的数字或字符串

函数应该返回一个数组，其中包含重复的数据参数。例如，

replicate\u recur（3,5）

或

replicate\u iter（3,5）

应返回

[5,5]

。如果times参数为负或零，则返回空数组。如果参数无效，则引发

ValueError

“

下面是我的代码：

my_list1 = []
my_list2 = []
   def replicate_iter(times,data):
      try:
        if type(data) != int and type(data) != str:
          raise ValueError('Invalid Argument')
        times += 0
          if times > 0:
            x = 0
            while x < times:
            my_list2.append(data)
            x = x+1
           return my_list2
         else:
          return []
    except (ValueError,AttributeError,TypeError):
        raise ValueError('Invalid Argument')

def replicate_recur(times,data):
    try:
        if type(data) != int and type(data) != str:
          raise ValueError('Invalid Argument')
        times += 0
        if times <= 0:
          return my_list1
        else:
          my_list1.append(data)
          return replicate_recur(times-1,data)
    except(AttributeError,TypeError):
        raise ValueError('Invalid Argument')

my_list1=[]
我的清单2=[]
def复制试验机（时间、数据）：
尝试：
如果类型（数据）！=int和类型（数据）！=str：
raise VALUERROR（'无效参数'）
次数+=0
如果时间>0：
x=0
而x<次：
我的清单2.append（数据）
x=x+1
返回我的_列表2
其他：
返回[]
除了（ValueError、AttributeError、TypeError）：
raise VALUERROR（'无效参数'）
def复制重复（次数、数据）：
尝试：
如果类型（数据）！=int和类型（数据）！=str：
raise VALUERROR（'无效参数'）
次数+=0
如果时间
边缘案例

>>> replicate_iter(0, 5)
[]

>>> replicate_iter(3, list())
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    replicate_iter(3, list())
  File "C:/temp/temp.py", line 3, in replicate_iter
    raise ValueError('Must be int or str')
ValueError: Must be int or str

复制iter（0,5）
[]
>>>复制iter（3，list（））
回溯（最近一次呼叫最后一次）：
文件“”，第1行，在
复制iter（3，list（））
文件“C:/temp/temp.py”，第3行，在复制文件中
raise VALUERROR（'必须是int或str'）
ValueError:必须是int或str

两者的基本实现（尽管老实说它们不是好的Python）是：

def replicate_iter(times, data):
    result = []
    for _ in range(times):  # xrange in Python2
        result.append(data)
    return result


def replicate_recur(times, data):
    if times <= 0:
        return []
    return [data] + replicate_recur(times - 1, data)


assert replicate_iter(3, 5) == [5, 5, 5]
assert replicate_recur(3, 5) == [5, 5, 5]
assert replicate_iter(4, "abc") == ["abc", "abc", "abc", "abc"]
assert replicate_recur(4, "abc") == ["abc", "abc", "abc", "abc"]

---

递归在任何生产代码中都不会真正用于此任务。

我认为您的代码比其他人所说的更接近正确——您只需要重新排列一些元素：

def replicate_iter(times, data):
    if type(data) != int and type(data) != str:
        raise TypeError('Invalid Argument')

    try:
        my_list = []

        if times > 0:
            for _ in range(times):
                my_list.append(data)

        return my_list

    except (ValueError, TypeError):
        raise ValueError('Invalid Argument') from None

def replicate_recur(times, data):
    if type(data) != int and type(data) != str:
        raise TypeError('Invalid Argument')

    try:
        my_list = []

        if times > 0:
            my_list.append(data)
            my_list.extend(replicate_recur(times - 1, data))

        return my_list

    except (ValueError, TypeError):
        raise ValueError('Invalid Argument') from None

---

我同意错误处理有点复杂，但这正是规范所要求的。虽然对

times

参数有明确规定，但如果

数据

不是可接受的类型之一，规范对生成哪种错误是不明确的，但TypeError似乎是有意义的。

对于递归版本，我建议nd正如您已经在做的那样，其他示例即使使用列表串联（

++

），也会生成一个新的列表，其中包含每个列表的元素副本，当您可以像使用迭代版本一样在单个列表中添加元素时，这太浪费时间和空间了

这里有一个例子

def replicate_recur(times, data, result=None):
    if result is None:
        result = []
    if times <= 0 :
        return result
    else:
        result.append(data)
        return replicate_recur(times-1,data,result)

def replicate\u recur（次数、数据、结果=无）：
如果结果为无：
结果=[]
如果时间这有效

def replicate_iter(times, data):
    if((not isinstance(times, int)) or (not isinstance(data, (int, float, long, complex, str)))):
            raise ValueError("Invalid arguments")
    elif(times <= 0):
            return []
    else:
            array = []
            for x in range(times):
                    array.append(data)
            return array


def replicate_recur(times, data):
    if((not isinstance(times, int)) or (not isinstance(data, (int, float, long, complex, str)))):
            raise ValueError("Invalid arguments")
    elif(times <= 0):
            return []
    else:
            return ([data] + replicate_recur((times - 1), data))        

def replicate_iter（时间、数据）：
如果（（非isinstance（times，int））或（非isinstance（data，（int，float，long，complex，str））：
raise VALUERROR（“无效参数”）
elif（times我认为迭代版本很简单，其他人也提供了很好的答案。至于递归，我总是想看看我是否能想出一个分而治之的策略，而不是一步一个脚印地解决问题，以避免破坏堆栈。下面是这样做的：

def replicate_recur(times, data):
    def f(n, value):
        if n < 1:
            return [] 
        result = f(n // 2, value) * 2
        if n % 2 > 0:
            result += [value] 
        return result

    if not isinstance(data, int) and not isinstance(data, str):
        raise ValueError('Must be int or str')
    return f(times, data)

def replicate_recur（次数、数据）：
def f（n，值）：
如果n<1：
返回[]
结果=f（n//2，值）*2
如果n%2>0：
结果+=[值]
返回结果
如果不存在isinstance（数据，int）和isinstance（数据，str）：
raise VALUERROR（'必须是int或str'）
返回f（次数、数据）

这使用了一个内部递归函数
f（）
，以避免重复对
数据
的类型检查。递归构造了一个大小为一半的列表，或者将其加倍（如果当前
n
为偶数），或者将其加倍，并添加一个以上出现的
数据
（如果当前
n
为奇数）

试试看，你会喜欢的！
我试过这个，它对那个测试有效

def replicate_iter(times,data):
    Array = []
    if type(times) != int or not isinstance(data, (int, float, complex, str)):
        raise ValueError ('Invalid Value')
    elif times < 0:
        return []
    else:
        for x in range (times):
            Array.append(data)
        return Array


def replicate_recur(times,data):
    Array = []
    if type(times) != int or not isinstance(data, (int, float, complex, str)):
        raise ValueError ('Invalid Value')
    elif times <= 0:
        return []
    else:
       Array = replicate_recur(times-1,data)
       Array.append(data)
    return Array

def replicate_iter（时间、数据）：
数组=[]
如果type（times）！=int或not isinstance（data，（int，float，complex，str））：
raise VALUERROR（'无效值'）
elif时间<0:
返回[]
其他：
对于范围内的x（次）：
Array.append（数据）
返回数组
def复制重复（次数、数据）：
数组=[]
如果type（times）！=int或not isinstance（data，（int，float，complex，str））：
raise VALUERROR（'无效值'）
elif times请为该站点更好地设置代码格式。如果您用4个字符的空格缩进句子（通常是一个制表符），它将更好地显示代码块。为什么要使用全局变量？不知道这是否是您失败的原因，但此行是错误的：
type（data）！=int和type（data）！=str:
我之所以使用全局变量，是因为我不希望每次递归都更改值。不要麻烦进行类型检查。任何此类异常都表明函数调用不正确或代码中存在错误；通过让代码自然失败，这两种情况都会得到同样有效的信号。您可以使用摘要number
numbers.number的基类，而不是列出数值类型的所有实现，这些实现在Python3中有失败的风险，因为
long
不再是
时代的特例
def replicate_recur(times, data, result=None):
    if result is None:
        result = []
    if times <= 0 :
        return result
    else:
        result.append(data)
        return replicate_recur(times-1,data,result)

def replicate_recur_aux(times, data, result):
    if times <= 0 :
        return result
    else:
        result.append(data)
        return replicate_recur_aux(times-1,data,result)  

def replicate_recur(times, data):
    if not isinstance(data, int) and not isinstance(data, str):
        raise ValueError('Invalid Argument')
    return replicate_recur_aux(times,data,[])

def replicate_iter(times, data):
    if not isinstance(data, int) and not isinstance(data, str):
        raise ValueError('Invalid Argument')
    result = []
    if times <=0:
        return result
    for i in range(times):
        result.append(data)
    return result

def replicate_iter(times, data):
    if((not isinstance(times, int)) or (not isinstance(data, (int, float, long, complex, str)))):
            raise ValueError("Invalid arguments")
    elif(times <= 0):
            return []
    else:
            array = []
            for x in range(times):
                    array.append(data)
            return array


def replicate_recur(times, data):
    if((not isinstance(times, int)) or (not isinstance(data, (int, float, long, complex, str)))):
            raise ValueError("Invalid arguments")
    elif(times <= 0):
            return []
    else:
            return ([data] + replicate_recur((times - 1), data))        

def replicate_recur(times, data):
    def f(n, value):
        if n < 1:
            return [] 
        result = f(n // 2, value) * 2
        if n % 2 > 0:
            result += [value] 
        return result

    if not isinstance(data, int) and not isinstance(data, str):
        raise ValueError('Must be int or str')
    return f(times, data)

def replicate_iter(times,data):
    Array = []
    if type(times) != int or not isinstance(data, (int, float, complex, str)):
        raise ValueError ('Invalid Value')
    elif times < 0:
        return []
    else:
        for x in range (times):
            Array.append(data)
        return Array


def replicate_recur(times,data):
    Array = []
    if type(times) != int or not isinstance(data, (int, float, complex, str)):
        raise ValueError ('Invalid Value')
    elif times <= 0:
        return []
    else:
       Array = replicate_recur(times-1,data)
       Array.append(data)
    return Array