Démystifier la récursivité python

Dans la programmation Python, de nombreuses tâches complexes peuvent être décomposées en sous-tâches plus simples. La récursivité est un moyen puissant de mettre en œuvre cette décomposition, ce qui rend le code plus concis et plus facile à entretenir. Ce tutoriel couvrira les concepts de la récursivité, les avantages et comment l'utiliser dans Python.

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

La récursivité est un moyen de résoudre un problème en résolvant une instance plus petite du problème. Cette approche peut être appliquée à de nombreux défis dans la programmation.

Avantages de l'utilisation de la récursivité

Certains des avantages de l'utilisation de la récursivité comprennent:

• Simplifiez l'écriture de code et facilitez le débogage.
• Réduisez le temps d'exécution de l'algorithme (en fonction de la longueur d'entrée).
• plus efficace lors de la résolution de problèmes très complexes (en particulier ceux basés sur les structures des arbres).

débutant des fonctions récursives python

La récursivité peut sembler compliquée, mais ce n'est pas le cas. Autrement dit, supposons que vous ayez deux rectangles A et B. Ajoutez-les ensemble pour former un rectangle C. Il s'agit d'un processus récursif en soi. Nous utilisons de petits instances de rectangles pour nous définir, si nous voulons écrire des fonctions python, cela ressemble à ceci:

def rectangle(a, b):
    return a + b

Étant donné que la fonction récursive s'appelle, une règle ou un point d'arrêt est nécessaire pour terminer le processus ou la boucle. Cette condition est appelée la condition de référence. Chaque programme récursif nécessite une condition de référence, sinon le processus entraînera une boucle infinie.

La deuxième exigence est le cas récursif, c'est-à-dire que la fonction s'appelle elle-même.

Prenons un exemple:

Dans cet exemple, vous rédigerez une fonction factorielle qui prend un entier (nombre positif) en entrée. Une factorielle pour un nombre est obtenue en multipliant le nombre par tous les entiers positifs en dessous. Par exemple, factorial(3) = 3 x 2 x 1, factorial(2) = 2 x 1, factorial(0) = 1.

Définissez d'abord le cas de référence, c'est-à-dire factoriel (0) = 1.

Comme indiqué ci-dessus, il existe une relation entre chaque scène factorielle successive. Vous devez remarquer factoriel (4) = 4 x factoriel (3). De même, factoriel (5) = 5 x factoriel (4).

La deuxième partie écrira une fonction qui s'appelle.

Après simplification, la fonction générée sera:

def factorial(n):
    # 定义基准情况
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

print(factorial(5))

# 结果
# 120

Si n==0, la solution est:

def factorial(n):
    # 定义基准情况
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)


print(factorial(0))

# 结果
# 1

Maintenant que vous savez comment écrire des fonctions récursives, regardons quelques études de cas qui renforceront votre compréhension de la récursivité.

Étude de cas 1: séquence de fibonacci

Dans la séquence Fibonacci, chaque nombre est la somme des deux premiers nombres, par exemple: 1 1 = 2; La séquence de Fibonacci a été appliquée dans de nombreux domaines, le plus souvent pour les traders Forex prédisant les tendances des prix boursiers.

Les séquences de Fibonacci commencent par 0 et 1. Le premier nombre dans la séquence Fibonacci est 0, le deuxième nombre est 1 et le troisième terme dans la séquence est 0 1 = 1. Le quatrième terme est 1 1 = 2, et ainsi de suite.

Afin d'obtenir une fonction récursive, vous devez avoir deux cas de référence, à savoir 0 et 1. Vous pouvez ensuite convertir le mode d'addition en cas ELSE.

La fonction générée sera:

def rectangle(a, b):
    return a + b

Étude de cas 2: inverser la chaîne

Dans cet exemple, vous rédigerez une fonction qui prend une chaîne en entrée, puis renvoie une inversion de cette chaîne.

Définissez d'abord le cas de référence, qui vérifiera si la chaîne est égale à 0, et dans l'affirmative, la chaîne elle-même est renvoyée.

La deuxième étape consiste à appeler récursivement la fonction d'inversion pour trancher la partie de la chaîne sauf le premier caractère, puis concaténer le premier caractère à la fin de la chaîne de tranche.

La fonction générée est la suivante:

def factorial(n):
    # 定义基准情况
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

print(factorial(5))

# 结果
# 120

Étude de cas 3: somme des éléments

Dans cet exemple, vous rédigerez une fonction qui prend un tableau en entrée, puis renvoie la somme des éléments dans la liste.

Définissez d'abord le cas de référence, qui vérifiera si la taille de la liste est nulle et si elle est vraie, renvoyez 0.

La deuxième étape renvoie l'élément et l'appel à la fonction SUM (), en soustrayant un élément de la liste.

La solution est la suivante:

def factorial(n):
    # 定义基准情况
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)


print(factorial(0))

# 结果
# 1

La solution à la liste vide est la suivante:

def fibonacci(n):
    # 定义基准情况 1
    if n == 0:
        return 0
    # 定义基准情况 2
    elif n == 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(5))

# 结果为 5

Conclusion

Ce tutoriel décrit ce dont vous avez besoin pour résoudre des programmes complexes dans Python en utilisant Recursion. Il convient également de noter que la récursivité a également ses propres limites:

• occupent récursivement beaucoup d'espace de pile, ce qui rend lent à maintenir le programme.
• Les fonctions récursives nécessitent plus d'espace et de temps pour s'exécuter.
• Les fonctions récursives peuvent devenir compliquées et difficiles à déboguer.

Cette image miniature est générée à l'aide d'Open Ai Dall-e.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!