Tout ce que vous devez savoir sur la récursivité en Python

Cet article vous aidera à obtenir une connaissance détaillée et complète de la récursivité en Python. Comment ça fonctionne? et quel est son but?

En termes simples, la récursivité est un moyen de résoudre le problème en faisant appeler une fonction elle-même, Le mot « récursif 'Provient du verbe latin' se reproduire », Ce qui signifie refaire quelque chose. C'est ce que fait la fonction récursive, elle refait encore et encore la même chose, c'est-à-dire qu'elle se rappelle. Dans cet article, nous allons en apprendre davantage sur la récursivité en python. Voici les sujets abordés dans ce blog:

Qu'est-ce que la récursivité en Python?

La récursivité est le processus de détermination de quelque chose en termes de lui-même. Nous savons qu'en Python, n'importe quelle fonction peut appeler n'importe quelle autre fonction, une fonction peut aussi s'appeler elle-même. Ces types de fonctions qui s'appellent jusqu'à ce que certaines conditions ne soient pas remplies sont appelées fonctions récursives.





Recursion-in-Python

obtenir la taille du tableau javascript

prenons quelques exemples pour voir comment cela fonctionne. Si on vous donne un entier positif n, la factorielle serait.



  • n! = n * (n-1) * (n-2) et ainsi de suite.
  • 2! = 2 * (2-1)
  • un! = 1
  • 0! = 0
  • 4! = 4 * 3!
  • 3! = 3 * 2!
  • 2! = 2 * 1!

Le remplacement des valeurs ci-dessus entraînera l'expression suivante

  • 4! = 4 * 3 * 2 * 1

Nous devons définir une fonction, disons fact (n) qui prend un entier positif ou 0 comme paramètre et retourne le nième factoriel, comment pouvons-nous faire cela en utilisant la récursivité?

Voyons voir, pour ce faire en utilisant la récursivité, nous devons examiner l'équation suivante



  • n! = n. (n-1). (n-2) & hellip3.2.1

  • n! = n. (n-1)! # nous pouvons réécrire l'instruction ci-dessus comme sur cette ligne

  • Maintenant, ici, si nous passons 2 comme paramètre, nous obtiendrons:

    • 2! = 2,1! = 2

  • De même, si nous passons 1, nous obtiendrons:

  • Mais si on passe 0, ça casse

    • 0! = 0. (- 1)! et ici factorielle pour -1 n'est pas définie donc cela ne fonctionne que pour les valeurs> 0

  • Il faut donc écrire deux cas

    • 1. n! = n. (n-1)! si n> = 1

    • 2. 1 si n = 0

C'est une solution complète pour tous les nombres entiers positifs et 0.

Condition de résiliation

Une fonction récursive doit remplir une condition importante pour se terminer. En se déplaçant vers une condition où le problème peut être résolu sans autre récursivité, une fonction récursive se terminera, minimisant le problème dans les sous-étapes plus petites. Une récursivité peut aboutir à une boucle infinie si la condition de terminaison n'est pas remplie dans les appels.

Conditions factorielles:

  • factorielle de n = n * (n-1) tant que n est supérieur à 1.
  • 1 si n = 0

Nous convertirons les conditions factorielles ci-dessus en code python:

def fact (n): si n == 1: retourne n else: retourne n * fait (n-1)

Prenons un exemple, disons que nous voulons trouver une factorielle de 4:

fact (4) #this renverra 4 * fact (3) et ainsi de suite jusqu'à n == 1.
 Production: 24

Il est souvent utilisé comme exemple de récursivité en raison de sa simplicité et de sa clarté. Résoudre des instances plus petites d'un problème à chaque étape, il a appelé comme récursivité en informatique.

Limite de récursivité de Python

Dans certains langages, vous pouvez créer une boucle récursive infinie mais, en Python, il existe une limite de récursivité. Pour vérifier la limite, exécutez la fonction suivante à partir du module sys. ce qui donnera la limite de l'ensemble de récursivité pour python.

import sys sys.getrecursionlimit ()
 Production: 1000

Vous pouvez également modifier la limite à l’aide de la fonction functionsetrecursionlimit () du module sys en fonction de vos besoins. Créons maintenant une fonction qui s’appelle de manière récursive jusqu’à ce qu’elle dépasse la limite et vérifie ce qui se passe:

def recursive (): recursive () if __name__ == '__main__': recursive ()

Si vous exécutez le code ci-dessus, vous obtiendrez une exception d'exécution: RuntimeError: profondeur de récursivité maximale dépassée. Python vous empêche de créer une fonction qui se termine dans une boucle récursive sans fin.

Aplatissement des listes avec récursivité

D'autres choses que vous pouvez faire en utilisant la récursivité sauf pour les factorielles, disons que vous voulez créer un single à partir d'une liste imbriquée, cela peut être fait en utilisant le code ci-dessous:

def flatten (a_list, flat_list = none): si flat_list n'est pas: flat_list = [] pour l'élément dans a_list: if isinstance (item, list): flatten (item, flat_list) else: flat_list.append (item) return flat_list si __name__ == '__main__': imbriqué = [1,2,3, [4,5], 6] x = aplatir (imbriqué) impression (x)
 Production: [1,2,3,4,5,6]

L'exécution du code ci-dessus entraînera une liste unique au lieu d'une liste d'entiers contenant une liste d'entiers que nous avons utilisée comme entrée. Vous pouvez également faire la même chose en utilisant d'autres méthodes, Python a quelque chose appelé itertools.chain (), vous pouvez vérifier le code utilisé pour créer une chaîne de fonctions () c'est une approche différente pour faire la même chose que nous.

surcharge et remplacement de méthode en java

Avantages de la récursivité

  • Le code est propre et élégant dans une fonction récursive.

  • Une tâche composite peut être décomposée en sous-problèmes plus simples en utilisant la récursivité.

  • La génération de séquence est plus facile avec la récursivité qu'avec une itération imbriquée.

Inconvénients de la récursivité

  • Suivre la logique de la fonction récursive peut parfois être difficile.

  • Les appels récursifs sont coûteux (inefficaces) car ils prennent beaucoup de mémoire et de temps.

  • Les fonctions récursives sont difficiles à déboguer.

Dans cet article, nous avons vu ce qu'est la récursion et comment pouvons-nous développer des fonctions récursives à partir de l'énoncé du problème, comment mathématiquement un énoncé du problème peut être défini. Nous avons résolu un problème de factorielle et découvert les conditions requises pour trouver des factorielles à partir desquelles nous avons pu convertir ces conditions en code python vous permettant de comprendre le fonctionnement de la récursivité. Je pense qu’il est intéressant que Python ait une limite intégrée de récursivité pour empêcher les développeurs de créer des fonctions récursives mal construites. Une chose importante à noter est que la récursivité est difficile à déboguer car la fonction continue de s'appeler.