相关疑难解决方法(0)

我有一个简单的代码,如:

    p = soup.find_all("p")
    paragraphs = []

    for x in p:
        paragraphs.append(str(x))

我试图转换我从xml获得的列表并将其转换为字符串.我想保留它的原始标签,以便我可以重用一些文本,因此我之所以如此追加它.但是该列表包含超过6000个观测值,因此由于str而发生递归错误:

"RuntimeError:调用Python对象时超出了最大递归深度"

我读到你可以改变最大递归但这样做并不明智.我的下一个想法是将转换分为500个批次,但我相信必须有更好的方法来做到这一点.有人有建议吗？

我编写了以下递归函数,但由于最大递归深度而导致运行时错误.我想知道是否有可能编写一个迭代函数来克服这个问题:

def finaldistance(n):

   if n%2 == 0:
       return 1 + finaldistance(n//2) 

   elif n != 1:
       a = finaldistance(n-1)+1
       b = distance(n)
       return min(a,b)

   else:
       return 0

我试过的是这个,但似乎没有用,

def finaldistance(n, acc):

   while n > 1:

     if n%2 == 0:
        (n, acc) = (n//2, acc+1)

     else:
        a = finaldistance(n-1, acc) + 1
        b = distance(n)
        if a < b:
          (n, acc) = (n-1, acc+1)

        else:
          (n, acc) =(1, acc + distance(n))

   return acc

我正在尝试编写一个函数来查找产生指定金额的所有可能的硬币组合,例如它计算所有可能的方式来从1p,2p,5p,10p的面额列表中更改2英镑的金额, 20P,50P,1pound,2pound.我坚持这个,找不到合适的解决方案.

我希望main函数是递归的,因为我想更好地理解递归.该算法必须回溯,如果在某个时刻发现的组合超过了要匹配的量,则程序应该返回到先前的步骤并从不同的点开始.

到目前为止,我已经编写了一个普通(非递归)函数,如果每个硬币仅使用一次,则计算给定国家中所有可能的硬币组合(这相当简单).我并没有试图找到一个给定数额的正确组合,只是所有可能的硬币组合.

def calcCoins(coins):
    """ 
    returns all possible combinations of coins, when called with 
    [1,2,5,10,20,50,100,200] returns a list of 126 Counters containing 
    for instance Counter{1:1}, Counter{1:1,2:1,5:1}, Counter {50:1,100:1} etc
    """
    i,combs = 1, []
    while i < len(coins):
        for x in combinations(coins,i):
            combs.append(Counter(x))
        i += 1
    return combs

现在我有一个笨拙的递归函数,它接受一个组合和所需的数量作为参数,并返回所有可能的方式,其中可以给出等于此数量的更改.

def findSum(comb,goal,rightOnes):
    if rightOnes == None:
        rightOnes = []
    if sum(comb.elements()) == goal:
        comb_ = Counter(comb)
        if comb_ in rightOnes:
             # probably a cycle, return combinations gathered and exit …

今天类中递归和堆栈溢出的有趣话题,我想知道是否有任何方法可以增加Python中的最大递归深度？写了一个快速函数,用于使用递归查找n的阶乘:

def factorial(n):
    if n == 1:
        return n
    else:
        return n * factorial(n-1)

它可以应对阶乘(994)而不是阶乘(995).给出的错误是:

RuntimeError: maximum recursion depth exceeded in comparison

显然,可以迭代地找到更高的阶乘,但是,为了论证和阴谋,最大递归深度可以增加吗？

我创建了一个迭代函数,输出4 3 2 1 0 1 2 3 4.

def bounce2(n):
    s = n
    for i in range(n):
        print(n)
        n = n-1

    if n <= 0:
        for i in range(s+1):
            print(-n)
            n = n-1
    return
bounce2(4)

如果我想要一个完全相同的递归函数,我该怎么想？

描述

我见过关于自引用 Pydantic 模型导致的类似问题，RecursionError: maximum recursion depth exceeded in comparison但据我所知，代码中不包含自引用模型。我只是使用 Pydantic 的BaseModel类。

代码成功运行，直到audit.py下面的函数尝试从模型返回输出。

我已经包含了完整的回溯，因为我不确定从哪里开始处理这个错误。我在没有 IDE 的情况下使用 PyCharm 运行了代码，它总是生成下面的回溯，但不会使应用程序崩溃，而是向前端返回 500 的 http 状态代码。

任何建议将不胜感激。

正如所建议的，我还尝试sys.setrecursionlimit(1500)增加递归限制。

环境

\n
• 操作系统：Windows 10
\n
• FastAPI版本：0.61.1
\n
• 派丹蒂克版本：1.6.1
\n
• Uvicorn版本：0.11.8
\n
• Python版本：3.7.1
\n
• Pycharm版本：2020.2
\n

应用程序

main.py

import uvicorn\nfrom fastapi import FastAPI\nfrom starlette.middleware.cors import CORSMiddleware\n\n\nfrom app.api.routes.router import api_router\nfrom app.core.logging import init_logging\nfrom app.core.config import settings\n\ninit_logging()\n\n\ndef get_app() -> FastAPI:\n    application …

我有这个递归阶乘函数：

def factorial(n):
    if n < 2:
        return 1
    return n * factorial(n-1)

正在做factorial(998)工作，但factorial(999)会提高RecursionError: maximum recursion depth exceeded in comparison.

为什么它在factorial(999)和 上出错而不是1000or 1001？factorial(1)达到基本情况，因此调用函数时应该只有一个堆栈帧factorial，factorial(2)递归一次，因此应该使用 2 个堆栈帧，依此类推。

递归限制是排他的还是包含的？例如，当达到1000 个堆栈帧或超过setrecursionlimit(1000)1000 个堆栈帧时，是否会出错？