0
votes

Pourquoi est-ce que j'obtiens une RecursionError en utilisant des boucles while ou if indefinite

Je veux créer une boucle while qui s'exécute indéfiniment jusqu'à ce qu'une condition soit vraie. Le problème est que lorsque la condition n'est pas vraie, la boucle ne s'exécute que pendant environ deux minutes, puis les pauses renvoient l'erreur suivante: RecursionError: profondeur maximale de récursivité dépassée en comparaison

Voici le code complet:

def request():
    s = requests.Session
    r = s.get(url)
    return r
def data(r):
    soup = BeautifulSoup(r.text, 'lxml')
    list = soup.select('.class')
    return list
def loop(list):
    n = 10
    while True:
        len(list) != n
        if len(list) == n:
            print('Lorem ipsum')
            main()
        else:
            return len(list)
def main():
    r = request()
    list = data(r)
    len(list) = loop(list)

if __name__ == "__main__":
    main()

python if-statement while-loop

4 commentaires

Vous pouvez utiliser le module sys pour changer le max. récursivité: import sys; sys.setrecursionlimit (num)

@Ruan Probablement mieux qu'ils identifient et corrigent l'erreur dans leur code à l'origine du problème.

On dirait que vous avez main et loop qui s’appellent jusqu’à ce que la pile déborde. Mais vous n'avez pas publié main , il est donc difficile de savoir pourquoi vous avez fait cela. Si vous publiez un exemple minimal reproductible , quelqu'un peut suggérer une alternative.

@khelwood Vous avez raison. main () appelle essentiellement d'autres fonctions. Je vais modifier la question.

3 Réponses :

2
votes

Eh bien, vous appelez la fonction main () qui exécute ensuite le script dans main () qui est probablement le code que vous avez posté ci-dessus. Par conséquent, vous avez créé une fonction récursive qui ne renvoie jamais rien. Donc, pour éviter de durer éternellement, python a une limite de profondeur de récursivité qui génère une erreur.

Je ne suis pas sûr de ce que vous essayez d'accomplir ici, mais je pense qu'appeler main () comme ça est une mauvaise idée. Si vous essayez seulement de parcourir votre boucle while sans la quitter, vous n'avez pas besoin d'appeler à nouveau main car pythoon continuera à la parcourir jusqu'à ce que la condition ne soit plus remplie. Veuillez consulter la documentation sur le fonctionnement d'une boucle while .

Veuillez consulter Récursivité .

6 commentaires

Pourquoi est-ce une mauvaise idée? main () appelle toutes les autres fonctions que je n'ai pas montrées, ce qui signifie que si la condition n'est pas vraie, je veux réessayer et appeler main () qui appelle d'autres fonctions et bientôt. Et je ne veux pas utiliser sys.setrecursionlimit (num) .

Eh bien, votre code ne rompt évidemment jamais la boucle, ce qui est impossible d'après ce que vous avez montré. Je veux dire dans le code que vous avez montré que vous ne modifiez jamais la liste donc votre condition est toujours vraie et vous recevez l'erreur. Je ne dis pas que c'est généralement une mauvaise idée d'appeler main () , mais quelle que soit la fonction que vous souhaitez appeler dans main () , vous pouvez aussi simplement appeler dans la boucle et appelez à nouveau votre fonction loop de manière récursive sans avoir besoin d'appeler main () .

Je n'ai pas posté main () , qui appelle d'autres fonctions. Une fonction effectue une requête http et une autre analyse la page de réponse et récupère des données. La liste contient ces données. En gros, je veux détecter s'il y a un changement dans cette liste sinon réessayer, c'est pourquoi je continue d'appeler main () .

D'accord, mais pourquoi n'appelez-vous pas directement les fonctions au lieu d'appeler main () ? De plus, chaque fois que vous appelez la fonction loop () , vous redéfinissez list comme list = ['Lorem ipsum'] . Par conséquent, votre condition n'est jamais remplie et main () est appelée à l'infini.

Bon, dans ce cas, votre problème est simplement que les données sur lesquelles vous définissez votre liste ne répondent tout simplement pas à votre condition. Vous devriez donc penser à un moyen de gérer cette possibilité. Sinon, votre code a l'air bien. Outre la ligne len (list)! = N car vous ne faites rien avec,

continuons cette discussion dans le chat .

0
votes

RecursionError est déclenché lorsqu'il y a un cycle. RecursionError est renvoyé lorsqu'il y a trop d'appels de fonction sur la pile., Vous bouclez une quantité infinie de votre fonction main ()

1 commentaires

Lorsque la condition est vraie, les boucles se cassent, le code ne s'exécute pas éternellement.

1
votes

Explication des erreurs de récursivité

La fonction n'est terminée qu'avec un return explicite ou lorsqu'elle arrive à la fin du code de la fonction (implicite return None ).

Lorsque vous appelez main , vous ne terminez pas la boucle - il est placé sur la pile d'appels. Il revient à cette boucle (exactement après la ligne main () ) lorsque main () retourne (se termine).

Cependant, dans votre cas, main est probablement construit de manière à ne pas revenir et appeler à nouveau loop . Ainsi, mettre également main sur la pile d'appels.

Puis loop appelle à nouveau main , puis main appelle loop ... aucun d'entre eux ne revient, donc la pile d'appels grandit et grandit jusqu'à ce qu'il n'y ait plus de mémoire ... ou jusqu'à ce qu'elle atteigne la taille maximale de la pile de sauvegarde (profondeur de récursivité) comme la vôtre.

Boucle infinie sans explication d'erreur (lorsque vous essayez de corriger ce qui précède)

boucle n'entre jamais dans else car la liste est définie ici, donc toujours de la même taille. Cela signifie que le while dans la boucle ne s'arrête jamais . - La liste est une variable locale, aucun appel à d'autres fonctions ne la modifiera car vous ne passez pas l'objet.

0 commentaires