Fonctions Python

Une fonction est un bloc de code qui ne s’exécute que lorsqu’elle est appelée.

Vous pouvez transmettre des données, appelées paramètres, dans une fonction.

En conséquence, une fonction peut renvoyer des données.

Création d’une fonction

En Python, une fonction est définie à l’aide du mot-clé def :

Exemple

def my_function():
  print("Bonjour je suis une fonction") 

Appeler une fonction

Pour appeler une fonction, utilisez le nom de la fonction suivi de parenthèses :

Exemple

def my_function():
  print("Bonjour je suis une fonction")

my_function()

Arguments

Les informations peuvent être transmises aux fonctions sous forme d’arguments.

Les arguments sont spécifiés après le nom de la fonction, entre parenthèses. Vous pouvez ajouter autant d’arguments que vous le souhaitez, il suffit de les séparer par une virgule.

L’exemple suivant a une fonction avec un argument (fname). Lorsque la fonction est appelée, nous transmettons un prénom, qui est utilisé à l’intérieur de la fonction pour imprimer le nom complet :

Exemple

def my_function(fname):
  print(fname + " Refsnes")

my_function("Emil")
my_function("Tobias")
my_function("Linus") 

>>>>> Emil Refsnes
>>>>> Tobias Refsnes
>>>>> Linus Refsnes

Paramètres ou arguments ?

Les termes paramètre et argument peuvent être utilisés pour la même chose : des informations transmises à une fonction.

Du point de vue d’une fonction :

Un paramètre est la variable répertoriée entre parenthèses dans la définition de la fonction.

Un argument est la valeur envoyée à la fonction lors de son appel.

Nombre d’arguments

Par défaut, une fonction doit être appelée avec le bon nombre d’arguments. Cela signifie que si votre fonction attend 2 arguments, vous devez appeler la fonction avec 2 arguments, ni plus ni moins.

Exemple

Cette fonction attend 2 arguments et obtient 2 arguments :

def my_function(fname, lname):
  print(fname + " " + lname)

my_function("Emil", "Refsnes") 

>>>>> Emil Refsnes

Si vous essayez d’appeler la fonction avec 1 ou 3 arguments, vous obtiendrez une erreur :

Exemple

Cette fonction attend 2 arguments, mais n’en obtient que 1 :

def my_function(fname, lname):
  print(fname + " " + lname)

my_function("Emil") 

Traceback (most recent call last):
  File "demo_function_args_error.py", line 4, in <module>
    my_function("Emil")
TypeError: my_function() missing 1 required positional argument: 'lname'

Arguments arbitraires, *args

Si vous ne savez pas combien d’arguments seront transmis à votre fonction, ajoutez un * avant le nom du paramètre dans la définition de la fonction.

De cette façon, la fonction recevra un tuple d’arguments et pourra accéder aux éléments en conséquence :

Exemple

Si le nombre d’arguments est inconnu, ajoutez un * avant le nom du paramètre :

def my_function(*kids):
  print("Le plus jeune enfant est " + kids[2])

my_function("Emil", "Tobias", "Linus") 

>>>>>>> Le plus jeune enfant est Linus

Les arguments arbitraires sont souvent abrégés en *args dans les documentations Python.

Arguments de mots clés

Vous pouvez également envoyer des arguments avec la syntaxe clé = valeur.

De cette façon, l’ordre des arguments n’a pas d’importance.

Exemple

def my_function(child3, child2, child1):
  print("Le plus jeune enfant est" + child3)

my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus") 

>>>>>>> Le plus jeune enfant est Linus

L’expression Arguments de mots-clés est souvent abrégée en kwargs dans les documentations Python.

Arguments de mots clés arbitraires, **kwargs

Si vous ne savez pas combien d’arguments de mot-clé seront transmis à votre fonction, ajoutez deux astérisques : ** avant le nom du paramètre dans la définition de la fonction.

De cette façon, la fonction recevra un dictionnaire d’arguments et pourra accéder aux éléments en conséquence :

Exemple

Si le nombre d’arguments du mot-clé est inconnu, ajoutez un double ** avant le nom du paramètre :

def my_function(**kid):
  print("Son nom de famille est" + kid["lname"])

my_function(fname = "Tobias", lname = "Refsnes") 

>>>>>>> Son nom de famille est Refsnes

Valeur du paramètre par défaut

L’exemple suivant montre comment utiliser une valeur de paramètre par défaut.

Si nous appelons la fonction sans argument, elle utilise la valeur par défaut :

Exemple

def my_function(country = "Norway"):
  print("je viens de " + country)

my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil") 

>>>>>>> je viens de Suède
>>>>>>> Je viens de l'Inde
>>>>>>> Je viens de Norvège
>>>>>>> Je viens du Brésil

Passer une liste comme argument

