Comprendre la surcharge de fonctions en Python

La surcharge de fonctions est une fonctionnalité de certains langages de programmation qui vous permet de définir des variantes de la même fonction. Chaque variante porte le même nom, mais des implémentations différentes, avec des signatures de fonction uniques.

Cette technique vous permet d'effectuer différentes opérations en fonction du type et du nombre d'arguments passés à une fonction.

Contrairement à des langages tels que C++ et Java, Python ne prend pas en charge la surcharge de fonctions par défaut, mais il existe des moyens d'obtenir des fonctionnalités similaires.

Comment Python gère-t-il la surcharge de fonctions?

En Python, vous pouvez définir la même fonction plusieurs fois avec des paramètres, des types de données ou les deux différents dans chaque définition. Cependant, Python ne reconnaîtra que la dernière définition de la fonction lorsque vous l'appelez. Voici un exemple :

defarithmetics(a, b):
return a - b
defarithmetics(a, b, c, d):
return a + b - c * d
print(arithmetics(1, 2, 3, 5)) # returns -12
print(arithmetics(1, 2)) # returns missing positional arguments error

Les langages orientés objet, comme Java, prennent souvent en charge la surcharge de fonctions et de méthodes. Une méthode est simplement une fonction que vous définissez dans une classe.

Dans le code ci-dessus, Python ne reconnaîtra que la deuxième définition du arithmétique() fonction lorsque vous essayez de l’appeler dans votre projet. Si vous essayez d'appeler la fonction avec deux arguments tels que définis en premier, vous obtiendrez une erreur indiquant "arguments de position requis manquants".

Vous n'obtiendrez pas d'erreur lorsque vous appellerez la fonction avec quatre arguments. Cela signifie que Python a écrasé la fonction avec sa dernière instance. Ce n’est pas le comportement d’une surcharge, vous devez donc y faire face.

Ainsi, Python ne gère pas la surcharge de fonctions par défaut, mais il existe quelques astuces que vous pouvez utiliser pour simuler son comportement dans vos programmes.

Méthode 1: utilisation de paramètres facultatifs ou d'arguments par défaut

Vous pouvez réaliser une surcharge en définissant une fonction avec des arguments par défaut. Voici un exemple :

defarithmetics(a, b=0, c=0):

 Arguments:
 a: The first number.
 b: The second number (optional).
 c: The third number (optional).

return a - b + c

Cette fonction possède trois paramètres, mais deux d'entre eux ont des valeurs par défaut. Cela signifie que vous pouvez l'appeler avec entre un et trois arguments :

print(arithmetics(1)) # returns 1
print(arithmetics(2, 5)) # returns -3
print(arithmetics(10, 3, 4)) # returns 11

Bien que cette approche permette d’appeler la fonction de plusieurs manières différentes, elle n’est pas très efficace à long terme. Voici quelques-unes de ses limites :

• Vous ne pouvez transmettre que des arguments qui sont des entiers ou des flottants.
• Il n’y a pas de changement significatif dans le comportement de la fonction. Par exemple, vous ne pouvez pas modifier son comportement pour calculer l'aire d'une forme ou même imprimer Bonjour le monde.

Méthode 2: utiliser des arguments variables

Pour utiliser des arguments variables pour la surcharge de fonctions en Python, vous devez incluez le paramètre args lors de la définition de votre fonction. Le arguments Le paramètre vous permet de transmettre plusieurs arguments de position lors de l’appel de votre fonction. Voici un exemple :

defarithmetics(a, *args):

 Arguments:
 a: The first number.
 *args: A variable number of arguments (optional).

 args_sum = 0
for num in args:
 args_sum *= num
return a - args_sum
print(arithmetics(1)) # returns 1
print(arithmetics(2, 5)) # returns 2
print(arithmetics(10, 3, 4, 2, 4, 6)) # returns 10

La fonction ci-dessus prend deux arguments: un argument obligatoire appelé un et le arguments argument, qui vous permet de saisir autant d’arguments que nécessaire.

Bien qu'elle puisse prendre plusieurs arguments, la fonction ci-dessus ne peut effectuer l'opération de multiplication que sur les arguments des variables, c'est-à-dire les arguments représentés par le arguments mot-clé.

Si vous souhaitez effectuer plusieurs opérations, vous devez introduire des instructions conditionnelles dans votre code, et cela peut vite devenir compliqué.

Méthode 3: Utilisation du décorateur de répartition multiple

Le décorateur de répartition multiple est une bibliothèque Python qui vous permet de définir plusieurs implémentations ou instances d'une seule fonction, en fonction du type de ses arguments. Cela signifie que vous pouvez définir la même fonction avec différents types de données et modifier entièrement son comportement.

Pour utiliser le décorateur de répartition multiple, procédez comme suit :

1. Installer chemins multiples dans votre environnement Python :

   pip install multipledispatch
   

2. Décorez votre (vos) fonction(s) avec le @expédition décorateur. Le @expédition le décorateur est un Décorateur Python cela vous permet de mettre en œuvre plusieurs répartitions. Il distribuera automatiquement la fonction appropriée en fonction des arguments que vous lui transmettez. Vous pouvez utiliser le @expédition décorateur en suivant ce modèle :

   from multipledispatch import dispatch
   @dispatch(data type1, data type2, data typeX)
   defyour_function(a, b, c, x):
   pass
   # perform your operations here
   

Voici un exemple qui utilise le décorateur de répartition multiple pour la surcharge de fonctions en Python :

from multipledispatch import dispatch
@dispatch(int, int)
defadd(a, b):

 Arguments:
 a: Any integer.
 b: Any integer.

return a + b
@dispatch(int, list)
defadd(a, b):

 Arguments:
 a: Any integer.
 b: Any Python list.

 b.append(a)
return b
# returns 3
print(add(1, 2))
# returns [2, 3, 4, 5, 'w', 'done', 1]
print(add(1, [2, 3, 4, 5, 'w', 'done']))

L'extrait de code ci-dessus définit deux instances de ajouter() fonction. La première instance prend deux entiers comme arguments et renvoie leur somme.

Pendant ce temps, la deuxième version de cette fonction prend en compte un entier et une liste. Il ajoute l'entier à la liste et renvoie la nouvelle liste.

Cette approche de la surcharge de fonctions en Python vous offre beaucoup de flexibilité, surtout si vous devez modifier le comportement de votre méthode. Vous pouvez en apprendre davantage auprès du documents d'expédition multiples.

La meilleure approche vers la surcharge de fonctions en Python

L’approche que vous adoptez face à la surcharge fonctionnelle doit dépendre de ce que vous essayez d’atteindre. Si vous pouvez terminer votre tâche en utilisant des arguments par défaut ou variables, alors le décorateur de répartition multiple pourrait être excessif. Cependant, le décorateur à expéditions multiples est généralement la meilleure option pour son efficacité et sa précision.

Ce décorateur fournit un moyen propre et flexible d’implémenter la surcharge de fonctions en Python. Il vous permet de définir plusieurs implémentations d'une même fonction en fonction du type de ses arguments.

Avec cette approche, vous pouvez créer des fonctions flexibles pouvant accepter différents types de paramètres sans avoir besoin d'instructions conditionnelles complexes.