Vous pouvez envoyer n’importe quel type de données d’argument à une fonction (chaîne, nombre, liste, dictionnaire, etc.), et il sera traité comme le même type de données à l’intérieur de la fonction.

Par ex. si vous envoyez une List en argument, ce sera toujours une List lorsqu’elle atteindra la fonction :

Exemple

def my_function(food):
  for x in food:
    print(x)

fruits = ["apple", "banana", "cherry"]

my_function(fruits)

>>>>>>> apple
>>>>>>> banana
>>>>>>> cherry

Valeurs de retour

Pour laisser une fonction renvoyer une valeur, utilisez l’instruction return :

def my_function(x):
  return 5 * x

print(my_function(3))
print(my_function(5))
print(my_function(9)) 

>>>>>>> 15
>>>>>>> 25
>>>>>>> 45

La déclaration pass

les définitions de fonction ne peuvent pas être vides, mais si, pour une raison quelconque, vous avez une définition de fonction sans contenu, insérez l’instruction pass pour éviter d’obtenir une erreur.

Exemple

def myfunction():
  pass 

>>>>>>>

Arguments de position uniquement

Vous pouvez spécifier qu’une fonction peut avoir UNIQUEMENT des arguments de position ou UNIQUEMENT des arguments de mot-clé.

Pour spécifier qu’une fonction ne peut avoir que des arguments de position, ajoutez , / après les arguments :

Exemple

def my_function(x, /):
  print(x)

my_function(3) 

>>>>>>> 3

Sans le , / vous êtes en fait autorisé à utiliser des arguments de mot-clé même si la fonction attend des arguments de position :

Exemple

def my_function(x):
  print(x)

my_function(x = 3) 

>>>>>>> 3

Mais lors de l’ajout du , /, vous obtiendrez une erreur si vous essayez d’envoyer un argument mot-clé :

Exemple

def my_function(x, /):
  print(x)

my_function(x = 3)

Traceback (most recent call last):
  File "./prog.py", line 4, in <module>
TypeError: my_function() got some positional-only argument

Arguments de mots clés uniquement

Pour spécifier qu’une fonction ne peut avoir que des arguments mot-clé, ajoutez *, avant les arguments :

Exemple

def my_function(*, x):
  print(x)

my_function(x = 3) 

>>>>>> 3

Sans le *, vous êtes autorisé à utiliser des arguments positionnels même si la fonction attend des arguments de mots-clés :

Exemple

def my_function(x):
  print(x)

>>>>>> 3

Mais avec le *, vous obtiendrez une erreur si vous essayez d’envoyer un argument positionnel :

Exemple

def my_function(*, x):
  print(x)

my_function(3)

Traceback (most recent call last):
  File "./prog.py", line 4, in <module>
TypeError: my_function() takes 0 positional arguments but 1 was given 

Combinez le positionnement uniquement et le mot clé uniquement

Vous pouvez combiner les deux types d’arguments dans la même fonction.

Tout argument avant le / est uniquement de position, et tout argument après le * est uniquement un mot-clé.

Exemple

def my_function(a, b, /, *, c, d):
  print(a + b + c + d)

my_function(5, 6, c = 7, d = 8)

>>>>>> 26

Récursivité

Python accepte également la récursivité des fonctions, ce qui signifie qu’une fonction définie peut s’appeler elle-même.

La récursivité est un concept mathématique et de programmation courant. Cela signifie qu’une fonction s’appelle elle-même. Cela a l’avantage de signifier que vous pouvez parcourir les données pour atteindre un résultat.

Le développeur doit être très prudent avec la récursion car il peut être assez facile d’écrire une fonction qui ne se termine jamais, ou qui utilise des quantités excessives de mémoire ou de puissance du processeur. Cependant, lorsqu’elle est écrite correctement, la récursion peut constituer une approche de programmation très efficace et mathématiquement élégante.

Dans cet exemple, tri_recursion() est une fonction que nous avons définie pour s’appeler (« recurse »). Nous utilisons la variable k comme données, qui décrémente (-1) à chaque fois que nous récurons. La récursion se termine lorsque la condition n’est pas supérieure à 0 (c’est-à-dire lorsqu’elle est 0).

Pour un nouveau développeur, comprendre exactement comment cela fonctionne peut prendre un certain temps. La meilleure façon de le savoir est de le tester et de le modifier.

Exemple

Exemple de récursion

def tri_recursion(k):
  if(k > 0):
    result = k + tri_recursion(k - 1)
    print(result)
  else:
    result = 0
  return result

print("Résultats d'exemple de récursion:")
tri_recursion(6)

>>>>>> Résultats d'exemple de récursion:
>>>>>> 1
>>>>>> 3
>>>>>> 6
>>>>>> 10
>>>>>> 15
>>>>>> 21